Method getYDoc

src/durable-objects/user-notes.ts:176–229

(noteId: string)

            // settings (e.g. agent prefs, last-seen versions) doesn't require
            // a schema migration each time.
            this.sql.exec(`
                CREATE TABLE IF NOT EXISTS smfs_config (
                    key TEXT PRIMARY KEY,
                    value TEXT NOT NULL
                )
            `);
        });
    }

    private getYDoc(noteId: string): Y.Doc {
        let doc = this.docs.get(noteId);
        if (doc) return doc;

        doc = new Y.Doc();
        const rows = this.sql.exec("SELECT yjs_state FROM notes WHERE id = ?", noteId).toArray();
        if (rows[0]?.yjs_state) {
            Y.applyUpdate(doc, new Uint8Array(rows[0].yjs_state as ArrayBuffer));
        }

        doc.on("update", (update: Uint8Array, origin: any) => {
            // Broadcast to all connected clients except the sender.
            // origin is the WebSocket that caused this update (null for DB loads).
            if (origin) {
                const encoder = encoding.createEncoder();
                encoding.writeVarUint(encoder, MSG_SYNC);
                syncProtocol.writeUpdate(encoder, update);
                const msg = encoding.toUint8Array(encoder);
                for (const other of this.ctx.getWebSockets(noteId)) {
                    if (other !== origin) {
                        try { other.send(msg); } catch { other.close(); }
                    }
                }
            }

            this.scheduleDocPersist(noteId, doc!, 2000);
        });

        this.docs.set(noteId, doc);
        return doc;
    }

    // Persist a live Yjs doc to the notes row: yjs_state always; content +
    // title when serialization yields a non-empty doc. Never replaces
    // non-empty column content with an empty doc — if serialization ever
    // regresses (or the doc is transiently blank), losing the row content is
    // the worst outcome. Shared by the debounced save and the last-close flush
    // so the content column can never lag behind yjs_state.
    private persistDocNow(noteId: string, doc: Y.Doc) {
        const state = Y.encodeStateAsUpdate(doc);
        let content = this.extractContentJson(noteId);
        if (content && isEmptyDoc(content)) {
            const existing = this.sql.exec("SELECT content FROM notes WHERE id = ?", noteId).toArray()[0] as any;
            if (existing?.content && !isEmptyDoc(existing.content)) content = null;
        }
        if (content && !isEmptyDoc(content)) {
            // Real content: UPSERT so a brand-new note persists even when the HTTP
            // autosave never created the row (or failed, e.g. a transient 503).