@abraca/nuxt 1.9.1 → 2.0.0

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

@@ -0,0 +1,68 @@
+import { type Ref } from 'vue';
+export interface CellAddress {
+    colIdx: number;
+    rowIdx: number;
+}
+export interface SelectionRange {
+    startCol: number;
+    startRow: number;
+    endCol: number;
+    endRow: number;
+}
+/**
+ * Manages spreadsheet cell selection, range selection, keyboard navigation, and edit mode.
+ */
+export declare function useSheetsSelection(opts: {
+    colCount: Ref<number>;
+    rowCount: Ref<number>;
+    getCellValue: (colIdx: number, rowIdx: number) => string;
+    commitValue: (colIdx: number, rowIdx: number, value: string) => void;
+    clearCell: (colIdx: number, rowIdx: number) => void;
+    /** Clear a cell without triggering formula recalc (for batch ops). Falls back to clearCell. */
+    clearCellValue?: (colIdx: number, rowIdx: number) => void;
+    transact?: (fn: () => void) => void;
+    /** Recalculate all formulas (called once after batch operations). */
+    recalcFormulas?: () => void;
+    pageSize?: Ref<number>;
+}): {
+    activeCell: Ref<{
+        colIdx: number;
+        rowIdx: number;
+    } | null, CellAddress | {
+        colIdx: number;
+        rowIdx: number;
+    } | null>;
+    editMode: Ref<boolean, boolean>;
+    editValue: Ref<string, string>;
+    selectionRange: Ref<{
+        startCol: number;
+        startRow: number;
+        endCol: number;
+        endRow: number;
+    } | null, SelectionRange | {
+        startCol: number;
+        startRow: number;
+        endCol: number;
+        endRow: number;
+    } | null>;
+    normalizedRange: import("vue").ComputedRef<SelectionRange | null>;
+    isDragging: Ref<boolean, boolean>;
+    isInRange: (colIdx: number, rowIdx: number) => boolean;
+    selectCell: (colIdx: number, rowIdx: number, shiftKey?: boolean) => void;
+    activateCell: (colIdx: number, rowIdx: number) => void;
+    startEdit: (preserveContent?: boolean) => void;
+    commitEdit: () => void;
+    cancelEdit: () => void;
+    moveTo: (colIdx: number, rowIdx: number) => void;
+    moveBy: (dCol: number, dRow: number) => void;
+    beginDrag: (colIdx: number, rowIdx: number) => void;
+    continueDrag: (colIdx: number, rowIdx: number) => void;
+    endDrag: () => void;
+    setRange: (startCol: number, startRow: number, endCol: number, endRow: number) => void;
+    selectRow: (rowIdx: number) => void;
+    selectColumn: (colIdx: number) => void;
+    selectAll: () => void;
+    clearRange: () => void;
+    onKeydown: (e: KeyboardEvent) => void;
+    isActive: (colIdx: number, rowIdx: number) => boolean;
+};

package/dist/runtime/composables/useSheetsSelection.js

@@ -0,0 +1,390 @@
+import { ref, computed } from "vue";
+export function useSheetsSelection(opts) {
+  const activeCell = ref(null);
+  const editMode = ref(false);
+  const editValue = ref("");
+  const selectionRange = ref(null);
+  const isDragging = ref(false);
+  const normalizedRange = computed(() => {
+    const r = selectionRange.value;
+    if (!r) return null;
+    return {
+      startCol: Math.min(r.startCol, r.endCol),
+      startRow: Math.min(r.startRow, r.endRow),
+      endCol: Math.max(r.startCol, r.endCol),
+      endRow: Math.max(r.startRow, r.endRow)
+    };
+  });
+  function isInRange(colIdx, rowIdx) {
+    const r = normalizedRange.value;
+    if (!r) return false;
+    return colIdx >= r.startCol && colIdx <= r.endCol && rowIdx >= r.startRow && rowIdx <= r.endRow;
+  }
+  function clamp(colIdx, rowIdx) {
+    return {
+      colIdx: Math.max(0, Math.min(colIdx, opts.colCount.value - 1)),
+      rowIdx: Math.max(0, Math.min(rowIdx, opts.rowCount.value - 1))
+    };
+  }
+  function moveTo(colIdx, rowIdx) {
+    if (editMode.value) commitEdit();
+    selectionRange.value = null;
+    activeCell.value = clamp(colIdx, rowIdx);
+  }
+  function moveBy(dCol, dRow) {
+    if (!activeCell.value) {
+      activeCell.value = { colIdx: 0, rowIdx: 0 };
+      selectionRange.value = null;
+      return;
+    }
+    moveTo(activeCell.value.colIdx + dCol, activeCell.value.rowIdx + dRow);
+  }
+  function extendSelection(dCol, dRow) {
+    if (!activeCell.value) return;
+    const r = selectionRange.value ?? {
+      startCol: activeCell.value.colIdx,
+      startRow: activeCell.value.rowIdx,
+      endCol: activeCell.value.colIdx,
+      endRow: activeCell.value.rowIdx
+    };
+    const end = clamp(r.endCol + dCol, r.endRow + dRow);
+    selectionRange.value = {
+      startCol: r.startCol,
+      startRow: r.startRow,
+      endCol: end.colIdx,
+      endRow: end.rowIdx
+    };
+  }
+  function startEdit(preserveContent = true) {
+    if (!activeCell.value) return;
+    editMode.value = true;
+    if (preserveContent) {
+      editValue.value = opts.getCellValue(activeCell.value.colIdx, activeCell.value.rowIdx);
+    } else {
+      editValue.value = "";
+    }
+  }
+  function commitEdit() {
+    if (!activeCell.value || !editMode.value) return;
+    opts.commitValue(activeCell.value.colIdx, activeCell.value.rowIdx, editValue.value);
+    editMode.value = false;
+  }
+  function cancelEdit() {
+    editMode.value = false;
+    editValue.value = "";
+  }
+  function selectCell(colIdx, rowIdx, shiftKey = false) {
+    if (editMode.value) commitEdit();
+    editMode.value = false;
+    if (shiftKey && activeCell.value) {
+      selectionRange.value = {
+        startCol: activeCell.value.colIdx,
+        startRow: activeCell.value.rowIdx,
+        endCol: colIdx,
+        endRow: rowIdx
+      };
+    } else {
+      activeCell.value = { colIdx, rowIdx };
+      selectionRange.value = null;
+    }
+  }
+  function activateCell(colIdx, rowIdx) {
+    activeCell.value = { colIdx, rowIdx };
+    selectionRange.value = null;
+    startEdit(true);
+  }
+  function beginDrag(colIdx, rowIdx) {
+    if (editMode.value) commitEdit();
+    editMode.value = false;
+    isDragging.value = true;
+    activeCell.value = { colIdx, rowIdx };
+    selectionRange.value = {
+      startCol: colIdx,
+      startRow: rowIdx,
+      endCol: colIdx,
+      endRow: rowIdx
+    };
+  }
+  function continueDrag(colIdx, rowIdx) {
+    if (!isDragging.value || !selectionRange.value) return;
+    selectionRange.value = {
+      ...selectionRange.value,
+      endCol: colIdx,
+      endRow: rowIdx
+    };
+  }
+  function endDrag() {
+    isDragging.value = false;
+    const r = normalizedRange.value;
+    if (r && r.startCol === r.endCol && r.startRow === r.endRow) {
+      selectionRange.value = null;
+    }
+  }
+  function setRange(startCol, startRow, endCol, endRow) {
+    if (editMode.value) commitEdit();
+    const sc = clamp(startCol, startRow);
+    const ec = clamp(endCol, endRow);
+    selectionRange.value = {
+      startCol: sc.colIdx,
+      startRow: sc.rowIdx,
+      endCol: ec.colIdx,
+      endRow: ec.rowIdx
+    };
+    if (!activeCell.value) activeCell.value = { colIdx: sc.colIdx, rowIdx: sc.rowIdx };
+  }
+  function selectRow(rowIdx) {
+    if (editMode.value) commitEdit();
+    editMode.value = false;
+    activeCell.value = { colIdx: 0, rowIdx };
+    selectionRange.value = {
+      startCol: 0,
+      startRow: rowIdx,
+      endCol: opts.colCount.value - 1,
+      endRow: rowIdx
+    };
+  }
+  function selectColumn(colIdx) {
+    if (editMode.value) commitEdit();
+    editMode.value = false;
+    activeCell.value = { colIdx, rowIdx: 0 };
+    selectionRange.value = {
+      startCol: colIdx,
+      startRow: 0,
+      endCol: colIdx,
+      endRow: opts.rowCount.value - 1
+    };
+  }
+  function selectAll() {
+    if (editMode.value) commitEdit();
+    editMode.value = false;
+    activeCell.value = { colIdx: 0, rowIdx: 0 };
+    selectionRange.value = {
+      startCol: 0,
+      startRow: 0,
+      endCol: opts.colCount.value - 1,
+      endRow: opts.rowCount.value - 1
+    };
+  }
+  function clearRange() {
+    const r = normalizedRange.value;
+    if (!r) {
+      if (activeCell.value) opts.clearCell(activeCell.value.colIdx, activeCell.value.rowIdx);
+      return;
+    }
+    const clear = opts.clearCellValue ?? opts.clearCell;
+    const run = () => {
+      for (let c = r.startCol; c <= r.endCol; c++) {
+        for (let row = r.startRow; row <= r.endRow; row++) {
+          clear(c, row);
+        }
+      }
+      opts.recalcFormulas?.();
+    };
+    if (opts.transact) opts.transact(run);
+    else run();
+  }
+  function findDataEdge(colIdx, rowIdx, dCol, dRow) {
+    let c = colIdx;
+    let r = rowIdx;
+    const currentEmpty = opts.getCellValue(c, r) === "";
+    const maxCol = opts.colCount.value - 1;
+    const maxRow = opts.rowCount.value - 1;
+    if (currentEmpty) {
+      while (true) {
+        c += dCol;
+        r += dRow;
+        if (c < 0 || c > maxCol || r < 0 || r > maxRow) {
+          return clamp(c - dCol, r - dRow);
+        }
+        if (opts.getCellValue(c, r) !== "") return { colIdx: c, rowIdx: r };
+      }
+    } else {
+      while (true) {
+        const nc = c + dCol;
+        const nr = r + dRow;
+        if (nc < 0 || nc > maxCol || nr < 0 || nr > maxRow) return { colIdx: c, rowIdx: r };
+        if (opts.getCellValue(nc, nr) === "") {
+          if (nc === colIdx + dCol && nr === rowIdx + dRow) {
+            return findDataEdge(nc, nr, dCol, dRow);
+          }
+          return { colIdx: c, rowIdx: r };
+        }
+        c = nc;
+        r = nr;
+      }
+    }
+  }
+  function extendSelectionTo(target) {
+    if (!activeCell.value) return;
+    selectionRange.value = {
+      startCol: activeCell.value.colIdx,
+      startRow: activeCell.value.rowIdx,
+      endCol: target.colIdx,
+      endRow: target.rowIdx
+    };
+  }
+  function onKeydown(e) {
+    const mod = e.ctrlKey || e.metaKey;
+    if (editMode.value) {
+      if (e.key === "Escape") {
+        e.preventDefault();
+        cancelEdit();
+        return;
+      }
+      if (e.key === "Enter") {
+        e.preventDefault();
+        commitEdit();
+        moveBy(0, e.shiftKey ? -1 : 1);
+        return;
+      }
+      if (e.key === "Tab") {
+        e.preventDefault();
+        commitEdit();
+        moveBy(e.shiftKey ? -1 : 1, 0);
+        return;
+      }
+      return;
+    }
+    if (mod && e.key === "a") {
+      e.preventDefault();
+      selectAll();
+      return;
+    }
+    if (mod && (e.key === "c" || e.key === "x" || e.key === "v")) {
+      return;
+    }
+    if (mod && (e.key === "z" || e.key === "y")) {
+      return;
+    }
+    if (mod && e.key === "Home") {
+      e.preventDefault();
+      moveTo(0, 0);
+      return;
+    }
+    if (mod && e.key === "End") {
+      e.preventDefault();
+      moveTo(opts.colCount.value - 1, opts.rowCount.value - 1);
+      return;
+    }
+    if (mod && ["ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight"].includes(e.key)) {
+      e.preventDefault();
+      if (!activeCell.value) {
+        activeCell.value = { colIdx: 0, rowIdx: 0 };
+        return;
+      }
+      const dCol = e.key === "ArrowLeft" ? -1 : e.key === "ArrowRight" ? 1 : 0;
+      const dRow = e.key === "ArrowUp" ? -1 : e.key === "ArrowDown" ? 1 : 0;
+      const target = findDataEdge(activeCell.value.colIdx, activeCell.value.rowIdx, dCol, dRow);
+      if (e.shiftKey) {
+        extendSelectionTo(target);
+      } else {
+        moveTo(target.colIdx, target.rowIdx);
+      }
+      return;
+    }
+    switch (e.key) {
+      case "ArrowUp":
+        e.preventDefault();
+        if (e.shiftKey) extendSelection(0, -1);
+        else moveBy(0, -1);
+        break;
+      case "ArrowDown":
+        e.preventDefault();
+        if (e.shiftKey) extendSelection(0, 1);
+        else moveBy(0, 1);
+        break;
+      case "ArrowLeft":
+        e.preventDefault();
+        if (e.shiftKey) extendSelection(-1, 0);
+        else moveBy(-1, 0);
+        break;
+      case "ArrowRight":
+        e.preventDefault();
+        if (e.shiftKey) extendSelection(1, 0);
+        else moveBy(1, 0);
+        break;
+      case "Tab":
+        e.preventDefault();
+        moveBy(e.shiftKey ? -1 : 1, 0);
+        break;
+      case "Enter":
+        e.preventDefault();
+        if (e.shiftKey) {
+          moveBy(0, -1);
+        } else {
+          startEdit(true);
+        }
+        break;
+      case "F2":
+        e.preventDefault();
+        startEdit(true);
+        break;
+      case "Delete":
+      case "Backspace":
+        e.preventDefault();
+        clearRange();
+        break;
+      case "Home":
+        e.preventDefault();
+        if (activeCell.value) moveTo(0, activeCell.value.rowIdx);
+        break;
+      case "End":
+        e.preventDefault();
+        if (activeCell.value) moveTo(opts.colCount.value - 1, activeCell.value.rowIdx);
+        break;
+      case "PageUp":
+        e.preventDefault();
+        moveBy(0, -(opts.pageSize?.value ?? 20));
+        break;
+      case "PageDown":
+        e.preventDefault();
+        moveBy(0, opts.pageSize?.value ?? 20);
+        break;
+      case "Escape":
+        e.preventDefault();
+        if (selectionRange.value) {
+          selectionRange.value = null;
+        } else {
+          activeCell.value = null;
+        }
+        break;
+      default:
+        if (e.key.length === 1 && !mod && !e.altKey) {
+          e.preventDefault();
+          selectionRange.value = null;
+          editValue.value = e.key;
+          editMode.value = true;
+        }
+        break;
+    }
+  }
+  function isActive(colIdx, rowIdx) {
+    return activeCell.value?.colIdx === colIdx && activeCell.value?.rowIdx === rowIdx;
+  }
+  return {
+    activeCell,
+    editMode,
+    editValue,
+    selectionRange,
+    normalizedRange,
+    isDragging,
+    isInRange,
+    selectCell,
+    activateCell,
+    startEdit,
+    commitEdit,
+    cancelEdit,
+    moveTo,
+    moveBy,
+    beginDrag,
+    continueDrag,
+    endDrag,
+    setRange,
+    selectRow,
+    selectColumn,
+    selectAll,
+    clearRange,
+    onKeydown,
+    isActive
+  };
+}

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

@@ -0,0 +1,31 @@
+import type { DocPageMeta } from './useChildTree.js';
+/**
+ * Manages the sheets view configuration stored on the SHEET document's own meta.
+ * Reads/writes sheetsColumnWidths, sheetsRowHeights, sheetsDefaultColWidth, etc.
+ */
+export declare function useSheetsView(tree: ReturnType<typeof import('./useChildTree').useChildTree>, sheetsDocId: string): {
+    sheetsMeta: import("vue").ComputedRef<DocPageMeta>;
+    defaultColWidth: import("vue").ComputedRef<number>;
+    defaultRowHeight: import("vue").ComputedRef<number>;
+    columnWidths: import("vue").ComputedRef<Record<string, number>>;
+    rowHeights: import("vue").ComputedRef<Record<string, number>>;
+    showGridlines: import("vue").ComputedRef<boolean>;
+    getColWidth: (colId: string) => number;
+    setColWidth: (colId: string, width: number) => void;
+    getRowHeight: (rowIdx: number) => number;
+    setRowHeight: (rowIdx: number, height: number) => void;
+    indexToColLetter: (n: number) => string;
+    colLetterToIndex: (s: string) => number;
+    getColumnPositions: (columns: {
+        id: string;
+        label: string;
+    }[], minCols: number) => {
+        idx: number;
+        id: string;
+        label: string;
+        start: number;
+        size: number;
+        letter: string;
+    }[];
+    updateSheetsMeta: (patch: Partial<DocPageMeta>) => void;
+};

package/dist/runtime/composables/useSheetsView.js

@@ -0,0 +1,77 @@
+import { computed } from "vue";
+export function useSheetsView(tree, sheetsDocId) {
+  const sheetsMeta = computed(() => {
+    const entry = tree.treeMap.data[sheetsDocId];
+    return entry?.meta ?? {};
+  });
+  const defaultColWidth = computed(() => sheetsMeta.value.sheetsDefaultColWidth ?? 100);
+  const columnWidths = computed(() => sheetsMeta.value.sheetsColumnWidths ?? {});
+  function getColWidth(colId) {
+    return columnWidths.value[colId] ?? defaultColWidth.value;
+  }
+  function setColWidth(colId, width) {
+    updateSheetsMeta({
+      sheetsColumnWidths: { ...columnWidths.value, [colId]: Math.max(40, width) }
+    });
+  }
+  const defaultRowHeight = computed(() => sheetsMeta.value.sheetsDefaultRowHeight ?? 28);
+  const rowHeights = computed(() => sheetsMeta.value.sheetsRowHeights ?? {});
+  function getRowHeight(rowIdx) {
+    return rowHeights.value[String(rowIdx)] ?? defaultRowHeight.value;
+  }
+  function setRowHeight(rowIdx, height) {
+    updateSheetsMeta({
+      sheetsRowHeights: { ...rowHeights.value, [String(rowIdx)]: Math.max(20, height) }
+    });
+  }
+  const showGridlines = computed(() => sheetsMeta.value.sheetsShowGridlines !== false);
+  function indexToColLetter(n) {
+    let result = "";
+    let idx = n;
+    while (idx >= 0) {
+      result = String.fromCharCode(65 + idx % 26) + result;
+      idx = Math.floor(idx / 26) - 1;
+    }
+    return result;
+  }
+  function colLetterToIndex(s) {
+    let result = 0;
+    for (let i = 0; i < s.length; i++) {
+      result = result * 26 + (s.charCodeAt(i) - 64);
+    }
+    return result - 1;
+  }
+  function updateSheetsMeta(patch) {
+    tree.updateMeta(sheetsDocId, patch);
+  }
+  function getColumnPositions(columns, minCols) {
+    const count = Math.max(columns.length, minCols);
+    const result = [];
+    let offset = 0;
+    for (let i = 0; i < count; i++) {
+      const col = columns[i];
+      const id = col?.id ?? `__empty_${i}`;
+      const label = col?.label || indexToColLetter(i);
+      const size = col ? getColWidth(col.id) : defaultColWidth.value;
+      result.push({ idx: i, id, label, start: offset, size, letter: indexToColLetter(i) });
+      offset += size;
+    }
+    return result;
+  }
+  return {
+    sheetsMeta,
+    defaultColWidth,
+    defaultRowHeight,
+    columnWidths,
+    rowHeights,
+    showGridlines,
+    getColWidth,
+    setColWidth,
+    getRowHeight,
+    setRowHeight,
+    indexToColLetter,
+    colLetterToIndex,
+    getColumnPositions,
+    updateSheetsMeta
+  };
+}

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

@@ -0,0 +1,43 @@
+/**
+ * useSpaceConnections — Single-space adapter.
+ *
+ * cou-sh has a multi-space `useSpaceConnections` (1073 LOC) that manages
+ * one provider per connected space. The Nuxt module is single-space — we
+ * always have exactly one active provider tied to `spaceDocId`.
+ *
+ * This adapter wraps that single connection in the same `Map<spaceId, conn>`
+ * shape, so consumers like `useDocLookup` and `useAggregatedPresence` can
+ * iterate it the same way as in cou-sh. When (if ever) the module gains
+ * multi-space, swap the implementation; the API stays.
+ *
+ * Why a Map for a single entry? It keeps the cou-sh ports near-1:1 — they
+ * iterate `for (const [, conn] of connections)` and read
+ * `conn.provider?.awareness`. Forcing them to special-case "single space"
+ * adds noise without changing behavior.
+ */
+import { type Ref } from 'vue';
+import * as Y from 'yjs';
+export interface SpaceTreeEntry {
+    label: string;
+    parentId: string | null;
+    order: number;
+    type?: string;
+    meta?: Record<string, unknown>;
+    createdAt?: number;
+    updatedAt?: number;
+}
+export interface SpaceConnection {
+    spaceId: string;
+    doc: Y.Doc;
+    provider: unknown | null;
+    client: unknown | null;
+    treeData: Ref<Record<string, SpaceTreeEntry>>;
+    trashData: Ref<Record<string, unknown>>;
+    status: Ref<'disconnected' | 'connecting' | 'connected'>;
+    isReady: Ref<boolean>;
+}
+interface SpaceConnectionsApi {
+    connections: Map<string, SpaceConnection>;
+}
+export declare function useSpaceConnections(): SpaceConnectionsApi;
+export {};

package/dist/runtime/composables/useSpaceConnections.js

@@ -0,0 +1,72 @@
+import { shallowReactive, ref, watch } from "vue";
+import * as Y from "yjs";
+import { useAbracadabra } from "./useAbracadabra.js";
+let _singleton = null;
+function _build() {
+  const state = useAbracadabra();
+  const connections = shallowReactive(/* @__PURE__ */ new Map());
+  const treeData = ref({});
+  const trashData = ref({});
+  let detachTree = null;
+  let detachTrash = null;
+  function syncMap(map, target) {
+    const obj = {};
+    map.forEach((val, key) => {
+      obj[key] = val instanceof Y.Map ? val.toJSON() : val;
+    });
+    target.value = obj;
+  }
+  function attachObservers(doc) {
+    detachTree?.();
+    detachTrash?.();
+    const tree = doc.getMap("doc-tree");
+    const trash = doc.getMap("doc-trash");
+    syncMap(tree, treeData);
+    syncMap(trash, trashData);
+    const onTree = () => syncMap(tree, treeData);
+    const onTrash = () => syncMap(trash, trashData);
+    tree.observe(onTree);
+    trash.observe(onTrash);
+    detachTree = () => tree.unobserve(onTree);
+    detachTrash = () => trash.unobserve(onTrash);
+  }
+  if (import.meta.client) {
+    watch(
+      () => [
+        state.spaceDocId.value,
+        state.doc.value,
+        state.provider.value,
+        state.client.value
+      ],
+      ([spaceId, doc, provider, client]) => {
+        connections.clear();
+        if (!spaceId || !doc) {
+          detachTree?.();
+          detachTrash?.();
+          detachTree = null;
+          detachTrash = null;
+          treeData.value = {};
+          trashData.value = {};
+          return;
+        }
+        attachObservers(doc);
+        connections.set(spaceId, {
+          spaceId,
+          doc,
+          provider,
+          client,
+          treeData,
+          trashData,
+          status: state.status,
+          isReady: state.isReady
+        });
+      },
+      { immediate: true }
+    );
+  }
+  return { connections };
+}
+export function useSpaceConnections() {
+  if (!_singleton) _singleton = _build();
+  return _singleton;
+}

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

@@ -11,8 +11,6 @@ import type { SpaceMeta } from '../types.js';
 export declare function useSpaces(): {
     /** All spaces on the current server. */
     spaces: import("vue").ComputedRef<SpaceMeta[]>;
-    /** Whether the current server supports spaces. */
-    spacesEnabled: import("vue").ComputedRef<boolean>;
     /** The currently active space. */
     currentSpace: import("vue").ComputedRef<SpaceMeta | null>;
     /** Whether space operations are in progress. */
@@ -29,7 +27,7 @@ export declare function useSpaces(): {
         id?: string;
     }) => Promise<SpaceMeta>;
     /** Update an existing space. */
-    update: (id: string, opts: Partial<Pick<SpaceMeta, "name" | "description" | "visibility" | "is_hub">>) => Promise<SpaceMeta>;
+    update: (id: string, opts: Partial<Pick<SpaceMeta, "name" | "description" | "visibility">>) => Promise<void>;
     /** Delete a space. */
     remove: (id: string) => Promise<void>;
     /** Switch to a different space. */