Method fetch

src/durable-objects/user-notes.ts:422–906

(request: Request)

    private contentHash(content: string): string {
        let hash = 5381;
        for (let i = 0; i < content.length; i++) {
            hash = ((hash << 5) + hash) ^ content.charCodeAt(i);
        }
        return (hash >>> 0).toString(36);
    }

    private beginEditSession(noteId: string): { sessionId: string } {
        const note = this.getNote(noteId);
        const branch = this.getCurrentBranch(noteId);
        const sessionId = crypto.randomUUID();
        this.sql.exec(
            `INSERT INTO edit_sessions (id, note_id, branch_id, base_content, base_version_id)
             VALUES (?, ?, ?, ?, ?)`,
            sessionId, noteId, branch.id, (note?.content as string) || "", branch.head_version_id
        );
        return { sessionId };
    }

    private async finalizeEditSession(noteId: string, sessionId: string, reason = "finalize"): Promise<{ versionId?: string }> {
        const session = this.sql.exec(
            "SELECT id, base_content FROM edit_sessions WHERE id = ? AND note_id = ? AND finalized_at IS NULL",
            sessionId, noteId
        ).toArray()[0] as any;
        if (!session) return {};

        const note = this.getNote(noteId);
        const currentContent = (note?.content as string) || "";
        this.sql.exec("UPDATE edit_sessions SET finalized_at = unixepoch(), last_edit_at = unixepoch() WHERE id = ?", sessionId);
        if (!note || currentContent === (session.base_content || "")) return {};

        const versionId = await this.createVersion(
            noteId,
            deriveTitleAndPreview(currentContent).title || (note.title as string) || "Untitled",
            currentContent,
            "session",
            "session",
            `Editing session (${reason})`
        ) || undefined;
        this.sql.exec(
            "UPDATE notes SET pending_index = 1 WHERE id = ?",
            noteId
        );
        return { versionId };
    }

    // strict: throw on R2 read errors instead of degrading to "" — used where
    // the caller must distinguish "genuinely empty" from "couldn't read".
    private async reconstructVersion(versionId: string, noteId: string, opts?: { strict?: boolean }): Promise<string> {
        // New-style versions are full snapshots in R2
        const head = this.sql.exec(
            "SELECT storage, data FROM note_versions WHERE id = ?", versionId
        ).toArray()[0] as any;
        if (head?.storage === "r2") {
            try {
                const obj = await this.bucket.get(head.data);
                if (obj) return await obj.text();
            } catch (e) {