@xnetjs/react 0.12.0 → 2.0.0

package/dist/index.js

@@ -5,7 +5,7 @@ import {
   useInfiniteQuery,
   useIsOffline,
   useNode
-} from "./chunk-Q3NDLI6Z.js";
+} from "./chunk-VZMZQTR7.js";
 import {
   useCell,
   useDatabase,
@@ -14,7 +14,7 @@ import {
   useDatabaseSchema,
   useRelatedRows,
   useReverseRelations
-} from "./chunk-WL7OCTSM.js";
+} from "./chunk-HTFAHJQK.js";
 import {
   AuthErrorScreen,
   AuthenticatingScreen,
@@ -94,7 +94,7 @@ import {
   useUndo,
   useVerification,
   useVisibleComments
-} from "./chunk-SEYIZDHG.js";
+} from "./chunk-ANCTAEML.js";
 import {
   EMPTY_PAGE_INFO,
   computeFallbackPageInfo,
@@ -106,10 +106,10 @@ import {
   useMutate,
   useQuery,
   useSyncManager
-} from "./chunk-EJEGIEIC.js";
+} from "./chunk-ZGP56IIJ.js";
 import {
   useUndoScope
-} from "./chunk-BDBDZXYS.js";
+} from "./chunk-SZQNGRTO.js";
 import {
   InstrumentationContext,
   useInstrumentation
@@ -122,6 +122,7 @@ import {
   TracingContext,
   XNetContext,
   XNetProvider,
+  mergeEditorContributions,
   useCommand,
   useCommands,
   useContributions,
@@ -129,6 +130,7 @@ import {
   useEditorExtensions,
   useEditorExtensionsSafe,
   useImporters,
+  useMergedEditorContributions,
   useNodeStore,
   usePluginRegistry,
   usePluginRegistryOptional,
@@ -142,7 +144,7 @@ import {
   useView,
   useViews,
   useXNet
-} from "./chunk-RIN2MXZK.js";
+} from "./chunk-H44ZSIH4.js";
 
 // src/hooks/useEffectiveSchema.ts
 import {
@@ -4205,6 +4207,92 @@ function formatSavedViewInspectorValue(key, value) {
   return formatSavedViewCellValue(key, value);
 }
 
+// src/hooks/usePresence.ts
+import { useCallback as useCallback2, useEffect as useEffect5, useRef as useRef3, useState as useState5 } from "react";
+function readPeers(awareness, ownKeys) {
+  const peers = [];
+  awareness.getStates().forEach((state, clientId) => {
+    if (clientId === awareness.clientID || !state) return;
+    for (const key of ownKeys) {
+      if (key in state) {
+        peers.push({ clientId, state });
+        return;
+      }
+    }
+  });
+  return peers;
+}
+function usePresence(awareness, initialState, options = {}) {
+  const { throttleMs = 33 } = options;
+  const [peers, setPeers] = useState5([]);
+  const [clientId, setClientId] = useState5(null);
+  const ownKeysRef = useRef3(new Set(Object.keys(initialState)));
+  const initialStateRef = useRef3(initialState);
+  initialStateRef.current = initialState;
+  const awarenessRef = useRef3(null);
+  const pendingRef = useRef3({});
+  const lastBroadcastRef = useRef3(0);
+  const timerRef = useRef3(null);
+  const flush = useCallback2(() => {
+    const aw = awarenessRef.current;
+    if (!aw) return;
+    lastBroadcastRef.current = Date.now();
+    const patch = pendingRef.current;
+    pendingRef.current = {};
+    aw.setLocalState({ ...aw.getLocalState() ?? {}, ...patch });
+  }, []);
+  const setState = useCallback2(
+    (patch) => {
+      for (const key of Object.keys(patch)) ownKeysRef.current.add(key);
+      pendingRef.current = { ...pendingRef.current, ...patch };
+      const elapsed = Date.now() - lastBroadcastRef.current;
+      if (elapsed >= throttleMs) {
+        flush();
+      } else if (timerRef.current === null) {
+        timerRef.current = setTimeout(() => {
+          timerRef.current = null;
+          flush();
+        }, throttleMs - elapsed);
+      }
+    },
+    [flush, throttleMs]
+  );
+  useEffect5(() => {
+    if (!awareness) {
+      awarenessRef.current = null;
+      setClientId(null);
+      setPeers([]);
+      return;
+    }
+    awarenessRef.current = awareness;
+    setClientId(awareness.clientID);
+    const ownKeys = ownKeysRef.current;
+    awareness.setLocalState({
+      ...awareness.getLocalState() ?? {},
+      ...initialStateRef.current
+    });
+    lastBroadcastRef.current = Date.now();
+    const handleChange = () => {
+      setPeers(readPeers(awareness, ownKeysRef.current));
+    };
+    handleChange();
+    awareness.on("change", handleChange);
+    return () => {
+      awareness.off("change", handleChange);
+      if (timerRef.current !== null) {
+        clearTimeout(timerRef.current);
+        timerRef.current = null;
+      }
+      pendingRef.current = {};
+      const remaining = { ...awareness.getLocalState() ?? {} };
+      for (const key of ownKeys) delete remaining[key];
+      awareness.setLocalState(remaining);
+      if (awarenessRef.current === awareness) awarenessRef.current = null;
+    };
+  }, [awareness]);
+  return { peers, setState, clientId };
+}
+
 // src/hooks/useCanvasTaskSync.ts
 function useCanvasTaskSync({
   canvasId,
@@ -4237,7 +4325,7 @@ import {
   convertCellValue,
   FormulaService
 } from "@xnetjs/data";
-import { useCallback as useCallback2, useEffect as useEffect5, useMemo as useMemo5, useRef as useRef3, useState as useState5 } from "react";
+import { useCallback as useCallback3, useEffect as useEffect6, useMemo as useMemo5, useRef as useRef4, useState as useState6 } from "react";
 function toFieldModel(node) {
   return {
     id: node.id,
@@ -4358,8 +4446,8 @@ function useGridDatabase(databaseId, options = {}) {
     return effective.map((e) => e.field);
   }, [fields, activeView]);
   const { store } = useNodeStore();
-  const [rollupValues, setRollupValues] = useState5(/* @__PURE__ */ new Map());
-  useEffect5(() => {
+  const [rollupValues, setRollupValues] = useState6(/* @__PURE__ */ new Map());
+  useEffect6(() => {
     const rollupFields = fields.filter((f) => f.type === "rollup");
     if (rollupFields.length === 0 || !store) {
       setRollupValues((prev) => prev.size > 0 ? /* @__PURE__ */ new Map() : prev);
@@ -4459,11 +4547,11 @@ function useGridDatabase(databaseId, options = {}) {
     return sortRows(filtered, columns, activeView.sorts);
   }, [rowNodes, activeView, fields, databaseId, rollupValues]);
   const loading = dbStatus === "loading" || fieldStatus === "loading" || viewStatus === "loading" || rowStatus === "loading";
-  const rowTailRef = useRef3(void 0);
-  const fieldTailRef = useRef3(void 0);
-  const viewTailRef = useRef3(void 0);
-  const optionTailRef = useRef3(/* @__PURE__ */ new Map());
-  useEffect5(() => {
+  const rowTailRef = useRef4(void 0);
+  const fieldTailRef = useRef4(void 0);
+  const viewTailRef = useRef4(void 0);
+  const optionTailRef = useRef4(/* @__PURE__ */ new Map());
+  useEffect6(() => {
     const dataTail = rows.reduce(
       (max, r) => !max || compareSortKeys(r.sortKey, max) > 0 ? r.sortKey : max,
       void 0
@@ -4472,19 +4560,19 @@ function useGridDatabase(databaseId, options = {}) {
       rowTailRef.current = dataTail;
     }
   }, [rows]);
-  useEffect5(() => {
+  useEffect6(() => {
     const dataTail = fields[fields.length - 1]?.sortKey;
     if (dataTail && (!fieldTailRef.current || compareSortKeys(dataTail, fieldTailRef.current) > 0)) {
       fieldTailRef.current = dataTail;
     }
   }, [fields]);
-  useEffect5(() => {
+  useEffect6(() => {
     const dataTail = views[views.length - 1]?.sortKey;
     if (dataTail && (!viewTailRef.current || compareSortKeys(dataTail, viewTailRef.current) > 0)) {
       viewTailRef.current = dataTail;
     }
   }, [views]);
-  useEffect5(() => {
+  useEffect6(() => {
     for (const [fieldId, list] of optionsByField) {
       const dataTail = list[list.length - 1]?.sortKey;
       const current = optionTailRef.current.get(fieldId);
@@ -4493,7 +4581,7 @@ function useGridDatabase(databaseId, options = {}) {
       }
     }
   }, [optionsByField]);
-  const nextAppendKey = useCallback2((tailRef) => {
+  const nextAppendKey = useCallback3((tailRef) => {
     const key = generateSortKey(tailRef.current, void 0);
     tailRef.current = key;
     return key;
@@ -4511,19 +4599,19 @@ function useGridDatabase(databaseId, options = {}) {
     localDID: did ?? null,
     options: { localOnly: true }
   });
-  const updateRowProps = useCallback2(
+  const updateRowProps = useCallback3(
     async (rowId, properties) => {
       await mutate.update(DatabaseRowSchema, rowId, properties);
     },
     [mutate]
   );
-  const updateCell = useCallback2(
+  const updateCell = useCallback3(
     async (rowId, fieldId, value) => {
       await updateRowProps(rowId, { [cellKey(fieldId)]: value });
     },
     [updateRowProps]
   );
-  const clearCells = useCallback2(
+  const clearCells = useCallback3(
     async (cells) => {
       const byRow = /* @__PURE__ */ new Map();
       for (const { rowId, fieldId } of cells) {
@@ -4535,7 +4623,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [updateRowProps]
   );
-  const addRow = useCallback2(
+  const addRow = useCallback3(
     async (afterRowId, cells, opts) => {
       let sortKey;
       if (afterRowId) {
@@ -4570,13 +4658,13 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, databaseId, rows, nextAppendKey]
   );
-  const deleteRows = useCallback2(
+  const deleteRows = useCallback3(
     async (rowIds) => {
       await Promise.all(rowIds.map((id) => mutate.remove(id)));
     },
     [mutate]
   );
-  const moveRowToIndex = useCallback2(
+  const moveRowToIndex = useCallback3(
     async (rowId, targetIndex) => {
       if (activeView && activeView.sorts.length > 0) return;
       const ordered = rows.map((r) => ({ id: r.id, key: r.sortKey }));
@@ -4585,7 +4673,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [rows, activeView, updateRowProps]
   );
-  const createOption = useCallback2(
+  const createOption = useCallback3(
     async (fieldId, name) => {
       const existing = optionsByField.get(fieldId) ?? [];
       const match = existing.find((o) => o.name.toLowerCase() === name.toLowerCase());
@@ -4604,7 +4692,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, databaseId, optionsByField]
   );
-  const addField = useCallback2(
+  const addField = useCallback3(
     async (name, type, config, opts) => {
       const node = await mutate.create(DatabaseFieldSchema, {
         database: databaseId,
@@ -4619,13 +4707,13 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, databaseId, nextAppendKey]
   );
-  const renameField = useCallback2(
+  const renameField = useCallback3(
     async (fieldId, name) => {
       await mutate.update(DatabaseFieldSchema, fieldId, { name });
     },
     [mutate]
   );
-  const updateFieldConfig = useCallback2(
+  const updateFieldConfig = useCallback3(
     async (fieldId, config) => {
       await mutate.update(DatabaseFieldSchema, fieldId, {
         config
@@ -4633,7 +4721,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate]
   );
-  const changeFieldType = useCallback2(
+  const changeFieldType = useCallback3(
     async (fieldId, type) => {
       const field = fields.find((f) => f.id === fieldId);
       const sourceType = field?.type ?? "text";
@@ -4670,7 +4758,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, fields, rows, createOption, updateRowProps]
   );
-  const removeField = useCallback2(
+  const removeField = useCallback3(
     async (fieldId) => {
       const orphanedOptions = optionsByField.get(fieldId) ?? [];
       await Promise.all(orphanedOptions.map((o) => mutate.remove(o.id)));
@@ -4678,7 +4766,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, optionsByField]
   );
-  const moveFieldToIndex = useCallback2(
+  const moveFieldToIndex = useCallback3(
     async (fieldId, targetIndex) => {
       if (!activeView) return;
       const ordered = visibleFields.map((f) => ({
@@ -4692,7 +4780,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, activeView, visibleFields, fields]
   );
-  const resizeField = useCallback2(
+  const resizeField = useCallback3(
     async (fieldId, width) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, {
@@ -4701,7 +4789,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, activeView]
   );
-  const setFieldHiddenInView = useCallback2(
+  const setFieldHiddenInView = useCallback3(
     async (fieldId, hidden) => {
       if (!activeView) return;
       const set = new Set(activeView.hiddenFields);
@@ -4711,7 +4799,7 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, activeView]
   );
-  const toggleSort = useCallback2(
+  const toggleSort = useCallback3(
     async (fieldId) => {
       if (!activeView) return;
       const current = activeView.sorts.find((s) => s.columnId === fieldId);
@@ -4727,28 +4815,28 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, activeView]
   );
-  const setFilters = useCallback2(
+  const setFilters = useCallback3(
     async (filters) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, { filters });
     },
     [mutate, activeView]
   );
-  const setGroupBy = useCallback2(
+  const setGroupBy = useCallback3(
     async (fieldId) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, { groupBy: fieldId ?? void 0 });
     },
     [mutate, activeView]
   );
-  const setRowHeight = useCallback2(
+  const setRowHeight = useCallback3(
     async (rowHeight) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, { rowHeight });
     },
     [mutate, activeView]
   );
-  const setColumnSummary = useCallback2(
+  const setColumnSummary = useCallback3(
     async (fieldId, fn) => {
       if (!activeView) return;
       const next = { ...activeView.columnSummaries };
@@ -4758,28 +4846,28 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, activeView]
   );
-  const setFormConfig = useCallback2(
+  const setFormConfig = useCallback3(
     async (config) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, { formConfig: config });
     },
     [mutate, activeView]
   );
-  const setFormRules = useCallback2(
+  const setFormRules = useCallback3(
     async (rules) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, { formRules: rules });
     },
     [mutate, activeView]
   );
-  const setFormAccepting = useCallback2(
+  const setFormAccepting = useCallback3(
     async (accepting) => {
       if (!activeView) return;
       await mutate.update(DatabaseViewSchema, activeView.id, { formAccepting: accepting });
     },
     [mutate, activeView]
   );
-  const addView = useCallback2(
+  const addView = useCallback3(
     async (name, type) => {
       const node = await mutate.create(DatabaseViewSchema, {
         database: databaseId,
@@ -4791,13 +4879,13 @@ function useGridDatabase(databaseId, options = {}) {
     },
     [mutate, databaseId, nextAppendKey]
   );
-  const renameView = useCallback2(
+  const renameView = useCallback3(
     async (id, name) => {
       await mutate.update(DatabaseViewSchema, id, { name });
     },
     [mutate]
   );
-  const removeView = useCallback2(
+  const removeView = useCallback3(
     async (id) => {
       await mutate.remove(id);
     },
@@ -4843,8 +4931,531 @@ function useGridDatabase(databaseId, options = {}) {
   };
 }
 
+// src/hooks/useTimeMachine.ts
+import { CHECKPOINT_SCHEMA_IRI } from "@xnetjs/data";
+import {
+  HistoryEngine,
+  HistoryHorizonError,
+  MemorySnapshotStorage,
+  ScopeTimeline,
+  SnapshotCache,
+  createCheckpoint,
+  listCheckpoints,
+  restoreToFrontier
+} from "@xnetjs/history";
+import { useCallback as useCallback4, useEffect as useEffect7, useMemo as useMemo6, useRef as useRef5, useState as useState7 } from "react";
+function useTimeMachine(nodeId, options) {
+  const { store, isReady } = useNodeStore();
+  const memberKey = options?.memberIds?.join(",") ?? "";
+  const members = useMemo6(() => {
+    if (!nodeId) return [];
+    const extra = options?.memberIds ?? [];
+    return [nodeId, ...extra.filter((id) => id !== nodeId)];
+  }, [nodeId, memberKey]);
+  const [timeline, setTimeline] = useState7([]);
+  const [checkpoints, setCheckpoints] = useState7([]);
+  const [horizon, setHorizon] = useState7(null);
+  const [docSnapshotCount, setDocSnapshotCount] = useState7(null);
+  const [loading, setLoading] = useState7(false);
+  const [error, setError] = useState7(null);
+  const [rawPosition, setRawPosition] = useState7(null);
+  const position = rawPosition === null ? Math.max(0, timeline.length - 1) : Math.max(0, Math.min(rawPosition, timeline.length - 1));
+  const atLatest = timeline.length === 0 || position === timeline.length - 1;
+  const [preview, setPreview] = useState7(null);
+  const [diffs, setDiffs] = useState7([]);
+  const engineRef = useRef5(null);
+  const getEngines = useCallback4(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      const snapshots = new SnapshotCache(new MemorySnapshotStorage(), { interval: 50 });
+      engineRef.current = {
+        engine: new HistoryEngine(storage, snapshots),
+        scope: new ScopeTimeline(storage),
+        storage
+      };
+    }
+    return engineRef.current;
+  }, [store]);
+  const reload = useCallback4(async () => {
+    if (!nodeId || !isReady || !store) return;
+    const engines = getEngines();
+    if (!engines) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const [line, nodeHorizon, named] = await Promise.all([
+        engines.scope.getMergedTimeline(members),
+        engines.engine.getHorizon(nodeId),
+        listCheckpoints(store, nodeId)
+      ]);
+      setTimeline(line);
+      setHorizon(nodeHorizon);
+      setCheckpoints(named);
+      const snapshotStorage = engines.storage;
+      if (typeof snapshotStorage.getYjsSnapshots === "function") {
+        const snapshots = await snapshotStorage.getYjsSnapshots(nodeId);
+        setDocSnapshotCount(snapshots.length);
+      } else {
+        setDocSnapshotCount(null);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [nodeId, isReady, store, members, getEngines]);
+  useEffect7(() => {
+    setRawPosition(null);
+    void reload();
+  }, [reload]);
+  useEffect7(() => {
+    if (!store || !nodeId) return;
+    const memberSet = new Set(members);
+    const unsub = store.subscribe((event) => {
+      if (memberSet.has(event.change.payload.nodeId) || event.change.payload.schemaId === CHECKPOINT_SCHEMA_IRI) {
+        void reload();
+      }
+    });
+    return unsub;
+  }, [store, nodeId, members, reload]);
+  useEffect7(() => {
+    let cancelled = false;
+    const engines = getEngines();
+    if (!nodeId || !engines || timeline.length === 0) {
+      setPreview(null);
+      setDiffs([]);
+      return;
+    }
+    let hash = null;
+    for (let i = position; i >= 0; i--) {
+      if (timeline[i].nodeId === nodeId) {
+        hash = timeline[i].change.hash;
+        break;
+      }
+    }
+    if (!hash) {
+      setPreview(null);
+      setDiffs([]);
+      return;
+    }
+    const target = { type: "hash", hash };
+    Promise.all([
+      engines.engine.materializeAt(nodeId, target),
+      engines.engine.diff(nodeId, target, { type: "latest" })
+    ]).then(([state, propertyDiffs]) => {
+      if (cancelled) return;
+      setPreview(state.node);
+      setDiffs(propertyDiffs);
+    }).catch((err) => {
+      if (cancelled) return;
+      setPreview(null);
+      setDiffs([]);
+      if (err instanceof HistoryHorizonError) {
+        setHorizon(err.horizon);
+      } else {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [nodeId, timeline, position, getEngines]);
+  const setPosition = useCallback4(
+    (index) => {
+      const max = timeline.length - 1;
+      const clamped = Math.max(0, Math.min(index, max));
+      setRawPosition(clamped >= max ? null : clamped);
+    },
+    [timeline.length]
+  );
+  const stepBack = useCallback4(() => setPosition(position - 1), [setPosition, position]);
+  const stepForward = useCallback4(() => setPosition(position + 1), [setPosition, position]);
+  const goToLatest = useCallback4(() => setRawPosition(null), []);
+  const createNamedVersion = useCallback4(
+    async (name, note) => {
+      if (!nodeId || !store) return null;
+      const engines = getEngines();
+      if (!engines) return null;
+      try {
+        const checkpoint = await createCheckpoint(store, engines.storage, {
+          name,
+          ...note !== void 0 ? { note } : {},
+          nodeIds: members,
+          scopeId: nodeId
+        });
+        await reload();
+        return checkpoint;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [nodeId, store, members, getEngines, reload]
+  );
+  const positionOfCheckpoint = useCallback4(
+    (checkpoint) => {
+      const frontier = checkpoint.properties.frontier;
+      if (!frontier) return null;
+      let best = -1;
+      for (let i = 0; i < timeline.length; i++) {
+        const pinned = frontier[timeline[i].nodeId];
+        if (pinned && pinned.hash === timeline[i].change.hash) {
+          best = Math.max(best, i);
+        }
+      }
+      return best >= 0 ? best : null;
+    },
+    [timeline]
+  );
+  const frontierAt = useCallback4(
+    (index) => {
+      const scope = getEngines()?.scope;
+      if (!scope) return {};
+      return scope.frontierAtPosition(timeline, index);
+    },
+    [getEngines, timeline]
+  );
+  const restore = useCallback4(async () => {
+    if (!nodeId || !store || timeline.length === 0) return null;
+    const engines = getEngines();
+    if (!engines) return null;
+    try {
+      const frontier = engines.scope.frontierAtPosition(timeline, position);
+      const result = await restoreToFrontier(store, engines.engine, frontier, members);
+      setRawPosition(null);
+      await reload();
+      return result;
+    } catch (err) {
+      if (err instanceof HistoryHorizonError) setHorizon(err.horizon);
+      setError(err instanceof Error ? err : new Error(String(err)));
+      return null;
+    }
+  }, [nodeId, store, timeline, position, members, getEngines, reload]);
+  return {
+    timeline,
+    changeCount: timeline.length,
+    position,
+    atLatest,
+    setPosition,
+    stepBack,
+    stepForward,
+    goToLatest,
+    preview,
+    diffs,
+    horizon,
+    docSnapshotCount,
+    checkpoints,
+    createNamedVersion,
+    positionOfCheckpoint,
+    frontierAt,
+    restore,
+    loading,
+    error,
+    reload
+  };
+}
+
+// src/hooks/useDraft.ts
+import { DRAFT_SCHEMA_IRI, DatabaseRowSchema as DatabaseRowSchema2, DatabaseSchema as DatabaseSchema2 } from "@xnetjs/data";
+import {
+  HistoryEngine as HistoryEngine2,
+  MemorySnapshotStorage as MemorySnapshotStorage2,
+  SnapshotCache as SnapshotCache2,
+  createDraft as createDraftNode,
+  discardDraft,
+  draftEntries,
+  forkNodeIntoDraft,
+  listDrafts,
+  mergeDraft,
+  refreshDraftFromMain,
+  threeWayPropertyMerge
+} from "@xnetjs/history";
+import { useCallback as useCallback5, useEffect as useEffect8, useRef as useRef6, useState as useState8 } from "react";
+var baseIRI = (schemaId) => schemaId.split("@")[0];
+async function resolveMembers(store, hostId) {
+  const members = [hostId];
+  const host = await store.getRaw(hostId);
+  if (host && baseIRI(host.schemaId) === baseIRI(DatabaseSchema2.schema["@id"])) {
+    const rows = await store.list({ schemaId: DatabaseRowSchema2.schema["@id"] });
+    for (const row of rows) {
+      if (row.properties.database === hostId) members.push(row.id);
+    }
+  }
+  return members;
+}
+function clonesFromEntries(draft) {
+  const clones = {};
+  for (const [originalId, entry] of Object.entries(draftEntries(draft))) {
+    clones[originalId] = entry.cloneId;
+  }
+  return clones;
+}
+function useDraft(hostId) {
+  const { store, isReady } = useNodeStore();
+  const [drafts, setDrafts] = useState8([]);
+  const [checkedOut, setCheckedOut] = useState8(null);
+  const [loading, setLoading] = useState8(false);
+  const [error, setError] = useState8(null);
+  const engineRef = useRef6(null);
+  const getEngines = useCallback5(() => {
+    if (!store) return null;
+    const storage = store.getStorageAdapter();
+    if (!storage) return null;
+    if (!engineRef.current || engineRef.current.storage !== storage) {
+      engineRef.current = {
+        engine: new HistoryEngine2(
+          storage,
+          new SnapshotCache2(new MemorySnapshotStorage2(), { interval: 50 })
+        ),
+        storage
+      };
+    }
+    return engineRef.current;
+  }, [store]);
+  const draftIdsRef = useRef6(/* @__PURE__ */ new Set());
+  const reload = useCallback5(async () => {
+    if (!hostId || !isReady || !store) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const open = await listDrafts(store, hostId);
+      setDrafts(open);
+      for (const draft of open) draftIdsRef.current.add(draft.id);
+      const overlay = store.getCheckedOutDraft();
+      if (overlay) {
+        const draftNode = await store.getRaw(overlay.draftId);
+        setCheckedOut(
+          draftNode && draftNode.properties.status === "open" && draftNode.properties.target === hostId ? draftNode : null
+        );
+      } else {
+        setCheckedOut(null);
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setLoading(false);
+    }
+  }, [hostId, isReady, store]);
+  useEffect8(() => {
+    void reload();
+  }, [reload]);
+  useEffect8(() => {
+    if (!store || !hostId) return;
+    const unsubStore = store.subscribe((event) => {
+      if (event.change.payload.schemaId === DRAFT_SCHEMA_IRI || draftIdsRef.current.has(event.change.payload.nodeId)) {
+        void reload();
+      }
+    });
+    const unsubOverlay = store.subscribeToDraftOverlay(() => void reload());
+    return () => {
+      unsubStore();
+      unsubOverlay();
+    };
+  }, [store, hostId, reload]);
+  const checkout = useCallback5(
+    async (draftId) => {
+      if (!hostId || !store) return false;
+      const engines = getEngines();
+      if (!engines) return false;
+      try {
+        const draft = await store.getRaw(draftId);
+        if (!draft || draft.properties.status !== "open") return false;
+        const members = await resolveMembers(store, hostId);
+        store.setCheckedOutDraft({
+          draftId,
+          members,
+          clones: clonesFromEntries(draft),
+          // Lazy copy-on-write: the first write to an unforked member clones
+          // it. Returning null declines — the write then targets the
+          // original (never-fork schemas stay live by policy).
+          onMissingMember: async (originalId) => {
+            try {
+              const entry = await forkNodeIntoDraft(store, engines.storage, draftId, originalId);
+              return entry.cloneId;
+            } catch {
+              return null;
+            }
+          }
+        });
+        await reload();
+        return true;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return false;
+      }
+    },
+    [hostId, store, getEngines, reload]
+  );
+  const returnToMain = useCallback5(() => {
+    if (!store) return;
+    store.setCheckedOutDraft(null);
+  }, [store]);
+  const createDraft = useCallback5(
+    async (name) => {
+      if (!hostId || !store) return null;
+      try {
+        const draft = await createDraftNode(store, { name, targetId: hostId });
+        await checkout(draft.id);
+        return draft;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [hostId, store, checkout]
+  );
+  const discard = useCallback5(
+    async (draftId) => {
+      if (!store) return false;
+      const engines = getEngines();
+      if (!engines) return false;
+      try {
+        if (store.getCheckedOutDraft()?.draftId === draftId) {
+          store.setCheckedOutDraft(null);
+        }
+        await discardDraft(store, engines.storage, draftId);
+        await reload();
+        return true;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return false;
+      }
+    },
+    [store, getEngines, reload]
+  );
+  const merge = useCallback5(
+    async (draftId) => {
+      if (!store) return null;
+      const engines = getEngines();
+      if (!engines) return null;
+      try {
+        const result = await mergeDraft(store, engines.storage, engines.engine, draftId);
+        if (result.status === "merged" && store.getCheckedOutDraft()?.draftId === draftId) {
+          store.setCheckedOutDraft(null);
+        }
+        await reload();
+        return result;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, getEngines, reload]
+  );
+  const refresh = useCallback5(
+    async (draftId) => {
+      if (!store) return null;
+      const engines = getEngines();
+      if (!engines) return null;
+      try {
+        const result = await refreshDraftFromMain(store, engines.storage, engines.engine, draftId);
+        await reload();
+        return result;
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, getEngines, reload]
+  );
+  const setReviewRequested = useCallback5(
+    async (draftId, requested) => {
+      if (!store) return;
+      try {
+        await store.update(draftId, { properties: { reviewRequested: requested } });
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    },
+    [store]
+  );
+  const computeReview = useCallback5(
+    async (draftId) => {
+      if (!store) return null;
+      const engines = getEngines();
+      if (!engines) return null;
+      try {
+        const draft = await store.getRaw(draftId);
+        if (!draft) return null;
+        const cards = [];
+        const members = [];
+        for (const [id, entry] of Object.entries(draftEntries(draft))) {
+          const originalId = id;
+          const cloneId = entry.cloneId;
+          const [base, ours, theirs] = await Promise.all([
+            engines.engine.materializeAt(originalId, {
+              type: "hash",
+              hash: entry.forkedAtHash
+            }),
+            store.getRaw(originalId),
+            store.getRaw(cloneId)
+          ]);
+          if (!ours || !theirs) continue;
+          const result = threeWayPropertyMerge(
+            base.node.properties,
+            ours.properties,
+            theirs.properties
+          );
+          for (const [property, draftValue] of Object.entries(result.patch)) {
+            cards.push({
+              originalId,
+              property,
+              base: base.node.properties[property],
+              main: ours.properties[property],
+              draft: draftValue,
+              conflict: false
+            });
+          }
+          for (const conflict of result.conflicts) {
+            cards.push({
+              originalId,
+              property: conflict.property,
+              base: conflict.base,
+              main: conflict.ours,
+              draft: conflict.theirs,
+              conflict: true
+            });
+          }
+          const hasDocument = Boolean(entry.forkedAtYjsStateVector);
+          let documentDiffers = false;
+          if (hasDocument) {
+            const [cloneBlob, mainBlob] = await Promise.all([
+              engines.storage.getDocumentContent(cloneId),
+              engines.storage.getDocumentContent(originalId)
+            ]);
+            documentDiffers = (cloneBlob?.length ?? 0) !== (mainBlob?.length ?? 0);
+          }
+          members.push({ originalId, cloneId, hasDocument, documentDiffers });
+        }
+        return { cards, members };
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+        return null;
+      }
+    },
+    [store, getEngines]
+  );
+  return {
+    drafts,
+    checkedOut,
+    createDraft,
+    checkout,
+    returnToMain,
+    discard,
+    merge,
+    refresh,
+    setReviewRequested,
+    computeReview,
+    loading,
+    error,
+    reload
+  };
+}
+
 // src/hooks/useGlobalUndo.ts
-import { useCallback as useCallback3, useContext, useEffect as useEffect6, useReducer } from "react";
+import { useCallback as useCallback6, useContext, useEffect as useEffect9, useReducer } from "react";
 function readUndoContext(ctx) {
   if (!ctx) return { undoManager: null, nodeStore: null };
   return { undoManager: ctx.undoManager, nodeStore: ctx.nodeStore };
@@ -4853,17 +5464,17 @@ function useGlobalUndo() {
   const ctx = useContext(XNetContext);
   const { undoManager, nodeStore } = readUndoContext(ctx);
   const [, bump] = useReducer((n) => n + 1, 0);
-  useEffect6(() => {
+  useEffect9(() => {
     if (!nodeStore) return;
     return nodeStore.subscribe(() => bump());
   }, [nodeStore]);
-  const undo = useCallback3(async () => {
+  const undo = useCallback6(async () => {
     if (!undoManager) return false;
     const ok = await undoManager.undoLatest();
     bump();
     return ok;
   }, [undoManager]);
-  const redo = useCallback3(async () => {
+  const redo = useCallback6(async () => {
     if (!undoManager) return false;
     const ok = await undoManager.redoLatest();
     bump();
@@ -4877,6 +5488,57 @@ function useGlobalUndo() {
   };
 }
 
+// src/hooks/useCanCreate.ts
+import { useEffect as useEffect10, useMemo as useMemo7, useRef as useRef7, useState as useState9 } from "react";
+var INITIAL_STATE = {
+  canCreate: false,
+  loading: true,
+  error: null
+};
+function useCanCreate(schemaId, properties) {
+  const { store, isReady } = useNodeStore();
+  const [state, setState] = useState9(INITIAL_STATE);
+  const requestRef = useRef7(0);
+  const propertiesKey = useMemo7(() => JSON.stringify(properties ?? {}), [properties]);
+  useEffect10(() => {
+    if (!store || !isReady) {
+      setState((prev) => ({ ...prev, loading: true }));
+      return;
+    }
+    if (!store.auth) {
+      setState({
+        ...INITIAL_STATE,
+        loading: false,
+        error: new Error("Authorization API is not configured on this NodeStore")
+      });
+      return;
+    }
+    const run = async () => {
+      const requestId = ++requestRef.current;
+      setState((prev) => ({ ...prev, loading: true, error: null }));
+      try {
+        const decision = await store.auth.can({
+          action: "create",
+          // A synthetic id: the draft node must not collide with a stored one.
+          nodeId: `draft:${schemaId}`,
+          node: {
+            schemaId,
+            properties: JSON.parse(propertiesKey)
+          }
+        });
+        if (requestRef.current !== requestId) return;
+        setState({ canCreate: decision.allowed, loading: false, error: null });
+      } catch (error) {
+        if (requestRef.current !== requestId) return;
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        setState((prev) => ({ ...prev, loading: false, error: normalized }));
+      }
+    };
+    void run();
+  }, [isReady, propertiesKey, schemaId, store]);
+  return state;
+}
+
 // src/index.ts
 import { WebSocketSyncProvider } from "@xnetjs/runtime";
 import {
@@ -4907,7 +5569,7 @@ import {
 } from "@xnetjs/runtime";
 
 // src/hooks/useBilling.ts
-import { useCallback as useCallback4, useContext as useContext2, useEffect as useEffect7, useMemo as useMemo6, useState as useState6 } from "react";
+import { useCallback as useCallback7, useContext as useContext2, useEffect as useEffect11, useMemo as useMemo8, useState as useState10 } from "react";
 var toHttpUrl = (hubUrl) => {
   try {
     const url = new URL(hubUrl);
@@ -4944,20 +5606,20 @@ function deriveBilling(state) {
 }
 function useBilling() {
   const context = useContext2(XNetContext);
-  const [state, setState] = useState6(null);
-  const [loading, setLoading] = useState6(
+  const [state, setState] = useState10(null);
+  const [loading, setLoading] = useState10(
     Boolean(context?.hubUrl || context?.billing?.apiBase)
   );
-  const [error, setError] = useState6(null);
-  const apiBase = useMemo6(() => {
+  const [error, setError] = useState10(null);
+  const apiBase = useMemo8(() => {
     if (context?.billing?.apiBase) return context.billing.apiBase.replace(/\/$/, "");
     return context?.hubUrl ? toHttpUrl(context.hubUrl) : null;
   }, [context?.billing?.apiBase, context?.hubUrl]);
-  const authHeaders = useCallback4(async () => {
+  const authHeaders = useCallback7(async () => {
     const token = context?.getHubAuthToken ? await context.getHubAuthToken() : "";
     return token ? { Authorization: `Bearer ${token}` } : {};
   }, [context]);
-  const reload = useCallback4(async () => {
+  const reload = useCallback7(async () => {
     if (!apiBase) {
       setState(null);
       setLoading(false);
@@ -4975,10 +5637,10 @@ function useBilling() {
       setLoading(false);
     }
   }, [apiBase, authHeaders]);
-  useEffect7(() => {
+  useEffect11(() => {
     void reload();
   }, [reload]);
-  const redirectVia = useCallback4(
+  const redirectVia = useCallback7(
     async (path, body) => {
       if (!apiBase) throw new Error("Hub URL not configured");
       const res = await fetch(`${apiBase}${path}`, {
@@ -4992,11 +5654,11 @@ function useBilling() {
     },
     [apiBase, authHeaders]
   );
-  const openCheckout = useCallback4(
+  const openCheckout = useCallback7(
     (priceRef, options = {}) => redirectVia("/billing/checkout", buildCheckoutBody(priceRef, options)),
     [redirectVia]
   );
-  const openPortal = useCallback4(
+  const openPortal = useCallback7(
     (returnUrl) => redirectVia("/billing/portal", returnUrl ? { returnUrl } : {}),
     [redirectVia]
   );
@@ -5102,6 +5764,7 @@ export {
   isReactionVisible,
   isSavedViewVisualPreviewEmbeddable,
   isTaskOverdue,
+  mergeEditorContributions,
   mergeSavedViewFeedEnrichment,
   moderateThread,
   onboardingReducer,
@@ -5120,6 +5783,7 @@ export {
   useBilling,
   useBlame,
   useCan,
+  useCanCreate,
   useCanEdit,
   useCanvasTaskSync,
   useCell,
@@ -5136,6 +5800,7 @@ export {
   useDatabaseSchema,
   useDemoMode,
   useDiff,
+  useDraft,
   useEditorExtensions,
   useEditorExtensionsSafe,
   useEffectiveSchema,
@@ -5152,6 +5817,7 @@ export {
   useInfiniteQuery,
   useInstrumentation,
   useIsOffline,
+  useMergedEditorContributions,
   useMessageRequests,
   useModeratedThread,
   useMutate,
@@ -5164,6 +5830,7 @@ export {
   usePluginRegistryOptional,
   usePlugins,
   usePolicyFilteredReactionCounters,
+  usePresence,
   useQuery,
   useRelatedRows,
   useRemoteSchema,
@@ -5178,6 +5845,7 @@ export {
   useTaskProjectionSync,
   useTasks,
   useTelemetryReporter,
+  useTimeMachine,
   useTracingReporter,
   useUndo,
   useVerification,