@py -3 -x "%~f0" & if errorlevel 1 pause & exit /b
"""Set up a per-user Windows relay from the files carried by the launcher."""
import base64
import hashlib
import json
import os
from pathlib import Path
import platform
import subprocess
import sys
import venv
import webbrowser
from urllib.request import build_opener, ProxyHandler


APP_URL = 'http://127.0.0.1:8765/'


def relay_ready():
    try:
        with build_opener(ProxyHandler({})).open(APP_URL + 'api/options', timeout=1) as response:
            return json.load(response).get('app') == 'iermu-cam'
    except (OSError, ValueError):
        return False


def run(payload):
    if os.name != 'nt' or sys.version_info < (3, 10) or platform.machine().lower() not in ('amd64', 'x86_64'):
        raise SystemExit('Install Python 3.10 or newer for Windows x64.')
    if relay_ready():
        webbrowser.open(APP_URL)
        return 0

    content = base64.b64decode(payload, validate=True)
    version = hashlib.sha256(content).hexdigest()[:16]
    folder = Path(os.environ['LOCALAPPDATA']) / 'IERMU Cam' / version
    folder.mkdir(parents=True, exist_ok=True)
    lock_path = folder / 'setup.lock'
    with lock_path.open('a+b') as lock:
        import msvcrt
        lock.seek(0)
        msvcrt.locking(lock.fileno(), msvcrt.LK_NBLCK, 1)
        for name, text in json.loads(content).items():
            path = folder / name
            path.parent.mkdir(parents=True, exist_ok=True)
            path.write_bytes(text.encode('utf-8'))
        python = folder / '.venv' / 'Scripts' / 'python.exe'
        ready = folder / 'dependencies.ready'
        if not python.is_file() or not ready.is_file():
            venv.EnvBuilder(with_pip=True).create(folder / '.venv')
            subprocess.run([
                str(python), '-m', 'pip', '--isolated', 'install',
                '--disable-pip-version-check', '--no-cache-dir',
                '--index-url', 'https://pypi.org/simple', '--only-binary=:all:', '--no-deps', '--require-hashes',
                '-r', str(folder / 'requirements.txt'),
            ], check=True)
            ready.touch()
    return subprocess.call([str(python), str(folder / 'iermu_web.py'), '--open'], cwd=folder)


if __name__ == '__main__':
    raise SystemExit(run('{"cms_recovery.py": "\"\"\"Bounded retry policy. No camera commands and no background lifetime of its own.\"\"\"\nimport time\n\n\nMAX_RETRIES = 3\nRECOVERED_VIDEO_SECONDS = 60.0\n\n\ndef supervise(attempt, stop, seconds, notify, *, clock=time.monotonic, wait=None):\n    if not 0 < seconds <= 1800:\n        raise ValueError('Playback duration out of bounds')\n    wait = wait or stop.wait\n    deadline = clock() + seconds\n    reports = []\n    frames = 0\n    retry_number = 0\n    reason = 'TIME_LIMIT'\n    while not stop.is_set() and clock() < deadline:\n        notify('接続中' if not reports else f'再接続中（{retry_number}/{MAX_RETRIES}）')\n        report = attempt(deadline - clock())\n        reports.append(report)\n        frames += report.get('decoded_frames', 0)\n        if stop.is_set():\n            reason = 'STOPPED'; break\n        if clock() >= deadline or report.get('reason') == 'TIME_LIMIT':\n            reason = 'TIME_LIMIT'; break\n        if not frames or not report.get('recoverable', False):\n            reason = report.get('reason', 'ERROR'); break\n        first_frame = report.get('first_decoded_frame_s')\n        last_frame = report.get('last_decoded_frame_s')\n        if first_frame is not None and last_frame is not None and last_frame - first_frame >= RECOVERED_VIDEO_SECONDS:\n            retry_number = 0\n        if retry_number >= MAX_RETRIES:\n            reason = 'RETRY_LIMIT'; break\n        retry_number += 1\n        if report.get('reason') == 'NO_DATA':\n            continue\n        notify(f'映像が途切れました。5秒後に再接続します（{retry_number}/{MAX_RETRIES}）。')\n        if wait(min(5.0, max(0.0, deadline-clock()))):\n            reason = 'STOPPED'; break\n    if stop.is_set(): reason = 'STOPPED'\n    return {'reason': reason, 'attempts': reports, 'retries': max(0, len(reports)-1),\n            'decoded_frames': frames, 'final': reports[-1] if reports else {}}\n", "iermu_cms.py": "\"\"\"MAC-verified CMS live-view transport for IERMU cameras.\"\"\"\nfrom contextlib import contextmanager, ExitStack\nfrom dataclasses import dataclass\nfrom functools import partial\nimport socket\nimport struct\nimport time\n\nimport imageio_ffmpeg\n\nfrom iermu_network import query_mac\nfrom iermu_protocol import live_request, query\n\n\nARP_NO_REPLY = 67  # Windows SendARP: ERROR_BAD_NET_NAME\nRECOVERY_WAIT_SECONDS = 110\n\n\nclass IdentityError(ValueError):\n    pass\n\n\n@dataclass(frozen=True)\nclass CameraRoute:\n    ip: str\n    mac: str\n    source: str\n    interface: int\n\n\ndef decoder_command(*, quality='low'):\n    # HD can start with audio before the first video PES.\n    probe_size = '65536' if quality == 'hd' else '32'\n    return [imageio_ffmpeg.get_ffmpeg_exe(), '-hide_banner', '-loglevel', 'warning',\n            '-nostdin', '-probesize', probe_size, '-analyzeduration', '0',\n            '-f', 'mpeg', '-threads', '1', '-i', 'pipe:0', '-map', '0:v:0', '-an', '-vsync', '0',\n            '-c:v', 'mjpeg', '-q:v', '4', '-f', 'image2pipe', 'pipe:1']\n\n\ndef _connect(camera, port, timeout, stack):\n    sock = socket.socket()\n    stack.callback(sock.close)\n    sock.settimeout(timeout)\n    sock.setsockopt(socket.IPPROTO_IP, 31, struct.pack('!I', camera.interface))\n    sock.bind((camera.source, 0))\n    sock.connect((camera.ip, port))\n    return sock\n\n\ndef _identify(control, expected_mac, exchange, check_stop):\n    exchange(control, 5, 17)\n    check_stop()\n    # Legacy local camera protocol credentials, independent of cloud accounts.\n    login = exchange(control, 69, 6, b'88888888'.ljust(20, b'\\0') + b'cms3518'.ljust(20, b'\\0'))\n    if len(login) != 4:\n        raise IdentityError('認証応答を確認できません')\n    check_stop()\n    info = exchange(control, 74, 63)\n    if len(info) < 6 or info[:6].hex(':') != expected_mac:\n        raise IdentityError('対象のカメラを確認できません（本体情報）')\n    return int.from_bytes(login, 'big')\n\n\ndef verify_camera(camera):\n    \"\"\"Confirm a discovery candidate using only local identification commands.\"\"\"\n    try:\n        with ExitStack() as stack:\n            control = _connect(camera, 3357, 0.6, stack)\n            exchange = partial(query, deadline=time.monotonic() + 1.2)\n            _identify(control, camera.mac, exchange, lambda: None)\n    except (OSError, ValueError, EOFError):\n        return False\n    return True\n\n\n@contextmanager\ndef connection(camera, matrix=False, *, stop=None, quality='low', recovery_wait=0.0,\n               arp=query_mac, exchange=query, build_request=live_request):\n    if not 0 <= recovery_wait <= RECOVERY_WAIT_SECONDS or (recovery_wait and stop is None):\n        raise ValueError('Invalid camera recovery wait')\n\n    def check_stop():\n        if stop is not None and stop.is_set():\n            raise InterruptedError('Playback stopped')\n\n    deadline = time.monotonic() + recovery_wait\n    with ExitStack() as stack:\n        def connect(port, timeout=4.0):\n            check_stop()\n            with ExitStack() as pending:\n                sock = _connect(camera, port, timeout, pending)\n                stack.enter_context(pending.pop_all())\n            return sock\n\n        while True:\n            check_stop()\n            next_probe = time.monotonic() + 5.0\n            code, mac = arp(camera.source, target_ip=camera.ip)\n            if (code, mac) == (0, camera.mac):\n                connect_timeout = min(4.0, deadline - time.monotonic()) if recovery_wait else 4.0\n                if connect_timeout <= 0:\n                    raise TimeoutError('Camera recovery wait expired')\n                try:\n                    control = connect(3357, connect_timeout)\n                except (ConnectionRefusedError, TimeoutError) as error:\n                    if not recovery_wait:\n                        raise\n                    unavailable = error\n                else:\n                    break\n            else:\n                unavailable = IdentityError('対象のカメラを確認できません（ARP）')\n                if not recovery_wait or (code, mac) != (ARP_NO_REPLY, None):\n                    raise unavailable\n            now = time.monotonic()\n            if now >= deadline:\n                raise unavailable\n            stop.wait(max(0.0, min(next_probe, deadline) - now))\n            check_stop()\n            if time.monotonic() >= deadline:\n                raise unavailable\n\n        check_stop()\n        if recovery_wait:\n            control.settimeout(4.0)\n        session = _identify(control, camera.mac, exchange, check_stop)\n        request = build_request(session, matrix=matrix, quality=quality)\n        data = connect(3356)\n        check_stop()\n        data.sendall(request)\n        yield data\n\n\ndef receive(sock, consume, stop, seconds, byte_limit=None, *, timings=None, stats=None, idle_timeout=None):\n    \"\"\"Keep final progress in optional stats even on error; re-raise that error.\n\n    Times are application recv times, not NIC or decoded-frame timestamps.\n    consumed_bytes counts only chunks whose consume callback returned normally.\n    Runs over 30 minutes use the larger bounded budget for the direct AP comparison.\n    \"\"\"\n    max_bytes = (128 if seconds <= 1800 else 256) * 1024 * 1024\n    if byte_limit is None:\n        byte_limit = max_bytes\n    if not 0 < seconds <= 2400 or not 0 < byte_limit <= max_bytes:\n        raise ValueError('Capture bounds exceeded')\n    if idle_timeout is not None and idle_timeout <= 0:\n        raise ValueError('Idle timeout must be positive')\n    sock.settimeout(min(0.5, idle_timeout) if idle_timeout is not None else 0.5)\n    begin = time.monotonic()\n    total = 0\n    consumed = 0\n    first = None\n    last = None\n    max_gap = None\n    reason = 'TIME_LIMIT'\n    timing_samples_dropped = 0\n    phase = 'RECEIVE_ERROR'\n    try:\n        while time.monotonic()-begin < seconds:\n            if stop.is_set():\n                reason = 'STOPPED'; break\n            if idle_timeout is not None and time.monotonic()-begin-(last or 0.0) >= idle_timeout:\n                reason = 'NO_DATA'; break\n            if total >= byte_limit:\n                reason = 'BYTE_LIMIT'; break\n            phase = 'RECEIVE_ERROR'\n            try:\n                block = sock.recv(min(65536, byte_limit-total))\n            except socket.timeout:\n                continue\n            if not block:\n                reason = 'PEER_CLOSED'; break\n            now = time.monotonic()-begin\n            if first is None:\n                first = now\n            if last is not None:\n                gap = now-last\n                max_gap = gap if max_gap is None else max(max_gap, gap)\n            last = now\n            offset = total\n            total += len(block)\n            consume_begin = time.monotonic()-begin if timings is not None else None\n            phase = 'CONSUME_ERROR'\n            consume(block)\n            consumed += len(block)\n            if timings is not None:\n                consume_done = time.monotonic()-begin\n                if len(timings) < 4096:\n                    timings.append({'offset': offset, 'length': len(block),\n                                    'recv_return_s': now,\n                                    'consume_start_s': consume_begin,\n                                    'consume_done_s': consume_done,\n                                    'consume_duration_s': consume_done-consume_begin})\n                else:\n                    timing_samples_dropped += 1\n    except Exception:\n        reason = 'STOPPED' if stop.is_set() else phase\n        raise\n    finally:\n        elapsed = time.monotonic()-begin\n        result = {'received_bytes': total, 'consumed_bytes': consumed,\n                  'elapsed_s': round(elapsed, 3), 'first_receive_s': first,\n                  'last_receive_s': last, 'max_receive_gap_s': max_gap,\n                  'trailing_no_receive_s': max(0.0, elapsed-(last if last is not None else 0.0)),\n                  'reason': reason}\n        if timings is not None:\n            result['timing_samples_dropped'] = timing_samples_dropped\n        if stats is not None:\n            stats.update(result)\n    return result\n\n\nclass JpegFrames:\n    def __init__(self):\n        self.pending = bytearray()\n\n    def feed(self, data):\n        self.pending.extend(data)\n        frames = []\n        while True:\n            start = self.pending.find(b'\\xff\\xd8')\n            if start < 0:\n                self.pending = self.pending[-1:]\n                break\n            if start:\n                del self.pending[:start]\n            end = self.pending.find(b'\\xff\\xd9', 2)\n            if end < 0:\n                if len(self.pending) > 2*1024*1024:\n                    raise ValueError('Decoded frame exceeded bound')\n                break\n            frames.append(bytes(self.pending[:end+2]))\n            del self.pending[:end+2]\n        return frames\n", "iermu_discovery.py": "\"\"\"Discover IERMU cameras on the PC's connected private networks.\"\"\"\nfrom concurrent.futures import ThreadPoolExecutor\nfrom contextlib import ExitStack\nimport ipaddress\nimport select\nimport socket\nimport time\nfrom urllib.parse import urlsplit\n\nfrom iermu_cms import CameraRoute, verify_camera\nfrom iermu_network import neighbors, query_mac\n\n\nDIRECT_IP = ipaddress.IPv4Address('192.168.58.1')\nDIRECT_NETWORK = ipaddress.IPv4Network('192.168.58.0/24')\nIBLACK_MAC_PREFIX = '00:20:1b:'\nSSDP = ('239.255.255.250', 1900)\nSEARCH = (\n    b'M-SEARCH * HTTP/1.1\\r\\nMAN:\"ssdp:discover\"\\r\\nMX: 2\\r\\n'\n    b'HOST:239.255.255.250:1900\\r\\nST:urn:schemas-upnp-org:device:MediaServer:\\r\\n\\r\\n'\n)\nMAX_CANDIDATES = 8\n\n\ndef camera_reply(packet, sender, adapter):\n    \"\"\"Validate the reply without fetching its Location URL.\"\"\"\n    ip = ipaddress.IPv4Address(sender)\n    if not adapter.contains_peer(ip) or b'cmsiermu' not in packet.lower():\n        return False\n    lines = packet.split(b'\\r\\n')\n    if not lines[0].startswith((b'HTTP/1.1 200 ', b'HTTP/1.0 200 ')):\n        return False\n    locations = [line.partition(b':')[2].strip() for line in lines if line.lower().startswith(b'location:')]\n    if len(locations) != 1:\n        return False\n    try:\n        location = urlsplit(locations[0].decode('ascii'))\n        return location.scheme == 'http' and location.hostname == sender and location.username is None\n    except ValueError:\n        return False\n\n\ndef search_lan(adapters):\n    results = {}\n    with ExitStack() as stack:\n        listeners = {}\n        for adapter in adapters[:8]:\n            try:\n                sock = stack.enter_context(socket.socket(socket.AF_INET, socket.SOCK_DGRAM))\n                sock.bind((adapter.ip, 0))\n                sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF, socket.inet_aton(adapter.ip))\n                sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 1)\n                sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)\n                sock.setblocking(False)\n                for destination in (SSDP, (str(adapter.address.network.broadcast_address), SSDP[1])):\n                    try:\n                        sock.sendto(SEARCH, destination)\n                    except OSError:\n                        continue\n                    listeners[sock] = adapter\n            except OSError:\n                continue\n\n        deadline = time.monotonic() + 2.25\n        for _ in range(64):\n            if not listeners or len(results) >= MAX_CANDIDATES:\n                break\n            remaining = deadline - time.monotonic()\n            if remaining <= 0:\n                break\n            readable, _, _ = select.select(list(listeners), [], [], remaining)\n            if not readable:\n                break\n            for sock in readable:\n                try:\n                    packet, (sender, _) = sock.recvfrom(2048)\n                except OSError:\n                    continue\n                adapter = listeners[sock]\n                if camera_reply(packet, sender, adapter):\n                    results.setdefault(sender, adapter)\n                    if len(results) >= MAX_CANDIDATES:\n                        break\n    return results\n\n\ndef find_cameras(adapters):\n    \"\"\"Identify candidates from AP mode, SSDP and the existing neighbor table.\"\"\"\n    candidates = {}\n    for adapter in adapters:\n        if adapter.address.network == DIRECT_NETWORK and adapter.contains_peer(DIRECT_IP):\n            candidates[(str(DIRECT_IP), adapter)] = (None, False)\n\n    for ip, adapter in search_lan(adapters).items():\n        candidates[(ip, adapter)] = (None, True)\n\n    try:\n        cached = neighbors()\n    except OSError:\n        cached = ()\n    for ip, mac, index in cached:\n        if not mac.startswith(IBLACK_MAC_PREFIX):\n            continue\n        for adapter in adapters:\n            if adapter.index == index and adapter.contains_peer(ip):\n                candidates.setdefault((str(ip), adapter), (mac, False))\n\n    def identify(entry):\n        (ip, adapter), (expected_mac, announced) = entry\n        code, mac = query_mac(adapter.ip, target_ip=ip)\n        if code != 0 or mac is None or (expected_mac and mac != expected_mac):\n            return None\n        if not announced and not mac.startswith(IBLACK_MAC_PREFIX):\n            return None\n        route = CameraRoute(ip, mac, adapter.ip, adapter.index)\n        return route if verify_camera(route) else None\n\n    if not candidates:\n        return []\n    routes = {}\n    with ThreadPoolExecutor(max_workers=MAX_CANDIDATES) as workers:\n        for route in workers.map(identify, list(candidates.items())[:MAX_CANDIDATES]):\n            if route:\n                routes.setdefault(route.mac, route)\n    return list(routes.values())\n", "iermu_network.py": "\"\"\"Windows IPv4 adapter and neighbor information for the local viewer.\"\"\"\nimport ctypes as C\nimport ipaddress\nimport socket\nfrom dataclasses import dataclass\n\n\nLOCAL_NETWORKS = tuple(map(ipaddress.IPv4Network, ('10.0.0.0/8', '172.16.0.0/12', '192.168.0.0/16')))\n\n\ndef private_address(address):\n    return any(address in network for network in LOCAL_NETWORKS)\n\n\n@dataclass(frozen=True)\nclass Adapter:\n    address: ipaddress.IPv4Interface\n    index: int\n\n    @property\n    def ip(self):\n        return str(self.address.ip)\n\n    def contains_peer(self, ip):\n        return (private_address(ip) and ip in self.address.network\n                and ip not in (self.address.ip, self.address.network.network_address,\n                               self.address.network.broadcast_address))\n\n\nclass AddressRow(C.Structure):\n    _fields_ = [\n        ('address', C.c_uint32), ('index', C.c_uint32), ('mask', C.c_uint32),\n        ('broadcast', C.c_uint32), ('reassembly', C.c_uint32),\n        ('reserved', C.c_uint16), ('flags', C.c_uint16),\n    ]\n\n\nclass AddressTable(C.Structure):\n    _fields_ = [('count', C.c_uint32), ('first', AddressRow)]\n\n\nclass NeighborRow(C.Structure):\n    _fields_ = [\n        ('index', C.c_uint32), ('length', C.c_uint32), ('mac', C.c_ubyte * 8),\n        ('address', C.c_uint32), ('kind', C.c_uint32),\n    ]\n\n\nclass NeighborTable(C.Structure):\n    _fields_ = [('count', C.c_uint32), ('first', NeighborRow)]\n\n\ndef read_rows(function, table, row_type):\n    read = getattr(C.WinDLL('iphlpapi'), function)\n    read.argtypes = (C.c_void_p, C.POINTER(C.c_uint32), C.c_int)\n    read.restype = C.c_uint32\n    size = C.c_uint32()\n    for _ in range(2):\n        result = read(None, C.byref(size), 0)\n        if result in (0, 232):  # Empty table.\n            return ()\n        if result != 122 or not 4 <= size.value <= 1_048_576:\n            break\n        buffer = C.create_string_buffer(size.value)\n        result = read(buffer, C.byref(size), 0)\n        if result == 122:  # The table grew while it was being read.\n            continue\n        if result == 0:\n            count = C.c_uint32.from_buffer(buffer).value\n            start = table.first.offset\n            if start + count * C.sizeof(row_type) <= len(buffer):\n                return (row_type * count).from_buffer(buffer, start)\n        break\n    raise OSError('PCのネットワーク一覧を取得できません。')\n\n\ndef adapters():\n    \"\"\"Read private IPv4 addresses without changing network settings.\"\"\"\n    result = []\n    for row in read_rows('GetIpAddrTable', AddressTable, AddressRow):\n        ip = ipaddress.IPv4Address(row.address.to_bytes(4, 'little'))\n        if private_address(ip):\n            mask = ipaddress.IPv4Address(row.mask.to_bytes(4, 'little'))\n            result.append(Adapter(ipaddress.IPv4Interface(f'{ip}/{mask}'), row.index))\n    return sorted(result, key=lambda adapter: (adapter.address.ip, adapter.index))\n\n\ndef neighbors():\n    \"\"\"Return the OS's existing IPv4 neighbor entries without sending packets.\"\"\"\n    return [\n        (ipaddress.IPv4Address(row.address.to_bytes(4, 'little')), bytes(row.mac[:6]).hex(':'), row.index)\n        for row in read_rows('GetIpNetTable', NeighborTable, NeighborRow)\n        if row.kind in (3, 4) and row.length == 6\n    ]\n\n\ndef query_mac(source, *, target_ip):\n    send = C.WinDLL('iphlpapi').SendARP\n    send.argtypes = (C.c_uint32, C.c_uint32, C.c_void_p, C.POINTER(C.c_uint32))\n    send.restype = C.c_uint32\n    mac = (C.c_ubyte * 8)()\n    length = C.c_uint32(len(mac))\n    result = send(\n        int.from_bytes(socket.inet_aton(target_ip), 'little'),\n        int.from_bytes(socket.inet_aton(source), 'little'),\n        mac, C.byref(length),\n    )\n    return result, bytes(mac[:6]).hex(':') if result == 0 and length.value == 6 else None\n", "iermu_protocol.py": "\"\"\"IERMU CMS framing and live-view request serialization.\"\"\"\nimport struct\nimport time\n\n\ndef receive_reply(sock, *, deadline=None):\n    def exact(n):\n        out = bytearray()\n        while len(out) < n:\n            if deadline is not None:\n                remaining = deadline - time.monotonic()\n                if remaining <= 0:\n                    raise TimeoutError('Camera identification timed out')\n                sock.settimeout(remaining)\n            chunk = sock.recv(n-len(out))\n            if not chunk:\n                raise EOFError('Camera closed connection')\n            out.extend(chunk)\n        return bytes(out)\n    head = exact(4)\n    main, sub, length = struct.unpack('>BBH', head)\n    # CmsNetUtil.receive_data treats the signed 0xff00 field as a header-only\n    # success for main 72 (last status byte zero). Restrict this exception to\n    # the observed Wi-Fi command; authentication errors such as 45 06 ff 09\n    # and nonzero Wi-Fi status remain rejected.\n    if head == b'\\x48\\x08\\xff\\x00':\n        return main, sub, b''\n    if head[2] == 255 or length > 4096:\n        raise ValueError('Camera error header ' + head.hex())\n    return main, sub, exact(length)\n\ndef query(sock, main, sub, payload=b'', *, deadline=None):\n    if (main,sub) not in {(5,17),(69,6),(74,63),(74,3)}:\n        raise ValueError('Not a permitted read/auth query')\n    sock.sendall(struct.pack('<BBH',main,sub,len(payload))+payload)\n    got_main, got_sub, data = receive_reply(sock, deadline=deadline)\n    if (got_main,got_sub) != (main,sub):\n        raise ValueError('Unexpected response command')\n    return data\n\ndef crc32_cms(data):\n    crc = 0xffffffff\n    for value in data:\n        crc ^= value\n        for _ in range(8):\n            crc = (crc >> 1) ^ (0xedb88320 if crc & 1 else 0)\n    return crc ^ 0xffffffff\n\n\ndef live_request(session, matrix=False, *, quality='low'):\n    if not 0 < session < 0x80000000:\n        raise ValueError('Session is zero or affected by original signed-byte ambiguity')\n    first = struct.pack('<I', 0xdbfacf03)\n    if type(matrix) is not bool:\n        raise ValueError('Unknown request mode')\n    if quality not in ('low', 'hd') or (matrix and quality == 'hd'):\n        raise ValueError('Unsupported quality/request combination')\n    fields = (3, 3, 60, 120) if matrix else (2, 2, 0, 0)\n    if quality == 'hd':\n        fields = (0, 2, 0, 0)\n    first += struct.pack('>6I', session, 1, *fields)\n    first += bytes(32)\n    assert len(first) == 60\n    return first + struct.pack('<I', crc32_cms(first))\n", "iermu_web.py": "\"\"\"Serve the IERMU viewer on a Windows PC, with optional home-network sharing.\"\"\"\nimport argparse\nimport base64\nimport ipaddress\nimport io\nimport json\nimport re\nimport secrets\nimport threading\nimport webbrowser\nfrom http.server import BaseHTTPRequestHandler, ThreadingHTTPServer\nfrom pathlib import Path\nfrom socketserver import TCPServer\nfrom urllib.parse import parse_qs\n\nfrom iermu_cms import CameraRoute\nfrom iermu_discovery import DIRECT_IP, find_cameras\nfrom iermu_network import Adapter, adapters, private_address\nfrom web_camera import Playback\n\n\nLOOPBACK = '127.0.0.1'\nWEB = Path(__file__).resolve().with_name('web_iermu')\nASSETS = {\n    '/': ('index.html', 'text/html; charset=utf-8'),\n    '/app.css': ('app.css', 'text/css; charset=utf-8'),\n    '/app.js': ('app.js', 'text/javascript; charset=utf-8'),\n    '/mark.svg': ('mark.svg', 'image/svg+xml'),\n}\n\n\ndef camera_route(adapter, ip_value, mac_value):\n    try:\n        if not isinstance(ip_value, str):\n            raise ValueError\n        ip = ipaddress.IPv4Address(ip_value)\n    except ValueError:\n        raise ValueError('カメラのIPv4アドレスを入力してください。') from None\n    if not adapter.contains_peer(ip):\n        raise ValueError('カメラと同じネットワークのPCアドレスを選んでください。')\n    if not isinstance(mac_value, str):\n        raise ValueError('本体シールのMACアドレスを入力してください。')\n    mac = mac_value.strip().lower().replace('-', ':')\n    if re.fullmatch(r'[0-9a-f]{12}', mac):\n        mac = ':'.join(mac[index:index + 2] for index in range(0, 12, 2))\n    if not re.fullmatch(r'(?:[0-9a-f]{2}:){5}[0-9a-f]{2}', mac):\n        raise ValueError('本体シールのMACアドレスを入力してください。')\n    return CameraRoute(str(ip), mac, adapter.ip, adapter.index)\n\n\ndef qr_data_url(link):\n    try:\n        import segno\n    except ImportError:\n        pass\n    else:\n        png = io.BytesIO()\n        segno.make_qr(link).save(png, kind='png', scale=6, border=4)\n        return 'data:image/png;base64,' + base64.b64encode(png.getvalue()).decode('ascii')\n\n    try:\n        import cv2\n    except ImportError:\n        return None\n    if not hasattr(cv2, 'QRCodeEncoder_create'):\n        return None\n    code = cv2.QRCodeEncoder_create().encode(link)\n    code = cv2.copyMakeBorder(code, 4, 4, 4, 4, cv2.BORDER_CONSTANT, value=255)\n    code = cv2.resize(code, None, fx=6, fy=6, interpolation=cv2.INTER_NEAREST)\n    success, png = cv2.imencode('.png', code)\n    return 'data:image/png;base64,' + base64.b64encode(png).decode('ascii') if success else None\n\n\nclass LocalHTTPServer(ThreadingHTTPServer):\n    allow_reuse_address = False\n\n    def __init__(self, address, app, *, network=None, token=None):\n        self.app = app\n        self.network = network\n        self.token = token\n        self.revoked = threading.Event()\n        super().__init__(address, Handler)\n\n    def server_bind(self):\n        # An invitation uses the numeric address, so skip the reverse DNS lookup.\n        TCPServer.server_bind(self)\n        self.server_name, self.server_port = self.server_address\n\n    @property\n    def authority(self):\n        return f'{self.server_address[0]}:{self.server_port}'\n\n\nclass App:\n    def __init__(self, port=8765, *, playback=None, list_adapters=adapters):\n        self.playback = Playback() if playback is None else playback\n        self.list_adapters = list_adapters\n        self._lock = threading.Lock()\n        self._camera_operation = threading.Lock()\n        self._closed = False\n        self._share = None\n        self.server = LocalHTTPServer((LOOPBACK, port), self)\n\n    def adapter_for(self, ip):\n        choices = [adapter for adapter in self.list_adapters() if adapter.ip == ip]\n        if len(choices) != 1:\n            raise ValueError('現在使えるPCの接続先を選んでください。')\n        return choices[0]\n\n    def options(self):\n        with self._lock:\n            sharing = None if self._share is None else self._share[2]\n        return {\n            'adapters': [\n                {'ip': adapter.ip, 'prefix': adapter.address.network.prefixlen, 'index': adapter.index}\n                for adapter in self.list_adapters()\n            ],\n            'app': 'iermu-cam', 'sharing': sharing,\n        }\n\n    def discover(self):\n        if not self._camera_operation.acquire(blocking=False):\n            raise ValueError('カメラの操作中です。')\n        try:\n            if self.playback.status()['phase'] not in ('idle', 'error'):\n                raise ValueError('再生を停止してから探してください。')\n            return [\n                {'ip': route.ip, 'mac': route.mac, 'source': route.source,\n                 'direct': route.ip == str(DIRECT_IP)}\n                for route in find_cameras(self.list_adapters())\n            ]\n        finally:\n            self._camera_operation.release()\n\n    def start_playback(self, route, seconds):\n        if not self._camera_operation.acquire(blocking=False):\n            return False\n        try:\n            return self.playback.start(route, seconds)\n        finally:\n            self._camera_operation.release()\n\n    def start_share(self, ip):\n        adapter = self.adapter_for(ip)\n        if not private_address(adapter.address.ip):\n            raise ValueError('家庭内ネットワークのアドレスを選んでください。')\n        with self._lock:\n            if self._closed:\n                raise OSError('Webアプリを終了しています。')\n            if self._share is not None:\n                if self._share[0].server_address[0] == adapter.ip:\n                    return self._share[2]\n                raise ValueError('接続先を変える前に、スマホ共有を終了してください。')\n            token = secrets.token_urlsafe(24)\n            server = LocalHTTPServer(\n                (adapter.ip, 0), self,\n                network=adapter.address.network, token=token,\n            )\n            try:\n                link = f'http://{server.authority}/#pair={token}'\n                info = {'url': link, 'qr': qr_data_url(link), 'ip': adapter.ip}\n                thread = threading.Thread(\n                    target=server.serve_forever, kwargs={'poll_interval': 0.2},\n                    daemon=True, name='iermu-phone-share',\n                )\n                thread.start()\n            except BaseException:\n                server.server_close()\n                raise\n            self._share = server, thread, info\n            return info\n\n    def stop_share(self):\n        with self._lock:\n            if self._share is not None:\n                server, thread, _ = self._share\n                server.revoked.set()\n                server.shutdown()\n                server.server_close()\n                thread.join()\n                self._share = None\n\n    def close(self):\n        with self._lock:\n            self._closed = True\n        self.server.server_close()\n        self.stop_share()\n        self.playback.close()\n\n\nclass Handler(BaseHTTPRequestHandler):\n    def setup(self):\n        self.request.settimeout(4)\n        super().setup()\n\n    def log_message(self, format, *args):\n        # Invitation keys and camera addresses do not belong in request logs.\n        pass\n\n    def handle(self):\n        try:\n            super().handle()\n        except (BrokenPipeError, ConnectionResetError, ConnectionAbortedError):\n            pass\n\n    def respond(self, status, payload=b'', content_type=None, *, sequence=None):\n        self.send_response(status)\n        if content_type is not None:\n            self.send_header('Content-Type', content_type)\n        if sequence is not None:\n            self.send_header('X-Frame-Sequence', str(sequence))\n        if status != 204:\n            self.send_header('Content-Length', str(len(payload)))\n        self.send_header('Cache-Control', 'no-store')\n        self.send_header('X-Content-Type-Options', 'nosniff')\n        self.send_header('Cross-Origin-Resource-Policy', 'same-origin')\n        self.send_header('Referrer-Policy', 'no-referrer')\n        self.send_header('Content-Security-Policy', \"default-src 'self'; img-src 'self' blob: data:; \"\n                         \"object-src 'none'; base-uri 'none'; frame-ancestors 'none'\")\n        self.end_headers()\n        if payload:\n            self.wfile.write(payload)\n\n    def json(self, status, data):\n        self.respond(status, json.dumps(data, ensure_ascii=False).encode(), 'application/json; charset=utf-8')\n\n    def valid_peer(self):\n        if self.headers.get_all('Host') != [self.server.authority] or self.server.revoked.is_set():\n            return False\n        ip = ipaddress.IPv4Address(self.client_address[0])\n        if self.server.network is None:\n            return ip.is_loopback\n        return private_address(ip) and ip in self.server.network\n\n    def can_view(self):\n        if self.server.token is None:\n            return True\n        received = self.headers.get('Authorization', '').encode('latin-1')\n        expected = f'Bearer {self.server.token}'.encode('ascii')\n        return secrets.compare_digest(received, expected)\n\n    def do_GET(self):\n        if not self.valid_peer():\n            self.json(403, {'error': 'このアドレスからは利用できません。'})\n            return\n        path, _, query = self.path.partition('?')\n        if path in ASSETS:\n            file, content_type = ASSETS[path]\n            self.respond(200, (WEB / file).read_bytes(), content_type)\n            return\n        if not self.can_view():\n            self.json(401, {'error': 'PCで発行したスマホ用リンクから開いてください。'})\n            return\n        app = self.server.app\n        if path == '/api/status':\n            self.json(200, app.playback.status())\n        elif path == '/api/frame':\n            after = parse_qs(query, keep_blank_values=True).get('after', ['0'])[0]\n            if re.fullmatch(r'[0-9]{1,18}', after) is None:\n                self.json(400, {'error': 'フレーム番号が無効です。'})\n                return\n            frame = app.playback.latest(int(after))\n            if frame is None:\n                self.respond(204)\n            else:\n                sequence, image = frame\n                self.respond(200, image, 'image/jpeg', sequence=sequence)\n        elif path == '/api/options' and self.server.network is None:\n            try:\n                self.json(200, app.options())\n            except OSError as error:\n                self.json(503, {'error': str(error)})\n        else:\n            self.json(404, {'error': 'ページが見つかりません。'})\n\n    def do_POST(self):\n        lengths = self.headers.get_all('Content-Length', [])\n        length = int(lengths[0]) if len(lengths) == 1 and re.fullmatch(r'[0-9]{1,4}', lengths[0]) else 0\n        bounded_body = 1 <= length <= 2048 and not self.headers.get('Transfer-Encoding')\n        if (not self.valid_peer() or self.server.network is not None\n                or self.headers.get_all('Origin') != [f'http://{self.server.authority}']):\n            # Consume a bounded request body so Windows can deliver the rejection before closing.\n            if bounded_body:\n                self.rfile.read(length)\n            self.json(403, {'error': 'PCの画面から操作してください。'})\n            return\n        try:\n            if not bounded_body or self.headers.get_content_type() != 'application/json':\n                raise ValueError('入力形式が無効です。')\n            data = json.loads(self.rfile.read(length))\n            if not isinstance(data, dict):\n                raise ValueError('入力形式が無効です。')\n        except (ValueError, TimeoutError, RecursionError):\n            self.json(400, {'error': '入力内容を確認してください。'})\n            return\n\n        app = self.server.app\n        try:\n            if self.path == '/api/discover':\n                self.json(200, {'cameras': app.discover()})\n            elif self.path == '/api/start':\n                seconds = data.get('seconds')\n                if type(seconds) is not int or seconds not in (120, 600, 1800):\n                    raise ValueError('再生時間を選んでください。')\n                route = camera_route(app.adapter_for(data.get('source')), data.get('ip'), data.get('mac'))\n                if not app.start_playback(route, seconds):\n                    self.json(409, {'error': 'カメラの操作中です。'})\n                    return\n                self.json(202, app.playback.status())\n            elif self.path == '/api/stop':\n                app.playback.stop()\n                self.json(200, app.playback.status())\n            elif self.path == '/api/share':\n                self.json(200, app.start_share(data.get('ip')))\n            elif self.path == '/api/unshare':\n                app.stop_share()\n                self.json(200, {'sharing': None})\n            else:\n                self.json(404, {'error': 'ページが見つかりません。'})\n        except ValueError as error:\n            self.json(400, {'error': str(error)})\n        except OSError:\n            self.json(503, {'error': 'PCのネットワークを確認してください。'})\n\n\ndef main():\n    parser = argparse.ArgumentParser(description=__doc__)\n    parser.add_argument('--port', type=int, default=8765)\n    parser.add_argument('--open', action='store_true', help='Open the PC viewer in the default browser')\n    args = parser.parse_args()\n    app = App(args.port)\n    url = f'http://{app.server.authority}/'\n    print(f'IERMU Cam専用アプリ  {url}\\n終了するには Ctrl+C', flush=True)\n    if args.open:\n        webbrowser.open(url)\n    try:\n        app.server.serve_forever(poll_interval=0.2)\n    except KeyboardInterrupt:\n        pass\n    finally:\n        app.close()\n\n\nif __name__ == '__main__':\n    main()\n", "requirements.txt": "imageio-ffmpeg==0.6.0 --hash=sha256:02fa47c83703c37df6bfe4896aab339013f62bf02c5ebf2dce6da56af04ffc0a\nsegno==1.6.6 --hash=sha256:28c7d081ed0cf935e0411293a465efd4d500704072cdb039778a2ab8736190c7\n", "web_camera.py": "\"\"\"Keep one decoded camera stream for all viewers of the local Web app.\"\"\"\nimport socket\nimport subprocess\nimport threading\nimport time\n\nimport iermu_cms\nimport cms_recovery\n\n\ndef decode_stream(stream, seconds, stop, publish, report):\n    \"\"\"Feed the existing decoder and publish only complete JPEG frames.\"\"\"\n    began = time.monotonic()\n    decoder_failed = threading.Event()\n    done = threading.Event()\n    report['decoded_frames'] = 0\n\n    with subprocess.Popen(\n        iermu_cms.decoder_command(quality='hd'),\n        stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,\n        creationflags=getattr(subprocess, 'CREATE_NO_WINDOW', 0),\n    ) as decoder:\n        def read_frames():\n            parser = iermu_cms.JpegFrames()\n            try:\n                while not stop.is_set():\n                    block = decoder.stdout.read1(32768)\n                    if not block:\n                        return\n                    for frame in parser.feed(block):\n                        elapsed = time.monotonic() - began\n                        report.setdefault('first_decoded_frame_s', elapsed)\n                        report['last_decoded_frame_s'] = elapsed\n                        report['decoded_frames'] += 1\n                        publish(frame)\n            except (OSError, ValueError):\n                decoder_failed.set()\n\n        def interrupt_if_needed():\n            while not done.wait(0.1):\n                if stop.is_set() or decoder_failed.is_set() or decoder.poll() is not None:\n                    try:\n                        stream.shutdown(socket.SHUT_RDWR)\n                    except OSError:\n                        pass\n                    try:\n                        if decoder.poll() is None:\n                            decoder.terminate()\n                    except OSError:\n                        pass\n                    return\n\n        def feed(block):\n            decoder.stdin.write(block)\n            decoder.stdin.flush()\n\n        reader = threading.Thread(target=read_frames, daemon=True)\n        watcher = threading.Thread(target=interrupt_if_needed, daemon=True)\n        reader.start()\n        watcher.start()\n        try:\n            iermu_cms.receive(stream, feed, stop, seconds, stats=report, idle_timeout=15)\n        finally:\n            try:\n                try:\n                    decoder.stdin.close()\n                except OSError:\n                    pass\n                try:\n                    decoder.wait(timeout=3)\n                except subprocess.TimeoutExpired:\n                    decoder.kill()\n                    decoder.wait()\n                reader.join()\n            finally:\n                done.set()\n                watcher.join()\n\n    if not stop.is_set() and (decoder_failed.is_set() or decoder.returncode):\n        report['reason'] = 'DECODER_ERROR'\n\n\ndef camera_attempt(route, remaining, stop, publish, *, reconnecting):\n    report = {'decoded_frames': 0, 'reason': 'ERROR'}\n    started = time.monotonic()\n    recovery_wait = min(remaining, iermu_cms.RECOVERY_WAIT_SECONDS) if reconnecting else 0\n    try:\n        with iermu_cms.connection(\n            route, quality='hd', stop=stop, recovery_wait=recovery_wait,\n        ) as stream:\n            seconds = remaining - (time.monotonic() - started)\n            if seconds <= 0 or stop.is_set():\n                return {**report, 'reason': 'TIME_LIMIT' if seconds <= 0 else 'STOPPED'}\n            decode_stream(stream, seconds, stop, publish, report)\n    except iermu_cms.IdentityError:\n        report['reason'] = 'IDENTITY_ERROR'\n    except (ConnectionError, TimeoutError, EOFError):\n        if report.get('reason') != 'CONSUME_ERROR':\n            report.update(reason='DISCONNECTED', recoverable=True)\n    except (OSError, ValueError):\n        pass\n\n    if stop.is_set():\n        report['reason'] = 'STOPPED'\n    elif report.get('reason') in ('NO_DATA', 'PEER_CLOSED'):\n        report['recoverable'] = True\n    return report\n\n\nclass Playback:\n    def __init__(self, attempt=camera_attempt):\n        self._attempt = attempt\n        self._lock = threading.Lock()\n        self._closed = False\n        self._worker = None\n        self._stop = None\n        self._phase = 'idle'\n        self._message = ''\n        self._frame = None\n        self._sequence = 0\n\n    def status(self):\n        with self._lock:\n            return {'phase': self._phase, 'message': self._message}\n\n    def latest(self, after):\n        with self._lock:\n            if self._frame is not None and self._sequence > after:\n                return self._sequence, self._frame\n            return None\n\n    def start(self, route, seconds):\n        with self._lock:\n            if self._closed or self._worker is not None:\n                return False\n            self._stop = threading.Event()\n            self._phase = 'connecting'\n            self._message = 'カメラを確認しています。'\n            self._frame = None\n            self._worker = threading.Thread(\n                target=self._play, args=(route, seconds, self._stop), name='iermu-playback',\n            )\n            self._worker.start()\n            return True\n\n    def stop(self):\n        with self._lock:\n            if self._worker is not None:\n                self._phase = 'stopping'\n                self._message = 'カメラとの接続を閉じています。'\n                self._frame = None\n                self._stop.set()\n\n    def close(self):\n        with self._lock:\n            self._closed = True\n            worker = self._worker\n        self.stop()\n        if worker is not None:\n            worker.join()\n\n    def _play(self, route, seconds, stop):\n        timed_out = threading.Event()\n        attempts = 0\n\n        def expire():\n            timed_out.set()\n            stop.set()\n\n        def publish(frame):\n            with self._lock:\n                if not stop.is_set():\n                    self._frame = frame\n                    self._sequence += 1\n                    self._phase = 'playing'\n                    self._message = '映像を受信しています。'\n\n        def notify(message):\n            with self._lock:\n                if not stop.is_set():\n                    self._frame = None\n                    self._phase = 'reconnecting' if attempts else 'connecting'\n                    self._message = message\n\n        def attempt(remaining):\n            nonlocal attempts\n            attempts += 1\n            return self._attempt(route, remaining, stop, publish, reconnecting=attempts > 1)\n\n        timer = threading.Timer(seconds, expire)\n        timer.daemon = True\n        timer.start()\n        reason = 'ERROR'\n        try:\n            reason = cms_recovery.supervise(attempt, stop, seconds, notify)['reason']\n        finally:\n            timer.cancel()\n            timer.join()\n            with self._lock:\n                self._frame = None\n                if timed_out.is_set() or reason == 'TIME_LIMIT':\n                    self._phase, self._message = 'idle', '設定した時間で自動停止しました。'\n                elif stop.is_set():\n                    self._phase, self._message = 'idle', '再生を停止しました。'\n                else:\n                    self._phase = 'error'\n                    self._message = {\n                        'IDENTITY_ERROR': 'カメラを確認できません。IP、MAC、PCの接続先を確認してください。',\n                        'RETRY_LIMIT': '再接続できなかったため停止しました。',\n                        'DECODER_ERROR': '映像の変換に失敗しました。',\n                        'CONSUME_ERROR': '映像の変換に失敗しました。',\n                    }.get(reason, '映像が届きません。電源とWi-Fiを確認してください。')\n                self._worker = None\n", "web_iermu/app.css": ":root {\n  color-scheme: light;\n  --background: #f4f5f2;\n  --surface: #ffffff;\n  --surface-muted: #eff2ef;\n  --border: #dfe4e0;\n  --foreground: #222c29;\n  --secondary-text: #56635e;\n  --accent: #385850;\n  --accent-hover: #29463f;\n  --accent-soft: #e6efea;\n  --warning: #744b25;\n  --warning-soft: #f8eee1;\n  --display: \"Yu Gothic UI\", \"Hiragino Kaku Gothic ProN\", Meiryo, sans-serif;\n  font-family: var(--display);\n}\n\n*, *::before, *::after { box-sizing: border-box; }\n[hidden] { display: none !important; }\nbody { margin: 0; color: var(--foreground); background: var(--background); }\nbutton, select, input { font: inherit; }\nbutton, select, summary { cursor: pointer; }\nbutton:disabled { cursor: default; opacity: .46; }\n:focus-visible { outline: 2px solid var(--accent); outline-offset: 3px; }\n\n.masthead {\n  width: min(1240px, calc(100% - 48px));\n  min-height: 78px;\n  display: flex;\n  align-items: center;\n  margin: 0 auto;\n  border-bottom: 1px solid var(--border);\n}\n.brand { display: flex; gap: 12px; align-items: center; margin: 0; font-size: 1rem; font-weight: 700; letter-spacing: .025em; }\n.brand img { flex: none; }\n.shell { width: min(1240px, calc(100% - 48px)); margin: 0 auto; padding: 28px 0; }\n.workspace { display: grid; grid-template-columns: minmax(0, 1fr) 300px; align-items: start; gap: 18px; }\n.remote .workspace { grid-template-columns: 1fr; }\n\n.monitor, .controls { min-width: 0; background: var(--surface); border: 1px solid var(--border); border-radius: 20px; }\n.monitor { overflow: hidden; }\n.monitor-bar { min-height: 49px; padding: 9px 16px; display: flex; justify-content: space-between; align-items: center; gap: 12px; }\n.status-badge { display: inline-flex; align-items: center; gap: 7px; border-radius: 100px; padding: 5px 10px; background: var(--surface-muted); color: var(--secondary-text); font-size: .75rem; }\n.status-badge i { width: 6px; height: 6px; border-radius: 50%; background: currentColor; }\n.status-badge[data-phase=\"playing\"] { background: var(--accent-soft); color: var(--accent); }\n.status-badge[data-phase=\"connecting\"], .status-badge[data-phase=\"reconnecting\"],\n.status-badge[data-phase=\"error\"], .status-badge[data-phase=\"locked\"] { background: var(--warning-soft); color: var(--warning); }\n.resolution { color: var(--secondary-text); font: .78rem \"Cascadia Mono\", Consolas, monospace; }\n.screen { display: grid; place-items: center; position: relative; aspect-ratio: 16 / 9; background: #1e2523; overflow: hidden; }\n.screen > img { position: absolute; inset: 0; width: 100%; height: 100%; object-fit: contain; background: #161b19; }\n.empty { display: grid; justify-items: center; gap: 9px; padding: 12px; color: #c5cfca; text-align: center; font-size: .84rem; }\n.empty p { margin: 0; }\n.reticle { fill: none; stroke: #a4b3ab; stroke-width: 1.35; stroke-linejoin: round; }\n\n.controls { padding: 14px; }\n.controls section { padding: 0 4px 3px; }\nh2 { margin: 0 0 12px; font-size: .93rem; }\n.mode-switch { display: grid; grid-template-columns: 1fr 1fr; gap: 3px; padding: 4px; margin-bottom: 17px; border-radius: 12px; background: var(--surface-muted); }\n.mode-switch button { min-height: 37px; border: 1px solid transparent; border-radius: 9px; background: transparent; color: var(--secondary-text); font-size: .82rem; }\n.mode-switch button[aria-pressed=\"true\"] { color: var(--foreground); background: var(--surface); border-color: var(--border); font-weight: 700; }\n.hint { color: var(--secondary-text); margin: 0 0 10px; font-size: .79rem; line-height: 1.65; }\nlabel { display: block; margin: 12px 0 5px; color: var(--secondary-text); font-size: .76rem; }\ninput, select { width: 100%; min-height: 42px; border: 1px solid var(--border); border-radius: 10px; padding: 8px 10px; color: var(--foreground); background: var(--surface); font-size: .83rem; }\ninput::placeholder { color: var(--secondary-text); }\ninput:disabled, select:disabled { background: var(--surface-muted); }\n.field-heading { display: flex; align-items: baseline; justify-content: space-between; gap: 6px; }\n.link-button { padding: 4px; border: 0; color: var(--accent); background: transparent; font-size: .76rem; }\n.actions { display: flex; flex-wrap: wrap; gap: 7px; margin-top: 9px; }\n.primary, .secondary { min-height: 42px; border: 1px solid transparent; border-radius: 10px; padding: 8px 12px; font-size: .82rem; font-weight: 700; text-align: center; }\n.primary { color: #fff; background: var(--accent); }\n.primary:not(:disabled):hover { background: var(--accent-hover); }\n.secondary { color: var(--foreground); border-color: var(--border); background: var(--surface); }\n.secondary:not(:disabled):hover { background: var(--surface-muted); }\n#start { flex: 1; }\n#start span { margin-right: 3px; font-size: .67rem; }\n.share-start { display: block; width: 100%; }\n.guide { margin-top: 12px; padding-top: 12px; border-top: 1px solid var(--border); color: var(--secondary-text); font-size: .77rem; }\n.guide p { margin: 9px 0 0; line-height: 1.7; }\n.invite { margin-top: 14px; padding-top: 14px; border-top: 1px solid var(--border); }\n.invite img { display: block; margin: 0 auto; }\n.notice { margin: 11px 4px 2px; padding: 8px 10px; border-radius: 8px; background: var(--warning-soft); color: var(--warning); font-size: .78rem; line-height: 1.55; }\n\n.setup { max-width: 660px; display: grid; gap: 14px; }\n.setup-card { padding: 20px 22px; background: var(--surface); border: 1px solid var(--border); border-radius: 20px; }\n.setup-card h2 { font-size: 1rem; }\n.setup-card ol { margin: 10px 0 14px; padding-left: 1.4em; color: var(--secondary-text); font-size: .86rem; line-height: 1.8; }\n.setup-card a:not(.setup-action) { color: var(--accent); }\n.setup-action { display: inline-flex; align-items: center; text-decoration: none; }\n\n@media (max-width: 740px) {\n  .masthead, .shell { width: calc(100% - 28px); }\n  .masthead { min-height: 62px; }\n  .shell { padding: 16px 0; }\n  .workspace { grid-template-columns: minmax(0, 1fr); gap: 12px; }\n  .monitor, .controls { border-radius: 15px; }\n  input, select { font-size: 16px; }\n}\n", "web_iermu/app.js": "\"use strict\";\n\nconst byId = (id) => document.getElementById(id);\nconst remote = location.hostname !== \"127.0.0.1\";\nconst feed = byId(\"feed\");\nconst cameraIp = byId(\"camera-ip\");\nconst cameraMac = byId(\"camera-mac\");\nconst cameraSource = byId(\"camera-source\");\nconst cameraChoice = byId(\"camera-choice\");\nconst shareSource = byId(\"share-source\");\nconst duration = byId(\"duration\");\nconst activePhases = new Set([\"connecting\", \"playing\", \"reconnecting\", \"stopping\"]);\nconst detailPhases = new Set([\"idle\", \"reconnecting\", \"error\", \"locked\"]);\nconst labels = {\n  idle: \"停止中\", connecting: \"接続中\", playing: \"再生中\", reconnecting: \"再接続中\",\n  stopping: \"停止処理中\", error: \"接続を確認\", locked: \"リンクが必要\",\n};\n\nlet phase = \"idle\";\nlet commandPending = false;\nlet shareInfo = null;\nlet cameras = [];\nlet latestSequence = 0;\nlet frameUrl = null;\nlet frameGeneration = 0;\nlet pair = \"\";\n\nif (remote) {\n  byId(\"shell\").classList.add(\"remote\");\n  const invitation = new URLSearchParams(location.hash.slice(1)).get(\"pair\");\n  pair = invitation || \"\";\n  try {\n    if (invitation) {\n      sessionStorage.setItem(\"iermu-pair\", invitation);\n      history.replaceState(null, \"\", location.pathname);\n    } else {\n      pair = sessionStorage.getItem(\"iermu-pair\") || \"\";\n    }\n  } catch {\n    // The invitation in the address still works if storage is unavailable.\n  }\n  window.addEventListener(\"hashchange\", () => {\n    if (location.hash.startsWith(\"#pair=\")) location.reload();\n  });\n} else {\n  byId(\"controls\").hidden = false;\n}\n\nasync function request(path, data, timeout = 4500) {\n  const headers = new Headers();\n  if (remote && pair) headers.set(\"Authorization\", \"Bearer \" + pair);\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeout);\n  try {\n    if (data !== undefined) headers.set(\"Content-Type\", \"application/json\");\n    const response = await fetch(path, {\n      method: data === undefined ? \"GET\" : \"POST\",\n      headers,\n      body: data === undefined ? undefined : JSON.stringify(data),\n      cache: \"no-store\",\n      signal: controller.signal,\n    });\n    if (!response.ok) {\n      const error = await response.json().catch(() => ({}));\n      const failure = new Error(error.error || \"PCのWebアプリに接続できません。\");\n      failure.status = response.status;\n      throw failure;\n    }\n    if (response.status === 204) return null;\n    if (path.startsWith(\"/api/frame?\")) {\n      return {\n        frame: await response.blob(),\n        sequence: Number(response.headers.get(\"X-Frame-Sequence\")),\n      };\n    }\n    return await response.json();\n  } finally {\n    clearTimeout(timer);\n  }\n}\n\nfunction clearFrame() {\n  frameGeneration += 1;\n  if (frameUrl) {\n    URL.revokeObjectURL(frameUrl);\n    frameUrl = null;\n    feed.removeAttribute(\"src\");\n  }\n  feed.hidden = true;\n  byId(\"empty\").hidden = false;\n  byId(\"resolution\").hidden = true;\n}\n\nfunction controls() {\n  const active = activePhases.has(phase);\n  const busy = commandPending || active;\n  byId(\"find-camera\").disabled = busy;\n  cameraChoice.disabled = busy;\n  byId(\"refresh\").disabled = busy;\n  byId(\"start\").disabled = busy || !cameraIp.value.trim() || !cameraMac.value.trim() || !cameraSource.value;\n  byId(\"stop\").disabled = commandPending || !active || phase === \"stopping\";\n  for (const field of [cameraIp, cameraMac, cameraSource, duration]) {\n    field.disabled = busy;\n  }\n  shareSource.disabled = commandPending || Boolean(shareInfo);\n  byId(\"share\").disabled = commandPending || !shareSource.value;\n  byId(\"unshare\").disabled = commandPending;\n}\n\nfunction showStatus(state) {\n  if (phase !== state.phase && state.phase !== \"playing\") clearFrame();\n  phase = state.phase;\n  byId(\"status-badge\").dataset.phase = phase;\n  const label = byId(\"status-label\");\n  const status = labels[phase] || \"接続を確認\";\n  if (label.textContent !== status) label.textContent = status;\n  const detail = byId(\"status-message\");\n  const text = remote && phase === \"idle\" ? \"PCで再生を開始してください。\"\n    : detailPhases.has(phase) ? state.message : \"\";\n  if (detail.textContent !== text) detail.textContent = text;\n  detail.hidden = !text;\n  if (!remote) controls();\n}\n\nasync function pollStatus() {\n  if (remote && !pair) {\n    showStatus({ phase: \"locked\", message: \"PCで発行したリンクを開いてください。\" });\n    return;\n  }\n  try {\n    showStatus(await request(\"/api/status\"));\n  } catch (error) {\n    if (remote && error.status === 401) {\n      showStatus({ phase: \"locked\", message: error.message });\n      return;\n    }\n    showStatus({ phase: \"error\", message: \"PCのWebアプリに接続できません。\" });\n  }\n  setTimeout(pollStatus, document.hidden ? 1800 : 650);\n}\n\nasync function pollFrame() {\n  const generation = frameGeneration;\n  if (phase === \"playing\" && !document.hidden) {\n    try {\n      const data = await request(\"/api/frame?after=\" + latestSequence);\n      if (data && phase === \"playing\" && generation === frameGeneration) {\n        latestSequence = data.sequence;\n        const previous = frameUrl;\n        frameUrl = URL.createObjectURL(data.frame);\n        feed.src = frameUrl;\n        if (previous) URL.revokeObjectURL(previous);\n      }\n    } catch {\n      // The status request reports loss of the PC or camera connection.\n    }\n  }\n  setTimeout(pollFrame, phase === \"playing\" && !document.hidden ? 85 : 400);\n}\n\nfeed.addEventListener(\"load\", () => {\n  if (phase !== \"playing\" || !frameUrl || feed.src !== frameUrl) return;\n  feed.hidden = false;\n  byId(\"empty\").hidden = true;\n  byId(\"resolution\").textContent = feed.naturalWidth + \" × \" + feed.naturalHeight;\n  byId(\"resolution\").hidden = false;\n});\n\nfunction notice(message) {\n  byId(\"notice\").textContent = message;\n  byId(\"notice\").hidden = !message;\n}\n\nfunction mode(phone) {\n  byId(\"pc-mode\").setAttribute(\"aria-pressed\", String(!phone));\n  byId(\"phone-mode\").setAttribute(\"aria-pressed\", String(phone));\n  byId(\"pc-panel\").hidden = phone;\n  byId(\"phone-panel\").hidden = !phone;\n  if (phone && !shareSource.value) byId(\"share-settings\").open = true;\n  notice(\"\");\n}\n\nfunction showShare(info) {\n  shareInfo = info;\n  byId(\"invite\").hidden = !info;\n  byId(\"share\").hidden = Boolean(info);\n  byId(\"share-link\").value = info?.url || \"\";\n  byId(\"qr\").hidden = !info?.qr;\n  if (info?.qr) byId(\"qr\").src = info.qr;\n  else byId(\"qr\").removeAttribute(\"src\");\n  controls();\n}\n\nfunction setChoices(field, addresses, preferred) {\n  const current = field.value;\n  field.replaceChildren(new Option(\"PCのアドレスを選択\", \"\"));\n  for (const item of addresses) {\n    field.add(new Option(item.ip + \"  ／  \" + item.prefix, item.ip));\n  }\n  if (addresses.some((item) => item.ip === current)) field.value = current;\n  else if (addresses.some((item) => item.ip === preferred)) field.value = preferred;\n  else if (addresses.length === 1) field.value = addresses[0].ip;\n}\n\nasync function refresh() {\n  const options = await request(\"/api/options\");\n  setChoices(cameraSource, options.adapters, \"\");\n  setChoices(shareSource, options.adapters, options.sharing?.ip);\n  showShare(options.sharing);\n}\n\nfunction selectCamera() {\n  const camera = cameras[cameraChoice.value];\n  if (!camera) return;\n  cameraIp.value = camera.ip;\n  cameraMac.value = camera.mac;\n  cameraSource.value = camera.source;\n  if (!shareInfo) {\n    const otherAddresses = [...shareSource.options]\n      .map((option) => option.value)\n      .filter((ip) => ip && ip !== camera.source);\n    if (!camera.direct || otherAddresses.length === 0) {\n      shareSource.value = camera.source;\n    } else {\n      shareSource.value = otherAddresses.length === 1 ? otherAddresses[0] : \"\";\n    }\n  }\n  controls();\n}\n\nasync function discover() {\n  const button = byId(\"find-camera\");\n  button.textContent = \"検索中…\";\n  try {\n    await refresh();\n    const previous = cameras[cameraChoice.value];\n    const found = await request(\"/api/discover\", {}, 12000);\n    cameras = found.cameras;\n    cameraChoice.replaceChildren(...cameras.map((camera, index) => {\n      const suffix = camera.mac.slice(-8).toUpperCase();\n      const route = camera.direct ? \"直接接続\" : \"LAN\";\n      return new Option(`IERMU ${suffix}（${route}）`, String(index));\n    }));\n    byId(\"camera-results\").hidden = cameras.length === 0;\n    if (cameras.length) {\n      const sameCamera = cameras.findIndex((camera) => camera.mac === previous?.mac);\n      cameraChoice.value = String(Math.max(0, sameCamera));\n      selectCamera();\n    } else {\n      if (previous) {\n        cameraIp.value = \"\";\n        cameraMac.value = \"\";\n      }\n      notice(\"カメラが見つかりませんでした。\");\n      byId(\"direct-guide\").open = true;\n    }\n  } finally {\n    button.textContent = \"カメラを探す\";\n  }\n}\n\nasync function action(run) {\n  if (commandPending) return;\n  commandPending = true;\n  notice(\"\");\n  controls();\n  try {\n    await run();\n  } catch (error) {\n    notice(error.name === \"AbortError\" ? \"PCのWebアプリが応答しません。\" : error.message);\n  } finally {\n    commandPending = false;\n    controls();\n  }\n}\n\nif (!remote) {\n  byId(\"pc-mode\").addEventListener(\"click\", () => mode(false));\n  byId(\"phone-mode\").addEventListener(\"click\", () => mode(true));\n  byId(\"refresh\").addEventListener(\"click\", () => action(refresh));\n  byId(\"find-camera\").addEventListener(\"click\", () => action(discover));\n  cameraChoice.addEventListener(\"change\", selectCamera);\n  for (const field of [cameraIp, cameraMac, cameraSource]) {\n    field.addEventListener(\"input\", () => {\n      cameraChoice.selectedIndex = -1;\n      controls();\n    });\n  }\n  shareSource.addEventListener(\"change\", controls);\n  byId(\"camera-form\").addEventListener(\"submit\", (event) => {\n    event.preventDefault();\n    action(async () => {\n      showStatus(await request(\"/api/start\", {\n        ip: cameraIp.value.trim(), mac: cameraMac.value.trim(),\n        source: cameraSource.value, seconds: Number(duration.value),\n      }));\n    });\n  });\n  byId(\"stop\").addEventListener(\"click\", () => action(async () => {\n    showStatus(await request(\"/api/stop\", {}));\n  }));\n  byId(\"share\").addEventListener(\"click\", () => action(async () => {\n    showShare(await request(\"/api/share\", { ip: shareSource.value }));\n  }));\n  byId(\"unshare\").addEventListener(\"click\", () => action(async () => {\n    await request(\"/api/unshare\", {});\n    showShare(null);\n  }));\n  byId(\"copy\").addEventListener(\"click\", async () => {\n    const input = byId(\"share-link\");\n    try {\n      await navigator.clipboard.writeText(input.value);\n      notice(\"リンクをコピーしました。\");\n    } catch {\n      input.focus();\n      input.select();\n      notice(\"選択したリンクをコピーしてください。\");\n    }\n  });\n  action(refresh);\n}\n\npollStatus();\npollFrame();\n", "web_iermu/index.html": "<!doctype html>\n<html lang=\"ja\">\n<head>\n  <meta charset=\"utf-8\">\n  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">\n  <meta name=\"color-scheme\" content=\"light\">\n  <title>IERMU Cam専用アプリ</title>\n  <link rel=\"icon\" href=\"/mark.svg\" type=\"image/svg+xml\">\n  <link rel=\"stylesheet\" href=\"/app.css\">\n  <script src=\"/app.js\" defer></script>\n</head>\n<body>\n  <header class=\"masthead\">\n    <h1 class=\"brand\">\n      <img src=\"/mark.svg\" width=\"34\" height=\"34\" alt=\"\">\n      <span>IERMU Cam専用アプリ</span>\n    </h1>\n  </header>\n  <main class=\"shell\" id=\"shell\">\n    <div class=\"workspace\">\n      <section class=\"monitor\" aria-label=\"カメラの映像\">\n        <div class=\"monitor-bar\">\n          <span class=\"status-badge\" id=\"status-badge\" data-phase=\"idle\" role=\"status\"><i></i><span id=\"status-label\">停止中</span></span>\n          <span class=\"resolution\" id=\"resolution\" hidden></span>\n        </div>\n        <div class=\"screen\">\n          <img id=\"feed\" alt=\"カメラのライブ映像\" hidden>\n          <div class=\"empty\" id=\"empty\">\n            <svg class=\"reticle\" viewBox=\"0 0 32 32\" width=\"32\" height=\"32\" aria-hidden=\"true\">\n              <rect x=\"3.5\" y=\"8.5\" width=\"25\" height=\"17\" rx=\"4\"/>\n              <path d=\"M10 8.5 12 5.5h8l2 3\"/>\n              <circle cx=\"16\" cy=\"17\" r=\"4.5\"/>\n            </svg>\n            <p id=\"status-message\" hidden></p>\n          </div>\n        </div>\n      </section>\n\n      <aside class=\"controls\" id=\"controls\" aria-label=\"再生と共有の設定\" hidden>\n        <div class=\"mode-switch\" aria-label=\"見る端末を選択\">\n          <button type=\"button\" id=\"pc-mode\" aria-pressed=\"true\">PCで見る</button>\n          <button type=\"button\" id=\"phone-mode\" aria-pressed=\"false\">スマホで見る</button>\n        </div>\n        <section id=\"pc-panel\" aria-labelledby=\"pc-title\">\n          <h2 id=\"pc-title\">カメラを接続</h2>\n          <form id=\"camera-form\">\n            <button class=\"primary share-start\" type=\"button\" id=\"find-camera\">カメラを探す</button>\n            <div id=\"camera-results\" hidden>\n              <label for=\"camera-choice\">見つかったカメラ</label>\n              <select id=\"camera-choice\"></select>\n            </div>\n            <div class=\"actions\">\n              <button class=\"secondary\" type=\"submit\" id=\"start\" disabled><span aria-hidden=\"true\">▶</span> 再生開始</button>\n              <button type=\"button\" class=\"secondary\" id=\"stop\" disabled>停止</button>\n            </div>\n            <details class=\"guide\">\n              <summary>詳細設定</summary>\n              <label for=\"camera-ip\">カメラのIPアドレス</label>\n              <input id=\"camera-ip\" inputmode=\"decimal\" spellcheck=\"false\" required>\n              <label for=\"camera-mac\">MACアドレス（本体シール）</label>\n              <input id=\"camera-mac\" placeholder=\"00:00:00:00:00:00\" maxlength=\"17\" autocapitalize=\"off\" spellcheck=\"false\" required>\n              <div class=\"field-heading\">\n                <label for=\"camera-source\">PCの接続先</label>\n                <button class=\"link-button\" type=\"button\" id=\"refresh\">更新</button>\n              </div>\n              <select id=\"camera-source\" required><option value=\"\">接続先を取得中</option></select>\n              <label for=\"duration\">自動停止</label>\n              <select id=\"duration\">\n                <option value=\"120\">2分</option>\n                <option value=\"600\" selected>10分</option>\n                <option value=\"1800\">30分</option>\n              </select>\n            </details>\n          </form>\n          <details class=\"guide\" id=\"direct-guide\">\n            <summary>カメラに直接つなぐ場合</summary>\n            <p>本体のRボタンを確認音が2回鳴るまで押します。Windowsで「iermuly…」に接続し、「カメラを探す」を押します。</p>\n          </details>\n        </section>\n        <section id=\"phone-panel\" aria-labelledby=\"phone-title\" hidden>\n          <h2 id=\"phone-title\">スマホに共有</h2>\n          <p class=\"hint\">PCで再生開始。スマホは同じLANへ。</p>\n          <button class=\"primary share-start\" type=\"button\" id=\"share\" disabled>リンクを発行</button>\n          <details class=\"guide\" id=\"share-settings\">\n            <summary>共有の接続先</summary>\n            <label for=\"share-source\">スマホと同じLANのPCアドレス</label>\n            <select id=\"share-source\"><option value=\"\">接続先を取得中</option></select>\n          </details>\n          <div class=\"invite\" id=\"invite\" hidden>\n            <img id=\"qr\" width=\"152\" height=\"152\" alt=\"スマホ用リンクのQRコード\" hidden>\n            <label for=\"share-link\">スマホ用リンク</label>\n            <input id=\"share-link\" type=\"text\" readonly aria-label=\"スマホ用リンク\">\n            <div class=\"actions\">\n              <button class=\"secondary\" type=\"button\" id=\"copy\">リンクをコピー</button>\n              <button class=\"secondary\" type=\"button\" id=\"unshare\">共有終了</button>\n            </div>\n          </div>\n        </section>\n        <p class=\"notice\" id=\"notice\" role=\"status\" hidden></p>\n      </aside>\n    </div>\n  </main>\n</body>\n</html>\n", "web_iermu/mark.svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 48 48\">\n  <rect width=\"48\" height=\"48\" rx=\"13\" fill=\"#e5ecea\"/>\n  <g fill=\"none\" stroke=\"#3a5751\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\">\n    <rect x=\"10\" y=\"15\" width=\"28\" height=\"20\" rx=\"4\"/>\n    <path d=\"m17 15 2-4h10l2 4\"/>\n    <circle cx=\"24\" cy=\"25\" r=\"5.5\"/>\n  </g>\n</svg>\n"}'))