MetaList 0.9.0__tar.gz → 0.11.0__tar.gz

{metalist-0.9.0 → metalist-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.9.0
+Version: 0.11.0
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -49,6 +49,23 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.11.0
+
+- Large namespaces stay fast while scrolling: only a band of root notes around the viewport is loaded, the server remembers what each tab shows so the browser no longer sends note hashes, and rendered notes are cached.
+- Tag suggestions, searches with only exclusions (`-tag`), and the updated/content-volume sort orders respond much faster on large namespaces.
+- Accepting or removing tag proposals in bulk, renaming or deleting a tag, and undoing a large delete no longer rebuild every note's inherited tags.
+- Unlocking an encrypted namespace is faster, and the startup encryption audit no longer loads every attachment into memory.
+- Fixed undo of deleting a note whose children have several children, and "accept all" failing on tag bars with leading or trailing spaces.
+- Fixed crashes in the status check after returning to a tab and in scroll-position saving.
+
+## Changes in 0.10.0
+
+- Excalidraw diagrams: add one from the note's right-click menu or the command palette, and double-click a diagram to edit it full screen. Diagrams autosave, show light and dark previews, resize like images, and each editing session is one undo step. The editor is bundled locally and needs no Node server.
+- The dark theme uses neutral greys with a brighter accent, the light theme header is darker, and Note Layout & Appearance adds note corner and tag style settings.
+- References to a note that starts with an image or diagram show its thumbnail. Collapsed notes, reference titles, and backlink previews show only the first line.
+- Fixed a command palette crash on queries with no matches.
+- The database schema moves to version 10. Password-protected namespaces migrate after unlock, with the usual automatic backup first.
+
 ## Changes in 0.9.0
 
 - AI chat can browse the web in disabled, contextual, or unrestricted mode, fetch multiple pages concurrently, and cite the specific pages used as evidence.

{metalist-0.9.0 → metalist-0.11.0}/README.md

@@ -12,6 +12,23 @@ A minimalist single-user note-taking app focused on server-side rendering (SSR),
 - Multi-tab search contexts with server-persisted scroll/search state (survives browser restarts)
 - Manual namespace backups/restores to a user-selected backup folder with retention controls
 
+## Changes in 0.11.0
+
+- Large namespaces stay fast while scrolling: only a band of root notes around the viewport is loaded, the server remembers what each tab shows so the browser no longer sends note hashes, and rendered notes are cached.
+- Tag suggestions, searches with only exclusions (`-tag`), and the updated/content-volume sort orders respond much faster on large namespaces.
+- Accepting or removing tag proposals in bulk, renaming or deleting a tag, and undoing a large delete no longer rebuild every note's inherited tags.
+- Unlocking an encrypted namespace is faster, and the startup encryption audit no longer loads every attachment into memory.
+- Fixed undo of deleting a note whose children have several children, and "accept all" failing on tag bars with leading or trailing spaces.
+- Fixed crashes in the status check after returning to a tab and in scroll-position saving.
+
+## Changes in 0.10.0
+
+- Excalidraw diagrams: add one from the note's right-click menu or the command palette, and double-click a diagram to edit it full screen. Diagrams autosave, show light and dark previews, resize like images, and each editing session is one undo step. The editor is bundled locally and needs no Node server.
+- The dark theme uses neutral greys with a brighter accent, the light theme header is darker, and Note Layout & Appearance adds note corner and tag style settings.
+- References to a note that starts with an image or diagram show its thumbnail. Collapsed notes, reference titles, and backlink previews show only the first line.
+- Fixed a command palette crash on queries with no matches.
+- The database schema moves to version 10. Password-protected namespaces migrate after unlock, with the usual automatic backup first.
+
 ## Changes in 0.9.0
 
 - AI chat can browse the web in disabled, contextual, or unrestricted mode, fetch multiple pages concurrently, and cite the specific pages used as evidence.

{metalist-0.9.0 → metalist-0.11.0}/app/api/middleware/auth.py

@@ -37,11 +37,6 @@ class AuthMiddleware(BaseHTTPMiddleware):
     )
     assert all(path.endswith("/") for path in PUBLIC_PREFIX_PATHS)
     
-    # Paths to suppress verbose logging for (frequent polling endpoints)
-    QUIET_PATHS = [
-        f"{API_PREFIX}/auth/status",
-    ]
-    
     # Background/automated paths that should NOT refresh tokens (not user activity)
     NO_TOKEN_REFRESH_PATHS = [
         f"{API_PREFIX}/auth/status",  # Polling service pings this for connectivity
@@ -75,20 +70,9 @@ class AuthMiddleware(BaseHTTPMiddleware):
             # Redirect all other requests to maintenance page
             return RedirectResponse(url="/maintenance", status_code=302)
         
-        # Check if this is a quiet path (suppress verbose logging)
-        is_quiet = any(path.startswith(quiet) for quiet in self.QUIET_PATHS)
-        
-        if not is_quiet:
-            print(f"Middleware checking path: {path}")
-        
         if self.is_public_path(path=path):
-            if not is_quiet:
-                print(f"Path {path} is explicitly public, skipping auth")
             return await call_next(request)
         
-        if not is_quiet:
-            print(f"Path {path} is NOT public, checking auth")
-        
         # Startup and recoverable password transitions publish this memory-owned flag.
         if path == f"{API_PREFIX}/auth/settings/password/create" and not is_encryption_required():
             return await call_next(request)

{metalist-0.9.0 → metalist-0.11.0}/app/api/note_requests.py

@@ -56,8 +56,9 @@ class ViewDiffRequest(TypedDict):
     search: Text | None
     tabId: Identifier
     undoContext: UndoContext
-    clientNoteUuidHashes: dict[Identifier, Text]
-    visibleRootAnchorId: Text | None
+    tabViewEmpty: bool
+    visibleTopRootId: Text | None
+    visibleBottomRootId: Text | None
     isUntaggedView: bool
 
 @with_config(ConfigDict(strict=True))
@@ -76,6 +77,7 @@ class UpdateTabSortModeRequest(TypedDict):
 @with_config(ConfigDict(strict=True))
 class CreateNewTabRequest(TypedDict):
     copyFromTabId: Identifier
+    clientId: Identifier
 
 @with_config(ConfigDict(strict=True))
 class DeleteTabRequest(TypedDict):
@@ -206,6 +208,19 @@ class ResizeNoteImageRequest(TypedDict):
     undoContext: UndoContext
     viewport: Viewport
 
+@with_config(ConfigDict(strict=True))
+class FinishFileEditSessionRequest(TypedDict):
+    clientId: Identifier
+    hostNoteId: Identifier
+    contentRevision: Annotated[int, Field(ge=1)]
+    isNewDiagram: bool
+    undoContext: UndoContext
+    viewport: Viewport
+
+@with_config(ConfigDict(strict=True))
+class DiscardFileEditSessionRequest(TypedDict):
+    contentRevision: Annotated[int, Field(ge=1)]
+
 @with_config(ConfigDict(strict=True))
 class RunShellEndpointRequest(TypedDict):
     timeoutSeconds: Annotated[int, Field(ge=0, le=SHELL_SECONDS)]

{metalist-0.9.0 → metalist-0.11.0}/app/api/routes/auth.py

@@ -713,7 +713,8 @@ def auth_status(
         "version": VERSION,
         "database_user_version": database_user_version,
         "authenticated": token is not None,
-        "has_password": auth.has_password(),
+        # Same answer as AuthService.has_password(), from the row already read.
+        "has_password": settings is not None and bool(settings.encryption_enabled),
         "encryption_enabled": settings.encryption_enabled if settings else False,
         "encryption_algorithm": settings.encryption_algorithm if settings else None,
         "vault_version": settings.vault_version if settings else None,

metalist-0.11.0/app/api/routes/files.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Annotated
+from urllib.parse import quote
+
+from fastapi import APIRouter, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import Response, StreamingResponse
+from pydantic import BaseModel
+
+from app.api.note_requests import DiscardFileEditSessionRequest, FinishFileEditSessionRequest
+from app.api.transactions import transactional_route
+from app.api.upload_limits import read_attachment
+from app.api.request_auth import require_request_auth_token
+from app.services.file_registry import file_registry
+from app.services.note_store import store as note_store
+from app.db.file_schema import FILE_PREVIEW_VARIANTS
+from app.services.file_storage import (
+    create_file,
+    download_file,
+    get_file_preview,
+    replace_file_content,
+    store_file_previews,
+    trim_unused_files,
+)
+from app.usecases.file_edit_session import (
+    CmdDiscardFileEditSession,
+    CmdFinishFileEditSession,
+    CmdStartFileEditSession,
+)
+
+router = APIRouter(prefix="/files", tags=["files"])
+
+FILE_REVISION_HEADER = "X-MetaList-File-Revision"
+
+
+class UploadedFileResponse(BaseModel):
+    file_id: str
+    reference_token: str
+    title: str
+    original_filename: str
+    mime_type: str
+    size_bytes: int
+    thumbnail_kind: str
+
+
+class FileContentUpdatedResponse(BaseModel):
+    file_id: str
+    content_revision: int
+    size_bytes: int
+
+
+class FilePreviewsStoredResponse(BaseModel):
+    file_id: str
+    content_revision: int
+
+
+class TrimUnusedFilesResponse(BaseModel):
+    deleted_count: int
+    deleted_file_ids: list[str]
+
+
+def _require_bearer_token(request: Request) -> str:
+    return require_request_auth_token(request)
+
+
+def _require_known_file(file_id: str) -> None:
+    if not file_registry.has_file(file_id):
+        raise HTTPException(status_code=404, detail=f"File not found: {file_id}")
+
+
+@router.post("/upload", response_model=UploadedFileResponse)
+@transactional_route
+async def upload_file_endpoint(
+    request: Request,
+    file: Annotated[UploadFile, File()],
+):
+    token = _require_bearer_token(request)
+    if not isinstance(file.filename, str) or file.filename == "":
+        raise HTTPException(status_code=400, detail="Uploaded file must include a filename")
+    if not isinstance(file.content_type, str) or file.content_type == "":
+        raise HTTPException(status_code=400, detail="Uploaded file must include a non-empty MIME type")
+
+    content_bytes = await read_attachment(file)
+
+    record = create_file(
+        original_filename=file.filename,
+        mime_type=file.content_type,
+        content_bytes=content_bytes,
+        token=token,
+    )
+    return UploadedFileResponse(
+        file_id=record.id,
+        reference_token=f"![[{record.id}]]",
+        title=record.title,
+        original_filename=record.original_filename,
+        mime_type=record.mime_type,
+        size_bytes=record.size_bytes,
+        thumbnail_kind=record.thumbnail_kind,
+    )
+
+
+@router.get("/{file_id}/download")
+def download_file_endpoint(request: Request, file_id: str):
+    token = _require_bearer_token(request)
+    if not file_registry.has_file(file_id):
+        raise HTTPException(status_code=404, detail=f"File not found: {file_id}")
+
+    downloaded = download_file(file_id, token)
+    quoted_filename = quote(downloaded.record.original_filename, safe="")
+    return StreamingResponse(
+        BytesIO(downloaded.content_bytes),
+        media_type=downloaded.record.mime_type,
+        headers={
+            "Content-Disposition": f"attachment; filename*=UTF-8''{quoted_filename}",
+            FILE_REVISION_HEADER: str(downloaded.record.content_revision),
+        },
+    )
+
+
+@router.put("/{file_id}/content", response_model=FileContentUpdatedResponse)
+@transactional_route
+async def replace_file_content_endpoint(
+    request: Request,
+    file_id: str,
+    file: Annotated[UploadFile, File()],
+    expected_revision: Annotated[int, Form()],
+):
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    content_bytes = await read_attachment(file)
+    record = replace_file_content(
+        file_id=file_id,
+        content_bytes=content_bytes,
+        expected_revision=expected_revision,
+        token=token,
+    )
+    return FileContentUpdatedResponse(
+        file_id=record.id,
+        content_revision=record.content_revision,
+        size_bytes=record.size_bytes,
+    )
+
+
+@router.put("/{file_id}/previews", response_model=FilePreviewsStoredResponse)
+@transactional_route
+async def store_file_previews_endpoint(
+    request: Request,
+    file_id: str,
+    light: Annotated[UploadFile, File()],
+    dark: Annotated[UploadFile, File()],
+    content_revision: Annotated[int, Form()],
+):
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    previews_by_variant = {
+        "light": await read_attachment(light),
+        "dark": await read_attachment(dark),
+    }
+    record = store_file_previews(
+        file_id=file_id,
+        previews_by_variant=previews_by_variant,
+        content_revision=content_revision,
+        token=token,
+    )
+    return FilePreviewsStoredResponse(file_id=record.id, content_revision=record.content_revision)
+
+
+@router.get("/{file_id}/previews/{variant}")
+def download_file_preview_endpoint(request: Request, file_id: str, variant: str):
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    if variant not in FILE_PREVIEW_VARIANTS:
+        raise HTTPException(status_code=404, detail=f"Unknown preview variant: {variant}")
+    preview = get_file_preview(file_id=file_id, variant=variant, token=token)
+    return Response(
+        content=preview.content_bytes,
+        media_type=preview.mime_type,
+        headers={FILE_REVISION_HEADER: str(preview.content_revision)},
+    )
+
+
+# A diagram editing session: opened with the editor, finished by Done (one undo step), or discarded.
+@router.post("/{file_id}/edit-sessions")
+@transactional_route
+def start_file_edit_session_endpoint(request: Request, file_id: str) -> dict[str, object]:
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    return CmdStartFileEditSession(file_id=file_id, token=token).execute()
+
+
+@router.post("/{file_id}/edit-sessions/{session_id}/finish")
+@transactional_route
+def finish_file_edit_session_endpoint(
+    request: Request,
+    file_id: str,
+    session_id: str,
+    body: FinishFileEditSessionRequest,
+) -> dict[str, object]:
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    host_note_id = body["hostNoteId"]
+    if not note_store.has_note(host_note_id):
+        raise HTTPException(status_code=404, detail=f"Note not found: {host_note_id}")
+    return CmdFinishFileEditSession(
+        file_id=file_id,
+        session_id=session_id,
+        host_note_id=host_note_id,
+        content_revision=body["contentRevision"],
+        is_new_diagram=body["isNewDiagram"],
+        token=token,
+        client_id=body["clientId"],
+        undo_context=body["undoContext"],
+        viewport=body["viewport"],
+    ).execute()
+
+
+@router.post("/{file_id}/edit-sessions/{session_id}/discard")
+@transactional_route
+def discard_file_edit_session_endpoint(
+    request: Request,
+    file_id: str,
+    session_id: str,
+    body: DiscardFileEditSessionRequest,
+) -> dict[str, object]:
+    token = _require_bearer_token(request)
+    _require_known_file(file_id)
+    return CmdDiscardFileEditSession(
+        file_id=file_id,
+        session_id=session_id,
+        content_revision=body["contentRevision"],
+        token=token,
+    ).execute()
+
+
+@router.post("/trim-unused", response_model=TrimUnusedFilesResponse)
+@transactional_route
+def trim_unused_files_endpoint(request: Request):
+    _require_bearer_token(request)
+    result = trim_unused_files()
+    return TrimUnusedFilesResponse(
+        deleted_count=result.deleted_count,
+        deleted_file_ids=result.deleted_file_ids,
+    )

{metalist-0.9.0 → metalist-0.11.0}/app/api/routes/notes.py

@@ -241,16 +241,16 @@ def view_diff(payload: ViewDiffRequest):
     search = payload["search"]
     tab_id = payload["tabId"]
     undo_context = payload["undoContext"]
-    client_note_uuid_hashes = payload["clientNoteUuidHashes"]
-    anchor_root_id = payload["visibleRootAnchorId"]
+    tab_view_empty = payload["tabViewEmpty"]
+    visible_top_root_id = payload["visibleTopRootId"]
+    visible_bottom_root_id = payload["visibleBottomRootId"]
     is_untagged_view = payload["isUntaggedView"]
     if not isinstance(is_untagged_view, bool):
         raise TypeError("isUntaggedView must be a boolean")
+    if not isinstance(tab_view_empty, bool):
+        raise TypeError("tabViewEmpty must be a boolean")
 
     sort_mode = _resolve_tab_sort_mode(tab_id)
-    if not isinstance(client_note_uuid_hashes, dict):
-        raise TypeError("clientNoteUuidHashes must be an object")
-
     normalized_search = search
     if isinstance(normalized_search, str) and normalized_search == "":
         normalized_search = None
@@ -278,164 +278,58 @@ def view_diff(payload: ViewDiffRequest):
         if not note_store.has_note(normalized_editing_note_id):
             normalized_editing_note_id = None
 
-    # Known hashes plus a viewport anchor so the server can extend the window
-    client_hashes = {
-        k: v for k, v in client_note_uuid_hashes.items() if k
-    }
-    # Fallback: if client didn't provide an anchor, use the last known root from cached state
-    cache_key = {
-        "client_id": client_id,
-        "tab_id": tab_id,
-        "search": normalized_search,
-        "sort_mode": sort_mode,
-        "is_untagged_view": is_untagged_view,
-    }
-    cached_state = view_cache.get(**cache_key)
-    if not anchor_root_id and cached_state and client_hashes:
-        last_roots = list(cached_state.children_by_parent.get(None, []))
-        if last_roots:
-            anchor_root_id = last_roots[-1]
+    # The server keeps each tab's warm view (what that browser tab displays),
+    # so the browser sends only where it is. A tab with no warm view, or one
+    # whose browser shows nothing for it, gets its initial window.
+    warm_view = view_cache.get(client_id=client_id, tab_id=tab_id)
+    if tab_view_empty:
+        warm_view = None
+    client_known_note_ids: set[str] = set()
+    if warm_view is not None:
+        client_known_note_ids = set(warm_view.hash_by_id)
 
     state = build_view_state(
         editing_note_id=normalized_editing_note_id,
         search=normalized_search,
         sort_mode=sort_mode,
-        client_known_note_ids=set(client_hashes.keys()),
-        client_seen_root_ids=set(),
-        anchor_root_id=anchor_root_id,
+        client_known_note_ids=client_known_note_ids,
+        visible_top_root_id=visible_top_root_id,
+        visible_bottom_root_id=visible_bottom_root_id,
         is_untagged_view=is_untagged_view,
     )
     update_uuid = get_current_sync_uuid()
     root_ids = list(state.children_by_parent.get(None, []))
-    root_count_total = state.metadata["rootCountTotal"]
-    search_root_count_total = state.metadata["searchRootCountTotal"]
-
-    client_note_ids = set(client_hashes.keys())
-    current_note_ids = set(state.hash_by_id.keys())
-    if cached_state is None:
-        cached_note_ids = set()
-    else:
-        cached_note_ids = set(cached_state.hash_by_id.keys())
-    extra_client_ids = _unknown_client_note_ids(
-        client_note_ids=client_note_ids,
-        current_note_ids=current_note_ids,
-        cached_note_ids=cached_note_ids,
-    )
-    force_full_snapshot = bool(extra_client_ids)
-    if force_full_snapshot:
-        logger.info(
-            "notes.view forcing full snapshot (client has unknown ids): extra_count=%s",
-            len(extra_client_ids),
-        )
-
-    client_has_state = bool(client_hashes)
-
-    if not cached_state or force_full_snapshot:
-        view_cache.set(state=state, **cache_key)
-        if force_full_snapshot:
-            filtered_notes = dict(state.payloads)
-        else:
-            filtered_notes = {
-                note_id: data
-                for note_id, data in state.payloads.items()
-                if client_hashes.get(note_id) != data.get("hash")
-            }
-
-        # Optimization: when the server cache is cold but the client already has a
-        # complete, matching hash map for the visible window, avoid resending the
-        # full structure + note payloads. This is common when a new tab is created
-        # by cloning the existing DOM.
-        if client_has_state and not filtered_notes and not force_full_snapshot:
-            response_snapshot = {
-                "diffOps": [],
-                "notes": {},
-                "locks": state.locks,
-                "rootIds": root_ids,
-                "lockDiffs": {},
-                "updateUUID": update_uuid,
-                "version": VERSION,
-                "currentClientId": client_id,
-                "searchQuery": search,
-                "sortMode": sort_mode,
-                "isUntaggedView": is_untagged_view,
-                "rootCountTotal": root_count_total,
-                "searchRootCountTotal": search_root_count_total,
-                "rootSortBuckets": state.metadata["rootSortBuckets"],
-                "editingNoteId": normalized_editing_note_id,
-            }
-            return {"snapshot": response_snapshot, "updateUUID": update_uuid}
-
-        response_snapshot = {
-            "structure": state.structure,
-            "notes": filtered_notes,
-            "locks": state.locks,
-            "rootIds": root_ids,
-            "updateUUID": update_uuid,
-            "version": VERSION,
-            "currentClientId": client_id,
-            "searchQuery": search,
-            "sortMode": sort_mode,
-            "isUntaggedView": is_untagged_view,
-            "rootCountTotal": root_count_total,
-            "searchRootCountTotal": search_root_count_total,
-            "rootSortBuckets": state.metadata["rootSortBuckets"],
-            "editingNoteId": normalized_editing_note_id,
-        }
-        return {"snapshot": response_snapshot, "updateUUID": update_uuid}
-
-    if not client_has_state:
-        view_cache.set(state=state, **cache_key)
-        filtered_notes = {
-            note_id: data
-            for note_id, data in state.payloads.items()
-            if client_hashes.get(note_id) != data.get("hash")
-        }
-        response_snapshot = {
-            "structure": state.structure,
-            "notes": filtered_notes,
-            "locks": state.locks,
-            "rootIds": root_ids,
-            "updateUUID": update_uuid,
-            "version": VERSION,
-            "currentClientId": client_id,
-            "searchQuery": search,
-            "sortMode": sort_mode,
-            "isUntaggedView": is_untagged_view,
-            "rootCountTotal": root_count_total,
-            "searchRootCountTotal": search_root_count_total,
-            "rootSortBuckets": state.metadata["rootSortBuckets"],
-            "editingNoteId": normalized_editing_note_id,
-        }
-        return {"snapshot": response_snapshot, "updateUUID": update_uuid}
-
-    diff_ops = generate_diff_ops(cached_state, state)
-    note_updates = {
-        note_id: payload
-        for note_id, payload in state.payloads.items()
-        if cached_state.hash_by_id.get(note_id) != payload["hash"]
-    }
-
-    view_cache.set(state=state, **cache_key)
-
-    lock_diff = _compute_lock_diff(cached_state.locks, state.locks)
-
+    view_cache.set(client_id=client_id, tab_id=tab_id, state=state)
     response_snapshot = {
-        "diffOps": diff_ops,
-        "notes": note_updates,
+        "notes": {},
         "locks": state.locks,
         "rootIds": root_ids,
-        "lockDiffs": lock_diff,
         "updateUUID": update_uuid,
         "version": VERSION,
         "currentClientId": client_id,
         "searchQuery": search,
         "sortMode": sort_mode,
         "isUntaggedView": is_untagged_view,
-        "rootCountTotal": root_count_total,
-        "searchRootCountTotal": search_root_count_total,
+        "rootCountTotal": state.metadata["rootCountTotal"],
+        "searchRootCountTotal": state.metadata["searchRootCountTotal"],
         "rootSortBuckets": state.metadata["rootSortBuckets"],
+        "rootWindowStart": state.metadata["rootWindowStart"],
+        "rootBandMargin": state.metadata["rootBandMargin"],
+        "rootSortKeyBeforeWindow": state.metadata["rootSortKeyBeforeWindow"],
         "editingNoteId": normalized_editing_note_id,
     }
+    if warm_view is None:
+        response_snapshot["structure"] = state.structure
+        response_snapshot["notes"] = dict(state.payloads)
+        return {"snapshot": response_snapshot, "updateUUID": update_uuid}
+
+    response_snapshot["diffOps"] = generate_diff_ops(warm_view, state)
+    response_snapshot["notes"] = {
+        note_id: note_payload
+        for note_id, note_payload in state.payloads.items()
+        if note_id not in warm_view.hash_by_id or warm_view.hash_by_id[note_id] != note_payload["hash"]
+    }
+    response_snapshot["lockDiffs"] = _compute_lock_diff(warm_view.locks, state.locks)
     return {"snapshot": response_snapshot, "updateUUID": update_uuid}
 
 
@@ -501,6 +395,11 @@ def create_new_tab(payload: CreateNewTabRequest) -> Dict[str, object]:
         response = tab_state_store.create_tab(copy_from_tab_id=copy_from_tab_id)
     if capture.captured_exception is not None:
         raise HTTPException(status_code=400, detail="Invalid or stale tab state") from capture.captured_exception
+    # The browser clones the source tab's DOM into the new tab, so the new tab
+    # starts from the source tab's warm view.
+    view_cache.copy_tab(
+        client_id=payload["clientId"], source_tab_id=copy_from_tab_id, target_tab_id=response["newTabId"],
+    )
     return response
 
 
@@ -790,16 +689,6 @@ def _compute_lock_diff(previous: Dict[str, str], current: Dict[str, str]) -> Dic
     return diff
 
 
-def _unknown_client_note_ids(
-    *,
-    client_note_ids: set[str],
-    current_note_ids: set[str],
-    cached_note_ids: set[str],
-) -> set[str]:
-    stale_deleted_ids = client_note_ids - current_note_ids
-    return stale_deleted_ids - cached_note_ids
-
-
 # Stub endpoints for the rest of the notes API (501 Not Implemented)
 
 def _not_impl(exc: Exception) -> None:

{metalist-0.9.0 → metalist-0.11.0}/app/api/routes/ontology.py

@@ -11,7 +11,6 @@ from app.api.transactions import transactional_route
 from app.services.search_index import search_index
 from app.services.note_store import store as note_store
 from app.services.sync import generate_new_uuid
-from app.services.view_cache import view_cache
 from app.services.tag_ontology import RegexAtom, TagAtom, TextAtom, parse_rules_text
 from app.services.ontology_rules_store import (
     build_direct_edge_rule_map,
@@ -155,7 +154,6 @@ def create_rule(request: Request, payload: RuleTextRequest) -> dict:
     rule_id, normalized = create_rule_line(text=text, token=token)
     if note_store.loaded:
         note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
-        view_cache.clear()
         update_uuid = generate_new_uuid()
         return {"id": rule_id, "text": normalized, "updateUUID": update_uuid}
     return {"id": rule_id, "text": normalized}
@@ -193,7 +191,6 @@ def update_rule(request: Request, rule_id: int, payload: RuleTextRequest) -> dic
     updated_id, normalized = update_rule_line(rule_id=rule_id, text=text, token=token)
     if note_store.loaded:
         note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
-        view_cache.clear()
         update_uuid = generate_new_uuid()
         return {"id": updated_id, "text": normalized, "updateUUID": update_uuid}
     return {"id": updated_id, "text": normalized}
@@ -224,7 +221,6 @@ def delete_rule(rule_id: int) -> dict:
     delete_rule_line(rule_id=rule_id)
     if note_store.loaded:
         note_store.rebuild_search_index_tag_terms_for_notes(candidate_note_ids)
-        view_cache.clear()
         update_uuid = generate_new_uuid()
         return {"ok": True, "updateUUID": update_uuid}
     return {"ok": True}