python-codex 0.3.2__py3-none-any.whl → 0.3.3__py3-none-any.whl

{python_codex-0.3.2.dist-info → python_codex-0.3.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-codex
-Version: 0.3.2
+Version: 0.3.3
 Summary: A minimal Python extraction of Codex's main agent loop
 License-File: LICENSE
 Requires-Python: >=3.6.2
@@ -25,6 +25,8 @@ Description-Content-Type: text/markdown
 
 English README. Chinese version: `README_ZH.md`
 
+0.3.3 workspace viewers and reasoning stream fix: [release notes](docs/RELEASE_0.3.3.md).
+
 0.3.2 startup fixes: [release notes](docs/RELEASE_0.3.2.md).
 
 0.3.0 release preparation and Python API migration: `docs/RELEASE_0.3.0.md`.
@@ -264,6 +266,45 @@ Current behavior:
 - with an argv prompt or piped stdin, run a single turn
 - `pycodex-ws` starts the standalone browser workspace manager and serves each
   workspace with a board pane and a pycodex session pane
+- the left pane is the board, containing a live HTML Canvas tab and closable read-only file/diff tabs that
+  scroll together in one toolbar; a mouse wheel scrolls overflowing tab strips
+  horizontally.
+  Click Markdown file links such as `[source](src/app.py:42)` or
+  `[source](/data/project/app.py#L42)` to open a view. Git-style diff links use
+  `[changes](diff:HEAD:src/app.py)` for working changes,
+  `[versions](diff:HEAD~1..HEAD:src/app.py)` for two revisions, and
+  `[files](diff:old.py..new.py)` for two local files. Append `#L42` or `#R42`
+  to a diff link to select a 1-based line on the left or right.
+  Views open when the user clicks; model replies alone do not create tabs.
+  Reopening the same file or comparison selects its existing tab in that
+  browser, including when the line changes. Other pages keep their selection.
+  Tabs show filenames first, adding a short directory suffix
+  for duplicate names. Git versions use short commit IDs in a secondary label.
+  Long labels use the same width limit as session tabs, shortening the secondary
+  information before the filename;
+  hover titles retain the complete paths and revisions. Text,
+  Markdown, HTML, common raster images and text diffs are supported. Monaco
+  provides syntax highlighting, find, folding and character-level diffs.
+  Its code and styles load only when a code or diff view opens, so Canvas,
+  Markdown and HTML previews do not load the editor. Viewer assets use gzip
+  when supported and revalidate cached content with ETags.
+  Narrow content panes automatically use a unified diff; targeting the left
+  side keeps both sides visible. Markdown and HTML links default to previews;
+  line targets open their source. Clicking a link without a line returns that
+  same tab to preview. Manual tab switches preserve the chosen mode and reading state.
+  All views remain
+  read-only, with text selection and copying available. Local files update
+  automatically, including both sides of file diffs and the working side of
+  Git diffs; Git revisions stay fixed. Updates keep the active editor and
+  reading state without replaying an earlier line request.
+  Canvas is for explanations and custom visuals; source and diffs use links.
+  `[Canvas](workspace://canvas)` returns to the live page; an HTML file link opens
+  a preview tab, and `page.html:1` opens its source. File links work even with an empty `--toolset`.
+  Canvas and HTML previews share the same origin and script permissions;
+  the browser loads their resources with the workspace login cookie.
+  Open views survive reloads and server restarts. See
+  [workspace content views](docs/RUNTIME.md#workspace-content-views) for the
+  complete syntax and limits.
 - interactive mode exits through `/exit`, `/quit`, Ctrl+D on an empty prompt,
   or a single Ctrl+C; accepted work finishes before cleanup and normal exit.
   A `[closing]` message explains the wait. Press Ctrl+C again while closing
@@ -366,7 +407,7 @@ Current behavior:
   time when it expires.
 - while a background command or clock is pending, the idle status is
   `idle: sleeping`
-- only the active workspace tab shows its close button; closing it restores
+- only the active workspace session tab shows its close button; closing it restores
   the selected tab's conversation, draft, and scroll position immediately
   after its snapshot loads
 - `--vllm-endpoint http://host:port` automatically launches a local
@@ -387,6 +428,10 @@ Current behavior:
   reasoning, retries the same downstream request once, and only then emits
   `response.failed` with `type = "model_output_invalid"` if the retry is still
   reasoning-only
+- compat reasoning fragments are forwarded immediately as
+  `response.reasoning_text.delta`, including thinking from `/v1/messages`.
+  Continuous reasoning keeps the client's read idle timeout from expiring
+  while it waits for assistant text; only finalized reasoning items enter history
 - malformed JSON in ordinary downstream function-call arguments is detected by
   `responses_server` and returned as `response.failed` with `type = "server_error"`;
   the client's existing `stream_max_retries` policy retries the current request

{python_codex-0.3.2.dist-info → python_codex-0.3.3.dist-info}/RECORD

@@ -73,20 +73,26 @@ responses_server/messages_api.py,sha256=ialAYTMmN0y-uxQB3Y51ukq-kvkSVO84WVLXaqLs
 responses_server/payload_processors.py,sha256=dqPwqHD-FhyiIwjzFEMf2wCtQDxkRyerZzbdqnH1aDE,3561
 responses_server/server.py,sha256=k4DbsOYkaHHcy38uF9u_QXahJC1cplKsTu-MdC3DCIs,2286
 responses_server/session_store.py,sha256=nwGxQL6nUVKnDVeDHz8IzqNQ7dWk8Ybf0URekOHdxTo,1133
-responses_server/stream_router.py,sha256=Bwuz_a_eEys7OuuN5qgtCIQF0mIo7DWDNojLI5mNetE,46062
+responses_server/stream_router.py,sha256=TQX2-8uOGad3TBJnRu9SOtDaHBHjYwE-WERYz6rcuo8,46274
 responses_server/trajectory_dump.py,sha256=5_Wy6tslszrqx3j1JeP_boyTbzIicKy8No84PzMnmHk,5111
 responses_server/tools/__init__.py,sha256=ivsBSEy0SBUhY-Uea5v1XMLXShkwHdCVl0id-1FwdZg,150
 responses_server/tools/custom_adapter.py,sha256=SnIiNUdomff3APtTriURAC9YCeEdhCDjzGMEYusfUdk,8340
 responses_server/tools/web_search.py,sha256=pnKH9JyTScRehWpZS3HpXRvjWsQvC0QZqxjEOCT4ndg,8936
 workspace_server/__init__.py,sha256=PRM4ONODb6hxjBUHkBD4TprE_pkTCIlT9sfftK5ic6M,866
 workspace_server/__main__.py,sha256=876xZTqhPeDBD2GKKr8pKX33Af8PhFTosAI8bYQsFgQ,61
-workspace_server/app.py,sha256=oYvUFxTGurXN0PDP_opUePyW_tBE3SauiSma_U4cc9c,59260
+workspace_server/app.py,sha256=aoo5vq5AciEHe3r5gcgt2B349uuWLY6fbFYbOQ2CRAE,67164
+workspace_server/content_views.LICENSE.txt,sha256=PUOceZvrZI9c2LeLVh6wJNv5wwALKoJ8jOOfq-05WmQ,64183
+workspace_server/content_views.css,sha256=n1yPrOZbzNS0phv2JGwaYbK8t81MI2kKe9rc3sY2TRI,1662
+workspace_server/content_views.mjs,sha256=8sbYqAgwYrAE9SMd3bO6jv6DlHwWru1gboID8h2oTLE,16241
+workspace_server/editor.css,sha256=4qBe2ZLqloAFQ2YNyJYvsJelvTHIIQCxpfg4EVTubk8,346450
+workspace_server/editor.mjs,sha256=oZpBsmnA56VIogpbg_NDg8cs4bIQZkuUCtXPJnVLook,4110455
 workspace_server/owned_process.py,sha256=j1cJ89Nm7gS91Zj62kYKabFbb9qhbU7-q1YDsWcVcn8,895
-workspace_server/workspace.html,sha256=CXrMdUVM9eB03nCVwvC5coc6tMsmplOOx8wLBrJc9cw,71625
-workspace_server/workspaces.html,sha256=TpmfzpuCIXTVdFQzQrojxSCtBTHMSESn1zNGOmNz_W8,15787
-workspace_server/workspaces.py,sha256=cyyDBMo0UVqMvCjeAEHNwZCHQzRRsyn7bbYIb0INOo0,22371
-python_codex-0.3.2.dist-info/METADATA,sha256=PClQOhAVKTGw8gaoYjP_G2pfp6j5QEZQS8uHPccymqg,39624
-python_codex-0.3.2.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
-python_codex-0.3.2.dist-info/entry_points.txt,sha256=vkV2UWCtEKvQNMJuPNjt8HyBKiwp83JyqBatrBNGDp8,80
-python_codex-0.3.2.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
-python_codex-0.3.2.dist-info/RECORD,,
+workspace_server/workspace.html,sha256=r1cBihjnyt8cxjI9xGqTVBs3zboMcoYHemgvwNMpN2A,74728
+workspace_server/workspace_views.py,sha256=acV-SS3Uw-Qy5AI_KV16AowB1R3cbJN4Okk6CDbpPzw,22172
+workspace_server/workspaces.html,sha256=72WEextEEUZeAYCmZ5UcWbg1m7voFezxgL6j48koRuU,15794
+workspace_server/workspaces.py,sha256=hMvGyZtuFshGV3l56AMhGJN0vDOvvVj8iv9-VAJJHhw,22524
+python_codex-0.3.3.dist-info/METADATA,sha256=ucgUraJ7rlCeUstF-FlAE8qiURNuqF-qOw6xKMbYF7M,42715
+python_codex-0.3.3.dist-info/WHEEL,sha256=KGYbc1zXlYddvwxnNty23BeaKzh7YuoSIvIMO4jEhvw,87
+python_codex-0.3.3.dist-info/entry_points.txt,sha256=vkV2UWCtEKvQNMJuPNjt8HyBKiwp83JyqBatrBNGDp8,80
+python_codex-0.3.3.dist-info/licenses/LICENSE,sha256=0X8ifk312hYAORM4hlzg8wVSEXYKNmiPgWlB1YIy2Nw,10926
+python_codex-0.3.3.dist-info/RECORD,,

responses_server/stream_router.py

@@ -894,19 +894,23 @@ class StreamRouter:
 
             reasoning = delta.get("reasoning")
             reasoning_content = delta.get("reasoning_content")
-            if (
-                isinstance(reasoning, str)
-                and reasoning
-                and isinstance(reasoning_content, str)
-                and reasoning == reasoning_content
-            ):
-                # Some chat providers expose the same delta under both aliases.
-                reasoning_parts.append(reasoning)
-            else:
-                if isinstance(reasoning, str) and reasoning:
-                    reasoning_parts.append(reasoning)
-                if isinstance(reasoning_content, str) and reasoning_content:
-                    reasoning_parts.append(reasoning_content)
+            reasoning_deltas = [reasoning]
+            # Some chat providers expose the same delta under both aliases.
+            if reasoning_content != reasoning:
+                reasoning_deltas.append(reasoning_content)
+            for reasoning_delta in reasoning_deltas:
+                if isinstance(reasoning_delta, str) and reasoning_delta:
+                    reasoning_parts.append(reasoning_delta)
+                    events.append(
+                        (
+                            "response.reasoning_text.delta",
+                            {
+                                "type": "response.reasoning_text.delta",
+                                "content_index": 0,
+                                "delta": reasoning_delta,
+                            },
+                        )
+                    )
 
             content = delta.get("content")
             if isinstance(content, str) and content:

workspace_server/app.py

@@ -1,10 +1,13 @@
 import argparse
 import asyncio
+import gzip
+import hashlib
 import html
 import json
 import mimetypes
 import os
 import secrets
+import subprocess
 import sys
 import threading
 from dataclasses import asdict, fields, is_dataclass
@@ -63,6 +66,7 @@ from pycodex.utils.event_helpers import (
     shorten_title,
 )
 
+from .workspace_views import WorkspaceViewOpener, WorkspaceViewStore
 from .workspaces import (
     WorkspaceDefinition,
     WorkspaceEntry,
@@ -122,7 +126,7 @@ def build_parser() -> "argparse.ArgumentParser":
         "--toolset",
         nargs="*",
         default=None,
-        help="Builtin tool names for all sessions; an empty list disables tools.",
+        help="Builtin tool names for all sessions. An empty list disables all tools.",
     )
     parser.add_argument(
         "--timeout-seconds",
@@ -815,6 +819,7 @@ def create_app(
     session_source: "typing.Union[WorkspaceSessionManager, SessionFactory]",
     board_path: "typing.Union[Path, None]",
     password: "typing.Union[str, None]" = None,
+    work_dir: "typing.Union[Path, None]" = None,
 ) -> FastAPI:
     manager = (
         session_source
@@ -823,7 +828,7 @@ def create_app(
     )
     app = _create_lifespan_app(manager.start, manager.close)
     auth_token = _install_auth(app, password)
-    _install_workspace_routes(app, manager, board_path)
+    _install_workspace_routes(app, manager, board_path, Path(work_dir or Path.cwd()).resolve())
     app.state.workspace_auth_token = auth_token
     return app
 
@@ -834,6 +839,7 @@ def create_multi_workspace_app(
 ) -> FastAPI:
     app = _create_lifespan_app(registry.start, registry.close)
     auth_token = _install_auth(app, password)
+    view_asset_cache = {}
 
     @app.get("/")
     async def index() -> Response:
@@ -899,6 +905,45 @@ def create_multi_workspace_app(
         entry = _workspace_entry_or_404(registry, workspace_id)
         return _board_status_response(entry.definition.board_path)
 
+    @app.get("/w/{workspace_id}/api/views")
+    def workspace_views(workspace_id: str) -> JSONResponse:
+        entry = _workspace_entry_or_404(registry, workspace_id)
+        return _views_response(entry.manager)
+
+    @app.post("/w/{workspace_id}/api/views/open")
+    def workspace_open_view(
+        workspace_id: str, payload: "typing.Dict[str, object]"
+    ) -> JSONResponse:
+        entry = _workspace_entry_or_404(registry, workspace_id)
+        return _open_view_response(entry.manager, entry.definition.work_dir, payload)
+
+    @app.get("/w/{workspace_id}/api/views/{view_id}")
+    def workspace_view(workspace_id: str, view_id: str) -> JSONResponse:
+        entry = _workspace_entry_or_404(registry, workspace_id)
+        return _view_response(entry.manager, view_id)
+
+    @app.delete("/w/{workspace_id}/api/views/{view_id}")
+    def workspace_close_view(workspace_id: str, view_id: str) -> JSONResponse:
+        entry = _workspace_entry_or_404(registry, workspace_id)
+        return _close_view_response(entry.manager, view_id)
+
+    @app.api_route(
+        "/w/{workspace_id}/assets/content_views.mjs", methods=["GET", "HEAD"]
+    )
+    @app.api_route(
+        "/w/{workspace_id}/assets/content_views.css", methods=["GET", "HEAD"]
+    )
+    @app.api_route(
+        "/w/{workspace_id}/assets/content_views.LICENSE.txt", methods=["GET", "HEAD"]
+    )
+    @app.api_route("/w/{workspace_id}/assets/editor.mjs", methods=["GET", "HEAD"])
+    @app.api_route("/w/{workspace_id}/assets/editor.css", methods=["GET", "HEAD"])
+    def workspace_view_asset(workspace_id: str, request: Request) -> Response:
+        _workspace_entry_or_404(registry, workspace_id)
+        return _view_asset_response(
+            request.url.path.rsplit("/", 1)[-1], request, view_asset_cache
+        )
+
     @app.get("/w/{workspace_id}/ws/session")
     async def workspace_websocket_backend_hint(workspace_id: str) -> JSONResponse:
         _workspace_entry_or_404(registry, workspace_id)
@@ -1139,10 +1184,13 @@ def _install_workspace_routes(
     app: FastAPI,
     manager: WorkspaceSessionManager,
     board_path: "typing.Union[Path, None]",
+    work_dir: Path,
 ) -> None:
+    view_asset_cache = {}
+
     @app.get("/")
     async def index() -> HTMLResponse:
-        return _html_response(_render_workspace_shell(board_path))
+        return _html_response(_render_workspace_shell(board_path, work_dir=work_dir))
 
     @app.get("/favicon.ico")
     async def favicon() -> Response:
@@ -1156,6 +1204,32 @@ def _install_workspace_routes(
     async def board_status() -> JSONResponse:
         return _board_status_response(board_path)
 
+    @app.get("/api/views")
+    def views() -> JSONResponse:
+        return _views_response(manager)
+
+    @app.post("/api/views/open")
+    def open_view(payload: "typing.Dict[str, object]") -> JSONResponse:
+        return _open_view_response(manager, work_dir, payload)
+
+    @app.get("/api/views/{view_id}")
+    def view(view_id: str) -> JSONResponse:
+        return _view_response(manager, view_id)
+
+    @app.delete("/api/views/{view_id}")
+    def close_view(view_id: str) -> JSONResponse:
+        return _close_view_response(manager, view_id)
+
+    @app.api_route("/assets/content_views.mjs", methods=["GET", "HEAD"])
+    @app.api_route("/assets/content_views.css", methods=["GET", "HEAD"])
+    @app.api_route("/assets/content_views.LICENSE.txt", methods=["GET", "HEAD"])
+    @app.api_route("/assets/editor.mjs", methods=["GET", "HEAD"])
+    @app.api_route("/assets/editor.css", methods=["GET", "HEAD"])
+    def view_asset(request: Request) -> Response:
+        return _view_asset_response(
+            request.url.path.rsplit("/", 1)[-1], request, view_asset_cache
+        )
+
     @app.get("/ws/session")
     async def websocket_backend_hint() -> JSONResponse:
         return _websocket_backend_hint_response()
@@ -1199,6 +1273,117 @@ def _install_workspace_routes(
         return _board_asset_response(board_path, asset_path)
 
 
+def _views_response(manager: WorkspaceSessionManager) -> JSONResponse:
+    try:
+        views = manager.views.list_views()
+    except (OSError, ValueError) as error:
+        raise HTTPException(status_code=400, detail=str(error))
+    return JSONResponse({"views": views}, headers={"Cache-Control": "no-store"})
+
+
+def _open_view_response(
+    manager: WorkspaceSessionManager, work_dir: Path, payload: "typing.Dict[str, object]"
+) -> JSONResponse:
+    try:
+        view = WorkspaceViewOpener(manager.views, work_dir).open(payload.get("href"))
+        views = manager.views.list_views()
+    except (OSError, ValueError, subprocess.TimeoutExpired) as error:
+        raise HTTPException(status_code=400, detail=str(error))
+    return JSONResponse(
+        {"view": view, "views": views}, headers={"Cache-Control": "no-store"}
+    )
+
+
+def _view_response(manager: WorkspaceSessionManager, view_id: str) -> JSONResponse:
+    try:
+        view = manager.views.get(view_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="view not found")
+    except (OSError, ValueError) as error:
+        raise HTTPException(status_code=400, detail=str(error))
+    return JSONResponse(view, headers={"Cache-Control": "no-store"})
+
+
+def _close_view_response(
+    manager: WorkspaceSessionManager, view_id: str
+) -> JSONResponse:
+    try:
+        manager.views.close(view_id)
+    except KeyError:
+        raise HTTPException(status_code=404, detail="view not found")
+    return JSONResponse({"ok": True})
+
+
+def _view_asset_encoding(accept_encoding: str) -> str:
+    qualities = {}
+    for entry in accept_encoding.lower().split(","):
+        name, *parameters = entry.strip().split(";")
+        quality = 1.0
+        for parameter in parameters:
+            key, _, value = parameter.strip().partition("=")
+            if key != "q":
+                continue
+            try:
+                quality = float(value)
+            except ValueError as exc:
+                raise HTTPException(
+                    status_code=400, detail="invalid encoding quality"
+                ) from exc
+            if not 0 <= quality <= 1:
+                raise HTTPException(status_code=400, detail="invalid encoding quality")
+        qualities[name.strip()] = quality
+    gzip_quality = qualities.get("gzip", qualities.get("*", 0))
+    if gzip_quality > 0 and gzip_quality >= qualities.get("identity", 0):
+        return "gzip"
+    if qualities.get("identity", 0 if qualities.get("*") == 0 else 1) > 0:
+        return "identity"
+    raise HTTPException(status_code=406, detail="no acceptable asset encoding")
+
+
+def _view_asset_response(asset_name: str, request: Request, cache: dict) -> Response:
+    media_types = {
+        "content_views.mjs": "text/javascript",
+        "content_views.css": "text/css",
+        "content_views.LICENSE.txt": "text/plain",
+        "editor.mjs": "text/javascript",
+        "editor.css": "text/css",
+    }
+    if asset_name not in media_types:
+        raise HTTPException(status_code=404, detail="asset not found")
+    encoding = _view_asset_encoding(request.headers.get("accept-encoding", ""))
+    path = Path(__file__).with_name(asset_name)
+    stat = path.stat()
+    stamp = (stat.st_mtime_ns, stat.st_size)
+    key = (asset_name, encoding)
+    cached = cache.get(key)
+    if cached is None or cached[0] != stamp:
+        body = path.read_bytes()
+        if encoding == "gzip":
+            body = gzip.compress(body, compresslevel=6)
+        etag = '"' + hashlib.sha256(body).hexdigest() + '"'
+        cached = cache[key] = (stamp, body, etag)
+    _, body, etag = cached
+    headers = {
+        "Cache-Control": "no-cache",
+        "X-Content-Type-Options": "nosniff",
+        "Vary": "Accept-Encoding",
+        "ETag": etag,
+    }
+    if encoding == "gzip":
+        headers["Content-Encoding"] = "gzip"
+    for candidate in request.headers.get("if-none-match", "").split(","):
+        candidate = candidate.strip()
+        if candidate.startswith("W/"):
+            candidate = candidate[2:]
+        if candidate in ("*", etag):
+            return Response(status_code=304, headers=headers)
+    headers["Content-Length"] = str(len(body))
+    return Response(
+        b"" if request.method == "HEAD" else body,
+        media_type=media_types[asset_name], headers=headers,
+    )
+
+
 def _board_status_response(board_path: "typing.Union[Path, None]") -> JSONResponse:
     if board_path is None or not board_path.is_file():
         return JSONResponse({"exists": False})
@@ -1560,6 +1745,8 @@ def _build_workspace_entry(
     args: "argparse.Namespace",
     persist_callback: "typing.Union[typing.Callable[[], None], None]" = None,
 ) -> "WorkspaceEntry":
+    views = WorkspaceViewStore(definition.board_path)
+
     def build_session() -> "WorkspaceInteractiveSession":
         model = build_model(
             config_path=args.config,
@@ -1575,7 +1762,7 @@ def _build_workspace_entry(
             profile=args.profile,
             system_prompt=args.system_prompt,
             extra_contextual_user_messages=(
-                [_board_context_text(definition.board_path, definition.work_dir)]
+                [_workspace_context_text(definition.board_path, definition.work_dir)]
                 if definition.board_path is not None
                 else []
             ),
@@ -1598,18 +1785,24 @@ def _build_workspace_entry(
             session_factory,
             definition.board_path,
             persist_callback=persist_callback,
+            views=views,
         ),
     )
 
 
-def _board_context_text(
+def _workspace_context_text(
     board_path: Path,
-    work_dir: "typing.Union[Path, None]" = None,
+    work_dir: "typing.Union[Path, None]",
 ) -> str:
     return (
-        "Current workspace board file: {0}. "
-        "Changes you make to this file are shown to the user in real time. "
-        "You can create or modify this file anytime."
+        "Current workspace Canvas file: {0}. "
+        "Changes you make to this HTML file are shown to the user in real time. "
+        "You can create or modify this file anytime.\n\n"
+        "Replies and Canvas HTML can use extended links to open files and diffs "
+        "in the board: git:REV:path, diff:REV:path, diff:BASE..HEAD:path, "
+        "and diff:left..right. Append #L42 to select a file or left-side line, "
+        "or #R42 for the right side of a diff. "
+        "Use workspace://canvas to return to the live Canvas."
     ).format(_format_board_path_for_prompt(board_path, work_dir=work_dir))
 
 
@@ -1662,7 +1855,7 @@ def _render_empty_board() -> str:
 
 def _render_missing_board(board_path: Path) -> str:
     return _render_board_placeholder(
-        "Board pending",
+        "Canvas pending",
         "Your work will appear here",
         "Ask pycodex to create a page, a report, or a visual. "
         "This canvas updates as you work.",