From 6da1d3af2dfc41db25277e0bcf7495eba7dfe8bd Mon Sep 17 00:00:00 2001
From: Eotel <49769982+Eotel@users.noreply.github.com>
Date: Sun, 25 Oct 2026 13:31:13 +0900
Subject: [PATCH] feat: add room home and caption reset
Add home-based registration and reconnection, isolated room captions and AI
context, and confirmation for reset and leaving unsaved work. Keep settings
across restarts, store private editing links with 0600 permissions, and reject
stale tabs and retired utterance replays. Preserve hidden state on reconnect
and start only the configured input.
Integrate with main at de2898a. Retain the current AI model selection,
contextual correction and inspector controls. Apply the cancellation fix
submitted in statelyai/xstate#5823 during locked dependency installation.
Validation: bash scripts/check.sh passes (141 frontend tests, 194 backend
tests, generated API agreement, type checks and build). A clean npm ci applies
the dependency patch and passes its StrictMode regression. Real browser tests
use a dedicated local API and synthetic captions for registration, reconnect,
reset/cancel, stale saves, restart persistence, and desktop/mobile layouts.
The UI review was an independent pass in the same conversation because separate
sessions are unavailable. Final disposition: ship. Usage docs and screenshots
are updated; the completed temporary implementation plan is removed.
No live UD Talk, microphone or LLM connection was used for this change.
The upstream fix passes its workspace tests and remote checks. Upstream GitHub
permissions prevent assigning its PR to Eotel. No implementation work remains
on this isolated branch; integration into the active checkout is separate.
---
.env.example | 1 +
.../surfaces/frontend-src-views-home-tsx.md | 28 +
.impeccable/surfaces/operator.md | 2 +-
ARCHITECTURE.md | 9 +-
PRODUCT.md | 2 +-
README.md | 8 +-
backend/app/connections.py | 18 +-
backend/app/main.py | 174 ++-
backend/app/relay.py | 11 +
backend/app/room_models.py | 65 +
backend/app/room_scope.py | 19 +
backend/app/room_store.py | 66 +
backend/app/rooms.py | 188 +++
backend/app/workflow.py | 10 +
backend/tests/test_connection_lifecycle.py | 19 +
backend/tests/test_rooms.py | 216 +++
docs/assets/manual/00-home.jpg | Bin 0 -> 32310 bytes
docs/assets/manual/00-reset.jpg | Bin 0 -> 66680 bytes
docs/assets/manual/00-room-settings.jpg | Bin 0 -> 57367 bytes
docs/current-behavior.md | 17 +-
docs/development.md | 11 +-
docs/frontend-architecture.md | 6 +-
docs/generated/openapi.json | 1260 ++++++++++++++++-
docs/index.md | 2 +
docs/manual.md | 18 +-
docs/rooms.md | 44 +
frontend/package-lock.json | 735 +++++++++-
frontend/package.json | 6 +-
frontend/patches/README.md | 7 +
frontend/patches/xstate+5.33.2.patch | 88 ++
frontend/src/adapters/microphone.ts | 8 +-
frontend/src/adapters/operator-keyboard.ts | 1 +
frontend/src/adapters/rooms.ts | 35 +
frontend/src/api.ts | 110 +-
.../src/components/ui/confirmation-dialog.tsx | 27 +
frontend/src/components/ui/form.tsx | 9 +
frontend/src/domain.ts | 31 +-
frontend/src/generated/api.d.ts | 583 +++++++-
frontend/src/machines/home.ts | 96 ++
frontend/src/machines/room.ts | 38 +
frontend/src/main.tsx | 7 +-
frontend/src/presenters/home.ts | 35 +
frontend/src/presenters/operator.ts | 4 +-
frontend/src/presenters/room.ts | 32 +
frontend/src/rooms.css | 54 +
frontend/src/rooms.test.tsx | 186 +++
frontend/src/roots.test.tsx | 1 +
frontend/src/roots.tsx | 63 +-
frontend/src/views/home.tsx | 78 +
frontend/src/views/operator/toolbar.tsx | 2 +-
frontend/src/views/room.tsx | 20 +
frontend/vite.config.ts | 6 +-
52 files changed, 4257 insertions(+), 199 deletions(-)
create mode 100644 .impeccable/surfaces/frontend-src-views-home-tsx.md
create mode 100644 backend/app/room_models.py
create mode 100644 backend/app/room_scope.py
create mode 100644 backend/app/room_store.py
create mode 100644 backend/app/rooms.py
create mode 100644 backend/tests/test_rooms.py
create mode 100644 docs/assets/manual/00-home.jpg
create mode 100644 docs/assets/manual/00-reset.jpg
create mode 100644 docs/assets/manual/00-room-settings.jpg
create mode 100644 docs/rooms.md
create mode 100644 frontend/patches/README.md
create mode 100644 frontend/patches/xstate+5.33.2.patch
create mode 100644 frontend/src/adapters/rooms.ts
create mode 100644 frontend/src/components/ui/confirmation-dialog.tsx
create mode 100644 frontend/src/components/ui/form.tsx
create mode 100644 frontend/src/machines/home.ts
create mode 100644 frontend/src/machines/room.ts
create mode 100644 frontend/src/presenters/home.ts
create mode 100644 frontend/src/presenters/room.ts
create mode 100644 frontend/src/rooms.css
create mode 100644 frontend/src/rooms.test.tsx
create mode 100644 frontend/src/views/home.tsx
create mode 100644 frontend/src/views/room.tsx
diff --git a/.env.example b/.env.example
index 0f06620..c81fd39 100644
--- a/.env.example
+++ b/.env.example
@@ -10,4 +10,5 @@ CAPTION_RELAY_STT_USAGE_PATH=
CAPTION_RELAY_AI_TIMEOUT_SECONDS=15
# Optional absolute path; empty/unset uses the user's data directory.
CAPTION_RELAY_DICTIONARY_PATH=
+CAPTION_RELAY_ROOMS_PATH=
CAPTION_RELAY_UDTALK_URL=
diff --git a/.impeccable/surfaces/frontend-src-views-home-tsx.md b/.impeccable/surfaces/frontend-src-views-home-tsx.md
new file mode 100644
index 0000000..2230117
--- /dev/null
+++ b/.impeccable/surfaces/frontend-src-views-home-tsx.md
@@ -0,0 +1,28 @@
+---
+version: 1
+slug: "frontend-src-views-home-tsx"
+primary_target: "frontend/src/views/home.tsx"
+related_targets: ["frontend/src/views/room.tsx"]
+---
+
+# ホームとルームの操作
+
+Mode: Operate
+
+## Direction contract
+
+THESIS: 運用者が以前使ったルームへ戻り、新しいルームを登録し、次のトークのために字幕だけを消せるようにする。
+
+OWN-WORLD: 既存の白い作業面、灰色の細い区切り、黒い主操作、青いフォーカス、Lucideの線画を引き継ぐ。余白は8・16・24・32pxを基準にし、ホームの本文は16px、行間24pxとする。削除を確定するボタンは白文字と暗い赤で区別する。
+
+STORY: ホームで名前と最終利用日時からルームを選ぶ。追加時は名前・配信先・必要な参加リンクを入れる。接続後は字幕の確認と訂正に集中し、リセットと離脱は対象と下書きの有無を確かめる。
+
+FIRST VIEWPORT: 上部にCaption Relayと新しいルームへの接続。下は区切り線のある一列のルーム一覧。各行の左に名前と接続方法・最終利用日時、右に接続設定と接続を置く。狭い画面では操作を次の行の右へ回す。ルーム画面は既存の操作画面の上に名前、ホーム、リセットを置く。
+
+FORM: 既存のOperate画面の拡張。新しい世界や構成案の選択は行わず、受け入れ済みのホーム・ルーム操作を既存の部品と配色で実装する。
+
+FINISH: unreviewed and undocumented is unfinished; this build ends with the finish review, the verdict, DESIGN.md, and every shipping raster carrying its provenance
+
+## Constraints
+
+同時に入力するのは一つのルーム。字幕と背景を混ぜない。参加リンクは履歴のAPI応答へ返さない。リセットは確認後にCaption Relayの字幕と下書きだけを消し、UDトークの字幕とルーム設定を残す。Rootは一つとし、Viewは通知、Mediatorは判断、Adapterは通信を担当する。
diff --git a/.impeccable/surfaces/operator.md b/.impeccable/surfaces/operator.md
index d5d0c7f..4e3f327 100644
--- a/.impeccable/surfaces/operator.md
+++ b/.impeccable/surfaces/operator.md
@@ -18,6 +18,6 @@ FINISH: unreviewed and undocumented is unfinished; this build ends with the fini
## Constraints
-人の修正は明示的に保存する。外部AIへの接続は後の段階に行い、今回は選択・振り分けと結果の受け取りまで。画面はRoot配下のPassive Viewとし、操作をChain経由で状態機械のMediatorへ渡す。認証・永続化・会場実機の試験は現行PoCの対象外。
+人の修正は明示的に保存する。外部AIへの接続は後の段階に行い、今回は選択・振り分けと結果の受け取りまで。画面はRoot配下のPassive Viewとし、操作をChain経由で状態機械のMediatorへ渡す。認証・字幕の永続化・会場実機の試験は現行PoCの対象外。ルームの設定は保存する。
INTERACTION: 右ペインの境界は24pxの操作領域でドラッグでき、右端で収納する。幅と未保存入力を保持して再表示し、キーボードでも操作できる。
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 3723d55..cf2bc68 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -1,6 +1,6 @@
# システム構成
-実装確認日：2026-10-11
+実装確認日：2026-10-25
Caption Relay は、単一の FastAPI プロセスが字幕の状態を持つローカル PoC。React の操作画面は HTTP で取得・更新し、観客画面は SSE で公開字幕を受け取る。現在の振る舞いは[現行 PoC の仕様](docs/current-behavior.md)、起動方法は[開発手順](docs/development.md)を参照する。
@@ -9,6 +9,7 @@ Caption Relay は、単一の FastAPI プロセスが字幕の状態を持つロ
| 場所 | 責務 |
|---|---|
| [backend/app/main.py](backend/app/main.py) | HTTP ルート、エラー応答、SSE、ビルド済み画面の配信 |
+| [backend/app/rooms.py](backend/app/rooms.py)・[room_store.py](backend/app/room_store.py) | 一つの入力接続とルームごとのWorkflow、設定の保存・復元、リセットと古い操作の拒否 |
| [backend/app/relay.py](backend/app/relay.py) | セッション状態、入力の改版・再送判定、手修正、公開可否、購読キュー |
| [backend/app/workflow.py](backend/app/workflow.py) | 入力、AI処理の開始・取消、訂正先への送信、保存時の改版照合 |
| [backend/app/connections.py](backend/app/connections.py) | 接続モードと入力の開始・終了、接続変更と保存の直列化 |
@@ -33,6 +34,8 @@ Caption Relay は、単一の FastAPI プロセスが字幕の状態を持つロ
## データの流れ
+ホームは `Rooms` の接続履歴を読み、ルームごとの `CaptionWorkflow` を選ぶ。同時に入力するのは一つのルームだけで、切り替え時に前の入力とAI要求を終了する。字幕は各Relayのメモリ、名前・接続先・背景・AI・表示・公開設定は `RoomStore` のファイルに保持する。単語辞書は全ルームで共有する。保存範囲と利用手順は[ルームの接続と字幕リセット](docs/rooms.md)を参照する。
+
```mermaid
flowchart LR
ud[UDトーク] -->|Zoom形式のPOST| api
@@ -56,7 +59,7 @@ flowchart LR
FastAPIはPydanticモデルで入出力を検証し、入力と訂正保存を `CaptionWorkflow` へ渡す。状態遷移と公開可否は `CaptionRelay`、外部接続の寿命と送信先は `Connections` が所有する。AI要求はバックグラウンドで実行し、元の発話の更新とモード変更で終了する。保存と接続変更は同時に実行しない。訂正先への送信前後に原文・表示文の改版を照合し、古い原文で新しい発話を上書きしない。存在しない字幕と改版競合はAPI層で404・409に変換する。
-`create_app()`ごとに独立した字幕状態を作る。字幕状態を共有するデータベースはなく、再起動で消えるため、複数ワーカーで運用しない。字幕・接続・AI設定・測定結果をこのプロセスに保持する。各AI提供元のキーは環境変数で読み、画面へ返さない。通常起動では単語辞書とマイク認識の試験使用量を再起動をまたぐファイルに保存する。テスト用の `create_app()` は辞書を注入しない限りメモリ上に保持する。詳細は[単語辞書](docs/dictionary.md)を参照する。
+`create_app()`ごとに独立したルーム管理を作る。字幕状態を共有するデータベースはなく、再起動で消えるため、複数ワーカーで運用しない。字幕とAIの測定結果はこのプロセスに保持する。各AI提供元のキーは環境変数で読み、画面へ返さない。通常起動ではルームの設定、単語辞書、マイク認識の試験使用量をファイルに保存する。テスト用の `create_app()` は保存先を注入しない限りメモリ上に保持する。詳細は[ルーム](docs/rooms.md)と[単語辞書](docs/dictionary.md)を参照する。
接続の初期値は独立配信。Zoom形式の送信先はプロセス内で生成し、再起動と接続変更で更新する。従来のWeb入力Adapterは `CAPTION_RELAY_UDTALK_URL` を設定した場合に開始する。編集参加へ切り替えると両方の入力を止め、有効な編集用URLの参加を開始する。入力の変換は各Adapter、公開と手修正の判断はRelayが所有する。経路・根拠・制約は[UDトークの入力接続](docs/udtalk-input.md)を参照する。
@@ -68,6 +71,8 @@ FastAPIはPydanticモデルで入出力を検証し、入力と訂正保存を `
## API と公開データの境界
+操作APIは `X-Caption-Relay-Room` と `X-Caption-Relay-Generation` で対象とリセットの世代を固定する。書き込みは現在接続中のルームだけに許可し、古い世代には409を返す。観客APIの `room_id` とSSEは取得開始時のRelayを保持し、ルーム切り替えで別の字幕へ切り替えない。リセットは保存・外部送信と直列化し、AI要求の取消完了後に字幕を消す。字幕の改版番号を巻き戻さず、リセット済みの発話IDを再送でも採用しない。
+
Zoom受信先の資格情報は操作画面用の接続状態だけに返す。編集用URLは適用時だけ送信し、応答・字幕ID・ログへ含めない。AIキーは提供元の認証ヘッダーで送り、画面には設定済みかどうかだけを返す。アクセスログはURLの資格情報を記録しないよう起動スクリプトで無効にする。アプリ全体の認証はなく、loopbackでのローカル利用を前提とする。
バックエンドは FastAPI と Pydantic v2 を使用する。入力・応答と内部の状態をモデルで型付けし、`backend/pyproject.toml` の pyright 厳格モードを通す。基底の `Model` は余分な項目と暗黙の型変換を拒否し、代入も検証する。
diff --git a/PRODUCT.md b/PRODUCT.md
index e24f631..9d71115 100644
--- a/PRODUCT.md
+++ b/PRODUCT.md
@@ -42,7 +42,7 @@ web
- 「字幕を隠す」は観客への表示を止める操作。入力と編集は継続する。「字幕を表示」では新しい発話から再開し、非表示期間の発話を自動公開しない。
- 観客には公開を許可した字幕だけを送り、原文や管理情報を送らない。観客画面は初期設定で公開字幕を残しながら末尾へスクロールする。過去の字幕を読み返し、「最新へ」で追従を再開できる。背景・文字・書体・サイズ・行間を調整でき、直近の発話だけの表示にも切り替えられる。
- Gemini・Claude・OpenAIのAPIによる校正と、費用・実測速度に基づく振り分けを設定できる。AIは初期値オフで、キーを設定した提供元へ次の確定字幕から依頼する。GPTの実生成と、Apple認識からGPT-5.4 Miniによる自動校正・編集・配信を合成音声で確認した。[AIの確認記録](docs/ai-routing.md#実接続での確認)を参照する。各社の品質・速度比較と請求確定額は未確認。
-- 認証と字幕の永続化は未実装。字幕と画面の設定は再起動で消え、単語辞書は保存先に残る。アプリはローカルの単一プロセスで使う。独立配信はUDトークのZoom連携から受信する。編集参加は試験接続として提供し、純正への手動訂正・AI訂正の反映を合成音声で確認した。[実接続の範囲](docs/udtalk-input.md#復旧後の実接続確認)を参照する。
+- 認証と字幕の永続化は未実装。字幕は再起動で消え、ルームの接続履歴・設定と単語辞書は保存先に残る。アプリはローカルの単一プロセスで使う。独立配信はUDトークのZoom連携から受信する。編集参加は試験接続として提供し、純正への手動訂正・AI訂正の反映を合成音声で確認した。[実接続の範囲](docs/udtalk-input.md#復旧後の実接続確認)を参照する。
振る舞いの詳細、テストとの対応、その他の未実装事項は [現行 PoC の仕様](docs/current-behavior.md)を参照する。将来要件を含む [v0.2 の設計案](docs/design-v0.2.md)を、現行機能の説明に使わない。
diff --git a/README.md b/README.md
index c5a01b2..93bd2a7 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ UDトークまたはマイク認識の字幕を、AIと手動で訂正して観
UDトークがない場合は、独立配信の入力元を「マイク」にし、OpenAIまたは接続先MacのApple認識を選べます。準備と開始・停止は[マイク入力](docs/microphone-input.md)を参照してください。両方とも合成音声で実認識を確認しています。物理マイクと会場での認識は未確認です。
-AIは初期値オフです。サーバーにGemini・Claude・OpenAIのAPIキーを設定すると、次の確定字幕から校正を実行します。APIキー未設定時と失敗時は原文を保持します。認証と字幕の永続化はなく、ローカルの単一プロセスで使用します。再起動すると字幕と画面の設定は消えます。単語辞書は保存先に残ります。
+AIは初期値オフです。サーバーにGemini・Claude・OpenAIのAPIキーを設定すると、次の確定字幕から校正を実行します。APIキー未設定時と失敗時は原文を保持します。認証と字幕の永続化はなく、ローカルの単一プロセスで使用します。字幕は再起動で消えます。ルームの接続履歴・設定と単語辞書は保存先に残ります。
## 起動
@@ -23,13 +23,15 @@ bash scripts/dev.sh
| 画面 | URL |
|---|---|
-| 操作画面 | |
-| 観客画面 | |
+| ホーム | |
+| 観客画面 | 接続後の操作画面のモニターアイコンから開きます |
`setup.sh` は依存関係を導入し、画面をビルドします。終了時はサーバーを Ctrl+C で止めます。フロントエンドの変更を即時確認する手順は[開発手順](docs/development.md)、Codex Cloud と SSH 接続は[リモート開発](docs/remote-development.md)に記載しています。
## 試す
+ホームからルームへ接続します。初回は「独立配信」を選ぶか、「新しいルームに接続」で名前と接続先を登録します。ホームへの帰還と字幕リセットはルーム画面の上部にあります。詳しくは[ルームの接続と字幕リセット](docs/rooms.md)を参照してください。
+
1. 接続アイコンから「字幕入力の接続設定」を開き、「独立配信」の送信先をUDトークのZoom連携に設定します。実機を使わない画面確認は「準備」の「テスト字幕を送る」で行えます。
2. 表示文をクリックして訂正欄を開き、修正して「保存して公開」を押します。未保存の下書きは観客へ出ません。Ctrl / Command + Enterでも保存できます。
3. 「新着の公開」で自動公開・確認して公開を選びます。「字幕を隠す」は表示を止め、「字幕を表示」は新しい発話から再開します。
diff --git a/backend/app/connections.py b/backend/app/connections.py
index b719b1a..983f960 100644
--- a/backend/app/connections.py
+++ b/backend/app/connections.py
@@ -37,14 +37,20 @@ def __init__(self, accept: Callable[[SourceEvent, bool], Caption | SourceIgnored
def start(self) -> None:
self._running = True
- self.web.start()
+ if self.mode == "host" and self.input_source == "udtalk":
+ self.web.start()
async def stop(self) -> None:
- await self.microphone.stop()
- await self.web.stop()
- if self.editor is not None:
- await self.editor.stop()
- self._running = False
+ async with self._changes:
+ await self.microphone.stop()
+ await self.web.stop()
+ if self.editor is not None:
+ await self.editor.stop()
+ self._running = False
+
+ async def reset_captions(self, reset: Callable[[], Awaitable[None]]) -> None:
+ async with self._changes:
+ await reset()
def status(self) -> ConnectionStatus:
if self.editor is not None:
diff --git a/backend/app/main.py b/backend/app/main.py
index ef32d66..182f08b 100644
--- a/backend/app/main.py
+++ b/backend/app/main.py
@@ -4,10 +4,11 @@
from datetime import UTC, datetime
from pathlib import Path
from collections.abc import Mapping
+from typing import Annotated
-from fastapi import FastAPI, HTTPException, Query, Request, WebSocket
+from fastapi import Depends, FastAPI, HTTPException, Query, Request, WebSocket
from urllib.parse import urlsplit
-from fastapi.responses import FileResponse, PlainTextResponse, StreamingResponse
+from fastapi.responses import FileResponse, JSONResponse, PlainTextResponse, StreamingResponse
from fastapi.staticfiles import StaticFiles
import httpx2 as httpx
@@ -20,6 +21,10 @@
from .udtalk_web import UdtalkStatus
from .udtalk_editor import EditorError
from .workflow import CaptionWorkflow
+from .rooms import RoomConflict, RoomNotFound, Rooms
+from .room_models import RoomCatalog, RoomDetails, RoomDraft, RoomReset
+from .room_scope import RoomScope, room_scope
+from .room_store import RoomStorageError, RoomStore, rooms_path
from .zoom_input import ReceiverError
from .transcription.openai import Connector, openai_connect
@@ -31,21 +36,37 @@ def create_app(relay: CaptionRelay | None = None, *, udtalk_url: str | None = No
environment: Mapping[str, str] | None = None,
ai_transport: httpx.AsyncBaseTransport | None = None,
editor_transport: httpx.AsyncBaseTransport | None = None, audio_connector: Connector = openai_connect,
- dictionary: WordDictionary | None = None) -> FastAPI:
+ dictionary: WordDictionary | None = None, room_store: RoomStore | None = None) -> FastAPI:
service = relay if relay is not None else CaptionRelay()
workflow = CaptionWorkflow(service, udtalk_url, environment if environment is not None else os.environ,
ai_transport, editor_transport, audio_connector, dictionary)
+ def new_workflow() -> CaptionWorkflow:
+ return CaptionWorkflow(CaptionRelay(), None, environment if environment is not None else os.environ,
+ ai_transport, editor_transport, audio_connector, workflow.dictionary)
+ rooms = Rooms(workflow, new_workflow, room_store if room_store is not None else RoomStore())
@asynccontextmanager
async def lifespan(_: FastAPI) -> AsyncGenerator[None]:
- workflow.start()
+ rooms.start()
try:
yield
finally:
- await workflow.stop()
+ await rooms.stop()
application = FastAPI(title="Caption Relay", version="0.2.0", lifespan=lifespan)
+ @application.exception_handler(RoomNotFound)
+ async def room_not_found(_: Request, error: RoomNotFound) -> JSONResponse:
+ return JSONResponse({"detail": str(error)}, status_code=404)
+
+ @application.exception_handler(RoomConflict)
+ async def room_conflict(_: Request, error: RoomConflict) -> JSONResponse:
+ return JSONResponse({"detail": str(error)}, status_code=409)
+
+ @application.exception_handler(RoomStorageError)
+ async def room_storage_error(_: Request, error: RoomStorageError) -> JSONResponse:
+ return JSONResponse({"detail": str(error)}, status_code=503)
+
@application.exception_handler(EditorError)
async def editor_error(_: Request, error: EditorError) -> PlainTextResponse:
return PlainTextResponse(str(error), status_code=502)
@@ -56,60 +77,109 @@ async def editor_error(_: Request, error: EditorError) -> PlainTextResponse:
async def index() -> FileResponse:
return FileResponse(FRONTEND / "index.html")
+ @application.get("/rooms/{room_id}", response_class=FileResponse)
+ async def room_index(room_id: str) -> FileResponse:
+ return FileResponse(FRONTEND / "index.html")
+
+ @application.get("/api/rooms", response_model=RoomCatalog)
+ async def room_catalog() -> RoomCatalog:
+ return rooms.catalog()
+
+ @application.post("/api/rooms", response_model=RoomDetails, status_code=201)
+ async def add_room(draft: RoomDraft) -> RoomDetails:
+ try:
+ return await rooms.save_room(draft)
+ except EditorError as error:
+ raise HTTPException(422, str(error)) from None
+
+ @application.get("/api/rooms/{room_id}", response_model=RoomDetails)
+ async def room_details(room_id: str) -> RoomDetails:
+ return rooms.details(room_id)
+
+ @application.put("/api/rooms/{room_id}", response_model=RoomDetails)
+ async def update_room(room_id: str, draft: RoomDraft) -> RoomDetails:
+ try:
+ return await rooms.save_room(draft, room_id)
+ except EditorError as error:
+ raise HTTPException(422, str(error)) from None
+
+ @application.post("/api/rooms/{room_id}/connect", response_model=RoomDetails)
+ async def connect_room(room_id: str) -> RoomDetails:
+ try:
+ return await rooms.connect(room_id)
+ except EditorError as error:
+ raise HTTPException(422, str(error)) from None
+
+ @application.post("/api/rooms/{room_id}/leave", response_model=RoomCatalog)
+ async def leave_room(room_id: str, operation: RoomReset) -> RoomCatalog:
+ return await rooms.leave(room_id, operation.generation)
+
+ @application.post("/api/rooms/{room_id}/reset", response_model=RoomDetails)
+ async def reset_room(room_id: str, operation: RoomReset) -> RoomDetails:
+ return await rooms.reset(room_id, operation.generation)
+
@application.get("/view/demo", response_class=FileResponse)
async def view() -> FileResponse:
return FileResponse(FRONTEND / "view.html")
@application.get("/api/session", response_model=Session)
- async def session() -> Session:
- return service.session()
+ async def session(scope: Annotated[RoomScope, Depends(room_scope)]) -> Session:
+ return rooms.workflow(scope.room_id, scope.generation).relay.session()
@application.get("/api/events", response_model=list[Caption])
- async def events() -> list[Caption]:
- return service.captions()
+ async def events(scope: Annotated[RoomScope, Depends(room_scope)]) -> list[Caption]:
+ return rooms.workflow(scope.room_id, scope.generation).relay.captions()
@application.post("/api/source/events", response_model=Caption | SourceIgnored)
- async def source_event(event: SourceEvent) -> Caption | SourceIgnored:
- if workflow.connections.input_source != "udtalk":
+ async def source_event(event: SourceEvent, scope: Annotated[RoomScope, Depends(room_scope)]) -> Caption | SourceIgnored:
+ target = rooms.workflow(scope.room_id, scope.generation, active=True)
+ if target.connections.input_source != "udtalk":
raise HTTPException(409, "マイク以外の入力は停止しています。")
- return workflow.source_event(event)
+ return target.source_event(event)
@application.get("/api/source/udtalk", response_model=UdtalkStatus)
- async def udtalk_status() -> UdtalkStatus:
- return workflow.connections.web.status.model_copy(deep=True)
+ async def udtalk_status(scope: Annotated[RoomScope, Depends(room_scope)]) -> UdtalkStatus:
+ return rooms.workflow(scope.room_id, scope.generation).connections.web.status.model_copy(deep=True)
@application.get("/api/connection", response_model=ConnectionStatus)
- async def connection() -> ConnectionStatus:
- return workflow.connections.status()
+ async def connection(scope: Annotated[RoomScope, Depends(room_scope)]) -> ConnectionStatus:
+ return rooms.workflow(scope.room_id, scope.generation).connections.status()
@application.put("/api/connection", response_model=ConnectionStatus)
- async def set_connection(settings: ConnectionSettings) -> ConnectionStatus:
+ async def set_connection(settings: ConnectionSettings, scope: Annotated[RoomScope, Depends(room_scope)]) -> ConnectionStatus:
try:
- return await workflow.configure(settings)
+ return await rooms.configure(scope.room_id, scope.generation, settings)
except EditorError as error:
raise HTTPException(422, str(error)) from None
@application.websocket("/api/source/audio")
- async def microphone_audio(socket: WebSocket) -> None:
+ async def microphone_audio(socket: WebSocket, room_id: str | None = None, generation: int | None = None) -> None:
+ try:
+ target = rooms.workflow(room_id, generation, active=True)
+ except (RoomConflict, RoomNotFound):
+ await socket.close(code=1008)
+ return
origin = socket.headers.get("origin")
parsed = urlsplit(origin or "")
if (parsed.scheme not in {"http", "https"} or parsed.netloc != socket.headers.get("host")
- or workflow.connections.mode != "host" or workflow.connections.input_source != "microphone"):
+ or target.connections.mode != "host" or target.connections.input_source != "microphone"):
await socket.close(code=1008)
return
await socket.accept()
- await workflow.connections.microphone.serve(socket, workflow.connections.recognizer)
+ await target.connections.microphone.serve(socket, target.connections.recognizer)
- def authorize_receiver(signature: str) -> None:
- if not workflow.connections.receiver.authorized(signature):
+ def authorize_receiver(signature: str) -> CaptionWorkflow:
+ target = rooms.workflow(active=True)
+ if not target.connections.receiver.authorized(signature):
raise HTTPException(403, "invalid receiver token")
- if workflow.connections.mode != "host" or workflow.connections.input_source != "udtalk":
+ if target.connections.mode != "host" or target.connections.input_source != "udtalk":
raise HTTPException(409, "receiver is inactive")
+ return target
@application.get("/closedcaption/seq", response_class=PlainTextResponse)
async def receiver_sequence(signature: str = "") -> str:
- authorize_receiver(signature)
- return str(workflow.connections.receiver.sequence)
+ target = authorize_receiver(signature)
+ return str(target.connections.receiver.sequence)
@application.post("/closedcaption", response_class=PlainTextResponse)
async def receive_caption(request: Request, seq: int = Query(ge=1), uttrId: str = Query(min_length=1, max_length=256),
@@ -124,16 +194,16 @@ async def receive_caption(request: Request, seq: int = Query(ge=1), uttrId: str
raise HTTPException(413, "caption too large")
try:
# Reading a streamed body can span a connection change.
- authorize_receiver(signature)
- workflow.connections.receive(seq, uttrId, lang, body.decode("utf-8"))
+ target = authorize_receiver(signature)
+ target.connections.receive(seq, uttrId, lang, body.decode("utf-8"))
except (UnicodeDecodeError, ReceiverError) as error:
raise HTTPException(400, "invalid caption packet") from error
return datetime.now(UTC).isoformat(timespec="milliseconds").replace("+00:00", "")
@application.patch("/api/captions/{caption_id}", response_model=Caption, responses={409: {"model": ConflictResponse}})
- async def patch_caption(caption_id: str, patch: CaptionPatch) -> Caption:
+ async def patch_caption(caption_id: str, patch: CaptionPatch, scope: Annotated[RoomScope, Depends(room_scope)]) -> Caption:
try:
- return await workflow.patch_caption(caption_id, patch)
+ return await rooms.patch(scope.room_id, scope.generation, caption_id, patch)
except CaptionNotFound as error:
raise HTTPException(404, "caption not found") from error
except RevisionConflict as error:
@@ -141,58 +211,60 @@ async def patch_caption(caption_id: str, patch: CaptionPatch) -> Caption:
raise HTTPException(409, detail=detail.model_dump(mode="json")) from error
@application.put("/api/captions/{caption_id}/formatted", response_model=Caption | SourceIgnored)
- async def formatted_result(caption_id: str, result: FormattedResult) -> Caption | SourceIgnored:
+ async def formatted_result(caption_id: str, result: FormattedResult, scope: Annotated[RoomScope, Depends(room_scope)]) -> Caption | SourceIgnored:
try:
- return await workflow.formatted_result(caption_id, result)
+ return await rooms.formatted(scope.room_id, scope.generation, caption_id, result)
except CaptionNotFound as error:
raise HTTPException(404, "caption not found") from error
@application.post("/api/commands", response_model=Visibility)
- async def command(command: Command) -> Visibility:
- return service.command(command)
+ async def command(command: Command, scope: Annotated[RoomScope, Depends(room_scope)]) -> Visibility:
+ return rooms.command(scope.room_id, scope.generation, command)
@application.put("/api/publication-mode", response_model=PublicationMode)
- async def publication_mode(mode: PublicationMode) -> PublicationMode:
- return service.publication_mode(mode)
+ async def publication_mode(mode: PublicationMode, scope: Annotated[RoomScope, Depends(room_scope)]) -> PublicationMode:
+ return rooms.publication_mode(scope.room_id, scope.generation, mode)
@application.put("/api/display", response_model=DisplaySettings)
- async def display_settings(settings: DisplaySettings) -> DisplaySettings:
- return service.display_settings(settings)
+ async def display_settings(settings: DisplaySettings, scope: Annotated[RoomScope, Depends(room_scope)]) -> DisplaySettings:
+ return rooms.set_display(scope.room_id, scope.generation, settings)
@application.get("/api/ai", response_model=AiRouting)
- async def ai_routing() -> AiRouting:
- return service.ai_routing()
+ async def ai_routing(scope: Annotated[RoomScope, Depends(room_scope)]) -> AiRouting:
+ return rooms.workflow(scope.room_id, scope.generation).relay.ai_routing()
@application.put("/api/ai", response_model=AiRouting)
- async def ai_settings(settings: AiSettings) -> AiRouting:
- return service.ai_settings(settings)
+ async def ai_settings(settings: AiSettings, scope: Annotated[RoomScope, Depends(room_scope)]) -> AiRouting:
+ return rooms.set_ai(scope.room_id, scope.generation, settings)
@application.get("/api/dictionary", response_model=DictionarySnapshot)
- async def get_dictionary() -> DictionarySnapshot:
- return workflow.dictionary.snapshot()
+ async def get_dictionary(scope: Annotated[RoomScope, Depends(room_scope)]) -> DictionarySnapshot:
+ return rooms.workflow(scope.room_id, scope.generation).dictionary.snapshot()
@application.put("/api/dictionary", response_model=DictionarySnapshot,
responses={409: {"model": DictionaryError}, 503: {"model": DictionaryError}})
- async def set_dictionary(update: DictionaryUpdate) -> DictionarySnapshot:
+ async def set_dictionary(update: DictionaryUpdate, scope: Annotated[RoomScope, Depends(room_scope)]) -> DictionarySnapshot:
try:
- return workflow.dictionary.update(update)
+ return rooms.workflow(scope.room_id, scope.generation, active=True).dictionary.update(update)
except DictionaryConflict as error:
raise HTTPException(409, str(error)) from None
except DictionaryStorageError as error:
raise HTTPException(503, str(error)) from None
@application.get("/api/view", response_model=PublicSnapshot)
- async def public_view() -> PublicSnapshot:
- return service.public_snapshot()
+ async def public_view(room_id: str | None = None) -> PublicSnapshot:
+ return rooms.workflow(room_id).relay.public_snapshot()
@application.get("/api/view/events", response_class=StreamingResponse)
- async def public_events() -> StreamingResponse:
+ async def public_events(room_id: str | None = None) -> StreamingResponse:
+ target = rooms.workflow(room_id)
async def stream() -> AsyncIterator[str]:
- async for snapshot in service.snapshots():
+ async for snapshot in target.relay.snapshots():
yield f"event: snapshot\ndata: {snapshot.model_dump_json()}\n\n"
return StreamingResponse(stream(), media_type="text/event-stream")
return application
-app = create_app(udtalk_url=os.environ.get("CAPTION_RELAY_UDTALK_URL"), dictionary=WordDictionary(dictionary_path(os.environ)))
+app = create_app(udtalk_url=os.environ.get("CAPTION_RELAY_UDTALK_URL"), dictionary=WordDictionary(dictionary_path(os.environ)),
+ room_store=RoomStore(rooms_path(os.environ)))
diff --git a/backend/app/relay.py b/backend/app/relay.py
index 9aa8dbb..d0ecce7 100644
--- a/backend/app/relay.py
+++ b/backend/app/relay.py
@@ -28,6 +28,7 @@ def __init__(self) -> None:
self._caption_positions: dict[str, int] = {}
self._published_ids: list[str] = []
self._seen_events: set[str] = set()
+ self._retired_utterances: set[str] = set()
self._subscribers: set[asyncio.Queue[PublicSnapshot]] = set()
self._visible = True
self._revision = 0
@@ -48,6 +49,14 @@ def session(self) -> Session:
def captions(self) -> list[Caption]:
return [caption.model_copy(deep=True) for caption in self._captions.values()]
+ def reset_captions(self) -> None:
+ self._retired_utterances.update(self._captions)
+ self._captions.clear()
+ self._caption_positions.clear()
+ self._published_ids.clear()
+ self._revision += 1
+ self.connection_mode(self._connection_mode)
+
def public_snapshot(self) -> PublicSnapshot:
if self._connection_mode == "client":
return PublicSnapshot(visible=False, captions=[], display=self._display.model_copy(deep=True))
@@ -110,6 +119,8 @@ def _publish(self) -> None:
queue.put_nowait(snapshot.model_copy(deep=True))
def source_event(self, event: SourceEvent, *, remote_edit: bool = False) -> Caption | SourceIgnored:
+ if event.utterance_id in self._retired_utterances:
+ return SourceIgnored(status="stale")
if event.source_event_id in self._seen_events:
return SourceIgnored(status="duplicate")
self._seen_events.add(event.source_event_id)
diff --git a/backend/app/room_models.py b/backend/app/room_models.py
new file mode 100644
index 0000000..244c9f1
--- /dev/null
+++ b/backend/app/room_models.py
@@ -0,0 +1,65 @@
+"""Saved room settings and the credential-free home API."""
+
+from datetime import datetime
+
+from pydantic import Field, field_validator, model_validator
+
+from .models import AiSettings, ConnectionSettings, DisplaySettings, InputSource, Model, RecognizerId
+
+
+class RoomDraft(Model):
+ name: str = Field(min_length=1, max_length=120)
+ connection: ConnectionSettings = Field(default_factory=ConnectionSettings)
+ ai: AiSettings = Field(default_factory=AiSettings)
+
+ @field_validator("name")
+ @classmethod
+ def nonblank_name(cls, value: str) -> str:
+ if not value.strip():
+ raise ValueError("room name must not be blank")
+ return value.strip()
+
+
+class SavedRoom(RoomDraft):
+ id: str = Field(pattern=r"^[a-z0-9-]{1,64}$")
+ last_used_at: datetime | None = None
+ generation: int = Field(default=0, ge=0)
+ display: DisplaySettings = Field(default_factory=DisplaySettings)
+ auto_publish: bool = True
+ visible: bool = True
+
+
+class RoomFile(Model):
+ rooms: list[SavedRoom] = Field(max_length=100)
+
+ @model_validator(mode="after")
+ def unique_rooms(self) -> "RoomFile":
+ if len({room.id for room in self.rooms}) != len(self.rooms):
+ raise ValueError("room identifiers must be unique")
+ return self
+
+
+class RoomSummary(Model):
+ id: str
+ name: str
+ last_used_at: datetime | None
+ generation: int
+ caption_count: int
+ mode: str
+ input_source: InputSource
+ recognizer: RecognizerId
+ background: str
+
+
+class RoomDetails(RoomSummary):
+ connection: ConnectionSettings
+ ai: AiSettings
+
+
+class RoomCatalog(Model):
+ active_room_id: str | None
+ rooms: list[RoomSummary]
+
+
+class RoomReset(Model):
+ generation: int = Field(ge=0)
diff --git a/backend/app/room_scope.py b/backend/app/room_scope.py
new file mode 100644
index 0000000..860b856
--- /dev/null
+++ b/backend/app/room_scope.py
@@ -0,0 +1,19 @@
+"""Bind an operator request to a room and a caption generation."""
+
+from dataclasses import dataclass
+from typing import Annotated
+
+from fastapi import Header
+
+
+@dataclass(frozen=True)
+class RoomScope:
+ room_id: str | None
+ generation: int | None
+
+
+def room_scope(
+ room_id: Annotated[str | None, Header(alias="X-Caption-Relay-Room", min_length=1, max_length=64)] = None,
+ generation: Annotated[int | None, Header(alias="X-Caption-Relay-Generation", ge=0)] = None,
+) -> RoomScope:
+ return RoomScope(room_id, generation)
diff --git a/backend/app/room_store.py b/backend/app/room_store.py
new file mode 100644
index 0000000..6c2611b
--- /dev/null
+++ b/backend/app/room_store.py
@@ -0,0 +1,66 @@
+"""Persist connection bookmarks privately; captions and API keys are never stored."""
+
+import os
+import tempfile
+from collections.abc import Mapping
+from pathlib import Path
+
+from .room_models import RoomFile, SavedRoom
+
+
+class RoomStorageError(Exception):
+ pass
+
+
+def rooms_path(environment: Mapping[str, str]) -> Path:
+ configured = environment.get("CAPTION_RELAY_ROOMS_PATH", "").strip()
+ base = environment.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+ return Path(configured).expanduser() if configured else Path(base).expanduser() / "caption-relay" / "rooms.json"
+
+
+class RoomStore:
+ def __init__(self, path: Path | None = None) -> None:
+ self._path = path
+ self.restored = path is not None and path.exists()
+ self._rooms: dict[str, SavedRoom] = {"default": SavedRoom(id="default", name="独立配信")}
+ if path is not None and path.exists():
+ try:
+ if path.stat().st_size > 4194304:
+ raise ValueError("room file too large")
+ data = RoomFile.model_validate_json(path.read_bytes())
+ self._rooms = {room.id: room for room in data.rooms}
+ self._rooms.setdefault("default", SavedRoom(id="default", name="独立配信"))
+ except (OSError, ValueError):
+ raise RoomStorageError("ルームの接続履歴を読み込めません。保存ファイルを確認してください。") from None
+
+ def all(self) -> list[SavedRoom]:
+ return [room.model_copy(deep=True) for room in self._rooms.values()]
+
+ def get(self, room_id: str) -> SavedRoom:
+ return self._rooms[room_id].model_copy(deep=True)
+
+ def put(self, room: SavedRoom) -> None:
+ records = {**self._rooms, room.id: room.model_copy(deep=True)}
+ try:
+ data = RoomFile(rooms=list(records.values()))
+ except ValueError:
+ raise RoomStorageError("登録できるルームは100件までです。") from None
+ if self._path is not None:
+ temporary: str | None = None
+ try:
+ self._path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+ with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=self._path.parent, delete=False) as output:
+ temporary = output.name
+ output.write(data.model_dump_json(indent=2))
+ output.flush()
+ os.fsync(output.fileno())
+ os.replace(temporary, self._path)
+ except OSError:
+ raise RoomStorageError("ルームの接続履歴を保存できません。保存先と空き容量を確認してください。") from None
+ finally:
+ if temporary is not None:
+ try:
+ Path(temporary).unlink(missing_ok=True)
+ except OSError:
+ pass
+ self._rooms = records
diff --git a/backend/app/rooms.py b/backend/app/rooms.py
new file mode 100644
index 0000000..45b2808
--- /dev/null
+++ b/backend/app/rooms.py
@@ -0,0 +1,188 @@
+"""One active connection, with isolated room state and saved connection bookmarks."""
+
+import asyncio
+from collections.abc import Callable
+from datetime import UTC, datetime
+from uuid import uuid4
+
+from .models import (
+ AiRouting, AiSettings, Caption, CaptionPatch, Command, ConnectionSettings, ConnectionStatus,
+ DisplaySettings, FormattedResult, PublicationMode, SourceIgnored, Visibility,
+)
+from .room_models import RoomCatalog, RoomDetails, RoomDraft, RoomSummary, SavedRoom
+from .room_store import RoomStore
+from .udtalk_editor import EditorError, decode_editor_url
+from .workflow import CaptionWorkflow
+
+
+class RoomNotFound(Exception):
+ pass
+
+
+class RoomConflict(Exception):
+ pass
+
+
+def validate_connection(settings: ConnectionSettings) -> None:
+ if settings.mode == "client":
+ if settings.input_source != "udtalk" or not settings.editor_url:
+ raise EditorError("UDトークの編集用の参加リンクを入力してください。")
+ decode_editor_url(settings.editor_url)
+ elif settings.editor_url:
+ raise EditorError("独立配信では編集用リンクを使いません。")
+
+
+class Rooms:
+ def __init__(self, initial: CaptionWorkflow, factory: Callable[[], CaptionWorkflow], store: RoomStore) -> None:
+ self.store = store
+ self._factory = factory
+ self._workflows = {"default": initial}
+ self.active_room_id: str | None = None if store.restored else "default"
+ self._configured: dict[str, ConnectionSettings] = {}
+ self._changes = asyncio.Lock()
+
+ def start(self) -> None:
+ if self.active_room_id is not None:
+ self._workflows["default"].start()
+
+ async def stop(self) -> None:
+ async with self._changes:
+ self.active_room_id = None
+ for workflow in self._workflows.values():
+ await workflow.stop()
+
+ def _record(self, room_id: str) -> SavedRoom:
+ try:
+ return self.store.get(room_id)
+ except KeyError:
+ raise RoomNotFound("ルームが見つかりません。ホームから選び直してください。") from None
+
+ def workflow(self, room_id: str | None = None, generation: int | None = None, *, active: bool = False) -> CaptionWorkflow:
+ identifier = room_id or self.active_room_id or "default"
+ room = self._record(identifier)
+ if generation is not None and generation != room.generation:
+ raise RoomConflict("字幕がリセットされました。画面を読み直してください。")
+ if active and self.active_room_id != identifier:
+ raise RoomConflict("このルームの接続は終了しました。ホームから接続してください。")
+ if identifier not in self._workflows:
+ workflow = self._factory()
+ workflow.relay.ai_settings(room.ai)
+ workflow.relay.display_settings(room.display)
+ workflow.relay.publication_mode(PublicationMode(auto_publish=room.auto_publish))
+ if not room.visible:
+ workflow.relay.command(Command(command="hide"))
+ self._workflows[identifier] = workflow
+ return self._workflows[identifier]
+
+ def details(self, room_id: str) -> RoomDetails:
+ room = self._record(room_id)
+ workflow = self._workflows.get(room_id)
+ return RoomDetails(id=room.id, name=room.name, generation=room.generation,
+ last_used_at=room.last_used_at, caption_count=workflow.relay.session().count if workflow else 0,
+ mode=room.connection.mode, input_source=room.connection.input_source, recognizer=room.connection.recognizer,
+ background=room.ai.background, ai=room.ai,
+ connection=room.connection.model_copy(update={"editor_url": None}))
+
+ def catalog(self) -> RoomCatalog:
+ records = sorted(self.store.all(), key=lambda room: (room.last_used_at or datetime.min.replace(tzinfo=UTC), room.id), reverse=True)
+ return RoomCatalog(active_room_id=self.active_room_id,
+ rooms=[RoomSummary.model_validate(self.details(room.id).model_dump(exclude={"ai", "connection"})) for room in records])
+
+ async def save_room(self, draft: RoomDraft, room_id: str | None = None) -> RoomDetails:
+ async with self._changes:
+ existing = self._record(room_id) if room_id is not None else None
+ settings = draft.connection.model_copy(deep=True)
+ if existing is not None and settings.mode == "client" and settings.editor_url is None and existing.connection.mode == "client":
+ settings.editor_url = existing.connection.editor_url
+ validate_connection(settings)
+ room = existing or SavedRoom(id=str(uuid4()), name=draft.name)
+ room = room.model_copy(update={"name": draft.name, "connection": settings, "ai": draft.ai.model_copy(deep=True)})
+ self.store.put(room)
+ if room.id in self._workflows:
+ self._workflows[room.id].relay.ai_settings(room.ai)
+ return self.details(room.id)
+
+ async def connect(self, room_id: str) -> RoomDetails:
+ async with self._changes:
+ room = self._record(room_id)
+ validate_connection(room.connection)
+ room.last_used_at = datetime.now(UTC)
+ self.store.put(room)
+ if self.active_room_id != room_id or self._configured.get(room_id) != room.connection:
+ previous = self._workflows.get(self.active_room_id or "")
+ self.active_room_id = None
+ if previous is not None:
+ await previous.stop()
+ target = self.workflow(room_id)
+ try:
+ target.relay.ai_settings(room.ai)
+ target.relay.display_settings(room.display)
+ target.relay.publication_mode(PublicationMode(auto_publish=room.auto_publish))
+ target.relay.command(Command(command="show" if room.visible else "hide"))
+ await target.configure(room.connection)
+ target.start()
+ except BaseException:
+ await target.stop()
+ raise
+ self.active_room_id = room_id
+ self._configured[room_id] = room.connection.model_copy(deep=True)
+ return self.details(room_id)
+
+ async def leave(self, room_id: str, generation: int) -> RoomCatalog:
+ async with self._changes:
+ target = self.workflow(room_id, generation, active=True)
+ self.active_room_id = None
+ await target.stop()
+ return self.catalog()
+
+ async def reset(self, room_id: str, generation: int) -> RoomDetails:
+ async with self._changes:
+ target = self.workflow(room_id, generation, active=True)
+ room = self._record(room_id)
+ room.generation += 1
+ self.store.put(room)
+ await target.reset_captions()
+ return self.details(room_id)
+
+ async def configure(self, room_id: str | None, generation: int | None, settings: ConnectionSettings) -> ConnectionStatus:
+ async with self._changes:
+ target = self.workflow(room_id, generation, active=True)
+ validate_connection(settings)
+ room = self._record(room_id or self.active_room_id or "default")
+ self.store.put(room.model_copy(update={"connection": settings.model_copy(deep=True)}))
+ result = await target.configure(settings)
+ self._configured[room.id] = settings.model_copy(deep=True)
+ return result
+
+ def set_ai(self, room_id: str | None, generation: int | None, settings: AiSettings) -> AiRouting:
+ target = self.workflow(room_id, generation, active=True)
+ room = self._record(room_id or self.active_room_id or "default")
+ self.store.put(room.model_copy(update={"ai": settings.model_copy(deep=True)}))
+ return target.relay.ai_settings(settings)
+
+ def set_display(self, room_id: str | None, generation: int | None, settings: DisplaySettings) -> DisplaySettings:
+ target = self.workflow(room_id, generation, active=True)
+ room = self._record(room_id or self.active_room_id or "default")
+ self.store.put(room.model_copy(update={"display": settings.model_copy(deep=True)}))
+ return target.relay.display_settings(settings)
+
+ def command(self, room_id: str | None, generation: int | None, command: Command) -> Visibility:
+ target = self.workflow(room_id, generation, active=True)
+ room = self._record(room_id or self.active_room_id or "default")
+ self.store.put(room.model_copy(update={"visible": command.command == "show"}))
+ return target.relay.command(command)
+
+ def publication_mode(self, room_id: str | None, generation: int | None, mode: PublicationMode) -> PublicationMode:
+ target = self.workflow(room_id, generation, active=True)
+ room = self._record(room_id or self.active_room_id or "default")
+ self.store.put(room.model_copy(update={"auto_publish": mode.auto_publish}))
+ return target.relay.publication_mode(mode)
+
+ async def patch(self, room_id: str | None, generation: int | None, caption_id: str, patch: CaptionPatch) -> Caption:
+ async with self._changes:
+ return await self.workflow(room_id, generation, active=True).patch_caption(caption_id, patch)
+
+ async def formatted(self, room_id: str | None, generation: int | None, caption_id: str,
+ result: FormattedResult) -> Caption | SourceIgnored:
+ async with self._changes:
+ return await self.workflow(room_id, generation, active=True).formatted_result(caption_id, result)
diff --git a/backend/app/workflow.py b/backend/app/workflow.py
index 20e9bcb..174cfd1 100644
--- a/backend/app/workflow.py
+++ b/backend/app/workflow.py
@@ -41,6 +41,16 @@ async def stop(self) -> None:
finally:
self._ai_paused -= 1
+ async def reset_captions(self) -> None:
+ self._ai_paused += 1
+ try:
+ async def reset() -> None:
+ await self._cancel_ai()
+ self.relay.reset_captions()
+ await self.connections.reset_captions(reset)
+ finally:
+ self._ai_paused -= 1
+
async def _cancel_ai(self) -> None:
self._generation += 1
self._ai_paused += 1
diff --git a/backend/tests/test_connection_lifecycle.py b/backend/tests/test_connection_lifecycle.py
index acaee7c..5058a7d 100644
--- a/backend/tests/test_connection_lifecycle.py
+++ b/backend/tests/test_connection_lifecycle.py
@@ -56,6 +56,25 @@ async def verify():
asyncio.run(verify())
+@pytest.mark.parametrize("mode", ["client", "microphone"])
+def test_starting_a_saved_connection_does_not_restart_the_inactive_web_input(mode):
+ async def verify():
+ server = NativeServer()
+ workflow = CaptionWorkflow(CaptionRelay(), URL, {}, editor_transport=httpx.MockTransport(server.handle))
+ settings = (ConnectionSettings(mode="client", editor_url=editor_url()) if mode == "client"
+ else ConnectionSettings(input_source="microphone"))
+ await workflow.configure(settings)
+ viewer = ViewerServer()
+ workflow.connections.web = UdtalkWebInput(URL, workflow.source_event, httpx.MockTransport(viewer.handle))
+ try:
+ workflow.start()
+ assert workflow.connections.web.status.state == "disabled"
+ assert viewer.polls == []
+ finally:
+ await workflow.stop()
+ asyncio.run(verify())
+
+
@pytest.mark.parametrize("shutdown", [False, True])
def test_transition_does_not_schedule_ai_for_input_received_while_cancelling(shutdown):
async def verify():
diff --git a/backend/tests/test_rooms.py b/backend/tests/test_rooms.py
new file mode 100644
index 0000000..73f8f2d
--- /dev/null
+++ b/backend/tests/test_rooms.py
@@ -0,0 +1,216 @@
+import asyncio
+import json
+import stat
+
+import httpx2 as httpx
+import pytest
+from fastapi.testclient import TestClient
+
+from app.main import create_app
+from app.models import AiSettings, ConnectionSettings, SourceEvent
+from app.relay import CaptionRelay
+from app.room_store import RoomStorageError, RoomStore
+from app.rooms import Rooms
+from app.workflow import CaptionWorkflow
+from test_udtalk_editor import NativeServer, editor_url, speech, wait_until
+
+
+def create_room(client, name, background=""):
+ response = client.post("/api/rooms", json={"name": name, "ai": {"background": background}})
+ response.raise_for_status()
+ return response.json()
+
+
+def scope(room):
+ return {"X-Caption-Relay-Room": room["id"], "X-Caption-Relay-Generation": str(room["generation"])}
+
+
+def receive(client, room, text, identifier="same"):
+ response = client.post("/api/source/events", headers=scope(room), json={
+ "utterance_id": identifier, "revision": 1, "text": text, "source_event_id": identifier + "-1",
+ })
+ response.raise_for_status()
+ return response.json()
+
+
+def test_switching_rooms_preserves_each_caption_and_background_but_rejects_old_tab_writes():
+ with TestClient(create_app(environment={})) as client:
+ first = create_room(client, "作家へのインタビュー", "写真と布の展示")
+ second = create_room(client, "別のトーク", "街の記録")
+ client.post(f"/api/rooms/{first['id']}/connect").raise_for_status()
+ old = receive(client, first, "最初のルームの字幕")
+ first_receiver = client.get("/api/connection", headers=scope(first)).json()["receiver_path"]
+ client.post(f"/api/rooms/{second['id']}/connect").raise_for_status()
+ receive(client, second, "別ルームの字幕")
+ assert client.get("/api/events", headers=scope(first)).json()[0]["text"] == "最初のルームの字幕"
+ assert client.get("/api/events", headers=scope(second)).json()[0]["text"] == "別ルームの字幕"
+ assert client.get("/api/ai", headers=scope(second)).json()["settings"]["background"] == "街の記録"
+ assert client.patch(f"/api/captions/{old['id']}", headers=scope(first), json={
+ "text": "間違ったルームへの保存", "base_revision": old["revision"],
+ }).status_code == 409
+ assert client.post(first_receiver + "&seq=1&uttrId=old", headers={"content-type": "text/plain"}, content="遅れた入力").status_code == 403
+ assert client.post(f"/api/rooms/{first['id']}/reset", json={"generation": first["generation"]}).status_code == 409
+ client.post(f"/api/rooms/{first['id']}/connect").raise_for_status()
+ assert client.get("/api/ai", headers=scope(first)).json()["settings"]["background"] == "写真と布の展示"
+ assert client.get("/api/view", params={"room_id": second["id"]}).json()["captions"][0]["text"] == "別ルームの字幕"
+ assert client.get("/api/rooms").json()["rooms"][0]["id"] == first["id"]
+
+
+def test_room_bookmarks_settings_and_private_links_survive_restart_without_saving_captions(tmp_path):
+ path = tmp_path / "rooms.json"
+ server = NativeServer()
+ url = editor_url()
+ with TestClient(create_app(environment={}, room_store=RoomStore(path), editor_transport=httpx.MockTransport(server.handle))) as client:
+ room = create_room(client, "保存するトーク", "会場と作品の背景")
+ client.post(f"/api/rooms/{room['id']}/connect").raise_for_status()
+ receive(client, room, "保存しない字幕")
+ client.put("/api/display", headers=scope(room), json={"font_size": 72}).raise_for_status()
+ client.put("/api/connection", headers=scope(room), json={"mode": "client", "editor_url": url}).raise_for_status()
+ assert url not in client.get("/api/rooms").text
+ assert url not in client.get(f"/api/rooms/{room['id']}").text
+ assert "会場と作品" not in client.get("/api/view", params={"room_id": room["id"]}).text
+ assert stat.S_IMODE(path.stat().st_mode) == 0o600
+ assert url in path.read_text()
+ assert "保存しない字幕" not in path.read_text()
+ with TestClient(create_app(environment={}, room_store=RoomStore(path), editor_transport=httpx.MockTransport(server.handle))) as client:
+ assert client.get("/api/rooms").json()["active_room_id"] is None
+ assert client.get(f"/api/rooms/{room['id']}").json()["background"] == "会場と作品の背景"
+ client.post(f"/api/rooms/{room['id']}/connect").raise_for_status()
+ assert client.get("/api/events", headers=scope(room)).json() == []
+ assert client.get("/api/session", headers=scope(room)).json()["display"]["font_size"] == 72
+ assert any(route == "/push/signTalk/" for route, _ in server.requests)
+
+
+def test_reset_clears_only_current_captions_rejects_replays_and_keeps_settings():
+ relay = CaptionRelay()
+ with TestClient(create_app(relay, environment={})) as client:
+ room = client.get("/api/rooms/default").json()
+ before = receive(client, room, "リセット前")
+ client.put("/api/ai", headers=scope(room), json={"background": "残す背景"}).raise_for_status()
+ client.put("/api/display", headers=scope(room), json={"font_size": 64}).raise_for_status()
+ result = client.post("/api/rooms/default/reset", json={"generation": 0})
+ result.raise_for_status()
+ after = result.json()
+ assert after["caption_count"] == 0 and after["generation"] == 1
+ assert after["background"] == "残す背景"
+ assert client.get("/api/events", headers=scope(room)).status_code == 409
+ assert client.get("/api/view", params={"room_id": "default"}).json()["captions"] == []
+ assert client.get("/api/session", headers=scope(after)).json()["display"]["font_size"] == 64
+ assert receive(client, after, "古い発話の再送")["status"] == "stale"
+ new = receive(client, after, "新しい発話", "new")
+ assert new["revision"] > before["revision"]
+ assert client.get("/api/events", headers=scope(after)).json()[0]["text"] == "新しい発話"
+ assert relay.ai_context(new["id"]).recent_utterances == []
+ assert relay.ai_context(new["id"]).background == "残す背景"
+ assert client.post("/api/rooms/default/reset", json={"generation": 0}).status_code == 409
+
+
+def test_reset_cancels_inflight_ai_before_clearing():
+ async def verify():
+ started = asyncio.Event()
+ cancelled = asyncio.Event()
+ async def ai_response(_):
+ started.set()
+ try:
+ await asyncio.Event().wait()
+ finally:
+ cancelled.set()
+ workflow = CaptionWorkflow(CaptionRelay(), None, {"OPENAI_API_KEY": "test-key"}, httpx.MockTransport(ai_response))
+ rooms = Rooms(workflow, lambda: CaptionWorkflow(CaptionRelay(), None, {}), RoomStore())
+ workflow.relay.ai_settings(AiSettings(strategy="manual"))
+ workflow.source_event(SourceEvent(utterance_id="old", revision=1, text="原文", source_event_id="one"))
+ await asyncio.wait_for(started.wait(), 1)
+ result = await rooms.reset("default", 0)
+ assert cancelled.is_set() and workflow._tasks == {}
+ assert result.caption_count == 0 and workflow.relay.captions() == []
+ assert workflow.source_event(SourceEvent(utterance_id="old", revision=2, text="遅延入力", source_event_id="two")).status == "stale"
+ await rooms.stop()
+ asyncio.run(verify())
+
+
+def test_reset_does_not_edit_native_history_and_keeps_receiving_new_utterances():
+ async def verify():
+ server = NativeServer()
+ workflow = CaptionWorkflow(CaptionRelay(), None, {}, editor_transport=httpx.MockTransport(server.handle))
+ rooms = Rooms(workflow, lambda: CaptionWorkflow(CaptionRelay(), None, {}), RoomStore())
+ rooms.start()
+ try:
+ await rooms.configure(None, None, ConnectionSettings(mode="client", editor_url=editor_url()))
+ await wait_until(lambda: workflow.connections.status().state == "live")
+ server.history.append(speech("リセット前の字幕"))
+ await wait_until(lambda: len(workflow.relay.captions()) == 1)
+ before = list(server.history)
+ await rooms.reset("default", 0)
+ assert server.history == before
+ assert not any(route == "/push/editMessage/" for route, _ in server.requests)
+ server.history.append(speech("リセット後の字幕", root="new"))
+ await wait_until(lambda: len(workflow.relay.captions()) == 1)
+ assert workflow.relay.captions()[0].text == "リセット後の字幕"
+ finally:
+ await rooms.stop()
+ asyncio.run(verify())
+
+
+def test_storage_failure_preserves_captions_and_reset_generation(tmp_path, monkeypatch):
+ path = tmp_path / "rooms.json"
+ with TestClient(create_app(environment={}, room_store=RoomStore(path))) as client:
+ room = create_room(client, "保存失敗の確認")
+ client.post(f"/api/rooms/{room['id']}/connect").raise_for_status()
+ receive(client, room, "失敗しても残す字幕")
+ before = path.read_bytes()
+ def fail_replace(*_):
+ raise OSError("storage unavailable")
+ monkeypatch.setattr("app.room_store.os.replace", fail_replace)
+ assert client.post(f"/api/rooms/{room['id']}/reset", json={"generation": 0}).status_code == 503
+ assert client.get(f"/api/rooms/{room['id']}").json()["generation"] == 0
+ assert client.get("/api/events", headers=scope(room)).json()[0]["text"] == "失敗しても残す字幕"
+ assert path.read_bytes() == before
+
+
+def test_leave_disconnects_current_room_and_stale_leave_cannot_disconnect_another():
+ with TestClient(create_app(environment={})) as client:
+ first = create_room(client, "一つ目")
+ second = create_room(client, "二つ目")
+ client.post(f"/api/rooms/{first['id']}/connect").raise_for_status()
+ client.post(f"/api/rooms/{second['id']}/connect").raise_for_status()
+ assert client.post(f"/api/rooms/{first['id']}/leave", json={"generation": 0}).status_code == 409
+ assert client.get("/api/rooms").json()["active_room_id"] == second["id"]
+ assert client.post(f"/api/rooms/{second['id']}/leave", json={"generation": 0}).json()["active_room_id"] is None
+ assert client.post("/api/source/events", headers=scope(second), json={
+ "utterance_id": "after-leave", "revision": 1, "text": "終了後の入力", "source_event_id": "after-leave",
+ }).status_code == 409
+
+
+def test_invalid_or_read_only_bookmarks_do_not_disconnect_the_current_room():
+ with TestClient(create_app(environment={})) as client:
+ before = client.get("/api/connection").json()
+ for url in ("https://example.invalid/", editor_url(editOnly="0", readOnly="1")):
+ result = client.post("/api/rooms", json={"name": "無効なリンク", "connection": {"mode": "client", "editor_url": url}})
+ assert result.status_code == 422
+ assert client.get("/api/connection").json() == before
+ assert client.post("/api/rooms", json={"name": " "}).status_code == 422
+ assert client.get("/api/rooms/missing").status_code == 404
+
+
+def test_corrupt_saved_rooms_are_not_overwritten(tmp_path):
+ path = tmp_path / "rooms.json"
+ path.write_text('{"rooms": "broken"}')
+ with pytest.raises(RoomStorageError):
+ RoomStore(path)
+ assert json.loads(path.read_text()) == {"rooms": "broken"}
+
+
+@pytest.mark.parametrize("use_default", [True, False])
+def test_reconnecting_after_restart_restores_hidden_state_for_builtin_and_saved_rooms(tmp_path, use_default):
+ path = tmp_path / "rooms.json"
+ with TestClient(create_app(environment={}, room_store=RoomStore(path))) as client:
+ room = client.get("/api/rooms/default").json() if use_default else create_room(client, "非表示で保存")
+ client.post(f"/api/rooms/{room['id']}/connect").raise_for_status()
+ client.post("/api/commands", headers=scope(room), json={"command": "hide"}).raise_for_status()
+ with TestClient(create_app(environment={}, room_store=RoomStore(path))) as client:
+ client.post(f"/api/rooms/{room['id']}/connect").raise_for_status()
+ assert client.get("/api/session", headers=scope(room)).json()["visible"] is False
+ receive(client, room, "再起動後の非公開字幕")
+ public = client.get("/api/view", params={"room_id": room["id"]}).json()
+ assert public["visible"] is False
+ assert public["captions"] == []
diff --git a/docs/assets/manual/00-home.jpg b/docs/assets/manual/00-home.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..ae0d5ddf430d82fa9dfa28a5a427d6316e7520a3
GIT binary patch
literal 32310
zcmeFZdstf6)-OzwHffW_)M_-*7`t^x6OATB!6;tZ9WQMHT8l`$pp7OdC|GZJ*R<|b
zMbT|-qTsE?1Qir(6cN#w#9O?eA&5p1sTlE!i1)jP{k+%jJo|g!{l4ey=R4ndy7+@N
z=N!+RbImp8SYwUfZ>)p22fqP6zUlm>GvLr60N{}72RIM`ZUBzH_x{oM-#dEr{iDZ@
z9sS_=$H$L<_~CI)wNoE`tgU(GjJBqhmX6*9eH~rHb6Q%TUjEe3$oP`UrL+2GSIsV7
zy>Ri;#lLoP=-9Di$3Hl(as0T(MI9}ji~r^0;5k73gCjHV|9s?-0pPIup(E;t4%z{F
zf1T=)Lw`L0|9l*I@944jKR9&wLsc{EW7Sn0Iehrou|tPX9DV=Ddq)6=4j*~%ef6WC
z9Mkv%5T3`^H2B;-_s2JPPG8eH^CyI7c*J)<)e1f^w6Og8sZ~Jq_rGZWvF^eRN9055
z3srZT|2E3MjP}=B^?x1vUu#DJA00WQn&uI8fCFIr@xRpn{{N3(fn)8~d!H)tc-#VI
zGslyK7^PKGJ5jw+@Ya_UOhJ0in==Q1wq(=&y!q0}#r@BA3KA`Lt)#89_MClt#k-V~
zn>E{R%#hQdU+iW29~}Vxtsnh=
zll#A6H2tWsE?@U^aX*i?)L^|luUUjnidlJis8JJYla#!HC6m@mx;O1#{QYlOo{hA{_Ln
zXdgjtRK{xpsh#Xi2vhUznjqcy
zGP%uam1hVobeHSMl6o!Ot-!_7OH6D*_Nzr&P~4XDZ}V-_%uE|Msc(tta4a$dqz6H^
zW~RmOgP){!BTgfofDlK4I?O{3*>G&{6l{mI=qpR1cAw6Wl|N&zTMj>nq{!~=fGg-N
zvm2rOb9rtrgW__s2+!>wx5kg#W#-q6QH6z3yy!7z1&xA9A4j7TsD{$zY9*MI@~8fx
ztDtkJ8*XjXsTk%2ini-=!Bz-g?AsCHATjG*ycer#_R{{p#2ZV;bi$-}lxlg7JE-|b
zQc74L474KX?e%a_q@6?g}3Qh6a$KsP9QImGe|T@fDc6WOlvm5
zgCGAv_wY((XOA#MXewBmp>=5C1QvM81_jsd*q$KR?&mk@)SQiKc|kEEcZ}W0qXh+z
zutb!l0I{VIODUrmRMOHZ=)g&yr=Z~g@M#j*K4#YHiT%aS$?TI|zj24=UkmC_nNDU=2`%`*Rq!(hdnIgNcxJIu{3QKj(*VikFmogvnG=)y?
zP8Q7wy;{h6itiWp-w%U)VW+<69b7Zb3pw%0n7G9k4vG-yt<)2Gi$$}FvZi?&dDtA@
zEN{7uT+cZG@D-~A2Y?5*hyy^m_yAzsU#zQiarTaJ(vI3Ud(qK5Bx4AKo$m>gE65wx
zVG(kT?G?h2xxEu!0@mKO{<1Q(SKmu+>je=aOoM&5YZka%GL$gonhM&xQMQ=2S(gzR
zZd!A^In%v-l%wJ3$F-kAIPPNPWpO#%CfS?LB|pV~E~r13Z1PGvuH9ctXu{Uqpvg;v
zsTqvmabkc;&X6^&A|s<@_N{%o6mR=FHYDA$THEs#H_QP}rvNKxLWC0>5$+fU9MP*&
z;;!V!dk!rqjlbAa54k=F<9dzvCSN3v2g_d3(B#r0SLGgW`te@aWADa>7KhJx{LR46
z*^V$B+LQRc1ScQIfqT9Jy*i+}=B^Ps`SVei{&OeZ1f5lCpHeb2tvB-<^PIaF#u{I>
zv+zw}9Zl=Z0uslB*f2^?CvCCgeI4G6Kgr!6h-ZI-zQ_0fcmh?UX1?a(yn&^cFqvOu
z`}N=*H*mIj+o{h;`oARI@DpxB1R&Q-J?q6cY)oEd%vG>^u|Z>`%Jl5f0Fwj2*!bUX
zhW;nXL;H#M0ix^LX)}W?J1ZmElgD0E3p0Ty7_sm3upQy5)Rc=_W9Gt#Pw{DU@sD6F
zx4vj`l=;$%LVb3JFJ{oIsTffmUh!I|(4^SGyc#S^0%MDAUV#TNii;l#VFe#j1R4FlY$VCI@8E))GtKj5_P7i>rs5bkknewp=a>hpGLNWKqw5{Lyp=-Zh
znGT$dV_&Uuw=%!$L}_ZmWN%R#M!s8M@BJ9jl=-ap^cp0nadceK<>&#h)&+umoWoP^MITi5-HWu#6N)d{J>FBO{ND=m`fZ{OMv1LLQQbV)TMZ0;=Dlr#5rB&l7#5YwI5T(W#O3!d*QB61`(aWpvLSYPKRme3s**7gHGr?Xztf#xbc6D{s@ZKVWYw;
zy=9%{;(6w9bDtyP-0E)1L;b4}&aU{Qo+r<+rbg&OYtMi^GGmJ%LmO1=S<#YnBE6(H
z*A#a<>wXT7jfBn6Dc@e*Zek8Z!97->eXe^V?qXhAMSyH+O;m7ZJ83@Fb7AV6*|)55
zuI4aGLEseTX;rt&5g^wU-swbxZ}cs&v1h&gaDA{pb;NFgrDVD|N!je=egJ51KLEt#
zr9RBe%*f3}a|zdG>DNr$I_ae%8;;=WC>hdKeU=7Cf1r?nDGFmb%_BkI!CM$*fz|S|0wiuN4PtI;0Sj|
zM+Hde@WGh9@8H#lsQJ|q9t+GA;xlWZeQsP75MeR0LJLS~$x^gjn)2mM=y_in=%!SA
zv$ZcH3X|z3H1YOjgzdu-no;~KdGU_)-t+H%jfyz{q@M#G0O$b+fGtc?-)2x*>+WY0
zIeT#J13>Ss#c%#6)A1h^^+C#kt$DoS2B=ATK*LmOnzLlQX6>7??e|#2v78qb&RE(2~vV
zq3ClZ>V2;*n^qUdY`hr~kqJapOqErO9$~lEHx#v$BN9Ty`p3Og>iI98}T%^&Ns8P8@V+6=|p?!=vgjdZYMqWT+IMz-~Cr^lJ%rlf^uk2+t9CTndG7HNHYYQI~eUDuxv-DOPb|&0?UOOO>FTWq8_}A
zN4_`kUeIs;btrm7-P4QAOvJJ?-vR_zho+b$U>6sXJdVi5O@6CJ!e(R2PS_+DmXc|+
zXKvpfUJ0E_FV!)Ghy78#c+?%{;R#J?xVgEO-9k}eqt!(=nx}z^76M1qp@hE1;iFORIvbyP
zozeLrZO0))IyL`xBO*M$C_5fIPQ+5ECR22~@o`>xO6u&V`k*D|gZ8no*RD@qH1+3I
zV78x;5lyQ*lpjF7mg7{Daf$(*Y8abN&v|21Dy*E{)OkQUcIr>%zmQ)^eS90}{XJb=
zu(_j~Ldd?X@&zmgG!>$4`{##Nkorr>>=07CX}Rv7m^jS-fIRPsbc~^`Qxi<1OO4r&
z3gpGA{pn|Qc4@pWP2gEe4|jMUTjc*_3g(^)%istF8bF}}0R*0_)qn~-#VelT0ml7A
z(SH9q5HonsNa^fc)5eJhn~Ah9v7J0kGd26hX#wIU8JKPWp&7-bi+eZo)9REqw}dv}
zH;axK&M2>N(A^~r2^Dzo_Xhd#G5hU_r6D2SNjeRr(sC4+AZ+eSC|L7lL6D9rAq(iP
zk<~(Q()lRsHs4c>Va6R~aWNfc0kb~K#xQY;5#(jK>hYj|c06G}LhV6nX3(({`Wjm4
z?3@5GxSFpwD1hSBS0CK}4>tCH+@wGK3h+u0G5>r}rGx?)Vp2?%TMEUht<&!IdhqG|
zz+gn3IUELhhhoY-1Y!-3zCIUWHek-%|BFq+YKRS@&r7gc(OU=WyBy*nrZxL9-=Sob
z>2W5VPKzm#Q&aNPypMzrZZgLi<>Ap@;Soi=KnHyjp}GR@qzMzxlJ^Xn0vsyU&PnYY
z^wXB>&wnaV$T0a4m|nIgXp=?Yy`^Eu85FchMtL13M@YXvdcBkwI%nf*o>_*e$9S9D
zb+-;Wjc_B@Mo3M)5Br=~*ms@z^{x`LnzqE4!e4?BvqQDO8Zp}n`=XcA>h%CIYHbeF
zb?Yom8(_040DS@$lm{NacLpgFo_%Djv+L-%B2o>Q5LnkxAkQAIWhz0?*{
zBENqAss+J)cn_Wi1NLfHw4w-?3iBMenn)I0vu_|KFdHC=K5x!nbJd<2R9<@;`@`jT
z-n6EQvI-i5V-b&USMW|dB0L;%?2tbJLiO|x0McV0rOXwy?tA-3+Mk_K8~{GP9(Vxo
z=r{l@zu77Hj}`wP(t4=dV*AL%pJr}dtvQ)nE183U%0Pw}{P5T#zeCIkTUv~RrF=XCaa^@$U1o!_T_w*mx=}`xJ|J1<#(vH6z(J#I7qITL%8acHIww>Me0syy`
zcXiK4?Hm6t^832{t_;6#l2`voOZ1QF`w%nyiuUZT9Wz+R6IVrFj%KXg?xYJfd6q&q
z^W7B-4RwV})E8i2^-{{2Z$p
zX4eK<5_GDHMD<W(Z=OhnH`p
zlO`v0H-w+^P+8p0Hx`Yi
zsk4Li3%j~;2v<*-mbo{xdiuuzY|gvofen`U%Fmg|Sho9MWBzSU=@Y*}<{Y@55yb;z
znRHqJqt*gwQ7^A|33W*pT$K;D!=X+HJV(TD$gYD27sIQs@~!
z5KIlQ>)t5C{}x%2Q8BD+GM7HHdQ%(fC$)<-S^ovw?*xK@MAXXBVrl?7MY`P86_4^S
zduG}(>H4u?t=X<}er8l&eE^t1W%tbN&n|9t3Y3w14nOzc?s&EJPnKM6NkgYovl6V6
zV029OE83+Es^NB_v6J3;Hy74?!CT5hFCAyJla(@@Q8r$?DEHv`_mCH|7v}A|pv*9-42&Cj|KfsI{=mswfjQ-)u&iy!(UL(a>+l2ByDrVlYNpFOGf^KjHN
zV`&lIq}c5!r^K>Q5c3r`w=%H*^!#bL=IE3xJ-z%9c(i&_1(}J0pf>B(32=VI8kxTu
zvSowgKI=`fa3~>D=o0q%fDHN8`YwbJndyCRXMO$^ubsaX8v++WyM{vqMrKZ)gmkV7
z_4A>u%b9@i1e!p^w^TzEH>7BdE3-P!r
z-P1mG%rSbHyN6KWc6q~b_q^4)rAMugm0bX-EL?VPl!?sOvM`s9mc6BBdhie~c!7pq
zUMpcB<(F-fGMf2i+B3uQ3?s{humiwX<#||cO3WBJ`#HfZ##>ot>ORC#872Vv3O0|ATb3)9fhQ(hg4clixv`uODWq5Nv(
zLp+bM`p$<#@`a;7j?lz_KpeebF=5oakW?1DX@h>>!r4fV0+ho&6hM_()E(#~+)q?=
z?ipjwCYd7&J>9&XEM==Xjm2Lii!8vEG|6S0L>&Yd9RPl;T#QXR7qWZr7s+r`=I)m-
zo77O&nn8ErOy74*`54i9ZfZOwZ-l2Vw%Be$W$W`74gmGIF-ScAa=_R`cOP?5ltE(%
ziiaZm+`1?RDX=p940brm&c|yu^|3X7GvNWKfR&(8wa3MV6#9%T%&ljLlFC!&?&I|=
z{DhS=L2B}aCIuFO>L|)0nPAg7E$#z|XMW>er1gmXt34AYu_5-cfnQDbuu8sI4{q^8
z8iSRRW}KKCHmkJ=(lZXW3DO8Riuq_Zylr)i<62nk394w-Hc6+IY>IGFh}CGpmZhJr
zaApwm+m5Y!XZ(2Klkv`ey6j%dO)g@LUPPp3W6P6v96n3ZU@Bc5j;;o|aw`O=x1BFp
zKztCEIYz+{F_MWExb8q(gKvt1$Ly`Iq>Gw@<=96cJ1)2a?+z-Se=G-r>|y$G!VnFZ5fRR0Oa!)+FRi)E9W~>!qaEe^z`Y1O~+-yUQ(T2
zA#`i(*3YxPU+%wwmxnZhBfp)W;K{^qC7AgjOooD%5YzxJc}>_sUTnc;K4Q?g(On=A
z9May^e<3x-=S?+=DHgjO&HM=}K!EPLYe2gapik`fsR&YqGqWps@+j5X}r@
zHC<9@WmGMzpeO5wiPh~|>aOqte@T9C2;|#x%bm|?A?Fhq!^{NKTpWWQLmo9v&zAhf
z>WXOFVWpvT-zW$9-5ccj*&>aX!nqiQcS~M;M%G8FC~pKFn!v^Fmb@jG=FbB)eoI-^
zE-RJksK^QLl5sidtNkCpuCKQ8lz!xU>voZYlcn^ogcia$Z(u+SFmAw>s0=>0I_TFoMM|?EEU91H%rvxByR4@CQOnJRFg?lY
zdS7y`g{WDsw{4(0!0DU+%TKpcGI`=pFn8U7yN=0qkQ>{#jQ7u_;B$6CNr*${|8(--F6+#3@fl2d1)Y+BHXvt+=1ng=JOG#`>}c%Yy#M!KhBDgq^lMh=
z4u?|mFe5)N;XDwJOddlHU`>hAjEsc>S$gSwTKy4iW7n5G0=i)NTczTgVHc#QU2l{S
zk5N$w9tGlBUGh@CZwxVDXypDfyAhxD#S519(lbmyR02}#d;Vqr1=fQF4c`2SFd%-tvr${*YS580>0^
z56&RQwbG6J?w>MM#YIE+yh&~lXnXenb-*1qKP2U3CMbGEOXKLGAz;+i?w&F#eAK
zz=!C-+q@1gi5xKGY&VL|e8l9Rc1KxAG&Dx8R-951$M9lH9~$K%4NRj12B&X1I(+u`
z>%!lXj94_E)%}Ve%QbfGsQoTJ%V)D85XPWHu6@wb+tL>+BNEEuB(VkKL^dTs~6
zJ*6Wy3iA=V-QMkk!bX+)h1It
ztPVdAA%{0BmN&u1roZhjTDEo)f`9S-oV&gj2-is}1o8$Eq=ZK%%*ukYBv}xa
zK7MIb@2mHorc89L&l~`nPXFsxI}JEPVJ$Q#Ss1MsW;mm9+(<-Kydv72P_bBEikXs3
zH}t7}B88e8znQ*r+}xXs=hWq8#+UfKWe09lkCjh&q^wBveq6rJNVSC0E!Mt#9U=tX
ztf0)+IioyjYvH<15MDUUjxX8|b8Vk98zPA#GAF50iMrv&rY9JU<
zA{CSf=UG9lGKdWslBW>89yB*va2nw#)KEv*DYx5XyYsPH_4|h1uQy8;of)}wAzr-r
zOuVzTsSMJuDvau&Z!t1tG;4!&$+M)l_oL3gFO}agPG<&tC4SyUDLymUF3iO)4oBd9
z=S?yRla!cu>1A>0CEcQD7p5_`k?k>c(Y;=pUTu9{t#$;vz7TS54$xAR=^4znL_}D}
z;SrHdHgkday(jz!bj*;k+aTy<7&I#+s;$)5-Vrp*
zb?mhsqz0Kc^L$+B+?@{3`f)G%T3k%%?H2qX-*ZP{yQ>7&yR}&8;?;`ztsjS*oNg$t8>m9cG`Z4Xos{6KE~3mD}6h+LbhkoBmbz)JZI7%WJfxxXP=u%<3o(I!v+v&(o%KJIBPe
zK%hs`d0GwGwe-oBcPTC(@Y^+&LuE1U9k0sHZ}`LJ
zH>?AMJ;7Y{9AUfrY3D%%P~q01I}q9yD-3uy%K@U-MA|l-0uFl2ms!%kjVUOe+j16&
zmi~e{lVq^g5H;H^xHi-JFaf)8yNjC~Dx%<_jyy}bl@%KzSR(Czy&i3EPVLt+6GLEw
zk>yre*MKHF7=gvK2emQqsD;kT>~yUwvUv!dK-xe8}um)i*8Wo4i3_uD(IBX
zw5C=dV_bPJTT(MUowk>&JLx$S-{ZE5pr-$hCoPo!kJ-G&^_L
zr^K7nKsTZXCT(FCw=N)TiWfDch1ND&PlCQ043+s&rs+&F9mmtE$i6A7EV+pjh(*9F
zN1zj;M(;hwc1dcAp)1>oXhN;>W5=oJ76EZKy@eb6=Ju{o1slJt>x?`%#!f9m)n>rP
zig-4~&TABF##|-i$4fZ`BLan9B5uvQ+^;F^-5&bI5A0kT(K#3iM_Hn#4gg}1JJe-n
zDOwCM;d({_EzQe}ja@UXLPzUB5ib5Ynta=ba1l)1qXVddx9qt1{@+eoU4aeN1-GU}
z2#LyBy7_PbH$lj=SK#Jz?TTAJJi7goUFlWh)B2>t%8uG^*G!=oWP8z?7&HUpq>XX0
z|EVnfr^*yuvT%wcFBw?iu04!cOB@qLC>nNl3E~NCJvKf}YfSiUJ$JMO?0T}L#n@Pa1G+%oi8#wF5w%7lU$s;n(Ndec%&e!Q&v&ap+mxls2tL*1;RFxUz7JFfv
z;2iT5wVtVEGs5u|FJ@$LJjI2(LBR?|nzC&he;563ZhLTa?@1oio64({m1*_4D)Gi!
za0`eKiC$s9{Pg@1VA`hq3+vnQ4apa-UoUDLo@1T%?W@IO(>Irg3FMqIt1H>~fNvY}
z=;O~BiK2&a7Qlf4o0eVmSi4r*|-q#E4+zWo5AJ2P77%O{w@@kU`V4L2Nz9*3bDvt#!Nopo|qf)}R>7_Hk~6Shrj_Mdk5^}fn#ri2d1PjMp$B?TpTZ%oPl7qm;|
z7|HarY;ppTx`}UE9$oJcp{DR-reQf?-zB=?x_#??l^E-%*uf?;r3dOX_ZL
ztgZ8bMnm8fFM>e^)8~?JXitOBAy=7L;ugwwI{XExFS8WuQQX9fXz{4o$XI|8RckMh2kFLvv
zFYIvetY4RK{Z7rc3w=7knckNC949+eAwtpXv4YS*-i6Ac&~}1+tRY5Yv};fyy)B5o
zJQ_}CyTW#TJcgYzm<9nx)>L{qhNhw|GlB~qu_|UMye!y>v}u=~LCbUJZdtw?CdKnC
z9!8|6XGUt9(gGx0p2Hf!g|IUbe(FQn_z;Wnw#hDLg>_;*;%c=0Gh)*B6*MAN63?Lq
z1WU#;WF%_BcMZx@XMUUUI@|EH>fX4@|M#Z@o`IyGft36<;B^dA;PSn{rzi+8<$4Mp{GVziGla(ySg3P=?jXiWB76{i?&
zSQz&G`7Zh$Uuj}i;s@R9eWDn%(Rr#ES+%Bx8}9W~_9D4{qCP@bThfae%q}b~57rY=
zefOKYqTcf3&56W-5SrYh!=rN*=FtZOIVv=s5*n#I@9HcFCHWV0zq3H9M-&!0KqltOFYRaY}dl|3iXSRHo=T_f$Y}&R*+BUVQ
zJ*_2K`Lec|!H
z+kX7x`%9cFZ3J@#O0GJ@@=J#GSFMgzG|_);32@3E47O(r|U0+GR5;W@-
zkE({dwD$<)5*m*eq;Zr(p)=y>;!%_0ecg6>gZM9}sA;@rcNLs->Vy93)Gm$|OV{&P
z+Ik*1)W1-3{2h%#TXhz$gbg&SQXNL>5+~zh^S-zFqtsV42G6UUdnC(j+S2|I8NMf2_jNmeNUli
zZ9LR)|MO-Z#J6|ya*~gG5o6O^xT9q@jIbSAfJ5Nw>Y|37^;A`)%R0w3F(~)v8F0O;
z9+O*ytP-Bt^bB>|=`m0taLJ`-GPe2;03RN6J$HEE%dv!)r7wzgGdBN3?&;@-sfl++
zNvFl#HSqy-4n~66C|e~>NS^<%EBdjOh(>A#Js@Z`Co6UP6IsiIXlMGhtaU=PV*L8_
zC;xo%-z}@tr+N%2Q%!M(&oGR*oMFy4fB%g2FNTc0U!^>CYs}rbCKn9iZri(-rw#hg
z&6Yhn0JvkxHTxNCXjtn@rkLxGWSuvjQKZF|dcGP2RfTZ0pI)te&Vl;TiD;o!z=9*L
zzJ0|d(Jkg1dx!RpBDufm34PbPoRn+n&)Wy_ST?4ssL);SUX-|$z+uFWl1pyONZiTf
zHbFkO22=2GLfqZ*;1}n6TWnHB{6&@%!YMk^j}}xn1zlH+$>YW}+TzB5E^64Mt2nh
z%>ymlsrQvh3!&8(M1#y+p`XC=gY=Ey;)b&19zuG-mLpCr_swE1bt&cZ?eW~7--%mn
z9^E6F2@;ILh7qF-wgnWbQXURADC~_-)~XqQ&j;48r%GmagdzO777%CgGZnN!?LYaV
zE+^!aBMU3e>amcwqnOn-?jtZ1OGSSlQ-gGjYM+}>4!CS`IKEdrqY>};sfa3Xsn`NW
zk866nk3@@bN?h@2>HL`_OXWSL0jJz|&=A&1p$p_Zu20xVy&HZfrsTNF{X5g5D&N>rWsDMVQYy8Sy?BpC!T#7vj~fcKA}D&lL<65
z-BrM+kt*%Cm6
zKM%Zk_wBJWn4(iJi$3r0MdhIf)WeS=;veYvA~kZs)5)}K*Ujuvnh_z}D@_HakHJiD
zwhO)u6@;A75`u9)3L=IEPTxx?AU9i3gF*%@BuekoQ{8-sXrt#I3+U2JT-`+wHycaCxYy<>OjHp8rts>P9%?!IuLi@pk!TtSj
zSPQOy=qc0ws+|i&G)iJK%9G!Y2XQfb{xI9>BWY1g{dL9L&7UR{@J?P{x<~}--Y9oY
zP8OxSK7Z_3aFLs>Zbk5JIKzwA+cGri)7w`5<1-pPE}*iwOd=;QZiTfbe02brG0NXF
zn>?jl-B;^8@^A)q0yApQO0D#f;xE3c`D9IdmX%9}5#}jDN%ZV5#?LcbXiLcVmFH9R
zLh`F8u~u>?J-pKhQx)S1;Au3kKyezHyM}eR>7+fW^3?GeUze1l>)a>O>9Lng{O!Wk
z$OvesU_=ZQk3c$=8cX*hO0sJ~_CLmdR`%E|Mop%bk%|wUiOqM2Z!DIEA@n77t!E2H
zgYx4RPxW9_8iz@z6_BVZAUkd5?>BOPTk`ew!pGPsvp^eOJPKLg0^SFMlTlVub06jb
z;4)u0LPRriSy77m_6@m4eQJu%Vrr*1xTW|y1sAvGPc)j|ky{ycK%6B#96Ti%IPy%M
z{p8l6MTR?Sl)8HN$dq
zB2QIz6%xu-R=_x(N}nTVcM}QZ1^Hj*3|%J7|0q4z;*yK9gf&!cvf@ERPV`i9|160szht+hC;IozT$9aG_|
zoE|8@d57N^?cUd9Gr4yoJrXw|6Y;Uk=AsI6T}7XmCe}738Wo~EBAxjzEj-=!6`byJ
zQ}Dl`_fP&iIQ~h4fiJ)&J-zINTYYs{VRL4|29{K2g7eLc)C^Ov?-RNui^BGP6L)2{
zHHpPv?-PvhCu7fUMut__AzpEGk!~Q1(=Mubf{DX=i|sDu+ogzWAyZRzct#%2*Ih5S
zRpE9w#drPi6P#zJAnzI0C((K>k+ugQ2Cy-kbgHtudc$facE#@*>1NSe7Q-bxbtu
z>jYGNG68(*WO(b+qmKC|`$D-ox`H-kIW1aYLNcqc+=
zC#e8`8|Yq~2m0V)UUgT1FK4~g!MiYLYyqy!z>)ehBw1Vmequ2AFUvRPJ&Y<
z_snpWFD<|jw>PWGhqcO{-Aug)I8=U5$pc#~E30R=i#I!45M)k>jyy^Tl++6xyHt1Y
zooYqw)5@{dTGz}HaEJ~q1~mXfG(x`{2)f&0DFnJD%Ilr?UNoHafld0F-9Xj2c67bs
zxYP?XomFfF&pBpc;+jHt#ZeW7#XXZ;|2p<5F>Kn2XJOAPvUhEmdaJrFW_9IMd0||J
zyms2r3
zfp!Q78&LQY0tE_F_vjai=vHraudaZqV~#i%YEB~)s#wP+^@4BqRcavPM*
z^7=4+uz8BsOu_ZHYy}$T`82d2)>JjZRO}Rp67ssC%Y5Cg7RYCI{E4|DWZ7(fB|HD2
zM;N|Ph{W?^F0%2Jqm+4O0VSA*Hpb8cAQyHj!(DS})BWesu&D8}yedlQ7&Fs$g=Kdy
zN?^%vZKHg1{;e{ad5OPzi>!&|{4^P@Rng)rgbv(`^iV}y!$58ql5(5n(B7@V#u{e<
z-mA>QoUVGHwYGpmm}VjsUy6yLse;T2R*Yc9))#g!rm(x8(`K~;#*XUWHN>MSMS`yE-O~bGhC03%S$jQBq%yTgy~NdDA>qoKnAOKpt-$$BgXZ&4QHd`
zira%gJ6gLxb!bI@uOsu3iHarIivmKDxwd1;X0Ml{#`<=X{*>7mn@{Z!HO$Z}rb|$j
z<-y}ETa}{xqzw}LSd%T!%1^-31^L$IcK5~u=gJI-RY=%KdI2?q*D
zAq_@~r)24Z()w;1B
zrou<`bt!vIMsgLW!L3a~;b2HyS#nlv!Ptei0`_Gj>1PZ$q!xt0GGYm{g^?cZeS&%d
zRFy~hX@qN9ecw5;t6c10{8>@b6$bT6|3gpvWXEXtmN_azfOxi;#
zS3lR5(u%pan;^J#^jNvkJKt7>==KI~giOQG(TbObY!y!n0@43cEcg~b2L_#Jj9r_4
zOQW0JMc|F5G=&m%WTNA49>ZB+!dq`z-M#s==~at1R`p$p(;c?C9PPs88pHmVqJEu(d(|Y-%ud@HVF#
zi{XF<96+EQ5nKWkpPWXO7rOM4lz}0UNHF5udZma>p(g`%!`L(ZhdQoaYJK4PzT5)N
zd6;aWKw9qib8MKSz#c-p2GU8dEZ|eq2q?+@sI@>XB*a*^U_UgX*w~J0OCiLq$
zJ~ShA9ERD?-*(w)cz(oxuzt)Jr&S<)%F?@`t9mn}n`A%b3iP>79zHbd*>RN2i55)HBu`VHX7G|B%1F4o_kgXYww{KTA6lHJ8U0aBFoaLjj9h-U7`h4rjJ&V
z_w=HUUE`2+_O734te1|nQ@ncniBD_G4LUqA)Twg<=hYP#P!Cw1Jw7fjNlq;j3D%Ny
zh}ARoXy=-TNMsHz+FH-o_f>XqO-YJ)o!~6a?bYoU4WJIu!xzgReix$ES(rxl^z#*>
zBWstKcN6rO-Sp}TS`a0{8nZ|q4SITB&tvrUHJs#yidjN3U(aw>Giw5xBO*-Mh)7M}
z@_b4L(=>aOYA7z2>76@vWstgV^pLvLfG@3dzKmJFD6|Ow)?AWV>jZRjhk4GHj1;Io
z^-wu(*pToC<^=XSMe#A}WibI{+njk;$G;99Il|a5x+$!5h}x`V$P<
zs~$Q7hn-RJuJ^1<#D0IA8q0DRRY#&c?fGm6tCpRyok+s6oO_&SRnIL#B&_36y{D%~
z3d3_k;-!+hw^Y1Od04`ufCK~M4YXkc82^o>`Kitxs>M9X!O*>nOZVZ1UGXTde5LyQ
zRRMiLfB@RR>oSADU6p#pqQ0lbhLEiK%!Y7Kym`RXSmxU}Eu*Uo{BD$8lD0ts4O=`J
z7GEPN7&UIN`B=@JzpqyQWGeWK?tCPfgqZh!Vy!urb)BU-tO+|eE?Yq&do2llkuZO4
zP_A9sjZHb2iPdbD}uGv$Maw
z+}!-P$+cW8g?>v?%!KDnJ*9)+cbDb~yIM8t>1xT%+5-X=N$jl(z
z4mj=GS>rT3R($yGY(32CT6lf0m0XC9qtdGcu;hi^7$Vwm`$Z)t>1z1-^Bm^g`9!^r
zn5Yoe$X+qpa{OlPB!(z$YEXHF6oULwM~B#8PMzOz&LzWXT$}59_kXl^u0c(m`5&j<
z9hvC`m*t`;NDD0@*HTDO0@_xfJC%TJIEGu)2{wTMiGn0tG}v)0gcum=2692D!6uME
zG(rp^1ZowKOQ2~8kc2?xqFfRXkqCs~p1%0+^uI55-F>rfa$cP?=b1Ur`JCr@=6Rm)
z@B2IB?Bve(Nxo87adu36Tvl$ZE{=4rBj7toR%hV+%#{sdJ6@|k%r!xdBmkgm%-Q$|
zD3tRg>HI@=i-l9hz^KH_E@ySBhFRgz4^(ia%Ee~THqjn1Y&-0OeHBrbk1k05;&No~
z;Y*)$(71~!?ADnH6+Q-T-zUGMgpt%C#wkr#Zt<_e52x7?9*f(s?#(SsR80i*`n;Tq
z&PKSZjo{XYa(`#G+Bif_ORhgLFyhUfEWxDnO&<@Qs9H4DeC4CX8TkjRyIQ)iKey>!
zpOfv#jo&A$^OEzL315Mk`^a!)0K6OzPG4y?IHrrHoghwq@OVge
z*p(GN7a!{%JP^AUl`sedJHPgU0Ri;8NB&`gv01|X
zK3EB~nft7LJVMKaC*xR*xSsJ!J>qe+jDMm+phh4@X;X>CbWR%tmdkhd1XU`sD;c
z&2{}3?MoJ~f&!AZh*;Z0{PMWg`4p6$85lq2E3mbjbaK)u*r_A&T>+~xkp!J&Ju>Vs
zcEFj>QxBew>L_~w>A$0+lm*1z0=Mtt$f~LLCWcB|GdqI9+-S!E3H8+Fj;-a?$Lwkh
z-xHsVtJS8hmych(;wlLJetG|(AXGR4>0cOlXbPKN#-@a*MwLV#FpV6>%SRH2B^9UX
zex0PDiYIy#7H=7O=XV28aGD>w%raD?$g_M{2Kx*q{a*wEa_Kd1<`9zW?w-S!}+9A>i
zA*wXT>~@B4)W13Qe^V0jKI!)R2P4&Yo;=kmu3t*2YR2Fkbv(`8CD5O;CzHiVBjbwD
zUY@K_hF&7=-TUNuce(F%McnaezlnB^+AO+yjb7}$o|j;qBA7`|f2RuetcuChi4D>U+f{`;j`B&<%zR>Ee%LibQ)=OY
zbbyH$xT=t6u-}EXW4|N5;-U*k;K%s&&wa0LO5AnzJM(~F-Npq=`?2LK2{ve)_FL!;
z?zu%5H8MH?B9#&O{^}fX`wCpmgWdM!wNHYB#P9jKFhY&9=qb)`J}=NLxxkq8@`63#
zuL88RUDqwi&-N;R$bfpY#fZ~&_}L_mr(}{jSv)MkUj6yolI9Esi%YykHqv}gc7;B_
zsH-|823Qyp`$i-&nPuK;Gw`;a676oH5|mNESP(pg7zG^1
zd(s%1QHCKgB*87fe7(cTA$1^TS}$hfyNO0jrn7jPZCVTHZsvkMnKo`4udv7q&6rAO
zGODV1iI0az)>93%WNI@0Oj098FQs4wa=ibz%q&I#K}i48vtVceuqr698-5U;S6nLK
zsEzN!_GR|WPquth_fo(c?RRzD&%(aiXm>(=N~8krs4nY_8$^@W{mH8
z27;jwOC96Hz5sriKBU)F7tGj-=rs5Cip0`b5sf#E+dff&%8dq`#(8gd>(=8i
zQ5TUp{_zRMl~hhK@#y|&<+$B9-!HXk$6A$`(b%KWkOUQ2|0!fnIS$Roq|F5#+m7p7
zIESL{eT7%U^FXU|Be$%8f3yBF=V7**sqlK>`B@6sbCj
z)V0!n*a@`1#_B6|vb-^aIhw}AT$t}GGb$qBB#aueLkHZHYnITJUAy);XSlR&F!ydc
zKtEkkP@U9qe#js=kQ;4|3zQ`g*1kP0xRX%`u$G2~yTu_|wlWHtQMSmF+-ES2QyH2b
ztgZXov{28#iXSG4qVp!msjLNw7|QSG9xB7IIPBbIqi)LawM|O)^_%bX+C9&j98xY%
z_Owu=w1iZNL+$|qB63J=3>QJ7ip`(PrdM|{!BzZ(>%fsbM5d4p4M5~P3&g%alQtgO
z#!YX#MRz0bUVy+%3xX0-rtt_J0NXy8U5{7HhW)VPqw<^1
z&_IyHZ0w8~UY?Q*fy*0jJ_UV1b1Kc&o!b}eb~Te_hv}%LLp*loeZHiFT%+7C?UYcs
z8WE)uy*{CUnIL<||28GTw@Ki83@O}(GA@h6o9H7!A=mqF7+CeNF?{mxZlrpgogh80!9ZFE`IG6@JhY
zAtn0!Btkcp2~%Ei(z)Q9KvxVER~hG@-umV?HvLGL(R?^jvyWV#Q<14HPnTBX=j>az
zG0Z9at9mNo2B$Vqict_l%%=5s$4~J&>2o5$2@XRXlR1Q|BeUIZ*eo~>0x>b97`!Dv
z`2bX0Qt6x1OO>Or#SVQr@cT1V4T3?g9rxq^L-Y
ziYiNb#MTm5?}S9f!yS9p5{8uaYx!Gy9Om2SWWn6UM2S#e-^6`{;x*50D)z6qM+e-w
z2BaPXIzJlq>v4muJw@ZFqZQmV9CF?DGR$uD78xqLf$t8{
zOWl10rIW>-Nk9HxjM8KlESEJhcN+L_oh%Y|jQm=53
zJlJ33^zc;xAvab6G{|t->W9T0v%!#DY0
z5oMe=qrgC5{Tj
z#4>z}kjdry(54$|Hy9fax89;sd1t5L!PF8O8VrT;0;LSC=RMDRFuH_>*4x8n&;~Ay
z!}9p>W;)as1
zyg9&sRq}1}F!q7O^l(jM$cOHXC;U-f+k2H@y!zi<+OERc39&CzILyuNpxt1*eBcjhCkmsT3q#_&Jw3;%(F{>J^>TF^?sO2A6MO2A6MO2A6MO2A6M
WO2A6MO2A6MO2A6se^0>uwdU_ByMzk>
literal 0
HcmV?d00001
diff --git a/docs/assets/manual/00-reset.jpg b/docs/assets/manual/00-reset.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..18f8206d3d0607b802321e55543178efc26495c7
GIT binary patch
literal 66680
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