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

package/dist/index.js

@@ -1,11 +1,11 @@
 'use strict';
 
+var React6 = require('react');
 var zustand = require('zustand');
 var middleware = require('zustand/middleware');
 var immer = require('zustand/middleware/immer');
-var React6 = require('react');
-var jsxRuntime = require('react/jsx-runtime');
 var shallow = require('zustand/react/shallow');
+var jsxRuntime = require('react/jsx-runtime');
 var reactTable = require('@tanstack/react-table');
 var lucideReact = require('lucide-react');
 var clsx = require('clsx');
@@ -15,1730 +15,2462 @@ function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
 var React6__default = /*#__PURE__*/_interopDefault(React6);
 
-// 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 = zustand.create()(
-  middleware.subscribeWithSelector(
-    immer.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;
+  const clauses = flattenClauses(filter);
+  let b = builder;
+  for (const c of clauses) {
+    b = applyClause(b, c);
+  }
+  return b;
 }
-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];
+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;
   }
-  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);
+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;
+  }
+}
+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 });
     }
-    return acc;
   }
-  if (JSON.stringify(current) !== JSON.stringify(original) && prefix) acc.add(prefix);
-  return acc;
+  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 toEntityError(error);
 }
-var schemaRegistry = /* @__PURE__ */ new Map();
-function registerEntityJsonSchema(config) {
-  const key = registryKey(config.entityType, config.field, config.schemaId);
-  schemaRegistry.set(key, config);
+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 registerRuntimeSchema(config) {
-  registerEntityJsonSchema(config);
+function defaultSyncMetadata() {
+  return { ...EMPTY_SYNC_METADATA };
 }
-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 defaultListState() {
+  return { ...EMPTY_LIST_STATE, ids: [] };
 }
-function useSchemaEntityFields(opts) {
-  return React6.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 ek(type, id) {
+  return `${type}:${id}`;
 }
-function buildEntityFieldsFromSchema(opts) {
-  return buildSchemaFields(opts.schema, opts.rootField ?? "", "");
+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 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
-  );
+var useGraphStore = zustand.create()(
+  middleware.subscribeWithSelector(
+    immer.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 escapeHtml(input) {
-  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
 }
-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 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;
 }
-function MarkdownFieldRenderer({ value, className }) {
-  return /* @__PURE__ */ jsxRuntime.jsx(
-    "div",
-    {
-      className,
-      dangerouslySetInnerHTML: { __html: renderMarkdownToHtml(value ?? "") }
+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__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [
-    /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx("div", { className: "rounded-md border bg-background px-3 py-2", children: /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.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)];
+      useGraphStore.getState().setEntityError(type, id, error.message);
+      opts.onError?.(error);
+    }
+  };
+  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);
+      }
+      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 (engineOptions.revalidateOnFocus) {
+    window.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "visible") revalidateAll();
     });
+    window.addEventListener("focus", revalidateAll);
   }
-  return [];
+  if (engineOptions.revalidateOnReconnect) window.addEventListener("online", revalidateAll);
 }
-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"]
+
+// src/hooks/use-entities.ts
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+function useEntities(type, options = {}) {
+  const {
+    filter,
+    sort,
+    search,
+    limit,
+    cursor,
+    enabled = true
+  } = options;
+  const queryKey = React6.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 = React6.useRef(null);
+  const fetchCountRef = React6.useRef(0);
+  const [fetchTick, setFetchTick] = React6.useState(0);
+  const listState = zustand.useStore(
+    useGraphStore,
+    React6.useCallback((s) => s.lists[queryKey] ?? EMPTY_LIST_STATE, [queryKey])
+  );
+  const items = React6.useMemo(() => {
+    const state = useGraphStore.getState();
+    return listState.ids.map((id) => state.readEntity(type, id)).filter((item) => item !== null);
+  }, [listState.ids, type]);
+  React6.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]);
+  React6.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 = React6.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
   };
-  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";
+
+// src/view/evaluator.ts
+function matchesFilter(entity, filter) {
+  if (Array.isArray(filter)) return filter.every((clause) => matchesClause(entity, clause));
+  return matchesGroup(entity, filter);
+}
+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 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 "text";
+      return true;
   }
 }
-function registryKey(entityType, field, schemaId) {
-  return `${entityType}::${field ?? "*"}::${schemaId ?? "*"}`;
-}
-function humanize(value) {
-  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+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 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 compareEntities(a, b, sort) {
+  for (const clause of sort) {
+    const r = compareByClause(a, b, clause);
+    if (r !== 0) return r;
+  }
+  return 0;
 }
-function renderInlineMarkdown(block) {
-  return block.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+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;
 }
-
-// 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 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;
+    }
+    if (compareEntities(entity, me, sort) <= 0) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
 }
-function createGraphTool(handler) {
-  return (input) => handler(input, {
-    store: useGraphStore.getState(),
-    queryOnce,
-    exportGraphSnapshot
-  });
+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 createSchemaGraphTool(handler) {
-  return (input) => handler(input, {
-    store: useGraphStore.getState(),
-    queryOnce,
-    exportGraphSnapshot,
-    getEntityJsonSchema,
-    exportGraphSnapshotWithSchemas
-  });
+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" };
 }
-var DEFAULT_STORAGE_KEY = "prometheus:graph";
-var useGraphSyncStatusStore = zustand.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);
+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;
 }
-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
-  };
+
+// src/hooks/use-entity-query.ts
+function sleep3(ms) {
+  return new Promise((r) => setTimeout(r, ms));
 }
-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"
-    };
+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 = React6.useRef(opts);
+  optsRef.current = opts;
+  const [liveView, setLiveView] = React6.useState(initialView);
+  const liveViewRef = React6.useRef(liveView);
+  liveViewRef.current = liveView;
+  const abortRef = React6.useRef(null);
+  const fetchCountRef = React6.useRef(0);
+  const [fetchTick, setFetchTick] = React6.useState(0);
+  const [remoteResultKey, setRemoteResultKey] = React6.useState(null);
+  const [isFetchingState, setIsFetchingState] = React6.useState(false);
+  const baseKey = React6.useMemo(
+    () => serializeKey([type, "__base__"]),
+    [type]
+  );
+  const seededRef = React6.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 = zustand.useStore(
+    useGraphStore,
+    React6.useCallback((s) => s.lists[baseKey] ?? EMPTY_LIST_STATE, [baseKey])
+  );
+  const remoteListState = zustand.useStore(
+    useGraphStore,
+    React6.useCallback(
+      (s) => remoteResultKey ? s.lists[remoteResultKey] ?? null : null,
+      [remoteResultKey]
+    )
+  );
+  const { isComplete } = React6.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 = React6.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 = zustand.useStore(
+    useGraphStore,
+    shallow.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 = React6.useMemo(
+    () => localViewIds.map((id) => useGraphStore.getState().readEntitySnapshot(type, id)).filter((item) => item !== null),
+    [localViewIds, type]
+  );
+  const fireRemoteFetch = React6.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 = React6.useRef(null);
+  React6.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]);
+  React6.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]);
+  React6.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]);
+  React6.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 = React6.useCallback(
+    (partial) => setLiveView((prev) => ({ ...prev, ...partial })),
+    []
+  );
+  const setFilter = React6.useCallback(
+    (filter) => setLiveView((prev) => ({ ...prev, filter: filter ?? void 0 })),
+    []
+  );
+  const setSort = React6.useCallback(
+    (sort) => setLiveView((prev) => ({ ...prev, sort: sort ?? void 0 })),
+    []
+  );
+  const setSearch = React6.useCallback(
+    (query) => setLiveView((prev) => ({
+      ...prev,
+      search: prev.search ? { ...prev.search, query } : { query, fields: [] }
+    })),
+    []
+  );
+  const clearView = React6.useCallback(() => setLiveView(initialView), [initialView]);
+  const fetchNextPage = React6.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 = React6.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];
+  }
+  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 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 });
+  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;
   }
-  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
-  };
+  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 React6.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 = React6.useSyncExternalStore(
-    subscribeSubscriberStats,
-    getActiveSubscriberCount,
-    subscriberCountServerSnapshot
-  );
-  const entities = zustand.useStore(useGraphStore, (state) => state.entities);
-  const patches = zustand.useStore(useGraphStore, (state) => state.patches);
-  const entityStates = zustand.useStore(useGraphStore, (state) => state.entityStates);
-  const listsState = zustand.useStore(useGraphStore, (state) => state.lists);
-  const graphPart = React6.useMemo(
-    () => collectGraphDevStats(entities, patches, entityStates, listsState),
-    [entities, patches, entityStates, listsState]
-  );
-  return { ...graphPart, subscriberCount };
+function buildEntityFieldsFromSchema(opts) {
+  return buildSchemaFields(opts.schema, opts.rootField ?? "", "");
 }
-var listenersAttached = false;
-function ensureListeners() {
-  if (!listenersAttached) {
-    attachGlobalListeners();
-    listenersAttached = true;
-  }
+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 useEntity(opts) {
-  const { type, id, staleTime = getEngineOptions().defaultStaleTime, enabled = true } = opts;
-  ensureListeners();
-  const fetchRef = React6.useRef(opts.fetch);
-  fetchRef.current = opts.fetch;
-  const normalizeRef = React6.useRef(opts.normalize);
-  normalizeRef.current = opts.normalize;
-  const dataSelector = React6.useCallback((state) => {
-    if (!id) return null;
-    return state.readEntitySnapshot(type, id);
-  }, [id, type]);
-  const data = zustand.useStore(useGraphStore, shallow.useShallow(dataSelector));
-  const entityState = zustand.useStore(useGraphStore, React6.useCallback(
-    (state) => state.entityStates[`${type}:${id}`] ?? EMPTY_ENTITY_STATE,
-    [type, id]
-  ));
-  const doFetch = React6.useCallback(() => {
-    if (!id || !enabled) return;
-    fetchEntity({ type, id, fetch: fetchRef.current, normalize: normalizeRef.current }, getEngineOptions());
-  }, [id, enabled, type]);
-  React6.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]);
-  React6.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 escapeHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 }
-function useEntityList(opts) {
-  const { type, queryKey, staleTime = getEngineOptions().defaultStaleTime, enabled = true, mode = "replace" } = opts;
-  ensureListeners();
-  const key = React6.useMemo(() => serializeKey(queryKey), [queryKey]);
-  const fetchRef = React6.useRef(opts.fetch);
-  fetchRef.current = opts.fetch;
-  const normalizeRef = React6.useRef(opts.normalize);
-  normalizeRef.current = opts.normalize;
-  const listState = zustand.useStore(useGraphStore, React6.useCallback((state) => state.lists[key] ?? EMPTY_LIST_STATE, [key]));
-  const itemsSelector = React6.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 = zustand.useStore(useGraphStore, shallow.useShallow(itemsSelector));
-  const doFetch = React6.useCallback((params = {}) => {
-    if (!enabled) return;
-    fetchList({ type, queryKey, mode, fetch: fetchRef.current, normalize: normalizeRef.current }, params, getEngineOptions(), false);
-  }, [enabled, type, queryKey, mode]);
-  const fetchNextPage = React6.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]);
-  React6.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]);
-  React6.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 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 useEntityMutation(opts) {
-  const [state, setState] = React6.useState({ isPending: false, isSuccess: false, isError: false, error: null });
-  const optsRef = React6.useRef(opts);
-  optsRef.current = opts;
-  const mutate = React6.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);
-        };
-      }
-    }
-    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;
+function MarkdownFieldRenderer({ value, className }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className,
+      dangerouslySetInnerHTML: { __html: renderMarkdownToHtml(value ?? "") }
     }
-  }, []);
-  const trigger = React6.useCallback((input) => {
-    void mutate(input);
-  }, [mutate]);
-  const reset = React6.useCallback(() => setState({ isPending: false, isSuccess: false, isError: false, error: null }), []);
-  return { mutate, trigger, reset, state };
-}
-function useEntityAugment(type, id) {
-  const patch = zustand.useStore(useGraphStore, React6.useCallback((state) => id ? state.patches[type]?.[id] ?? null : null, [type, id]));
-  const augment = React6.useCallback((fields) => {
-    if (!id) return;
-    useGraphStore.getState().patchEntity(type, id, fields);
-  }, [type, id]);
-  const unaugment = React6.useCallback((keys) => {
-    if (!id) return;
-    useGraphStore.getState().unpatchEntity(type, id, keys);
-  }, [type, id]);
-  const clear = React6.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 MarkdownFieldEditor({
+  value,
+  onChange,
+  placeholder
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-2", children: [
+    /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx("div", { className: "rounded-md border bg-background px-3 py-2", children: /* @__PURE__ */ jsxRuntime.jsx(MarkdownFieldRenderer, { value, className: "prose prose-sm max-w-none" }) })
+  ] });
 }
-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 createMarkdownDetailRenderer(field) {
+  return (value, entity) => /* @__PURE__ */ jsxRuntime.jsx(MarkdownFieldRenderer, { value: String(value ?? getValueAtPath(entity, field) ?? ""), className: "prose prose-sm max-w-none" });
 }
-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 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);
+      }
+      return [schemaField(field, schemaPath, childSchema, schema.required?.includes(key) ?? false)];
+    });
   }
-  if (result.error != null && result.data == null) {
-    throw new Error(result.error);
+  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 (result.data == null) {
-    throw new Error(!id ? "useSuspenseEntity requires a non-null entity id" : "Entity not found");
+  if (type === "markdown") {
+    descriptor.render = createMarkdownDetailRenderer(field);
   }
-  return {
-    data: result.data,
-    isFetching: result.isFetching,
-    isStale: result.isStale,
-    refetch: result.refetch
-  };
+  return descriptor;
 }
-function useSuspenseEntityList(opts) {
-  const key = React6.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);
+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";
   }
-  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 registryKey(entityType, field, schemaId) {
+  return `${entityType}::${field ?? "*"}::${schemaId ?? "*"}`;
 }
-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 humanize(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
 }
-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 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 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 renderInlineMarkdown(block) {
+  return block.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
 }
-function compareEntities(a, b, sort) {
-  for (const clause of sort) {
-    const r = compareByClause(a, b, clause);
-    if (r !== 0) return r;
-  }
-  return 0;
+
+// 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 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 createGraphTool(handler) {
+  return (input) => handler(input, {
+    store: useGraphStore.getState(),
+    queryOnce,
+    exportGraphSnapshot
+  });
 }
-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;
+function createSchemaGraphTool(handler) {
+  return (input) => handler(input, {
+    store: useGraphStore.getState(),
+    queryOnce,
+    exportGraphSnapshot,
+    getEntityJsonSchema,
+    exportGraphSnapshotWithSchemas
+  });
+}
+var DEFAULT_STORAGE_KEY = "prometheus:graph";
+var useGraphSyncStatusStore = zustand.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
     }
-    if (compareEntities(entity, me, sort) <= 0) hi = mid;
-    else lo = mid + 1;
-  }
-  return lo;
+  }))
+}));
+var pendingActions = /* @__PURE__ */ new Map();
+function useGraphSyncStatus() {
+  return useGraphSyncStatusStore((state) => state.status);
 }
-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 });
+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
+  };
+}
+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"
+    };
+  }
+  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
+    };
   }
-  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 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 {
+    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 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;
+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)
+  };
 }
-
-// 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 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 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":
+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 null;
+      return base / 2 + Math.random() * (base / 2);
   }
 }
-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 });
-  }
-  const leaf = clauseToPrismaLeaf(c);
-  if (leaf === null) return null;
-  return nestWhereField(parts, leaf);
+function sleep4(ms) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((r) => setTimeout(r, ms));
 }
-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);
+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 (parts.length === 0) return {};
-  if (parts.length === 1) return parts[0];
-  return g.logic === "or" ? { OR: parts } : { AND: parts };
+  try {
+    await policy.poisonHandler?.(action, lastError);
+  } catch {
+  }
+  return { ok: false, poisoned: true, error: lastError };
 }
-function toPrismaWhere(filter) {
-  if (Array.isArray(filter)) {
-    const parts = [];
-    for (const item of filter) {
-      const entry = clauseToPrismaEntry(item);
-      if (entry) parts.push(entry);
+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);
+        };
+      }
+    };
+  }
+  return {
+    getIsOnline: () => true,
+    subscribe: () => () => {
     }
-    if (parts.length === 0) return {};
-    if (parts.length === 1) return parts[0];
-    return { AND: parts };
+  };
+}
+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;
   }
-  return groupToPrismaWhere(filter);
+  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 });
+    }
+  }
+  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 = React6.useSyncExternalStore(
+    subscribeSubscriberStats,
+    getActiveSubscriberCount,
+    subscriberCountServerSnapshot
+  );
+  const entities = zustand.useStore(useGraphStore, (state) => state.entities);
+  const patches = zustand.useStore(useGraphStore, (state) => state.patches);
+  const entityStates = zustand.useStore(useGraphStore, (state) => state.entityStates);
+  const listsState = zustand.useStore(useGraphStore, (state) => state.lists);
+  const graphPart = React6.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 = React6.useRef(opts.fetch);
+  fetchRef.current = opts.fetch;
+  const normalizeRef = React6.useRef(opts.normalize);
+  normalizeRef.current = opts.normalize;
+  const dataSelector = React6.useCallback((state) => {
+    if (!id) return null;
+    return state.readEntitySnapshot(type, id);
+  }, [id, type]);
+  const data = zustand.useStore(useGraphStore, shallow.useShallow(dataSelector));
+  const entityState = zustand.useStore(useGraphStore, React6.useCallback(
+    (state) => state.entityStates[`${type}:${id}`] ?? EMPTY_ENTITY_STATE,
+    [type, id]
+  ));
+  const doFetch = React6.useCallback(() => {
+    if (!id || !enabled) return;
+    fetchEntity({ type, id, fetch: fetchRef.current, normalize: normalizeRef.current }, getEngineOptions());
+  }, [id, enabled, type]);
+  React6.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]);
+  React6.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 = React6.useMemo(() => serializeKey(queryKey), [queryKey]);
+  const fetchRef = React6.useRef(opts.fetch);
+  fetchRef.current = opts.fetch;
+  const normalizeRef = React6.useRef(opts.normalize);
+  normalizeRef.current = opts.normalize;
+  const listState = zustand.useStore(useGraphStore, React6.useCallback((state) => state.lists[key] ?? EMPTY_LIST_STATE, [key]));
+  const itemsSelector = React6.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 = zustand.useStore(useGraphStore, shallow.useShallow(itemsSelector));
+  const doFetch = React6.useCallback((params = {}) => {
+    if (!enabled) return;
+    fetchList({ type, queryKey, mode, fetch: fetchRef.current, normalize: normalizeRef.current }, params, getEngineOptions(), false);
+  }, [enabled, type, queryKey, mode]);
+  const fetchNextPage = React6.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]);
+  React6.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]);
+  React6.useEffect(() => {
+    if (listState.stale && enabled && !listState.isFetching) doFetch();
+  }, [listState.stale, enabled, listState.isFetching, doFetch]);
+  return React6.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] = React6.useState({ isPending: false, isSuccess: false, isError: false, error: null });
+  const optsRef = React6.useRef(opts);
+  optsRef.current = opts;
+  const mutate = React6.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 = React6.useCallback((input) => {
+    void mutate(input);
+  }, [mutate]);
+  const reset = React6.useCallback(() => setState({ isPending: false, isSuccess: false, isError: false, error: null }), []);
+  return { mutate, trigger, reset, state };
+}
+function useEntityAugment(type, id) {
+  const patch = zustand.useStore(useGraphStore, React6.useCallback((state) => id ? state.patches[type]?.[id] ?? null : null, [type, id]));
+  const augment = React6.useCallback((fields) => {
+    if (!id) return;
+    useGraphStore.getState().patchEntity(type, id, fields);
+  }, [type, id]);
+  const unaugment = React6.useCallback((keys) => {
+    if (!id) return;
+    useGraphStore.getState().unpatchEntity(type, id, keys);
+  }, [type, id]);
+  const clear = React6.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 = React6.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 = React6.useRef(opts);
   optsRef.current = opts;
@@ -1803,16 +2535,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);
     }
@@ -1836,7 +2571,7 @@ function useEntityView(opts) {
     if (!existing || isStale) fireRemoteFetch(liveViewRef.current);
   }, [baseKey, enabled, staleTime, fireRemoteFetch]);
   React6.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];
@@ -1868,15 +2603,17 @@ function useEntityView(opts) {
   }, [completenessMode, isRemoteFetching, remoteListState?.nextCursor, fireRemoteFetch]);
   const refetch = React6.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,
@@ -2820,6 +3557,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 = React6.useRef(null);
+  const data = React6.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?.() ?? {} };
@@ -2860,6 +3846,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 () => {
@@ -6647,10 +7634,11 @@ function DefaultListItemContent({
   descriptor
 }) {
   if (!descriptor) {
-    const keys = Object.keys(item);
+    const rec = item;
+    const keys = Object.keys(rec);
     return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex-1 min-w-0", children: [
-      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "truncate text-sm font-medium", children: String(item[keys[0]] ?? "") }),
-      keys[1] && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "truncate text-xs text-muted-foreground", children: String(item[keys[1]] ?? "") })
+      /* @__PURE__ */ jsxRuntime.jsx("p", { className: "truncate text-sm font-medium", children: String(rec[keys[0]] ?? "") }),
+      keys[1] && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "truncate text-xs text-muted-foreground", children: String(rec[keys[1]] ?? "") })
     ] });
   }
   const IconComponent = typeof descriptor.icon === "function" ? descriptor.icon : null;
@@ -8706,12 +9694,16 @@ exports.TableHead = TableHead;
 exports.TableHeader = TableHeader;
 exports.TableRow = TableRow;
 exports.TableStorageProvider = TableStorageProvider;
+exports.TerminalError = TerminalError;
+exports.TransientError = TransientError;
 exports.ViewModeSwitcher = ViewModeSwitcher;
 exports.ZustandPersistAdapter = ZustandPersistAdapter;
+exports.__resetEntityTransports = __resetEntityTransports;
 exports.actionsColumn = actionsColumn;
 exports.applyView = applyView;
 exports.booleanColumn = booleanColumn;
 exports.buildEntityFieldsFromSchema = buildEntityFieldsFromSchema;
+exports.buildTenantWhere = buildTenantWhere;
 exports.cascadeInvalidation = cascadeInvalidation;
 exports.checkCompleteness = checkCompleteness;
 exports.compareEntities = compareEntities;
@@ -8724,12 +9716,14 @@ exports.createGraphEffect = createGraphEffect;
 exports.createGraphQLSubscriptionAdapter = createGraphQLSubscriptionAdapter;
 exports.createGraphTool = createGraphTool;
 exports.createGraphTransaction = createGraphTransaction;
+exports.createPGlitePersistenceAdapter = createPGlitePersistenceAdapter;
 exports.createPresetStore = createPresetStore;
 exports.createPrismaEntityConfig = createPrismaEntityConfig;
 exports.createRow = createRow;
 exports.createSchemaGraphTool = createSchemaGraphTool;
 exports.createSelectionStore = createSelectionStore;
 exports.createSupabaseRealtimeAdapter = createSupabaseRealtimeAdapter;
+exports.createTenantScopedElectricAdapter = createTenantScopedElectricAdapter;
 exports.createWebSocketAdapter = createWebSocketAdapter;
 exports.dateColumn = dateColumn;
 exports.dedupe = dedupe;
@@ -8744,6 +9738,7 @@ exports.fetchList = fetchList;
 exports.flattenClauses = flattenClauses;
 exports.getCoreRowModel = getCoreRowModel2;
 exports.getEntityJsonSchema = getEntityJsonSchema;
+exports.getEntityTransport = getEntityTransport;
 exports.getExpandedRowModel = getExpandedRowModel;
 exports.getFacetedMinMaxValues = getFacetedMinMaxValues;
 exports.getFacetedRowModel = getFacetedRowModel;
@@ -8752,15 +9747,18 @@ exports.getFilteredRowModel = getFilteredRowModel;
 exports.getGroupedRowModel = getGroupedRowModel;
 exports.getPaginatedRowModel = getPaginatedRowModel;
 exports.getRealtimeManager = getRealtimeManager;
+exports.getRegisteredEntityTypes = getRegisteredEntityTypes;
 exports.getSchema = getSchema;
 exports.getSelectedRowModel = getSelectedRowModel;
 exports.getSortedRowModel = getSortedRowModel2;
 exports.hasCustomPredicates = hasCustomPredicates;
 exports.hydrateGraphFromStorage = hydrateGraphFromStorage;
+exports.makeRestTransport = makeRestTransport;
 exports.matchesFilter = matchesFilter;
 exports.matchesSearch = matchesSearch;
 exports.normalizeGQLResponse = normalizeGQLResponse;
 exports.numberColumn = numberColumn;
+exports.parseCreateTable = parseCreateTable;
 exports.persistGraphToStorage = persistGraphToStorage;
 exports.prismaRelationsToSchema = prismaRelationsToSchema;
 exports.pureActionsColumn = actionsColumn2;
@@ -8772,29 +9770,37 @@ exports.pureSelectionColumn = selectionColumn2;
 exports.pureTextColumn = textColumn2;
 exports.queryOnce = queryOnce;
 exports.readRelations = readRelations;
+exports.registerEntityFromSql = registerEntityFromSql;
 exports.registerEntityJsonSchema = registerEntityJsonSchema;
+exports.registerEntityTransport = registerEntityTransport;
 exports.registerRuntimeSchema = registerRuntimeSchema;
 exports.registerSchema = registerSchema;
 exports.renderMarkdownToHtml = renderMarkdownToHtml;
+exports.replayActionWithRetry = replayActionWithRetry;
 exports.resetRealtimeManager = resetRealtimeManager;
 exports.selectGraph = selectGraph;
 exports.selectionColumn = selectionColumn;
 exports.serializeKey = serializeKey;
+exports.sqlTypeToJsonSchema = sqlTypeToJsonSchema;
 exports.startGarbageCollector = startGarbageCollector;
 exports.startLocalFirstGraph = startLocalFirstGraph;
 exports.stopGarbageCollector = stopGarbageCollector;
 exports.textColumn = textColumn;
+exports.toEntityError = toEntityError;
 exports.toGraphQLVariables = toGraphQLVariables;
 exports.toPrismaInclude = toPrismaInclude;
 exports.toPrismaOrderBy = toPrismaOrderBy;
 exports.toPrismaWhere = toPrismaWhere;
 exports.toRestParams = toRestParams;
 exports.toSQLClauses = toSQLClauses;
+exports.useEntities = useEntities;
 exports.useEntity = useEntity;
 exports.useEntityAugment = useEntityAugment;
 exports.useEntityCRUD = useEntityCRUD;
 exports.useEntityList = useEntityList;
+exports.useEntityListAsTable = useEntityListAsTable;
 exports.useEntityMutation = useEntityMutation;
+exports.useEntityQuery = useEntityQuery;
 exports.useEntityView = useEntityView;
 exports.useGQLEntity = useGQLEntity;
 exports.useGQLList = useGQLList;