@xnetjs/react 1.0.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-MEIYFD6R.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 {
@@ -4929,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 useCallback4, useContext, useEffect as useEffect7, 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 };
@@ -4939,17 +5464,17 @@ function useGlobalUndo() {
   const ctx = useContext(XNetContext);
   const { undoManager, nodeStore } = readUndoContext(ctx);
   const [, bump] = useReducer((n) => n + 1, 0);
-  useEffect7(() => {
+  useEffect9(() => {
     if (!nodeStore) return;
     return nodeStore.subscribe(() => bump());
   }, [nodeStore]);
-  const undo = useCallback4(async () => {
+  const undo = useCallback6(async () => {
     if (!undoManager) return false;
     const ok = await undoManager.undoLatest();
     bump();
     return ok;
   }, [undoManager]);
-  const redo = useCallback4(async () => {
+  const redo = useCallback6(async () => {
     if (!undoManager) return false;
     const ok = await undoManager.redoLatest();
     bump();
@@ -4964,7 +5489,7 @@ function useGlobalUndo() {
 }
 
 // src/hooks/useCanCreate.ts
-import { useEffect as useEffect8, useMemo as useMemo6, useRef as useRef5, useState as useState7 } from "react";
+import { useEffect as useEffect10, useMemo as useMemo7, useRef as useRef7, useState as useState9 } from "react";
 var INITIAL_STATE = {
   canCreate: false,
   loading: true,
@@ -4972,10 +5497,10 @@ var INITIAL_STATE = {
 };
 function useCanCreate(schemaId, properties) {
   const { store, isReady } = useNodeStore();
-  const [state, setState] = useState7(INITIAL_STATE);
-  const requestRef = useRef5(0);
-  const propertiesKey = useMemo6(() => JSON.stringify(properties ?? {}), [properties]);
-  useEffect8(() => {
+  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;
@@ -5044,7 +5569,7 @@ import {
 } from "@xnetjs/runtime";
 
 // src/hooks/useBilling.ts
-import { useCallback as useCallback5, useContext as useContext2, useEffect as useEffect9, useMemo as useMemo7, useState as useState8 } 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);
@@ -5081,20 +5606,20 @@ function deriveBilling(state) {
 }
 function useBilling() {
   const context = useContext2(XNetContext);
-  const [state, setState] = useState8(null);
-  const [loading, setLoading] = useState8(
+  const [state, setState] = useState10(null);
+  const [loading, setLoading] = useState10(
     Boolean(context?.hubUrl || context?.billing?.apiBase)
   );
-  const [error, setError] = useState8(null);
-  const apiBase = useMemo7(() => {
+  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 = useCallback5(async () => {
+  const authHeaders = useCallback7(async () => {
     const token = context?.getHubAuthToken ? await context.getHubAuthToken() : "";
     return token ? { Authorization: `Bearer ${token}` } : {};
   }, [context]);
-  const reload = useCallback5(async () => {
+  const reload = useCallback7(async () => {
     if (!apiBase) {
       setState(null);
       setLoading(false);
@@ -5112,10 +5637,10 @@ function useBilling() {
       setLoading(false);
     }
   }, [apiBase, authHeaders]);
-  useEffect9(() => {
+  useEffect11(() => {
     void reload();
   }, [reload]);
-  const redirectVia = useCallback5(
+  const redirectVia = useCallback7(
     async (path, body) => {
       if (!apiBase) throw new Error("Hub URL not configured");
       const res = await fetch(`${apiBase}${path}`, {
@@ -5129,11 +5654,11 @@ function useBilling() {
     },
     [apiBase, authHeaders]
   );
-  const openCheckout = useCallback5(
+  const openCheckout = useCallback7(
     (priceRef, options = {}) => redirectVia("/billing/checkout", buildCheckoutBody(priceRef, options)),
     [redirectVia]
   );
-  const openPortal = useCallback5(
+  const openPortal = useCallback7(
     (returnUrl) => redirectVia("/billing/portal", returnUrl ? { returnUrl } : {}),
     [redirectVia]
   );
@@ -5239,6 +5764,7 @@ export {
   isReactionVisible,
   isSavedViewVisualPreviewEmbeddable,
   isTaskOverdue,
+  mergeEditorContributions,
   mergeSavedViewFeedEnrichment,
   moderateThread,
   onboardingReducer,
@@ -5274,6 +5800,7 @@ export {
   useDatabaseSchema,
   useDemoMode,
   useDiff,
+  useDraft,
   useEditorExtensions,
   useEditorExtensionsSafe,
   useEffectiveSchema,
@@ -5290,6 +5817,7 @@ export {
   useInfiniteQuery,
   useInstrumentation,
   useIsOffline,
+  useMergedEditorContributions,
   useMessageRequests,
   useModeratedThread,
   useMutate,
@@ -5317,6 +5845,7 @@ export {
   useTaskProjectionSync,
   useTasks,
   useTelemetryReporter,
+  useTimeMachine,
   useTracingReporter,
   useUndo,
   useVerification,