@prometheus-ags/prometheus-entity-management 1.0.0 → 1.2.0

package/dist/index.js

@@ -3,17 +3,17 @@
 var zustand = require('zustand');
 var middleware = require('zustand/middleware');
 var immer = require('zustand/middleware/immer');
-var React5 = require('react');
+var React6 = require('react');
+var jsxRuntime = require('react/jsx-runtime');
 var shallow = require('zustand/react/shallow');
 var reactTable = require('@tanstack/react-table');
 var lucideReact = require('lucide-react');
 var clsx = require('clsx');
 var tailwindMerge = require('tailwind-merge');
-var jsxRuntime = require('react/jsx-runtime');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-var React5__default = /*#__PURE__*/_interopDefault(React5);
+var React6__default = /*#__PURE__*/_interopDefault(React6);
 
 // src/graph.ts
 var EMPTY_IDS = [];
@@ -23,6 +23,11 @@ var EMPTY_ENTITY_STATE = {
   error: null,
   stale: false
 };
+var EMPTY_SYNC_METADATA = {
+  synced: true,
+  origin: "server",
+  updatedAt: null
+};
 var EMPTY_LIST_STATE = {
   ids: EMPTY_IDS,
   total: null,
@@ -41,6 +46,9 @@ var EMPTY_LIST_STATE = {
 function defaultEntityState() {
   return { ...EMPTY_ENTITY_STATE };
 }
+function defaultSyncMetadata() {
+  return { ...EMPTY_SYNC_METADATA };
+}
 function defaultListState() {
   return { ...EMPTY_LIST_STATE, ids: [] };
 }
@@ -53,24 +61,33 @@ var useGraphStore = zustand.create()(
       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)
+        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] = {};
@@ -102,12 +119,20 @@ var useGraphStore = zustand.create()(
         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() };
@@ -179,11 +204,717 @@ var useGraphStore = zustand.create()(
         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;
+}
+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 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;
+}
+
+// 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;
+}
+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);
+}
+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 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;
+      }
+      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;
+  };
+  evaluate();
+  const unsubscribe = useGraphStore.subscribe(() => {
+    evaluate();
+  });
+  return {
+    dispose: () => {
+      unsubscribe();
+    }
+  };
+}
+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;
+  }
+  return String(index);
+}
+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];
+  }
+  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;
+  }
+  if (JSON.stringify(current) !== JSON.stringify(original) && prefix) acc.add(prefix);
+  return acc;
+}
+var schemaRegistry = /* @__PURE__ */ new Map();
+function registerEntityJsonSchema(config) {
+  const key = registryKey(config.entityType, config.field, config.schemaId);
+  schemaRegistry.set(key, config);
+}
+function registerRuntimeSchema(config) {
+  registerEntityJsonSchema(config);
+}
+function getEntityJsonSchema(opts) {
+  const exact = schemaRegistry.get(registryKey(opts.entityType, opts.field, opts.schemaId));
+  if (exact) return exact;
+  if (opts.field) {
+    const byField = schemaRegistry.get(registryKey(opts.entityType, opts.field));
+    if (byField) return byField;
+  }
+  if (opts.schemaId) {
+    const byId = schemaRegistry.get(registryKey(opts.entityType, void 0, opts.schemaId));
+    if (byId) return byId;
+  }
+  for (const schema of schemaRegistry.values()) {
+    if (schema.entityType !== opts.entityType) continue;
+    if (opts.field && schema.field !== opts.field) continue;
+    return schema;
+  }
+  return null;
+}
+function 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 buildEntityFieldsFromSchema(opts) {
+  return buildSchemaFields(opts.schema, opts.rootField ?? "", "");
+}
+function exportGraphSnapshotWithSchemas(opts) {
+  return JSON.stringify(
+    {
+      scope: opts.scope,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      data: opts.data,
+      schemas: opts.schemas.filter(Boolean)
+    },
+    null,
+    opts.pretty === false ? 0 : 2
+  );
+}
+function escapeHtml(input) {
+  return input.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+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 MarkdownFieldRenderer({ value, className }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      className,
+      dangerouslySetInnerHTML: { __html: renderMarkdownToHtml(value ?? "") }
+    }
+  );
+}
+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 createMarkdownDetailRenderer(field) {
+  return (value, entity) => /* @__PURE__ */ jsxRuntime.jsx(MarkdownFieldRenderer, { value: String(value ?? getValueAtPath(entity, field) ?? ""), className: "prose prose-sm max-w-none" });
+}
+function buildSchemaFields(schema, pathPrefix, schemaPathPrefix) {
+  if (schema.type === "object" && schema.properties) {
+    const entries = Object.entries(schema.properties).sort(([, left], [, right]) => {
+      const l = left["x-display-order"] ?? Number.MAX_SAFE_INTEGER;
+      const r = right["x-display-order"] ?? Number.MAX_SAFE_INTEGER;
+      return l - r;
+    });
+    return entries.flatMap(([key, childSchema]) => {
+      if (childSchema["x-hidden"]) return [];
+      const field = pathPrefix ? `${pathPrefix}.${key}` : key;
+      const schemaPath = schemaPathPrefix ? `${schemaPathPrefix}.${key}` : key;
+      if (childSchema.type === "object" && childSchema.properties) {
+        return buildSchemaFields(childSchema, field, schemaPath);
+      }
+      return [schemaField(field, schemaPath, childSchema, schema.required?.includes(key) ?? false)];
+    });
+  }
+  return [];
+}
+function schemaField(field, schemaPath, schema, required) {
+  const type = inferFieldType(schema);
+  const descriptor = {
+    field,
+    label: schema.title ?? humanize(field.split(".").pop() ?? field),
+    type,
+    required,
+    hint: schema.description,
+    schemaPath,
+    schema,
+    componentHint: schema["x-a2ui-component"]
+  };
+  if (schema.enum) {
+    descriptor.options = schema.enum.map((value) => ({
+      value: String(value),
+      label: String(value)
+    }));
+  }
+  if (type === "markdown") {
+    descriptor.render = createMarkdownDetailRenderer(field);
+  }
+  return descriptor;
+}
+function inferFieldType(schema) {
+  const forced = schema["x-field-type"];
+  if (forced === "markdown") return "markdown";
+  if (schema.format === "markdown") return "markdown";
+  if (schema.enum) return "enum";
+  const type = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  switch (type) {
+    case "boolean":
+      return "boolean";
+    case "integer":
+    case "number":
+      return "number";
+    case "string":
+      if (schema.format === "email") return "email";
+      if (schema.format === "uri" || schema.format === "url") return "url";
+      if (schema.format === "date" || schema.format === "date-time") return "date";
+      return "text";
+    case "array":
+    case "object":
+      return "json";
+    default:
+      return "text";
+  }
+}
+function 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 renderMarkdownBlock(block) {
+  if (block.startsWith("# ")) return `<h1>${renderInlineMarkdown(block.slice(2))}</h1>`;
+  if (block.startsWith("## ")) return `<h2>${renderInlineMarkdown(block.slice(3))}</h2>`;
+  return `<p>${renderInlineMarkdown(block).replaceAll("\n", "<br/>")}</p>`;
+}
+function renderInlineMarkdown(block) {
+  return block.replace(/\*\*(.+?)\*\*/g, "<strong>$1</strong>");
+}
+
+// src/ai-interop.ts
+function exportGraphSnapshot(opts) {
+  const payload = {
+    scope: opts.scope,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    data: opts.data
+  };
+  return JSON.stringify(payload, null, opts.pretty === false ? 0 : 2);
+}
+function createGraphTool(handler) {
+  return (input) => handler(input, {
+    store: useGraphStore.getState(),
+    queryOnce,
+    exportGraphSnapshot
+  });
+}
+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
+    }
+  }))
+}));
+var pendingActions = /* @__PURE__ */ new Map();
+function useGraphSyncStatus() {
+  return useGraphSyncStatusStore((state) => state.status);
+}
+async function persistGraphToStorage(opts) {
+  const payload = {
+    version: 1,
+    snapshot: cloneGraphSnapshot(),
+    pendingActions: opts.pendingActions ?? Array.from(pendingActions.values())
+  };
+  const json = JSON.stringify(payload);
+  await opts.storage.set(opts.key, json);
+  const persistedAt = (/* @__PURE__ */ new Date()).toISOString();
+  useGraphSyncStatusStore.getState().setStatus({
+    lastPersistedAt: persistedAt,
+    storageKey: opts.key,
+    pendingActions: payload.pendingActions.length
+  });
+  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
+    };
+  }
+}
+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);
+      }
+      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 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);
+        };
+      }
+    };
+  }
+  return {
+    getIsOnline: () => true,
+    subscribe: () => () => {
+    }
+  };
+}
+
 // 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);
@@ -420,7 +1151,7 @@ function subscriberCountServerSnapshot() {
   return 0;
 }
 function useGraphDevTools() {
-  const subscriberCount = React5.useSyncExternalStore(
+  const subscriberCount = React6.useSyncExternalStore(
     subscribeSubscriberStats,
     getActiveSubscriberCount,
     subscriberCountServerSnapshot
@@ -429,7 +1160,7 @@ function useGraphDevTools() {
   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 = React5.useMemo(
+  const graphPart = React6.useMemo(
     () => collectGraphDevStats(entities, patches, entityStates, listsState),
     [entities, patches, entityStates, listsState]
   );
@@ -445,26 +1176,23 @@ function ensureListeners() {
 function useEntity(opts) {
   const { type, id, staleTime = getEngineOptions().defaultStaleTime, enabled = true } = opts;
   ensureListeners();
-  const fetchRef = React5.useRef(opts.fetch);
+  const fetchRef = React6.useRef(opts.fetch);
   fetchRef.current = opts.fetch;
-  const normalizeRef = React5.useRef(opts.normalize);
+  const normalizeRef = React6.useRef(opts.normalize);
   normalizeRef.current = opts.normalize;
   const data = zustand.useStore(useGraphStore, shallow.useShallow((state) => {
     if (!id) return null;
-    const base = state.entities[type]?.[id];
-    if (!base) return null;
-    const patch = state.patches[type]?.[id];
-    return patch ? { ...base, ...patch } : base;
+    return state.readEntitySnapshot(type, id);
   }));
-  const entityState = zustand.useStore(useGraphStore, React5.useCallback(
+  const entityState = zustand.useStore(useGraphStore, React6.useCallback(
     (state) => state.entityStates[`${type}:${id}`] ?? EMPTY_ENTITY_STATE,
     [type, id]
   ));
-  const doFetch = React5.useCallback(() => {
+  const doFetch = React6.useCallback(() => {
     if (!id || !enabled) return;
     fetchEntity({ type, id, fetch: fetchRef.current, normalize: normalizeRef.current }, getEngineOptions());
   }, [id, enabled, type]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (!id || !enabled) return;
     const token = registerSubscriber(`${type}:${id}`);
     const state = useGraphStore.getState();
@@ -474,7 +1202,7 @@ function useEntity(opts) {
     if (!hasData || isStale) doFetch();
     return () => unregisterSubscriber(`${type}:${id}`, token);
   }, [id, type, enabled, staleTime, doFetch]);
-  React5.useEffect(() => {
+  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 };
@@ -482,49 +1210,44 @@ function useEntity(opts) {
 function useEntityList(opts) {
   const { type, queryKey, staleTime = getEngineOptions().defaultStaleTime, enabled = true, mode = "replace" } = opts;
   ensureListeners();
-  const key = React5.useMemo(() => serializeKey(queryKey), [queryKey]);
-  const fetchRef = React5.useRef(opts.fetch);
+  const key = React6.useMemo(() => serializeKey(queryKey), [queryKey]);
+  const fetchRef = React6.useRef(opts.fetch);
   fetchRef.current = opts.fetch;
-  const normalizeRef = React5.useRef(opts.normalize);
+  const normalizeRef = React6.useRef(opts.normalize);
   normalizeRef.current = opts.normalize;
-  const listState = zustand.useStore(useGraphStore, React5.useCallback((state) => state.lists[key] ?? EMPTY_LIST_STATE, [key]));
+  const listState = zustand.useStore(useGraphStore, React6.useCallback((state) => state.lists[key] ?? EMPTY_LIST_STATE, [key]));
   const items = zustand.useStore(
     useGraphStore,
     shallow.useShallow((state) => {
       const ids = state.lists[key]?.ids ?? EMPTY_IDS;
-      return ids.map((id) => {
-        const base = state.entities[type]?.[id];
-        if (!base) return null;
-        const patch = state.patches[type]?.[id];
-        return patch ? { ...base, ...patch } : base;
-      }).filter((x) => x !== null);
+      return ids.map((id) => state.readEntitySnapshot(type, id)).filter((x) => x !== null);
     })
   );
-  const doFetch = React5.useCallback((params = {}) => {
+  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 = React5.useCallback(() => {
+  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]);
-  React5.useEffect(() => {
+  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]);
-  React5.useEffect(() => {
+  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 useEntityMutation(opts) {
-  const [state, setState] = React5.useState({ isPending: false, isSuccess: false, isError: false, error: null });
-  const optsRef = React5.useRef(opts);
+  const [state, setState] = React6.useState({ isPending: false, isSuccess: false, isError: false, error: null });
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
-  const mutate = React5.useCallback(async (input) => {
+  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;
@@ -534,18 +1257,28 @@ function useEntityMutation(opts) {
         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);
-        rollback = () => Object.keys(previous).length > 0 ? useGraphStore.getState().patchEntity(type, id, previous) : useGraphStore.getState().clearPatch(type, id);
+        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);
-        useGraphStore.getState().upsertEntity(type, id, data);
+        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) useGraphStore.getState().clearPatch(type, opt.id);
+          if (opt) store.clearPatch(type, opt.id);
         }
       }
       if (invalidateLists) for (const k of invalidateLists) useGraphStore.getState().invalidateLists(k);
@@ -561,23 +1294,23 @@ function useEntityMutation(opts) {
       return null;
     }
   }, []);
-  const trigger = React5.useCallback((input) => {
+  const trigger = React6.useCallback((input) => {
     void mutate(input);
   }, [mutate]);
-  const reset = React5.useCallback(() => setState({ isPending: false, isSuccess: false, isError: false, error: null }), []);
+  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, React5.useCallback((state) => id ? state.patches[type]?.[id] ?? null : null, [type, id]));
-  const augment = React5.useCallback((fields) => {
+  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 = React5.useCallback((keys) => {
+  const unaugment = React6.useCallback((keys) => {
     if (!id) return;
     useGraphStore.getState().unpatchEntity(type, id, keys);
   }, [type, id]);
-  const clear = React5.useCallback(() => {
+  const clear = React6.useCallback(() => {
     if (!id) return;
     useGraphStore.getState().clearPatch(type, id);
   }, [type, id]);
@@ -670,7 +1403,7 @@ function useSuspenseEntity(opts) {
   };
 }
 function useSuspenseEntityList(opts) {
-  const key = React5.useMemo(() => serializeKey(opts.queryKey), [opts.queryKey]);
+  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) {
@@ -1008,17 +1741,17 @@ function hasCustomPredicates(filter) {
 var EMPTY_ENTITY_BUCKET = {};
 function useEntityView(opts) {
   const { type, baseQueryKey, mode: forcedMode, remoteFetch, remoteDebounce = 300, staleTime = getEngineOptions().defaultStaleTime, enabled = true, initialIds, initialTotal } = opts;
-  const optsRef = React5.useRef(opts);
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
-  const [liveView, setLiveView] = React5.useState(opts.view);
-  const liveViewRef = React5.useRef(liveView);
+  const [liveView, setLiveView] = React6.useState(opts.view);
+  const liveViewRef = React6.useRef(liveView);
   liveViewRef.current = liveView;
-  const [isRemoteFetching, setIsRemoteFetching] = React5.useState(false);
-  const [remoteError, setRemoteError] = React5.useState(null);
-  const [remoteResultKey, setRemoteResultKey] = React5.useState(null);
-  const debounceTimer = React5.useRef(null);
-  const baseKey = React5.useMemo(() => serializeKey(baseQueryKey), [baseQueryKey]);
-  const seededRef = React5.useRef(false);
+  const [isRemoteFetching, setIsRemoteFetching] = React6.useState(false);
+  const [remoteError, setRemoteError] = React6.useState(null);
+  const [remoteResultKey, setRemoteResultKey] = React6.useState(null);
+  const debounceTimer = React6.useRef(null);
+  const baseKey = React6.useMemo(() => serializeKey(baseQueryKey), [baseQueryKey]);
+  const seededRef = React6.useRef(false);
   if (!seededRef.current && initialIds && initialIds.length > 0) {
     seededRef.current = true;
     const store = useGraphStore.getState();
@@ -1028,14 +1761,14 @@ function useEntityView(opts) {
   }
   const listState = zustand.useStore(
     useGraphStore,
-    React5.useCallback((state) => state.lists[baseKey] ?? null, [baseKey])
+    React6.useCallback((state) => state.lists[baseKey] ?? null, [baseKey])
   );
-  const remoteListState = zustand.useStore(useGraphStore, React5.useCallback((state) => remoteResultKey ? state.lists[remoteResultKey] ?? null : null, [remoteResultKey]));
-  const { isComplete } = React5.useMemo(() => {
+  const remoteListState = zustand.useStore(useGraphStore, React6.useCallback((state) => remoteResultKey ? state.lists[remoteResultKey] ?? null : null, [remoteResultKey]));
+  const { isComplete } = React6.useMemo(() => {
     if (!listState) return { isComplete: false };
     return checkCompleteness(listState.ids.length, listState.total, listState.hasNextPage);
   }, [listState]);
-  const completenessMode = React5.useMemo(() => {
+  const completenessMode = React6.useMemo(() => {
     if (forcedMode) return forcedMode;
     if (liveView.filter && hasCustomPredicates(liveView.filter)) return "local";
     if (isComplete) return "local";
@@ -1047,12 +1780,7 @@ function useEntityView(opts) {
     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) => {
-        const base = state.entities[type]?.[id];
-        if (!base) return null;
-        const patch = state.patches[type]?.[id];
-        return patch ? { ...base, ...patch } : base;
-      };
+      const getEntity = (id) => state.readEntitySnapshot(type, id);
       return applyView(
         sourceIds,
         getEntity,
@@ -1065,15 +1793,10 @@ function useEntityView(opts) {
   const items = zustand.useStore(
     useGraphStore,
     shallow.useShallow(
-      (state) => localViewIds.map((id) => {
-        const base = state.entities[type]?.[id];
-        if (!base) return null;
-        const patch = state.patches[type]?.[id];
-        return patch ? { ...base, ...patch } : base;
-      }).filter((item) => item !== null)
+      (state) => localViewIds.map((id) => state.readEntitySnapshot(type, id)).filter((item) => item !== null)
     )
   );
-  const fireRemoteFetch = React5.useCallback(async (view, cursor) => {
+  const fireRemoteFetch = React6.useCallback(async (view, cursor) => {
     const { remoteFetch: rf, normalize: norm, baseQueryKey: bqk } = optsRef.current;
     if (!rf) return;
     const params = { rest: toRestParams(view), graphql: toGraphQLVariables(view), sql: toSQLClauses(view), view };
@@ -1097,7 +1820,7 @@ function useEntityView(opts) {
       setIsRemoteFetching(false);
     }
   }, [type]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (!enabled || completenessMode === "local" || !remoteFetch) return;
     const searchQuery = liveView.search?.query ?? "";
     const minChars = liveView.search?.minChars ?? 2;
@@ -1108,14 +1831,14 @@ function useEntityView(opts) {
       if (debounceTimer.current) clearTimeout(debounceTimer.current);
     };
   }, [liveView, completenessMode, enabled, remoteFetch, remoteDebounce, fireRemoteFetch]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (!enabled) return;
     const state = useGraphStore.getState();
     const existing = state.lists[baseKey];
     const isStale = !existing?.lastFetched || existing.stale || Date.now() - (existing.lastFetched ?? 0) > staleTime;
     if (!existing || isStale) fireRemoteFetch(liveViewRef.current);
   }, [baseKey, enabled, staleTime, fireRemoteFetch]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     const unsub = useGraphStore.subscribe((state) => state.entities[type] ?? EMPTY_ENTITY_BUCKET, (newEntities, prevEntities) => {
       const view = liveViewRef.current;
       const store = useGraphStore.getState();
@@ -1125,17 +1848,11 @@ function useEntityView(opts) {
         const isPresent = id in newEntities;
         if (!isPresent) continue;
         const entity = newEntities[id];
-        const patch = store.patches[type]?.[id];
-        const merged = patch ? { ...entity, ...patch } : entity;
+        const merged = store.readEntitySnapshot(type, id) ?? entity;
         const matches = (!view.filter || matchesFilter(merged, view.filter)) && (!view.search?.query || matchesSearch(merged, view.search.query, view.search.fields));
         if (matches && !list.ids.includes(id)) {
           if (view.sort && view.sort.length > 0) {
-            const idx = findInsertionIndex(merged, list.ids, (eid) => {
-              const b = store.entities[type]?.[eid];
-              if (!b) return null;
-              const p = store.patches[type]?.[eid];
-              return p ? { ...b, ...p } : b;
-            }, view.sort);
+            const idx = findInsertionIndex(merged, list.ids, (eid) => store.readEntitySnapshot(type, eid), view.sort);
             store.insertIdInList(baseKey, id, idx);
           } else store.insertIdInList(baseKey, id, "start");
         }
@@ -1143,16 +1860,16 @@ function useEntityView(opts) {
     });
     return unsub;
   }, [type, baseKey]);
-  const setView = React5.useCallback((partial) => setLiveView((prev) => ({ ...prev, ...partial })), []);
-  const setFilter = React5.useCallback((filter) => setLiveView((prev) => ({ ...prev, filter: filter ?? void 0 })), []);
-  const setSort = React5.useCallback((sort) => setLiveView((prev) => ({ ...prev, sort: sort ?? void 0 })), []);
-  const setSearch = React5.useCallback((query) => setLiveView((prev) => ({ ...prev, search: prev.search ? { ...prev.search, query } : { query, fields: [] } })), []);
-  const clearView = React5.useCallback(() => setLiveView({}), []);
-  const fetchNextPage = React5.useCallback(() => {
+  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({}), []);
+  const fetchNextPage = React6.useCallback(() => {
     if (completenessMode === "local" || isRemoteFetching) return;
     fireRemoteFetch(liveViewRef.current, remoteListState?.nextCursor ?? void 0);
   }, [completenessMode, isRemoteFetching, remoteListState?.nextCursor, fireRemoteFetch]);
-  const refetch = React5.useCallback(() => fireRemoteFetch(liveViewRef.current), [fireRemoteFetch]);
+  const refetch = React6.useCallback(() => fireRemoteFetch(liveViewRef.current), [fireRemoteFetch]);
   const viewTotal = remoteListState?.total ?? (isComplete ? localViewIds.length : listState?.total ?? null);
   return {
     items,
@@ -1178,15 +1895,15 @@ function useEntityView(opts) {
 }
 
 // src/crud/relations.ts
-var schemaRegistry = /* @__PURE__ */ new Map();
+var schemaRegistry2 = /* @__PURE__ */ new Map();
 function registerSchema(schema) {
-  schemaRegistry.set(schema.type, schema);
+  schemaRegistry2.set(schema.type, schema);
 }
 function getSchema(type) {
-  return schemaRegistry.get(type) ?? null;
+  return schemaRegistry2.get(type) ?? null;
 }
 function cascadeInvalidation(ctx) {
-  const schema = schemaRegistry.get(ctx.type);
+  const schema = schemaRegistry2.get(ctx.type);
   if (!schema) return;
   const store = useGraphStore.getState();
   if (schema.globalListKeys) for (const key of schema.globalListKeys) store.invalidateLists(key);
@@ -1213,7 +1930,7 @@ function cascadeInvalidation(ctx) {
       }
     }
   }
-  for (const [, otherSchema] of schemaRegistry) {
+  for (const [, otherSchema] of schemaRegistry2) {
     if (!otherSchema.relations) continue;
     for (const [, rel] of Object.entries(otherSchema.relations)) {
       if (rel.targetType !== ctx.type) continue;
@@ -1222,7 +1939,7 @@ function cascadeInvalidation(ctx) {
   }
 }
 function readRelations(type, entity) {
-  const schema = schemaRegistry.get(type);
+  const schema = schemaRegistry2.get(type);
   if (!schema?.relations) return {};
   const store = useGraphStore.getState();
   const result = {};
@@ -1252,15 +1969,15 @@ function readRelations(type, entity) {
 // src/crud/use-entity-crud.ts
 function useEntityCRUD(opts) {
   const { type, listQueryKey, listFetch, normalize, detailFetch, onCreate, onUpdate, onDelete, createDefaults = {}, initialView = {}, selectAfterCreate = true, clearSelectionAfterDelete = true } = opts;
-  const optsRef = React5.useRef(opts);
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
-  const [mode, setMode] = React5.useState("list");
-  const [selectedId, setSelectedId] = React5.useState(null);
-  const select = React5.useCallback((id) => {
+  const [mode, setMode] = React6.useState("list");
+  const [selectedId, setSelectedId] = React6.useState(null);
+  const select = React6.useCallback((id) => {
     setSelectedId(id);
     setMode(id ? "detail" : "list");
   }, []);
-  const openDetail = React5.useCallback((id) => {
+  const openDetail = React6.useCallback((id) => {
     setSelectedId(id);
     setMode("detail");
   }, []);
@@ -1276,28 +1993,25 @@ function useEntityCRUD(opts) {
     normalize: (raw) => raw,
     enabled: !!selectedId
   });
-  const relations = React5.useMemo(() => detail ? readRelations(type, detail) : {}, [type, detail]);
-  const [editBuffer, setEditBuffer] = React5.useState({});
-  const [isSaving, setIsSaving] = React5.useState(false);
-  const [saveError, setSaveError] = React5.useState(null);
-  React5.useEffect(() => {
+  const relations = React6.useMemo(() => detail ? readRelations(type, detail) : {}, [type, detail]);
+  const [editBuffer, setEditBuffer] = React6.useState({});
+  const [isSaving, setIsSaving] = React6.useState(false);
+  const [saveError, setSaveError] = React6.useState(null);
+  React6.useEffect(() => {
     if (detail) setEditBuffer({ ...detail });
   }, [selectedId]);
-  const setField = React5.useCallback((field, value) => setEditBuffer((prev) => ({ ...prev, [field]: value })), []);
-  const setFields = React5.useCallback((fields) => setEditBuffer((prev) => ({ ...prev, ...fields })), []);
-  const resetBuffer = React5.useCallback(() => {
+  const setField = React6.useCallback((field, value) => setEditBuffer((prev) => setValueAtPath(prev, String(field), value)), []);
+  const setFields = React6.useCallback((fields) => setEditBuffer((prev) => ({ ...prev, ...fields })), []);
+  const resetBuffer = React6.useCallback(() => {
     const current = selectedId ? useGraphStore.getState().readEntity(type, selectedId) : null;
     setEditBuffer(current ? { ...current } : {});
   }, [type, selectedId]);
-  const dirty = React5.useMemo(() => {
+  const dirty = React6.useMemo(() => {
     if (!detail) return { changed: /* @__PURE__ */ new Set(), isDirty: false };
-    const changed = /* @__PURE__ */ new Set();
-    for (const key of Object.keys(editBuffer)) {
-      if (JSON.stringify(editBuffer[key]) !== JSON.stringify(detail[key])) changed.add(key);
-    }
+    const changed = collectDirtyPaths(editBuffer, detail);
     return { changed, isDirty: changed.size > 0 };
   }, [editBuffer, detail]);
-  const startEdit = React5.useCallback((id) => {
+  const startEdit = React6.useCallback((id) => {
     const targetId = id ?? selectedId;
     if (targetId) {
       setSelectedId(targetId);
@@ -1306,32 +2020,40 @@ function useEntityCRUD(opts) {
     }
     setMode("edit");
   }, [selectedId, type]);
-  const cancelEdit = React5.useCallback(() => {
+  const cancelEdit = React6.useCallback(() => {
     resetBuffer();
     setMode(selectedId ? "detail" : "list");
     setSaveError(null);
   }, [resetBuffer, selectedId]);
-  const applyOptimistic = React5.useCallback(() => {
+  const applyOptimistic = React6.useCallback(() => {
     if (!selectedId) return;
-    useGraphStore.getState().patchEntity(type, selectedId, editBuffer);
+    const store = useGraphStore.getState();
+    store.patchEntity(type, selectedId, editBuffer);
+    store.setEntitySyncMetadata(type, selectedId, { synced: false, origin: "optimistic", updatedAt: Date.now() });
   }, [type, selectedId, editBuffer]);
-  const save = React5.useCallback(async () => {
+  const save = React6.useCallback(async () => {
     if (!selectedId || !onUpdate) return null;
     setIsSaving(true);
     setSaveError(null);
-    const previous = useGraphStore.getState().readEntity(type, selectedId);
-    useGraphStore.getState().upsertEntity(type, selectedId, editBuffer);
+    const store = useGraphStore.getState();
+    const previous = store.readEntity(type, selectedId);
+    const previousSync = store.syncMetadata[`${type}:${selectedId}`];
+    store.upsertEntity(type, selectedId, editBuffer);
+    store.setEntitySyncMetadata(type, selectedId, { synced: false, origin: "optimistic", updatedAt: Date.now() });
     try {
       const result = await onUpdate(selectedId, editBuffer);
       const { id, data } = normalize(result);
-      useGraphStore.getState().replaceEntity(type, id, data);
-      useGraphStore.getState().clearPatch(type, id);
+      store.replaceEntity(type, id, data);
+      store.clearPatch(type, id);
+      store.setEntitySyncMetadata(type, id, { synced: true, origin: "server", updatedAt: Date.now() });
       cascadeInvalidation({ type, id: selectedId, previous, next: data, op: "update" });
       setMode("detail");
       optsRef.current.onUpdateSuccess?.(result);
       return result;
     } catch (err) {
-      if (previous) useGraphStore.getState().replaceEntity(type, selectedId, previous);
+      if (previous) store.replaceEntity(type, selectedId, previous);
+      if (previousSync) store.setEntitySyncMetadata(type, selectedId, previousSync);
+      else store.clearEntitySyncMetadata(type, selectedId);
       const error = err instanceof Error ? err : new Error(String(err));
       setSaveError(error.message);
       optsRef.current.onError?.("update", error);
@@ -1340,37 +2062,39 @@ function useEntityCRUD(opts) {
       setIsSaving(false);
     }
   }, [selectedId, type, editBuffer, normalize]);
-  const [createBuffer, setCreateBuffer] = React5.useState({ ...createDefaults });
-  const [isCreating, setIsCreating] = React5.useState(false);
-  const [createError, setCreateError] = React5.useState(null);
-  const setCreateField = React5.useCallback((field, value) => setCreateBuffer((prev) => ({ ...prev, [field]: value })), []);
-  const setCreateFields = React5.useCallback((fields) => setCreateBuffer((prev) => ({ ...prev, ...fields })), []);
-  const resetCreateBuffer = React5.useCallback(() => setCreateBuffer({ ...optsRef.current.createDefaults ?? {} }), []);
-  const startCreate = React5.useCallback(() => {
+  const [createBuffer, setCreateBuffer] = React6.useState({ ...createDefaults });
+  const [isCreating, setIsCreating] = React6.useState(false);
+  const [createError, setCreateError] = React6.useState(null);
+  const setCreateField = React6.useCallback((field, value) => setCreateBuffer((prev) => setValueAtPath(prev, String(field), value)), []);
+  const setCreateFields = React6.useCallback((fields) => setCreateBuffer((prev) => ({ ...prev, ...fields })), []);
+  const resetCreateBuffer = React6.useCallback(() => setCreateBuffer({ ...optsRef.current.createDefaults ?? {} }), []);
+  const startCreate = React6.useCallback(() => {
     resetCreateBuffer();
     setCreateError(null);
     setMode("create");
   }, [resetCreateBuffer]);
-  const cancelCreate = React5.useCallback(() => {
+  const cancelCreate = React6.useCallback(() => {
     resetCreateBuffer();
     setMode("list");
     setCreateError(null);
   }, [resetCreateBuffer]);
-  const create2 = React5.useCallback(async () => {
+  const create3 = React6.useCallback(async () => {
     if (!onCreate) return null;
     setIsCreating(true);
     setCreateError(null);
     const tempId = `__temp__${Date.now()}`;
     const optimisticData = { ...createBuffer, id: tempId, _optimistic: true };
-    useGraphStore.getState().upsertEntity(type, tempId, optimisticData);
-    useGraphStore.getState().insertIdInList(serializeKey(listQueryKey), tempId, "start");
+    const store = useGraphStore.getState();
+    store.upsertEntity(type, tempId, optimisticData);
+    store.setEntitySyncMetadata(type, tempId, { synced: false, origin: "optimistic", updatedAt: Date.now() });
+    store.insertIdInList(serializeKey(listQueryKey), tempId, "start");
     try {
       const result = await onCreate(createBuffer);
       const { id: realId, data } = normalize(result);
-      useGraphStore.getState().removeEntity(type, tempId);
-      useGraphStore.getState().upsertEntity(type, realId, data);
-      useGraphStore.getState().setEntityFetched(type, realId);
-      const store = useGraphStore.getState();
+      store.removeEntity(type, tempId);
+      store.upsertEntity(type, realId, data);
+      store.setEntityFetched(type, realId);
+      store.setEntitySyncMetadata(type, realId, { synced: true, origin: "server", updatedAt: Date.now() });
       for (const key of Object.keys(store.lists)) {
         const list2 = store.lists[key];
         const idx = list2.ids.indexOf(tempId);
@@ -1388,8 +2112,8 @@ function useEntityCRUD(opts) {
       optsRef.current.onCreateSuccess?.(result);
       return result;
     } catch (err) {
-      useGraphStore.getState().removeEntity(type, tempId);
-      useGraphStore.getState().removeIdFromAllLists(type, tempId);
+      store.removeEntity(type, tempId);
+      store.removeIdFromAllLists(type, tempId);
       const error = err instanceof Error ? err : new Error(String(err));
       setCreateError(error.message);
       optsRef.current.onError?.("create", error);
@@ -1398,9 +2122,9 @@ function useEntityCRUD(opts) {
       setIsCreating(false);
     }
   }, [type, createBuffer, normalize, listQueryKey, selectAfterCreate, resetCreateBuffer]);
-  const [isDeleting, setIsDeleting] = React5.useState(false);
-  const [deleteError, setDeleteError] = React5.useState(null);
-  const deleteEntity = React5.useCallback(async (id) => {
+  const [isDeleting, setIsDeleting] = React6.useState(false);
+  const [deleteError, setDeleteError] = React6.useState(null);
+  const deleteEntity = React6.useCallback(async (id) => {
     const targetId = id ?? selectedId;
     if (!targetId || !onDelete) return;
     setIsDeleting(true);
@@ -1428,7 +2152,7 @@ function useEntityCRUD(opts) {
       setIsDeleting(false);
     }
   }, [type, selectedId, listQueryKey, clearSelectionAfterDelete]);
-  return { mode, setMode, list, selectedId, select, openDetail, detail: detail ?? null, detailIsLoading, detailError: detailError ?? null, relations, editBuffer, setField, setFields, resetBuffer, dirty, startEdit, cancelEdit, save, isSaving, saveError, applyOptimistic, createBuffer, setCreateField, setCreateFields, resetCreateBuffer, startCreate, cancelCreate, create: create2, isCreating, createError, deleteEntity, isDeleting, deleteError, isEditing: mode === "edit" || mode === "create" };
+  return { mode, setMode, list, selectedId, select, openDetail, detail: detail ?? null, detailIsLoading, detailError: detailError ?? null, relations, editBuffer, setField, setFields, resetBuffer, dirty, startEdit, cancelEdit, save, isSaving, saveError, applyOptimistic, createBuffer, setCreateField, setCreateFields, resetCreateBuffer, startCreate, cancelCreate, create: create3, isCreating, createError, deleteEntity, isDeleting, deleteError, isEditing: mode === "edit" || mode === "create" };
 }
 
 // src/adapters/realtime-manager.ts
@@ -2059,8 +2783,8 @@ function createElectricAdapter(opts) {
   };
 }
 function useLocalFirst(adapter) {
-  const [isSynced, setIsSynced] = React5.useState(adapter.isSynced());
-  React5.useEffect(() => {
+  const [isSynced, setIsSynced] = React6.useState(adapter.isSynced());
+  React6.useEffect(() => {
     const u1 = adapter.onSyncComplete(() => setIsSynced(true));
     const u2 = getRealtimeManager().register(adapter, []);
     return () => {
@@ -2068,15 +2792,15 @@ function useLocalFirst(adapter) {
       u2();
     };
   }, [adapter]);
-  const query = React5.useCallback(async (sql, params) => (await adapter.query(sql, params)).rows, [adapter]);
-  const execute = React5.useCallback((sql, params) => adapter.execute(sql, params), [adapter]);
+  const query = React6.useCallback(async (sql, params) => (await adapter.query(sql, params)).rows, [adapter]);
+  const execute = React6.useCallback((sql, params) => adapter.execute(sql, params), [adapter]);
   return { isSynced, query, execute };
 }
 function usePGliteQuery(opts) {
   const { adapter, type, sql, params, idColumn = "id", normalize, deps = [] } = opts;
-  const [isLoading, setIsLoading] = React5.useState(true);
-  const [error, setError] = React5.useState(null);
-  React5.useEffect(() => {
+  const [isLoading, setIsLoading] = React6.useState(true);
+  const [error, setError] = React6.useState(null);
+  React6.useEffect(() => {
     let cancelled = false;
     setIsLoading(true);
     adapter.query(sql, params).then((r) => {
@@ -2189,20 +2913,17 @@ function createGQLClient(cfg) {
 }
 function useGQLEntity(opts) {
   const { type, id, staleTime = getEngineOptions().defaultStaleTime, enabled = true } = opts;
-  const optsRef = React5.useRef(opts);
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
   const data = zustand.useStore(useGraphStore, shallow.useShallow((s) => {
     if (!id) return null;
-    const base = s.entities[type]?.[id];
-    if (!base) return null;
-    const patch = s.patches[type]?.[id];
-    return patch ? { ...base, ...patch } : base;
+    return s.readEntitySnapshot(type, id);
   }));
-  const entityState = zustand.useStore(useGraphStore, React5.useCallback(
+  const entityState = zustand.useStore(useGraphStore, React6.useCallback(
     (s) => s.entityStates[`${type}:${id}`] ?? EMPTY_ENTITY_STATE,
     [type, id]
   ));
-  const doFetch = React5.useCallback(() => {
+  const doFetch = React6.useCallback(() => {
     if (!id || !enabled) return;
     const { client, document: document2, variables, descriptor, sideDescriptors, onSuccess, onError } = optsRef.current;
     useGraphStore.getState().setEntityFetching(type, id, true);
@@ -2219,7 +2940,7 @@ function useGQLEntity(opts) {
       onError?.(e);
     });
   }, [id, type, enabled]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (!id || !enabled) return;
     const token = registerSubscriber(`${type}:${id}`);
     const s = useGraphStore.getState();
@@ -2227,30 +2948,25 @@ function useGQLEntity(opts) {
     if (!s.entities[type]?.[id] || !ex?.lastFetched || ex.stale || Date.now() - (ex.lastFetched ?? 0) > staleTime) doFetch();
     return () => unregisterSubscriber(`${type}:${id}`, token);
   }, [id, type, enabled, staleTime, doFetch]);
-  React5.useEffect(() => {
+  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 useGQLList(opts) {
   const { type, queryKey, staleTime = getEngineOptions().defaultStaleTime, enabled = true, mode = "replace" } = opts;
-  const optsRef = React5.useRef(opts);
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
-  const key = React5.useMemo(() => serializeKey(queryKey), [queryKey]);
-  const listState = zustand.useStore(useGraphStore, React5.useCallback((s) => s.lists[key] ?? EMPTY_LIST_STATE, [key]));
+  const key = React6.useMemo(() => serializeKey(queryKey), [queryKey]);
+  const listState = zustand.useStore(useGraphStore, React6.useCallback((s) => s.lists[key] ?? EMPTY_LIST_STATE, [key]));
   const items = zustand.useStore(
     useGraphStore,
     shallow.useShallow((s) => {
       const ids = s.lists[key]?.ids ?? EMPTY_IDS;
-      return ids.map((id) => {
-        const base = s.entities[type]?.[id];
-        if (!base) return null;
-        const p = s.patches[type]?.[id];
-        return p ? { ...base, ...p } : base;
-      }).filter((x) => x !== null);
+      return ids.map((id) => s.readEntitySnapshot(type, id)).filter((x) => x !== null);
     })
   );
-  const doFetch = React5.useCallback((cursor, append = false) => {
+  const doFetch = React6.useCallback((cursor, append = false) => {
     if (!enabled) return;
     const { client, document: document2, variables, descriptor, sideDescriptors, getItems, getPagination } = optsRef.current;
     const store = useGraphStore.getState();
@@ -2273,25 +2989,25 @@ function useGQLList(opts) {
       else useGraphStore.getState().setListResult(key, ids, meta);
     }).catch((e) => useGraphStore.getState().setListError(key, e.message));
   }, [key, enabled, mode]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (!enabled) return;
     const ex = useGraphStore.getState().lists[key];
     if (!ex || ex.stale || !ex.lastFetched || Date.now() - ex.lastFetched > staleTime) doFetch();
   }, [key, enabled, staleTime, doFetch]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (listState.stale && enabled && !listState.isFetching) doFetch();
   }, [listState.stale, enabled, listState.isFetching, doFetch]);
-  const fetchNextPage = React5.useCallback(() => {
+  const fetchNextPage = React6.useCallback(() => {
     if (!listState.hasNextPage || listState.isFetchingMore) return;
     doFetch(listState.nextCursor ?? void 0, true);
   }, [listState.hasNextPage, listState.isFetchingMore, listState.nextCursor, 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, total: listState.total, currentPage: listState.currentPage, fetchNextPage, refetch: () => doFetch() };
 }
 function useGQLMutation(opts) {
-  const optsRef = React5.useRef(opts);
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
-  const [state, setState] = React5.useState({ isPending: false, isSuccess: false, isError: false, error: null });
-  const mutate = React5.useCallback(async (variables) => {
+  const [state, setState] = React6.useState({ isPending: false, isSuccess: false, isError: false, error: null });
+  const mutate = React6.useCallback(async (variables) => {
     const { client, document: document2, descriptors, optimistic, invalidateLists, onSuccess, onError } = optsRef.current;
     setState({ isPending: true, isSuccess: false, isError: false, error: null });
     try {
@@ -2307,17 +3023,17 @@ function useGQLMutation(opts) {
       return null;
     }
   }, []);
-  const trigger = React5.useCallback((v) => {
+  const trigger = React6.useCallback((v) => {
     void mutate(v);
   }, [mutate]);
   return { mutate, trigger, state };
 }
 function useGQLSubscription(opts) {
   const { document: document2, variables, enabled = true } = opts;
-  const [status, setStatus] = React5.useState({ connected: false, error: null });
-  const optsRef = React5.useRef(opts);
+  const [status, setStatus] = React6.useState({ connected: false, error: null });
+  const optsRef = React6.useRef(opts);
   optsRef.current = opts;
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     const { client, wsClient, descriptors, onData, onError } = optsRef.current;
     if (!enabled) return;
     const unsub = client.subscribe({ document: document2, variables, descriptors, wsClient, onData: (d) => {
@@ -2336,7 +3052,7 @@ function cn(...inputs) {
   return tailwindMerge.twMerge(clsx.clsx(inputs));
 }
 function InlineCellEditor({ initialValue, onCommit, onCancel, className }) {
-  const [value, setValue] = React5.useState(initialValue);
+  const [value, setValue] = React6.useState(initialValue);
   return /* @__PURE__ */ jsxRuntime.jsx(
     "input",
     {
@@ -2366,22 +3082,22 @@ function InlineCellEditor({ initialValue, onCommit, onCancel, className }) {
 }
 function EntityTable({ viewResult, columns, getRowId = (r) => String(r.id), selectedId, onRowClick, onCellEdit, onBulkAction, paginationMode = "loadMore", pageSize = 50, searchPlaceholder = "Search\u2026", searchFields, toolbarChildren, showToolbar = true, emptyState, className }) {
   const { items, isLoading, isFetching, isRemoteFetching, isShowingLocalPending, hasNextPage, fetchNextPage, isFetchingMore, viewTotal, setSort, setSearch, refetch } = viewResult;
-  const [sorting, setSorting] = React5.useState([]);
-  const [rowSelection, setRowSelection] = React5.useState({});
-  const [colVis, setColVis] = React5.useState({});
-  const [search, setSearchLocal] = React5.useState("");
-  const [editingCell, setEditingCell] = React5.useState(null);
-  const [page, setPage] = React5.useState(1);
-  const handleSort = React5.useCallback((updater) => {
+  const [sorting, setSorting] = React6.useState([]);
+  const [rowSelection, setRowSelection] = React6.useState({});
+  const [colVis, setColVis] = React6.useState({});
+  const [search, setSearchLocal] = React6.useState("");
+  const [editingCell, setEditingCell] = React6.useState(null);
+  const [page, setPage] = React6.useState(1);
+  const handleSort = React6.useCallback((updater) => {
     const next = typeof updater === "function" ? updater(sorting) : updater;
     setSorting(next);
     setSort(next.length ? next.map((s) => ({ field: s.id, direction: s.desc ? "desc" : "asc" })) : null);
   }, [sorting, setSort]);
-  const handleSearch = React5.useCallback((v) => {
+  const handleSearch = React6.useCallback((v) => {
     setSearchLocal(v);
     setSearch(v);
   }, [setSearch]);
-  const pagedItems = React5.useMemo(() => paginationMode === "pages" ? items.slice((page - 1) * pageSize, page * pageSize) : items, [items, paginationMode, page, pageSize]);
+  const pagedItems = React6.useMemo(() => paginationMode === "pages" ? items.slice((page - 1) * pageSize, page * pageSize) : items, [items, paginationMode, page, pageSize]);
   const totalPages = Math.ceil(items.length / pageSize);
   const table = reactTable.useReactTable({
     data: pagedItems,
@@ -2484,7 +3200,7 @@ function EntityTable({ viewResult, columns, getRowId = (r) => String(r.id), sele
   ] });
 }
 function Sheet({ open, onClose, title, subtitle, children, footer, width = "w-[480px]" }) {
-  React5__default.default.useEffect(() => {
+  React6__default.default.useEffect(() => {
     const h = (e) => {
       if (e.key === "Escape") onClose();
     };
@@ -2520,6 +3236,8 @@ function FieldControl({ descriptor, value, onChange, entity, readonly }) {
       return /* @__PURE__ */ jsxRuntime.jsx("input", { type: "number", value: String(value ?? ""), onChange: (e) => onChange(e.target.valueAsNumber), placeholder: descriptor.placeholder, className: base });
     case "textarea":
       return /* @__PURE__ */ jsxRuntime.jsx("textarea", { value: String(value ?? ""), onChange: (e) => onChange(e.target.value), placeholder: descriptor.placeholder, className: "w-full min-h-[80px] rounded-md border bg-muted/50 px-3 py-2 text-sm resize-none focus:outline-none focus:ring-1 focus:ring-ring transition-colors" });
+    case "markdown":
+      return /* @__PURE__ */ jsxRuntime.jsx(MarkdownFieldEditor, { value: String(value ?? ""), onChange: (nextValue) => onChange(nextValue), placeholder: descriptor.placeholder });
     case "date":
       return /* @__PURE__ */ jsxRuntime.jsx("input", { type: "date", value: value ? new Date(value).toISOString().split("T")[0] : "", onChange: (e) => onChange(e.target.value ? new Date(e.target.value).toISOString() : null), className: base });
     case "boolean":
@@ -2539,12 +3257,35 @@ function FieldControl({ descriptor, value, onChange, entity, readonly }) {
         !value && /* @__PURE__ */ jsxRuntime.jsx("option", { value: "", children: "Select\u2026" }),
         (descriptor.options ?? []).map((o) => /* @__PURE__ */ jsxRuntime.jsx("option", { value: o.value, children: o.label }, o.value))
       ] });
+    case "json":
+      return /* @__PURE__ */ jsxRuntime.jsx(
+        "textarea",
+        {
+          value: value != null ? JSON.stringify(value, null, 2) : "",
+          onChange: (event) => {
+            const nextValue = event.target.value;
+            try {
+              onChange(nextValue ? JSON.parse(nextValue) : null);
+            } catch {
+              onChange(nextValue);
+            }
+          },
+          placeholder: descriptor.placeholder,
+          className: "w-full min-h-[120px] rounded-md border bg-muted/50 px-3 py-2 text-sm font-mono resize-y focus:outline-none focus:ring-1 focus:ring-ring transition-colors"
+        }
+      );
     default:
       return /* @__PURE__ */ jsxRuntime.jsx("input", { value: String(value ?? ""), onChange: (e) => onChange(e.target.value), className: base });
   }
 }
+function FieldReadonlyValue({ descriptor, value, entity }) {
+  if (descriptor.render) return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: descriptor.render(value, entity) });
+  if (descriptor.type === "markdown") return /* @__PURE__ */ jsxRuntime.jsx(MarkdownFieldRenderer, { value: String(value ?? ""), className: "prose prose-sm max-w-none py-1" });
+  if (descriptor.type === "json") return /* @__PURE__ */ jsxRuntime.jsx("pre", { className: "text-xs py-1 whitespace-pre-wrap break-words", children: JSON.stringify(value ?? null, null, 2) });
+  return /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-sm py-1", children: value != null && value !== "" ? String(value) : "\u2014" });
+}
 function EntityDetailSheet({ crud, fields, title = "Details", description, children, showEditButton = true, showDeleteButton = true, deleteConfirmMessage = "This action cannot be undone." }) {
-  const [confirmDelete, setConfirmDelete] = React5__default.default.useState(false);
+  const [confirmDelete, setConfirmDelete] = React6__default.default.useState(false);
   const open = crud.mode === "detail" && !!crud.selectedId;
   const entity = crud.detail;
   const resolvedTitle = entity && typeof title === "function" ? title(entity) : String(title);
@@ -2568,8 +3309,7 @@ function EntityDetailSheet({ crud, fields, title = "Details", description, child
         entity && /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-4", children: [
           fields.map((f) => /* @__PURE__ */ jsxRuntime.jsxs("div", { children: [
             /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-[10px] font-medium text-muted-foreground uppercase tracking-wide mb-1", children: f.label }),
-            /* @__PURE__ */ jsxRuntime.jsx(FieldControl, { descriptor: f, value: entity[f.field], onChange: () => {
-            }, entity, readonly: true })
+            /* @__PURE__ */ jsxRuntime.jsx(FieldReadonlyValue, { descriptor: f, value: getValueAtPath(entity, f.field), entity })
           ] }, f.field)),
           children && /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
             /* @__PURE__ */ jsxRuntime.jsx("div", { className: "border-t my-1" }),
@@ -2639,13 +3379,14 @@ function EntityFormSheet({ crud, fields, createTitle = "Create", editTitle = "Ed
         error && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "px-3 py-2 rounded-md bg-destructive/10 border border-destructive/20 text-xs text-destructive", children: error }),
         visibleFields.map((f) => {
           const isDirty = !isCreate && crud.dirty.changed.has(f.field);
+          const currentValue = getValueAtPath(buf, f.field);
           return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex flex-col gap-1.5", children: [
             /* @__PURE__ */ jsxRuntime.jsxs("label", { className: cn("text-xs font-medium", isDirty ? "text-primary" : "text-muted-foreground"), children: [
               f.label,
               f.required && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-destructive ml-0.5", children: "*" }),
               isDirty && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ml-1.5 text-[10px] font-normal opacity-70", children: "modified" })
             ] }),
-            /* @__PURE__ */ jsxRuntime.jsx(FieldControl, { descriptor: f, value: buf[f.field], onChange: (v) => setField(f.field, v), entity: buf, readonly: f.readonlyOnEdit && isEdit }),
+            /* @__PURE__ */ jsxRuntime.jsx(FieldControl, { descriptor: f, value: currentValue, onChange: (v) => setField(f.field, v), entity: buf, readonly: f.readonlyOnEdit && isEdit }),
             f.hint && /* @__PURE__ */ jsxRuntime.jsx("p", { className: "text-[10px] text-muted-foreground", children: f.hint })
           ] }, f.field);
         })
@@ -3303,43 +4044,43 @@ function buildHeaderGroups(columns, table) {
 function useTable(options) {
   const { data, columns: columnDefs } = options;
   const ini = options.initialState;
-  const [sorting, _setSorting] = React5.useState(
+  const [sorting, _setSorting] = React6.useState(
     options.state?.sorting ?? ini?.sorting ?? []
   );
-  const [columnFilters, _setColumnFilters] = React5.useState(
+  const [columnFilters, _setColumnFilters] = React6.useState(
     options.state?.columnFilters ?? ini?.columnFilters ?? []
   );
-  const [globalFilter, _setGlobalFilter] = React5.useState(
+  const [globalFilter, _setGlobalFilter] = React6.useState(
     options.state?.globalFilter ?? ini?.globalFilter ?? ""
   );
-  const [rowSelection, _setRowSelection] = React5.useState(
+  const [rowSelection, _setRowSelection] = React6.useState(
     options.state?.rowSelection ?? ini?.rowSelection ?? {}
   );
-  const [columnVisibility, _setColumnVisibility] = React5.useState(
+  const [columnVisibility, _setColumnVisibility] = React6.useState(
     options.state?.columnVisibility ?? ini?.columnVisibility ?? {}
   );
-  const [columnOrder, _setColumnOrder] = React5.useState(
+  const [columnOrder, _setColumnOrder] = React6.useState(
     options.state?.columnOrder ?? ini?.columnOrder ?? []
   );
-  const [columnPinning, _setColumnPinning] = React5.useState(
+  const [columnPinning, _setColumnPinning] = React6.useState(
     options.state?.columnPinning ?? ini?.columnPinning ?? { left: [], right: [] }
   );
-  const [columnSizing, _setColumnSizing] = React5.useState(
+  const [columnSizing, _setColumnSizing] = React6.useState(
     options.state?.columnSizing ?? ini?.columnSizing ?? {}
   );
-  const [columnSizingInfo, _setColumnSizingInfo] = React5.useState(
+  const [columnSizingInfo, _setColumnSizingInfo] = React6.useState(
     options.state?.columnSizingInfo ?? ini?.columnSizingInfo ?? defaultState.columnSizingInfo
   );
-  const [expanded, _setExpanded] = React5.useState(
+  const [expanded, _setExpanded] = React6.useState(
     options.state?.expanded ?? ini?.expanded ?? {}
   );
-  const [grouping, _setGrouping] = React5.useState(
+  const [grouping, _setGrouping] = React6.useState(
     options.state?.grouping ?? ini?.grouping ?? []
   );
-  const [pagination, _setPagination] = React5.useState(
+  const [pagination, _setPagination] = React6.useState(
     options.state?.pagination ?? ini?.pagination ?? { pageIndex: 0, pageSize: 10 }
   );
-  const state = React5.useMemo(
+  const state = React6.useMemo(
     () => ({
       sorting: options.state?.sorting ?? sorting,
       columnFilters: options.state?.columnFilters ?? columnFilters,
@@ -3370,63 +4111,63 @@ function useTable(options) {
       pagination
     ]
   );
-  const stateRef = React5.useRef(state);
+  const stateRef = React6.useRef(state);
   stateRef.current = state;
-  const setSorting = React5.useCallback((updater) => {
+  const setSorting = React6.useCallback((updater) => {
     options.onSortingChange?.(updater);
     if (!options.state?.sorting) _setSorting((prev) => resolveUpdater(updater, prev));
   }, [options.onSortingChange, options.state?.sorting]);
-  const setColumnFilters = React5.useCallback((updater) => {
+  const setColumnFilters = React6.useCallback((updater) => {
     options.onColumnFiltersChange?.(updater);
     if (!options.state?.columnFilters) _setColumnFilters((prev) => resolveUpdater(updater, prev));
     if (options.autoResetPageIndex !== false) {
       _setPagination((prev) => ({ ...prev, pageIndex: 0 }));
     }
   }, [options.onColumnFiltersChange, options.state?.columnFilters, options.autoResetPageIndex]);
-  const setGlobalFilter = React5.useCallback((value) => {
+  const setGlobalFilter = React6.useCallback((value) => {
     options.onGlobalFilterChange?.(value);
     if (!options.state?.globalFilter) _setGlobalFilter(value);
     if (options.autoResetPageIndex !== false) {
       _setPagination((prev) => ({ ...prev, pageIndex: 0 }));
     }
   }, [options.onGlobalFilterChange, options.state?.globalFilter, options.autoResetPageIndex]);
-  const setRowSelection = React5.useCallback((updater) => {
+  const setRowSelection = React6.useCallback((updater) => {
     options.onRowSelectionChange?.(updater);
     if (!options.state?.rowSelection) _setRowSelection((prev) => resolveUpdater(updater, prev));
   }, [options.onRowSelectionChange, options.state?.rowSelection]);
-  const setColumnVisibility = React5.useCallback((updater) => {
+  const setColumnVisibility = React6.useCallback((updater) => {
     options.onColumnVisibilityChange?.(updater);
     if (!options.state?.columnVisibility) _setColumnVisibility((prev) => resolveUpdater(updater, prev));
   }, [options.onColumnVisibilityChange, options.state?.columnVisibility]);
-  const setColumnOrder = React5.useCallback((updater) => {
+  const setColumnOrder = React6.useCallback((updater) => {
     options.onColumnOrderChange?.(updater);
     if (!options.state?.columnOrder) _setColumnOrder((prev) => resolveUpdater(updater, prev));
   }, [options.onColumnOrderChange, options.state?.columnOrder]);
-  const setColumnPinning = React5.useCallback((updater) => {
+  const setColumnPinning = React6.useCallback((updater) => {
     options.onColumnPinningChange?.(updater);
     if (!options.state?.columnPinning) _setColumnPinning((prev) => resolveUpdater(updater, prev));
   }, [options.onColumnPinningChange, options.state?.columnPinning]);
-  const setColumnSizing = React5.useCallback((updater) => {
+  const setColumnSizing = React6.useCallback((updater) => {
     options.onColumnSizingChange?.(updater);
     if (!options.state?.columnSizing) _setColumnSizing((prev) => resolveUpdater(updater, prev));
   }, [options.onColumnSizingChange, options.state?.columnSizing]);
-  const setColumnSizingInfo = React5.useCallback((updater) => {
+  const setColumnSizingInfo = React6.useCallback((updater) => {
     options.onColumnSizingInfoChange?.(updater);
     if (!options.state?.columnSizingInfo) _setColumnSizingInfo((prev) => resolveUpdater(updater, prev));
   }, [options.onColumnSizingInfoChange, options.state?.columnSizingInfo]);
-  const setExpanded = React5.useCallback((updater) => {
+  const setExpanded = React6.useCallback((updater) => {
     options.onExpandedChange?.(updater);
     if (!options.state?.expanded) _setExpanded((prev) => resolveUpdater(updater, prev));
   }, [options.onExpandedChange, options.state?.expanded]);
-  const setGrouping = React5.useCallback((updater) => {
+  const setGrouping = React6.useCallback((updater) => {
     options.onGroupingChange?.(updater);
     if (!options.state?.grouping) _setGrouping((prev) => resolveUpdater(updater, prev));
   }, [options.onGroupingChange, options.state?.grouping]);
-  const setPagination = React5.useCallback((updater) => {
+  const setPagination = React6.useCallback((updater) => {
     options.onPaginationChange?.(updater);
     if (!options.state?.pagination) _setPagination((prev) => resolveUpdater(updater, prev));
   }, [options.onPaginationChange, options.state?.pagination]);
-  const stateSetters = React5.useMemo(() => ({
+  const stateSetters = React6.useMemo(() => ({
     setSorting,
     setColumnFilters,
     setGlobalFilter,
@@ -3453,13 +4194,13 @@ function useTable(options) {
     setGrouping,
     setPagination
   ]);
-  const getState = React5.useCallback(() => state, [state]);
-  const coreRowModelRef = React5.useRef(null);
-  const emptyCoreRowModel = React5.useMemo(
+  const getState = React6.useCallback(() => state, [state]);
+  const coreRowModelRef = React6.useRef(null);
+  const emptyCoreRowModel = React6.useMemo(
     () => ({ rows: [], flatRows: [], rowsById: {} }),
     []
   );
-  const rowModelTable = React5.useMemo(
+  const rowModelTable = React6.useMemo(
     () => ({
       options,
       getState: () => stateRef.current,
@@ -3469,11 +4210,11 @@ function useTable(options) {
     }),
     [options, setRowSelection, setExpanded, emptyCoreRowModel]
   );
-  const columns = React5.useMemo(
+  const columns = React6.useMemo(
     () => buildColumns(columnDefs, { getState, ...stateSetters }, stateSetters),
     [columnDefs, getState, stateSetters]
   );
-  const orderedColumns = React5.useMemo(() => {
+  const orderedColumns = React6.useMemo(() => {
     if (state.columnOrder.length === 0) return columns;
     const ordered = [];
     const remaining = [...columns];
@@ -3487,28 +4228,28 @@ function useTable(options) {
     ordered.push(...remaining);
     return ordered;
   }, [columns, state.columnOrder]);
-  const visibleColumns = React5.useMemo(
+  const visibleColumns = React6.useMemo(
     () => orderedColumns.filter((c) => c.getIsVisible()),
     [orderedColumns]
   );
-  const leftPinnedColumns = React5.useMemo(
+  const leftPinnedColumns = React6.useMemo(
     () => visibleColumns.filter((c) => c.getIsPinned() === "left"),
     [visibleColumns]
   );
-  const rightPinnedColumns = React5.useMemo(
+  const rightPinnedColumns = React6.useMemo(
     () => visibleColumns.filter((c) => c.getIsPinned() === "right"),
     [visibleColumns]
   );
-  const centerColumns = React5.useMemo(
+  const centerColumns = React6.useMemo(
     () => visibleColumns.filter((c) => c.getIsPinned() === false),
     [visibleColumns]
   );
-  const coreRowModel = React5.useMemo(() => {
+  const coreRowModel = React6.useMemo(() => {
     const cm = getCoreRowModel2(data, columns, rowModelTable);
     coreRowModelRef.current = cm;
     return cm;
   }, [data, columns, rowModelTable]);
-  const filteredRowModel = React5.useMemo(() => {
+  const filteredRowModel = React6.useMemo(() => {
     if (options.manualFiltering) return coreRowModel;
     return getFilteredRowModel(
       coreRowModel,
@@ -3518,32 +4259,32 @@ function useTable(options) {
       options.globalFilterFn
     );
   }, [coreRowModel, state.columnFilters, state.globalFilter, columns, options.manualFiltering, options.globalFilterFn]);
-  const sortedRowModel = React5.useMemo(() => {
+  const sortedRowModel = React6.useMemo(() => {
     if (options.manualSorting) return filteredRowModel;
     return getSortedRowModel2(filteredRowModel, state.sorting, columns);
   }, [filteredRowModel, state.sorting, columns, options.manualSorting]);
-  const groupedRowModel = React5.useMemo(() => {
+  const groupedRowModel = React6.useMemo(() => {
     if (options.manualGrouping || state.grouping.length === 0) return sortedRowModel;
     return getGroupedRowModel(sortedRowModel, state.grouping, columns, rowModelTable);
   }, [sortedRowModel, state.grouping, columns, options.manualGrouping, rowModelTable]);
-  const expandedRowModel = React5.useMemo(
+  const expandedRowModel = React6.useMemo(
     () => getExpandedRowModel(groupedRowModel, state.expanded),
     [groupedRowModel, state.expanded]
   );
   const prePaginationRowModel = expandedRowModel;
-  const paginatedRowModel = React5.useMemo(() => {
+  const paginatedRowModel = React6.useMemo(() => {
     if (options.manualPagination) return prePaginationRowModel;
     return getPaginatedRowModel(prePaginationRowModel, state.pagination);
   }, [prePaginationRowModel, state.pagination, options.manualPagination]);
-  const selectedRowModel = React5.useMemo(
+  const selectedRowModel = React6.useMemo(
     () => getSelectedRowModel(coreRowModel, state.rowSelection),
     [coreRowModel, state.rowSelection]
   );
-  const pageCount = React5.useMemo(() => {
+  const pageCount = React6.useMemo(() => {
     if (options.pageCount != null) return options.pageCount;
     return Math.ceil(prePaginationRowModel.rows.length / state.pagination.pageSize);
   }, [options.pageCount, prePaginationRowModel, state.pagination.pageSize]);
-  const table = React5.useMemo(() => {
+  const table = React6.useMemo(() => {
     const inst = {
       options,
       getState: () => state,
@@ -3846,9 +4587,9 @@ function createSelectionStore() {
 function useSelectionStore(store, selector) {
   return zustand.useStore(store, selector);
 }
-var SelectionContext = React5__default.default.createContext(null);
+var SelectionContext = React6__default.default.createContext(null);
 function useSelectionContext() {
-  const store = React5__default.default.useContext(SelectionContext);
+  const store = React6__default.default.useContext(SelectionContext);
   if (!store) throw new Error("useSelectionContext must be used within a SelectionContext.Provider");
   return store;
 }
@@ -4574,18 +5315,18 @@ function generateId() {
 function useTablePresets(tableId, options = {}) {
   const { adapter, realtimeMode = "auto-apply", enabled = true } = options;
   const resolvedAdapter = adapter ?? new MemoryAdapter();
-  const adapterRef = React5.useRef(resolvedAdapter);
+  const adapterRef = React6.useRef(resolvedAdapter);
   adapterRef.current = resolvedAdapter;
-  const storeRef = React5.useRef(createPresetStore(realtimeMode));
+  const storeRef = React6.useRef(createPresetStore(realtimeMode));
   const store = storeRef.current;
-  const [isLoading, setIsLoading] = React5.useState(false);
-  const [isSubscribed, setIsSubscribed] = React5.useState(false);
-  React5.useEffect(() => {
+  const [isLoading, setIsLoading] = React6.useState(false);
+  const [isSubscribed, setIsSubscribed] = React6.useState(false);
+  React6.useEffect(() => {
     if (!enabled) return;
     setIsLoading(true);
     store.getState().loadPresets(tableId, adapterRef.current).finally(() => setIsLoading(false));
   }, [tableId, enabled, store]);
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (!enabled) return;
     const currentAdapter = adapterRef.current;
     if (!currentAdapter.subscribe) {
@@ -4600,19 +5341,19 @@ function useTablePresets(tableId, options = {}) {
   }, [tableId, enabled, store]);
   const slice = zustand.useStore(store, (s) => s.presets[tableId] ?? s.getTablePresets(tableId));
   const allPendingChanges = zustand.useStore(store, (s) => s.pendingChanges);
-  const pendingChanges = React5.useMemo(
+  const pendingChanges = React6.useMemo(
     () => allPendingChanges.filter((e) => e.tableId === tableId),
     [allPendingChanges, tableId]
   );
-  const activeFilterPreset = React5.useMemo(
+  const activeFilterPreset = React6.useMemo(
     () => slice.filters.find((p) => p.id === slice.activeFilterId) ?? null,
     [slice.filters, slice.activeFilterId]
   );
-  const activeColumnPreset = React5.useMemo(
+  const activeColumnPreset = React6.useMemo(
     () => slice.columns.find((p) => p.id === slice.activeColumnId) ?? null,
     [slice.columns, slice.activeColumnId]
   );
-  const applyFilterPreset = React5.useCallback(
+  const applyFilterPreset = React6.useCallback(
     (id) => {
       store.getState().applyFilterPreset(tableId, id);
       adapterRef.current.saveActivePresets(tableId, {
@@ -4623,7 +5364,7 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, slice.activeColumnId, slice.activeViewMode, store]
   );
-  const applyColumnPreset = React5.useCallback(
+  const applyColumnPreset = React6.useCallback(
     (id) => {
       store.getState().applyColumnPreset(tableId, id);
       adapterRef.current.saveActivePresets(tableId, {
@@ -4634,7 +5375,7 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, slice.activeFilterId, slice.activeViewMode, store]
   );
-  const setViewMode = React5.useCallback(
+  const setViewMode = React6.useCallback(
     (mode) => {
       store.getState().setViewMode(tableId, mode);
       adapterRef.current.saveActivePresets(tableId, {
@@ -4645,7 +5386,7 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, slice.activeFilterId, slice.activeColumnId, store]
   );
-  const saveFilterPreset = React5.useCallback(
+  const saveFilterPreset = React6.useCallback(
     async (preset) => {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const full = {
@@ -4658,7 +5399,7 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, store]
   );
-  const updateFilterPreset = React5.useCallback(
+  const updateFilterPreset = React6.useCallback(
     async (id, patch) => {
       const existing = slice.filters.find((p) => p.id === id);
       if (!existing) return;
@@ -4672,7 +5413,7 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, slice.filters, store]
   );
-  const saveColumnPreset = React5.useCallback(
+  const saveColumnPreset = React6.useCallback(
     async (preset) => {
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const full = {
@@ -4685,7 +5426,7 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, store]
   );
-  const updateColumnPreset = React5.useCallback(
+  const updateColumnPreset = React6.useCallback(
     async (id, patch) => {
       const existing = slice.columns.find((p) => p.id === id);
       if (!existing) return;
@@ -4699,25 +5440,25 @@ function useTablePresets(tableId, options = {}) {
     },
     [tableId, slice.columns, store]
   );
-  const deleteFilterPreset = React5.useCallback(
+  const deleteFilterPreset = React6.useCallback(
     async (id) => {
       await store.getState().deleteFilterPreset(tableId, id, adapterRef.current);
     },
     [tableId, store]
   );
-  const deleteColumnPreset = React5.useCallback(
+  const deleteColumnPreset = React6.useCallback(
     async (id) => {
       await store.getState().deleteColumnPreset(tableId, id, adapterRef.current);
     },
     [tableId, store]
   );
-  const acknowledgePendingChange = React5.useCallback(
+  const acknowledgePendingChange = React6.useCallback(
     (index) => {
       store.getState().acknowledgePendingChange(index);
     },
     [store]
   );
-  const dismissPendingChanges = React5.useCallback(() => {
+  const dismissPendingChanges = React6.useCallback(() => {
     store.getState().dismissPendingChanges(tableId);
   }, [tableId, store]);
   return {
@@ -4742,7 +5483,7 @@ function useTablePresets(tableId, options = {}) {
     isSubscribed
   };
 }
-var TableStorageContext = React5.createContext({
+var TableStorageContext = React6.createContext({
   adapter: new MemoryAdapter(),
   realtimeMode: "auto-apply"
 });
@@ -4751,19 +5492,19 @@ function TableStorageProvider({
   realtimeMode = "auto-apply",
   children
 }) {
-  const value = React5.useMemo(
+  const value = React6.useMemo(
     () => ({ adapter, realtimeMode }),
     [adapter, realtimeMode]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(TableStorageContext.Provider, { value, children });
 }
 function useTableStorageAdapter() {
-  return React5.useContext(TableStorageContext).adapter;
+  return React6.useContext(TableStorageContext).adapter;
 }
 function useTableRealtimeMode() {
-  return React5.useContext(TableStorageContext).realtimeMode;
+  return React6.useContext(TableStorageContext).realtimeMode;
 }
-var Table = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full overflow-auto", children: /* @__PURE__ */ jsxRuntime.jsx(
+var Table = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("div", { className: "relative w-full overflow-auto", children: /* @__PURE__ */ jsxRuntime.jsx(
   "table",
   {
     ref,
@@ -4772,11 +5513,11 @@ var Table = React5__default.default.forwardRef(({ className, ...props }, ref) =>
   }
 ) }));
 Table.displayName = "Table";
-var TableHeader = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("thead", { ref, className: cn("bg-muted/60", className), ...props }));
+var TableHeader = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("thead", { ref, className: cn("bg-muted/60", className), ...props }));
 TableHeader.displayName = "TableHeader";
-var TableBody = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("tbody", { ref, className: cn("bg-background", className), ...props }));
+var TableBody = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx("tbody", { ref, className: cn("bg-background", className), ...props }));
 TableBody.displayName = "TableBody";
-var TableFooter = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var TableFooter = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "tfoot",
   {
     ref,
@@ -4785,7 +5526,7 @@ var TableFooter = React5__default.default.forwardRef(({ className, ...props }, r
   }
 ));
 TableFooter.displayName = "TableFooter";
-var TableRow = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var TableRow = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "tr",
   {
     ref,
@@ -4797,7 +5538,7 @@ var TableRow = React5__default.default.forwardRef(({ className, ...props }, ref)
   }
 ));
 TableRow.displayName = "TableRow";
-var TableHead = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var TableHead = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "th",
   {
     ref,
@@ -4809,7 +5550,7 @@ var TableHead = React5__default.default.forwardRef(({ className, ...props }, ref
   }
 ));
 TableHead.displayName = "TableHead";
-var TableCell = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var TableCell = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "td",
   {
     ref,
@@ -4821,7 +5562,7 @@ var TableCell = React5__default.default.forwardRef(({ className, ...props }, ref
   }
 ));
 TableCell.displayName = "TableCell";
-var TableCaption = React5__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
+var TableCaption = React6__default.default.forwardRef(({ className, ...props }, ref) => /* @__PURE__ */ jsxRuntime.jsx(
   "caption",
   {
     ref,
@@ -4884,11 +5625,11 @@ function InlineCellEditor2({
   inputId,
   ariaLabel
 }) {
-  const [value, setValue] = React5.useState(initialValue);
-  const inputRef = React5.useRef(null);
-  const selectRef = React5.useRef(null);
+  const [value, setValue] = React6.useState(initialValue);
+  const inputRef = React6.useRef(null);
+  const selectRef = React6.useRef(null);
   const filterType = columnDef.meta?.entityMeta?.filterType ?? "text";
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     if (filterType === "enum") {
       selectRef.current?.focus();
       return;
@@ -4897,7 +5638,7 @@ function InlineCellEditor2({
     inputRef.current?.focus();
     inputRef.current?.select();
   }, [filterType]);
-  const handleKeyDown = React5.useCallback(
+  const handleKeyDown = React6.useCallback(
     (e) => {
       if (e.key === "Enter") {
         e.preventDefault();
@@ -4909,7 +5650,7 @@ function InlineCellEditor2({
     },
     [value, onSave, onCancel]
   );
-  const handleBlur = React5.useCallback(() => {
+  const handleBlur = React6.useCallback(() => {
     onSave(value);
   }, [value, onSave]);
   if (filterType === "boolean") {
@@ -5017,8 +5758,8 @@ function InlineItemEditor({
   onCancel,
   className
 }) {
-  const baseId = React5.useId();
-  const [editValues, setEditValues] = React5.useState({});
+  const baseId = React6.useId();
+  const [editValues, setEditValues] = React6.useState({});
   const editableFields = columns.filter(
     (c) => c.meta?.entityMeta?.editable && c.accessorKey
   );
@@ -5119,11 +5860,11 @@ function ActionDropdown({
   actions,
   className
 }) {
-  const [isOpen, setIsOpen] = React5.useState(false);
-  const [confirmAction, setConfirmAction] = React5.useState(null);
-  const menuRef = React5.useRef(null);
+  const [isOpen, setIsOpen] = React6.useState(false);
+  const [confirmAction, setConfirmAction] = React6.useState(null);
+  const menuRef = React6.useRef(null);
   const visibleActions = actions.filter((a) => !a.hidden?.(item));
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     function handleClick(e) {
       if (menuRef.current && !menuRef.current.contains(e.target)) {
         setIsOpen(false);
@@ -5195,7 +5936,7 @@ function ActionButtonRow({
   const visibleActions = actions.filter((a) => !a.hidden?.(item));
   const inline = visibleActions.slice(0, maxVisible);
   const overflow = visibleActions.slice(maxVisible);
-  const [confirmAction, setConfirmAction] = React5.useState(null);
+  const [confirmAction, setConfirmAction] = React6.useState(null);
   function executeAction(action) {
     if (action.confirm) {
       setConfirmAction(action);
@@ -5363,10 +6104,10 @@ function DataTable({
   getRowId,
   className
 }) {
-  const [editingCell, setEditingCell] = React5.useState(null);
+  const [editingCell, setEditingCell] = React6.useState(null);
   const headerGroups = table.getHeaderGroups();
   const rowModel = table.getRowModel();
-  const handleCellDoubleClick = React5.useCallback(
+  const handleCellDoubleClick = React6.useCallback(
     (rowId, columnId, columnDef) => {
       if (!enableInlineEdit) return;
       if (!columnDef.meta?.entityMeta?.editable) return;
@@ -5374,7 +6115,7 @@ function DataTable({
     },
     [enableInlineEdit]
   );
-  const handleInlineSave = React5.useCallback(
+  const handleInlineSave = React6.useCallback(
     async (row, columnId, value) => {
       const field = columnId;
       await onInlineSave?.(row.original, field, value);
@@ -5551,7 +6292,7 @@ function GalleryView({
   galleryColumns,
   className
 }) {
-  const [editingId, setEditingId] = React5.useState(null);
+  const [editingId, setEditingId] = React6.useState(null);
   const breakpointClasses = galleryColumns ? buildBreakpointClasses(galleryColumns) : "";
   return /* @__PURE__ */ jsxRuntime.jsx(
     "div",
@@ -5615,7 +6356,7 @@ function GalleryCard({
     (s) => selectionStore ? s.isMultiSelectMode : false
   );
   const storeToggle = useSelectionStore(selStore, (s) => s.toggle);
-  const toggle = React5.useCallback(
+  const toggle = React6.useCallback(
     (id) => {
       if (selectionStore) storeToggle(id);
     },
@@ -5776,7 +6517,7 @@ function ListView({
   getRowId,
   className
 }) {
-  const [editingId, setEditingId] = React5.useState(null);
+  const [editingId, setEditingId] = React6.useState(null);
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: cn("divide-y rounded-md border", className), children: rows.map((row) => {
     const id = getRowId?.(row.original) ?? row.id;
     const isEditing = editingId === id;
@@ -5829,7 +6570,7 @@ function ListItem({
     (s) => selectionStore ? s.isMultiSelectMode : false
   );
   const storeToggle = useSelectionStore(selStore, (s) => s.toggle);
-  const toggle = React5.useCallback(
+  const toggle = React6.useCallback(
     (id) => {
       if (selectionStore) storeToggle(id);
     },
@@ -6023,7 +6764,7 @@ function DataTableToolbar({
   className,
   children
 }) {
-  const [colVisOpen, setColVisOpen] = React5.useState(false);
+  const [colVisOpen, setColVisOpen] = React6.useState(false);
   const globalFilter = table.getState().globalFilter;
   const columnFilters = table.getState().columnFilters;
   const hasFilters = columnFilters.length > 0;
@@ -6191,7 +6932,7 @@ function DataTablePagination({
   totalCount,
   className
 }) {
-  const pageSizeId = React5.useId();
+  const pageSizeId = React6.useId();
   if (mode === "none") return null;
   const state = table.getState();
   const count = totalCount ?? table.getPrePaginationRowModel().rows.length;
@@ -6340,7 +7081,7 @@ function ChevronsRightIcon({ className }) {
   ] });
 }
 function EmptyState({ config, isFiltered = false, className }) {
-  if (React5__default.default.isValidElement(config)) {
+  if (React6__default.default.isValidElement(config)) {
     return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: config });
   }
   const cfg = config ?? {};
@@ -6390,7 +7131,7 @@ function MultiSelectBar({
 }) {
   const selectedIdsSet = useSelectionStore(store, (s) => s.selectedIds);
   const selectedCount = selectedIdsSet.size;
-  const selectedIds = React5.useMemo(() => Array.from(selectedIdsSet), [selectedIdsSet]);
+  const selectedIds = React6.useMemo(() => Array.from(selectedIdsSet), [selectedIdsSet]);
   const deselectAll = useSelectionStore(store, (s) => s.deselectAll);
   useSelectionStore(store, (s) => s.selectAll);
   if (selectedCount === 0) return null;
@@ -6468,11 +7209,11 @@ function PresetPicker({
   pendingChangesCount = 0,
   className
 }) {
-  const [isOpen, setIsOpen] = React5.useState(false);
-  const [activeTab, setActiveTab] = React5.useState("filters");
-  const popoverRef = React5.useRef(null);
-  const triggerRef = React5.useRef(null);
-  React5.useEffect(() => {
+  const [isOpen, setIsOpen] = React6.useState(false);
+  const [activeTab, setActiveTab] = React6.useState("filters");
+  const popoverRef = React6.useRef(null);
+  const triggerRef = React6.useRef(null);
+  React6.useEffect(() => {
     function handleClick(e) {
       if (popoverRef.current && !popoverRef.current.contains(e.target) && !triggerRef.current?.contains(e.target)) {
         setIsOpen(false);
@@ -6643,7 +7384,7 @@ function PresetItem({
   onEdit,
   onDelete
 }) {
-  const [showDeleteConfirm, setShowDeleteConfirm] = React5.useState(false);
+  const [showDeleteConfirm, setShowDeleteConfirm] = React6.useState(false);
   return /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
@@ -6755,13 +7496,13 @@ function FilterPresetDialog({
   preset,
   onSave
 }) {
-  const nameId = React5.useId();
-  const descriptionId = React5.useId();
-  const [name, setName] = React5.useState(preset?.name ?? "");
-  const [description, setDescription] = React5.useState(preset?.description ?? "");
-  const [isDefault, setIsDefault] = React5.useState(preset?.isDefault ?? false);
-  const [logic, setLogic] = React5.useState("and");
-  const [clauses, setClauses] = React5.useState(() => {
+  const nameId = React6.useId();
+  const descriptionId = React6.useId();
+  const [name, setName] = React6.useState(preset?.name ?? "");
+  const [description, setDescription] = React6.useState(preset?.description ?? "");
+  const [isDefault, setIsDefault] = React6.useState(preset?.isDefault ?? false);
+  const [logic, setLogic] = React6.useState("and");
+  const [clauses, setClauses] = React6.useState(() => {
     if (!preset?.filter) return [];
     const filterSpec = preset.filter;
     const rawClauses = Array.isArray(filterSpec) ? filterSpec : filterSpec.clauses ?? [];
@@ -7004,10 +7745,10 @@ function ColumnPresetDialog({
   preset,
   onSave
 }) {
-  const [name, setName] = React5.useState(preset?.name ?? "");
-  const [description, setDescription] = React5.useState(preset?.description ?? "");
-  const [isDefault, setIsDefault] = React5.useState(preset?.isDefault ?? false);
-  const [entries, setEntries] = React5.useState(() => {
+  const [name, setName] = React6.useState(preset?.name ?? "");
+  const [description, setDescription] = React6.useState(preset?.description ?? "");
+  const [isDefault, setIsDefault] = React6.useState(preset?.isDefault ?? false);
+  const [entries, setEntries] = React6.useState(() => {
     if (preset?.columns) return [...preset.columns];
     return columns.map((col, idx) => ({
       id: col.accessorKey ?? col.id ?? `col_${idx}`,
@@ -7017,7 +7758,7 @@ function ColumnPresetDialog({
       pinned: false
     }));
   });
-  const [dragIdx, setDragIdx] = React5.useState(null);
+  const [dragIdx, setDragIdx] = React6.useState(null);
   function updateEntry(id, updates) {
     setEntries(
       (prev) => prev.map((e) => e.id === id ? { ...e, ...updates } : e)
@@ -7290,15 +8031,15 @@ function EntityListView(props) {
     onRefresh,
     className
   } = props;
-  const data = React5.useMemo(
+  const data = React6.useMemo(
     () => viewResult?.items ?? dataProp ?? [],
     [viewResult?.items, dataProp]
   );
-  const selectionStoreRef = React5.useRef(null);
+  const selectionStoreRef = React6.useRef(null);
   if (!selectionStoreRef.current) {
     selectionStoreRef.current = createSelectionStore();
   }
-  const [viewMode, setViewMode] = React5.useState(defaultViewMode);
+  const [viewMode, setViewMode] = React6.useState(defaultViewMode);
   const adapter = useTableStorageAdapter();
   const realtimeMode = useTableRealtimeMode();
   const presets = useTablePresets(tableId ?? "__no_table_id__", {
@@ -7306,10 +8047,10 @@ function EntityListView(props) {
     realtimeMode,
     enabled: enablePresets && !!tableId
   });
-  const [filterDialogOpen, setFilterDialogOpen] = React5.useState(false);
-  const [columnDialogOpen, setColumnDialogOpen] = React5.useState(false);
-  const [editingFilterPreset, setEditingFilterPreset] = React5.useState(null);
-  const [editingColumnPreset, setEditingColumnPreset] = React5.useState(null);
+  const [filterDialogOpen, setFilterDialogOpen] = React6.useState(false);
+  const [columnDialogOpen, setColumnDialogOpen] = React6.useState(false);
+  const [editingFilterPreset, setEditingFilterPreset] = React6.useState(null);
+  const [editingColumnPreset, setEditingColumnPreset] = React6.useState(null);
   const table = useTable({
     data,
     columns,
@@ -7330,7 +8071,7 @@ function EntityListView(props) {
   const prePagRows = table.getPrePaginationRowModel();
   const isEmpty = data.length === 0;
   const isFilteredEmpty = !isEmpty && prePagRows.rows.length === 0;
-  const handleViewModeChange = React5.useCallback(
+  const handleViewModeChange = React6.useCallback(
     (mode) => {
       setViewMode(mode);
       if (enablePresets && tableId) {
@@ -7339,19 +8080,19 @@ function EntityListView(props) {
     },
     [enablePresets, tableId, presets]
   );
-  const handleInlineSaveTable = React5.useCallback(
+  const handleInlineSaveTable = React6.useCallback(
     (item, field, value) => {
       onInlineEdit?.(item, field, value);
     },
     [onInlineEdit]
   );
-  const handleInlineSaveItem = React5.useCallback(
+  const handleInlineSaveItem = React6.useCallback(
     (item, changes) => {
       onInlineSave?.(item, changes);
     },
     [onInlineSave]
   );
-  const handleBatchAction = React5.useCallback(
+  const handleBatchAction = React6.useCallback(
     (actionId, selectedIds) => {
       if (!onBatchAction) return;
       const selectedItems = data.filter((item) => {
@@ -7500,12 +8241,12 @@ function DataTableFilter({
   column,
   className
 }) {
-  const [isOpen, setIsOpen] = React5.useState(false);
-  const popoverRef = React5.useRef(null);
-  const triggerRef = React5.useRef(null);
+  const [isOpen, setIsOpen] = React6.useState(false);
+  const popoverRef = React6.useRef(null);
+  const triggerRef = React6.useRef(null);
   const filterType = column.columnDef.meta?.entityMeta?.filterType ?? "text";
   const isFiltered = column.getIsFiltered();
-  React5.useEffect(() => {
+  React6.useEffect(() => {
     function handleClick(e) {
       if (popoverRef.current && !popoverRef.current.contains(e.target) && !triggerRef.current?.contains(e.target)) {
         setIsOpen(false);
@@ -7563,7 +8304,7 @@ function FilterControl({
   }
 }
 function TextFilter({ column }) {
-  const id = React5.useId();
+  const id = React6.useId();
   const value = column.getFilterValue() ?? "";
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
     /* @__PURE__ */ jsxRuntime.jsx("label", { htmlFor: id, className: "text-xs font-medium", children: "Contains" }),
@@ -7590,8 +8331,8 @@ function TextFilter({ column }) {
   ] });
 }
 function NumberFilter({ column }) {
-  const minId = React5.useId();
-  const maxId = React5.useId();
+  const minId = React6.useId();
+  const maxId = React6.useId();
   const value = column.getFilterValue() ?? [void 0, void 0];
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium", children: "Range" }),
@@ -7695,8 +8436,8 @@ function EnumFilter({ column }) {
   ] });
 }
 function DateFilter({ column }) {
-  const startId = React5.useId();
-  const endId = React5.useId();
+  const startId = React6.useId();
+  const endId = React6.useId();
   const value = column.getFilterValue() ?? [void 0, void 0];
   return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "space-y-2", children: [
     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-xs font-medium", children: "Date range" }),
@@ -7740,13 +8481,13 @@ function selectionColumn2() {
     enableFiltering: false,
     enableHiding: false,
     enableResizing: false,
-    header: ({ table }) => React5__default.default.createElement("input", {
+    header: ({ table }) => React6__default.default.createElement("input", {
       type: "checkbox",
       checked: table.getIsAllPageRowsSelected(),
       onChange: table.getToggleAllPageRowsSelectedHandler(),
       className: "h-4 w-4 rounded border-primary text-primary focus:ring-ring"
     }),
-    cell: ({ row }) => React5__default.default.createElement("input", {
+    cell: ({ row }) => React6__default.default.createElement("input", {
       type: "checkbox",
       checked: row.getIsSelected(),
       onChange: row.getToggleSelectedHandler(),
@@ -7882,7 +8623,7 @@ function enumColumn2(options) {
       const opt = options.options.find((o) => o.value === val);
       if (!opt) return val;
       if (opt.badgeClassName) {
-        return React5__default.default.createElement(
+        return React6__default.default.createElement(
           "span",
           {
             className: `inline-flex items-center rounded px-1.5 py-0.5 text-[11px] font-medium capitalize ${opt.badgeClassName}`
@@ -7890,7 +8631,7 @@ function enumColumn2(options) {
           opt.label
         );
       }
-      return React5__default.default.createElement(
+      return React6__default.default.createElement(
         "span",
         {
           className: "inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium",
@@ -7947,6 +8688,8 @@ exports.GalleryView = GalleryView;
 exports.InlineCellEditor = InlineCellEditor;
 exports.InlineItemEditor = InlineItemEditor;
 exports.ListView = ListView;
+exports.MarkdownFieldEditor = MarkdownFieldEditor;
+exports.MarkdownFieldRenderer = MarkdownFieldRenderer;
 exports.MemoryAdapter = MemoryAdapter;
 exports.MultiSelectBar = MultiSelectBar;
 exports.PresetPicker = PresetPicker;
@@ -7971,6 +8714,7 @@ exports.ZustandPersistAdapter = ZustandPersistAdapter;
 exports.actionsColumn = actionsColumn;
 exports.applyView = applyView;
 exports.booleanColumn = booleanColumn;
+exports.buildEntityFieldsFromSchema = buildEntityFieldsFromSchema;
 exports.cascadeInvalidation = cascadeInvalidation;
 exports.checkCompleteness = checkCompleteness;
 exports.compareEntities = compareEntities;
@@ -7978,10 +8722,15 @@ exports.configureEngine = configureEngine;
 exports.createConvexAdapter = createConvexAdapter;
 exports.createElectricAdapter = createElectricAdapter;
 exports.createGQLClient = createGQLClient;
+exports.createGraphAction = createGraphAction;
+exports.createGraphEffect = createGraphEffect;
 exports.createGraphQLSubscriptionAdapter = createGraphQLSubscriptionAdapter;
+exports.createGraphTool = createGraphTool;
+exports.createGraphTransaction = createGraphTransaction;
 exports.createPresetStore = createPresetStore;
 exports.createPrismaEntityConfig = createPrismaEntityConfig;
 exports.createRow = createRow;
+exports.createSchemaGraphTool = createSchemaGraphTool;
 exports.createSelectionStore = createSelectionStore;
 exports.createSupabaseRealtimeAdapter = createSupabaseRealtimeAdapter;
 exports.createWebSocketAdapter = createWebSocketAdapter;
@@ -7991,10 +8740,13 @@ exports.deleteAction = deleteAction;
 exports.editAction = editAction;
 exports.enumColumn = enumColumn;
 exports.executeGQL = executeGQL;
+exports.exportGraphSnapshot = exportGraphSnapshot;
+exports.exportGraphSnapshotWithSchemas = exportGraphSnapshotWithSchemas;
 exports.fetchEntity = fetchEntity;
 exports.fetchList = fetchList;
 exports.flattenClauses = flattenClauses;
 exports.getCoreRowModel = getCoreRowModel2;
+exports.getEntityJsonSchema = getEntityJsonSchema;
 exports.getExpandedRowModel = getExpandedRowModel;
 exports.getFacetedMinMaxValues = getFacetedMinMaxValues;
 exports.getFacetedRowModel = getFacetedRowModel;
@@ -8007,10 +8759,12 @@ exports.getSchema = getSchema;
 exports.getSelectedRowModel = getSelectedRowModel;
 exports.getSortedRowModel = getSortedRowModel2;
 exports.hasCustomPredicates = hasCustomPredicates;
+exports.hydrateGraphFromStorage = hydrateGraphFromStorage;
 exports.matchesFilter = matchesFilter;
 exports.matchesSearch = matchesSearch;
 exports.normalizeGQLResponse = normalizeGQLResponse;
 exports.numberColumn = numberColumn;
+exports.persistGraphToStorage = persistGraphToStorage;
 exports.prismaRelationsToSchema = prismaRelationsToSchema;
 exports.pureActionsColumn = actionsColumn2;
 exports.pureBooleanColumn = booleanColumn2;
@@ -8019,12 +8773,18 @@ exports.pureEnumColumn = enumColumn2;
 exports.pureNumberColumn = numberColumn2;
 exports.pureSelectionColumn = selectionColumn2;
 exports.pureTextColumn = textColumn2;
+exports.queryOnce = queryOnce;
 exports.readRelations = readRelations;
+exports.registerEntityJsonSchema = registerEntityJsonSchema;
+exports.registerRuntimeSchema = registerRuntimeSchema;
 exports.registerSchema = registerSchema;
+exports.renderMarkdownToHtml = renderMarkdownToHtml;
 exports.resetRealtimeManager = resetRealtimeManager;
+exports.selectGraph = selectGraph;
 exports.selectionColumn = selectionColumn;
 exports.serializeKey = serializeKey;
 exports.startGarbageCollector = startGarbageCollector;
+exports.startLocalFirstGraph = startLocalFirstGraph;
 exports.stopGarbageCollector = stopGarbageCollector;
 exports.textColumn = textColumn;
 exports.toGraphQLVariables = toGraphQLVariables;
@@ -8045,8 +8805,10 @@ exports.useGQLMutation = useGQLMutation;
 exports.useGQLSubscription = useGQLSubscription;
 exports.useGraphDevTools = useGraphDevTools;
 exports.useGraphStore = useGraphStore;
+exports.useGraphSyncStatus = useGraphSyncStatus;
 exports.useLocalFirst = useLocalFirst;
 exports.usePGliteQuery = usePGliteQuery;
+exports.useSchemaEntityFields = useSchemaEntityFields;
 exports.useSelectionContext = useSelectionContext;
 exports.useSelectionStore = useSelectionStore;
 exports.useSuspenseEntity = useSuspenseEntity;