@prometheus-ags/prometheus-entity-management 1.2.2 → 2.0.0

package/dist/index.mjs

@@ -1,1738 +1,2470 @@
+import React6, { createContext, useMemo, useRef, useState, useCallback, useEffect, useSyncExternalStore, useContext, useId } from 'react';
 import { create, createStore, useStore } from 'zustand';
 import { subscribeWithSelector, persist } from 'zustand/middleware';
 import { immer } from 'zustand/middleware/immer';
-import React6, { createContext, useMemo, useSyncExternalStore, useRef, useCallback, useEffect, useState, useContext, useId } from 'react';
-import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { useShallow } from 'zustand/react/shallow';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
 import { useReactTable, getSortedRowModel, getCoreRowModel, flexRender } from '@tanstack/react-table';
 import { Search, X, Loader2, RefreshCw, ChevronLeft, ChevronRight, Pencil, Trash2 } from 'lucide-react';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 
-// src/graph.ts
-var EMPTY_IDS = [];
-var EMPTY_ENTITY_STATE = {
-  isFetching: false,
-  lastFetched: null,
-  error: null,
-  stale: false
-};
-var EMPTY_SYNC_METADATA = {
-  synced: true,
-  origin: "server",
-  updatedAt: null
+// src/errors.ts
+var TerminalError = class _TerminalError extends Error {
+  kind = "terminal";
+  status;
+  constructor(message, opts = {}) {
+    super(message, { cause: opts.cause });
+    this.name = "TerminalError";
+    this.status = opts.status;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, _TerminalError);
+    }
+  }
 };
-var EMPTY_LIST_STATE = {
-  ids: EMPTY_IDS,
-  total: null,
-  nextCursor: null,
-  prevCursor: null,
-  hasNextPage: false,
-  hasPrevPage: false,
-  isFetching: false,
-  isFetchingMore: false,
-  error: null,
-  lastFetched: null,
-  stale: false,
-  currentPage: null,
-  pageSize: null
+var TransientError = class _TransientError extends Error {
+  kind = "transient";
+  status;
+  constructor(message, opts = {}) {
+    super(message, { cause: opts.cause });
+    this.name = "TransientError";
+    this.status = opts.status;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, _TransientError);
+    }
+  }
 };
-function defaultEntityState() {
-  return { ...EMPTY_ENTITY_STATE };
+function toEntityError(err) {
+  if (err instanceof TerminalError) return err;
+  if (err instanceof TransientError) return err;
+  if (err && typeof err === "object" && "name" in err && err.name === "AbortError") {
+    return new TerminalError("Aborted", { cause: err });
+  }
+  if (err && typeof err === "object" && "status" in err) {
+    const status = Number(err.status);
+    const message2 = err && typeof err === "object" && "message" in err ? String(err.message ?? `HTTP ${status}`) : `HTTP ${status}`;
+    if (Number.isFinite(status) && status >= 400 && status < 500) {
+      return new TerminalError(message2, { status, cause: err });
+    }
+    if (Number.isFinite(status) && status >= 500) {
+      return new TransientError(message2, { status, cause: err });
+    }
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return new TransientError(message, { cause: err });
 }
-function defaultSyncMetadata() {
-  return { ...EMPTY_SYNC_METADATA };
+
+// src/transport/registry.ts
+var transports = /* @__PURE__ */ new Map();
+function registerEntityTransport(type, transport) {
+  transports.set(type, transport);
+}
+function getEntityTransport(type) {
+  const t = transports.get(type);
+  if (!t) {
+    throw new Error(
+      `[entity-management] No transport registered for entity type "${type}". Call registerEntityTransport("${type}", ...) at app boot.`
+    );
+  }
+  return t;
 }
-function defaultListState() {
-  return { ...EMPTY_LIST_STATE, ids: [] };
+function __resetEntityTransports() {
+  transports.clear();
 }
-function ek(type, id) {
-  return `${type}:${id}`;
+function getRegisteredEntityTypes() {
+  return Array.from(transports.keys());
 }
-var useGraphStore = create()(
-  subscribeWithSelector(
-    immer((set, get) => ({
-      entities: {},
-      patches: {},
-      entityStates: {},
-      syncMetadata: {},
-      lists: {},
-      upsertEntity: (type, id, data) => set((s) => {
-        if (!s.entities[type]) s.entities[type] = {};
-        s.entities[type][id] = { ...s.entities[type][id] ?? {}, ...data };
-        const key = ek(type, id);
-        if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-      }),
-      upsertEntities: (type, entries) => set((s) => {
-        if (!s.entities[type]) s.entities[type] = {};
-        for (const { id, data } of entries) {
-          s.entities[type][id] = { ...s.entities[type][id] ?? {}, ...data };
-          const key = ek(type, id);
-          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-        }
-      }),
-      replaceEntity: (type, id, data) => set((s) => {
-        if (!s.entities[type]) s.entities[type] = {};
-        s.entities[type][id] = data;
-        const key = ek(type, id);
-        if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
-      }),
-      removeEntity: (type, id) => set((s) => {
-        delete s.entities[type]?.[id];
-        delete s.patches[type]?.[id];
-        delete s.entityStates[ek(type, id)];
-        delete s.syncMetadata[ek(type, id)];
-      }),
-      patchEntity: (type, id, patch) => set((s) => {
-        if (!s.patches[type]) s.patches[type] = {};
-        s.patches[type][id] = { ...s.patches[type][id] ?? {}, ...patch };
-      }),
-      unpatchEntity: (type, id, keys) => set((s) => {
-        const p = s.patches[type]?.[id];
-        if (!p) return;
-        for (const k of keys) delete p[k];
-      }),
-      clearPatch: (type, id) => set((s) => {
-        delete s.patches[type]?.[id];
-      }),
-      setEntityFetching: (type, id, fetching) => set((s) => {
-        const k = ek(type, id);
-        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-        s.entityStates[k].isFetching = fetching;
-      }),
-      setEntityError: (type, id, error) => set((s) => {
-        const k = ek(type, id);
-        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-        s.entityStates[k].error = error;
-        s.entityStates[k].isFetching = false;
-      }),
-      setEntityFetched: (type, id) => set((s) => {
-        const k = ek(type, id);
-        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-        s.entityStates[k].lastFetched = Date.now();
-        s.entityStates[k].isFetching = false;
-        s.entityStates[k].error = null;
-        s.entityStates[k].stale = false;
-        s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), synced: true, origin: "server", updatedAt: Date.now() };
-      }),
-      setEntityStale: (type, id, stale) => set((s) => {
-        const k = ek(type, id);
-        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
-        s.entityStates[k].stale = stale;
-      }),
-      setEntitySyncMetadata: (type, id, metadata) => set((s) => {
-        const k = ek(type, id);
-        s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), ...metadata };
-      }),
-      clearEntitySyncMetadata: (type, id) => set((s) => {
-        delete s.syncMetadata[ek(type, id)];
-      }),
-      setListResult: (key, ids, meta) => set((s) => {
-        const ex = s.lists[key] ?? defaultListState();
-        s.lists[key] = { ...ex, ...meta, ids, isFetching: false, isFetchingMore: false, error: null, stale: false, lastFetched: Date.now() };
-      }),
-      appendListResult: (key, ids, meta) => set((s) => {
-        const ex = s.lists[key] ?? defaultListState();
-        s.lists[key] = { ...ex, ...meta, ids: Array.from(/* @__PURE__ */ new Set([...ex.ids, ...ids])), isFetching: false, isFetchingMore: false, error: null, stale: false, lastFetched: Date.now() };
-      }),
-      prependListResult: (key, ids, meta) => set((s) => {
-        const ex = s.lists[key] ?? defaultListState();
-        s.lists[key] = { ...ex, ...meta ?? {}, ids: Array.from(/* @__PURE__ */ new Set([...ids, ...ex.ids])), isFetching: false, isFetchingMore: false, error: null, stale: false, lastFetched: Date.now() };
-      }),
-      removeIdFromAllLists: (_type, id) => set((s) => {
-        for (const key of Object.keys(s.lists)) {
-          const list = s.lists[key];
-          const idx = list.ids.indexOf(id);
-          if (idx !== -1) {
-            list.ids.splice(idx, 1);
-            if (list.total !== null) list.total -= 1;
-          }
-        }
-      }),
-      insertIdInList: (key, id, position) => set((s) => {
-        if (!s.lists[key]) s.lists[key] = defaultListState();
-        const ids = s.lists[key].ids;
-        const ex = ids.indexOf(id);
-        if (ex !== -1) ids.splice(ex, 1);
-        if (position === "start") ids.unshift(id);
-        else if (position === "end") ids.push(id);
-        else ids.splice(position, 0, id);
-      }),
-      setListFetching: (key, fetching) => set((s) => {
-        if (!s.lists[key]) s.lists[key] = defaultListState();
-        s.lists[key].isFetching = fetching;
-      }),
-      setListFetchingMore: (key, fetchingMore) => set((s) => {
-        if (!s.lists[key]) s.lists[key] = defaultListState();
-        s.lists[key].isFetchingMore = fetchingMore;
-      }),
-      setListError: (key, error) => set((s) => {
-        if (!s.lists[key]) s.lists[key] = defaultListState();
-        s.lists[key].error = error;
-        s.lists[key].isFetching = false;
-        s.lists[key].isFetchingMore = false;
-      }),
-      setListStale: (key, stale) => set((s) => {
-        if (!s.lists[key]) s.lists[key] = defaultListState();
-        s.lists[key].stale = stale;
-      }),
-      invalidateEntity: (type, id) => set((s) => {
-        if (id) {
-          const k = ek(type, id);
-          if (s.entityStates[k]) s.entityStates[k].stale = true;
-        } else {
-          for (const k of Object.keys(s.entityStates)) if (k.startsWith(`${type}:`)) s.entityStates[k].stale = true;
-        }
-      }),
-      invalidateLists: (matcher) => set((s) => {
-        const pred = typeof matcher === "string" ? (k) => k.startsWith(matcher) : matcher;
-        for (const key of Object.keys(s.lists)) if (pred(key)) s.lists[key].stale = true;
-      }),
-      invalidateType: (type) => {
-        get().invalidateEntity(type);
-        get().invalidateLists(type);
-      },
-      readEntity: (type, id) => {
-        const s = get();
-        const base = s.entities[type]?.[id];
-        if (!base) return null;
-        const patch = s.patches[type]?.[id];
-        return patch ? { ...base, ...patch } : base;
-      },
-      readEntitySnapshot: (type, id) => {
-        const s = get();
-        const base = s.entities[type]?.[id];
-        if (!base) return null;
-        const patch = s.patches[type]?.[id];
-        const metadata = s.syncMetadata[ek(type, id)] ?? EMPTY_SYNC_METADATA;
-        return {
-          ...patch ? { ...base, ...patch } : base,
-          $synced: metadata.synced,
-          $origin: metadata.origin,
-          $updatedAt: metadata.updatedAt
-        };
-      }
-    }))
-  )
-);
 
-// src/graph-query.ts
-function queryOnce(opts) {
-  const store = useGraphStore.getState();
-  const ids = resolveCandidateIds(store, opts);
-  let rows = ids.map((id) => store.readEntitySnapshot(opts.type, id)).filter((row) => row !== null);
-  if (opts.where) rows = rows.filter(opts.where);
-  if (opts.sort) rows = [...rows].sort(opts.sort);
-  const projected = rows.map((row) => applySelection(projectRow(row, opts.include, store), opts.select));
-  if (opts.id) return projected[0] ?? null;
-  return projected;
-}
-var selectGraph = queryOnce;
-function resolveCandidateIds(store, opts) {
-  if (opts.id) return [opts.id];
-  if (opts.ids) return opts.ids;
-  if (opts.listKey) return store.lists[opts.listKey]?.ids ?? [];
-  return Object.keys(store.entities[opts.type] ?? {});
-}
-function projectRow(row, include, store) {
-  if (!include) return row;
-  const projected = { ...row };
-  for (const [key, relation] of Object.entries(include)) {
-    const related = resolveRelation(row, relation, store);
-    projected[key] = related;
-  }
-  return projected;
+// src/view/prisma-compile.ts
+function nestWhereField(parts, leaf) {
+  if (parts.length === 0) return {};
+  if (parts.length === 1) return { [parts[0]]: leaf };
+  return { [parts[0]]: nestWhereField(parts.slice(1), leaf) };
 }
-function resolveRelation(entity, relation, store) {
-  const include = relation.include;
-  switch (relation.via.kind) {
-    case "field": {
-      const relatedId = entity[relation.via.field];
-      if (typeof relatedId !== "string") return null;
-      const related = store.readEntitySnapshot(relation.type, relatedId);
-      return related ? projectRow(related, include, store) : null;
-    }
-    case "array": {
-      const ids = entity[relation.via.field];
-      if (!Array.isArray(ids)) return [];
-      return ids.map((id) => typeof id === "string" ? store.readEntitySnapshot(relation.type, id) : null).filter((row) => row !== null).map((row) => projectRow(row, include, store));
-    }
-    case "list": {
-      const key = typeof relation.via.key === "function" ? relation.via.key(entity) : relation.via.key;
-      if (!key) return [];
-      const ids = store.lists[key]?.ids ?? [];
-      return ids.map((id) => store.readEntitySnapshot(relation.type, id)).filter((row) => row !== null).map((row) => projectRow(row, include, store));
-    }
-    case "resolver": {
-      const resolved = relation.via.resolve(entity, store);
-      if (Array.isArray(resolved)) {
-        return resolved.map((id) => store.readEntitySnapshot(relation.type, id)).filter((row) => row !== null).map((row) => projectRow(row, include, store));
-      }
-      if (typeof resolved !== "string") return null;
-      const related = store.readEntitySnapshot(relation.type, resolved);
-      return related ? projectRow(related, include, store) : null;
-    }
+function clauseToPrismaLeaf(c) {
+  switch (c.op) {
+    case "eq":
+      return { equals: c.value };
+    case "neq":
+      return { not: c.value };
+    case "gt":
+      return { gt: c.value };
+    case "gte":
+      return { gte: c.value };
+    case "lt":
+      return { lt: c.value };
+    case "lte":
+      return { lte: c.value };
+    case "contains":
+      return { contains: c.value, mode: "insensitive" };
+    case "startsWith":
+      return { startsWith: c.value, mode: "insensitive" };
+    case "endsWith":
+      return { endsWith: c.value, mode: "insensitive" };
+    case "in":
+      return { in: c.value };
+    case "nin":
+      return { notIn: c.value };
+    case "arrayContains":
+      return { has: c.value };
+    case "between":
+    case "arrayOverlaps":
+    case "matches":
+    case "custom":
+    default:
+      return null;
   }
 }
-function applySelection(row, select) {
-  if (!select) return row;
-  if (typeof select === "function") {
-    const result = select(row);
-    return result && typeof result === "object" ? result : { value: result };
+function clauseToPrismaEntry(c) {
+  const parts = c.field.split(".").filter(Boolean);
+  if (parts.length === 0) return null;
+  if (c.op === "isNull") {
+    const equalsNull = c.value === void 0 || c.value === true;
+    return nestWhereField(parts, equalsNull ? null : { not: null });
   }
-  const picked = {};
-  for (const key of select) {
-    if (key in row) picked[key] = row[key];
+  if (c.op === "isNotNull") {
+    return nestWhereField(parts, { not: null });
   }
-  return picked;
+  const leaf = clauseToPrismaLeaf(c);
+  if (leaf === null) return null;
+  return nestWhereField(parts, leaf);
 }
-
-// src/graph-actions.ts
-var graphActionListeners = /* @__PURE__ */ new Set();
-var graphActionReplayers = /* @__PURE__ */ new Map();
-function createGraphTransaction() {
-  const baseline = cloneGraphData();
-  let closed = false;
-  const tx = {
-    upsertEntity(type, id, data) {
-      useGraphStore.getState().upsertEntity(type, id, data);
-      return tx;
-    },
-    replaceEntity(type, id, data) {
-      useGraphStore.getState().replaceEntity(type, id, data);
-      return tx;
-    },
-    removeEntity(type, id) {
-      useGraphStore.getState().removeEntity(type, id);
-      return tx;
-    },
-    patchEntity(type, id, patch) {
-      useGraphStore.getState().patchEntity(type, id, patch);
-      return tx;
-    },
-    clearPatch(type, id) {
-      useGraphStore.getState().clearPatch(type, id);
-      return tx;
-    },
-    insertIdInList(key, id, position) {
-      useGraphStore.getState().insertIdInList(key, id, position);
-      return tx;
-    },
-    removeIdFromAllLists(type, id) {
-      useGraphStore.getState().removeIdFromAllLists(type, id);
-      return tx;
-    },
-    setEntitySyncMetadata(type, id, metadata) {
-      useGraphStore.getState().setEntitySyncMetadata(type, id, metadata);
-      return tx;
-    },
-    markEntityPending(type, id, origin = "optimistic") {
-      useGraphStore.getState().setEntitySyncMetadata(type, id, {
-        synced: false,
-        origin,
-        updatedAt: Date.now()
-      });
-      return tx;
-    },
-    markEntitySynced(type, id, origin = "server") {
-      useGraphStore.getState().setEntitySyncMetadata(type, id, {
-        synced: true,
-        origin,
-        updatedAt: Date.now()
-      });
-      return tx;
-    },
-    commit() {
-      closed = true;
-    },
-    rollback() {
-      if (closed) return;
-      useGraphStore.setState(cloneGraphData(baseline));
-      closed = true;
-    },
-    snapshot() {
-      return cloneGraphData();
+function groupToPrismaWhere(g) {
+  const parts = [];
+  for (const item of g.clauses) {
+    if ("logic" in item) {
+      const nested = groupToPrismaWhere(item);
+      if (Object.keys(nested).length > 0) parts.push(nested);
+    } else {
+      const entry = clauseToPrismaEntry(item);
+      if (entry) parts.push(entry);
     }
-  };
-  return tx;
-}
-function createGraphAction(opts) {
-  if (opts.key) {
-    graphActionReplayers.set(opts.key, async (record) => {
-      const tx = createGraphTransaction();
-      try {
-        const result = await opts.run(tx, record.input);
-        tx.commit();
-        return result;
-      } catch (error) {
-        tx.rollback();
-        throw error;
-      }
-    });
   }
-  return async (input) => {
-    const tx = createGraphTransaction();
-    const record = opts.key ? {
-      id: `${opts.key}:${Date.now()}`,
-      key: opts.key,
-      input: structuredClone(input),
-      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString()
-    } : null;
-    try {
-      if (record) emitGraphActionEvent({ type: "enqueued", record });
-      opts.optimistic?.(tx, input);
-      const result = await opts.run(tx, input);
-      opts.onSuccess?.(result, input, tx);
-      tx.commit();
-      if (record) emitGraphActionEvent({ type: "settled", record });
-      return result;
-    } catch (error) {
-      tx.rollback();
-      const normalized = error instanceof Error ? error : new Error(String(error));
-      if (record) emitGraphActionEvent({ type: "settled", record });
-      opts.onError?.(normalized, input);
-      throw normalized;
-    }
-  };
-}
-function subscribeGraphActionEvents(listener) {
-  graphActionListeners.add(listener);
-  return () => graphActionListeners.delete(listener);
-}
-async function replayRegisteredGraphAction(record) {
-  const replayer = graphActionReplayers.get(record.key);
-  if (!replayer) throw new Error(`No graph action registered for key "${record.key}"`);
-  return replayer(record);
+  if (parts.length === 0) return {};
+  if (parts.length === 1) return parts[0];
+  return g.logic === "or" ? { OR: parts } : { AND: parts };
 }
-function cloneGraphData(source = useGraphStore.getState()) {
-  return {
-    entities: structuredClone(source.entities),
-    patches: structuredClone(source.patches),
-    entityStates: structuredClone(source.entityStates),
-    syncMetadata: structuredClone(source.syncMetadata),
-    lists: structuredClone(source.lists)
-  };
+function toPrismaWhere(filter) {
+  if (Array.isArray(filter)) {
+    const parts = [];
+    for (const item of filter) {
+      const entry = clauseToPrismaEntry(item);
+      if (entry) parts.push(entry);
+    }
+    if (parts.length === 0) return {};
+    if (parts.length === 1) return parts[0];
+    return { AND: parts };
+  }
+  return groupToPrismaWhere(filter);
 }
-function emitGraphActionEvent(event) {
-  for (const listener of graphActionListeners) listener(event);
+function toPrismaOrderBy(sort) {
+  return sort.map((s) => ({ [s.field]: s.direction }));
 }
 
-// src/graph-effects.ts
-function createGraphEffect(opts) {
-  const getKey = opts.getKey ?? defaultGetKey;
-  const isEqual = opts.isEqual ?? defaultIsEqual;
-  let initialized = false;
-  let previous = /* @__PURE__ */ new Map();
-  const evaluate = () => {
-    const nextValues = normalizeQueryResult(opts.query());
-    const next = /* @__PURE__ */ new Map();
-    nextValues.forEach((value, index) => {
-      next.set(getKey(value, index), value);
-    });
-    if (!initialized) {
-      initialized = true;
-      previous = next;
-      if (opts.skipInitial) return;
-    }
-    for (const [key, value] of next.entries()) {
-      const previousValue = previous.get(key);
-      if (previousValue === void 0) {
-        opts.onEnter?.({ key, value });
-        continue;
-      }
-      if (!isEqual(previousValue, value)) {
-        opts.onUpdate?.({ key, value, previousValue });
-      }
-    }
-    for (const [key, previousValue] of previous.entries()) {
-      if (!next.has(key)) opts.onExit?.({ key, previousValue });
+// src/view/types.ts
+function toRestParams(view) {
+  const params = {};
+  if (view.filter) {
+    const clauses = flattenClauses(view.filter);
+    for (const c of clauses) {
+      if (c.op === "custom") continue;
+      const key = c.op === "eq" ? c.field : `${c.field}[${c.op}]`;
+      params[key] = Array.isArray(c.value) ? c.value.join(",") : String(c.value ?? "");
     }
-    previous = next;
-  };
-  evaluate();
-  const unsubscribe = useGraphStore.subscribe(() => {
-    evaluate();
-  });
-  return {
-    dispose: () => {
-      unsubscribe();
+  }
+  if (view.sort) params["sort"] = view.sort.map((s) => `${s.direction === "desc" ? "-" : ""}${s.field}`).join(",");
+  if (view.search?.query) params["q"] = view.search.query;
+  return params;
+}
+function toSQLClauses(view) {
+  const params = [];
+  let paramIdx = 1;
+  function clauseToSQL(c) {
+    const col = `"${c.field}"`;
+    switch (c.op) {
+      case "eq":
+        params.push(c.value);
+        return `${col} = $${paramIdx++}`;
+      case "neq":
+        params.push(c.value);
+        return `${col} != $${paramIdx++}`;
+      case "gt":
+        params.push(c.value);
+        return `${col} > $${paramIdx++}`;
+      case "gte":
+        params.push(c.value);
+        return `${col} >= $${paramIdx++}`;
+      case "lt":
+        params.push(c.value);
+        return `${col} < $${paramIdx++}`;
+      case "lte":
+        params.push(c.value);
+        return `${col} <= $${paramIdx++}`;
+      case "in":
+        params.push(c.value);
+        return `${col} = ANY($${paramIdx++})`;
+      case "nin":
+        params.push(c.value);
+        return `${col} != ALL($${paramIdx++})`;
+      case "isNull":
+        return `${col} IS NULL`;
+      case "isNotNull":
+        return `${col} IS NOT NULL`;
+      case "contains":
+        params.push(`%${c.value}%`);
+        return `${col} ILIKE $${paramIdx++}`;
+      case "startsWith":
+        params.push(`${c.value}%`);
+        return `${col} ILIKE $${paramIdx++}`;
+      case "between": {
+        const [lo, hi] = c.value;
+        params.push(lo, hi);
+        return `${col} BETWEEN $${paramIdx++} AND $${paramIdx++}`;
+      }
+      case "arrayContains":
+        params.push(c.value);
+        return `$${paramIdx++} = ANY(${col})`;
+      default:
+        return "TRUE";
     }
-  };
+  }
+  function groupToSQL(g) {
+    const parts = g.clauses.map((c) => "logic" in c ? `(${groupToSQL(c)})` : clauseToSQL(c));
+    return parts.join(` ${g.logic.toUpperCase()} `);
+  }
+  let where = "TRUE";
+  if (view.filter) {
+    if (Array.isArray(view.filter)) where = view.filter.map(clauseToSQL).join(" AND ") || "TRUE";
+    else where = groupToSQL(view.filter) || "TRUE";
+  }
+  if (view.search?.query) {
+    params.push(`%${view.search.query}%`);
+    where += ` AND (${view.search.fields.map((f) => `"${f}"`).join(" || ' ' || ")}) ILIKE $${paramIdx++}`;
+  }
+  const orderBy = view.sort ? view.sort.map((s) => `"${s.field}" ${s.direction.toUpperCase()}${s.nulls ? ` NULLS ${s.nulls.toUpperCase()}` : ""}`).join(", ") : "";
+  return { where, orderBy, params };
 }
-function normalizeQueryResult(value) {
-  if (value == null) return [];
-  return Array.isArray(value) ? value : [value];
+function toGraphQLVariables(view) {
+  const result = {};
+  if (view.filter) {
+    const clauses = flattenClauses(view.filter);
+    const where = {};
+    for (const c of clauses) {
+      if (c.op === "custom") continue;
+      where[c.field] = { [`_${c.op}`]: c.value };
+    }
+    if (Object.keys(where).length) result.where = where;
+  }
+  if (view.sort) result.orderBy = view.sort.map((s) => ({ [s.field]: s.direction === "desc" ? "desc_nulls_last" : "asc_nulls_last" }));
+  if (view.search?.query) result.search = view.search.query;
+  return result;
 }
-function defaultGetKey(value, index) {
-  if (value && typeof value === "object") {
-    const record = value;
-    if (typeof record.id === "string") return record.id;
-    if (typeof record.$key === "string") return record.$key;
+function flattenClauses(filter) {
+  if (Array.isArray(filter)) return filter;
+  function walk(g) {
+    return g.clauses.flatMap((c) => "logic" in c ? walk(c) : [c]);
   }
-  return String(index);
+  return walk(filter);
 }
-function defaultIsEqual(previousValue, nextValue) {
-  return JSON.stringify(previousValue) === JSON.stringify(nextValue);
+function hasCustomPredicates(filter) {
+  return flattenClauses(filter).some((c) => c.op === "custom");
 }
 
-// src/object-path.ts
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+// src/transport/rest.ts
+function makeRestTransport(opts) {
+  const {
+    supabase,
+    table,
+    select = "*",
+    identify = (row) => String(row.id),
+    authoritative = false,
+    staleTime,
+    searchColumns = [],
+    defaultLimit = 200
+  } = opts;
+  return {
+    identify,
+    authoritative,
+    staleTime,
+    async list(q) {
+      const limit = q.limit ?? defaultLimit;
+      const offset = typeof q.cursor === "number" ? q.cursor : 0;
+      let builder = supabase.from(table).select(select, { count: offset === 0 ? "exact" : void 0 });
+      if (q.filter) builder = applyFilter(builder, q.filter);
+      if (q.search && searchColumns.length > 0) {
+        const escaped = q.search.replace(/[%,()]/g, "");
+        const orClause = searchColumns.map((c) => `${c}.ilike.*${escaped}*`).join(",");
+        builder = builder.or(orClause);
+      }
+      if (q.sort) {
+        for (const s of q.sort) {
+          builder = builder.order(s.field, {
+            ascending: s.direction === "asc",
+            nullsFirst: s.nulls === "first"
+          });
+        }
+      }
+      builder = builder.range(offset, offset + limit - 1);
+      if (q.signal && builder.abortSignal) builder = builder.abortSignal(q.signal);
+      const result = await builder;
+      if (result.error) {
+        throw mapPostgrestError(result.error, result.status);
+      }
+      const rows = result.data ?? [];
+      const total = typeof result.count === "number" ? result.count : null;
+      const nextCursor = rows.length === limit ? offset + limit : null;
+      return { rows, total, nextCursor };
+    }
+  };
 }
-function getValueAtPath(source, path) {
-  if (!path) return source;
-  const segments = path.split(".").filter(Boolean);
-  let current = source;
-  for (const segment of segments) {
-    if (!isObject(current) && !Array.isArray(current)) return void 0;
-    current = current[segment];
+function applyFilter(builder, filter) {
+  if (!Array.isArray(filter) && filter.logic === "or") {
+    const parts = filter.clauses.filter((c) => !("logic" in c)).map((c) => clauseToOrFragment(c)).filter((s) => !!s);
+    if (parts.length > 0) return builder.or(parts.join(","));
+    return builder;
   }
-  return current;
-}
-function setValueAtPath(source, path, value) {
-  const segments = path.split(".").filter(Boolean);
-  if (segments.length === 0) return source;
-  const clone = structuredClone(source);
-  let current = clone;
-  for (let index = 0; index < segments.length - 1; index += 1) {
-    const segment = segments[index];
-    const next = current[segment];
-    if (!isObject(next)) current[segment] = {};
-    current = current[segment];
+  const clauses = flattenClauses(filter);
+  let b = builder;
+  for (const c of clauses) {
+    b = applyClause(b, c);
   }
-  current[segments[segments.length - 1]] = value;
-  return clone;
+  return b;
 }
-function collectDirtyPaths(current, original, prefix = "", acc = /* @__PURE__ */ new Set()) {
-  if (isObject(current) && isObject(original)) {
-    const keys = /* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(original)]);
-    for (const key of keys) {
-      const nextPrefix = prefix ? `${prefix}.${key}` : key;
-      collectDirtyPaths(current[key], original[key], nextPrefix, acc);
-    }
-    return acc;
+function applyClause(builder, c) {
+  switch (c.op) {
+    case "eq":
+      return builder.eq(c.field, c.value);
+    case "neq":
+      return builder.neq(c.field, c.value);
+    case "gt":
+      return builder.gt(c.field, c.value);
+    case "gte":
+      return builder.gte(c.field, c.value);
+    case "lt":
+      return builder.lt(c.field, c.value);
+    case "lte":
+      return builder.lte(c.field, c.value);
+    case "in":
+      return builder.in(c.field, c.value);
+    case "isNull":
+      return builder.is(c.field, null);
+    case "isNotNull":
+      return builder.neq(c.field, null);
+    case "contains":
+      return builder.ilike(c.field, `%${String(c.value)}%`);
+    case "startsWith":
+      return builder.ilike(c.field, `${String(c.value)}%`);
+    case "endsWith":
+      return builder.ilike(c.field, `%${String(c.value)}`);
+    case "matches":
+      return builder.ilike(c.field, String(c.value));
+    case "custom":
+      return builder;
+    // local-only predicate; skip on server
+    default:
+      return builder;
   }
-  if (JSON.stringify(current) !== JSON.stringify(original) && prefix) acc.add(prefix);
-  return acc;
-}
-var schemaRegistry = /* @__PURE__ */ new Map();
-function registerEntityJsonSchema(config) {
-  const key = registryKey(config.entityType, config.field, config.schemaId);
-  schemaRegistry.set(key, config);
-}
-function registerRuntimeSchema(config) {
-  registerEntityJsonSchema(config);
 }
-function getEntityJsonSchema(opts) {
-  const exact = schemaRegistry.get(registryKey(opts.entityType, opts.field, opts.schemaId));
-  if (exact) return exact;
-  if (opts.field) {
-    const byField = schemaRegistry.get(registryKey(opts.entityType, opts.field));
-    if (byField) return byField;
+function clauseToOrFragment(c) {
+  const v = encodeURIComponent(String(c.value ?? ""));
+  switch (c.op) {
+    case "eq":
+      return `${c.field}.eq.${v}`;
+    case "neq":
+      return `${c.field}.neq.${v}`;
+    case "gt":
+      return `${c.field}.gt.${v}`;
+    case "gte":
+      return `${c.field}.gte.${v}`;
+    case "lt":
+      return `${c.field}.lt.${v}`;
+    case "lte":
+      return `${c.field}.lte.${v}`;
+    case "isNull":
+      return `${c.field}.is.null`;
+    case "isNotNull":
+      return `${c.field}.not.is.null`;
+    case "contains":
+      return `${c.field}.ilike.*${v}*`;
+    case "startsWith":
+      return `${c.field}.ilike.${v}*`;
+    case "endsWith":
+      return `${c.field}.ilike.*${v}`;
+    default:
+      return null;
   }
-  if (opts.schemaId) {
-    const byId = schemaRegistry.get(registryKey(opts.entityType, void 0, opts.schemaId));
-    if (byId) return byId;
+}
+function mapPostgrestError(error, status) {
+  if (error instanceof TerminalError || error instanceof TransientError) return error;
+  const message = error && typeof error === "object" && "message" in error ? String(error.message ?? "Unknown REST error") : String(error);
+  if (typeof status === "number") {
+    if (status >= 400 && status < 500) {
+      return new TerminalError(message, { status, cause: error });
+    }
+    if (status >= 500) {
+      return new TransientError(message, { status, cause: error });
+    }
   }
-  for (const schema of schemaRegistry.values()) {
-    if (schema.entityType !== opts.entityType) continue;
-    if (opts.field && schema.field !== opts.field) continue;
-    return schema;
+  const code = error && typeof error === "object" && "code" in error ? String(error.code ?? "") : "";
+  if (code === "42P01" || code === "PGRST116" || code === "PGRST106") {
+    return new TerminalError(message, { cause: error });
   }
-  return null;
+  return toEntityError(error);
 }
-function useSchemaEntityFields(opts) {
-  return useMemo(() => {
-    const schema = opts.schema ?? getEntityJsonSchema(opts)?.schema;
-    if (!schema) return [];
-    return buildEntityFieldsFromSchema({ schema, rootField: opts.rootField ?? opts.field });
-  }, [opts.entityType, opts.field, opts.rootField, opts.schemaId, opts.schema]);
+var EMPTY_IDS = [];
+var EMPTY_ENTITY_STATE = {
+  isFetching: false,
+  lastFetched: null,
+  error: null,
+  stale: false
+};
+var EMPTY_SYNC_METADATA = {
+  synced: true,
+  origin: "server",
+  updatedAt: null
+};
+var EMPTY_LIST_STATE = {
+  ids: EMPTY_IDS,
+  total: null,
+  nextCursor: null,
+  prevCursor: null,
+  hasNextPage: false,
+  hasPrevPage: false,
+  isFetching: false,
+  isFetchingMore: false,
+  error: null,
+  lastError: null,
+  lastFetched: null,
+  stale: false,
+  currentPage: null,
+  pageSize: null
+};
+function defaultEntityState() {
+  return { ...EMPTY_ENTITY_STATE };
 }
-function buildEntityFieldsFromSchema(opts) {
-  return buildSchemaFields(opts.schema, opts.rootField ?? "", "");
+function defaultSyncMetadata() {
+  return { ...EMPTY_SYNC_METADATA };
 }
-function exportGraphSnapshotWithSchemas(opts) {
-  return JSON.stringify(
-    {
-      scope: opts.scope,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      data: opts.data,
-      schemas: opts.schemas.filter(Boolean)
-    },
-    null,
-    opts.pretty === false ? 0 : 2
-  );
+function defaultListState() {
+  return { ...EMPTY_LIST_STATE, ids: [] };
 }
-function escapeHtml(input) {
-  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+function ek(type, id) {
+  return `${type}:${id}`;
 }
-function renderMarkdownToHtml(value) {
-  const escaped = escapeHtml(value);
-  const blocks = escaped.split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
-  return blocks.map((block) => renderMarkdownBlock(block)).join("");
+var snapshotCache = /* @__PURE__ */ new Map();
+function readCachedEntitySnapshot(type, id, base, patch, metadata) {
+  const key = ek(type, id);
+  const cached = snapshotCache.get(key);
+  if (cached && cached.base === base && cached.patch === patch && cached.metadata === metadata) {
+    return cached.snapshot;
+  }
+  const snapshot = {
+    ...patch ? { ...base, ...patch } : base,
+    $synced: metadata.synced,
+    $origin: metadata.origin,
+    $updatedAt: metadata.updatedAt
+  };
+  snapshotCache.set(key, { base, patch, metadata, snapshot });
+  return snapshot;
 }
-function MarkdownFieldRenderer({ value, className }) {
-  return /* @__PURE__ */ jsx(
-    "div",
-    {
-      className,
-      dangerouslySetInnerHTML: { __html: renderMarkdownToHtml(value ?? "") }
+var useGraphStore = create()(
+  subscribeWithSelector(
+    immer((set, get) => ({
+      entities: {},
+      patches: {},
+      entityStates: {},
+      syncMetadata: {},
+      lists: {},
+      upsertEntity: (type, id, data) => set((s) => {
+        if (!s.entities[type]) s.entities[type] = {};
+        s.entities[type][id] = { ...s.entities[type][id] ?? {}, ...data };
+        const key = ek(type, id);
+        if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
+      }),
+      upsertEntities: (type, entries) => set((s) => {
+        if (!s.entities[type]) s.entities[type] = {};
+        for (const { id, data } of entries) {
+          s.entities[type][id] = { ...s.entities[type][id] ?? {}, ...data };
+          const key = ek(type, id);
+          if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
+        }
+      }),
+      replaceEntity: (type, id, data) => set((s) => {
+        if (!s.entities[type]) s.entities[type] = {};
+        s.entities[type][id] = data;
+        const key = ek(type, id);
+        if (!s.syncMetadata[key]) s.syncMetadata[key] = defaultSyncMetadata();
+      }),
+      removeEntity: (type, id) => set((s) => {
+        delete s.entities[type]?.[id];
+        delete s.patches[type]?.[id];
+        delete s.entityStates[ek(type, id)];
+        delete s.syncMetadata[ek(type, id)];
+      }),
+      patchEntity: (type, id, patch) => set((s) => {
+        if (!s.patches[type]) s.patches[type] = {};
+        s.patches[type][id] = { ...s.patches[type][id] ?? {}, ...patch };
+      }),
+      unpatchEntity: (type, id, keys) => set((s) => {
+        const p = s.patches[type]?.[id];
+        if (!p) return;
+        for (const k of keys) delete p[k];
+      }),
+      clearPatch: (type, id) => set((s) => {
+        delete s.patches[type]?.[id];
+      }),
+      setEntityFetching: (type, id, fetching) => set((s) => {
+        const k = ek(type, id);
+        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+        s.entityStates[k].isFetching = fetching;
+      }),
+      setEntityError: (type, id, error) => set((s) => {
+        const k = ek(type, id);
+        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+        s.entityStates[k].error = error;
+        s.entityStates[k].isFetching = false;
+      }),
+      setEntityFetched: (type, id) => set((s) => {
+        const k = ek(type, id);
+        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+        s.entityStates[k].lastFetched = Date.now();
+        s.entityStates[k].isFetching = false;
+        s.entityStates[k].error = null;
+        s.entityStates[k].stale = false;
+        s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), synced: true, origin: "server", updatedAt: Date.now() };
+      }),
+      setEntityStale: (type, id, stale) => set((s) => {
+        const k = ek(type, id);
+        if (!s.entityStates[k]) s.entityStates[k] = defaultEntityState();
+        s.entityStates[k].stale = stale;
+      }),
+      setEntitySyncMetadata: (type, id, metadata) => set((s) => {
+        const k = ek(type, id);
+        s.syncMetadata[k] = { ...s.syncMetadata[k] ?? defaultSyncMetadata(), ...metadata };
+      }),
+      clearEntitySyncMetadata: (type, id) => set((s) => {
+        delete s.syncMetadata[ek(type, id)];
+      }),
+      setListResult: (key, ids, meta) => set((s) => {
+        const ex = s.lists[key] ?? defaultListState();
+        s.lists[key] = { ...ex, ...meta, ids, isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
+      }),
+      appendListResult: (key, ids, meta) => set((s) => {
+        const ex = s.lists[key] ?? defaultListState();
+        s.lists[key] = { ...ex, ...meta, ids: Array.from(/* @__PURE__ */ new Set([...ex.ids, ...ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
+      }),
+      prependListResult: (key, ids, meta) => set((s) => {
+        const ex = s.lists[key] ?? defaultListState();
+        s.lists[key] = { ...ex, ...meta ?? {}, ids: Array.from(/* @__PURE__ */ new Set([...ids, ...ex.ids])), isFetching: false, isFetchingMore: false, error: null, lastError: null, stale: false, lastFetched: Date.now() };
+      }),
+      removeIdFromAllLists: (_type, id) => set((s) => {
+        for (const key of Object.keys(s.lists)) {
+          const list = s.lists[key];
+          const idx = list.ids.indexOf(id);
+          if (idx !== -1) {
+            list.ids.splice(idx, 1);
+            if (list.total !== null) list.total -= 1;
+          }
+        }
+      }),
+      insertIdInList: (key, id, position) => set((s) => {
+        if (!s.lists[key]) s.lists[key] = defaultListState();
+        const ids = s.lists[key].ids;
+        const ex = ids.indexOf(id);
+        if (ex !== -1) ids.splice(ex, 1);
+        if (position === "start") ids.unshift(id);
+        else if (position === "end") ids.push(id);
+        else ids.splice(position, 0, id);
+      }),
+      setListFetching: (key, fetching) => set((s) => {
+        if (!s.lists[key]) s.lists[key] = defaultListState();
+        s.lists[key].isFetching = fetching;
+      }),
+      setListFetchingMore: (key, fetchingMore) => set((s) => {
+        if (!s.lists[key]) s.lists[key] = defaultListState();
+        s.lists[key].isFetchingMore = fetchingMore;
+      }),
+      setListError: (key, error, typed) => set((s) => {
+        if (!s.lists[key]) s.lists[key] = defaultListState();
+        s.lists[key].error = error;
+        s.lists[key].lastError = typed ?? (error === null ? null : s.lists[key].lastError);
+        s.lists[key].isFetching = false;
+        s.lists[key].isFetchingMore = false;
+        s.lists[key].lastFetched = Date.now();
+        s.lists[key].stale = false;
+      }),
+      setListStale: (key, stale) => set((s) => {
+        if (!s.lists[key]) s.lists[key] = defaultListState();
+        s.lists[key].stale = stale;
+      }),
+      invalidateEntity: (type, id) => set((s) => {
+        if (id) {
+          const k = ek(type, id);
+          if (s.entityStates[k]) s.entityStates[k].stale = true;
+        } else {
+          for (const k of Object.keys(s.entityStates)) if (k.startsWith(`${type}:`)) s.entityStates[k].stale = true;
+        }
+      }),
+      invalidateLists: (matcher) => set((s) => {
+        const pred = typeof matcher === "string" ? (k) => k.startsWith(matcher) : matcher;
+        for (const key of Object.keys(s.lists)) if (pred(key)) s.lists[key].stale = true;
+      }),
+      invalidateType: (type) => {
+        get().invalidateEntity(type);
+        get().invalidateLists(type);
+      },
+      readEntity: (type, id) => {
+        const s = get();
+        const base = s.entities[type]?.[id];
+        if (!base) return null;
+        const patch = s.patches[type]?.[id];
+        return patch ? { ...base, ...patch } : base;
+      },
+      readEntitySnapshot: (type, id) => {
+        const s = get();
+        const base = s.entities[type]?.[id];
+        if (!base) {
+          snapshotCache.delete(ek(type, id));
+          return null;
+        }
+        const patch = s.patches[type]?.[id];
+        const metadata = s.syncMetadata[ek(type, id)] ?? EMPTY_SYNC_METADATA;
+        return readCachedEntitySnapshot(
+          type,
+          id,
+          base,
+          patch,
+          metadata
+        );
+      }
+    }))
+  )
+);
+
+// src/engine.ts
+function serializeKey(key) {
+  return JSON.stringify(key, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort()) : v);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var inflight = /* @__PURE__ */ new Map();
+function dedupe(key, fn) {
+  if (inflight.has(key)) return inflight.get(key);
+  const p = fn().finally(() => inflight.delete(key));
+  inflight.set(key, p);
+  return p;
+}
+var subscriberStatsListeners = /* @__PURE__ */ new Set();
+function emitSubscriberStatsChange() {
+  for (const cb of subscriberStatsListeners) cb();
+}
+var subscribers = /* @__PURE__ */ new Map();
+function registerSubscriber(key) {
+  const token = Symbol(key);
+  if (!subscribers.has(key)) subscribers.set(key, /* @__PURE__ */ new Set());
+  subscribers.get(key).add(token);
+  emitSubscriberStatsChange();
+  return token;
+}
+function unregisterSubscriber(key, token) {
+  const set = subscribers.get(key);
+  if (!set) return;
+  set.delete(token);
+  if (set.size === 0) subscribers.delete(key);
+  emitSubscriberStatsChange();
+}
+function hasSubscribers(key) {
+  return (subscribers.get(key)?.size ?? 0) > 0;
+}
+var DEFAULT_OPTIONS = {
+  defaultStaleTime: 3e4,
+  defaultGcTime: 3e5,
+  gcInterval: 6e4,
+  maxRetries: 3,
+  retryBaseDelay: 1e3,
+  revalidateOnFocus: true,
+  revalidateOnReconnect: true
+};
+var engineOptions = { ...DEFAULT_OPTIONS };
+function subscribeSubscriberStats(onChange) {
+  subscriberStatsListeners.add(onChange);
+  return () => subscriberStatsListeners.delete(onChange);
+}
+function getActiveSubscriberCount() {
+  let n = 0;
+  for (const set of subscribers.values()) n += set.size;
+  return n;
+}
+var gcIntervalId = null;
+function runGarbageCollection() {
+  const store = useGraphStore.getState();
+  const { defaultGcTime: gcTime } = getEngineOptions();
+  const now = Date.now();
+  const toRemove = [];
+  for (const type of Object.keys(store.entities)) {
+    const bucket = store.entities[type];
+    if (!bucket) continue;
+    for (const id of Object.keys(bucket)) {
+      const key = `${type}:${id}`;
+      if (hasSubscribers(key)) continue;
+      const patch = store.patches[type]?.[id];
+      if (patch !== void 0 && Object.keys(patch).length > 0) continue;
+      const entityState = store.entityStates[key];
+      if (entityState?.isFetching) continue;
+      const lastFetched = entityState?.lastFetched;
+      if (lastFetched == null) continue;
+      if (now - lastFetched <= gcTime) continue;
+      toRemove.push({ type, id });
     }
-  );
+  }
+  for (const { type, id } of toRemove) {
+    store.removeEntity(type, id);
+    store.removeIdFromAllLists(type, id);
+  }
 }
-function MarkdownFieldEditor({
-  value,
-  onChange,
-  placeholder
-}) {
-  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
-    /* @__PURE__ */ jsx(
-      "textarea",
-      {
-        value,
-        onChange: (event) => onChange(event.target.value),
-        placeholder,
-        className: "w-full min-h-[120px] rounded-md border bg-muted/50 px-3 py-2 text-sm resize-y focus:outline-none focus:ring-1 focus:ring-ring transition-colors"
-      }
-    ),
-    /* @__PURE__ */ jsx("div", { className: "rounded-md border bg-background px-3 py-2", children: /* @__PURE__ */ jsx(MarkdownFieldRenderer, { value, className: "prose prose-sm max-w-none" }) })
-  ] });
+function stopGarbageCollector() {
+  if (gcIntervalId != null && typeof clearInterval !== "undefined") {
+    clearInterval(gcIntervalId);
+    gcIntervalId = null;
+  }
 }
-function createMarkdownDetailRenderer(field) {
-  return (value, entity) => /* @__PURE__ */ jsx(MarkdownFieldRenderer, { value: String(value ?? getValueAtPath(entity, field) ?? ""), className: "prose prose-sm max-w-none" });
+function startGarbageCollector() {
+  stopGarbageCollector();
+  if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
+  };
+  gcIntervalId = setInterval(() => runGarbageCollection(), getEngineOptions().gcInterval);
+  return () => stopGarbageCollector();
 }
-function buildSchemaFields(schema, pathPrefix, schemaPathPrefix) {
-  if (schema.type === "object" && schema.properties) {
-    const entries = Object.entries(schema.properties).sort(([, left], [, right]) => {
-      const l = left["x-display-order"] ?? Number.MAX_SAFE_INTEGER;
-      const r = right["x-display-order"] ?? Number.MAX_SAFE_INTEGER;
-      return l - r;
-    });
-    return entries.flatMap(([key, childSchema]) => {
-      if (childSchema["x-hidden"]) return [];
-      const field = pathPrefix ? `${pathPrefix}.${key}` : key;
-      const schemaPath = schemaPathPrefix ? `${schemaPathPrefix}.${key}` : key;
-      if (childSchema.type === "object" && childSchema.properties) {
-        return buildSchemaFields(childSchema, field, schemaPath);
+function restartGarbageCollector() {
+  startGarbageCollector();
+}
+function configureEngine(opts) {
+  engineOptions = { ...DEFAULT_OPTIONS, ...opts };
+  restartGarbageCollector();
+}
+function getEngineOptions() {
+  return engineOptions;
+}
+async function fetchEntity(opts, engineOpts) {
+  const { type, id, fetch: fetch2, normalize, sideEffects, idField = "id" } = opts;
+  if (!id) return;
+  useGraphStore.getState().setEntityFetching(type, id, true);
+  const attempt = async (retries) => {
+    try {
+      const raw = await fetch2(id);
+      const normalized = normalize(raw);
+      const resolvedId = normalized[idField] ?? id;
+      useGraphStore.getState().upsertEntity(type, resolvedId, normalized);
+      useGraphStore.getState().setEntityFetched(type, resolvedId);
+      if (sideEffects) sideEffects(raw, useGraphStore);
+      opts.onSuccess?.(normalized);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (retries < engineOpts.maxRetries) {
+        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
+        return attempt(retries + 1);
       }
-      return [schemaField(field, schemaPath, childSchema, schema.required?.includes(key) ?? false)];
-    });
-  }
-  return [];
+      useGraphStore.getState().setEntityError(type, id, error.message);
+      opts.onError?.(error);
+    }
+  };
+  await dedupe(`${type}:${id}`, () => attempt(0));
 }
-function schemaField(field, schemaPath, schema, required) {
-  const type = inferFieldType(schema);
-  const descriptor = {
-    field,
-    label: schema.title ?? humanize(field.split(".").pop() ?? field),
-    type,
-    required,
-    hint: schema.description,
-    schemaPath,
-    schema,
-    componentHint: schema["x-a2ui-component"]
+async function fetchList(opts, params, engineOpts, isLoadMore = false) {
+  const { type, queryKey, fetch: fetch2, normalize, sideEffects, mode = "replace" } = opts;
+  const key = serializeKey(queryKey);
+  const store = useGraphStore.getState();
+  if (isLoadMore) store.setListFetchingMore(key, true);
+  else store.setListFetching(key, true);
+  const attempt = async (retries) => {
+    try {
+      const response = await fetch2(params);
+      const normalized = response.items.map(normalize);
+      useGraphStore.getState().upsertEntities(type, normalized.map(({ id, data }) => ({ id, data })));
+      for (const { id } of normalized) useGraphStore.getState().setEntityFetched(type, id);
+      const ids = normalized.map(({ id }) => id);
+      const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
+      if (mode === "append" && isLoadMore) useGraphStore.getState().appendListResult(key, ids, meta);
+      else useGraphStore.getState().setListResult(key, ids, meta);
+      if (sideEffects) sideEffects(response.items, useGraphStore);
+      opts.onSuccess?.(response);
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      if (retries < engineOpts.maxRetries) {
+        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
+        return attempt(retries + 1);
+      }
+      useGraphStore.getState().setListError(key, error.message);
+      opts.onError?.(error);
+    }
+  };
+  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0));
+}
+var focusListenerAttached = false;
+function attachGlobalListeners() {
+  if (typeof window === "undefined" || focusListenerAttached) return;
+  focusListenerAttached = true;
+  restartGarbageCollector();
+  const revalidateAll = () => {
+    const state = useGraphStore.getState();
+    for (const key of subscribers.keys()) {
+      if (!hasSubscribers(key)) continue;
+      const colonIdx = key.indexOf(":");
+      if (colonIdx === -1) continue;
+      const type = key.slice(0, colonIdx);
+      const id = key.slice(colonIdx + 1);
+      state.setEntityStale(type, id, true);
+    }
   };
-  if (schema.enum) {
-    descriptor.options = schema.enum.map((value) => ({
-      value: String(value),
-      label: String(value)
-    }));
-  }
-  if (type === "markdown") {
-    descriptor.render = createMarkdownDetailRenderer(field);
-  }
-  return descriptor;
-}
-function inferFieldType(schema) {
-  const forced = schema["x-field-type"];
-  if (forced === "markdown") return "markdown";
-  if (schema.format === "markdown") return "markdown";
-  if (schema.enum) return "enum";
-  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
-  switch (type) {
-    case "boolean":
-      return "boolean";
-    case "integer":
-    case "number":
-      return "number";
-    case "string":
-      if (schema.format === "email") return "email";
-      if (schema.format === "uri" || schema.format === "url") return "url";
-      if (schema.format === "date" || schema.format === "date-time") return "date";
-      return "text";
-    case "array":
-    case "object":
-      return "json";
-    default:
-      return "text";
+  if (engineOptions.revalidateOnFocus) {
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") revalidateAll();
+    });
+    window.addEventListener("focus", revalidateAll);
   }
+  if (engineOptions.revalidateOnReconnect) window.addEventListener("online", revalidateAll);
 }
-function registryKey(entityType, field, schemaId) {
-  return `${entityType}::${field ?? "*"}::${schemaId ?? "*"}`;
+
+// src/hooks/use-entities.ts
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
 }
-function humanize(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+function useEntities(type, options = {}) {
+  const {
+    filter,
+    sort,
+    search,
+    limit,
+    cursor,
+    enabled = true
+  } = options;
+  const queryKey = useMemo(
+    () => serializeKey([type, { filter, sort, search, limit, cursor }]),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [type, JSON.stringify({ filter, sort, search, limit, cursor })]
+  );
+  const abortRef = useRef(null);
+  const fetchCountRef = useRef(0);
+  const [fetchTick, setFetchTick] = useState(0);
+  const listState = useStore(
+    useGraphStore,
+    useCallback((s) => s.lists[queryKey] ?? EMPTY_LIST_STATE, [queryKey])
+  );
+  const items = useMemo(() => {
+    const state = useGraphStore.getState();
+    return listState.ids.map((id) => state.readEntity(type, id)).filter((item) => item !== null);
+  }, [listState.ids, type]);
+  useEffect(() => {
+    if (!enabled) return;
+    const store = useGraphStore.getState();
+    const existing = store.lists[queryKey];
+    const engineOpts = getEngineOptions();
+    let transport;
+    try {
+      transport = getEntityTransport(type);
+    } catch {
+      const err = new TerminalError(`No transport registered for entity type "${type}"`);
+      store.setListError(queryKey, err.message, err);
+      return;
+    }
+    const effectiveStaleTime = transport.staleTime ?? engineOpts.defaultStaleTime;
+    if (existing?.lastFetched !== null && existing?.lastFetched !== void 0 && !existing.stale && Date.now() - existing.lastFetched < effectiveStaleTime) {
+      return;
+    }
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+    const thisCount = ++fetchCountRef.current;
+    const query = {
+      filter: filter ?? void 0,
+      sort: sort ?? void 0,
+      search,
+      limit,
+      cursor: cursor ?? void 0,
+      signal: controller.signal
+    };
+    const maxRetries = engineOpts.maxRetries ?? 3;
+    const retryBaseDelay = engineOpts.retryBaseDelay ?? 1e3;
+    store.setListFetching(queryKey, true);
+    const attempt = async (retries) => {
+      try {
+        const result = await transport.list(query);
+        if (thisCount !== fetchCountRef.current) return;
+        if (controller.signal.aborted) return;
+        const graphStore = useGraphStore.getState();
+        const entries = result.rows.map((row) => ({
+          id: transport.identify(row),
+          data: row
+        }));
+        graphStore.upsertEntities(type, entries);
+        for (const { id } of entries) graphStore.setEntityFetched(type, id);
+        const ids = entries.map(({ id }) => id);
+        graphStore.setListResult(queryKey, ids, {
+          total: result.total,
+          nextCursor: typeof result.nextCursor === "string" ? result.nextCursor : null,
+          hasNextPage: result.nextCursor !== null && result.nextCursor !== void 0
+        });
+      } catch (err) {
+        if (thisCount !== fetchCountRef.current) return;
+        if (controller.signal.aborted) return;
+        const typed = toEntityError(err);
+        if (typed instanceof TransientError && retries < maxRetries) {
+          await sleep2(retryBaseDelay * Math.pow(2, retries));
+          if (controller.signal.aborted) return;
+          return attempt(retries + 1);
+        }
+        useGraphStore.getState().setListError(queryKey, typed.message, typed);
+      }
+    };
+    attempt(0);
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, [queryKey, enabled, fetchTick]);
+  useEffect(() => {
+    let transport;
+    try {
+      transport = getEntityTransport(type);
+    } catch {
+      return;
+    }
+    if (!transport.subscribe || !enabled) return;
+    const unsub = transport.subscribe((ev) => {
+      const store = useGraphStore.getState();
+      if (ev.op === "delete") {
+        store.removeIdFromAllLists(type, ev.id);
+        store.removeEntity(type, ev.id);
+      } else if (ev.row) {
+        store.upsertEntity(type, ev.id, ev.row);
+        store.setEntityFetched(type, ev.id);
+      }
+    });
+    return () => unsub();
+  }, [type, enabled]);
+  const refetch = useCallback(() => {
+    abortRef.current?.abort();
+    useGraphStore.getState().setListStale(queryKey, true);
+    setFetchTick((n) => n + 1);
+  }, [queryKey]);
+  const typedError = listState.lastError ?? null;
+  return {
+    items,
+    // isLoading = first attempt in-flight with zero cached rows
+    isLoading: !enabled ? false : listState.lastFetched === null && listState.isFetching,
+    isError: typedError !== null,
+    error: typedError,
+    refetch
+  };
 }
-function renderMarkdownBlock(block) {
-  if (block.startsWith("# ")) return `<h1>${renderInlineMarkdown(block.slice(2))}</h1>`;
-  if (block.startsWith("## ")) return `<h2>${renderInlineMarkdown(block.slice(3))}</h2>`;
-  return `<p>${renderInlineMarkdown(block).replaceAll("\n", "<br/>")}</p>`;
+
+// src/view/evaluator.ts
+function matchesFilter(entity, filter) {
+  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
+  return matchesGroup(entity, filter);
 }
-function renderInlineMarkdown(block) {
-  return block.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+function matchesGroup(entity, group) {
+  const { logic, clauses } = group;
+  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
+  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
 }
-
-// src/ai-interop.ts
-function exportGraphSnapshot(opts) {
-  const payload = {
-    scope: opts.scope,
-    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    data: opts.data
-  };
-  return JSON.stringify(payload, null, opts.pretty === false ? 0 : 2);
+function matchesClause(entity, clause) {
+  const { field, op, value, predicate } = clause;
+  const fv = getNestedValue(entity, field);
+  switch (op) {
+    case "eq":
+      return fv === value;
+    case "neq":
+      return fv !== value;
+    case "gt":
+      return fv > value;
+    case "gte":
+      return fv >= value;
+    case "lt":
+      return fv < value;
+    case "lte":
+      return fv <= value;
+    case "in":
+      return Array.isArray(value) && value.includes(fv);
+    case "nin":
+      return Array.isArray(value) && !value.includes(fv);
+    case "isNull":
+      return fv == null;
+    case "isNotNull":
+      return fv != null;
+    case "contains":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
+    case "startsWith":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
+    case "endsWith":
+      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
+    case "between": {
+      const [lo, hi] = value;
+      return fv >= lo && fv <= hi;
+    }
+    case "arrayContains":
+      return Array.isArray(fv) && fv.includes(value);
+    case "arrayOverlaps":
+      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
+    case "matches":
+      return typeof fv === "string" && new RegExp(value).test(fv);
+    case "custom":
+      return predicate ? predicate(fv, entity) : true;
+    default:
+      return true;
+  }
 }
-function createGraphTool(handler) {
-  return (input) => handler(input, {
-    store: useGraphStore.getState(),
-    queryOnce,
-    exportGraphSnapshot
+function matchesSearch(entity, query, fields) {
+  if (!query.trim()) return true;
+  const lq = query.toLowerCase();
+  return fields.some((field) => {
+    const v = getNestedValue(entity, field);
+    return typeof v === "string" && v.toLowerCase().includes(lq);
   });
 }
-function createSchemaGraphTool(handler) {
-  return (input) => handler(input, {
-    store: useGraphStore.getState(),
-    queryOnce,
-    exportGraphSnapshot,
-    getEntityJsonSchema,
-    exportGraphSnapshotWithSchemas
-  });
+function compareEntities(a, b, sort) {
+  for (const clause of sort) {
+    const r = compareByClause(a, b, clause);
+    if (r !== 0) return r;
+  }
+  return 0;
 }
-var DEFAULT_STORAGE_KEY = "prometheus:graph";
-var useGraphSyncStatusStore = create((set) => ({
-  status: {
-    phase: "idle",
-    isOnline: true,
-    isSynced: true,
-    pendingActions: 0,
-    lastHydratedAt: null,
-    lastPersistedAt: null,
-    storageKey: null,
-    error: null
-  },
-  setStatus: (status) => set((state) => ({
-    status: {
-      ...state.status,
-      ...status
+function compareByClause(a, b, clause) {
+  const { field, direction, nulls = "last", comparator } = clause;
+  const av = getNestedValue(a, field);
+  const bv = getNestedValue(b, field);
+  const aNull = av == null;
+  const bNull = bv == null;
+  if (aNull && bNull) return 0;
+  if (aNull) return nulls === "first" ? -1 : 1;
+  if (bNull) return nulls === "first" ? 1 : -1;
+  let cmp;
+  if (comparator) cmp = comparator(av, bv);
+  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
+  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
+  else cmp = String(av).localeCompare(String(bv));
+  return direction === "desc" ? -cmp : cmp;
+}
+function findInsertionIndex(entity, sortedIds, getEntity, sort) {
+  let lo = 0;
+  let hi = sortedIds.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    const me = getEntity(sortedIds[mid]);
+    if (!me) {
+      lo = mid + 1;
+      continue;
     }
-  }))
-}));
-var pendingActions = /* @__PURE__ */ new Map();
-function useGraphSyncStatus() {
-  return useGraphSyncStatusStore((state) => state.status);
+    if (compareEntities(entity, me, sort) <= 0) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
 }
-async function persistGraphToStorage(opts) {
-  const payload = {
-    version: 1,
-    snapshot: cloneGraphSnapshot(),
-    pendingActions: opts.pendingActions ?? Array.from(pendingActions.values())
-  };
-  const json = JSON.stringify(payload);
-  await opts.storage.set(opts.key, json);
-  const persistedAt = (/* @__PURE__ */ new Date()).toISOString();
-  useGraphSyncStatusStore.getState().setStatus({
-    lastPersistedAt: persistedAt,
-    storageKey: opts.key,
-    pendingActions: payload.pendingActions.length
-  });
-  return {
-    ok: true,
-    key: opts.key,
-    bytes: json.length,
-    persistedAt
-  };
+function applyView(ids, getEntity, filter, sort, search) {
+  let entries = [];
+  for (const id of ids) {
+    const entity = getEntity(id);
+    if (!entity) continue;
+    entries.push({ id, entity });
+  }
+  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
+  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
+  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
+  return entries.map((e) => e.id);
 }
-async function hydrateGraphFromStorage(opts) {
-  const raw = await opts.storage.get(opts.key);
-  if (!raw) {
-    return {
-      ok: false,
-      key: opts.key,
-      hydratedAt: null,
-      entityCounts: {},
-      error: "No persisted graph snapshot found"
-    };
+function checkCompleteness(loadedCount, total, hasNextPage) {
+  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
+  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
+  return { isComplete: true, reason: "no-more-pages" };
+}
+function getNestedValue(obj, path) {
+  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+
+// src/hooks/use-entity-query.ts
+function sleep3(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var EMPTY_ENTITY_BUCKET = {};
+function useEntityQuery(type, opts = {}) {
+  const {
+    view: initialView = {},
+    mode: forcedMode,
+    enabled = true,
+    initialIds,
+    initialTotal,
+    remoteDebounce = 300
+  } = opts;
+  const engineOpts = getEngineOptions();
+  const optsRef = useRef(opts);
+  optsRef.current = opts;
+  const [liveView, setLiveView] = useState(initialView);
+  const liveViewRef = useRef(liveView);
+  liveViewRef.current = liveView;
+  const abortRef = useRef(null);
+  const fetchCountRef = useRef(0);
+  const [fetchTick, setFetchTick] = useState(0);
+  const [remoteResultKey, setRemoteResultKey] = useState(null);
+  const [isFetchingState, setIsFetchingState] = useState(false);
+  const baseKey = useMemo(
+    () => serializeKey([type, "__base__"]),
+    [type]
+  );
+  const seededRef = useRef(false);
+  if (!seededRef.current && initialIds && initialIds.length > 0) {
+    seededRef.current = true;
+    const store = useGraphStore.getState();
+    if (!store.lists[baseKey]) {
+      store.setListResult(baseKey, initialIds, { total: initialTotal ?? null });
+    }
   }
+  const listState = useStore(
+    useGraphStore,
+    useCallback((s) => s.lists[baseKey] ?? EMPTY_LIST_STATE, [baseKey])
+  );
+  const remoteListState = useStore(
+    useGraphStore,
+    useCallback(
+      (s) => remoteResultKey ? s.lists[remoteResultKey] ?? null : null,
+      [remoteResultKey]
+    )
+  );
+  const { isComplete } = useMemo(() => {
+    if (!listState) return { isComplete: false };
+    return checkCompleteness(listState.ids.length, listState.total, listState.hasNextPage);
+  }, [listState]);
+  let transport = null;
   try {
-    const parsed = JSON.parse(raw);
-    useGraphStore.setState(parsed.snapshot);
-    pendingActions.clear();
-    for (const action of parsed.pendingActions ?? []) pendingActions.set(action.id, action);
-    const hydratedAt = (/* @__PURE__ */ new Date()).toISOString();
-    useGraphSyncStatusStore.getState().setStatus({
-      lastHydratedAt: hydratedAt,
-      storageKey: opts.key,
-      pendingActions: pendingActions.size,
-      error: null
-    });
-    return {
-      ok: true,
-      key: opts.key,
-      hydratedAt,
-      entityCounts: Object.fromEntries(
-        Object.entries(parsed.snapshot.entities).map(([type, entities]) => [type, Object.keys(entities).length])
-      ),
-      pendingActions: Array.from(pendingActions.values())
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    useGraphSyncStatusStore.getState().setStatus({
-      phase: "error",
-      error: message,
-      storageKey: opts.key
-    });
-    return {
-      ok: false,
-      key: opts.key,
-      hydratedAt: null,
-      entityCounts: {},
-      error: message
-    };
+    transport = getEntityTransport(type);
+  } catch {
   }
-}
-function startLocalFirstGraph(opts) {
-  const key = opts.key ?? DEFAULT_STORAGE_KEY;
-  const persistDebounceMs = opts.persistDebounceMs ?? 50;
-  const statusStore = useGraphSyncStatusStore.getState();
-  statusStore.setStatus({
-    phase: "hydrating",
-    storageKey: key,
-    isOnline: opts.onlineSource?.getIsOnline() ?? getDefaultOnlineSource().getIsOnline(),
-    isSynced: pendingActions.size === 0,
-    error: null
-  });
-  let persistTimer = null;
-  const schedulePersist = () => {
-    if (persistTimer) clearTimeout(persistTimer);
-    persistTimer = setTimeout(() => {
-      void persistGraphToStorage({ storage: opts.storage, key });
-    }, persistDebounceMs);
-  };
-  const graphUnsub = useGraphStore.subscribe(() => {
-    schedulePersist();
-  });
-  const actionUnsub = subscribeGraphActionEvents((event) => {
-    if (event.type === "enqueued") pendingActions.set(event.record.id, event.record);
-    if (event.type === "settled") pendingActions.delete(event.record.id);
-    useGraphSyncStatusStore.getState().setStatus({
-      pendingActions: pendingActions.size,
-      isSynced: pendingActions.size === 0
-    });
-    schedulePersist();
-  });
-  const onlineSource = opts.onlineSource ?? getDefaultOnlineSource();
-  const onlineUnsub = onlineSource.subscribe((online) => {
-    useGraphSyncStatusStore.getState().setStatus({
-      isOnline: online,
-      phase: online ? "ready" : "offline"
-    });
-  });
-  const ready = (async () => {
-    const hydrated = await hydrateGraphFromStorage({ storage: opts.storage, key });
-    if (opts.replayPendingActions && hydrated.ok && pendingActions.size > 0) {
-      useGraphSyncStatusStore.getState().setStatus({
-        phase: "syncing",
-        isSynced: false
-      });
-      for (const action of Array.from(pendingActions.values())) {
-        await replayRegisteredGraphAction(action);
-        pendingActions.delete(action.id);
+  const completenessMode = useMemo(() => {
+    if (forcedMode) return forcedMode;
+    if (liveView.filter && hasCustomPredicates(liveView.filter)) return "local";
+    if (isComplete) return "local";
+    if (!transport) return "local";
+    return "hybrid";
+  }, [forcedMode, isComplete, liveView.filter, transport?.authoritative]);
+  const localViewIds = useStore(
+    useGraphStore,
+    useShallow((state) => {
+      const list = state.lists[baseKey] ?? EMPTY_LIST_STATE;
+      const sourceIds = completenessMode !== "remote" && remoteResultKey ? state.lists[remoteResultKey]?.ids ?? EMPTY_IDS : list.ids;
+      const getEntity = (id) => state.readEntitySnapshot(type, id);
+      return applyView(
+        sourceIds,
+        getEntity,
+        liveView.filter,
+        liveView.sort,
+        liveView.search?.query ? { query: liveView.search.query, fields: liveView.search.fields } : null
+      );
+    })
+  );
+  const items = useMemo(
+    () => localViewIds.map((id) => useGraphStore.getState().readEntitySnapshot(type, id)).filter((item) => item !== null),
+    [localViewIds, type]
+  );
+  const fireRemoteFetch = useCallback(
+    async (view, cursor) => {
+      let tp;
+      try {
+        tp = getEntityTransport(type);
+      } catch (e) {
+        const err = toEntityError(e);
+        useGraphStore.getState().setListError(baseKey, err.message, err);
+        return;
       }
-      await persistGraphToStorage({ storage: opts.storage, key });
-    }
-    const online = onlineSource.getIsOnline();
-    useGraphSyncStatusStore.getState().setStatus({
-      phase: online ? "ready" : "offline",
-      isOnline: online,
-      isSynced: pendingActions.size === 0,
-      pendingActions: pendingActions.size
-    });
-  })();
-  return {
-    ready,
-    dispose() {
-      graphUnsub();
-      actionUnsub();
-      onlineUnsub();
-      if (persistTimer) clearTimeout(persistTimer);
-    },
-    async persistNow() {
-      await persistGraphToStorage({ storage: opts.storage, key });
-    },
-    hydrate() {
-      return hydrateGraphFromStorage({ storage: opts.storage, key });
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      const thisCount = ++fetchCountRef.current;
+      const rKey = serializeKey([type, "__view__", view, cursor]);
+      setRemoteResultKey(rKey);
+      setIsFetchingState(true);
+      const store = useGraphStore.getState();
+      store.setListFetching(rKey, true);
+      store.setListFetching(baseKey, true);
+      tp.staleTime ?? engineOpts.defaultStaleTime;
+      const maxRetries = engineOpts.maxRetries ?? 3;
+      const retryBaseDelay = engineOpts.retryBaseDelay ?? 1e3;
+      const query = {
+        filter: view.filter,
+        sort: view.sort,
+        search: view.search?.query,
+        cursor,
+        signal: controller.signal
+      };
+      const attempt = async (retries) => {
+        try {
+          const result = await tp.list(query);
+          if (thisCount !== fetchCountRef.current) return;
+          if (controller.signal.aborted) return;
+          const graphStore = useGraphStore.getState();
+          const entries = result.rows.map((row) => ({
+            id: tp.identify(row),
+            data: row
+          }));
+          graphStore.upsertEntities(type, entries);
+          for (const { id } of entries) graphStore.setEntityFetched(type, id);
+          const ids = entries.map(({ id }) => id);
+          if (cursor !== void 0) {
+            graphStore.appendListResult(rKey, ids, {
+              total: result.total,
+              nextCursor: typeof result.nextCursor === "string" ? result.nextCursor : null,
+              hasNextPage: result.nextCursor !== null && result.nextCursor !== void 0
+            });
+          } else {
+            graphStore.setListResult(rKey, ids, {
+              total: result.total,
+              nextCursor: typeof result.nextCursor === "string" ? result.nextCursor : null,
+              hasNextPage: result.nextCursor !== null && result.nextCursor !== void 0
+            });
+            graphStore.setListFetching(baseKey, false);
+          }
+        } catch (err) {
+          if (thisCount !== fetchCountRef.current) return;
+          if (controller.signal.aborted) return;
+          const typed = toEntityError(err);
+          if (typed instanceof TransientError && retries < maxRetries) {
+            await sleep3(retryBaseDelay * Math.pow(2, retries));
+            if (controller.signal.aborted) return;
+            return attempt(retries + 1);
+          }
+          const gs = useGraphStore.getState();
+          gs.setListError(rKey, typed.message, typed);
+          gs.setListError(baseKey, typed.message, typed);
+        } finally {
+          if (thisCount === fetchCountRef.current) setIsFetchingState(false);
+        }
+      };
+      void attempt(0);
     },
-    getStatus() {
-      return useGraphSyncStatusStore.getState().status;
+    [type, baseKey, engineOpts.defaultStaleTime, engineOpts.maxRetries, engineOpts.retryBaseDelay]
+  );
+  const debounceTimer = useRef(null);
+  useEffect(() => {
+    if (!enabled || completenessMode === "local" || !transport) return;
+    const searchQuery = liveView.search?.query ?? "";
+    const minChars = liveView.search?.minChars ?? 2;
+    if (searchQuery.length > 0 && searchQuery.length < minChars) return;
+    if (debounceTimer.current) clearTimeout(debounceTimer.current);
+    debounceTimer.current = setTimeout(
+      () => fireRemoteFetch(liveViewRef.current),
+      remoteDebounce
+    );
+    return () => {
+      if (debounceTimer.current) clearTimeout(debounceTimer.current);
+    };
+  }, [liveView, completenessMode, enabled, remoteDebounce]);
+  useEffect(() => {
+    if (!enabled || !transport) return;
+    const store = useGraphStore.getState();
+    const existing = store.lists[baseKey];
+    const effectiveStaleTime = transport.staleTime ?? engineOpts.defaultStaleTime;
+    const isStale = !existing?.lastFetched || existing.stale || Date.now() - (existing.lastFetched ?? 0) > effectiveStaleTime;
+    if (!existing || isStale) {
+      void fireRemoteFetch(liveViewRef.current);
     }
-  };
-}
-function cloneGraphSnapshot() {
-  const state = useGraphStore.getState();
-  return {
-    entities: structuredClone(state.entities),
-    patches: structuredClone(state.patches),
-    entityStates: structuredClone(state.entityStates),
-    syncMetadata: structuredClone(state.syncMetadata),
-    lists: structuredClone(state.lists)
-  };
-}
-function getDefaultOnlineSource() {
-  if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
-    return {
-      getIsOnline: () => window.navigator.onLine,
-      subscribe: (listener) => {
-        const onlineHandler = () => listener(true);
-        const offlineHandler = () => listener(false);
-        window.addEventListener("online", onlineHandler);
-        window.addEventListener("offline", offlineHandler);
-        return () => {
-          window.removeEventListener("online", onlineHandler);
-          window.removeEventListener("offline", offlineHandler);
-        };
+  }, [baseKey, enabled, fetchTick]);
+  useEffect(() => {
+    const unsub = useGraphStore.subscribe(
+      (state) => state.entities[type] ?? EMPTY_ENTITY_BUCKET,
+      (newEntities, prevEntities) => {
+        const view = liveViewRef.current;
+        const store = useGraphStore.getState();
+        const list = store.lists[baseKey];
+        if (!list) return;
+        for (const id of /* @__PURE__ */ new Set([
+          ...Object.keys(newEntities),
+          ...Object.keys(prevEntities)
+        ])) {
+          const isPresent = id in newEntities;
+          if (!isPresent) continue;
+          const entity = newEntities[id];
+          const merged = store.readEntitySnapshot(type, id) ?? entity;
+          const matchesCurrentView = (!view.filter || matchesFilter(merged, view.filter)) && (!view.search?.query || matchesSearch(merged, view.search.query, view.search.fields));
+          if (matchesCurrentView && !list.ids.includes(id)) {
+            if (view.sort && view.sort.length > 0) {
+              const idx = findInsertionIndex(
+                merged,
+                list.ids,
+                (eid) => store.readEntitySnapshot(type, eid),
+                view.sort
+              );
+              store.insertIdInList(baseKey, id, idx);
+            } else {
+              store.insertIdInList(baseKey, id, "start");
+            }
+          }
+        }
       }
-    };
-  }
+    );
+    return unsub;
+  }, [type, baseKey]);
+  useEffect(() => {
+    let tp;
+    try {
+      tp = getEntityTransport(type);
+    } catch {
+      return;
+    }
+    if (!tp.subscribe || !enabled) return;
+    const unsub = tp.subscribe((ev) => {
+      const store = useGraphStore.getState();
+      if (ev.op === "delete") {
+        store.removeIdFromAllLists(type, ev.id);
+        store.removeEntity(type, ev.id);
+      } else if (ev.row) {
+        store.upsertEntity(type, ev.id, ev.row);
+        store.setEntityFetched(type, ev.id);
+      }
+    });
+    return () => unsub();
+  }, [type, enabled]);
+  const setView = useCallback(
+    (partial) => setLiveView((prev) => ({ ...prev, ...partial })),
+    []
+  );
+  const setFilter = useCallback(
+    (filter) => setLiveView((prev) => ({ ...prev, filter: filter ?? void 0 })),
+    []
+  );
+  const setSort = useCallback(
+    (sort) => setLiveView((prev) => ({ ...prev, sort: sort ?? void 0 })),
+    []
+  );
+  const setSearch = useCallback(
+    (query) => setLiveView((prev) => ({
+      ...prev,
+      search: prev.search ? { ...prev.search, query } : { query, fields: [] }
+    })),
+    []
+  );
+  const clearView = useCallback(() => setLiveView(initialView), [initialView]);
+  const fetchNextPage = useCallback(() => {
+    if (completenessMode === "local" || isFetchingState) return;
+    const cursor = remoteListState?.nextCursor ?? void 0;
+    void fireRemoteFetch(liveViewRef.current, cursor ?? void 0);
+  }, [completenessMode, isFetchingState, remoteListState?.nextCursor, fireRemoteFetch]);
+  const refetch = useCallback(() => {
+    abortRef.current?.abort();
+    useGraphStore.getState().setListStale(baseKey, true);
+    setFetchTick((n) => n + 1);
+  }, [baseKey]);
+  const viewTotal = remoteListState?.total ?? (isComplete ? localViewIds.length : listState?.total ?? null);
+  const baseError = listState?.lastError ?? null;
+  const remoteError = remoteListState?.lastError ?? null;
+  const typedError = remoteError ?? baseError ?? null;
   return {
-    getIsOnline: () => true,
-    subscribe: () => () => {
-    }
+    items,
+    viewIds: localViewIds,
+    viewTotal,
+    isLoading: !enabled ? false : items.length === 0 && ((listState?.isFetching ?? false) || isFetchingState),
+    isFetching: (listState?.isFetching ?? false) || isFetchingState,
+    isFetchingMore: remoteListState?.isFetching ?? false,
+    isError: typedError !== null,
+    error: typedError,
+    hasNextPage: completenessMode === "local" ? false : remoteListState?.hasNextPage ?? listState?.hasNextPage ?? false,
+    fetchNextPage,
+    isShowingLocalPending: completenessMode === "hybrid" && isFetchingState && items.length > 0,
+    isLocallyComplete: isComplete,
+    completenessMode,
+    setView,
+    setFilter,
+    setSort,
+    setSearch,
+    clearView,
+    refetch
   };
 }
 
-// src/engine.ts
-function serializeKey(key) {
-  return JSON.stringify(key, (_, v) => v && typeof v === "object" && !Array.isArray(v) ? Object.fromEntries(Object.entries(v).sort()) : v);
-}
-function sleep(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-var inflight = /* @__PURE__ */ new Map();
-function dedupe(key, fn) {
-  if (inflight.has(key)) return inflight.get(key);
-  const p = fn().finally(() => inflight.delete(key));
-  inflight.set(key, p);
-  return p;
-}
-var subscriberStatsListeners = /* @__PURE__ */ new Set();
-function emitSubscriberStatsChange() {
-  for (const cb of subscriberStatsListeners) cb();
+// src/graph-query.ts
+function queryOnce(opts) {
+  const store = useGraphStore.getState();
+  const ids = resolveCandidateIds(store, opts);
+  let rows = ids.map((id) => store.readEntitySnapshot(opts.type, id)).filter((row) => row !== null);
+  if (opts.where) rows = rows.filter(opts.where);
+  if (opts.sort) rows = [...rows].sort(opts.sort);
+  const projected = rows.map((row) => applySelection(projectRow(row, opts.include, store), opts.select));
+  if (opts.id) return projected[0] ?? null;
+  return projected;
 }
-var subscribers = /* @__PURE__ */ new Map();
-function registerSubscriber(key) {
-  const token = Symbol(key);
-  if (!subscribers.has(key)) subscribers.set(key, /* @__PURE__ */ new Set());
-  subscribers.get(key).add(token);
-  emitSubscriberStatsChange();
-  return token;
+var selectGraph = queryOnce;
+function resolveCandidateIds(store, opts) {
+  if (opts.id) return [opts.id];
+  if (opts.ids) return opts.ids;
+  if (opts.listKey) return store.lists[opts.listKey]?.ids ?? [];
+  return Object.keys(store.entities[opts.type] ?? {});
 }
-function unregisterSubscriber(key, token) {
-  const set = subscribers.get(key);
-  if (!set) return;
-  set.delete(token);
-  if (set.size === 0) subscribers.delete(key);
-  emitSubscriberStatsChange();
+function projectRow(row, include, store) {
+  if (!include) return row;
+  const projected = { ...row };
+  for (const [key, relation] of Object.entries(include)) {
+    const related = resolveRelation(row, relation, store);
+    projected[key] = related;
+  }
+  return projected;
 }
-function hasSubscribers(key) {
-  return (subscribers.get(key)?.size ?? 0) > 0;
+function resolveRelation(entity, relation, store) {
+  const include = relation.include;
+  switch (relation.via.kind) {
+    case "field": {
+      const relatedId = entity[relation.via.field];
+      if (typeof relatedId !== "string") return null;
+      const related = store.readEntitySnapshot(relation.type, relatedId);
+      return related ? projectRow(related, include, store) : null;
+    }
+    case "array": {
+      const ids = entity[relation.via.field];
+      if (!Array.isArray(ids)) return [];
+      return ids.map((id) => typeof id === "string" ? store.readEntitySnapshot(relation.type, id) : null).filter((row) => row !== null).map((row) => projectRow(row, include, store));
+    }
+    case "list": {
+      const key = typeof relation.via.key === "function" ? relation.via.key(entity) : relation.via.key;
+      if (!key) return [];
+      const ids = store.lists[key]?.ids ?? [];
+      return ids.map((id) => store.readEntitySnapshot(relation.type, id)).filter((row) => row !== null).map((row) => projectRow(row, include, store));
+    }
+    case "resolver": {
+      const resolved = relation.via.resolve(entity, store);
+      if (Array.isArray(resolved)) {
+        return resolved.map((id) => store.readEntitySnapshot(relation.type, id)).filter((row) => row !== null).map((row) => projectRow(row, include, store));
+      }
+      if (typeof resolved !== "string") return null;
+      const related = store.readEntitySnapshot(relation.type, resolved);
+      return related ? projectRow(related, include, store) : null;
+    }
+  }
 }
-var DEFAULT_OPTIONS = {
-  defaultStaleTime: 3e4,
-  defaultGcTime: 3e5,
-  gcInterval: 6e4,
-  maxRetries: 3,
-  retryBaseDelay: 1e3,
-  revalidateOnFocus: true,
-  revalidateOnReconnect: true
-};
-var engineOptions = { ...DEFAULT_OPTIONS };
-function subscribeSubscriberStats(onChange) {
-  subscriberStatsListeners.add(onChange);
-  return () => subscriberStatsListeners.delete(onChange);
+function applySelection(row, select) {
+  if (!select) return row;
+  if (typeof select === "function") {
+    const result = select(row);
+    return result && typeof result === "object" ? result : { value: result };
+  }
+  const picked = {};
+  for (const key of select) {
+    if (key in row) picked[key] = row[key];
+  }
+  return picked;
 }
-function getActiveSubscriberCount() {
-  let n = 0;
-  for (const set of subscribers.values()) n += set.size;
-  return n;
+
+// src/graph-actions.ts
+var graphActionListeners = /* @__PURE__ */ new Set();
+var graphActionReplayers = /* @__PURE__ */ new Map();
+function createGraphTransaction() {
+  const baseline = cloneGraphData();
+  let closed = false;
+  const tx = {
+    upsertEntity(type, id, data) {
+      useGraphStore.getState().upsertEntity(type, id, data);
+      return tx;
+    },
+    replaceEntity(type, id, data) {
+      useGraphStore.getState().replaceEntity(type, id, data);
+      return tx;
+    },
+    removeEntity(type, id) {
+      useGraphStore.getState().removeEntity(type, id);
+      return tx;
+    },
+    patchEntity(type, id, patch) {
+      useGraphStore.getState().patchEntity(type, id, patch);
+      return tx;
+    },
+    clearPatch(type, id) {
+      useGraphStore.getState().clearPatch(type, id);
+      return tx;
+    },
+    insertIdInList(key, id, position) {
+      useGraphStore.getState().insertIdInList(key, id, position);
+      return tx;
+    },
+    removeIdFromAllLists(type, id) {
+      useGraphStore.getState().removeIdFromAllLists(type, id);
+      return tx;
+    },
+    setEntitySyncMetadata(type, id, metadata) {
+      useGraphStore.getState().setEntitySyncMetadata(type, id, metadata);
+      return tx;
+    },
+    markEntityPending(type, id, origin = "optimistic") {
+      useGraphStore.getState().setEntitySyncMetadata(type, id, {
+        synced: false,
+        origin,
+        updatedAt: Date.now()
+      });
+      return tx;
+    },
+    markEntitySynced(type, id, origin = "server") {
+      useGraphStore.getState().setEntitySyncMetadata(type, id, {
+        synced: true,
+        origin,
+        updatedAt: Date.now()
+      });
+      return tx;
+    },
+    commit() {
+      closed = true;
+    },
+    rollback() {
+      if (closed) return;
+      useGraphStore.setState(cloneGraphData(baseline));
+      closed = true;
+    },
+    snapshot() {
+      return cloneGraphData();
+    }
+  };
+  return tx;
 }
-var gcIntervalId = null;
-function runGarbageCollection() {
-  const store = useGraphStore.getState();
-  const { defaultGcTime: gcTime } = getEngineOptions();
-  const now = Date.now();
-  const toRemove = [];
-  for (const type of Object.keys(store.entities)) {
-    const bucket = store.entities[type];
-    if (!bucket) continue;
-    for (const id of Object.keys(bucket)) {
-      const key = `${type}:${id}`;
-      if (hasSubscribers(key)) continue;
-      const patch = store.patches[type]?.[id];
-      if (patch !== void 0 && Object.keys(patch).length > 0) continue;
-      const entityState = store.entityStates[key];
-      if (entityState?.isFetching) continue;
-      const lastFetched = entityState?.lastFetched;
-      if (lastFetched == null) continue;
-      if (now - lastFetched <= gcTime) continue;
-      toRemove.push({ type, id });
+function createGraphAction(opts) {
+  if (opts.key) {
+    graphActionReplayers.set(opts.key, async (record) => {
+      const tx = createGraphTransaction();
+      try {
+        const result = await opts.run(tx, record.input);
+        tx.commit();
+        return result;
+      } catch (error) {
+        tx.rollback();
+        throw error;
+      }
+    });
+  }
+  return async (input) => {
+    const tx = createGraphTransaction();
+    const record = opts.key ? {
+      id: `${opts.key}:${Date.now()}`,
+      key: opts.key,
+      input: structuredClone(input),
+      enqueuedAt: (/* @__PURE__ */ new Date()).toISOString()
+    } : null;
+    try {
+      if (record) emitGraphActionEvent({ type: "enqueued", record });
+      opts.optimistic?.(tx, input);
+      const result = await opts.run(tx, input);
+      opts.onSuccess?.(result, input, tx);
+      tx.commit();
+      if (record) emitGraphActionEvent({ type: "settled", record });
+      return result;
+    } catch (error) {
+      tx.rollback();
+      const normalized = error instanceof Error ? error : new Error(String(error));
+      if (record) emitGraphActionEvent({ type: "settled", record });
+      opts.onError?.(normalized, input);
+      throw normalized;
     }
-  }
-  for (const { type, id } of toRemove) {
-    store.removeEntity(type, id);
-    store.removeIdFromAllLists(type, id);
-  }
-}
-function stopGarbageCollector() {
-  if (gcIntervalId != null && typeof clearInterval !== "undefined") {
-    clearInterval(gcIntervalId);
-    gcIntervalId = null;
-  }
-}
-function startGarbageCollector() {
-  stopGarbageCollector();
-  if (typeof window === "undefined" || typeof setInterval === "undefined") return () => {
   };
-  gcIntervalId = setInterval(() => runGarbageCollection(), getEngineOptions().gcInterval);
-  return () => stopGarbageCollector();
-}
-function restartGarbageCollector() {
-  startGarbageCollector();
 }
-function configureEngine(opts) {
-  engineOptions = { ...DEFAULT_OPTIONS, ...opts };
-  restartGarbageCollector();
+function subscribeGraphActionEvents(listener) {
+  graphActionListeners.add(listener);
+  return () => graphActionListeners.delete(listener);
 }
-function getEngineOptions() {
-  return engineOptions;
+async function replayRegisteredGraphAction(record) {
+  const replayer = graphActionReplayers.get(record.key);
+  if (!replayer) throw new Error(`No graph action registered for key "${record.key}"`);
+  return replayer(record);
 }
-async function fetchEntity(opts, engineOpts) {
-  const { type, id, fetch: fetch2, normalize, sideEffects, idField = "id" } = opts;
-  if (!id) return;
-  useGraphStore.getState().setEntityFetching(type, id, true);
-  const attempt = async (retries) => {
-    try {
-      const raw = await fetch2(id);
-      const normalized = normalize(raw);
-      const resolvedId = normalized[idField] ?? id;
-      useGraphStore.getState().upsertEntity(type, resolvedId, normalized);
-      useGraphStore.getState().setEntityFetched(type, resolvedId);
-      if (sideEffects) sideEffects(raw, useGraphStore);
-      opts.onSuccess?.(normalized);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
-      }
-      useGraphStore.getState().setEntityError(type, id, error.message);
-      opts.onError?.(error);
-    }
+function cloneGraphData(source = useGraphStore.getState()) {
+  return {
+    entities: structuredClone(source.entities),
+    patches: structuredClone(source.patches),
+    entityStates: structuredClone(source.entityStates),
+    syncMetadata: structuredClone(source.syncMetadata),
+    lists: structuredClone(source.lists)
   };
-  await dedupe(`${type}:${id}`, () => attempt(0));
 }
-async function fetchList(opts, params, engineOpts, isLoadMore = false) {
-  const { type, queryKey, fetch: fetch2, normalize, sideEffects, mode = "replace" } = opts;
-  const key = serializeKey(queryKey);
-  const store = useGraphStore.getState();
-  if (isLoadMore) store.setListFetchingMore(key, true);
-  else store.setListFetching(key, true);
-  const attempt = async (retries) => {
-    try {
-      const response = await fetch2(params);
-      const normalized = response.items.map(normalize);
-      useGraphStore.getState().upsertEntities(type, normalized.map(({ id, data }) => ({ id, data })));
-      for (const { id } of normalized) useGraphStore.getState().setEntityFetched(type, id);
-      const ids = normalized.map(({ id }) => id);
-      const meta = { total: response.total ?? null, nextCursor: response.nextCursor ?? null, prevCursor: response.prevCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor, hasPrevPage: response.hasPrevPage ?? !!response.prevCursor, currentPage: response.page ?? null, pageSize: response.pageSize ?? null };
-      if (mode === "append" && isLoadMore) useGraphStore.getState().appendListResult(key, ids, meta);
-      else useGraphStore.getState().setListResult(key, ids, meta);
-      if (sideEffects) sideEffects(response.items, useGraphStore);
-      opts.onSuccess?.(response);
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (retries < engineOpts.maxRetries) {
-        await sleep(engineOpts.retryBaseDelay * Math.pow(2, retries));
-        return attempt(retries + 1);
+function emitGraphActionEvent(event) {
+  for (const listener of graphActionListeners) listener(event);
+}
+
+// src/graph-effects.ts
+function createGraphEffect(opts) {
+  const getKey = opts.getKey ?? defaultGetKey;
+  const isEqual = opts.isEqual ?? defaultIsEqual;
+  let initialized = false;
+  let previous = /* @__PURE__ */ new Map();
+  const evaluate = () => {
+    const nextValues = normalizeQueryResult(opts.query());
+    const next = /* @__PURE__ */ new Map();
+    nextValues.forEach((value, index) => {
+      next.set(getKey(value, index), value);
+    });
+    if (!initialized) {
+      initialized = true;
+      previous = next;
+      if (opts.skipInitial) return;
+    }
+    for (const [key, value] of next.entries()) {
+      const previousValue = previous.get(key);
+      if (previousValue === void 0) {
+        opts.onEnter?.({ key, value });
+        continue;
       }
-      useGraphStore.getState().setListError(key, error.message);
-      opts.onError?.(error);
+      if (!isEqual(previousValue, value)) {
+        opts.onUpdate?.({ key, value, previousValue });
+      }
+    }
+    for (const [key, previousValue] of previous.entries()) {
+      if (!next.has(key)) opts.onExit?.({ key, previousValue });
     }
+    previous = next;
   };
-  await dedupe(isLoadMore ? `${key}:more` : key, () => attempt(0));
-}
-var focusListenerAttached = false;
-function attachGlobalListeners() {
-  if (typeof window === "undefined" || focusListenerAttached) return;
-  focusListenerAttached = true;
-  restartGarbageCollector();
-  const revalidateAll = () => {
-    const state = useGraphStore.getState();
-    for (const key of subscribers.keys()) {
-      if (!hasSubscribers(key)) continue;
-      const colonIdx = key.indexOf(":");
-      if (colonIdx === -1) continue;
-      const type = key.slice(0, colonIdx);
-      const id = key.slice(colonIdx + 1);
-      state.setEntityStale(type, id, true);
+  evaluate();
+  const unsubscribe = useGraphStore.subscribe(() => {
+    evaluate();
+  });
+  return {
+    dispose: () => {
+      unsubscribe();
     }
   };
-  if (engineOptions.revalidateOnFocus) {
-    window.addEventListener("visibilitychange", () => {
-      if (document.visibilityState === "visible") revalidateAll();
-    });
-    window.addEventListener("focus", revalidateAll);
+}
+function normalizeQueryResult(value) {
+  if (value == null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function defaultGetKey(value, index) {
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.id === "string") return record.id;
+    if (typeof record.$key === "string") return record.$key;
   }
-  if (engineOptions.revalidateOnReconnect) window.addEventListener("online", revalidateAll);
+  return String(index);
 }
-function collectGraphDevStats(entities, patches, entityStates, listsState) {
-  const entityCounts = {};
-  let totalEntities = 0;
-  for (const type of Object.keys(entities)) {
-    const bucket = entities[type];
-    if (!bucket) continue;
-    const n = Object.keys(bucket).length;
-    if (n > 0) entityCounts[type] = n;
-    totalEntities += n;
+function defaultIsEqual(previousValue, nextValue) {
+  return JSON.stringify(previousValue) === JSON.stringify(nextValue);
+}
+
+// src/object-path.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getValueAtPath(source, path) {
+  if (!path) return source;
+  const segments = path.split(".").filter(Boolean);
+  let current = source;
+  for (const segment of segments) {
+    if (!isObject(current) && !Array.isArray(current)) return void 0;
+    current = current[segment];
   }
-  const listKeys = Object.keys(listsState);
-  const listCount = listKeys.length;
-  const patchedEntities = [];
-  for (const type of Object.keys(patches)) {
-    const bucket = patches[type];
-    if (!bucket) continue;
-    for (const id of Object.keys(bucket)) {
-      const p = bucket[id];
-      if (p && Object.keys(p).length > 0) patchedEntities.push({ type, id });
-    }
+  return current;
+}
+function setValueAtPath(source, path, value) {
+  const segments = path.split(".").filter(Boolean);
+  if (segments.length === 0) return source;
+  const clone = structuredClone(source);
+  let current = clone;
+  for (let index = 0; index < segments.length - 1; index += 1) {
+    const segment = segments[index];
+    const next = current[segment];
+    if (!isObject(next)) current[segment] = {};
+    current = current[segment];
   }
-  const staleEntities = [];
-  const fetchingEntities = [];
-  for (const key of Object.keys(entityStates)) {
-    const colon = key.indexOf(":");
-    if (colon === -1) continue;
-    const type = key.slice(0, colon);
-    const id = key.slice(colon + 1);
-    const es = entityStates[key];
-    if (es.stale) staleEntities.push({ type, id });
-    if (es.isFetching) fetchingEntities.push({ type, id });
+  current[segments[segments.length - 1]] = value;
+  return clone;
+}
+function collectDirtyPaths(current, original, prefix = "", acc = /* @__PURE__ */ new Set()) {
+  if (isObject(current) && isObject(original)) {
+    const keys = /* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(original)]);
+    for (const key of keys) {
+      const nextPrefix = prefix ? `${prefix}.${key}` : key;
+      collectDirtyPaths(current[key], original[key], nextPrefix, acc);
+    }
+    return acc;
   }
-  const lists = listKeys.map((key) => ({
-    key,
-    idCount: listsState[key]?.ids.length ?? 0,
-    isFetching: Boolean(listsState[key]?.isFetching || listsState[key]?.isFetchingMore),
-    isStale: Boolean(listsState[key]?.stale)
-  }));
-  return {
-    entityCounts,
-    totalEntities,
-    listCount,
-    patchedEntities,
-    staleEntities,
-    fetchingEntities,
-    lists
-  };
+  if (JSON.stringify(current) !== JSON.stringify(original) && prefix) acc.add(prefix);
+  return acc;
+}
+var schemaRegistry = /* @__PURE__ */ new Map();
+function registerEntityJsonSchema(config) {
+  const key = registryKey(config.entityType, config.field, config.schemaId);
+  schemaRegistry.set(key, config);
+}
+function registerRuntimeSchema(config) {
+  registerEntityJsonSchema(config);
+}
+function getEntityJsonSchema(opts) {
+  const exact = schemaRegistry.get(registryKey(opts.entityType, opts.field, opts.schemaId));
+  if (exact) return exact;
+  if (opts.field) {
+    const byField = schemaRegistry.get(registryKey(opts.entityType, opts.field));
+    if (byField) return byField;
+  }
+  if (opts.schemaId) {
+    const byId = schemaRegistry.get(registryKey(opts.entityType, void 0, opts.schemaId));
+    if (byId) return byId;
+  }
+  for (const schema of schemaRegistry.values()) {
+    if (schema.entityType !== opts.entityType) continue;
+    if (opts.field && schema.field !== opts.field) continue;
+    return schema;
+  }
+  return null;
 }
-function subscriberCountServerSnapshot() {
-  return 0;
+function useSchemaEntityFields(opts) {
+  return useMemo(() => {
+    const schema = opts.schema ?? getEntityJsonSchema(opts)?.schema;
+    if (!schema) return [];
+    return buildEntityFieldsFromSchema({ schema, rootField: opts.rootField ?? opts.field });
+  }, [opts.entityType, opts.field, opts.rootField, opts.schemaId, opts.schema]);
 }
-function useGraphDevTools() {
-  const subscriberCount = useSyncExternalStore(
-    subscribeSubscriberStats,
-    getActiveSubscriberCount,
-    subscriberCountServerSnapshot
-  );
-  const entities = useStore(useGraphStore, (state) => state.entities);
-  const patches = useStore(useGraphStore, (state) => state.patches);
-  const entityStates = useStore(useGraphStore, (state) => state.entityStates);
-  const listsState = useStore(useGraphStore, (state) => state.lists);
-  const graphPart = useMemo(
-    () => collectGraphDevStats(entities, patches, entityStates, listsState),
-    [entities, patches, entityStates, listsState]
+function buildEntityFieldsFromSchema(opts) {
+  return buildSchemaFields(opts.schema, opts.rootField ?? "", "");
+}
+function exportGraphSnapshotWithSchemas(opts) {
+  return JSON.stringify(
+    {
+      scope: opts.scope,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      data: opts.data,
+      schemas: opts.schemas.filter(Boolean)
+    },
+    null,
+    opts.pretty === false ? 0 : 2
   );
-  return { ...graphPart, subscriberCount };
 }
-var listenersAttached = false;
-function ensureListeners() {
-  if (!listenersAttached) {
-    attachGlobalListeners();
-    listenersAttached = true;
-  }
+function escapeHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
-function useEntity(opts) {
-  const { type, id, staleTime = getEngineOptions().defaultStaleTime, enabled = true } = opts;
-  ensureListeners();
-  const fetchRef = useRef(opts.fetch);
-  fetchRef.current = opts.fetch;
-  const normalizeRef = useRef(opts.normalize);
-  normalizeRef.current = opts.normalize;
-  const dataSelector = useCallback((state) => {
-    if (!id) return null;
-    return state.readEntitySnapshot(type, id);
-  }, [id, type]);
-  const data = useStore(useGraphStore, useShallow(dataSelector));
-  const entityState = useStore(useGraphStore, useCallback(
-    (state) => state.entityStates[`${type}:${id}`] ?? EMPTY_ENTITY_STATE,
-    [type, id]
-  ));
-  const doFetch = useCallback(() => {
-    if (!id || !enabled) return;
-    fetchEntity({ type, id, fetch: fetchRef.current, normalize: normalizeRef.current }, getEngineOptions());
-  }, [id, enabled, type]);
-  useEffect(() => {
-    if (!id || !enabled) return;
-    const token = registerSubscriber(`${type}:${id}`);
-    const state = useGraphStore.getState();
-    const existingState = state.entityStates[`${type}:${id}`];
-    const hasData = !!state.entities[type]?.[id];
-    const isStale = !existingState?.lastFetched || existingState.stale || Date.now() - (existingState.lastFetched ?? 0) > staleTime;
-    if (!hasData || isStale) doFetch();
-    return () => unregisterSubscriber(`${type}:${id}`, token);
-  }, [id, type, enabled, staleTime, doFetch]);
-  useEffect(() => {
-    if (entityState.stale && id && enabled && !entityState.isFetching) doFetch();
-  }, [entityState.stale, id, enabled, entityState.isFetching, doFetch]);
-  return { data, isLoading: !data && entityState.isFetching, isFetching: entityState.isFetching, error: entityState.error, isStale: entityState.stale, refetch: doFetch };
+function renderMarkdownToHtml(value) {
+  const escaped = escapeHtml(value);
+  const blocks = escaped.split(/\n{2,}/).map((block) => block.trim()).filter(Boolean);
+  return blocks.map((block) => renderMarkdownBlock(block)).join("");
 }
-function useEntityList(opts) {
-  const { type, queryKey, staleTime = getEngineOptions().defaultStaleTime, enabled = true, mode = "replace" } = opts;
-  ensureListeners();
-  const key = useMemo(() => serializeKey(queryKey), [queryKey]);
-  const fetchRef = useRef(opts.fetch);
-  fetchRef.current = opts.fetch;
-  const normalizeRef = useRef(opts.normalize);
-  normalizeRef.current = opts.normalize;
-  const listState = useStore(useGraphStore, useCallback((state) => state.lists[key] ?? EMPTY_LIST_STATE, [key]));
-  const itemsSelector = useCallback((state) => {
-    const ids = state.lists[key]?.ids ?? EMPTY_IDS;
-    return ids.map((id) => state.readEntitySnapshot(type, id)).filter((x) => x !== null);
-  }, [key, type]);
-  const items = useStore(useGraphStore, useShallow(itemsSelector));
-  const doFetch = useCallback((params = {}) => {
-    if (!enabled) return;
-    fetchList({ type, queryKey, mode, fetch: fetchRef.current, normalize: normalizeRef.current }, params, getEngineOptions(), false);
-  }, [enabled, type, queryKey, mode]);
-  const fetchNextPage = useCallback(() => {
-    if (!listState.hasNextPage || listState.isFetchingMore || !enabled) return;
-    fetchList({ type, queryKey, mode, fetch: fetchRef.current, normalize: normalizeRef.current }, { cursor: listState.nextCursor ?? void 0, page: (listState.currentPage ?? 0) + 1, pageSize: listState.pageSize ?? void 0 }, getEngineOptions(), true);
-  }, [listState.hasNextPage, listState.isFetchingMore, listState.nextCursor, listState.currentPage, listState.pageSize, enabled, type, queryKey, mode]);
-  useEffect(() => {
-    if (!enabled) return;
-    const state = useGraphStore.getState();
-    const existing = state.lists[key];
-    const isStale = !existing?.lastFetched || existing.stale || Date.now() - (existing.lastFetched ?? 0) > staleTime;
-    if (!existing || isStale) doFetch({ page: 1, pageSize: listState.pageSize ?? void 0 });
-  }, [key, enabled, staleTime, doFetch, listState.pageSize]);
-  useEffect(() => {
-    if (listState.stale && enabled && !listState.isFetching) doFetch();
-  }, [listState.stale, enabled, listState.isFetching, doFetch]);
-  return { items, ids: listState.ids, isLoading: listState.ids.length === 0 && listState.isFetching, isFetching: listState.isFetching, isFetchingMore: listState.isFetchingMore, error: listState.error, hasNextPage: listState.hasNextPage, hasPrevPage: listState.hasPrevPage, total: listState.total, currentPage: listState.currentPage, fetchNextPage, refetch: doFetch };
+function MarkdownFieldRenderer({ value, className }) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className,
+      dangerouslySetInnerHTML: { __html: renderMarkdownToHtml(value ?? "") }
+    }
+  );
 }
-function useEntityMutation(opts) {
-  const [state, setState] = useState({ isPending: false, isSuccess: false, isError: false, error: null });
-  const optsRef = useRef(opts);
-  optsRef.current = opts;
-  const mutate = useCallback(async (input) => {
-    const { type, mutate: apiFn, normalize, optimistic, invalidateLists, invalidateEntities, onSuccess, onError } = optsRef.current;
-    setState({ isPending: true, isSuccess: false, isError: false, error: null });
-    let rollback = null;
-    if (optimistic) {
-      const opt = optimistic(input);
-      if (opt) {
-        const { id, patch } = opt;
-        const store = useGraphStore.getState();
-        const previous = { ...store.patches[type]?.[id] };
-        const previousSync = store.syncMetadata[`${type}:${id}`];
-        store.patchEntity(type, id, patch);
-        store.setEntitySyncMetadata(type, id, { synced: false, origin: "optimistic", updatedAt: Date.now() });
-        rollback = () => {
-          const currentStore = useGraphStore.getState();
-          if (Object.keys(previous).length > 0) currentStore.patchEntity(type, id, previous);
-          else currentStore.clearPatch(type, id);
-          if (previousSync) currentStore.setEntitySyncMetadata(type, id, previousSync);
-          else currentStore.clearEntitySyncMetadata(type, id);
-        };
+function MarkdownFieldEditor({
+  value,
+  onChange,
+  placeholder
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col gap-2", children: [
+    /* @__PURE__ */ jsx(
+      "textarea",
+      {
+        value,
+        onChange: (event) => onChange(event.target.value),
+        placeholder,
+        className: "w-full min-h-[120px] rounded-md border bg-muted/50 px-3 py-2 text-sm resize-y focus:outline-none focus:ring-1 focus:ring-ring transition-colors"
       }
-    }
-    try {
-      const result = await apiFn(input);
-      if (normalize) {
-        const { id, data } = normalize(result, input);
-        const store = useGraphStore.getState();
-        store.upsertEntity(type, id, data);
-        store.setEntitySyncMetadata(type, id, { synced: true, origin: "server", updatedAt: Date.now() });
-        if (optimistic) {
-          const opt = optimistic(input);
-          if (opt) store.clearPatch(type, opt.id);
-        }
+    ),
+    /* @__PURE__ */ jsx("div", { className: "rounded-md border bg-background px-3 py-2", children: /* @__PURE__ */ jsx(MarkdownFieldRenderer, { value, className: "prose prose-sm max-w-none" }) })
+  ] });
+}
+function createMarkdownDetailRenderer(field) {
+  return (value, entity) => /* @__PURE__ */ jsx(MarkdownFieldRenderer, { value: String(value ?? getValueAtPath(entity, field) ?? ""), className: "prose prose-sm max-w-none" });
+}
+function buildSchemaFields(schema, pathPrefix, schemaPathPrefix) {
+  if (schema.type === "object" && schema.properties) {
+    const entries = Object.entries(schema.properties).sort(([, left], [, right]) => {
+      const l = left["x-display-order"] ?? Number.MAX_SAFE_INTEGER;
+      const r = right["x-display-order"] ?? Number.MAX_SAFE_INTEGER;
+      return l - r;
+    });
+    return entries.flatMap(([key, childSchema]) => {
+      if (childSchema["x-hidden"]) return [];
+      const field = pathPrefix ? `${pathPrefix}.${key}` : key;
+      const schemaPath = schemaPathPrefix ? `${schemaPathPrefix}.${key}` : key;
+      if (childSchema.type === "object" && childSchema.properties) {
+        return buildSchemaFields(childSchema, field, schemaPath);
       }
-      if (invalidateLists) for (const k of invalidateLists) useGraphStore.getState().invalidateLists(k);
-      if (invalidateEntities) for (const { type: t, id } of invalidateEntities) useGraphStore.getState().invalidateEntity(t, id);
-      setState({ isPending: false, isSuccess: true, isError: false, error: null });
-      onSuccess?.(result, input);
-      return result;
-    } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      rollback?.();
-      setState({ isPending: false, isSuccess: false, isError: true, error: error.message });
-      onError?.(error, input);
-      return null;
-    }
-  }, []);
-  const trigger = useCallback((input) => {
-    void mutate(input);
-  }, [mutate]);
-  const reset = useCallback(() => setState({ isPending: false, isSuccess: false, isError: false, error: null }), []);
-  return { mutate, trigger, reset, state };
+      return [schemaField(field, schemaPath, childSchema, schema.required?.includes(key) ?? false)];
+    });
+  }
+  return [];
+}
+function schemaField(field, schemaPath, schema, required) {
+  const type = inferFieldType(schema);
+  const descriptor = {
+    field,
+    label: schema.title ?? humanize(field.split(".").pop() ?? field),
+    type,
+    required,
+    hint: schema.description,
+    schemaPath,
+    schema,
+    componentHint: schema["x-a2ui-component"]
+  };
+  if (schema.enum) {
+    descriptor.options = schema.enum.map((value) => ({
+      value: String(value),
+      label: String(value)
+    }));
+  }
+  if (type === "markdown") {
+    descriptor.render = createMarkdownDetailRenderer(field);
+  }
+  return descriptor;
+}
+function inferFieldType(schema) {
+  const forced = schema["x-field-type"];
+  if (forced === "markdown") return "markdown";
+  if (schema.format === "markdown") return "markdown";
+  if (schema.enum) return "enum";
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  switch (type) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+    case "number":
+      return "number";
+    case "string":
+      if (schema.format === "email") return "email";
+      if (schema.format === "uri" || schema.format === "url") return "url";
+      if (schema.format === "date" || schema.format === "date-time") return "date";
+      return "text";
+    case "array":
+    case "object":
+      return "json";
+    default:
+      return "text";
+  }
 }
-function useEntityAugment(type, id) {
-  const patch = useStore(useGraphStore, useCallback((state) => id ? state.patches[type]?.[id] ?? null : null, [type, id]));
-  const augment = useCallback((fields) => {
-    if (!id) return;
-    useGraphStore.getState().patchEntity(type, id, fields);
-  }, [type, id]);
-  const unaugment = useCallback((keys) => {
-    if (!id) return;
-    useGraphStore.getState().unpatchEntity(type, id, keys);
-  }, [type, id]);
-  const clear = useCallback(() => {
-    if (!id) return;
-    useGraphStore.getState().clearPatch(type, id);
-  }, [type, id]);
-  return { patch, augment, unaugment, clear };
+function registryKey(entityType, field, schemaId) {
+  return `${entityType}::${field ?? "*"}::${schemaId ?? "*"}`;
 }
-var suspenseEntityPromises = /* @__PURE__ */ new Map();
-var suspenseListPromises = /* @__PURE__ */ new Map();
-function getEntitySuspensePromise(type, id) {
-  const key = `${type}:${id}`;
-  const existing = suspenseEntityPromises.get(key);
-  if (existing) return existing;
-  let unsub = null;
-  let settled = false;
-  const promise = new Promise((resolve, reject) => {
-    const settle = (fn) => {
-      if (settled) return;
-      settled = true;
-      unsub?.();
-      unsub = null;
-      fn();
-    };
-    const inspect = (state) => {
-      if (settled) return;
-      const hasData = !!state.entities[type]?.[id];
-      const es = state.entityStates[key];
-      if (hasData) settle(() => resolve());
-      else if (es != null && es.error != null && !es.isFetching) {
-        const msg = es.error;
-        settle(() => reject(new Error(msg)));
-      }
-    };
-    inspect(useGraphStore.getState());
-    if (!settled) unsub = useGraphStore.subscribe((state) => inspect(state));
-  });
-  const tracked = promise.finally(() => {
-    suspenseEntityPromises.delete(key);
+function humanize(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
+function renderMarkdownBlock(block) {
+  if (block.startsWith("# ")) return `<h1>${renderInlineMarkdown(block.slice(2))}</h1>`;
+  if (block.startsWith("## ")) return `<h2>${renderInlineMarkdown(block.slice(3))}</h2>`;
+  return `<p>${renderInlineMarkdown(block).replaceAll("\n", "<br/>")}</p>`;
+}
+function renderInlineMarkdown(block) {
+  return block.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+}
+
+// src/ai-interop.ts
+function exportGraphSnapshot(opts) {
+  const payload = {
+    scope: opts.scope,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    data: opts.data
+  };
+  return JSON.stringify(payload, null, opts.pretty === false ? 0 : 2);
+}
+function createGraphTool(handler) {
+  return (input) => handler(input, {
+    store: useGraphStore.getState(),
+    queryOnce,
+    exportGraphSnapshot
   });
-  suspenseEntityPromises.set(key, tracked);
-  return tracked;
 }
-function getListSuspensePromise(listKey) {
-  const existing = suspenseListPromises.get(listKey);
-  if (existing) return existing;
-  let unsub = null;
-  let settled = false;
-  const promise = new Promise((resolve, reject) => {
-    const settle = (fn) => {
-      if (settled) return;
-      settled = true;
-      unsub?.();
-      unsub = null;
-      fn();
-    };
-    const inspect = (state) => {
-      if (settled) return;
-      const list = state.lists[listKey] ?? EMPTY_LIST_STATE;
-      if (list.ids.length > 0) settle(() => resolve());
-      else if (list.error != null && !list.isFetching) {
-        const msg = list.error;
-        settle(() => reject(new Error(msg)));
-      } else if (list.ids.length === 0 && !list.isFetching && list.lastFetched != null) settle(() => resolve());
-    };
-    inspect(useGraphStore.getState());
-    if (!settled) unsub = useGraphStore.subscribe((state) => inspect(state));
+function createSchemaGraphTool(handler) {
+  return (input) => handler(input, {
+    store: useGraphStore.getState(),
+    queryOnce,
+    exportGraphSnapshot,
+    getEntityJsonSchema,
+    exportGraphSnapshotWithSchemas
   });
-  const tracked = promise.finally(() => {
-    suspenseListPromises.delete(listKey);
+}
+var DEFAULT_STORAGE_KEY = "prometheus:graph";
+var useGraphSyncStatusStore = create((set) => ({
+  status: {
+    phase: "idle",
+    isOnline: true,
+    isSynced: true,
+    pendingActions: 0,
+    lastHydratedAt: null,
+    lastPersistedAt: null,
+    storageKey: null,
+    error: null
+  },
+  setStatus: (status) => set((state) => ({
+    status: {
+      ...state.status,
+      ...status
+    }
+  }))
+}));
+var pendingActions = /* @__PURE__ */ new Map();
+function useGraphSyncStatus() {
+  return useGraphSyncStatusStore((state) => state.status);
+}
+async function persistGraphToStorage(opts) {
+  const payload = {
+    version: 1,
+    snapshot: cloneGraphSnapshot(),
+    pendingActions: opts.pendingActions ?? Array.from(pendingActions.values())
+  };
+  const json = JSON.stringify(payload);
+  await opts.storage.set(opts.key, json);
+  const persistedAt = (/* @__PURE__ */ new Date()).toISOString();
+  useGraphSyncStatusStore.getState().setStatus({
+    lastPersistedAt: persistedAt,
+    storageKey: opts.key,
+    pendingActions: payload.pendingActions.length
   });
-  suspenseListPromises.set(listKey, tracked);
-  return tracked;
+  return {
+    ok: true,
+    key: opts.key,
+    bytes: json.length,
+    persistedAt
+  };
 }
-function useSuspenseEntity(opts) {
-  const result = useEntity(opts);
-  const { type, id } = opts;
-  if (result.isLoading) {
-    if (!id) throw new Error("useSuspenseEntity requires a non-null entity id");
-    throw getEntitySuspensePromise(type, id);
-  }
-  if (result.error != null && result.data == null) {
-    throw new Error(result.error);
+async function hydrateGraphFromStorage(opts) {
+  const raw = await opts.storage.get(opts.key);
+  if (!raw) {
+    return {
+      ok: false,
+      key: opts.key,
+      hydratedAt: null,
+      entityCounts: {},
+      error: "No persisted graph snapshot found"
+    };
   }
-  if (result.data == null) {
-    throw new Error(!id ? "useSuspenseEntity requires a non-null entity id" : "Entity not found");
+  try {
+    const parsed = JSON.parse(raw);
+    useGraphStore.setState(parsed.snapshot);
+    pendingActions.clear();
+    for (const action of parsed.pendingActions ?? []) pendingActions.set(action.id, action);
+    const hydratedAt = (/* @__PURE__ */ new Date()).toISOString();
+    useGraphSyncStatusStore.getState().setStatus({
+      lastHydratedAt: hydratedAt,
+      storageKey: opts.key,
+      pendingActions: pendingActions.size,
+      error: null
+    });
+    return {
+      ok: true,
+      key: opts.key,
+      hydratedAt,
+      entityCounts: Object.fromEntries(
+        Object.entries(parsed.snapshot.entities).map(([type, entities]) => [type, Object.keys(entities).length])
+      ),
+      pendingActions: Array.from(pendingActions.values())
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    useGraphSyncStatusStore.getState().setStatus({
+      phase: "error",
+      error: message,
+      storageKey: opts.key
+    });
+    return {
+      ok: false,
+      key: opts.key,
+      hydratedAt: null,
+      entityCounts: {},
+      error: message
+    };
   }
+}
+function startLocalFirstGraph(opts) {
+  const key = opts.key ?? DEFAULT_STORAGE_KEY;
+  const persistDebounceMs = opts.persistDebounceMs ?? 50;
+  const statusStore = useGraphSyncStatusStore.getState();
+  statusStore.setStatus({
+    phase: "hydrating",
+    storageKey: key,
+    isOnline: opts.onlineSource?.getIsOnline() ?? getDefaultOnlineSource().getIsOnline(),
+    isSynced: pendingActions.size === 0,
+    error: null
+  });
+  let persistTimer = null;
+  const schedulePersist = () => {
+    if (persistTimer) clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+      void persistGraphToStorage({ storage: opts.storage, key });
+    }, persistDebounceMs);
+  };
+  const graphUnsub = useGraphStore.subscribe(() => {
+    schedulePersist();
+  });
+  const actionUnsub = subscribeGraphActionEvents((event) => {
+    if (event.type === "enqueued") pendingActions.set(event.record.id, event.record);
+    if (event.type === "settled") pendingActions.delete(event.record.id);
+    useGraphSyncStatusStore.getState().setStatus({
+      pendingActions: pendingActions.size,
+      isSynced: pendingActions.size === 0
+    });
+    schedulePersist();
+  });
+  const onlineSource = opts.onlineSource ?? getDefaultOnlineSource();
+  const onlineUnsub = onlineSource.subscribe((online) => {
+    useGraphSyncStatusStore.getState().setStatus({
+      isOnline: online,
+      phase: online ? "ready" : "offline"
+    });
+  });
+  const ready = (async () => {
+    const hydrated = await hydrateGraphFromStorage({ storage: opts.storage, key });
+    if (opts.replayPendingActions && hydrated.ok && pendingActions.size > 0) {
+      useGraphSyncStatusStore.getState().setStatus({
+        phase: "syncing",
+        isSynced: false
+      });
+      const policy = resolveRetryPolicy(opts.retryPolicy);
+      for (const action of Array.from(pendingActions.values())) {
+        await replayActionWithRetry(action, policy);
+        pendingActions.delete(action.id);
+      }
+      await persistGraphToStorage({ storage: opts.storage, key });
+    }
+    const online = onlineSource.getIsOnline();
+    useGraphSyncStatusStore.getState().setStatus({
+      phase: online ? "ready" : "offline",
+      isOnline: online,
+      isSynced: pendingActions.size === 0,
+      pendingActions: pendingActions.size
+    });
+  })();
   return {
-    data: result.data,
-    isFetching: result.isFetching,
-    isStale: result.isStale,
-    refetch: result.refetch
+    ready,
+    dispose() {
+      graphUnsub();
+      actionUnsub();
+      onlineUnsub();
+      if (persistTimer) clearTimeout(persistTimer);
+    },
+    async persistNow() {
+      await persistGraphToStorage({ storage: opts.storage, key });
+    },
+    hydrate() {
+      return hydrateGraphFromStorage({ storage: opts.storage, key });
+    },
+    getStatus() {
+      return useGraphSyncStatusStore.getState().status;
+    }
   };
 }
-function useSuspenseEntityList(opts) {
-  const key = useMemo(() => serializeKey(opts.queryKey), [opts.queryKey]);
-  const result = useEntityList(opts);
-  if (result.isLoading) throw getListSuspensePromise(key);
-  if (result.error != null && result.items.length === 0) {
-    throw new Error(result.error);
-  }
-  const { isLoading: _isLoading, ...rest } = result;
-  return rest;
-}
-
-// src/view/evaluator.ts
-function matchesFilter(entity, filter) {
-  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
-  return matchesGroup(entity, filter);
+function cloneGraphSnapshot() {
+  const state = useGraphStore.getState();
+  return {
+    entities: structuredClone(state.entities),
+    patches: structuredClone(state.patches),
+    entityStates: structuredClone(state.entityStates),
+    syncMetadata: structuredClone(state.syncMetadata),
+    lists: structuredClone(state.lists)
+  };
 }
-function matchesGroup(entity, group) {
-  const { logic, clauses } = group;
-  if (logic === "and") return clauses.every((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
-  return clauses.some((c) => "logic" in c ? matchesGroup(entity, c) : matchesClause(entity, c));
+function resolveRetryPolicy(policy) {
+  return {
+    maxAttempts: policy?.maxAttempts ?? 5,
+    initialDelayMs: policy?.initialDelayMs ?? 500,
+    maxDelayMs: policy?.maxDelayMs ?? 3e4,
+    backoffFactor: policy?.backoffFactor ?? 2,
+    jitter: policy?.jitter ?? "equal",
+    poisonHandler: policy?.poisonHandler
+  };
 }
-function matchesClause(entity, clause) {
-  const { field, op, value, predicate } = clause;
-  const fv = getNestedValue(entity, field);
-  switch (op) {
-    case "eq":
-      return fv === value;
-    case "neq":
-      return fv !== value;
-    case "gt":
-      return fv > value;
-    case "gte":
-      return fv >= value;
-    case "lt":
-      return fv < value;
-    case "lte":
-      return fv <= value;
-    case "in":
-      return Array.isArray(value) && value.includes(fv);
-    case "nin":
-      return Array.isArray(value) && !value.includes(fv);
-    case "isNull":
-      return fv == null;
-    case "isNotNull":
-      return fv != null;
-    case "contains":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().includes(value.toLowerCase());
-    case "startsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().startsWith(value.toLowerCase());
-    case "endsWith":
-      return typeof fv === "string" && typeof value === "string" && fv.toLowerCase().endsWith(value.toLowerCase());
-    case "between": {
-      const [lo, hi] = value;
-      return fv >= lo && fv <= hi;
-    }
-    case "arrayContains":
-      return Array.isArray(fv) && fv.includes(value);
-    case "arrayOverlaps":
-      return Array.isArray(fv) && Array.isArray(value) && value.some((v) => fv.includes(v));
-    case "matches":
-      return typeof fv === "string" && new RegExp(value).test(fv);
-    case "custom":
-      return predicate ? predicate(fv, entity) : true;
+function computeDelay(policy, attempt) {
+  const base = Math.min(
+    policy.initialDelayMs * Math.pow(policy.backoffFactor, Math.max(0, attempt - 1)),
+    policy.maxDelayMs
+  );
+  switch (policy.jitter) {
+    case "none":
+      return base;
+    case "full":
+      return Math.random() * base;
+    case "equal":
     default:
-      return true;
-  }
-}
-function matchesSearch(entity, query, fields) {
-  if (!query.trim()) return true;
-  const lq = query.toLowerCase();
-  return fields.some((field) => {
-    const v = getNestedValue(entity, field);
-    return typeof v === "string" && v.toLowerCase().includes(lq);
-  });
-}
-function compareEntities(a, b, sort) {
-  for (const clause of sort) {
-    const r = compareByClause(a, b, clause);
-    if (r !== 0) return r;
+      return base / 2 + Math.random() * (base / 2);
   }
-  return 0;
 }
-function compareByClause(a, b, clause) {
-  const { field, direction, nulls = "last", comparator } = clause;
-  const av = getNestedValue(a, field);
-  const bv = getNestedValue(b, field);
-  const aNull = av == null;
-  const bNull = bv == null;
-  if (aNull && bNull) return 0;
-  if (aNull) return nulls === "first" ? -1 : 1;
-  if (bNull) return nulls === "first" ? 1 : -1;
-  let cmp;
-  if (comparator) cmp = comparator(av, bv);
-  else if (typeof av === "string" && typeof bv === "string") cmp = av.localeCompare(bv, void 0, { sensitivity: "base", numeric: true });
-  else if (typeof av === "number" && typeof bv === "number") cmp = av - bv;
-  else cmp = String(av).localeCompare(String(bv));
-  return direction === "desc" ? -cmp : cmp;
+function sleep4(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((r) => setTimeout(r, ms));
 }
-function findInsertionIndex(entity, sortedIds, getEntity, sort) {
-  let lo = 0;
-  let hi = sortedIds.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    const me = getEntity(sortedIds[mid]);
-    if (!me) {
-      lo = mid + 1;
-      continue;
+async function replayActionWithRetry(action, policy) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= policy.maxAttempts; attempt++) {
+    try {
+      await replayRegisteredGraphAction(action);
+      return { ok: true };
+    } catch (error) {
+      lastError = error;
+      if (attempt >= policy.maxAttempts) break;
+      await sleep4(computeDelay(policy, attempt));
     }
-    if (compareEntities(entity, me, sort) <= 0) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
-}
-function applyView(ids, getEntity, filter, sort, search) {
-  let entries = [];
-  for (const id of ids) {
-    const entity = getEntity(id);
-    if (!entity) continue;
-    entries.push({ id, entity });
-  }
-  if (filter && entries.length > 0) entries = entries.filter(({ entity }) => matchesFilter(entity, filter));
-  if (search?.query) entries = entries.filter(({ entity }) => matchesSearch(entity, search.query, search.fields));
-  if (sort && sort.length > 0) entries.sort((a, b) => compareEntities(a.entity, b.entity, sort));
-  return entries.map((e) => e.id);
-}
-function checkCompleteness(loadedCount, total, hasNextPage) {
-  if (!hasNextPage && total !== null && loadedCount >= total) return { isComplete: true, reason: "all-loaded" };
-  if (hasNextPage) return { isComplete: false, reason: "has-more-pages" };
-  return { isComplete: true, reason: "no-more-pages" };
-}
-function getNestedValue(obj, path) {
-  const parts = path.replace(/\[(\d+)\]/g, ".$1").split(".");
-  let current = obj;
-  for (const part of parts) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[part];
   }
-  return current;
-}
-
-// src/view/prisma-compile.ts
-function nestWhereField(parts, leaf) {
-  if (parts.length === 0) return {};
-  if (parts.length === 1) return { [parts[0]]: leaf };
-  return { [parts[0]]: nestWhereField(parts.slice(1), leaf) };
-}
-function clauseToPrismaLeaf(c) {
-  switch (c.op) {
-    case "eq":
-      return { equals: c.value };
-    case "neq":
-      return { not: c.value };
-    case "gt":
-      return { gt: c.value };
-    case "gte":
-      return { gte: c.value };
-    case "lt":
-      return { lt: c.value };
-    case "lte":
-      return { lte: c.value };
-    case "contains":
-      return { contains: c.value, mode: "insensitive" };
-    case "startsWith":
-      return { startsWith: c.value, mode: "insensitive" };
-    case "endsWith":
-      return { endsWith: c.value, mode: "insensitive" };
-    case "in":
-      return { in: c.value };
-    case "nin":
-      return { notIn: c.value };
-    case "arrayContains":
-      return { has: c.value };
-    case "between":
-    case "arrayOverlaps":
-    case "matches":
-    case "custom":
-    default:
-      return null;
+  try {
+    await policy.poisonHandler?.(action, lastError);
+  } catch {
   }
+  return { ok: false, poisoned: true, error: lastError };
 }
-function clauseToPrismaEntry(c) {
-  const parts = c.field.split(".").filter(Boolean);
-  if (parts.length === 0) return null;
-  if (c.op === "isNull") {
-    const equalsNull = c.value === void 0 || c.value === true;
-    return nestWhereField(parts, equalsNull ? null : { not: null });
-  }
-  if (c.op === "isNotNull") {
-    return nestWhereField(parts, { not: null });
+function getDefaultOnlineSource() {
+  if (typeof window !== "undefined" && typeof window.addEventListener === "function") {
+    return {
+      getIsOnline: () => window.navigator.onLine,
+      subscribe: (listener) => {
+        const onlineHandler = () => listener(true);
+        const offlineHandler = () => listener(false);
+        window.addEventListener("online", onlineHandler);
+        window.addEventListener("offline", offlineHandler);
+        return () => {
+          window.removeEventListener("online", onlineHandler);
+          window.removeEventListener("offline", offlineHandler);
+        };
+      }
+    };
   }
-  const leaf = clauseToPrismaLeaf(c);
-  if (leaf === null) return null;
-  return nestWhereField(parts, leaf);
-}
-function groupToPrismaWhere(g) {
-  const parts = [];
-  for (const item of g.clauses) {
-    if ("logic" in item) {
-      const nested = groupToPrismaWhere(item);
-      if (Object.keys(nested).length > 0) parts.push(nested);
-    } else {
-      const entry = clauseToPrismaEntry(item);
-      if (entry) parts.push(entry);
+  return {
+    getIsOnline: () => true,
+    subscribe: () => () => {
     }
-  }
-  if (parts.length === 0) return {};
-  if (parts.length === 1) return parts[0];
-  return g.logic === "or" ? { OR: parts } : { AND: parts };
+  };
 }
-function toPrismaWhere(filter) {
-  if (Array.isArray(filter)) {
-    const parts = [];
-    for (const item of filter) {
-      const entry = clauseToPrismaEntry(item);
-      if (entry) parts.push(entry);
+function collectGraphDevStats(entities, patches, entityStates, listsState) {
+  const entityCounts = {};
+  let totalEntities = 0;
+  for (const type of Object.keys(entities)) {
+    const bucket = entities[type];
+    if (!bucket) continue;
+    const n = Object.keys(bucket).length;
+    if (n > 0) entityCounts[type] = n;
+    totalEntities += n;
+  }
+  const listKeys = Object.keys(listsState);
+  const listCount = listKeys.length;
+  const patchedEntities = [];
+  for (const type of Object.keys(patches)) {
+    const bucket = patches[type];
+    if (!bucket) continue;
+    for (const id of Object.keys(bucket)) {
+      const p = bucket[id];
+      if (p && Object.keys(p).length > 0) patchedEntities.push({ type, id });
     }
-    if (parts.length === 0) return {};
-    if (parts.length === 1) return parts[0];
-    return { AND: parts };
   }
-  return groupToPrismaWhere(filter);
+  const staleEntities = [];
+  const fetchingEntities = [];
+  for (const key of Object.keys(entityStates)) {
+    const colon = key.indexOf(":");
+    if (colon === -1) continue;
+    const type = key.slice(0, colon);
+    const id = key.slice(colon + 1);
+    const es = entityStates[key];
+    if (es.stale) staleEntities.push({ type, id });
+    if (es.isFetching) fetchingEntities.push({ type, id });
+  }
+  const lists = listKeys.map((key) => ({
+    key,
+    idCount: listsState[key]?.ids.length ?? 0,
+    isFetching: Boolean(listsState[key]?.isFetching || listsState[key]?.isFetchingMore),
+    isStale: Boolean(listsState[key]?.stale)
+  }));
+  return {
+    entityCounts,
+    totalEntities,
+    listCount,
+    patchedEntities,
+    staleEntities,
+    fetchingEntities,
+    lists
+  };
 }
-function toPrismaOrderBy(sort) {
-  return sort.map((s) => ({ [s.field]: s.direction }));
+function subscriberCountServerSnapshot() {
+  return 0;
 }
-
-// src/view/types.ts
-function toRestParams(view) {
-  const params = {};
-  if (view.filter) {
-    const clauses = flattenClauses(view.filter);
-    for (const c of clauses) {
-      if (c.op === "custom") continue;
-      const key = c.op === "eq" ? c.field : `${c.field}[${c.op}]`;
-      params[key] = Array.isArray(c.value) ? c.value.join(",") : String(c.value ?? "");
-    }
+function useGraphDevTools() {
+  const subscriberCount = useSyncExternalStore(
+    subscribeSubscriberStats,
+    getActiveSubscriberCount,
+    subscriberCountServerSnapshot
+  );
+  const entities = useStore(useGraphStore, (state) => state.entities);
+  const patches = useStore(useGraphStore, (state) => state.patches);
+  const entityStates = useStore(useGraphStore, (state) => state.entityStates);
+  const listsState = useStore(useGraphStore, (state) => state.lists);
+  const graphPart = useMemo(
+    () => collectGraphDevStats(entities, patches, entityStates, listsState),
+    [entities, patches, entityStates, listsState]
+  );
+  return { ...graphPart, subscriberCount };
+}
+var listenersAttached = false;
+function ensureListeners() {
+  if (!listenersAttached) {
+    attachGlobalListeners();
+    listenersAttached = true;
   }
-  if (view.sort) params["sort"] = view.sort.map((s) => `${s.direction === "desc" ? "-" : ""}${s.field}`).join(",");
-  if (view.search?.query) params["q"] = view.search.query;
-  return params;
 }
-function toSQLClauses(view) {
-  const params = [];
-  let paramIdx = 1;
-  function clauseToSQL(c) {
-    const col = `"${c.field}"`;
-    switch (c.op) {
-      case "eq":
-        params.push(c.value);
-        return `${col} = $${paramIdx++}`;
-      case "neq":
-        params.push(c.value);
-        return `${col} != $${paramIdx++}`;
-      case "gt":
-        params.push(c.value);
-        return `${col} > $${paramIdx++}`;
-      case "gte":
-        params.push(c.value);
-        return `${col} >= $${paramIdx++}`;
-      case "lt":
-        params.push(c.value);
-        return `${col} < $${paramIdx++}`;
-      case "lte":
-        params.push(c.value);
-        return `${col} <= $${paramIdx++}`;
-      case "in":
-        params.push(c.value);
-        return `${col} = ANY($${paramIdx++})`;
-      case "nin":
-        params.push(c.value);
-        return `${col} != ALL($${paramIdx++})`;
-      case "isNull":
-        return `${col} IS NULL`;
-      case "isNotNull":
-        return `${col} IS NOT NULL`;
-      case "contains":
-        params.push(`%${c.value}%`);
-        return `${col} ILIKE $${paramIdx++}`;
-      case "startsWith":
-        params.push(`${c.value}%`);
-        return `${col} ILIKE $${paramIdx++}`;
-      case "between": {
-        const [lo, hi] = c.value;
-        params.push(lo, hi);
-        return `${col} BETWEEN $${paramIdx++} AND $${paramIdx++}`;
+function useEntity(opts) {
+  const { type, id, staleTime = getEngineOptions().defaultStaleTime, enabled = true } = opts;
+  ensureListeners();
+  const fetchRef = useRef(opts.fetch);
+  fetchRef.current = opts.fetch;
+  const normalizeRef = useRef(opts.normalize);
+  normalizeRef.current = opts.normalize;
+  const dataSelector = useCallback((state) => {
+    if (!id) return null;
+    return state.readEntitySnapshot(type, id);
+  }, [id, type]);
+  const data = useStore(useGraphStore, useShallow(dataSelector));
+  const entityState = useStore(useGraphStore, useCallback(
+    (state) => state.entityStates[`${type}:${id}`] ?? EMPTY_ENTITY_STATE,
+    [type, id]
+  ));
+  const doFetch = useCallback(() => {
+    if (!id || !enabled) return;
+    fetchEntity({ type, id, fetch: fetchRef.current, normalize: normalizeRef.current }, getEngineOptions());
+  }, [id, enabled, type]);
+  useEffect(() => {
+    if (!id || !enabled) return;
+    const token = registerSubscriber(`${type}:${id}`);
+    const state = useGraphStore.getState();
+    const existingState = state.entityStates[`${type}:${id}`];
+    const hasData = !!state.entities[type]?.[id];
+    const isStale = !existingState?.lastFetched || existingState.stale || Date.now() - (existingState.lastFetched ?? 0) > staleTime;
+    if (!hasData || isStale) doFetch();
+    return () => unregisterSubscriber(`${type}:${id}`, token);
+  }, [id, type, enabled, staleTime, doFetch]);
+  useEffect(() => {
+    if (entityState.stale && id && enabled && !entityState.isFetching) doFetch();
+  }, [entityState.stale, id, enabled, entityState.isFetching, doFetch]);
+  return { data, isLoading: !data && entityState.isFetching, isFetching: entityState.isFetching, error: entityState.error, isStale: entityState.stale, refetch: doFetch };
+}
+function useEntityList(opts) {
+  console.warn(
+    `[entity-management] useEntityList("${String(opts.type)}") is deprecated in 2.0.
+Register a transport at boot: registerEntityTransport("${String(opts.type)}", makeRestTransport(...))
+Then replace this call with: useEntities<T>("${String(opts.type)}")`
+  );
+  const { type, queryKey, staleTime = getEngineOptions().defaultStaleTime, enabled = true, mode = "replace" } = opts;
+  ensureListeners();
+  const key = useMemo(() => serializeKey(queryKey), [queryKey]);
+  const fetchRef = useRef(opts.fetch);
+  fetchRef.current = opts.fetch;
+  const normalizeRef = useRef(opts.normalize);
+  normalizeRef.current = opts.normalize;
+  const listState = useStore(useGraphStore, useCallback((state) => state.lists[key] ?? EMPTY_LIST_STATE, [key]));
+  const itemsSelector = useCallback((state) => {
+    const ids = state.lists[key]?.ids ?? EMPTY_IDS;
+    return ids.map((id) => state.readEntitySnapshot(type, id)).filter((x) => x !== null);
+  }, [key, type]);
+  const items = useStore(useGraphStore, useShallow(itemsSelector));
+  const doFetch = useCallback((params = {}) => {
+    if (!enabled) return;
+    fetchList({ type, queryKey, mode, fetch: fetchRef.current, normalize: normalizeRef.current }, params, getEngineOptions(), false);
+  }, [enabled, type, queryKey, mode]);
+  const fetchNextPage = useCallback(() => {
+    if (!listState.hasNextPage || listState.isFetchingMore || !enabled) return;
+    fetchList({ type, queryKey, mode, fetch: fetchRef.current, normalize: normalizeRef.current }, { cursor: listState.nextCursor ?? void 0, page: (listState.currentPage ?? 0) + 1, pageSize: listState.pageSize ?? void 0 }, getEngineOptions(), true);
+  }, [listState.hasNextPage, listState.isFetchingMore, listState.nextCursor, listState.currentPage, listState.pageSize, enabled, type, queryKey, mode]);
+  useEffect(() => {
+    if (!enabled) return;
+    const state = useGraphStore.getState();
+    const existing = state.lists[key];
+    const isStale = !existing?.lastFetched || existing.stale || Date.now() - (existing.lastFetched ?? 0) > staleTime;
+    if (!existing || isStale) doFetch({ page: 1, pageSize: listState.pageSize ?? void 0 });
+  }, [key, enabled, staleTime, doFetch, listState.pageSize]);
+  useEffect(() => {
+    if (listState.stale && enabled && !listState.isFetching) doFetch();
+  }, [listState.stale, enabled, listState.isFetching, doFetch]);
+  return useMemo(
+    () => ({
+      items,
+      ids: listState.ids,
+      isLoading: listState.ids.length === 0 && listState.isFetching,
+      isFetching: listState.isFetching,
+      isFetchingMore: listState.isFetchingMore,
+      error: listState.error,
+      isError: listState.error !== null,
+      hasNextPage: listState.hasNextPage,
+      hasPrevPage: listState.hasPrevPage,
+      total: listState.total,
+      currentPage: listState.currentPage,
+      fetchNextPage,
+      refetch: doFetch
+    }),
+    [items, listState, fetchNextPage, doFetch]
+  );
+}
+function useEntityMutation(opts) {
+  const [state, setState] = useState({ isPending: false, isSuccess: false, isError: false, error: null });
+  const optsRef = useRef(opts);
+  optsRef.current = opts;
+  const mutate = useCallback(async (input) => {
+    const { type, mutate: apiFn, normalize, optimistic, invalidateLists, invalidateEntities, onSuccess, onError } = optsRef.current;
+    setState({ isPending: true, isSuccess: false, isError: false, error: null });
+    let rollback = null;
+    if (optimistic) {
+      const opt = optimistic(input);
+      if (opt) {
+        const { id, patch } = opt;
+        const store = useGraphStore.getState();
+        const previous = { ...store.patches[type]?.[id] };
+        const previousSync = store.syncMetadata[`${type}:${id}`];
+        store.patchEntity(type, id, patch);
+        store.setEntitySyncMetadata(type, id, { synced: false, origin: "optimistic", updatedAt: Date.now() });
+        rollback = () => {
+          const currentStore = useGraphStore.getState();
+          if (Object.keys(previous).length > 0) currentStore.patchEntity(type, id, previous);
+          else currentStore.clearPatch(type, id);
+          if (previousSync) currentStore.setEntitySyncMetadata(type, id, previousSync);
+          else currentStore.clearEntitySyncMetadata(type, id);
+        };
       }
-      case "arrayContains":
-        params.push(c.value);
-        return `$${paramIdx++} = ANY(${col})`;
-      default:
-        return "TRUE";
     }
+    try {
+      const result = await apiFn(input);
+      if (normalize) {
+        const { id, data } = normalize(result, input);
+        const store = useGraphStore.getState();
+        store.upsertEntity(type, id, data);
+        store.setEntitySyncMetadata(type, id, { synced: true, origin: "server", updatedAt: Date.now() });
+        if (optimistic) {
+          const opt = optimistic(input);
+          if (opt) store.clearPatch(type, opt.id);
+        }
+      }
+      if (invalidateLists) for (const k of invalidateLists) useGraphStore.getState().invalidateLists(k);
+      if (invalidateEntities) for (const { type: t, id } of invalidateEntities) useGraphStore.getState().invalidateEntity(t, id);
+      setState({ isPending: false, isSuccess: true, isError: false, error: null });
+      onSuccess?.(result, input);
+      return result;
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error(String(err));
+      rollback?.();
+      setState({ isPending: false, isSuccess: false, isError: true, error: error.message });
+      onError?.(error, input);
+      return null;
+    }
+  }, []);
+  const trigger = useCallback((input) => {
+    void mutate(input);
+  }, [mutate]);
+  const reset = useCallback(() => setState({ isPending: false, isSuccess: false, isError: false, error: null }), []);
+  return { mutate, trigger, reset, state };
+}
+function useEntityAugment(type, id) {
+  const patch = useStore(useGraphStore, useCallback((state) => id ? state.patches[type]?.[id] ?? null : null, [type, id]));
+  const augment = useCallback((fields) => {
+    if (!id) return;
+    useGraphStore.getState().patchEntity(type, id, fields);
+  }, [type, id]);
+  const unaugment = useCallback((keys) => {
+    if (!id) return;
+    useGraphStore.getState().unpatchEntity(type, id, keys);
+  }, [type, id]);
+  const clear = useCallback(() => {
+    if (!id) return;
+    useGraphStore.getState().clearPatch(type, id);
+  }, [type, id]);
+  return { patch, augment, unaugment, clear };
+}
+var suspenseEntityPromises = /* @__PURE__ */ new Map();
+var suspenseListPromises = /* @__PURE__ */ new Map();
+function getEntitySuspensePromise(type, id) {
+  const key = `${type}:${id}`;
+  const existing = suspenseEntityPromises.get(key);
+  if (existing) return existing;
+  let unsub = null;
+  let settled = false;
+  const promise = new Promise((resolve, reject) => {
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      unsub?.();
+      unsub = null;
+      fn();
+    };
+    const inspect = (state) => {
+      if (settled) return;
+      const hasData = !!state.entities[type]?.[id];
+      const es = state.entityStates[key];
+      if (hasData) settle(() => resolve());
+      else if (es != null && es.error != null && !es.isFetching) {
+        const msg = es.error;
+        settle(() => reject(new Error(msg)));
+      }
+    };
+    inspect(useGraphStore.getState());
+    if (!settled) unsub = useGraphStore.subscribe((state) => inspect(state));
+  });
+  const tracked = promise.finally(() => {
+    suspenseEntityPromises.delete(key);
+  });
+  suspenseEntityPromises.set(key, tracked);
+  return tracked;
+}
+function getListSuspensePromise(listKey) {
+  const existing = suspenseListPromises.get(listKey);
+  if (existing) return existing;
+  let unsub = null;
+  let settled = false;
+  const promise = new Promise((resolve, reject) => {
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      unsub?.();
+      unsub = null;
+      fn();
+    };
+    const inspect = (state) => {
+      if (settled) return;
+      const list = state.lists[listKey] ?? EMPTY_LIST_STATE;
+      if (list.ids.length > 0) settle(() => resolve());
+      else if (list.error != null && !list.isFetching) {
+        const msg = list.error;
+        settle(() => reject(new Error(msg)));
+      } else if (list.ids.length === 0 && !list.isFetching && list.lastFetched != null) settle(() => resolve());
+    };
+    inspect(useGraphStore.getState());
+    if (!settled) unsub = useGraphStore.subscribe((state) => inspect(state));
+  });
+  const tracked = promise.finally(() => {
+    suspenseListPromises.delete(listKey);
+  });
+  suspenseListPromises.set(listKey, tracked);
+  return tracked;
+}
+function useSuspenseEntity(opts) {
+  const result = useEntity(opts);
+  const { type, id } = opts;
+  if (result.isLoading) {
+    if (!id) throw new Error("useSuspenseEntity requires a non-null entity id");
+    throw getEntitySuspensePromise(type, id);
   }
-  function groupToSQL(g) {
-    const parts = g.clauses.map((c) => "logic" in c ? `(${groupToSQL(c)})` : clauseToSQL(c));
-    return parts.join(` ${g.logic.toUpperCase()} `);
-  }
-  let where = "TRUE";
-  if (view.filter) {
-    if (Array.isArray(view.filter)) where = view.filter.map(clauseToSQL).join(" AND ") || "TRUE";
-    else where = groupToSQL(view.filter) || "TRUE";
-  }
-  if (view.search?.query) {
-    params.push(`%${view.search.query}%`);
-    where += ` AND (${view.search.fields.map((f) => `"${f}"`).join(" || ' ' || ")}) ILIKE $${paramIdx++}`;
+  if (result.error != null && result.data == null) {
+    throw new Error(result.error);
   }
-  const orderBy = view.sort ? view.sort.map((s) => `"${s.field}" ${s.direction.toUpperCase()}${s.nulls ? ` NULLS ${s.nulls.toUpperCase()}` : ""}`).join(", ") : "";
-  return { where, orderBy, params };
-}
-function toGraphQLVariables(view) {
-  const result = {};
-  if (view.filter) {
-    const clauses = flattenClauses(view.filter);
-    const where = {};
-    for (const c of clauses) {
-      if (c.op === "custom") continue;
-      where[c.field] = { [`_${c.op}`]: c.value };
-    }
-    if (Object.keys(where).length) result.where = where;
+  if (result.data == null) {
+    throw new Error(!id ? "useSuspenseEntity requires a non-null entity id" : "Entity not found");
   }
-  if (view.sort) result.orderBy = view.sort.map((s) => ({ [s.field]: s.direction === "desc" ? "desc_nulls_last" : "asc_nulls_last" }));
-  if (view.search?.query) result.search = view.search.query;
-  return result;
+  return {
+    data: result.data,
+    isFetching: result.isFetching,
+    isStale: result.isStale,
+    refetch: result.refetch
+  };
 }
-function flattenClauses(filter) {
-  if (Array.isArray(filter)) return filter;
-  function walk(g) {
-    return g.clauses.flatMap((c) => "logic" in c ? walk(c) : [c]);
+function useSuspenseEntityList(opts) {
+  const key = useMemo(() => serializeKey(opts.queryKey), [opts.queryKey]);
+  const result = useEntityList(opts);
+  if (result.isLoading) throw getListSuspensePromise(key);
+  if (result.error != null && result.items.length === 0) {
+    throw new Error(result.error);
   }
-  return walk(filter);
-}
-function hasCustomPredicates(filter) {
-  return flattenClauses(filter).some((c) => c.op === "custom");
+  const { isLoading: _isLoading, ...rest } = result;
+  return rest;
 }
-
-// src/view/use-entity-view.ts
-var EMPTY_ENTITY_BUCKET = {};
+var EMPTY_ENTITY_BUCKET2 = {};
 function useEntityView(opts) {
+  console.warn(
+    `[entity-management] useEntityView("${String(opts.type)}") is deprecated in 2.0.
+Register a transport at boot: registerEntityTransport("${String(opts.type)}", makeRestTransport(...))
+Then replace this call with: useEntityQuery<T>("${String(opts.type)}", { view })`
+  );
   const { type, baseQueryKey, mode: forcedMode, remoteFetch, remoteDebounce = 300, staleTime = getEngineOptions().defaultStaleTime, enabled = true, initialIds, initialTotal } = opts;
   const optsRef = useRef(opts);
   optsRef.current = opts;
@@ -1783,11 +2515,9 @@ function useEntityView(opts) {
       );
     })
   );
-  const items = useStore(
-    useGraphStore,
-    useShallow(
-      (state) => localViewIds.map((id) => state.readEntitySnapshot(type, id)).filter((item) => item !== null)
-    )
+  const items = useMemo(
+    () => localViewIds.map((id) => useGraphStore.getState().readEntitySnapshot(type, id)).filter((item) => item !== null),
+    [localViewIds, type]
   );
   const fireRemoteFetch = useCallback(async (view, cursor) => {
     const { remoteFetch: rf, normalize: norm, baseQueryKey: bqk } = optsRef.current;
@@ -1799,16 +2529,19 @@ function useEntityView(opts) {
     setRemoteError(null);
     const store = useGraphStore.getState();
     store.setListFetching(rKey, true);
+    const baseKeyStr = serializeKey(bqk);
     try {
       const response = await rf(params);
       const normalized = norm ? response.items.map(norm) : response.items.map((item) => ({ id: String(item.id), data: item }));
-      store.upsertEntities(type, normalized);
+      store.upsertEntities(type, normalized.map(({ id, data }) => ({ id, data })));
       for (const { id } of normalized) store.setEntityFetched(type, id);
       store.setListResult(rKey, normalized.map(({ id }) => id), { total: response.total ?? null, nextCursor: response.nextCursor ?? null, hasNextPage: response.hasNextPage ?? !!response.nextCursor });
+      store.setListFetching(baseKeyStr, false);
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
       setRemoteError(msg);
       store.setListError(rKey, msg);
+      store.setListError(baseKeyStr, msg);
     } finally {
       setIsRemoteFetching(false);
     }
@@ -1832,7 +2565,7 @@ function useEntityView(opts) {
     if (!existing || isStale) fireRemoteFetch(liveViewRef.current);
   }, [baseKey, enabled, staleTime, fireRemoteFetch]);
   useEffect(() => {
-    const unsub = useGraphStore.subscribe((state) => state.entities[type] ?? EMPTY_ENTITY_BUCKET, (newEntities, prevEntities) => {
+    const unsub = useGraphStore.subscribe((state) => state.entities[type] ?? EMPTY_ENTITY_BUCKET2, (newEntities, prevEntities) => {
       const view = liveViewRef.current;
       const store = useGraphStore.getState();
       const list = store.lists[baseKey];
@@ -1864,15 +2597,17 @@ function useEntityView(opts) {
   }, [completenessMode, isRemoteFetching, remoteListState?.nextCursor, fireRemoteFetch]);
   const refetch = useCallback(() => fireRemoteFetch(liveViewRef.current), [fireRemoteFetch]);
   const viewTotal = remoteListState?.total ?? (isComplete ? localViewIds.length : listState?.total ?? null);
+  const error = remoteError ?? listState?.error ?? null;
   return {
     items,
     viewIds: localViewIds,
     viewTotal,
-    isLoading: items.length === 0 && (listState?.isFetching ?? true) && !isRemoteFetching,
+    isLoading: items.length === 0 && ((listState?.isFetching ?? false) || isRemoteFetching),
     isFetching: (listState?.isFetching ?? false) || isRemoteFetching,
     isRemoteFetching,
     isShowingLocalPending: completenessMode === "hybrid" && isRemoteFetching && items.length > 0,
-    error: remoteError ?? listState?.error ?? null,
+    error,
+    isError: error !== null,
     hasNextPage: completenessMode === "local" ? false : remoteListState?.hasNextPage ?? listState?.hasNextPage ?? false,
     fetchNextPage,
     isLocallyComplete: isComplete,
@@ -2816,6 +3551,255 @@ function usePGliteQuery(opts) {
   return { isLoading, error };
 }
 
+// src/adapters/electricsql-tenant.ts
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function assertUuid(companyId) {
+  if (typeof companyId !== "string" || !UUID_RE.test(companyId)) {
+    throw new Error(
+      `tenant-scoped adapter: companyId must be a UUID, received "${companyId}".`
+    );
+  }
+}
+function assertSafeColumn(column) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(column)) {
+    throw new Error(`tenant-scoped adapter: unsafe tenantColumn "${column}".`);
+  }
+}
+function buildTenantWhere(tenantColumn, companyId, tableLabel) {
+  if (typeof tenantColumn === "undefined") {
+    throw new Error(
+      `shape "${tableLabel}" lacks tenantColumn \u2014 tenant-scoped adapter refuses to attach unscoped shapes.`
+    );
+  }
+  assertUuid(companyId);
+  if (tenantColumn === null) {
+    return `id = '${companyId}'`;
+  }
+  assertSafeColumn(tenantColumn);
+  return `${tenantColumn} = '${companyId}'`;
+}
+function createTenantScopedElectricAdapter(opts) {
+  const { pglite, tenantClaim, tables, onSynced } = opts;
+  assertUuid(tenantClaim.companyId);
+  const wired = tables.map((tc) => {
+    const where = buildTenantWhere(tc.tenantColumn, tenantClaim.companyId, tc.table);
+    const shapeStream = tc.shapeStreamFactory({ table: tc.table, where, tenantClaim });
+    return {
+      type: tc.type,
+      table: tc.table,
+      where,
+      idColumn: tc.primaryKey?.[0] ?? "id",
+      normalize: tc.normalize,
+      shapeStream
+    };
+  });
+  return createElectricAdapter({ pglite, tables: wired, onSynced });
+}
+
+// src/adapters/pglite-persistence.ts
+var DEFAULT_TABLE = "_graph_snapshot";
+async function createPGlitePersistenceAdapter(pglite, options = {}) {
+  const tableName = options.tableName ?? DEFAULT_TABLE;
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(tableName)) {
+    throw new Error(`createPGlitePersistenceAdapter: invalid tableName "${tableName}"`);
+  }
+  await pglite.exec(
+    `CREATE TABLE IF NOT EXISTS ${tableName} (
+       key        TEXT        PRIMARY KEY,
+       value      TEXT        NOT NULL,
+       updated_at TIMESTAMPTZ NOT NULL DEFAULT now()
+     )`
+  );
+  return {
+    async get(key) {
+      const result = await pglite.query(
+        `SELECT value FROM ${tableName} WHERE key = $1`,
+        [key]
+      );
+      const row = result.rows[0];
+      return row?.value ?? null;
+    },
+    async set(key, value) {
+      await pglite.query(
+        `INSERT INTO ${tableName} (key, value, updated_at)
+         VALUES ($1, $2, now())
+         ON CONFLICT (key) DO UPDATE
+           SET value = EXCLUDED.value,
+               updated_at = now()`,
+        [key, value]
+      );
+    },
+    async remove(key) {
+      await pglite.query(`DELETE FROM ${tableName} WHERE key = $1`, [key]);
+    }
+  };
+}
+
+// src/schema-from-sql.ts
+function parseCreateTable(sql) {
+  const headerMatch = sql.match(
+    /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["]?([A-Za-z_][A-Za-z0-9_]*)["]?\s*\(([\s\S]*)\)\s*;?\s*$/im
+  );
+  if (!headerMatch) {
+    throw new Error("parseCreateTable: could not locate a CREATE TABLE block");
+  }
+  const tableName = headerMatch[1];
+  const body = headerMatch[2];
+  const columns = [];
+  for (const rawLine of splitTopLevelCommas(body)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    if (/^(?:PRIMARY\s+KEY|FOREIGN\s+KEY|UNIQUE|CHECK|CONSTRAINT|LIKE|EXCLUDE)\b/i.test(line)) {
+      continue;
+    }
+    const colMatch = line.match(/^["]?([A-Za-z_][A-Za-z0-9_]*)["]?\s+([A-Za-z][A-Za-z0-9_]*(?:\s*\([^)]*\))?(?:\s*\[\s*\])?)([\s\S]*)$/);
+    if (!colMatch) continue;
+    const name = colMatch[1];
+    const sqlType = colMatch[2].replace(/\s+/g, "").toUpperCase();
+    const rest = colMatch[3].toUpperCase();
+    const notNull = /\bNOT\s+NULL\b/.test(rest);
+    const hasDefault = /\bDEFAULT\b/.test(rest);
+    columns.push({ name, sqlType, notNull, hasDefault });
+  }
+  return { tableName, columns };
+}
+function splitTopLevelCommas(body) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of body) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function sqlTypeToJsonSchema(sqlType) {
+  const t = sqlType.replace(/\s+/g, "").toUpperCase();
+  if (/^TEXT\[\]$/.test(t)) {
+    return { schema: { type: "array", items: { type: "string" } } };
+  }
+  if (t === "UUID" || t === "TEXT" || /^VARCHAR(\(.*\))?$/.test(t) || /^CHAR(\(.*\))?$/.test(t)) {
+    return { schema: { type: "string" } };
+  }
+  if (t === "INTEGER" || t === "INT" || t === "BIGINT" || t === "SMALLINT" || t === "INT4" || t === "INT8" || t === "INT2") {
+    return { schema: { type: "integer" } };
+  }
+  if (/^NUMERIC(\(.*\))?$/.test(t) || /^DECIMAL(\(.*\))?$/.test(t) || t === "REAL" || t === "DOUBLEPRECISION" || t === "FLOAT") {
+    return { schema: { type: "number" } };
+  }
+  if (t === "BOOLEAN" || t === "BOOL") {
+    return { schema: { type: "boolean" } };
+  }
+  if (t === "TIMESTAMPTZ" || t === "TIMESTAMP" || t === "TIMESTAMPWITHTIMEZONE" || t === "TIMESTAMPWITHOUTTIMEZONE") {
+    return { schema: { type: "string", format: "date-time" } };
+  }
+  if (t === "DATE") {
+    return { schema: { type: "string", format: "date" } };
+  }
+  if (t === "JSONB" || t === "JSON") {
+    return { schema: { type: "object" } };
+  }
+  return {
+    schema: { type: "string" },
+    warning: `sql type "${sqlType}" not explicitly mapped; defaulting to string`
+  };
+}
+function deepMergeUnknown(base, override) {
+  const out = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const baseValue = base[key];
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && baseValue !== null && typeof baseValue === "object" && !Array.isArray(baseValue)) {
+      out[key] = deepMergeUnknown(
+        baseValue,
+        value
+      );
+    } else {
+      out[key] = value;
+    }
+  }
+  return out;
+}
+function mergeEntityConfig(generated, overrides) {
+  if (!overrides) return generated;
+  const merged = deepMergeUnknown(
+    generated,
+    overrides
+  );
+  const refined = merged;
+  return {
+    ...refined,
+    entityType: generated.entityType,
+    schema: refined.schema ?? generated.schema
+  };
+}
+function registerEntityFromSql(opts) {
+  const parsed = parseCreateTable(opts.createTableSql);
+  const properties = {};
+  const required = [];
+  for (const col of parsed.columns) {
+    const { schema, warning } = sqlTypeToJsonSchema(col.sqlType);
+    const propSchema = { ...schema };
+    if (warning) {
+      propSchema["x-warning"] = warning;
+    }
+    properties[col.name] = propSchema;
+    if (col.notNull && !col.hasDefault) {
+      required.push(col.name);
+    }
+  }
+  const generated = {
+    entityType: opts.entityType,
+    source: "runtime",
+    schema: {
+      type: "object",
+      title: parsed.tableName,
+      properties,
+      required
+    }
+  };
+  const config = mergeEntityConfig(generated, opts.overrides);
+  registerEntityJsonSchema(config);
+  return config;
+}
+function useEntityListAsTable(opts) {
+  const queryKey = opts.queryKey ?? ["entity-list-as-table", opts.type];
+  const list = useEntityList({
+    ...opts,
+    queryKey
+  });
+  const lastDataRef = useRef(null);
+  const data = useMemo(() => {
+    const prev = lastDataRef.current;
+    if (prev && prev.length === list.items.length) {
+      let same = true;
+      for (let i = 0; i < prev.length; i++) {
+        if (prev[i] !== list.items[i]) {
+          same = false;
+          break;
+        }
+      }
+      if (same) return prev;
+    }
+    lastDataRef.current = list.items;
+    return list.items;
+  }, [list.items]);
+  return {
+    data,
+    rowCount: list.total ?? list.ids.length,
+    isLoading: list.isLoading,
+    isFetching: list.isFetching,
+    error: list.error,
+    refetch: list.refetch
+  };
+}
+
 // src/graphql/client.ts
 async function executeGQL(cfg, document2, variables) {
   const headers = { "Content-Type": "application/json", ...cfg.headers?.() ?? {} };
@@ -2856,6 +3840,7 @@ var GQLClient = class {
   constructor(cfg) {
     this.cfg = cfg;
   }
+  cfg;
   async query(opts) {
     const key = opts.cacheKey ?? `gql:${opts.document.slice(0, 60)}:${JSON.stringify(opts.variables ?? {})}`;
     return dedupe(key, async () => {
@@ -6643,10 +7628,11 @@ function DefaultListItemContent({
   descriptor
 }) {
   if (!descriptor) {
-    const keys = Object.keys(item);
+    const rec = item;
+    const keys = Object.keys(rec);
     return /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
-      /* @__PURE__ */ jsx("p", { className: "truncate text-sm font-medium", children: String(item[keys[0]] ?? "") }),
-      keys[1] && /* @__PURE__ */ jsx("p", { className: "truncate text-xs text-muted-foreground", children: String(item[keys[1]] ?? "") })
+      /* @__PURE__ */ jsx("p", { className: "truncate text-sm font-medium", children: String(rec[keys[0]] ?? "") }),
+      keys[1] && /* @__PURE__ */ jsx("p", { className: "truncate text-xs text-muted-foreground", children: String(rec[keys[1]] ?? "") })
     ] });
   }
   const IconComponent = typeof descriptor.icon === "function" ? descriptor.icon : null;
@@ -8661,6 +9647,6 @@ function actionsColumn2() {
   };
 }
 
-export { ActionButtonRow, ActionDropdown, ColumnPresetDialog, DataTable, DataTableColumnHeader, DataTableFilter, DataTablePagination, DataTableToolbar, ElectricSQLAdapter as ElectricSQLPresetAdapter, EmptyState, EntityDetailSheet, EntityFormSheet, EntityListView, EntityTable, FilterPresetDialog, GQLClient, GalleryView, InlineCellEditor, InlineItemEditor, ListView, MarkdownFieldEditor, MarkdownFieldRenderer, MemoryAdapter, MultiSelectBar, PresetPicker, InlineCellEditor2 as PureInlineCellEditor, RealtimeManager, RestApiAdapter, SelectionContext, Sheet, SortHeader, SupabaseRealtimeAdapter as SupabasePresetAdapter, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, TableStorageProvider, ViewModeSwitcher, ZustandPersistAdapter, actionsColumn, applyView, booleanColumn, buildEntityFieldsFromSchema, cascadeInvalidation, checkCompleteness, compareEntities, configureEngine, createConvexAdapter, createElectricAdapter, createGQLClient, createGraphAction, createGraphEffect, createGraphQLSubscriptionAdapter, createGraphTool, createGraphTransaction, createPresetStore, createPrismaEntityConfig, createRow, createSchemaGraphTool, createSelectionStore, createSupabaseRealtimeAdapter, createWebSocketAdapter, dateColumn, dedupe, deleteAction, editAction, enumColumn, executeGQL, exportGraphSnapshot, exportGraphSnapshotWithSchemas, fetchEntity, fetchList, flattenClauses, getCoreRowModel2 as getCoreRowModel, getEntityJsonSchema, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getPaginatedRowModel, getRealtimeManager, getSchema, getSelectedRowModel, getSortedRowModel2 as getSortedRowModel, hasCustomPredicates, hydrateGraphFromStorage, matchesFilter, matchesSearch, normalizeGQLResponse, numberColumn, persistGraphToStorage, prismaRelationsToSchema, actionsColumn2 as pureActionsColumn, booleanColumn2 as pureBooleanColumn, dateColumn2 as pureDateColumn, enumColumn2 as pureEnumColumn, numberColumn2 as pureNumberColumn, selectionColumn2 as pureSelectionColumn, textColumn2 as pureTextColumn, queryOnce, readRelations, registerEntityJsonSchema, registerRuntimeSchema, registerSchema, renderMarkdownToHtml, resetRealtimeManager, selectGraph, selectionColumn, serializeKey, startGarbageCollector, startLocalFirstGraph, stopGarbageCollector, textColumn, toGraphQLVariables, toPrismaInclude, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses, useEntity, useEntityAugment, useEntityCRUD, useEntityList, useEntityMutation, useEntityView, useGQLEntity, useGQLList, useGQLMutation, useGQLSubscription, useGraphDevTools, useGraphStore, useGraphSyncStatus, useLocalFirst, usePGliteQuery, useSchemaEntityFields, useSelectionContext, useSelectionStore, useSuspenseEntity, useSuspenseEntityList, useTable, useTablePresets, useTableRealtimeMode, useTableStorageAdapter, viewAction };
+export { ActionButtonRow, ActionDropdown, ColumnPresetDialog, DataTable, DataTableColumnHeader, DataTableFilter, DataTablePagination, DataTableToolbar, ElectricSQLAdapter as ElectricSQLPresetAdapter, EmptyState, EntityDetailSheet, EntityFormSheet, EntityListView, EntityTable, FilterPresetDialog, GQLClient, GalleryView, InlineCellEditor, InlineItemEditor, ListView, MarkdownFieldEditor, MarkdownFieldRenderer, MemoryAdapter, MultiSelectBar, PresetPicker, InlineCellEditor2 as PureInlineCellEditor, RealtimeManager, RestApiAdapter, SelectionContext, Sheet, SortHeader, SupabaseRealtimeAdapter as SupabasePresetAdapter, Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow, TableStorageProvider, TerminalError, TransientError, ViewModeSwitcher, ZustandPersistAdapter, __resetEntityTransports, actionsColumn, applyView, booleanColumn, buildEntityFieldsFromSchema, buildTenantWhere, cascadeInvalidation, checkCompleteness, compareEntities, configureEngine, createConvexAdapter, createElectricAdapter, createGQLClient, createGraphAction, createGraphEffect, createGraphQLSubscriptionAdapter, createGraphTool, createGraphTransaction, createPGlitePersistenceAdapter, createPresetStore, createPrismaEntityConfig, createRow, createSchemaGraphTool, createSelectionStore, createSupabaseRealtimeAdapter, createTenantScopedElectricAdapter, createWebSocketAdapter, dateColumn, dedupe, deleteAction, editAction, enumColumn, executeGQL, exportGraphSnapshot, exportGraphSnapshotWithSchemas, fetchEntity, fetchList, flattenClauses, getCoreRowModel2 as getCoreRowModel, getEntityJsonSchema, getEntityTransport, getExpandedRowModel, getFacetedMinMaxValues, getFacetedRowModel, getFacetedUniqueValues, getFilteredRowModel, getGroupedRowModel, getPaginatedRowModel, getRealtimeManager, getRegisteredEntityTypes, getSchema, getSelectedRowModel, getSortedRowModel2 as getSortedRowModel, hasCustomPredicates, hydrateGraphFromStorage, makeRestTransport, matchesFilter, matchesSearch, normalizeGQLResponse, numberColumn, parseCreateTable, persistGraphToStorage, prismaRelationsToSchema, actionsColumn2 as pureActionsColumn, booleanColumn2 as pureBooleanColumn, dateColumn2 as pureDateColumn, enumColumn2 as pureEnumColumn, numberColumn2 as pureNumberColumn, selectionColumn2 as pureSelectionColumn, textColumn2 as pureTextColumn, queryOnce, readRelations, registerEntityFromSql, registerEntityJsonSchema, registerEntityTransport, registerRuntimeSchema, registerSchema, renderMarkdownToHtml, replayActionWithRetry, resetRealtimeManager, selectGraph, selectionColumn, serializeKey, sqlTypeToJsonSchema, startGarbageCollector, startLocalFirstGraph, stopGarbageCollector, textColumn, toEntityError, toGraphQLVariables, toPrismaInclude, toPrismaOrderBy, toPrismaWhere, toRestParams, toSQLClauses, useEntities, useEntity, useEntityAugment, useEntityCRUD, useEntityList, useEntityListAsTable, useEntityMutation, useEntityQuery, useEntityView, useGQLEntity, useGQLList, useGQLMutation, useGQLSubscription, useGraphDevTools, useGraphStore, useGraphSyncStatus, useLocalFirst, usePGliteQuery, useSchemaEntityFields, useSelectionContext, useSelectionStore, useSuspenseEntity, useSuspenseEntityList, useTable, useTablePresets, useTableRealtimeMode, useTableStorageAdapter, viewAction };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map