fix: collab refactor

Author: gustavotoyota

AGENTS.md

@@ -3,5 +3,4 @@
     - Feature-based folder structure.
 - Do not try to use the Cwd or MatchPerLine parameters in tool calls, they don't work.
 - Run tests via `pnpm test` from the package root (e.g. `cd packages/session && pnpm test`). Do not use `vitest run --workspace` or `pnpm test --run`.
-- Collab wire has two message types: `DOC` (ProseMirror-only, legacy) and `PAGE_DOC` (page-level spatial). The DO routes them to `page_updates` vs `page_spatial_updates`, which share a unified index space.
 - A DeepNotes "page" is an infinite spatial canvas.

docs/RESTART_PLAN.md

@@ -494,8 +494,7 @@ The new `usePageCollabEditor` only syncs a ProseMirror `Y.XmlFragment`. We need
 **Exit criteria:**
 - [x] `packages/collab-wire` can encode/decode a page-level Yjs update.
 - [x] `PageCollabRoom` persists and relays page-level updates (not just ProseMirror).
-- [x] Two clients sync note creation/deletion via WS (integration test: `spatial collab updates: separate table with unified index`).
-- [x] `docs/COLLAB_DATA_MIGRATION.md` documents the `page_updates` compatibility strategy.
+- [x] Two clients sync note creation/deletion via WS (integration test).
 - [x] `docs/COLLAB_DO_ARCHITECTURE.md` documents stateless-relay trade-offs, protocol differences, and CPU limits.
 - [x] `docs/SPATIAL_ARCHITECTURE_DECISION.md` documents SyncedStore vs hybrid proxy decision.
 - [x] Schema includes every legacy field from the Phase 1 diff table (no omissions).

new-deepnotes/apps/api-worker/src/page-collab-room.ts

@@ -2,8 +2,6 @@ import {
   decodeClientCollabBinaryMessage,
   encodeDocSingleUpdateAck,
   encodeDocSingleUpdateFromServer,
-  encodePageDocSingleUpdateAck,
-  encodePageDocSingleUpdateFromServer,
   uint8ToBase64Standard,
 } from "@deepnotes/collab-wire";
 
@@ -76,7 +74,6 @@ export class PageCollabRoom {
       return;
     }
 
-    const isPageDoc = decoded.kind === "page-doc-single";
     const encryptedUpdate = decoded.encryptedUpdate;
 
     const secret = this.env.COLLAB_INTERNAL_SECRET;
@@ -98,7 +95,6 @@ export class PageCollabRoom {
           body: JSON.stringify({
             userId: attachment.userId,
             encryptedDataBase64: uint8ToBase64Standard(encryptedUpdate),
-            type: isPageDoc ? "spatial" : "prosemirror",
           }),
         },
       ),
@@ -124,25 +120,14 @@ export class PageCollabRoom {
     }
     const dbIndex = (payload as { newIndex: number }).newIndex;
 
-    if (isPageDoc) {
-      const relay = encodePageDocSingleUpdateFromServer(encryptedUpdate, dbIndex);
-      this.broadcast(ws, relay);
-      ws.send(
-        encodePageDocSingleUpdateAck({
-          updateId: decoded.updateId,
-          dbIndex,
-        }),
-      );
-    } else {
-      const relay = encodeDocSingleUpdateFromServer(encryptedUpdate, dbIndex);
-      this.broadcast(ws, relay);
-      ws.send(
-        encodeDocSingleUpdateAck({
-          updateId: decoded.updateId,
-          dbIndex,
-        }),
-      );
-    }
+    const relay = encodeDocSingleUpdateFromServer(encryptedUpdate, dbIndex);
+    this.broadcast(ws, relay);
+    ws.send(
+      encodeDocSingleUpdateAck({
+        updateId: decoded.updateId,
+        dbIndex,
+      }),
+    );
   }
 
   private broadcast(exceptWs: WebSocket, data: Uint8Array): void {

new-deepnotes/apps/api-worker/src/routes/pages.ts

@@ -254,9 +254,6 @@ app.post("/api/internal/pages/:pageId/collab-ws-append", async (c) => {
     );
   }
 
-  const updateType =
-    (bodyJson as { type?: string }).type === "spatial" ? "spatial" : "prosemirror";
-
   const { base64ToUint8Standard } = await import("@deepnotes/collab-wire");
   const userId = (bodyJson as { userId: string }).userId;
   const encryptedData = base64ToUint8Standard(
@@ -266,18 +263,6 @@ app.post("/api/internal/pages/:pageId/collab-ws-append", async (c) => {
   const db = getDbForConnectionString(hyper.connectionString);
 
   try {
-    if (updateType === "spatial") {
-      const { performTrustedAppendNextPageSpatialCollabUpdate } =
-        await import("@deepnotes/session");
-      const { newIndex } = await performTrustedAppendNextPageSpatialCollabUpdate({
-        db,
-        pageId: pParams.data.pageId,
-        userId,
-        encryptedData,
-      });
-      return c.json({ newIndex }, 200);
-    }
-
     const { performTrustedAppendNextPageCollabUpdate } =
       await import("@deepnotes/session");
     const { newIndex } = await performTrustedAppendNextPageCollabUpdate({

new-deepnotes/apps/web/src/features/pages/page-collab-ws-incoming.ts

@@ -86,42 +86,5 @@ export function applyIncomingCollabWsMessage(
     if (msg.dbIndex != null) {
       ctx.collabLastIndex.value = msg.dbIndex;
     }
-    return;
-  }
-
-  if (msg.kind === "page-single-update") {
-    if (pk == null || !id) {
-      return;
-    }
-    ctx.hydrating.value = true;
-    try {
-      const plain = decryptPageDocUpdate({
-        pageKeyring: pk,
-        pageId: id,
-        ciphertext: msg.encryptedUpdate,
-      });
-      Y.applyUpdateV2(ctx.ydoc, plain, "collab-ws-remote");
-      Y.applyUpdateV2(ctx.serverDoc, plain);
-      if (msg.dbIndex != null) {
-        ctx.collabLastIndex.value = msg.dbIndex;
-      }
-      ctx.refreshYMetrics();
-    } catch {
-      // ignore decrypt failures
-    } finally {
-      ctx.hydrating.value = false;
-    }
-    return;
-  }
-
-  if (msg.kind === "page-single-update-ack") {
-    const ackedDiff = ctx.unackedUpdates.get(msg.updateId);
-    if (ackedDiff) {
-      Y.applyUpdateV2(ctx.serverDoc, ackedDiff);
-      ctx.unackedUpdates.delete(msg.updateId);
-    }
-    if (msg.dbIndex != null) {
-      ctx.collabLastIndex.value = msg.dbIndex;
-    }
   }
 }

new-deepnotes/apps/web/src/features/pages/useCollabPush.ts

@@ -1,7 +1,4 @@
-import {
-  encodeDocSingleUpdateFromClient,
-  encodePageDocSingleUpdateFromClient,
-} from "@deepnotes/collab-wire";
+import { encodeDocSingleUpdateFromClient } from "@deepnotes/collab-wire";
 import type { SymmetricKeyring } from "@deepnotes/e2ee";
 import type { ComputedRef, Ref } from "vue";
 import { ref } from "vue";
@@ -24,8 +21,6 @@ export function useCollabPush(opts: {
   serverDoc?: Y.Doc;
   unackedUpdates?: Map<number, Uint8Array>;
   collabLastIndex?: Ref<number | null>;
-  /** "doc" = ProseMirror-only (legacy), "page-doc" = page-level spatial updates */
-  messageType?: "doc" | "page-doc";
 }) {
   const {
     ydoc,
@@ -36,7 +31,6 @@ export function useCollabPush(opts: {
     client,
     collabWsLive,
     getCollabWs,
-    messageType = "doc",
   } = opts;
 
   const pushError = ref<string | null>(null);
@@ -109,17 +103,12 @@ export function useCollabPush(opts: {
       });
       const uid = collabClientUpdateId++;
       unackedUpdates.set(uid, diff);
-      const frame =
-        messageType === "page-doc"
-          ? encodePageDocSingleUpdateFromClient({
-              updateId: uid,
-              encryptedUpdate: enc,
-            })
-          : encodeDocSingleUpdateFromClient({
-              updateId: uid,
-              encryptedUpdate: enc,
-            });
-      ws.send(frame);
+      ws.send(
+        encodeDocSingleUpdateFromClient({
+          updateId: uid,
+          encryptedUpdate: enc,
+        }),
+      );
     } catch (e) {
       pushError.value =
         e instanceof Error ? e.message : "Could not send collab update.";

new-deepnotes/packages/collab-wire/src/collab-wire.test.ts

@@ -8,9 +8,6 @@ import {
   encodeDocSingleUpdateAck,
   encodeDocSingleUpdateFromClient,
   encodeDocSingleUpdateFromServer,
-  encodePageDocSingleUpdateFromClient,
-  encodePageDocSingleUpdateFromServer,
-  encodePageDocSingleUpdateAck,
   uint8ToBase64Standard,
   base64ToUint8Standard,
 } from "./index.js";
@@ -70,37 +67,4 @@ describe("@deepnotes/collab-wire", () => {
     });
   });
 
-  it("round-trips PAGE_DOC client SINGLE_UPDATE and server ACK with dbIndex", () => {
-    const enc = new Uint8Array([4, 5, 6]);
-    const bin = encodePageDocSingleUpdateFromClient({ updateId: 9, encryptedUpdate: enc });
-    const dec = decodeClientCollabBinaryMessage(bin);
-    expect(dec).toEqual({
-      kind: "page-doc-single",
-      updateId: 9,
-      encryptedUpdate: enc,
-    });
-
-    const ack = encodePageDocSingleUpdateAck({ updateId: 9, dbIndex: 55 });
-    const incoming = decodeIncomingCollabBinaryMessage(ack);
-    expect(incoming).toEqual({
-      kind: "page-single-update-ack",
-      updateId: 9,
-      dbIndex: 55,
-    });
-  });
-
-  it("PAGE_DOC server SINGLE_UPDATE decodes ciphertext and optional dbIndex", () => {
-    const enc = new Uint8Array([10, 11]);
-    const bin = encodePageDocSingleUpdateFromServer(enc, 6);
-    expect(decodeIncomingCollabBinaryMessage(bin)).toEqual({
-      kind: "page-single-update",
-      encryptedUpdate: enc,
-      dbIndex: 6,
-    });
-    expect(decodeIncomingCollabBinaryMessage(encodePageDocSingleUpdateFromServer(enc))).toEqual({
-      kind: "page-single-update",
-      encryptedUpdate: enc,
-      dbIndex: null,
-    });
-  });
 });

new-deepnotes/packages/collab-wire/src/index.ts

@@ -8,7 +8,6 @@ import * as encoding from "lib0/encoding";
 export const CollabMessageType = {
   DOC: 0,
   AWARENESS: 1,
-  PAGE_DOC: 2,
 } as const;
 
 export const CollabServerDocMessageType = {
@@ -63,46 +62,6 @@ export function encodeDocSingleUpdateAck(input: {
   return encoding.toUint8Array(enc);
 }
 
-export function encodePageDocSingleUpdateFromClient(input: {
-  updateId: number;
-  encryptedUpdate: Uint8Array;
-}): Uint8Array {
-  const enc = encoding.createEncoder();
-  encoding.writeVarUint(enc, CollabMessageType.PAGE_DOC);
-  encoding.writeVarUint(enc, CollabClientDocMessageType.SINGLE_UPDATE);
-  encoding.writeVarUint(enc, input.updateId);
-  encoding.writeVarUint8Array(enc, input.encryptedUpdate);
-  return encoding.toUint8Array(enc);
-}
-
-export function encodePageDocSingleUpdateFromServer(
-  encryptedUpdate: Uint8Array,
-  dbIndex?: number,
-): Uint8Array {
-  const enc = encoding.createEncoder();
-  encoding.writeVarUint(enc, CollabMessageType.PAGE_DOC);
-  encoding.writeVarUint(enc, CollabServerDocMessageType.SINGLE_UPDATE);
-  encoding.writeVarUint8Array(enc, encryptedUpdate);
-  if (dbIndex !== undefined) {
-    encoding.writeVarUint(enc, dbIndex);
-  }
-  return encoding.toUint8Array(enc);
-}
-
-export function encodePageDocSingleUpdateAck(input: {
-  updateId: number;
-  dbIndex?: number;
-}): Uint8Array {
-  const enc = encoding.createEncoder();
-  encoding.writeVarUint(enc, CollabMessageType.PAGE_DOC);
-  encoding.writeVarUint(enc, CollabServerDocMessageType.SINGLE_UPDATE_ACK);
-  encoding.writeVarUint(enc, input.updateId);
-  if (input.dbIndex !== undefined) {
-    encoding.writeVarUint(enc, input.dbIndex);
-  }
-  return encoding.toUint8Array(enc);
-}
-
 export function encodeAwarenessMessage(encryptedChunks: Uint8Array[]): Uint8Array {
   const enc = encoding.createEncoder();
   encoding.writeVarUint(enc, CollabMessageType.AWARENESS);
@@ -115,7 +74,6 @@ export function encodeAwarenessMessage(encryptedChunks: Uint8Array[]): Uint8Arra
 
 export type DecodedClientCollabMessage =
   | { kind: "doc-single"; updateId: number; encryptedUpdate: Uint8Array }
-  | { kind: "page-doc-single"; updateId: number; encryptedUpdate: Uint8Array }
   | { kind: "awareness"; raw: Uint8Array };
 
 export function decodeClientCollabBinaryMessage(message: Uint8Array): DecodedClientCollabMessage | null {
@@ -127,15 +85,6 @@ export function decodeClientCollabBinaryMessage(message: Uint8Array): DecodedCli
   if (top === CollabMessageType.AWARENESS) {
     return { kind: "awareness", raw: message };
   }
-  if (top === CollabMessageType.PAGE_DOC) {
-    const docKind = decoding.readVarUint(dec);
-    if (docKind !== CollabClientDocMessageType.SINGLE_UPDATE) {
-      return null;
-    }
-    const updateId = decoding.readVarUint(dec);
-    const encryptedUpdate = decoding.readVarUint8Array(dec);
-    return { kind: "page-doc-single", updateId, encryptedUpdate };
-  }
   if (top !== CollabMessageType.DOC) {
     return null;
   }
@@ -152,15 +101,10 @@ export type DecodedServerDocMessage =
   | { kind: "single-update"; encryptedUpdate: Uint8Array; dbIndex: number | null }
   | { kind: "single-update-ack"; updateId: number; dbIndex: number | null };
 
-export type DecodedServerPageDocMessage =
-  | { kind: "page-single-update"; encryptedUpdate: Uint8Array; dbIndex: number | null }
-  | { kind: "page-single-update-ack"; updateId: number; dbIndex: number | null };
-
 /** Server/relay → client: awareness broadcast or doc message (legacy framing). */
 export type DecodedIncomingCollabMessage =
   | { kind: "awareness"; encryptedChunks: Uint8Array[] }
-  | DecodedServerDocMessage
-  | DecodedServerPageDocMessage;
+  | DecodedServerDocMessage;
 
 function decodeServerDocFromDocDecoder(
   dec: decoding.Decoder,
@@ -179,23 +123,6 @@ function decodeServerDocFromDocDecoder(
   return null;
 }
 
-function decodeServerPageDocFromDecoder(
-  dec: decoding.Decoder,
-): DecodedServerPageDocMessage | null {
-  const docKind = decoding.readVarUint(dec);
-  if (docKind === CollabServerDocMessageType.SINGLE_UPDATE) {
-    const encryptedUpdate = decoding.readVarUint8Array(dec);
-    const dbIndex = decoding.hasContent(dec) ? decoding.readVarUint(dec) : null;
-    return { kind: "page-single-update", encryptedUpdate, dbIndex };
-  }
-  if (docKind === CollabServerDocMessageType.SINGLE_UPDATE_ACK) {
-    const updateId = decoding.readVarUint(dec);
-    const dbIndex = decoding.hasContent(dec) ? decoding.readVarUint(dec) : null;
-    return { kind: "page-single-update-ack", updateId, dbIndex };
-  }
-  return null;
-}
-
 export function decodeIncomingCollabBinaryMessage(
   message: Uint8Array,
 ): DecodedIncomingCollabMessage | null {
@@ -212,9 +139,6 @@ export function decodeIncomingCollabBinaryMessage(
     }
     return { kind: "awareness", encryptedChunks };
   }
-  if (top === CollabMessageType.PAGE_DOC) {
-    return decodeServerPageDocFromDecoder(dec);
-  }
   if (top !== CollabMessageType.DOC) {
     return null;
   }