@abraca/nuxt 1.8.2 → 2.0.0

package/dist/runtime/composables/useAggregatedPresence.d.ts

@@ -0,0 +1,23 @@
+export interface PresenceUser {
+    name: string;
+    color: string;
+    publicKey?: string;
+    clientId: number;
+}
+interface AwarenessState {
+    user?: {
+        name?: string;
+        color?: string;
+        publicKey?: string;
+    };
+    docId?: string;
+    viewingDocId?: string;
+    [k: string]: unknown;
+}
+export declare const useAggregatedPresence: () => {
+    allAwarenessStates: import("vue").ComputedRef<AwarenessState[]>;
+    docPresence: import("vue").ComputedRef<Map<string, PresenceUser[]>>;
+    findUserState: (publicKey: string) => AwarenessState | null;
+    selfState: import("vue").ComputedRef<AwarenessState | null>;
+};
+export {};

package/dist/runtime/composables/useAggregatedPresence.js

@@ -0,0 +1,140 @@
+import { ref, computed, watch } from "vue";
+import { createSharedComposable } from "@vueuse/core";
+import { useSpaceConnections } from "./useSpaceConnections.js";
+import { useAbracadabra } from "./useAbracadabra.js";
+const _useAggregatedPresence = () => {
+  const { connections } = useSpaceConnections();
+  const { publicKeyB64 } = useAbracadabra();
+  const awarenessVersion = ref(0);
+  const attachedAwareness = /* @__PURE__ */ new Map();
+  if (import.meta.client) {
+    const onChange = () => {
+      awarenessVersion.value++;
+    };
+    watch(
+      () => [...connections.values()],
+      (conns) => {
+        const current = /* @__PURE__ */ new Set();
+        for (const conn of conns) {
+          const provider = conn.provider;
+          const awareness = provider?.awareness;
+          if (!awareness) continue;
+          current.add(awareness);
+          if (!attachedAwareness.has(awareness)) {
+            const handler = () => onChange();
+            awareness.on("change", handler);
+            attachedAwareness.set(awareness, handler);
+          }
+        }
+        for (const [a, handler] of attachedAwareness) {
+          if (!current.has(a)) {
+            try {
+              a.off("change", handler);
+            } catch {
+            }
+            attachedAwareness.delete(a);
+          }
+        }
+        awarenessVersion.value++;
+      },
+      { immediate: true }
+    );
+  }
+  const allAwarenessStates = computed(() => {
+    void awarenessVersion.value;
+    const seen = /* @__PURE__ */ new Map();
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      let stateMap;
+      try {
+        stateMap = awareness.getStates();
+      } catch {
+        continue;
+      }
+      const selfClientId = awareness.clientID;
+      for (const [clientId, state] of stateMap) {
+        if (clientId === selfClientId) continue;
+        if (!state.user?.publicKey) continue;
+        const key = state.user.publicKey;
+        if (key === publicKeyB64.value) continue;
+        if (!seen.has(key)) {
+          seen.set(key, { ...state, clientId });
+        }
+      }
+    }
+    return [...seen.values()];
+  });
+  const docPresence = computed(() => {
+    void awarenessVersion.value;
+    const map = /* @__PURE__ */ new Map();
+    const addToBucket = (docId, user) => {
+      const users = map.get(docId) ?? [];
+      if (user.publicKey && users.some((u) => u.publicKey === user.publicKey)) return;
+      users.push(user);
+      map.set(docId, users);
+    };
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      let stateMap;
+      try {
+        stateMap = awareness.getStates();
+      } catch {
+        continue;
+      }
+      const selfClientId = awareness.clientID;
+      for (const [clientId, state] of stateMap) {
+        if (clientId === selfClientId) continue;
+        const pk = state.user?.publicKey;
+        if (pk && pk === publicKeyB64.value) continue;
+        const docId = state.docId;
+        const viewingDocId = state.viewingDocId;
+        if (!docId && !viewingDocId) continue;
+        const user = {
+          name: state.user?.name || "?",
+          color: state.user?.color || "#888",
+          publicKey: pk,
+          clientId
+        };
+        if (docId) addToBucket(docId, user);
+        if (viewingDocId && viewingDocId !== docId) addToBucket(viewingDocId, user);
+      }
+    }
+    return map;
+  });
+  function findUserState(publicKey) {
+    void awarenessVersion.value;
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      let stateMap;
+      try {
+        stateMap = awareness.getStates();
+      } catch {
+        continue;
+      }
+      for (const state of stateMap.values()) {
+        if (state.user?.publicKey === publicKey) return state;
+      }
+    }
+    return null;
+  }
+  const selfState = computed(() => {
+    void awarenessVersion.value;
+    if (!publicKeyB64.value) return null;
+    for (const [, conn] of connections) {
+      const provider = conn.provider;
+      const awareness = provider?.awareness;
+      if (!awareness) continue;
+      const local = awareness.getLocalState();
+      if (local?.user?.publicKey === publicKeyB64.value) return local;
+    }
+    return null;
+  });
+  return { allAwarenessStates, docPresence, findUserState, selfState };
+};
+export const useAggregatedPresence = createSharedComposable(_useAggregatedPresence);

package/dist/runtime/composables/useChat.d.ts

@@ -30,8 +30,22 @@ declare let _userName: import("vue").Ref<string, string>;
 export declare function _initChat(publicKeyB64Ref: typeof _publicKeyB64, userNameRef: typeof _userName): void;
 export declare function _destroyChat(): void;
 export declare function _handleStatelessChat(payload: string): void;
-declare function sendMessage(channelId: string, content: string): void;
-declare function fetchHistory(channelId: string, opts?: {
+declare function sendMessage(channelId: string, content: string, opts?: {
+    mentions?: string[];
+    replyTo?: string;
+}): void;
+/**
+ * Open the wrapper provider for the given channel, observe its
+ * `periods` Y.Array, and attach the active period subdoc so its
+ * `messages` Y.Array entries flow into the local buffer. Idempotent —
+ * calling twice for the same channel is a no-op (observers already
+ * live).
+ *
+ * `channelId` is the raw channel/dm doc UUID. The legacy `group:<uuid>`
+ * prefix is stripped before passing to provider.loadChild (which
+ * validates strict UUIDs).
+ */
+declare function fetchHistory(channelId: string, _opts?: {
     before?: number;
     limit?: number;
 }): void;

package/dist/runtime/composables/useChat.js

@@ -1,8 +1,32 @@
-import { ref, computed } from "vue";
+import { ref, computed, watch } from "vue";
 import { useAbracadabra } from "./useAbracadabra.js";
+import { tsToMs } from "../utils/time.js";
+import {
+  ChannelKeyResolver,
+  DocKeyManager,
+  decryptChatContent,
+  foldRecords,
+  isEncryptedContent,
+  recordFromYAny
+} from "@abraca/dabra";
+const _docKeys = new DocKeyManager();
+const _resolverByClient = /* @__PURE__ */ new WeakMap();
+function _resolveChannelKey(client) {
+  if (!client) return null;
+  const cached = _resolverByClient.get(client);
+  if (cached) return cached;
+  const { keystore } = useAbracadabra();
+  if (!keystore.value) return null;
+  const resolver = new ChannelKeyResolver(client, _docKeys, keystore.value);
+  _resolverByClient.set(client, resolver);
+  return resolver;
+}
 export function buildDmChannelId(a, b) {
   return `dm:${[a, b].sort().join(":")}`;
 }
+function normalizeChannel(channelId) {
+  return channelId.startsWith("group:") ? channelId.slice("group:".length) : channelId;
+}
 const messagesByChannel = ref({});
 const channels = ref({});
 const typingByChannel = ref({});
@@ -26,6 +50,20 @@ export function _destroyChat() {
   for (const t of typingTimers.values()) clearTimeout(t);
   typingTimers.clear();
 }
+function resolveSenderName(senderId, fallback = "User") {
+  if (!senderId) return fallback;
+  try {
+    const { provider } = useAbracadabra();
+    const awareness = provider.value?.awareness;
+    if (!awareness) return fallback;
+    const states = awareness.getStates();
+    for (const state of states.values()) {
+      if (state?.user?.publicKey === senderId && state.user.name) return state.user.name;
+    }
+  } catch {
+  }
+  return fallback;
+}
 function resolveChannelLabel(channelId, senderName, senderId) {
   const { doc } = useAbracadabra();
   if (channelId.startsWith("group:")) {
@@ -60,50 +98,56 @@ function ensureChannel(channelId, label) {
 function addMessage(msg) {
   const list = messagesByChannel.value[msg.channel] ?? [];
   if (list.some((m) => m.id === msg.id)) return;
-  const sorted = [...list, msg].sort((a, b) => a.createdAt - b.createdAt);
+  const isServerEcho = !msg.id.startsWith("local-");
+  let filtered = list;
+  if (isServerEcho) {
+    filtered = list.filter(
+      (m) => !(m.id.startsWith("local-") && m.senderId === msg.senderId && m.content === msg.content && Math.abs(m.createdAt - msg.createdAt) < 3e4)
+    );
+  }
+  const sorted = [...filtered, msg].sort((a, b) => a.createdAt - b.createdAt);
   messagesByChannel.value = { ...messagesByChannel.value, [msg.channel]: sorted };
   const chan = channels.value[msg.channel];
   if (chan) {
     const isActive = activeChannel.value === msg.channel;
+    const isOwn = msg.senderId === _publicKeyB64.value;
     channels.value = {
       ...channels.value,
       [msg.channel]: {
         ...chan,
         lastMessage: msg,
-        unreadCount: isActive ? 0 : chan.unreadCount + 1
+        unreadCount: isActive || isOwn ? chan.unreadCount : chan.unreadCount + 1
       }
     };
   }
 }
 export function _handleStatelessChat(payload) {
-  if (!payload.includes('"chat:')) return;
+  if (!payload.includes('"messages:')) return;
   try {
     const data = JSON.parse(payload);
-    if (!data.type?.startsWith("chat:")) return;
-    switch (data.type) {
-      case "chat:history": {
-        const msgs = (data.messages || []).map((m) => ({
-          id: m.id,
-          channel: m.channel,
-          senderId: m.sender_id ?? "",
-          senderName: m.sender_name ?? "User",
-          content: m.content,
-          createdAt: typeof m.created_at === "number" ? m.created_at : new Date(m.created_at).getTime()
-        }));
-        for (const msg of msgs) {
-          ensureChannel(msg.channel, resolveChannelLabel(msg.channel, msg.senderName, msg.senderId));
-          addMessage(msg);
-        }
-        break;
-      }
-      case "chat:message": {
+    const t = data.type;
+    if (!t || !t.startsWith("messages:")) return;
+    switch (t) {
+      case "messages:new_message": {
+        const rec = data.record;
+        if (!rec || rec.record_kind && rec.record_kind !== "message") break;
+        const channelDocId = rec.channel_doc_id;
+        if (!channelDocId) break;
+        const tsMs = tsToMs(rec.ts) ?? Date.now();
+        const senderId = rec.sender_id ?? "";
         const msg = {
-          id: data.id ?? crypto.randomUUID(),
-          channel: data.channel,
-          senderId: data.sender_id ?? "",
-          senderName: data.sender_name ?? "User",
-          content: data.content,
-          createdAt: typeof data.created_at === "number" ? data.created_at : Date.now()
+          id: rec.id ?? `${senderId}-${tsMs}`,
+          // Use the raw doc id as the channel key; the legacy `group:`
+          // prefix scheme is on its way out across the codebase.
+          channel: channelDocId,
+          senderId,
+          // Server records carry only `sender_id` (publicKey). Resolve a
+          // human-readable name from awareness so peers don't all show as
+          // the placeholder "User" — that visual collapse was being read
+          // as "chat is broken / messages aren't syncing".
+          senderName: rec.sender_name ?? resolveSenderName(senderId),
+          content: rec.content ?? "",
+          createdAt: tsMs
         };
         ensureChannel(msg.channel, resolveChannelLabel(msg.channel, msg.senderName, msg.senderId));
         addMessage(msg);
@@ -115,26 +159,61 @@ export function _handleStatelessChat(payload) {
         }
         break;
       }
-      case "chat:typing": {
-        const channel = data.channel;
+      case "messages:typing": {
+        const channelDocId = data.channel_doc_id;
+        if (!channelDocId) break;
         const senderId = data.sender_id ?? "";
         const name = data.sender_name ?? "User";
         if (senderId === _publicKeyB64.value) break;
-        const current = typingByChannel.value[channel] ?? /* @__PURE__ */ new Map();
+        const current = typingByChannel.value[channelDocId] ?? /* @__PURE__ */ new Map();
         const next = new Map(current);
         next.set(senderId, name);
-        typingByChannel.value = { ...typingByChannel.value, [channel]: next };
-        const timerKey = `${channel}:${senderId}`;
+        typingByChannel.value = { ...typingByChannel.value, [channelDocId]: next };
+        const timerKey = `${channelDocId}:${senderId}`;
         const existing = typingTimers.get(timerKey);
         if (existing) clearTimeout(existing);
         typingTimers.set(timerKey, setTimeout(() => {
           typingTimers.delete(timerKey);
-          const cur = typingByChannel.value[channel];
-          if (!cur) return;
-          const updated = new Map(cur);
-          updated.delete(senderId);
-          typingByChannel.value = { ...typingByChannel.value, [channel]: updated };
-        }, 4e3));
+          const cur = typingByChannel.value[channelDocId];
+          if (cur?.has(senderId)) {
+            const n2 = new Map(cur);
+            n2.delete(senderId);
+            typingByChannel.value = { ...typingByChannel.value, [channelDocId]: n2 };
+          }
+        }, 5e3));
+        break;
+      }
+      case "permissions:rewrap_needed": {
+        const docId = data.doc_id;
+        const targetUserId = data.target_user_id;
+        if (!docId || !targetUserId) break;
+        if (targetUserId === _publicKeyB64.value) break;
+        (async () => {
+          const { client } = useAbracadabra();
+          if (!client?.value) return;
+          try {
+            const resolver = _resolveChannelKey(client.value);
+            if (!resolver) return;
+            const docKey = await resolver.docKeyFor(docId);
+            if (!docKey) return;
+            const granteeKeys = await client.value.listUserKeys(targetUserId);
+            if (!granteeKeys.length) return;
+            const granteeKey = granteeKeys[0];
+            if (!granteeKey.x25519Key) return;
+            const x25519Pub = Uint8Array.from(
+              atob(granteeKey.x25519Key.replace(/-/g, "+").replace(/_/g, "/")),
+              (c) => c.charCodeAt(0)
+            );
+            const wrapped = await _docKeys.wrapKeyForRecipient(docKey, x25519Pub, docId);
+            const b64 = btoa(String.fromCharCode(...wrapped));
+            await client.value.uploadKeyEnvelopes(docId, {
+              key_epoch: 1,
+              envelopes: [{ recipient_key_id: granteeKey.id, encrypted_key: b64 }]
+            });
+          } catch (err) {
+            if (import.meta.dev) console.warn("[abracadabra] rewrap_needed handler failed:", err);
+          }
+        })();
         break;
       }
     }
@@ -142,39 +221,140 @@ export function _handleStatelessChat(payload) {
     if (import.meta.dev) console.warn("[abracadabra] chat: failed to handle stateless message:", e);
   }
 }
-function sendMessage(channelId, content) {
-  const { provider } = useAbracadabra();
+function sendMessage(channelId, content, opts) {
+  const { provider, userName } = useAbracadabra();
   if (!provider.value || !content.trim()) return;
+  const channelDocId = normalizeChannel(channelId);
+  const trimmed = content.trim();
+  ensureChannel(channelDocId);
+  addMessage({
+    id: `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+    channel: channelDocId,
+    senderId: _publicKeyB64.value,
+    senderName: userName?.value ?? _userName.value,
+    content: trimmed,
+    createdAt: Date.now()
+  });
   provider.value.sendStateless(JSON.stringify({
-    type: "chat:send",
-    channel: channelId,
-    content: content.trim()
+    type: "messages:send",
+    channel_doc_id: channelDocId,
+    content: trimmed,
+    mentions: opts?.mentions ?? [],
+    ...opts?.replyTo ? { reply_to: opts.replyTo } : {}
   }));
 }
-function fetchHistory(channelId, opts) {
+const _channelHandles = /* @__PURE__ */ new Map();
+async function _attachPeriodProvider(channel, rootProv, periodId) {
+  const handle = _channelHandles.get(channel);
+  if (!handle) return;
+  if (handle.periodProv && handle.periodProv.name === periodId) return;
+  try {
+    const periodChild = await rootProv.loadChild(periodId);
+    handle.periodProv = periodChild;
+    const arr = periodChild.document.getArray("messages");
+    const channelDocIdRaw = channel.startsWith("group:") ? channel.slice("group:".length) : channel;
+    const { client } = useAbracadabra();
+    const resolver = _resolveChannelKey(client?.value);
+    let channelDocKey = null;
+    let docKeyError = null;
+    if (resolver) {
+      try {
+        channelDocKey = await resolver.docKeyFor(channelDocIdRaw);
+      } catch (e) {
+        docKeyError = e;
+      }
+    }
+    const pumpAll = async () => {
+      const records = arr.toArray().map((v) => recordFromYAny(v)).filter((r) => r !== null);
+      const folded = foldRecords(records);
+      for (const f of folded) {
+        let content = f.content;
+        if (isEncryptedContent(content)) {
+          if (channelDocKey) {
+            const decrypted = await decryptChatContent(content, channelDocKey);
+            content = decrypted ?? "[decryption failed]";
+          } else {
+            content = docKeyError ? "[encrypted \u2014 no key available for this channel]" : "[encrypted]";
+          }
+        }
+        addMessage({
+          id: f.id,
+          channel,
+          senderId: f.senderId,
+          senderName: "",
+          content,
+          createdAt: f.createdAt
+        });
+      }
+    };
+    const onChange = () => {
+      void pumpAll();
+    };
+    arr.observe(onChange);
+    handle.disposers.push(() => arr.unobserve(onChange));
+    const tryPump = () => {
+      if (arr.length > 0) void pumpAll();
+    };
+    if (periodChild.synced) tryPump();
+    else periodChild.on("synced", tryPump);
+  } catch (err) {
+    if (import.meta.dev) console.warn(`[abracadabra] loadChild(period ${periodId}) for ${channel} failed:`, err);
+  }
+}
+function fetchHistory(channelId, _opts) {
+  const channelDocId = normalizeChannel(channelId);
+  if (_channelHandles.has(channelDocId)) return;
   const { provider } = useAbracadabra();
-  if (!provider.value) return;
-  provider.value.sendStateless(JSON.stringify({
-    type: "chat:history",
-    channel: channelId,
-    before: opts?.before,
-    limit: opts?.limit ?? 50
-  }));
+  const rootProv = provider.value;
+  if (!rootProv) {
+    if (import.meta.dev) console.warn(`[abracadabra] fetchHistory(${channelDocId}): no provider attached yet`);
+    return;
+  }
+  const handle = { wrapperProv: null, periodProv: null, disposers: [] };
+  _channelHandles.set(channelDocId, handle);
+  const rootName = rootProv?.configuration?.name ?? rootProv?.document?.guid;
+  const isSelfChannel = rootName === channelDocId;
+  const wireUp = (wrapperChild) => {
+    handle.wrapperProv = wrapperChild;
+    const periods = wrapperChild.document.getArray("periods");
+    const pickActive = () => {
+      const len = periods.length;
+      if (len === 0) return;
+      const last = periods.get(len - 1);
+      const periodId = last?.id ?? last?.get?.("id");
+      if (periodId) void _attachPeriodProvider(channelDocId, rootProv, periodId);
+    };
+    const onPeriods = () => pickActive();
+    periods.observe(onPeriods);
+    handle.disposers.push(() => periods.unobserve(onPeriods));
+    if (wrapperChild.synced) pickActive();
+    else wrapperChild.on("synced", pickActive);
+  };
+  if (isSelfChannel) {
+    wireUp(rootProv);
+    return;
+  }
+  rootProv.loadChild(channelDocId).then(wireUp).catch((err) => {
+    if (import.meta.dev) console.warn(`[abracadabra] loadChild(${channelDocId}) failed:`, err);
+    _channelHandles.delete(channelDocId);
+  });
 }
 function sendTyping(channelId) {
   const { provider } = useAbracadabra();
   if (!provider.value) return;
+  const channelDocId = normalizeChannel(channelId);
   provider.value.sendStateless(JSON.stringify({
-    type: "chat:typing",
-    channel: channelId
+    type: "messages:typing",
+    channel_doc_id: channelDocId
   }));
 }
 function setActiveChannel(channelId) {
-  activeChannel.value = channelId;
-  if (channelId && channels.value[channelId]) {
+  const key = channelId ? normalizeChannel(channelId) : null;
+  activeChannel.value = key;
+  if (key && channels.value[key]) {
     channels.value = {
       ...channels.value,
-      [channelId]: { ...channels.value[channelId], unreadCount: 0 }
+      [key]: { ...channels.value[key], unreadCount: 0 }
     };
   }
 }
@@ -196,24 +376,35 @@ export function useChat() {
   };
 }
 export function useChatChannel(channelId) {
-  const messages = computed(() => messagesByChannel.value[channelId] ?? []);
-  const channel = computed(() => channels.value[channelId]);
-  const typingUsers = computed(() => [...typingByChannel.value[channelId]?.values() ?? []]);
-  const unreadCount = computed(() => channels.value[channelId]?.unreadCount ?? 0);
+  const key = normalizeChannel(channelId);
+  const messages = computed(() => messagesByChannel.value[key] ?? []);
+  const channel = computed(() => channels.value[key]);
+  const typingUsers = computed(() => [...typingByChannel.value[key]?.values() ?? []]);
+  const unreadCount = computed(() => channels.value[key]?.unreadCount ?? 0);
+  ensureChannel(key);
+  const { provider } = useAbracadabra();
+  if (provider.value) fetchHistory(key);
+  else {
+    const stop = watch(provider, (p) => {
+      if (!p) return;
+      fetchHistory(key);
+      stop();
+    });
+  }
   function send(content) {
-    sendMessage(channelId, content);
+    sendMessage(key, content);
   }
   function loadHistory(opts) {
-    fetchHistory(channelId, opts);
+    fetchHistory(key, opts);
   }
   function typing() {
-    sendTyping(channelId);
+    sendTyping(key);
   }
   function focus() {
-    setActiveChannel(channelId);
+    setActiveChannel(key);
   }
   function blur() {
-    if (activeChannel.value === channelId) setActiveChannel(null);
+    if (activeChannel.value === key) setActiveChannel(null);
   }
   return { messages, channel, typingUsers, unreadCount, send, loadHistory, typing, focus, blur };
 }

package/dist/runtime/composables/useChatUsers.d.ts

@@ -14,6 +14,8 @@ export interface ChatUserAppearance {
     neutralName: string;
     publicKey: string;
     isOnline: boolean;
+    /** Doc the user is currently viewing (from awareness `docId` field). */
+    docId?: string;
 }
 export declare function useChatUsers(): {
     onlineUsers: import("vue").ComputedRef<ChatUserAppearance[]>;

package/dist/runtime/composables/useChatUsers.js

@@ -16,7 +16,8 @@ export function useChatUsers() {
             color: u.color ?? "#888",
             neutralName: "zinc",
             publicKey: u.publicKey,
-            isOnline: true
+            isOnline: true,
+            docId: typeof state.docId === "string" ? state.docId : void 0
           });
         }
       }

package/dist/runtime/composables/useDocLookup.d.ts

@@ -0,0 +1,4 @@
+export declare function useDocLookup(): {
+    docToSpace: import("vue").ComputedRef<Map<string, string>>;
+    resolveDocSpace: (docId: string) => string | undefined;
+};

package/dist/runtime/composables/useDocLookup.js

@@ -0,0 +1,25 @@
+import { computed } from "vue";
+import { useSpaceConnections } from "./useSpaceConnections.js";
+import { useAbracadabra } from "./useAbracadabra.js";
+export function useDocLookup() {
+  const { connections } = useSpaceConnections();
+  const state = useAbracadabra();
+  const docToSpace = computed(() => {
+    const map = /* @__PURE__ */ new Map();
+    for (const [spaceId, conn] of connections) {
+      if (state.spaceDocId.value) map.set(state.spaceDocId.value, spaceId);
+      const treeData = conn.treeData.value;
+      for (const docId of Object.keys(treeData)) {
+        map.set(docId, spaceId);
+      }
+    }
+    return map;
+  });
+  function resolveDocSpace(docId) {
+    return docToSpace.value.get(docId);
+  }
+  return {
+    docToSpace,
+    resolveDocSpace
+  };
+}