From 31962181cb2418ebf1fc5ea30750977d9462bf09 Mon Sep 17 00:00:00 2001
From: Felipe Santos <felipecassiors@gmail.com>
Date: Tue, 25 Nov 2025 16:37:08 -0300
Subject: [PATCH 01/26] Add `#timeout` param for ffmpeg source

---
 README.md                      |  7 +++++--
 internal/ffmpeg/ffmpeg.go      | 20 ++++++++++++++++----
 internal/ffmpeg/ffmpeg_test.go |  5 +++++
 3 files changed, 26 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index f27afeb0..1861433d 100644
--- a/README.md
+++ b/README.md
@@ -371,9 +371,11 @@ But you can override them via YAML config. You can also add your own formats to
 ```yaml
 ffmpeg:
   bin: ffmpeg  # path to ffmpeg binary
+  global: "-hide_banner"
+  timeout: 5  # default timeout in seconds for rtsp inputs
   h264: "-codec:v libx264 -g:v 30 -preset:v superfast -tune:v zerolatency -profile:v main -level:v 4.1"
   mycodec: "-any args that supported by ffmpeg..."
-  myinput: "-fflags nobuffer -flags low_delay -timeout 5000000 -i {input}"
+  myinput: "-fflags nobuffer -flags low_delay -timeout {timeout} -i {input}"
   myraw: "-ss 00:00:20"
 ```
 
@@ -383,9 +385,10 @@ ffmpeg:
 - You can use `width` and/or `height` params, important with transcoding (ex. `#video=h264#width=1280`)
 - You can use `drawtext` to add a timestamp (ex. `drawtext=x=2:y=2:fontsize=12:fontcolor=white:box=1:boxcolor=black`)
   - This will greatly increase the CPU of the server, even with hardware acceleration
+- You can use `timeout` param to set RTSP input timeout in seconds (ex. `#timeout=10`)
 - You can use `raw` param for any additional FFmpeg arguments (ex. `#raw=-vf transpose=1`)
 - You can use `input` param to override default input template (ex. `#input=rtsp/udp` will change RTSP transport from TCP to UDP+TCP)
-  - You can use raw input value (ex. `#input=-timeout 5000000 -i {input}`)
+  - You can use raw input value (ex. `#input=-timeout {timeout} -i {input}`)
   - You can add your own input templates
 
 Read more about [hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration).
diff --git a/internal/ffmpeg/ffmpeg.go b/internal/ffmpeg/ffmpeg.go
index 242c151d..d945c0ff 100644
--- a/internal/ffmpeg/ffmpeg.go
+++ b/internal/ffmpeg/ffmpeg.go
@@ -2,6 +2,7 @@ package ffmpeg
 
 import (
 	"net/url"
+	"strconv"
 	"strings"
 
 	"github.com/AlexxIT/go2rtc/internal/api"
@@ -60,13 +61,14 @@ func Init() {
 var defaults = map[string]string{
 	"bin":    "ffmpeg",
 	"global": "-hide_banner",
+	"timeout": "5",
 
 	// inputs
-	"file": "-re -i {input}",
-	"http": "-fflags nobuffer -flags low_delay -i {input}",
-	"rtsp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}",
+	"file":    "-re -i {input}",
+	"http":    "-fflags nobuffer -flags low_delay -i {input}",
+	"rtsp":    "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}",
 
-	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i {input}",
+	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -i {input}",
 
 	// output
 	"output":       "-user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}",
@@ -169,6 +171,16 @@ func inputTemplate(name, s string, query url.Values) string {
 	} else {
 		template = defaults[name]
 	}
+	if strings.Contains(template, "{timeout}") {
+		timeout := query.Get("timeout")
+		if timeout == "" {
+			timeout = defaults["timeout"]
+		}
+		if i, _ := strconv.Atoi(timeout); i > 0 {
+			timeout = strconv.Itoa(i * 1000000)
+		}
+		template = strings.Replace(template, "{timeout}", timeout, 1)
+	}
 	return strings.Replace(template, "{input}", s, 1)
 }
 
diff --git a/internal/ffmpeg/ffmpeg_test.go b/internal/ffmpeg/ffmpeg_test.go
index 30052d78..b9d02183 100644
--- a/internal/ffmpeg/ffmpeg_test.go
+++ b/internal/ffmpeg/ffmpeg_test.go
@@ -123,6 +123,11 @@ func TestParseArgsIpCam(t *testing.T) {
 			source: "rtmp://example.com#input=rtsp/udp",
 			expect: `ffmpeg -hide_banner -fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i rtmp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
 		},
+		{
+			name:   "[RTSP] custom timeout",
+			source: "rtsp://example.com#timeout=10",
+			expect: `ffmpeg -hide_banner -allowed_media_types video+audio -fflags nobuffer -flags low_delay -timeout 10000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i rtsp://example.com -c copy -user_agent ffmpeg/go2rtc -rtsp_transport tcp -f rtsp {output}`,
+		},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {

From 1e5def35c95973df6a5ad6e0d84d4e382a416037 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sun, 14 Dec 2025 04:47:27 +0300
Subject: [PATCH 02/26] monaco initial

---
 www/config.html | 445 ++++++++++++++++++++++++++++++++++++++++----
 www/schema.json | 477 ++++++++++++++++++++++++++++++++++++++++++++++++
 www/static.go   |   1 +
 3 files changed, 888 insertions(+), 35 deletions(-)
 create mode 100644 www/schema.json

diff --git a/www/config.html b/www/config.html
index 7a712a3b..345bddd3 100644
--- a/www/config.html
+++ b/www/config.html
@@ -4,11 +4,17 @@
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <title>config - go2rtc</title>
-    <script src="https://unpkg.com/ace-builds@1.33.1/src-min/ace.js"></script>
     <style>
-        html, body, #config {
+        html, body {
             height: 100%;
         }
+
+        #config {
+            flex: 1 1 auto;
+            min-height: 0;
+            border-top: 1px solid #ccc;
+            min-height: 300px;
+        }
     </style>
 </head>
 <body>
@@ -22,44 +28,413 @@
 </main>
 <div id="config"></div>
 
+<script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js"></script>
 <script>
-    /* global ace */
-    ace.config.set('basePath', 'https://unpkg.com/ace-builds@1.33.1/src-min/');
-    const editor = ace.edit('config', {
-        mode: 'ace/mode/yaml',
-    });
+    /* global require, monaco */
+    const monacoVersion = '0.52.2';
+    const monacoRoot = `https://cdn.jsdelivr.net/npm/monaco-editor@${monacoVersion}/min`;
+    const monacoBase = `${monacoRoot}/vs`;
 
-    let dump;
-
-    document.getElementById('save').addEventListener('click', async () => {
-        let r = await fetch('api/config', {cache: 'no-cache'});
-        if (r.ok && dump !== await r.text()) {
-            alert('Config was changed from another place. Refresh the page and make changes again');
-            return;
+    window.MonacoEnvironment = {
+        getWorkerUrl: function () {
+            return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
+                self.MonacoEnvironment = { baseUrl: '${monacoRoot}/' };
+                importScripts('${monacoBase}/base/worker/workerMain.js');
+            `)}`;
         }
+    };
 
-        r = await fetch('api/config', {method: 'POST', body: editor.getValue()});
-        if (r.ok) {
-            alert('OK');
-            dump = editor.getValue();
-            await fetch('api/restart', {method: 'POST'});
-        } else {
-            alert(await r.text());
-        }
-    });
+    require.config({ paths: { vs: monacoBase } });
 
-    window.addEventListener('load', async () => {
-        const r = await fetch('api/config', {cache: 'no-cache'});
-        if (r.status === 410) {
-            alert('Config file is not set');
-        } else if (r.status === 404) {
-            editor.setValue(''); // config file not exist
-        } else if (r.ok) {
-            dump = await r.text();
-            editor.setValue(dump);
-        } else {
-            alert(`Unknown error: ${r.statusText} (${r.status})`);
-        }
+    require(['vs/editor/editor.main'], () => {
+        const container = document.getElementById('config');
+        container.textContent = '';
+
+        const ensureYamlLanguage = () => {
+            const hasYaml = (monaco.languages.getLanguages?.() || []).some((l) => l.id === 'yaml');
+            if (hasYaml) return;
+
+            monaco.languages.register({
+                id: 'yaml',
+                extensions: ['.yaml', '.yml'],
+                aliases: ['YAML', 'yaml'],
+                mimetypes: ['application/x-yaml', 'text/yaml'],
+            });
+
+            monaco.languages.setLanguageConfiguration('yaml', {
+                comments: {lineComment: '#'},
+                brackets: [['{', '}'], ['[', ']'], ['(', ')']],
+                autoClosingPairs: [
+                    {open: '{', close: '}'},
+                    {open: '[', close: ']'},
+                    {open: '(', close: ')'},
+                    {open: '"', close: '"'},
+                    {open: '\'', close: '\''},
+                ],
+                surroundingPairs: [
+                    {open: '{', close: '}'},
+                    {open: '[', close: ']'},
+                    {open: '(', close: ')'},
+                    {open: '"', close: '"'},
+                    {open: '\'', close: '\''},
+                ],
+            });
+
+            monaco.languages.setMonarchTokensProvider('yaml', {
+                tokenizer: {
+                    root: [
+                        [/^\s*(---|\.\.\.)\s*$/, 'delimiter'],
+                        [/#.*$/, 'comment'],
+                        [/^\s*-\s+/, 'delimiter'],
+                        [/[A-Za-z0-9_-]+(?=\s*:)/, 'key'],
+                        [/:/, 'delimiter'],
+                        [/[{}\[\](),]/, 'delimiter'],
+                        [/\b(true|false|null|~)\b/, 'keyword'],
+                        [/-?\d+(\.\d+)?\b/, 'number'],
+                        [/"/, 'string', '@string_double'],
+                        [/'/, 'string', '@string_single'],
+                        [/[^#\s{}\[\](),]+/, 'string'],
+                        [/\s+/, ''],
+                    ],
+                    string_double: [
+                        [/[^\\"]+/, 'string'],
+                        [/\\./, 'string.escape'],
+                        [/"/, 'string', '@pop'],
+                    ],
+                    string_single: [
+                        [/[^']+/, 'string'],
+                        [/'/, 'string', '@pop'],
+                    ],
+                },
+            });
+        };
+
+        ensureYamlLanguage();
+
+        const prefersDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
+        monaco.editor.setTheme(prefersDark ? 'vs-dark' : 'vs');
+
+        const editor = monaco.editor.create(container, {
+            language: 'yaml',
+            minimap: { enabled: false },
+            automaticLayout: true,
+            tabSize: 2,
+            insertSpaces: true,
+            quickSuggestions: { other: true, comments: false, strings: true },
+            suggestOnTriggerCharacters: true,
+            scrollBeyondLastLine: false,
+        });
+
+        const layout = () => {
+            const top = container.getBoundingClientRect().top;
+            container.style.height = `${Math.max(200, window.innerHeight - top)}px`;
+            editor.layout();
+        };
+        window.addEventListener('resize', layout);
+        layout();
+
+        const stripInlineComment = (line) => {
+            let inSingle = false;
+            let inDouble = false;
+            for (let i = 0; i < line.length; i++) {
+                const ch = line[i];
+                if (ch === '\'' && !inDouble) {
+                    inSingle = !inSingle;
+                    continue;
+                }
+                if (ch === '"' && !inSingle) {
+                    inDouble = !inDouble;
+                    continue;
+                }
+                if (ch === '#' && !inSingle && !inDouble) {
+                    if (i === 0 || /\s/.test(line[i - 1])) return line.slice(0, i);
+                }
+            }
+            return line;
+        };
+
+        const countIndent = (line) => {
+            let indent = 0;
+            for (let i = 0; i < line.length; i++) {
+                if (line[i] === ' ') {
+                    indent++;
+                } else if (line[i] === '\t') {
+                    indent += 2;
+                } else {
+                    break;
+                }
+            }
+            return indent;
+        };
+
+        const parseListItem = (line) => {
+            const m = line.match(/^(\s*)-\s*(.*)$/);
+            if (!m) return null;
+            return {indent: countIndent(m[1]), rest: m[2]};
+        };
+
+        const parseKey = (line) => {
+            const m = line.match(/^(\s*)([A-Za-z0-9_-]+)\s*:(.*)$/);
+            if (!m) return null;
+            const after = m[3] ?? '';
+            const isContainer = after.trim() === '' || after.trim().startsWith('#');
+            return {indent: countIndent(m[1]), key: m[2], isContainer, after};
+        };
+
+        const unique = (arr) => [...new Set(arr)];
+
+        const toYamlScalar = (v) => {
+            if (v === '') return '\'\'';
+            if (typeof v === 'string') return v;
+            if (typeof v === 'number') return String(v);
+            if (typeof v === 'boolean') return v ? 'true' : 'false';
+            return JSON.stringify(v);
+        };
+
+        const setupYamlHints = (schemaRoot) => {
+            const resolveRef = (schema, seen = new Set()) => {
+                if (!schema || typeof schema !== 'object') return schema;
+                if (typeof schema.$ref === 'string') {
+                    const ref = schema.$ref;
+                    if (ref.startsWith('#/definitions/')) {
+                        if (seen.has(ref)) return schema;
+                        seen.add(ref);
+                        const name = ref.slice('#/definitions/'.length);
+                        const def = schemaRoot.definitions?.[name];
+                        if (!def) return schema;
+                        const resolved = resolveRef(def, seen);
+                        const {$ref, ...rest} = schema;
+                        return {...resolved, ...rest};
+                    }
+                }
+                return schema;
+            };
+
+            const mergeProps = (schemas) => {
+                const props = {};
+                for (const s of schemas) {
+                    const schema = resolveRef(s);
+                    if (schema && schema.properties && typeof schema.properties === 'object') {
+                        Object.assign(props, schema.properties);
+                    }
+                }
+                return props;
+            };
+
+            const getObjectProperties = (schema) => {
+                schema = resolveRef(schema);
+                if (!schema) return {};
+                if (schema.properties && typeof schema.properties === 'object') return schema.properties;
+                if (Array.isArray(schema.anyOf)) return mergeProps(schema.anyOf);
+                return {};
+            };
+
+            const getPropertySchema = (schema, key) => {
+                schema = resolveRef(schema);
+                if (!schema) return null;
+
+                if (schema.properties && schema.properties[key]) return resolveRef(schema.properties[key]);
+
+                if (schema.additionalProperties && typeof schema.additionalProperties === 'object') {
+                    return resolveRef(schema.additionalProperties);
+                }
+
+                if (Array.isArray(schema.anyOf)) {
+                    for (const alt of schema.anyOf) {
+                        const res = getPropertySchema(alt, key);
+                        if (res) return res;
+                    }
+                }
+
+                return null;
+            };
+
+            const getValueSuggestions = (schema) => {
+                schema = resolveRef(schema);
+                if (!schema) return [];
+
+                const values = [];
+
+                const addFrom = (s) => {
+                    s = resolveRef(s);
+                    if (!s) return;
+                    if (Array.isArray(s.enum)) values.push(...s.enum);
+                    if ('const' in s) values.push(s.const);
+                    if (Array.isArray(s.examples)) values.push(...s.examples);
+                    if ('default' in s) values.push(s.default);
+                };
+
+                if (Array.isArray(schema.anyOf)) {
+                    for (const alt of schema.anyOf) addFrom(alt);
+                } else {
+                    addFrom(schema);
+                }
+
+                return unique(values);
+            };
+
+            const buildContextStack = (model, upToLineNumber) => {
+                const stack = [{indent: -1, schema: schemaRoot}];
+
+                for (let lineNumber = 1; lineNumber <= upToLineNumber; lineNumber++) {
+                    let line = model.getLineContent(lineNumber);
+                    if (!line.trim()) continue;
+
+                    line = stripInlineComment(line).trimEnd();
+                    if (!line.trim()) continue;
+
+                    const listItem = parseListItem(line);
+                    if (listItem) {
+                        while (stack.length > 1 && listItem.indent <= stack[stack.length - 1].indent) stack.pop();
+                        const parent = resolveRef(stack[stack.length - 1].schema);
+                        if (parent && parent.type === 'array' && parent.items) {
+                            stack.push({indent: listItem.indent, schema: resolveRef(parent.items)});
+                        } else {
+                            stack.push({indent: listItem.indent, schema: null});
+                        }
+
+                        const inline = listItem.rest ? parseKey(' '.repeat(listItem.indent + 2) + listItem.rest) : null;
+                        if (inline && inline.isContainer) {
+                            while (stack.length > 1 && inline.indent <= stack[stack.length - 1].indent) stack.pop();
+                            const ctx = resolveRef(stack[stack.length - 1].schema);
+                            const next = ctx ? getPropertySchema(ctx, inline.key) : null;
+                            stack.push({indent: inline.indent, schema: next});
+                        }
+                        continue;
+                    }
+
+                    const kv = parseKey(line);
+                    if (!kv) continue;
+                    while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
+                    if (!kv.isContainer) continue;
+
+                    const ctx = resolveRef(stack[stack.length - 1].schema);
+                    const next = ctx ? getPropertySchema(ctx, kv.key) : null;
+                    stack.push({indent: kv.indent, schema: next});
+                }
+
+                return stack;
+            };
+
+            monaco.languages.registerCompletionItemProvider('yaml', {
+                triggerCharacters: [':', ' '],
+                provideCompletionItems: (model, position) => {
+                    const line = model.getLineContent(position.lineNumber);
+                    const lineNoComment = stripInlineComment(line).trimEnd();
+                    const listItem = parseListItem(lineNoComment);
+
+                    const {word, startColumn, endColumn} = model.getWordUntilPosition(position);
+                    const range = new monaco.Range(position.lineNumber, startColumn, position.lineNumber, endColumn);
+
+                    const cursorIndex = position.column - 1;
+                    let contentStartIndex = 0;
+                    if (listItem) {
+                        contentStartIndex = listItem.indent;
+                        if (lineNoComment.slice(contentStartIndex, contentStartIndex + 1) === '-') contentStartIndex += 1;
+                        if (lineNoComment.slice(contentStartIndex, contentStartIndex + 1) === ' ') contentStartIndex += 1;
+                    } else {
+                        contentStartIndex = countIndent(lineNoComment);
+                    }
+
+                    if (cursorIndex < contentStartIndex) return {suggestions: []};
+
+                    const text = lineNoComment.slice(contentStartIndex);
+                    const cursorInText = cursorIndex - contentStartIndex;
+                    const colonIndex = text.indexOf(':');
+                    const isValueContext = colonIndex >= 0 && cursorInText > colonIndex;
+
+                    const stack = buildContextStack(model, position.lineNumber - 1);
+
+                    const effectiveIndent = listItem ? listItem.indent + 2 : countIndent(lineNoComment);
+                    while (stack.length > 1 && effectiveIndent <= stack[stack.length - 1].indent) stack.pop();
+
+                    let contextSchema = resolveRef(stack[stack.length - 1].schema);
+
+                    if (listItem && cursorIndex >= listItem.indent + 2 && contextSchema && contextSchema.type === 'array') {
+                        contextSchema = resolveRef(contextSchema.items);
+                    }
+
+                    if (!contextSchema) return {suggestions: []};
+
+                    if (!isValueContext) {
+                        const props = getObjectProperties(contextSchema);
+                        const suggestions = Object.keys(props).map((key) => {
+                            const s = resolveRef(props[key]);
+                            const wantsBlock = s && (s.type === 'object' || s.type === 'array' || s.properties);
+                            const indent = listItem ? ' '.repeat(listItem.indent + 2) : ' '.repeat(countIndent(lineNoComment));
+                            const innerIndent = indent + '  ';
+
+                            const insertText = wantsBlock ? `${key}:\n${innerIndent}` : `${key}: `;
+
+                            return {
+                                label: key,
+                                kind: monaco.languages.CompletionItemKind.Property,
+                                insertText,
+                                insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                                documentation: s?.description,
+                                range,
+                            };
+                        });
+
+                        return {suggestions};
+                    }
+
+                    const keyName = text.slice(0, colonIndex).trim();
+                    const keySchema = getPropertySchema(contextSchema, keyName);
+                    if (!keySchema) return {suggestions: []};
+
+                    const values = getValueSuggestions(keySchema);
+                    const suggestions = values.map((v) => ({
+                        label: toYamlScalar(v),
+                        kind: monaco.languages.CompletionItemKind.Value,
+                        insertText: toYamlScalar(v),
+                        range,
+                    }));
+
+                    return {suggestions};
+                }
+            });
+        };
+
+        let dump;
+
+        document.getElementById('save').addEventListener('click', async () => {
+            let r = await fetch('api/config', {cache: 'no-cache'});
+            if (r.ok && dump !== await r.text()) {
+                alert('Config was changed from another place. Refresh the page and make changes again');
+                return;
+            }
+
+            r = await fetch('api/config', {method: 'POST', body: editor.getValue()});
+            if (r.ok) {
+                alert('OK');
+                dump = editor.getValue();
+                await fetch('api/restart', {method: 'POST'});
+            } else {
+                alert(await r.text());
+            }
+        });
+
+        (async () => {
+            try {
+                const schemaRes = await fetch('schema.json', {cache: 'no-cache'});
+                if (schemaRes.ok) setupYamlHints(await schemaRes.json());
+            } catch (e) {
+                // ignore schema load errors
+            }
+
+            const r = await fetch('api/config', {cache: 'no-cache'});
+            if (r.status === 410) {
+                alert('Config file is not set');
+            } else if (r.status === 404) {
+                editor.setValue(''); // config file not exist
+            } else if (r.ok) {
+                dump = await r.text();
+                editor.setValue(dump);
+            } else {
+                alert(`Unknown error: ${r.statusText} (${r.status})`);
+            }
+        })();
     });
 </script>
 
diff --git a/www/schema.json b/www/schema.json
new file mode 100644
index 00000000..fbf8c022
--- /dev/null
+++ b/www/schema.json
@@ -0,0 +1,477 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "go2rtc",
+  "type": "object",
+  "additionalProperties": false,
+  "definitions": {
+    "listen": {
+      "type": "string",
+      "anyOf": [
+        {
+          "type": "string",
+          "pattern": ":[0-9]{1,5}$"
+        },
+        {
+          "type": "string",
+          "const": ""
+        }
+      ]
+    },
+    "log_level": {
+      "type": "string",
+      "enum": [
+        "trace",
+        "debug",
+        "info",
+        "warn",
+        "error"
+      ]
+    }
+  },
+  "properties": {
+    "api": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "default": ":1984",
+          "examples": [
+            "127.0.0.1:8080"
+          ],
+          "$ref": "#/definitions/listen"
+        },
+        "username": {
+          "type": "string",
+          "examples": [
+            "admin"
+          ]
+        },
+        "password": {
+          "type": "string"
+        },
+        "local_auth": {
+          "description": "Will use Auth header from local network",
+          "type": "boolean",
+          "default": false
+        },
+        "base_path": {
+          "type": "string",
+          "default": ""
+        },
+        "static_dir": {
+          "type": "string",
+          "default": ""
+        },
+        "origin": {
+          "type": "string",
+          "default": "*"
+        },
+        "tls_listen": {
+          "$ref": "#/definitions/listen"
+        },
+        "tls_cert": {
+          "type": "string",
+          "examples": [
+            "/etc/ssl/certs/my_certificate.pem"
+          ]
+        },
+        "tls_key": {
+          "type": "string",
+          "examples": [
+            "/etc/ssl/private/my_certificate_key.pem"
+          ]
+        },
+        "unix_listen": {
+          "type": "string",
+          "examples": [
+            "/tmp/go2rtc.sock"
+          ]
+        }
+      }
+    },
+    "ffmpeg": {
+      "type": "object",
+      "properties": {
+        "bin": {
+          "type": "string",
+          "default": "ffmpeg"
+        }
+      },
+      "additionalProperties": {
+        "description": "FFmpeg template",
+        "type": "string"
+      }
+    },
+    "hass": {
+      "type": "object",
+      "properties": {
+        "config": {
+          "type": "string",
+          "examples": [
+            "/config/go2rtc.yaml"
+          ]
+        },
+        "api": {
+          "type": "object",
+          "properties": {
+            "listen": {
+              "default": ":8124",
+              "$ref": "#/definitions/listen"
+            }
+          }
+        }
+      }
+    },
+    "homekit": {
+      "type": "object",
+      "properties": {
+        "pin": {
+          "type": "string",
+          "default": "123-45-678"
+        },
+        "name": {
+          "type": "string",
+          "default": "go2rtc"
+        },
+        "device_id": {
+          "type": "string",
+          "default": ""
+        },
+        "device_private": {
+          "type": "string",
+          "default": ""
+        },
+        "category_id": {
+          "type": "integer",
+          "default": 2
+        },
+        "pairings": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "log": {
+      "type": "object",
+      "properties": {
+        "format": {
+          "type": "string",
+          "default": "color",
+          "enum": [
+            "color",
+            "json",
+            "text"
+          ]
+        },
+        "level": {
+          "description": "Defaul log level",
+          "default": "info",
+          "$ref": "#/definitions/log_level"
+        },
+        "output": {
+          "type": "string",
+          "default": "stdout",
+          "enum": [
+            "",
+            "stdout",
+            "stderr"
+          ]
+        },
+        "time": {
+          "type": "string",
+          "default": "UNIXMS",
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "",
+                "UNIXMS",
+                "UNIXMICRO",
+                "UNIXNANO",
+                "2006-01-02T15:04:05Z07:00",
+                "2006-01-02T15:04:05.999999999Z07:00"
+              ]
+            },
+            {
+              "type": "string"
+            }
+          ]
+        },
+        "api": {
+          "$ref": "#/definitions/log_level"
+        },
+        "echo": {
+          "$ref": "#/definitions/log_level"
+        },
+        "exec": {
+          "description": "Value `exec: debug` will print stderr",
+          "$ref": "#/definitions/log_level"
+        },
+        "expr": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ffmpeg": {
+          "description": "Will only be displayed with `exec: debug` setting",
+          "default": "error",
+          "$ref": "#/definitions/log_level"
+        },
+        "hass": {
+          "$ref": "#/definitions/log_level"
+        },
+        "hls": {
+          "$ref": "#/definitions/log_level"
+        },
+        "homekit": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mp4": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ngrok": {
+          "$ref": "#/definitions/log_level"
+        },
+        "onvif": {
+          "$ref": "#/definitions/log_level"
+        },
+        "rtmp": {
+          "$ref": "#/definitions/log_level"
+        },
+        "rtsp": {
+          "$ref": "#/definitions/log_level"
+        },
+        "streams": {
+          "$ref": "#/definitions/log_level"
+        },
+        "webrtc": {
+          "$ref": "#/definitions/log_level"
+        },
+        "webtorrent": {
+          "$ref": "#/definitions/log_level"
+        }
+      }
+    },
+    "ngrok": {
+      "type": "object",
+      "properties": {
+        "command": {
+          "description": "ngrok start --all --config ngrok.yaml",
+          "type": "string"
+        }
+      }
+    },
+    "publish": {
+      "type": "object",
+      "additionalProperties": {
+        "anyOf": [
+          {
+            "type": "string",
+            "examples": [
+              "rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx",
+              "rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx"
+            ]
+          },
+          {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        ]
+      }
+    },
+    "rtmp": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "examples": [
+            ":1935"
+          ],
+          "$ref": "#/definitions/listen"
+        }
+      }
+    },
+    "rtsp": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "default": ":8554",
+          "$ref": "#/definitions/listen"
+        },
+        "username": {
+          "type": "string"
+        },
+        "password": {
+          "type": "string"
+        },
+        "default_query": {
+          "type": "string",
+          "default": ""
+        },
+        "pkt_size": {
+          "type": "integer",
+          "default": 0
+        }
+      }
+    },
+    "srtp": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "default": ":8443",
+          "$ref": "#/definitions/listen"
+        }
+      }
+    },
+    "streams": {
+      "type": "object",
+      "additionalProperties": {
+        "title": "Stream",
+        "anyOf": [
+          {
+            "description": "Source",
+            "type": "string",
+            "examples": [
+              "rtsp://username:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
+              "rtsp://username:password@192.168.1.123/stream1",
+              "rtsp://username:password@192.168.1.123/h264Preview_01_main",
+              "rtmp://192.168.1.123/bcs/channel0_main.bcs?channel=0&stream=0&user=username&password=password",
+              "http://192.168.1.123/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password",
+              "http://username:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1",
+              "ffmpeg:media.mp4#video=h264#hardware#width=1920#height=1080#rotate=180#audio=copy",
+              "ffmpeg:virtual?video=testsrc&size=4K#video=h264#hardware#bitrate=50M",
+              "bubble://username:password@192.168.1.123:34567/bubble/live?ch=0&stream=0",
+              "dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0",
+              "exec:ffmpeg -re -i media.mp4 -c copy -rtsp_transport tcp -f rtsp {output}",
+              "isapi://username:password@192.168.1.123:80/",
+              "kasa://username:password@192.168.1.123:19443/https/stream/mixed",
+              "onvif://username:password@192.168.1.123:80?subtype=0",
+              "tapo://password@192.168.1.123:8800?channel=0&subtype=0",
+              "webtorrent:?share=xxx&pwd=xxx"
+            ]
+          },
+          {
+            "type": "array",
+            "items": {
+              "description": "Source",
+              "type": "string"
+            }
+          }
+        ]
+      }
+    },
+    "webrtc": {
+      "type": "object",
+      "properties": {
+        "listen": {
+          "default": ":8555",
+          "$ref": "#/definitions/listen"
+        },
+        "candidates": {
+          "type": "array",
+          "items": {
+            "type": "string",
+            "examples": [
+              "192.168.1.123",
+              "stun:stun.l.google.com:19302"
+            ]
+          }
+        },
+        "ice_servers": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "properties": {
+              "urls": {
+                "type": "array",
+                "items": {
+                  "type": "string",
+                  "examples": [
+                    "stun:stun.l.google.com:19302",
+                    "turn:123.123.123.123:3478"
+                  ]
+                }
+              },
+              "username": {
+                "type": "string"
+              },
+              "credential": {
+                "type": "string"
+              }
+            }
+          }
+        },
+        "filters": {
+          "type": "object",
+          "properties": {
+            "candidates": {
+              "description": "Keep only these candidates",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "interfaces": {
+              "description": "Keep only these interfaces",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "ips": {
+              "description": "Keep only these IP-addresses",
+              "type": "array",
+              "items": {
+                "type": "string"
+              }
+            },
+            "networks": {
+              "description": "Use only these network types",
+              "type": "array",
+              "items": {
+                "enum": [
+                  "tcp4",
+                  "tcp6",
+                  "udp4",
+                  "udp6"
+                ],
+                "type": "string"
+              }
+            },
+            "udp_ports": {
+              "description": "Use only these UDP ports range [min, max]",
+              "type": "array",
+              "items": {
+                "type": "integer"
+              },
+              "maxItems": 2,
+              "minItems": 2
+            }
+          }
+        }
+      }
+    },
+    "webtorrent": {
+      "type": "object",
+      "properties": {
+        "trackers": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "shares": {
+          "type": "object",
+          "properties": {
+            "pwd": {
+              "type": "string"
+            },
+            "src": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/www/static.go b/www/static.go
index 01f50906..064fec36 100644
--- a/www/static.go
+++ b/www/static.go
@@ -4,4 +4,5 @@ import "embed"
 
 //go:embed *.html
 //go:embed *.js
+//go:embed *.json
 var Static embed.FS

From ce9138b3548c8734453395c55376e15d9c928337 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sun, 14 Dec 2025 04:52:35 +0300
Subject: [PATCH 03/26] update monaco to 0.55.1

---
 www/config.html | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/www/config.html b/www/config.html
index 345bddd3..62cceab4 100644
--- a/www/config.html
+++ b/www/config.html
@@ -28,10 +28,10 @@
 </main>
 <div id="config"></div>
 
-<script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs/loader.js"></script>
 <script>
     /* global require, monaco */
-    const monacoVersion = '0.52.2';
+    const monacoVersion = '0.55.1';
     const monacoRoot = `https://cdn.jsdelivr.net/npm/monaco-editor@${monacoVersion}/min`;
     const monacoBase = `${monacoRoot}/vs`;
 

From d041c89c5c32d2b6e13eacdd2651e1a542ab695e Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sun, 14 Dec 2025 05:20:59 +0300
Subject: [PATCH 04/26] schema improvements

---
 website/schema.json | 382 ++++++++++++++++++++++++++++++++++---
 www/config.html     |  15 ++
 www/schema.json     | 451 +++++++++++++++++++++++++++++++++++++++-----
 3 files changed, 774 insertions(+), 74 deletions(-)

diff --git a/website/schema.json b/website/schema.json
index 530616c6..726879e3 100644
--- a/website/schema.json
+++ b/website/schema.json
@@ -24,7 +24,10 @@
         "debug",
         "info",
         "warn",
-        "error"
+        "error",
+        "fatal",
+        "panic",
+        "disabled"
       ]
     }
   },
@@ -48,6 +51,11 @@
         "password": {
           "type": "string"
         },
+        "local_auth": {
+          "description": "Allow auth from local network without credentials (uses existing Auth header)",
+          "type": "boolean",
+          "default": false
+        },
         "base_path": {
           "type": "string",
           "examples": [
@@ -61,8 +69,18 @@
           ]
         },
         "origin": {
+          "description": "Set to \"*\" to enable CORS and allow any Origin",
           "type": "string",
-          "const": "*"
+          "anyOf": [
+            {
+              "type": "string",
+              "const": "*"
+            },
+            {
+              "type": "string",
+              "const": ""
+            }
+          ]
         },
         "tls_listen": {
           "$ref": "#/definitions/listen"
@@ -86,6 +104,116 @@
           "examples": [
             "/tmp/go2rtc.sock"
           ]
+        },
+        "allow_paths": {
+          "description": "Allow only these HTTP paths (full paths, including base_path); when set, all other endpoints are not registered",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "/api/ws",
+              "/api/config",
+              "/api/streams"
+            ]
+          ]
+        }
+      }
+    },
+    "app": {
+      "type": "object",
+      "properties": {
+        "modules": {
+          "description": "Enable only these modules (empty / omitted means all)",
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "api",
+              "ws",
+              "http",
+              "rtsp",
+              "webrtc",
+              "mp4",
+              "hls",
+              "mjpeg",
+              "hass",
+              "homekit",
+              "onvif",
+              "rtmp",
+              "webtorrent",
+              "wyoming",
+              "echo",
+              "exec",
+              "expr",
+              "ffmpeg",
+              "alsa",
+              "v4l2",
+              "bubble",
+              "doorbird",
+              "dvrip",
+              "eseecloud",
+              "flussonic",
+              "gopro",
+              "isapi",
+              "ivideon",
+              "mpegts",
+              "nest",
+              "ring",
+              "roborock",
+              "tapo",
+              "tuya",
+              "yandex",
+              "debug",
+              "ngrok",
+              "pinggy",
+              "srtp"
+            ]
+          }
+        }
+      }
+    },
+    "env": {
+      "description": "Config variables that can be referenced as ${NAME} / ${NAME:default}",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "echo": {
+      "type": "object",
+      "properties": {
+        "allow_paths": {
+          "description": "Allow only these binaries for echo: URLs (exact cmd name/path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "ffmpeg",
+              "/usr/bin/ffmpeg"
+            ]
+          ]
+        }
+      }
+    },
+    "exec": {
+      "type": "object",
+      "properties": {
+        "allow_paths": {
+          "description": "Allow only these binaries for exec: URLs (exact cmd name/path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "ffmpeg",
+              "/usr/bin/ffmpeg"
+            ]
+          ]
         }
       }
     },
@@ -118,25 +246,56 @@
       "type": "object",
       "additionalProperties": {
         "type": "object",
-        "properties": {
-          "pin": {
-            "type": "string",
-            "default": "19550224",
-            "pattern": "^[0-9]{8}$"
-          },
-          "name": {
-            "type": "string"
-          },
+      "properties": {
+        "pin": {
+          "description": "HomeKit pairing PIN (will be normalized to XXX-XX-XXX); insecure PINs are rejected",
+          "type": "string",
+          "default": "19550224",
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[0-9]{8}$"
+            },
+            {
+              "type": "string",
+              "pattern": "^[0-9]{3}-[0-9]{2}-[0-9]{3}$"
+            }
+          ]
+        },
+        "name": {
+          "type": "string"
+        },
           "device_id": {
             "type": "string"
           },
-          "device_private": {
+        "device_private": {
+          "type": "string"
+        },
+        "category_id": {
+          "description": "Accessory category: \"bridge\", \"doorbell\" or numeric ID (default: camera)",
+          "type": "string",
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "bridge",
+                "doorbell"
+              ]
+            },
+            {
+              "type": "string",
+              "pattern": "^[0-9]+$"
+            },
+            {
+              "type": "string",
+              "const": ""
+            }
+          ]
+        },
+        "pairings": {
+          "type": "array",
+          "items": {
             "type": "string"
-          },
-          "pairings": {
-            "type": "array",
-            "items": {
-              "type": "string"
             }
           }
         }
@@ -146,9 +305,11 @@
       "type": "object",
       "properties": {
         "format": {
+          "description": "Log format: color/json/text or empty for autodetect",
           "type": "string",
           "default": "color",
           "enum": [
+            "",
             "color",
             "json",
             "text"
@@ -160,12 +321,26 @@
           "$ref": "#/definitions/log_level"
         },
         "output": {
+          "description": "Log output: stdout/stderr/file[:path] or empty (memory only)",
           "type": "string",
           "default": "stdout",
-          "enum": [
-            "",
-            "stdout",
-            "stderr"
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "",
+                "stdout",
+                "stderr"
+              ]
+            },
+            {
+              "type": "string",
+              "pattern": "^file(:.+)?$",
+              "examples": [
+                "file",
+                "file:go2rtc.log"
+              ]
+            }
           ]
         },
         "time": {
@@ -191,6 +366,24 @@
         "api": {
           "$ref": "#/definitions/log_level"
         },
+        "alsa": {
+          "$ref": "#/definitions/log_level"
+        },
+        "bubble": {
+          "$ref": "#/definitions/log_level"
+        },
+        "debug": {
+          "$ref": "#/definitions/log_level"
+        },
+        "doorbird": {
+          "$ref": "#/definitions/log_level"
+        },
+        "dvrip": {
+          "$ref": "#/definitions/log_level"
+        },
+        "eseecloud": {
+          "$ref": "#/definitions/log_level"
+        },
         "echo": {
           "$ref": "#/definitions/log_level"
         },
@@ -206,6 +399,12 @@
           "default": "error",
           "$ref": "#/definitions/log_level"
         },
+        "flussonic": {
+          "$ref": "#/definitions/log_level"
+        },
+        "gopro": {
+          "$ref": "#/definitions/log_level"
+        },
         "hass": {
           "$ref": "#/definitions/log_level"
         },
@@ -215,30 +414,78 @@
         "homekit": {
           "$ref": "#/definitions/log_level"
         },
+        "http": {
+          "$ref": "#/definitions/log_level"
+        },
+        "isapi": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ivideon": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mjpeg": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mpegts": {
+          "$ref": "#/definitions/log_level"
+        },
         "mp4": {
           "$ref": "#/definitions/log_level"
         },
+        "nest": {
+          "$ref": "#/definitions/log_level"
+        },
         "ngrok": {
           "$ref": "#/definitions/log_level"
         },
         "onvif": {
           "$ref": "#/definitions/log_level"
         },
+        "pinggy": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ring": {
+          "$ref": "#/definitions/log_level"
+        },
+        "roborock": {
+          "$ref": "#/definitions/log_level"
+        },
         "rtmp": {
           "$ref": "#/definitions/log_level"
         },
         "rtsp": {
           "$ref": "#/definitions/log_level"
         },
+        "srtp": {
+          "$ref": "#/definitions/log_level"
+        },
         "streams": {
           "$ref": "#/definitions/log_level"
         },
+        "tapo": {
+          "$ref": "#/definitions/log_level"
+        },
+        "tuya": {
+          "$ref": "#/definitions/log_level"
+        },
+        "v4l2": {
+          "$ref": "#/definitions/log_level"
+        },
         "webrtc": {
           "$ref": "#/definitions/log_level"
         },
         "webtorrent": {
           "$ref": "#/definitions/log_level"
+        },
+        "wyoming": {
+          "$ref": "#/definitions/log_level"
+        },
+        "yandex": {
+          "$ref": "#/definitions/log_level"
         }
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/log_level"
       }
     },
     "ngrok": {
@@ -253,6 +500,30 @@
         }
       }
     },
+    "pinggy": {
+      "type": "object",
+      "properties": {
+        "tunnel": {
+          "description": "Expose local address via Pinggy (scheme: http/tcp/tls/tlstcp, host:port is your local address)",
+          "type": "string",
+          "examples": [
+            "http://127.0.0.1:1984",
+            "tcp://127.0.0.1:8554"
+          ]
+        }
+      }
+    },
+    "preload": {
+      "description": "Preload streams on startup (map stream name => probe query, default \"video&audio\")",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "examples": [
+          "video&audio",
+          "video"
+        ]
+      }
+    },
     "publish": {
       "type": "object",
       "additionalProperties": {
@@ -352,6 +623,29 @@
               "description": "Source",
               "type": "string"
             }
+          },
+          {
+            "type": "object",
+            "properties": {
+              "url": {
+                "description": "Source URL or list of URLs",
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "examples": [
+                      "rtsp://username:password@192.168.1.123/stream1",
+                      "ffmpeg:media.mp4#video=h264#audio=copy"
+                    ]
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                ]
+              }
+            }
           }
         ]
       }
@@ -472,7 +766,8 @@
             "type": "object",
             "properties": {
               "pwd": {
-                "type": "string"
+                "type": "string",
+                "minLength": 4
               },
               "src": {
                 "type": "string"
@@ -481,6 +776,49 @@
           }
         }
       }
+    },
+    "wyoming": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "listen": {
+            "description": "Listen address for Wyoming server",
+            "$ref": "#/definitions/listen"
+          },
+          "name": {
+            "description": "Optional satellite name (default: stream name)",
+            "type": "string"
+          },
+          "mode": {
+            "description": "Optional mode: mic / snd / default",
+            "type": "string",
+            "enum": [
+              "",
+              "mic",
+              "snd"
+            ]
+          },
+          "event": {
+            "description": "Event handlers (map event type => expr script)",
+            "type": "object",
+            "additionalProperties": {
+              "type": "string"
+            }
+          },
+          "wake_uri": {
+            "description": "Optional WAKE service URI (ex. tcp://host:port?name=...)",
+            "type": "string",
+            "examples": [
+              "tcp://192.168.1.23:10400"
+            ]
+          },
+          "vad_threshold": {
+            "description": "Optional VAD threshold (0.1..3.5 typical)",
+            "type": "number"
+          }
+        }
+      }
     }
   }
 }
diff --git a/www/config.html b/www/config.html
index 62cceab4..9b973f80 100644
--- a/www/config.html
+++ b/www/config.html
@@ -356,6 +356,21 @@
 
                     if (!contextSchema) return {suggestions: []};
 
+                    // Scalar array item (e.g. "- tcp4") - suggest values (enum/examples/default)
+                    if (listItem && colonIndex === -1 && !isValueContext) {
+                        const props = getObjectProperties(contextSchema);
+                        if (!props || Object.keys(props).length === 0) {
+                            const values = getValueSuggestions(contextSchema);
+                            const suggestions = values.map((v) => ({
+                                label: toYamlScalar(v),
+                                kind: monaco.languages.CompletionItemKind.Value,
+                                insertText: toYamlScalar(v),
+                                range,
+                            }));
+                            return {suggestions};
+                        }
+                    }
+
                     if (!isValueContext) {
                         const props = getObjectProperties(contextSchema);
                         const suggestions = Object.keys(props).map((key) => {
diff --git a/www/schema.json b/www/schema.json
index fbf8c022..726879e3 100644
--- a/www/schema.json
+++ b/www/schema.json
@@ -24,7 +24,10 @@
         "debug",
         "info",
         "warn",
-        "error"
+        "error",
+        "fatal",
+        "panic",
+        "disabled"
       ]
     }
   },
@@ -49,21 +52,35 @@
           "type": "string"
         },
         "local_auth": {
-          "description": "Will use Auth header from local network",
+          "description": "Allow auth from local network without credentials (uses existing Auth header)",
           "type": "boolean",
           "default": false
         },
         "base_path": {
           "type": "string",
-          "default": ""
+          "examples": [
+            "/go2rtc"
+          ]
         },
         "static_dir": {
           "type": "string",
-          "default": ""
+          "examples": [
+            "/var/www"
+          ]
         },
         "origin": {
+          "description": "Set to \"*\" to enable CORS and allow any Origin",
           "type": "string",
-          "default": "*"
+          "anyOf": [
+            {
+              "type": "string",
+              "const": "*"
+            },
+            {
+              "type": "string",
+              "const": ""
+            }
+          ]
         },
         "tls_listen": {
           "$ref": "#/definitions/listen"
@@ -71,13 +88,15 @@
         "tls_cert": {
           "type": "string",
           "examples": [
-            "/etc/ssl/certs/my_certificate.pem"
+            "-----BEGIN CERTIFICATE-----",
+            "/ssl/fullchain.pem"
           ]
         },
         "tls_key": {
           "type": "string",
           "examples": [
-            "/etc/ssl/private/my_certificate_key.pem"
+            "-----BEGIN PRIVATE KEY-----",
+            "/ssl/privkey.pem"
           ]
         },
         "unix_listen": {
@@ -85,6 +104,116 @@
           "examples": [
             "/tmp/go2rtc.sock"
           ]
+        },
+        "allow_paths": {
+          "description": "Allow only these HTTP paths (full paths, including base_path); when set, all other endpoints are not registered",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "/api/ws",
+              "/api/config",
+              "/api/streams"
+            ]
+          ]
+        }
+      }
+    },
+    "app": {
+      "type": "object",
+      "properties": {
+        "modules": {
+          "description": "Enable only these modules (empty / omitted means all)",
+          "type": "array",
+          "items": {
+            "type": "string",
+            "enum": [
+              "api",
+              "ws",
+              "http",
+              "rtsp",
+              "webrtc",
+              "mp4",
+              "hls",
+              "mjpeg",
+              "hass",
+              "homekit",
+              "onvif",
+              "rtmp",
+              "webtorrent",
+              "wyoming",
+              "echo",
+              "exec",
+              "expr",
+              "ffmpeg",
+              "alsa",
+              "v4l2",
+              "bubble",
+              "doorbird",
+              "dvrip",
+              "eseecloud",
+              "flussonic",
+              "gopro",
+              "isapi",
+              "ivideon",
+              "mpegts",
+              "nest",
+              "ring",
+              "roborock",
+              "tapo",
+              "tuya",
+              "yandex",
+              "debug",
+              "ngrok",
+              "pinggy",
+              "srtp"
+            ]
+          }
+        }
+      }
+    },
+    "env": {
+      "description": "Config variables that can be referenced as ${NAME} / ${NAME:default}",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
+    "echo": {
+      "type": "object",
+      "properties": {
+        "allow_paths": {
+          "description": "Allow only these binaries for echo: URLs (exact cmd name/path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "ffmpeg",
+              "/usr/bin/ffmpeg"
+            ]
+          ]
+        }
+      }
+    },
+    "exec": {
+      "type": "object",
+      "properties": {
+        "allow_paths": {
+          "description": "Allow only these binaries for exec: URLs (exact cmd name/path)",
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "examples": [
+            [
+              "ffmpeg",
+              "/usr/bin/ffmpeg"
+            ]
+          ]
         }
       }
     },
@@ -105,49 +234,69 @@
       "type": "object",
       "properties": {
         "config": {
+          "description": "Home Assistant config directory path",
           "type": "string",
           "examples": [
-            "/config/go2rtc.yaml"
+            "/config"
           ]
-        },
-        "api": {
-          "type": "object",
-          "properties": {
-            "listen": {
-              "default": ":8124",
-              "$ref": "#/definitions/listen"
-            }
-          }
         }
       }
     },
     "homekit": {
       "type": "object",
+      "additionalProperties": {
+        "type": "object",
       "properties": {
         "pin": {
+          "description": "HomeKit pairing PIN (will be normalized to XXX-XX-XXX); insecure PINs are rejected",
           "type": "string",
-          "default": "123-45-678"
+          "default": "19550224",
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": "^[0-9]{8}$"
+            },
+            {
+              "type": "string",
+              "pattern": "^[0-9]{3}-[0-9]{2}-[0-9]{3}$"
+            }
+          ]
         },
         "name": {
-          "type": "string",
-          "default": "go2rtc"
-        },
-        "device_id": {
-          "type": "string",
-          "default": ""
+          "type": "string"
         },
+          "device_id": {
+            "type": "string"
+          },
         "device_private": {
-          "type": "string",
-          "default": ""
+          "type": "string"
         },
         "category_id": {
-          "type": "integer",
-          "default": 2
+          "description": "Accessory category: \"bridge\", \"doorbell\" or numeric ID (default: camera)",
+          "type": "string",
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "bridge",
+                "doorbell"
+              ]
+            },
+            {
+              "type": "string",
+              "pattern": "^[0-9]+$"
+            },
+            {
+              "type": "string",
+              "const": ""
+            }
+          ]
         },
         "pairings": {
           "type": "array",
           "items": {
             "type": "string"
+            }
           }
         }
       }
@@ -156,9 +305,11 @@
       "type": "object",
       "properties": {
         "format": {
+          "description": "Log format: color/json/text or empty for autodetect",
           "type": "string",
           "default": "color",
           "enum": [
+            "",
             "color",
             "json",
             "text"
@@ -170,12 +321,26 @@
           "$ref": "#/definitions/log_level"
         },
         "output": {
+          "description": "Log output: stdout/stderr/file[:path] or empty (memory only)",
           "type": "string",
           "default": "stdout",
-          "enum": [
-            "",
-            "stdout",
-            "stderr"
+          "anyOf": [
+            {
+              "type": "string",
+              "enum": [
+                "",
+                "stdout",
+                "stderr"
+              ]
+            },
+            {
+              "type": "string",
+              "pattern": "^file(:.+)?$",
+              "examples": [
+                "file",
+                "file:go2rtc.log"
+              ]
+            }
           ]
         },
         "time": {
@@ -201,6 +366,24 @@
         "api": {
           "$ref": "#/definitions/log_level"
         },
+        "alsa": {
+          "$ref": "#/definitions/log_level"
+        },
+        "bubble": {
+          "$ref": "#/definitions/log_level"
+        },
+        "debug": {
+          "$ref": "#/definitions/log_level"
+        },
+        "doorbird": {
+          "$ref": "#/definitions/log_level"
+        },
+        "dvrip": {
+          "$ref": "#/definitions/log_level"
+        },
+        "eseecloud": {
+          "$ref": "#/definitions/log_level"
+        },
         "echo": {
           "$ref": "#/definitions/log_level"
         },
@@ -216,6 +399,12 @@
           "default": "error",
           "$ref": "#/definitions/log_level"
         },
+        "flussonic": {
+          "$ref": "#/definitions/log_level"
+        },
+        "gopro": {
+          "$ref": "#/definitions/log_level"
+        },
         "hass": {
           "$ref": "#/definitions/log_level"
         },
@@ -225,41 +414,116 @@
         "homekit": {
           "$ref": "#/definitions/log_level"
         },
+        "http": {
+          "$ref": "#/definitions/log_level"
+        },
+        "isapi": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ivideon": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mjpeg": {
+          "$ref": "#/definitions/log_level"
+        },
+        "mpegts": {
+          "$ref": "#/definitions/log_level"
+        },
         "mp4": {
           "$ref": "#/definitions/log_level"
         },
+        "nest": {
+          "$ref": "#/definitions/log_level"
+        },
         "ngrok": {
           "$ref": "#/definitions/log_level"
         },
         "onvif": {
           "$ref": "#/definitions/log_level"
         },
+        "pinggy": {
+          "$ref": "#/definitions/log_level"
+        },
+        "ring": {
+          "$ref": "#/definitions/log_level"
+        },
+        "roborock": {
+          "$ref": "#/definitions/log_level"
+        },
         "rtmp": {
           "$ref": "#/definitions/log_level"
         },
         "rtsp": {
           "$ref": "#/definitions/log_level"
         },
+        "srtp": {
+          "$ref": "#/definitions/log_level"
+        },
         "streams": {
           "$ref": "#/definitions/log_level"
         },
+        "tapo": {
+          "$ref": "#/definitions/log_level"
+        },
+        "tuya": {
+          "$ref": "#/definitions/log_level"
+        },
+        "v4l2": {
+          "$ref": "#/definitions/log_level"
+        },
         "webrtc": {
           "$ref": "#/definitions/log_level"
         },
         "webtorrent": {
           "$ref": "#/definitions/log_level"
+        },
+        "wyoming": {
+          "$ref": "#/definitions/log_level"
+        },
+        "yandex": {
+          "$ref": "#/definitions/log_level"
         }
+      },
+      "additionalProperties": {
+        "$ref": "#/definitions/log_level"
       }
     },
     "ngrok": {
       "type": "object",
       "properties": {
         "command": {
-          "description": "ngrok start --all --config ngrok.yaml",
-          "type": "string"
+          "type": "string",
+          "examples": [
+            "ngrok tcp 8555 --authtoken xxx",
+            "ngrok start --all --config ngrok.yaml"
+          ]
         }
       }
     },
+    "pinggy": {
+      "type": "object",
+      "properties": {
+        "tunnel": {
+          "description": "Expose local address via Pinggy (scheme: http/tcp/tls/tlstcp, host:port is your local address)",
+          "type": "string",
+          "examples": [
+            "http://127.0.0.1:1984",
+            "tcp://127.0.0.1:8554"
+          ]
+        }
+      }
+    },
+    "preload": {
+      "description": "Preload streams on startup (map stream name => probe query, default \"video&audio\")",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string",
+        "examples": [
+          "video&audio",
+          "video"
+        ]
+      }
+    },
     "publish": {
       "type": "object",
       "additionalProperties": {
@@ -299,22 +563,25 @@
           "$ref": "#/definitions/listen"
         },
         "username": {
-          "type": "string"
+          "type": "string",
+          "examples": [
+            "admin"
+          ]
         },
         "password": {
           "type": "string"
         },
         "default_query": {
           "type": "string",
-          "default": ""
+          "default": "video&audio"
         },
         "pkt_size": {
-          "type": "integer",
-          "default": 0
+          "type": "integer"
         }
       }
     },
     "srtp": {
+      "description": "SRTP server for HomeKit",
       "type": "object",
       "properties": {
         "listen": {
@@ -356,6 +623,29 @@
               "description": "Source",
               "type": "string"
             }
+          },
+          {
+            "type": "object",
+            "properties": {
+              "url": {
+                "description": "Source URL or list of URLs",
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "examples": [
+                      "rtsp://username:password@192.168.1.123/stream1",
+                      "ffmpeg:media.mp4#video=h264#audio=copy"
+                    ]
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": "string"
+                    }
+                  }
+                ]
+              }
+            }
           }
         ]
       }
@@ -364,18 +654,29 @@
       "type": "object",
       "properties": {
         "listen": {
-          "default": ":8555",
-          "$ref": "#/definitions/listen"
+          "default": ":8555/tcp",
+          "type": "string",
+          "anyOf": [
+            {
+              "type": "string",
+              "pattern": ":[0-9]{1,5}(/tcp|/udp)?$"
+            },
+            {
+              "type": "string",
+              "const": ""
+            }
+          ]
         },
         "candidates": {
           "type": "array",
           "items": {
-            "type": "string",
-            "examples": [
-              "192.168.1.123",
-              "stun:stun.l.google.com:19302"
-            ]
-          }
+            "$ref": "#/definitions/listen/anyOf/0"
+          },
+          "examples": [
+            "216.58.210.174:8555",
+            "stun:8555",
+            "home.duckdns.org:8555"
+          ]
         },
         "ice_servers": {
           "type": "array",
@@ -461,14 +762,60 @@
           }
         },
         "shares": {
-          "type": "object",
-          "properties": {
-            "pwd": {
-              "type": "string"
-            },
-            "src": {
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "pwd": {
+                "type": "string",
+                "minLength": 4
+              },
+              "src": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      }
+    },
+    "wyoming": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "listen": {
+            "description": "Listen address for Wyoming server",
+            "$ref": "#/definitions/listen"
+          },
+          "name": {
+            "description": "Optional satellite name (default: stream name)",
+            "type": "string"
+          },
+          "mode": {
+            "description": "Optional mode: mic / snd / default",
+            "type": "string",
+            "enum": [
+              "",
+              "mic",
+              "snd"
+            ]
+          },
+          "event": {
+            "description": "Event handlers (map event type => expr script)",
+            "type": "object",
+            "additionalProperties": {
               "type": "string"
             }
+          },
+          "wake_uri": {
+            "description": "Optional WAKE service URI (ex. tcp://host:port?name=...)",
+            "type": "string",
+            "examples": [
+              "tcp://192.168.1.23:10400"
+            ]
+          },
+          "vad_threshold": {
+            "description": "Optional VAD threshold (0.1..3.5 typical)",
+            "type": "number"
           }
         }
       }

From ff198857907d5d2dc5b212e11a57eb46ac21db7b Mon Sep 17 00:00:00 2001
From: Davide Figini <davidefigini55@gmail.com>
Date: Fri, 28 Nov 2025 14:24:43 +0100
Subject: [PATCH 05/26] Add rtsp params pass through from onvif sources

---
 internal/onvif/onvif.go | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/internal/onvif/onvif.go b/internal/onvif/onvif.go
index 3c64cb5c..5b1c8233 100644
--- a/internal/onvif/onvif.go
+++ b/internal/onvif/onvif.go
@@ -7,6 +7,7 @@ import (
 	"net/url"
 	"os"
 	"strconv"
+	"strings"
 	"time"
 
 	"github.com/AlexxIT/go2rtc/internal/api"
@@ -33,6 +34,9 @@ func Init() {
 var log zerolog.Logger
 
 func streamOnvif(rawURL string) (core.Producer, error) {
+	// Split the ONVIF URL to extract hash-based arguments
+	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
+
 	client, err := onvif.NewClient(rawURL)
 	if err != nil {
 		return nil, err
@@ -43,6 +47,11 @@ func streamOnvif(rawURL string) (core.Producer, error) {
 		return nil, err
 	}
 
+	// Append hash-based arguments to the retrieved URI
+	if rawQuery != "" {
+		uri = uri + "#" + rawQuery
+	}
+
 	log.Debug().Msgf("[onvif] new uri=%s", uri)
 
 	if err = streams.Validate(uri); err != nil {

From 7ada6d81ebbc8c663559755e410e669acb75f2e6 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sun, 21 Dec 2025 00:02:49 +0300
Subject: [PATCH 06/26] Add YAML schema-based linting and validation

Integrates js-yaml for parsing and adds comprehensive YAML linting with schema-based type checking, duplicate key detection, and improved error reporting. Refactors and extends parsing utilities, enhances completion logic, and introduces a schema tools abstraction for type and property resolution.
---
 www/config.html | 507 ++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 489 insertions(+), 18 deletions(-)

diff --git a/www/config.html b/www/config.html
index 9b973f80..8e50f340 100644
--- a/www/config.html
+++ b/www/config.html
@@ -29,6 +29,7 @@
 <div id="config"></div>
 
 <script src="https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs/loader.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/js-yaml@4.1.0/dist/js-yaml.min.js"></script>
 <script>
     /* global require, monaco */
     const monacoVersion = '0.55.1';
@@ -168,17 +169,110 @@
         };
 
         const parseListItem = (line) => {
-            const m = line.match(/^(\s*)-\s*(.*)$/);
+            const m = line.match(/^([ \t]*)-/);
             if (!m) return null;
-            return {indent: countIndent(m[1]), rest: m[2]};
+
+            const dashIndex = m[1].length;
+            if (dashIndex + 1 < line.length && !/\s/.test(line[dashIndex + 1])) return null;
+
+            let afterDashIndex = dashIndex + 1;
+            while (afterDashIndex < line.length && /\s/.test(line[afterDashIndex])) afterDashIndex++;
+
+            const spacesAfterDash = Math.max(1, afterDashIndex - (dashIndex + 1));
+
+            return {
+                indent: countIndent(m[1]),
+                dashIndex,
+                afterDashIndex,
+                rest: line.slice(afterDashIndex),
+                contentIndent: countIndent(m[1]) + 1 + spacesAfterDash,
+            };
         };
 
         const parseKey = (line) => {
-            const m = line.match(/^(\s*)([A-Za-z0-9_-]+)\s*:(.*)$/);
-            if (!m) return null;
-            const after = m[3] ?? '';
+            const m = line.match(/^([ \t]*)/);
+            const indentStr = m ? m[0] : '';
+            const indentIndex = indentStr.length;
+            const indent = countIndent(indentStr);
+
+            if (indentIndex >= line.length) return null;
+
+            let i = indentIndex;
+            let key = '';
+            let rawKey = '';
+            let isQuoted = false;
+            let keyStartIndex = i;
+            let keyEndIndex = i;
+            let colonIndex = -1;
+
+            const parseQuotedKey = (quoteChar) => {
+                isQuoted = true;
+                let j = i + 1;
+                if (quoteChar === '"') {
+                    while (j < line.length) {
+                        if (line[j] === '\\') {
+                            j += 2;
+                            continue;
+                        }
+                        if (line[j] === '"') break;
+                        j++;
+                    }
+                } else {
+                    while (j < line.length) {
+                        if (line[j] === '\'') {
+                            if (line[j + 1] === '\'') {
+                                j += 2;
+                                continue;
+                            }
+                            break;
+                        }
+                        j++;
+                    }
+                }
+
+                if (j >= line.length) return null;
+                rawKey = line.slice(i, j + 1);
+                if (quoteChar === '"') {
+                    key = line.slice(i + 1, j).replace(/\\"/g, '"').replace(/\\\\/g, '\\');
+                } else {
+                    key = line.slice(i + 1, j).replace(/''/g, '\'');
+                }
+                keyStartIndex = i;
+                keyEndIndex = j + 1;
+
+                let k = j + 1;
+                while (k < line.length && /\s/.test(line[k])) k++;
+                if (k >= line.length || line[k] !== ':') return null;
+                colonIndex = k;
+                return colonIndex;
+            };
+
+            if (line[i] === '"' || line[i] === '\'') {
+                if (parseQuotedKey(line[i]) === null) return null;
+            } else {
+                let j = i;
+                while (j < line.length) {
+                    if (line[j] === ':') {
+                        if (j + 1 >= line.length || /\s/.test(line[j + 1])) {
+                            colonIndex = j;
+                            break;
+                        }
+                    }
+                    j++;
+                }
+                if (colonIndex === -1) return null;
+                rawKey = line.slice(i, colonIndex).replace(/\s+$/, '');
+                if (!rawKey) return null;
+                key = rawKey;
+                keyStartIndex = i;
+                keyEndIndex = i + rawKey.length;
+            }
+
+            const after = line.slice(colonIndex + 1) ?? '';
             const isContainer = after.trim() === '' || after.trim().startsWith('#');
-            return {indent: countIndent(m[1]), key: m[2], isContainer, after};
+            const valueStartIndex = colonIndex + 1;
+
+            return {indent, key, rawKey, isQuoted, isContainer, after, keyStartIndex, keyEndIndex, colonIndex, valueStartIndex};
         };
 
         const unique = (arr) => [...new Set(arr)];
@@ -191,7 +285,7 @@
             return JSON.stringify(v);
         };
 
-        const setupYamlHints = (schemaRoot) => {
+        const createSchemaTools = (schemaRoot) => {
             const resolveRef = (schema, seen = new Set()) => {
                 if (!schema || typeof schema !== 'object') return schema;
                 if (typeof schema.$ref === 'string') {
@@ -273,6 +367,383 @@
                 return unique(values);
             };
 
+            const getSchemaTypes = (schema, seen = new Set()) => {
+                schema = resolveRef(schema);
+                if (!schema || typeof schema !== 'object') return new Set();
+
+                if (Array.isArray(schema.anyOf)) {
+                    const types = new Set();
+                    for (const alt of schema.anyOf) {
+                        for (const t of getSchemaTypes(alt, seen)) types.add(t);
+                    }
+                    return types;
+                }
+
+                if (Array.isArray(schema.oneOf)) {
+                    const types = new Set();
+                    for (const alt of schema.oneOf) {
+                        for (const t of getSchemaTypes(alt, seen)) types.add(t);
+                    }
+                    return types;
+                }
+
+                if (Array.isArray(schema.type)) return new Set(schema.type);
+                if (typeof schema.type === 'string') return new Set([schema.type]);
+                if (schema.properties || schema.additionalProperties) return new Set(['object']);
+                if (schema.items) return new Set(['array']);
+                return new Set();
+            };
+
+            const schemaAllowsType = (schema, actualType) => {
+                const types = getSchemaTypes(schema);
+                if (actualType === 'integer' && types.has('number')) return true;
+                return types.has(actualType);
+            };
+
+            const schemaTypesLabel = (schema) => {
+                const types = Array.from(getSchemaTypes(schema));
+                if (types.length === 0) return 'any';
+                return types.sort().join(' | ');
+            };
+
+            const getArrayItemSchema = (schema) => {
+                schema = resolveRef(schema);
+                if (!schema) return null;
+                if (schema.type === 'array' && schema.items) return resolveRef(schema.items);
+                if (Array.isArray(schema.anyOf)) {
+                    for (const alt of schema.anyOf) {
+                        const item = getArrayItemSchema(alt);
+                        if (item) return item;
+                    }
+                }
+                return null;
+            };
+
+            return {
+                schemaRoot,
+                resolveRef,
+                getObjectProperties,
+                getPropertySchema,
+                getValueSuggestions,
+                getSchemaTypes,
+                schemaAllowsType,
+                schemaTypesLabel,
+                getArrayItemSchema,
+            };
+        };
+
+        const isIntLike = (s) => /^[+-]?\d+$/.test(s);
+        const isNumberLike = (s) => (
+            /^[+-]?(?:\d*\.\d+|\d+\.\d*)(?:[eE][+-]?\d+)?$/.test(s) ||
+            /^[+-]?\d+(?:[eE][+-]?\d+)$/.test(s) ||
+            isIntLike(s)
+        );
+
+        const classifyYamlScalar = (raw) => {
+            const v = raw.trim();
+            if (!v) return {type: 'null'};
+            if (/^\$\{[^}{]+\}$/.test(v)) return {type: 'dynamic'};
+            if (v.startsWith('[')) return {type: 'array'};
+            if (v.startsWith('{')) return {type: 'object'};
+            if (v.startsWith('"') || v.startsWith('\'')) return {type: 'string'};
+            if (v === 'true' || v === 'false') return {type: 'boolean'};
+            if (v === 'null' || v === '~') return {type: 'null'};
+            if (isIntLike(v)) return {type: 'integer'};
+            if (isNumberLike(v)) return {type: 'number'};
+            return {type: 'string'};
+        };
+
+        const lintYamlModel = (model, schemaTools) => {
+            const markers = [];
+            const markedLines = new Set();
+
+            const markLineError = (lineNumber, message, startColumn = 1) => {
+                if (markedLines.has(`${lineNumber}:${message}`)) return;
+                markedLines.add(`${lineNumber}:${message}`);
+                const lineText = model.getLineContent(lineNumber);
+                markers.push({
+                    severity: monaco.MarkerSeverity.Error,
+                    message,
+                    startLineNumber: lineNumber,
+                    startColumn,
+                    endLineNumber: lineNumber,
+                    endColumn: Math.max(startColumn + 1, lineText.length + 1),
+                });
+            };
+
+            if (window.jsyaml?.load) {
+                try {
+                    window.jsyaml.load(model.getValue());
+                } catch (e) {
+                    const mark = e?.mark || {};
+                    const line = typeof mark.line === 'number' ? mark.line + 1 : 1;
+                    const column = typeof mark.column === 'number' ? mark.column + 1 : 1;
+                    markLineError(line, e?.reason ? `YAML: ${e.reason}` : `YAML: ${e?.message || 'Invalid YAML'}`, column);
+                }
+            }
+
+            const pushMarker = (m) => markers.push(m);
+
+            const getExpectedContainerType = (schema) => {
+                if (!schemaTools) return null;
+                const types = schemaTools.getSchemaTypes(schema);
+                const wantsObject = types.has('object');
+                const wantsArray = types.has('array');
+                if (wantsObject && !wantsArray) return 'object';
+                if (wantsArray && !wantsObject) return 'array';
+                return null;
+            };
+
+            const stack = [{
+                indent: -1,
+                schema: schemaTools?.schemaRoot || null,
+                expected: 'object',
+                actual: null,
+                keys: new Map(),
+                origin: null,
+                reportedTypeMismatch: false,
+            }];
+
+            let hasTopLevelKey = false;
+            let hasTopLevelList = false;
+            const lineCount = model.getLineCount();
+            for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+                let line = model.getLineContent(lineNumber);
+                if (!line.trim()) continue;
+                line = stripInlineComment(line).trimEnd();
+                if (!line.trim()) continue;
+                const kv = parseKey(line);
+                if (kv && kv.indent === 0) hasTopLevelKey = true;
+                const li = parseListItem(line);
+                if (li && li.indent === 0) hasTopLevelList = true;
+            }
+
+            const setActualType = (ctx, actual, fallbackLineNumber) => {
+                if (ctx.actual !== null) return;
+                ctx.actual = actual;
+                if (ctx.origin && ctx.expected && ctx.expected !== actual && !ctx.reportedTypeMismatch) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Error,
+                        message: `Type mismatch: expected ${ctx.expected}, got ${actual}`,
+                        startLineNumber: ctx.origin.lineNumber,
+                        startColumn: ctx.origin.startColumn,
+                        endLineNumber: ctx.origin.lineNumber,
+                        endColumn: ctx.origin.endColumn,
+                    });
+                    ctx.reportedTypeMismatch = true;
+                } else if (!ctx.origin && ctx.expected && ctx.expected !== actual && fallbackLineNumber) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Error,
+                        message: `Type mismatch: expected ${ctx.expected}, got ${actual}`,
+                        startLineNumber: fallbackLineNumber,
+                        startColumn: 1,
+                        endLineNumber: fallbackLineNumber,
+                        endColumn: 2,
+                    });
+                    ctx.reportedTypeMismatch = true;
+                }
+            };
+
+            const checkValueType = (schema, actualType, lineNumber, startColumn, endColumn, keyName) => {
+                if (!schemaTools || !schema) return;
+                if (actualType === 'dynamic') return;
+                if (schemaTools.schemaAllowsType(schema, actualType)) return;
+                pushMarker({
+                    severity: monaco.MarkerSeverity.Error,
+                    message: `Type mismatch for ${keyName ? `"${keyName}"` : 'value'}: expected ${schemaTools.schemaTypesLabel(schema)}, got ${actualType}`,
+                    startLineNumber: lineNumber,
+                    startColumn,
+                    endLineNumber: lineNumber,
+                    endColumn: Math.max(startColumn + 1, endColumn),
+                });
+            };
+
+            for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
+                let line = model.getLineContent(lineNumber);
+                if (!line.trim()) continue;
+
+                line = stripInlineComment(line).trimEnd();
+                if (!line.trim()) continue;
+
+                const indent = countIndent(line);
+                if (indent === 0 && (hasTopLevelKey || hasTopLevelList)) {
+                    const trimmed = line.trim();
+                    if (trimmed !== '---' && trimmed !== '...' && !trimmed.startsWith('#')) {
+                        const listItem0 = parseListItem(line);
+                        const kv0 = parseKey(line);
+                        const flow0 = trimmed.startsWith('{') || trimmed.startsWith('[');
+                        if (!flow0 && !listItem0 && !kv0) {
+                            markLineError(lineNumber, 'YAML: unexpected content at document root');
+                            continue;
+                        }
+                    }
+                }
+
+                const listItem = parseListItem(line);
+                if (listItem) {
+                    while (stack.length > 1 && listItem.indent <= stack[stack.length - 1].indent) stack.pop();
+
+                    const parent = stack[stack.length - 1];
+                    setActualType(parent, 'array', lineNumber);
+
+                    const itemSchema = schemaTools ? schemaTools.getArrayItemSchema(parent.schema) : null;
+                    const itemExpected = getExpectedContainerType(itemSchema);
+
+                    const itemCtx = {
+                        indent: listItem.indent,
+                        schema: itemSchema,
+                        expected: itemExpected,
+                        actual: null,
+                        keys: new Map(),
+                        origin: {lineNumber, startColumn: listItem.dashIndex + 1, endColumn: listItem.dashIndex + 2},
+                        reportedTypeMismatch: false,
+                    };
+                    stack.push(itemCtx);
+
+                    if (!listItem.rest) continue;
+
+                    const inline = parseKey(' '.repeat(listItem.afterDashIndex) + listItem.rest);
+                    if (inline) {
+                        // handle inline mapping in the same line: "- key: value"
+                        const kv = inline;
+                        while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
+                        const ctx = stack[stack.length - 1];
+                        setActualType(ctx, 'object', lineNumber);
+
+                        const prev = ctx.keys.get(kv.key);
+                        if (prev) {
+                            pushMarker({
+                                severity: monaco.MarkerSeverity.Warning,
+                                message: `Duplicate key "${kv.key}" (previous at line ${prev.lineNumber})`,
+                                startLineNumber: lineNumber,
+                                startColumn: kv.keyStartIndex + 1,
+                                endLineNumber: lineNumber,
+                                endColumn: kv.keyEndIndex + 1,
+                            });
+                        } else {
+                            ctx.keys.set(kv.key, {lineNumber});
+                        }
+
+                        if (!kv.isQuoted && isNumberLike(kv.rawKey.trim())) {
+                            pushMarker({
+                                severity: monaco.MarkerSeverity.Error,
+                                message: `Map keys must be strings. Quote numeric key as '${kv.rawKey}':`,
+                                startLineNumber: lineNumber,
+                                startColumn: kv.keyStartIndex + 1,
+                                endLineNumber: lineNumber,
+                                endColumn: kv.keyEndIndex + 1,
+                            });
+                        }
+
+                        const propSchema = schemaTools ? schemaTools.getPropertySchema(ctx.schema, kv.key) : null;
+                        if (kv.isContainer) {
+                            stack.push({
+                                indent: kv.indent,
+                                schema: propSchema,
+                                expected: getExpectedContainerType(propSchema),
+                                actual: null,
+                                keys: new Map(),
+                                origin: {lineNumber, startColumn: kv.keyStartIndex + 1, endColumn: kv.keyEndIndex + 1},
+                                reportedTypeMismatch: false,
+                            });
+                        } else if (propSchema) {
+                            const valueText = kv.after.trim();
+                            const actual = classifyYamlScalar(valueText).type;
+                            const valueStartColumn = kv.valueStartIndex + 1 + (kv.after.length - kv.after.trimStart().length);
+                            checkValueType(propSchema, actual, lineNumber, valueStartColumn, line.length + 1, kv.key);
+                        }
+                        continue;
+                    }
+
+                    const scalar = classifyYamlScalar(listItem.rest).type;
+                    checkValueType(itemSchema, scalar, lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
+                    continue;
+                }
+
+                const kv = parseKey(line);
+                if (!kv) continue;
+
+                while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
+                const ctx = stack[stack.length - 1];
+                setActualType(ctx, 'object', lineNumber);
+
+                const prev = ctx.keys.get(kv.key);
+                if (prev) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Warning,
+                        message: `Duplicate key "${kv.key}" (previous at line ${prev.lineNumber})`,
+                        startLineNumber: lineNumber,
+                        startColumn: kv.keyStartIndex + 1,
+                        endLineNumber: lineNumber,
+                        endColumn: kv.keyEndIndex + 1,
+                    });
+                } else {
+                    ctx.keys.set(kv.key, {lineNumber});
+                }
+
+                if (!kv.isQuoted && isNumberLike(kv.rawKey.trim())) {
+                    pushMarker({
+                        severity: monaco.MarkerSeverity.Error,
+                        message: `Map keys must be strings. Quote numeric key as '${kv.rawKey}':`,
+                        startLineNumber: lineNumber,
+                        startColumn: kv.keyStartIndex + 1,
+                        endLineNumber: lineNumber,
+                        endColumn: kv.keyEndIndex + 1,
+                    });
+                }
+
+                const propSchema = schemaTools ? schemaTools.getPropertySchema(ctx.schema, kv.key) : null;
+                if (kv.isContainer) {
+                    stack.push({
+                        indent: kv.indent,
+                        schema: propSchema,
+                        expected: getExpectedContainerType(propSchema),
+                        actual: null,
+                        keys: new Map(),
+                        origin: {lineNumber, startColumn: kv.keyStartIndex + 1, endColumn: kv.keyEndIndex + 1},
+                        reportedTypeMismatch: false,
+                    });
+                    continue;
+                }
+
+                if (!propSchema) continue;
+
+                const actual = classifyYamlScalar(kv.after).type;
+                const valueStartColumn = kv.valueStartIndex + 1 + (kv.after.length - kv.after.trimStart().length);
+                checkValueType(propSchema, actual, lineNumber, valueStartColumn, line.length + 1, kv.key);
+            }
+
+            return markers;
+        };
+
+        let schemaTools = null;
+        let completionProvider = null;
+
+        const scheduleLint = (() => {
+            let handle = null;
+            return () => {
+                if (handle) clearTimeout(handle);
+                handle = setTimeout(() => {
+                    const model = editor.getModel();
+                    if (!model) return;
+                    monaco.editor.setModelMarkers(model, 'yaml-lint', lintYamlModel(model, schemaTools));
+                }, 250);
+            };
+        })();
+
+        editor.onDidChangeModelContent(() => scheduleLint());
+
+        const setupYamlHints = (schemaRoot) => {
+            schemaTools = createSchemaTools(schemaRoot);
+            scheduleLint();
+
+            const {
+                resolveRef,
+                getObjectProperties,
+                getPropertySchema,
+                getValueSuggestions,
+            } = schemaTools;
+
             const buildContextStack = (model, upToLineNumber) => {
                 const stack = [{indent: -1, schema: schemaRoot}];
 
@@ -293,7 +764,7 @@
                             stack.push({indent: listItem.indent, schema: null});
                         }
 
-                        const inline = listItem.rest ? parseKey(' '.repeat(listItem.indent + 2) + listItem.rest) : null;
+                        const inline = listItem.rest ? parseKey(' '.repeat(listItem.contentIndent) + listItem.rest) : null;
                         if (inline && inline.isContainer) {
                             while (stack.length > 1 && inline.indent <= stack[stack.length - 1].indent) stack.pop();
                             const ctx = resolveRef(stack[stack.length - 1].schema);
@@ -316,12 +787,14 @@
                 return stack;
             };
 
-            monaco.languages.registerCompletionItemProvider('yaml', {
+            if (completionProvider) completionProvider.dispose();
+            completionProvider = monaco.languages.registerCompletionItemProvider('yaml', {
                 triggerCharacters: [':', ' '],
                 provideCompletionItems: (model, position) => {
                     const line = model.getLineContent(position.lineNumber);
-                    const lineNoComment = stripInlineComment(line).trimEnd();
-                    const listItem = parseListItem(lineNoComment);
+                    const lineNoComment = stripInlineComment(line);
+                    const lineNoCommentTrimmedEnd = lineNoComment.trimEnd();
+                    const listItem = parseListItem(lineNoCommentTrimmedEnd);
 
                     const {word, startColumn, endColumn} = model.getWordUntilPosition(position);
                     const range = new monaco.Range(position.lineNumber, startColumn, position.lineNumber, endColumn);
@@ -329,28 +802,26 @@
                     const cursorIndex = position.column - 1;
                     let contentStartIndex = 0;
                     if (listItem) {
-                        contentStartIndex = listItem.indent;
-                        if (lineNoComment.slice(contentStartIndex, contentStartIndex + 1) === '-') contentStartIndex += 1;
-                        if (lineNoComment.slice(contentStartIndex, contentStartIndex + 1) === ' ') contentStartIndex += 1;
+                        contentStartIndex = listItem.afterDashIndex;
                     } else {
                         contentStartIndex = countIndent(lineNoComment);
                     }
 
                     if (cursorIndex < contentStartIndex) return {suggestions: []};
 
-                    const text = lineNoComment.slice(contentStartIndex);
+                    const text = lineNoCommentTrimmedEnd.slice(contentStartIndex);
                     const cursorInText = cursorIndex - contentStartIndex;
                     const colonIndex = text.indexOf(':');
                     const isValueContext = colonIndex >= 0 && cursorInText > colonIndex;
 
                     const stack = buildContextStack(model, position.lineNumber - 1);
 
-                    const effectiveIndent = listItem ? listItem.indent + 2 : countIndent(lineNoComment);
+                    const effectiveIndent = listItem ? listItem.contentIndent : countIndent(lineNoComment);
                     while (stack.length > 1 && effectiveIndent <= stack[stack.length - 1].indent) stack.pop();
 
                     let contextSchema = resolveRef(stack[stack.length - 1].schema);
 
-                    if (listItem && cursorIndex >= listItem.indent + 2 && contextSchema && contextSchema.type === 'array') {
+                    if (listItem && cursorIndex >= listItem.afterDashIndex && contextSchema && contextSchema.type === 'array') {
                         contextSchema = resolveRef(contextSchema.items);
                     }
 
@@ -376,7 +847,7 @@
                         const suggestions = Object.keys(props).map((key) => {
                             const s = resolveRef(props[key]);
                             const wantsBlock = s && (s.type === 'object' || s.type === 'array' || s.properties);
-                            const indent = listItem ? ' '.repeat(listItem.indent + 2) : ' '.repeat(countIndent(lineNoComment));
+                            const indent = listItem ? ' '.repeat(listItem.contentIndent) : ' '.repeat(countIndent(lineNoComment));
                             const innerIndent = indent + '  ';
 
                             const insertText = wantsBlock ? `${key}:\n${innerIndent}` : `${key}: `;

From 2f470fa5186997e124e410d3218dd03e8d551714 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Fri, 26 Dec 2025 12:53:52 +0300
Subject: [PATCH 07/26] Add support cs2+tcp protocol for xiaomi source

---
 pkg/xiaomi/cs2/conn.go    | 285 +++++++++++++++++++++++++++-----------
 pkg/xiaomi/miss/client.go |  17 +--
 pkg/xiaomi/tutk/conn.go   |   4 +
 3 files changed, 211 insertions(+), 95 deletions(-)

diff --git a/pkg/xiaomi/cs2/conn.go b/pkg/xiaomi/cs2/conn.go
index 45c9e704..198b3beb 100644
--- a/pkg/xiaomi/cs2/conn.go
+++ b/pkg/xiaomi/cs2/conn.go
@@ -1,6 +1,7 @@
 package cs2
 
 import (
+	"bufio"
 	"encoding/binary"
 	"fmt"
 	"io"
@@ -10,33 +11,27 @@ import (
 	"time"
 )
 
-func Dial(host string) (*Conn, error) {
-	conn, err := net.ListenUDP("udp", nil)
+func Dial(host, transport string) (*Conn, error) {
+	conn, err := handshake(host, transport)
 	if err != nil {
 		return nil, err
 	}
 
+	_, isTCP := conn.(*tcpConn)
+
 	c := &Conn{
-		conn: conn,
-		addr: &net.UDPAddr{IP: net.ParseIP(host), Port: 32108},
+		conn:   conn,
+		isTCP:  isTCP,
+		rawCh0: make(chan []byte, 10),
+		rawCh2: make(chan []byte, 100),
 	}
-
-	if err = c.handshake(); err != nil {
-		_ = conn.Close()
-		return nil, err
-	}
-
-	c.rawCh0 = make(chan []byte, 10)
-	c.rawCh2 = make(chan []byte, 100)
-
 	go c.worker()
-
 	return c, nil
 }
 
 type Conn struct {
-	conn *net.UDPConn
-	addr *net.UDPAddr
+	conn  net.Conn
+	isTCP bool
 
 	err    error
 	seqCh0 uint16
@@ -53,30 +48,58 @@ const (
 	magicDrw     = 0xD1
 	msgLanSearch = 0x30
 	msgPunchPkt  = 0x41
-	msgP2PRdy    = 0x42
+	msgP2PRdyUDP = 0x42
+	msgP2PRdyTCP = 0x43
 	msgDrw       = 0xD0
 	msgDrwAck    = 0xD1
-	msgAlive     = 0xE0
+	msgPing      = 0xE0
+	msgPong      = 0xE1
+	msgClose     = 0xF1
 )
 
-func (c *Conn) handshake() error {
-	_ = c.SetDeadline(time.Now().Add(5 * time.Second))
-
-	buf, err := c.WriteAndWait([]byte{magic, msgLanSearch, 0, 0}, msgPunchPkt)
+func handshake(host, transport string) (net.Conn, error) {
+	conn, err := newUDPConn(host, 32108)
 	if err != nil {
-		return fmt.Errorf("%s: read punch: %w", "cs2", err)
+		return nil, err
 	}
 
-	_, err = c.WriteAndWait(buf, msgP2PRdy)
+	_ = conn.SetDeadline(time.Now().Add(5 * time.Second))
+
+	req := []byte{magic, msgLanSearch, 0, 0}
+	res, err := conn.(*udpConn).WriteUntil(req, func(res []byte) bool {
+		return res[1] == msgPunchPkt
+	})
 	if err != nil {
-		return fmt.Errorf("%s: read ready: %w", "cs2", err)
+		_ = conn.Close()
+		return nil, err
 	}
 
-	_ = c.Write([]byte{magic, msgAlive, 0, 0})
+	var msgUDP, msgTCP byte
 
-	_ = c.SetDeadline(time.Time{})
+	if transport == "" || transport == "udp" {
+		msgUDP = msgP2PRdyUDP
+	}
+	if transport == "" || transport == "tcp" {
+		msgTCP = msgP2PRdyTCP
+	}
 
-	return nil
+	res, err = conn.(*udpConn).WriteUntil(res, func(res []byte) bool {
+		return res[1] == msgUDP || res[1] == msgTCP
+	})
+	if err != nil {
+		_ = conn.Close()
+		return nil, err
+	}
+
+	_ = conn.SetDeadline(time.Time{})
+
+	if res[1] == msgTCP {
+		_ = conn.Close()
+		//host := fmt.Sprintf("%d.%d.%d.%d:%d", b[31], b[30], b[29], b[28], uint16(b[27])<<8|uint16(b[26]))
+		return newTCPConn(conn.RemoteAddr().String())
+	}
+
+	return conn, nil
 }
 
 func (c *Conn) worker() {
@@ -85,38 +108,41 @@ func (c *Conn) worker() {
 		close(c.rawCh2)
 	}()
 
-	chAck := make([]uint16, 4)
+	chAck := make([]uint16, 4) // only for UDP
 	buf := make([]byte, 1200)
 	var ch2WaitSize int
 	var ch2WaitData []byte
+	var keepaliveTS time.Time
 
 	for {
-		n, addr, err := c.conn.ReadFromUDP(buf)
+		n, err := c.conn.Read(buf)
 		if err != nil {
 			c.err = fmt.Errorf("%s: %w", "cs2", err)
 			return
 		}
 
-		if string(addr.IP) != string(c.addr.IP) || n < 8 || buf[0] != magic {
-			continue // skip messages from another IP
-		}
-
-		//log.Printf("<- %x", buf[:n])
-
 		switch buf[1] {
 		case msgDrw:
 			ch := buf[5]
-			seqHI := buf[6]
-			seqLO := buf[7]
 
-			if chAck[ch] != uint16(seqHI)<<8|uint16(seqLO) {
-				continue
-			}
-			chAck[ch]++
+			if c.isTCP {
+				// For TCP we should using ping/pong.
+				if now := time.Now(); now.After(keepaliveTS) {
+					_, _ = c.conn.Write([]byte{magic, msgPing, 0, 0})
+					keepaliveTS = now.Add(5 * time.Second)
+				}
+			} else {
+				// For UDP we should using ack.
+				seqHI := buf[6]
+				seqLO := buf[7]
 
-			ack := []byte{magic, msgDrwAck, 0, 6, magicDrw, ch, 0, 1, seqHI, seqLO}
-			if _, err = c.conn.WriteToUDP(ack, c.addr); err != nil {
-				return
+				if chAck[ch] != uint16(seqHI)<<8|uint16(seqLO) {
+					continue
+				}
+				chAck[ch]++
+
+				ack := []byte{magic, msgDrwAck, 0, 6, magicDrw, ch, 0, 1, seqHI, seqLO}
+				_, _ = c.conn.Write(ack)
 			}
 
 			switch ch {
@@ -152,9 +178,12 @@ func (c *Conn) worker() {
 				continue
 			}
 
-		case msgP2PRdy: // skip it
+		case msgPing:
+			_, _ = c.conn.Write([]byte{magic, msgPong, 0, 0})
 			continue
-		case msgDrwAck:
+		case msgPong, msgP2PRdyUDP, msgP2PRdyTCP, msgClose:
+			continue // skip it
+		case msgDrwAck: // only for UDP
 			if c.cmdAck != nil {
 				c.cmdAck()
 			}
@@ -165,42 +194,15 @@ func (c *Conn) worker() {
 	}
 }
 
-func (c *Conn) Write(req []byte) error {
-	//log.Printf("-> %x", req)
-	_, err := c.conn.WriteToUDP(req, c.addr)
-	return err
-}
-
-func (c *Conn) WriteAndWait(req []byte, waitMsg uint8) ([]byte, error) {
-	var t *time.Timer
-	t = time.AfterFunc(1, func() {
-		if err := c.Write(req); err == nil && t != nil {
-			t.Reset(time.Second)
-		}
-	})
-	defer t.Stop()
-
-	buf := make([]byte, 1200)
-
-	for {
-		n, addr, err := c.conn.ReadFromUDP(buf)
-		if err != nil {
-			return nil, err
-		}
-
-		if string(addr.IP) != string(c.addr.IP) || n < 16 {
-			continue // skip messages from another IP
-		}
-
-		if buf[0] == magic && buf[1] == waitMsg {
-			c.addr.Port = addr.Port
-			return buf[:n], nil
-		}
+func (c *Conn) Protocol() string {
+	if c.isTCP {
+		return "cs2+tcp"
 	}
+	return "cs2+udp"
 }
 
 func (c *Conn) RemoteAddr() net.Addr {
-	return c.addr
+	return c.conn.RemoteAddr()
 }
 
 func (c *Conn) SetDeadline(t time.Time) error {
@@ -232,6 +234,14 @@ func (c *Conn) WriteCommand(cmd uint16, data []byte) error {
 	c.cmdMu.Lock()
 	defer c.cmdMu.Unlock()
 
+	req := marshalCmd(0, c.seqCh0, uint32(cmd), data)
+	c.seqCh0++
+
+	if c.isTCP {
+		_, err := c.conn.Write(req)
+		return err
+	}
+
 	var repeat atomic.Int32
 	repeat.Store(5)
 
@@ -243,11 +253,8 @@ func (c *Conn) WriteCommand(cmd uint16, data []byte) error {
 		timeout.Reset(1)
 	}
 
-	req := marshalCmd(0, c.seqCh0, uint32(cmd), data)
-	c.seqCh0++
-
 	for {
-		if err := c.Write(req); err != nil {
+		if _, err := c.conn.Write(req); err != nil {
 			return err
 		}
 		<-timeout.C
@@ -285,7 +292,8 @@ func (c *Conn) WritePacket(data []byte) error {
 	binary.BigEndian.PutUint32(req[8:], n)
 	copy(req[offset:], data)
 
-	return c.Write(req)
+	_, err := c.conn.Write(req)
+	return err
 }
 
 func marshalCmd(channel byte, seq uint16, cmd uint32, payload []byte) []byte {
@@ -313,3 +321,112 @@ func marshalCmd(channel byte, seq uint16, cmd uint32, payload []byte) []byte {
 
 	return req
 }
+
+func newUDPConn(host string, port int) (net.Conn, error) {
+	// We using raw net.UDPConn, because RemoteAddr should be changed during handshake.
+	conn, err := net.ListenUDP("udp", nil)
+	if err != nil {
+		return nil, err
+	}
+
+	addr, err := net.ResolveUDPAddr("udp", host)
+	if err != nil {
+		addr = &net.UDPAddr{IP: net.ParseIP(host), Port: port}
+	}
+
+	return &udpConn{UDPConn: conn, addr: addr}, nil
+}
+
+type udpConn struct {
+	*net.UDPConn
+	addr *net.UDPAddr
+}
+
+func (c *udpConn) Read(p []byte) (n int, err error) {
+	var addr *net.UDPAddr
+	for {
+		n, addr, err = c.UDPConn.ReadFromUDP(p)
+		if err != nil {
+			return 0, err
+		}
+
+		if string(addr.IP) == string(c.addr.IP) || n >= 8 {
+			return
+		}
+	}
+}
+
+func (c *udpConn) Write(req []byte) (n int, err error) {
+	//log.Printf("-> %x", req)
+	return c.UDPConn.WriteToUDP(req, c.addr)
+}
+
+func (c *udpConn) RemoteAddr() net.Addr {
+	return c.addr
+}
+
+func (c *udpConn) WriteUntil(req []byte, ok func(res []byte) bool) ([]byte, error) {
+	var t *time.Timer
+	t = time.AfterFunc(1, func() {
+		if _, err := c.Write(req); err == nil && t != nil {
+			t.Reset(time.Second)
+		}
+	})
+	defer t.Stop()
+
+	buf := make([]byte, 1200)
+
+	for {
+		n, addr, err := c.UDPConn.ReadFromUDP(buf)
+		if err != nil {
+			return nil, err
+		}
+
+		if string(addr.IP) != string(c.addr.IP) || n < 16 {
+			continue // skip messages from another IP
+		}
+
+		if ok(buf[:n]) {
+			c.addr.Port = addr.Port
+			return buf[:n], nil
+		}
+	}
+}
+
+func newTCPConn(addr string) (net.Conn, error) {
+	conn, err := net.DialTimeout("tcp", addr, 3*time.Second)
+	if err != nil {
+		return nil, err
+	}
+	return &tcpConn{conn.(*net.TCPConn), bufio.NewReader(conn)}, nil
+}
+
+type tcpConn struct {
+	*net.TCPConn
+	rd *bufio.Reader
+}
+
+func (c *tcpConn) Read(p []byte) (n int, err error) {
+	tmp := make([]byte, 8)
+	if _, err = io.ReadFull(c.rd, tmp); err != nil {
+		return
+	}
+	n = int(binary.BigEndian.Uint16(tmp))
+	if len(p) < n {
+		return 0, fmt.Errorf("tcp: buffer too small")
+	}
+	_, err = io.ReadFull(c.rd, p[:n])
+	//log.Printf("<- %x%x", tmp, p[:n])
+	return
+}
+
+func (c *tcpConn) Write(req []byte) (n int, err error) {
+	n = len(req)
+	buf := make([]byte, 8+n)
+	binary.BigEndian.PutUint16(buf, uint16(n))
+	buf[2] = 0x68
+	copy(buf[8:], req)
+	//log.Printf("-> %x", buf)
+	_, err = c.TCPConn.Write(buf)
+	return
+}
diff --git a/pkg/xiaomi/miss/client.go b/pkg/xiaomi/miss/client.go
index a335968d..470c0e0e 100644
--- a/pkg/xiaomi/miss/client.go
+++ b/pkg/xiaomi/miss/client.go
@@ -33,7 +33,7 @@ func Dial(rawURL string) (*Client, error) {
 
 	switch s := query.Get("vendor"); s {
 	case "cs2":
-		c.conn, err = cs2.Dial(u.Host)
+		c.conn, err = cs2.Dial(u.Host, query.Get("transport"))
 	case "tutk":
 		c.conn, err = tutk.Dial(u.Host, query.Get("uid"))
 	default:
@@ -63,6 +63,7 @@ const (
 )
 
 type Conn interface {
+	Protocol() string
 	ReadCommand() (cmd uint16, data []byte, err error)
 	WriteCommand(cmd uint16, data []byte) error
 	ReadPacket() ([]byte, error)
@@ -77,6 +78,10 @@ type Client struct {
 	key  []byte
 }
 
+func (c *Client) Protocol() string {
+	return c.conn.Protocol()
+}
+
 func (c *Client) RemoteAddr() net.Addr {
 	return c.conn.RemoteAddr()
 }
@@ -89,16 +94,6 @@ func (c *Client) Close() error {
 	return c.conn.Close()
 }
 
-func (c *Client) Protocol() string {
-	switch c.conn.(type) {
-	case *cs2.Conn:
-		return "cs2+udp"
-	case *tutk.Conn:
-		return "tutk+udp"
-	}
-	return ""
-}
-
 const (
 	cmdAuthReq           = 0x100
 	cmdAuthRes           = 0x101
diff --git a/pkg/xiaomi/tutk/conn.go b/pkg/xiaomi/tutk/conn.go
index bce4a795..f3005224 100644
--- a/pkg/xiaomi/tutk/conn.go
+++ b/pkg/xiaomi/tutk/conn.go
@@ -249,6 +249,10 @@ func (c *Conn) WriteAndWait(req []byte, ok func(req, res []byte) bool) ([]byte,
 	}
 }
 
+func (c *Conn) Protocol() string {
+	return "tutk+udp"
+}
+
 func (c *Conn) RemoteAddr() net.Addr {
 	return c.addr
 }

From 3fd1fe2622cfc9fbac9ced0447058d0f27428e79 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Fri, 26 Dec 2025 14:09:22 +0300
Subject: [PATCH 08/26] Add net interfaces list to webrtc debug

---
 internal/webrtc/webrtc.go | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/internal/webrtc/webrtc.go b/internal/webrtc/webrtc.go
index 03545cff..960bc689 100644
--- a/internal/webrtc/webrtc.go
+++ b/internal/webrtc/webrtc.go
@@ -2,6 +2,7 @@ package webrtc
 
 import (
 	"errors"
+	"net"
 	"strings"
 
 	"github.com/AlexxIT/go2rtc/internal/api"
@@ -33,7 +34,13 @@ func Init() {
 
 	log = app.GetLogger("webrtc")
 
-	filters = cfg.Mod.Filters
+	if log.Debug().Enabled() {
+		itfs, _ := net.Interfaces()
+		for _, itf := range itfs {
+			addrs, _ := itf.Addrs()
+			log.Debug().Msgf("[webrtc] interface %+v addrs %v", itf, addrs)
+		}
+	}
 
 	address, network, _ := strings.Cut(cfg.Mod.Listen, "/")
 	for _, candidate := range cfg.Mod.Candidates {
@@ -53,7 +60,7 @@ func Init() {
 	var err error
 
 	// create pionAPI with custom codecs list and custom network settings
-	serverAPI, err = webrtc.NewServerAPI(network, address, &filters)
+	serverAPI, err = webrtc.NewServerAPI(network, address, &cfg.Mod.Filters)
 	if err != nil {
 		log.Error().Err(err).Caller().Send()
 		return

From 9b618f45d00b58dc8393439a996243f50ecdcab7 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Fri, 26 Dec 2025 22:56:39 +0300
Subject: [PATCH 09/26] Rewrite webrtc listen logic #1890 #1892

---
 internal/webrtc/webrtc.go |  10 ++-
 pkg/webrtc/api.go         | 161 +++++++++++++++++++++++++++++---------
 2 files changed, 132 insertions(+), 39 deletions(-)

diff --git a/internal/webrtc/webrtc.go b/internal/webrtc/webrtc.go
index 960bc689..2a5b4ad6 100644
--- a/internal/webrtc/webrtc.go
+++ b/internal/webrtc/webrtc.go
@@ -57,6 +57,15 @@ func Init() {
 		}
 	}
 
+	webrtc.OnNewListener = func(ln any) {
+		switch ln := ln.(type) {
+		case *net.TCPListener:
+			log.Info().Stringer("addr", ln.Addr()).Msg("[webrtc] listen tcp")
+		case *net.UDPConn:
+			log.Info().Stringer("addr", ln.LocalAddr()).Msg("[webrtc] listen udp")
+		}
+	}
+
 	var err error
 
 	// create pionAPI with custom codecs list and custom network settings
@@ -70,7 +79,6 @@ func Init() {
 	clientAPI = serverAPI
 
 	if address != "" {
-		log.Info().Str("addr", cfg.Mod.Listen).Msg("[webrtc] listen")
 		clientAPI, _ = webrtc.NewAPI()
 	}
 
diff --git a/pkg/webrtc/api.go b/pkg/webrtc/api.go
index 79cf6d3c..5551d65e 100644
--- a/pkg/webrtc/api.go
+++ b/pkg/webrtc/api.go
@@ -1,7 +1,9 @@
 package webrtc
 
 import (
+	"fmt"
 	"net"
+	"slices"
 
 	"github.com/AlexxIT/go2rtc/pkg/core"
 	"github.com/AlexxIT/go2rtc/pkg/xnet"
@@ -27,6 +29,69 @@ type Filters struct {
 	UDPPorts   []uint16 `yaml:"udp_ports"`
 }
 
+func (f *Filters) Network(protocol string) string {
+	if f == nil || f.Networks == nil {
+		return protocol
+	}
+	v4 := slices.Contains(f.Networks, protocol+"4")
+	v6 := slices.Contains(f.Networks, protocol+"6")
+	if v4 && v6 {
+		return protocol
+	} else if v4 {
+		return protocol + "4"
+	} else if v6 {
+		return protocol + "6"
+	}
+	return ""
+}
+
+func (f *Filters) NetIPs() (ips []net.IP) {
+	itfs, _ := net.Interfaces()
+	for _, itf := range itfs {
+		if itf.Flags&net.FlagUp == 0 {
+			continue
+		}
+		if !f.IncludeLoopback() && itf.Flags&net.FlagLoopback != 0 {
+			continue
+		}
+		if !f.InterfaceFilter(itf.Name) {
+			continue
+		}
+
+		addrs, _ := itf.Addrs()
+		for _, addr := range addrs {
+			ip := parseNetAddr(addr)
+			if ip == nil || !f.IPFilter(ip) {
+				continue
+			}
+			ips = append(ips, ip)
+		}
+	}
+	return
+}
+
+func parseNetAddr(addr net.Addr) net.IP {
+	switch addr := addr.(type) {
+	case *net.IPNet:
+		return addr.IP
+	case *net.IPAddr:
+		return addr.IP
+	}
+	return nil
+}
+
+func (f *Filters) IncludeLoopback() bool {
+	return f != nil && f.Loopback
+}
+
+func (f *Filters) InterfaceFilter(name string) bool {
+	return f == nil || f.Interfaces == nil || slices.Contains(f.Interfaces, name)
+}
+
+func (f *Filters) IPFilter(ip net.IP) bool {
+	return f == nil || f.IPs == nil || core.Contains(f.IPs, ip.String())
+}
+
 func NewServerAPI(network, address string, filters *Filters) (*webrtc.API, error) {
 	// for debug logs add to env: `PION_LOG_DEBUG=all`
 	m := &webrtc.MediaEngine{}
@@ -99,48 +164,17 @@ func NewServerAPI(network, address string, filters *Filters) (*webrtc.API, error
 		_ = s.SetEphemeralUDPPortRange(filters.UDPPorts[0], filters.UDPPorts[1])
 	}
 
-	//if len(hosts) != 0 {
-	//	// support only: host, srflx
-	//	if candidateType, err := webrtc.NewICECandidateType(hosts[0]); err == nil {
-	//		s.SetNAT1To1IPs(hosts[1:], candidateType)
-	//	} else {
-	//		s.SetNAT1To1IPs(hosts, 0) // 0 = host
-	//	}
-	//}
-
+	// If you don't specify an address, this won't cause an error.
+	// Connections can still be established using random UDP addresses.
 	if address != "" {
+		// Both newMux functions respect filters and do not raise an error
+		// if the port cannot be listened on.
 		if network == "" || network == "tcp" {
-			if ln, err := net.Listen("tcp", address); err == nil {
-				tcpMux := webrtc.NewICETCPMux(nil, ln, 8)
-				s.SetICETCPMux(tcpMux)
-			}
+			tcpMux := newTCPMux(address, filters)
+			s.SetICETCPMux(tcpMux)
 		}
-
 		if network == "" || network == "udp" {
-			// UDPMuxDefault should not listening on unspecified address, use NewMultiUDPMuxFromPort instead
-			var udpMux ice.UDPMux
-			if port := xnet.ParseUnspecifiedPort(address); port != 0 {
-				var networks []ice.NetworkType
-				for _, ntype := range networkTypes {
-					networks = append(networks, ice.NetworkType(ntype))
-				}
-
-				var err error
-				if udpMux, err = ice.NewMultiUDPMuxFromPort(
-					port,
-					ice.UDPMuxFromPortWithInterfaceFilter(interfaceFilter),
-					ice.UDPMuxFromPortWithIPFilter(ipFilter),
-					ice.UDPMuxFromPortWithNetworks(networks...),
-				); err != nil {
-					return nil, err
-				}
-			} else {
-				ln, err := net.ListenPacket("udp", address)
-				if err != nil {
-					return nil, err
-				}
-				udpMux = ice.NewUDPMuxDefault(ice.UDPMuxParams{UDPConn: ln})
-			}
+			udpMux := newUDPMux(address, filters)
 			s.SetICEUDPMux(udpMux)
 		}
 	}
@@ -152,6 +186,57 @@ func NewServerAPI(network, address string, filters *Filters) (*webrtc.API, error
 	), nil
 }
 
+// OnNewListener temporary ugly solution for log
+var OnNewListener = func(ln any) {}
+
+func newTCPMux(address string, filters *Filters) ice.TCPMux {
+	networkTCP := filters.Network("tcp") // tcp or tcp4 or tcp6
+	if ln, _ := net.Listen(networkTCP, address); ln != nil {
+		OnNewListener(ln)
+		return webrtc.NewICETCPMux(nil, ln, 8)
+	}
+	return nil
+}
+
+func newUDPMux(address string, filters *Filters) ice.UDPMux {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil
+	}
+
+	// UDPMux should not listening on unspecified address.
+	// So we will create a listener on all available interfaces.
+	// We can't use ice.NewMultiUDPMuxFromPort, because it sometimes crashes with an error:
+	//     listen udp [***]:8555: bind: cannot assign requested address
+	var addrs []string
+	if host == "" {
+		for _, ip := range filters.NetIPs() {
+			addrs = append(addrs, fmt.Sprintf("%s:%s", ip, port))
+		}
+	} else {
+		addrs = []string{address}
+	}
+
+	networkUDP := filters.Network("udp") // udp or udp4 or udp6
+
+	var muxes []ice.UDPMux
+	for _, addr := range addrs {
+		if ln, _ := net.ListenPacket(networkUDP, addr); ln != nil {
+			OnNewListener(ln)
+			mux := ice.NewUDPMuxDefault(ice.UDPMuxParams{UDPConn: ln})
+			muxes = append(muxes, mux)
+		}
+	}
+
+	switch len(muxes) {
+	case 0:
+		return nil
+	case 1:
+		return muxes[0]
+	}
+	return ice.NewMultiUDPMuxDefault(muxes...)
+}
+
 func RegisterDefaultCodecs(m *webrtc.MediaEngine) error {
 	for _, codec := range []webrtc.RTPCodecParameters{
 		{

From c4fb66a8182bf2950db9e3523967f77281a61961 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Fri, 26 Dec 2025 23:05:58 +0300
Subject: [PATCH 10/26] Code refactoring for #1992

---
 internal/onvif/onvif.go | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/internal/onvif/onvif.go b/internal/onvif/onvif.go
index 5b1c8233..8d80398a 100644
--- a/internal/onvif/onvif.go
+++ b/internal/onvif/onvif.go
@@ -34,9 +34,6 @@ func Init() {
 var log zerolog.Logger
 
 func streamOnvif(rawURL string) (core.Producer, error) {
-	// Split the ONVIF URL to extract hash-based arguments
-	rawURL, rawQuery, _ := strings.Cut(rawURL, "#")
-
 	client, err := onvif.NewClient(rawURL)
 	if err != nil {
 		return nil, err
@@ -48,8 +45,8 @@ func streamOnvif(rawURL string) (core.Producer, error) {
 	}
 
 	// Append hash-based arguments to the retrieved URI
-	if rawQuery != "" {
-		uri = uri + "#" + rawQuery
+	if i := strings.IndexByte(rawURL, '#'); i > 0 {
+		uri += rawURL[i:]
 	}
 
 	log.Debug().Msgf("[onvif] new uri=%s", uri)

From da0b19026ca90519d7cf9ad2136e334fc37c191a Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 07:59:22 +0300
Subject: [PATCH 11/26] Improve YAML linter with indentation and block scalar
 checks

Adds detection for inconsistent indentation and unexpected indentation at the document root. Enhances block scalar handling by tracking parent indentation and skipping content lines accordingly. Also improves error reporting for missing map keys or list items.
---
 www/config.html | 54 ++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/www/config.html b/www/config.html
index 8e50f340..b4b20c04 100644
--- a/www/config.html
+++ b/www/config.html
@@ -456,6 +456,23 @@
         const lintYamlModel = (model, schemaTools) => {
             const markers = [];
             const markedLines = new Set();
+            let blockScalarParentIndent = null;
+
+            const isBlockScalarHeader = (text) => {
+                const t = (text ?? '').trimStart();
+                return t.startsWith('|') || t.startsWith('>');
+            };
+
+            const checkChildIndent = (ctx, childIndent, lineNumber) => {
+                if (!ctx) return;
+                if (ctx.childIndent == null) {
+                    ctx.childIndent = childIndent;
+                    return;
+                }
+                if (childIndent !== ctx.childIndent) {
+                    markLineError(lineNumber, `YAML: inconsistent indentation (expected ${ctx.childIndent} spaces)`, 1);
+                }
+            };
 
             const markLineError = (lineNumber, message, startColumn = 1) => {
                 if (markedLines.has(`${lineNumber}:${message}`)) return;
@@ -500,6 +517,7 @@
                 expected: 'object',
                 actual: null,
                 keys: new Map(),
+                childIndent: null,
                 origin: null,
                 reportedTypeMismatch: false,
             }];
@@ -566,6 +584,13 @@
                 if (!line.trim()) continue;
 
                 const indent = countIndent(line);
+                if (blockScalarParentIndent !== null && indent <= blockScalarParentIndent) {
+                    blockScalarParentIndent = null;
+                }
+                if (blockScalarParentIndent !== null && indent > blockScalarParentIndent) {
+                    continue; // treat as block scalar content
+                }
+
                 if (indent === 0 && (hasTopLevelKey || hasTopLevelList)) {
                     const trimmed = line.trim();
                     if (trimmed !== '---' && trimmed !== '...' && !trimmed.startsWith('#')) {
@@ -581,9 +606,13 @@
 
                 const listItem = parseListItem(line);
                 if (listItem) {
+                    if (listItem.indent > 0 && (hasTopLevelKey || hasTopLevelList) && stack.length === 1) {
+                        markLineError(lineNumber, 'YAML: unexpected indentation at document root', 1);
+                    }
                     while (stack.length > 1 && listItem.indent <= stack[stack.length - 1].indent) stack.pop();
 
                     const parent = stack[stack.length - 1];
+                    checkChildIndent(parent, listItem.indent, lineNumber);
                     setActualType(parent, 'array', lineNumber);
 
                     const itemSchema = schemaTools ? schemaTools.getArrayItemSchema(parent.schema) : null;
@@ -595,12 +624,18 @@
                         expected: itemExpected,
                         actual: null,
                         keys: new Map(),
+                        childIndent: null,
                         origin: {lineNumber, startColumn: listItem.dashIndex + 1, endColumn: listItem.dashIndex + 2},
                         reportedTypeMismatch: false,
                     };
                     stack.push(itemCtx);
 
                     if (!listItem.rest) continue;
+                    if (isBlockScalarHeader(listItem.rest)) {
+                        blockScalarParentIndent = listItem.indent;
+                        checkValueType(itemSchema, 'string', lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
+                        continue;
+                    }
 
                     const inline = parseKey(' '.repeat(listItem.afterDashIndex) + listItem.rest);
                     if (inline) {
@@ -608,6 +643,7 @@
                         const kv = inline;
                         while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
                         const ctx = stack[stack.length - 1];
+                        checkChildIndent(ctx, kv.indent, lineNumber);
                         setActualType(ctx, 'object', lineNumber);
 
                         const prev = ctx.keys.get(kv.key);
@@ -636,6 +672,9 @@
                         }
 
                         const propSchema = schemaTools ? schemaTools.getPropertySchema(ctx.schema, kv.key) : null;
+                        if (isBlockScalarHeader(kv.after)) {
+                            blockScalarParentIndent = kv.indent;
+                        }
                         if (kv.isContainer) {
                             stack.push({
                                 indent: kv.indent,
@@ -643,6 +682,7 @@
                                 expected: getExpectedContainerType(propSchema),
                                 actual: null,
                                 keys: new Map(),
+                                childIndent: null,
                                 origin: {lineNumber, startColumn: kv.keyStartIndex + 1, endColumn: kv.keyEndIndex + 1},
                                 reportedTypeMismatch: false,
                             });
@@ -661,10 +701,17 @@
                 }
 
                 const kv = parseKey(line);
-                if (!kv) continue;
+                if (!kv) {
+                    markLineError(lineNumber, 'YAML: expected a map key (key:) or list item (-)', indent + 1);
+                    continue;
+                }
+                if (kv.indent > 0 && (hasTopLevelKey || hasTopLevelList) && stack.length === 1) {
+                    markLineError(lineNumber, 'YAML: unexpected indentation at document root', 1);
+                }
 
                 while (stack.length > 1 && kv.indent <= stack[stack.length - 1].indent) stack.pop();
                 const ctx = stack[stack.length - 1];
+                checkChildIndent(ctx, kv.indent, lineNumber);
                 setActualType(ctx, 'object', lineNumber);
 
                 const prev = ctx.keys.get(kv.key);
@@ -700,12 +747,17 @@
                         expected: getExpectedContainerType(propSchema),
                         actual: null,
                         keys: new Map(),
+                        childIndent: null,
                         origin: {lineNumber, startColumn: kv.keyStartIndex + 1, endColumn: kv.keyEndIndex + 1},
                         reportedTypeMismatch: false,
                     });
                     continue;
                 }
 
+                if (isBlockScalarHeader(kv.after)) {
+                    blockScalarParentIndent = kv.indent;
+                }
+
                 if (!propSchema) continue;
 
                 const actual = classifyYamlScalar(kv.after).type;

From 11ad1129ede87296087d7a04e31fe55a88c16081 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 08:05:42 +0300
Subject: [PATCH 12/26] Add hover provider for YAML editor

Introduces a hover provider to the YAML editor using Monaco, displaying property descriptions from the schema when hovering over keys. This enhances the editor's usability by providing inline documentation for YAML properties.
---
 www/config.html | 64 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/www/config.html b/www/config.html
index b4b20c04..9d01ec4a 100644
--- a/www/config.html
+++ b/www/config.html
@@ -770,6 +770,7 @@
 
         let schemaTools = null;
         let completionProvider = null;
+        let hoverProvider = null;
 
         const scheduleLint = (() => {
             let handle = null;
@@ -932,6 +933,69 @@
                     return {suggestions};
                 }
             });
+
+            if (hoverProvider) hoverProvider.dispose();
+            hoverProvider = monaco.languages.registerHoverProvider('yaml', {
+                provideHover: (model, position) => {
+                    if (!schemaTools) return null;
+
+                    const line = model.getLineContent(position.lineNumber);
+                    const lineNoComment = stripInlineComment(line).trimEnd();
+                    const listItem = parseListItem(lineNoComment);
+
+                    const cursorIndex = position.column - 1;
+                    if (listItem && cursorIndex < listItem.afterDashIndex) return null;
+
+                    let kv;
+                    let effectiveIndent;
+                    let keyStartIndex;
+                    let keyEndIndex;
+
+                    if (listItem) {
+                        if (!listItem.rest) return null;
+                        const synthetic = ' '.repeat(listItem.contentIndent) + listItem.rest;
+                        kv = parseKey(synthetic);
+                        if (!kv) return null;
+                        effectiveIndent = listItem.contentIndent;
+                        keyStartIndex = listItem.afterDashIndex + (kv.keyStartIndex - listItem.contentIndent);
+                        keyEndIndex = listItem.afterDashIndex + (kv.keyEndIndex - listItem.contentIndent);
+                    } else {
+                        kv = parseKey(lineNoComment);
+                        if (!kv) return null;
+                        effectiveIndent = countIndent(lineNoComment);
+                        keyStartIndex = kv.keyStartIndex;
+                        keyEndIndex = kv.keyEndIndex;
+                    }
+
+                    if (cursorIndex < keyStartIndex || cursorIndex >= keyEndIndex) return null;
+
+                    const stack = buildContextStack(model, position.lineNumber - 1);
+                    while (stack.length > 1 && effectiveIndent <= stack[stack.length - 1].indent) stack.pop();
+
+                    let contextSchema = resolveRef(stack[stack.length - 1].schema);
+                    if (listItem && cursorIndex >= listItem.afterDashIndex && contextSchema && contextSchema.type === 'array') {
+                        contextSchema = resolveRef(contextSchema.items);
+                    }
+
+                    if (!contextSchema) return null;
+                    const propSchema = getPropertySchema(contextSchema, kv.key);
+                    if (!propSchema) return null;
+
+                    const resolved = resolveRef(propSchema);
+                    const description = resolved?.description;
+                    if (!description) return null;
+
+                    return {
+                        range: new monaco.Range(
+                            position.lineNumber,
+                            keyStartIndex + 1,
+                            position.lineNumber,
+                            keyEndIndex + 1
+                        ),
+                        contents: [{value: description}],
+                    };
+                }
+            });
         };
 
         let dump;

From 0f4607a070dc4635ac260dd67d322079770cadd9 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 08:08:28 +0300
Subject: [PATCH 13/26] Improve YAML language detection in config.html

Refactored the logic for detecting the YAML language in Monaco editor to handle cases where getLanguages may not be available or Monaco is not loaded. This increases robustness and prevents potential runtime errors.
---
 www/config.html | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/www/config.html b/www/config.html
index 9d01ec4a..d541a780 100644
--- a/www/config.html
+++ b/www/config.html
@@ -52,7 +52,13 @@
         container.textContent = '';
 
         const ensureYamlLanguage = () => {
-            const hasYaml = (monaco.languages.getLanguages?.() || []).some((l) => l.id === 'yaml');
+            const languages =
+                (window.monaco &&
+                    monaco.languages &&
+                    typeof monaco.languages.getLanguages === 'function' &&
+                    monaco.languages.getLanguages()) ||
+                [];
+            const hasYaml = languages.some((l) => l.id === 'yaml');
             if (hasYaml) return;
 
             monaco.languages.register({

From a3a4276c155a2e2edc3787c7eb68cccacd409005 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Sat, 27 Dec 2025 08:36:40 +0300
Subject: [PATCH 14/26] Code refactoring for #1956

---
 internal/ffmpeg/ffmpeg.go | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/internal/ffmpeg/ffmpeg.go b/internal/ffmpeg/ffmpeg.go
index d945c0ff..a3d589b1 100644
--- a/internal/ffmpeg/ffmpeg.go
+++ b/internal/ffmpeg/ffmpeg.go
@@ -2,7 +2,6 @@ package ffmpeg
 
 import (
 	"net/url"
-	"strconv"
 	"strings"
 
 	"github.com/AlexxIT/go2rtc/internal/api"
@@ -59,15 +58,14 @@ func Init() {
 }
 
 var defaults = map[string]string{
-	"bin":    "ffmpeg",
-	"global": "-hide_banner",
+	"bin":     "ffmpeg",
+	"global":  "-hide_banner",
 	"timeout": "5",
 
 	// inputs
-	"file":    "-re -i {input}",
-	"http":    "-fflags nobuffer -flags low_delay -i {input}",
-	"rtsp":    "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}",
-
+	"file":     "-re -i {input}",
+	"http":     "-fflags nobuffer -flags low_delay -i {input}",
+	"rtsp":     "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}",
 	"rtsp/udp": "-fflags nobuffer -flags low_delay -timeout {timeout} -user_agent go2rtc/ffmpeg -i {input}",
 
 	// output
@@ -176,10 +174,7 @@ func inputTemplate(name, s string, query url.Values) string {
 		if timeout == "" {
 			timeout = defaults["timeout"]
 		}
-		if i, _ := strconv.Atoi(timeout); i > 0 {
-			timeout = strconv.Itoa(i * 1000000)
-		}
-		template = strings.Replace(template, "{timeout}", timeout, 1)
+		template = strings.Replace(template, "{timeout}", timeout+"000000", 1)
 	}
 	return strings.Replace(template, "{input}", s, 1)
 }

From 0e65bd05c49553140687c33109e87e679aef9d5c Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 08:49:26 +0300
Subject: [PATCH 15/26] Disable word-based suggestions in editor config

Updated the editor configuration in config.html to set wordBasedSuggestions to false and disable word suggestions in the suggestion widget. This change aims to refine the suggestion behavior for a more focused coding experience.
---
 www/config.html | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/www/config.html b/www/config.html
index d541a780..df8edc91 100644
--- a/www/config.html
+++ b/www/config.html
@@ -129,6 +129,8 @@
             insertSpaces: true,
             quickSuggestions: { other: true, comments: false, strings: true },
             suggestOnTriggerCharacters: true,
+            wordBasedSuggestions: false,
+            suggest: { showWords: false },
             scrollBeyondLastLine: false,
         });
 

From 4c50a2c00cdb9fa4aad0c7a5e3ebc0fd7ea9a9ec Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 08:50:00 +0300
Subject: [PATCH 16/26] Remove redundant min-height property from #config

Deleted an unnecessary 'min-height: 0;' CSS rule from the #config selector, as a fixed min-height is already set.
---
 www/config.html | 1 -
 1 file changed, 1 deletion(-)

diff --git a/www/config.html b/www/config.html
index df8edc91..e6562c5d 100644
--- a/www/config.html
+++ b/www/config.html
@@ -11,7 +11,6 @@
 
         #config {
             flex: 1 1 auto;
-            min-height: 0;
             border-top: 1px solid #ccc;
             min-height: 300px;
         }

From 3bd433c950f3e4cd14aa0619fef57756c38d72cf Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 09:09:32 +0300
Subject: [PATCH 17/26] Improve null checks and object handling in config.html

Replaces optional chaining with explicit null checks and more robust object property access throughout the file. Refactors destructuring and object spreading to use Object.assign for better compatibility. These changes improve code reliability and compatibility with older browsers or environments lacking support for newer JavaScript features.
---
 www/config.html | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/www/config.html b/www/config.html
index e6562c5d..eaf6bcdf 100644
--- a/www/config.html
+++ b/www/config.html
@@ -204,7 +204,7 @@
 
             if (indentIndex >= line.length) return null;
 
-            let i = indentIndex;
+            const i = indentIndex;
             let key = '';
             let rawKey = '';
             let isQuoted = false;
@@ -275,7 +275,7 @@
                 keyEndIndex = i + rawKey.length;
             }
 
-            const after = line.slice(colonIndex + 1) ?? '';
+            const after = line.slice(colonIndex + 1);
             const isContainer = after.trim() === '' || after.trim().startsWith('#');
             const valueStartIndex = colonIndex + 1;
 
@@ -301,11 +301,12 @@
                         if (seen.has(ref)) return schema;
                         seen.add(ref);
                         const name = ref.slice('#/definitions/'.length);
-                        const def = schemaRoot.definitions?.[name];
+                        const def = schemaRoot.definitions && schemaRoot.definitions[name];
                         if (!def) return schema;
                         const resolved = resolveRef(def, seen);
-                        const {$ref, ...rest} = schema;
-                        return {...resolved, ...rest};
+                        const rest = Object.assign({}, schema);
+                        delete rest.$ref;
+                        return Object.assign({}, resolved, rest);
                     }
                 }
                 return schema;
@@ -466,7 +467,8 @@
             let blockScalarParentIndent = null;
 
             const isBlockScalarHeader = (text) => {
-                const t = (text ?? '').trimStart();
+                const rawText = (text == null) ? '' : text;
+                const t = rawText.trimStart ? rawText.trimStart() : rawText.replace(/^\s+/, '');
                 return t.startsWith('|') || t.startsWith('>');
             };
 
@@ -495,14 +497,16 @@
                 });
             };
 
-            if (window.jsyaml?.load) {
+            if (window.jsyaml && window.jsyaml.load) {
                 try {
                     window.jsyaml.load(model.getValue());
                 } catch (e) {
-                    const mark = e?.mark || {};
+                    const mark = (e && e.mark) || {};
                     const line = typeof mark.line === 'number' ? mark.line + 1 : 1;
                     const column = typeof mark.column === 'number' ? mark.column + 1 : 1;
-                    markLineError(line, e?.reason ? `YAML: ${e.reason}` : `YAML: ${e?.message || 'Invalid YAML'}`, column);
+                    const reason = e && e.reason;
+                    const messageText = e && e.message;
+                    markLineError(line, reason ? `YAML: ${reason}` : `YAML: ${messageText || 'Invalid YAML'}`, column);
                 }
             }
 
@@ -520,7 +524,7 @@
 
             const stack = [{
                 indent: -1,
-                schema: schemaTools?.schemaRoot || null,
+                schema: (schemaTools && schemaTools.schemaRoot) || null,
                 expected: 'object',
                 actual: null,
                 keys: new Map(),
@@ -856,8 +860,8 @@
                     const lineNoCommentTrimmedEnd = lineNoComment.trimEnd();
                     const listItem = parseListItem(lineNoCommentTrimmedEnd);
 
-                    const {word, startColumn, endColumn} = model.getWordUntilPosition(position);
-                    const range = new monaco.Range(position.lineNumber, startColumn, position.lineNumber, endColumn);
+                    const wordUntil = model.getWordUntilPosition(position);
+                    const range = new monaco.Range(position.lineNumber, wordUntil.startColumn, position.lineNumber, wordUntil.endColumn);
 
                     const cursorIndex = position.column - 1;
                     let contentStartIndex = 0;
@@ -917,7 +921,7 @@
                                 kind: monaco.languages.CompletionItemKind.Property,
                                 insertText,
                                 insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
-                                documentation: s?.description,
+                                documentation: s && s.description,
                                 range,
                             };
                         });
@@ -989,7 +993,7 @@
                     if (!propSchema) return null;
 
                     const resolved = resolveRef(propSchema);
-                    const description = resolved?.description;
+                    const description = resolved && resolved.description;
                     if (!description) return null;
 
                     return {

From 76bdc7e06555ec4f411e544de5c764839914c635 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 09:56:52 +0300
Subject: [PATCH 18/26] Refactor block scalar handling in config parser

Simplifies the logic for handling block scalar content by restructuring the conditional checks for blockScalarParentIndent. This improves readability and ensures correct processing of indented lines.
---
 www/config.html | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/www/config.html b/www/config.html
index eaf6bcdf..05363c4c 100644
--- a/www/config.html
+++ b/www/config.html
@@ -595,13 +595,13 @@
                 if (!line.trim()) continue;
 
                 const indent = countIndent(line);
-                if (blockScalarParentIndent !== null && indent <= blockScalarParentIndent) {
-                    blockScalarParentIndent = null;
+                if (blockScalarParentIndent !== null) {
+                    if (indent <= blockScalarParentIndent) {
+                        blockScalarParentIndent = null;
+                    } else {
+                        continue; // treat as block scalar content
+                    }      
                 }
-                if (blockScalarParentIndent !== null && indent > blockScalarParentIndent) {
-                    continue; // treat as block scalar content
-                }
-
                 if (indent === 0 && (hasTopLevelKey || hasTopLevelList)) {
                     const trimmed = line.trim();
                     if (trimmed !== '---' && trimmed !== '...' && !trimmed.startsWith('#')) {

From 0fd2217bd216caa598417fe3b91041a01e132d31 Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 10:26:15 +0300
Subject: [PATCH 19/26] Trigger suggestions for property completions

Adds logic to trigger the suggestion widget when completing a property if it expects a block or has value suggestions, improving the user experience in the config editor.
---
 www/config.html | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/www/config.html b/www/config.html
index 05363c4c..f976702a 100644
--- a/www/config.html
+++ b/www/config.html
@@ -915,12 +915,14 @@
                             const innerIndent = indent + '  ';
 
                             const insertText = wantsBlock ? `${key}:\n${innerIndent}` : `${key}: `;
+                            const hasValueSuggestions = !wantsBlock && getValueSuggestions(s).length > 0;
 
                             return {
                                 label: key,
                                 kind: monaco.languages.CompletionItemKind.Property,
                                 insertText,
                                 insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                                command: (wantsBlock || hasValueSuggestions) ? {id: 'editor.action.triggerSuggest'} : undefined,
                                 documentation: s && s.description,
                                 range,
                             };

From 7e38b4fe89bb91fa1a27507755990d4b4f5e49cc Mon Sep 17 00:00:00 2001
From: Sergey Krashevich <svk@svk.su>
Date: Sat, 27 Dec 2025 12:00:47 +0300
Subject: [PATCH 20/26] Add enum and pattern constraint checks to YAML linter

Enhances the YAML linter to validate scalar values against enum and pattern constraints defined in the schema. Adds utility functions for value comparison, schema constraint collection, and applies these checks during linting to provide more precise error messages for invalid values.
---
 www/config.html | 162 +++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 160 insertions(+), 2 deletions(-)

diff --git a/www/config.html b/www/config.html
index f976702a..58f0c3cf 100644
--- a/www/config.html
+++ b/www/config.html
@@ -461,6 +461,33 @@
             return {type: 'string'};
         };
 
+        const parseYamlValue = (raw) => {
+            const trimmed = raw.trim();
+            if (!trimmed) return {ok: false};
+            if (/^\$\{[^}{]+\}$/.test(trimmed)) return {ok: false, dynamic: true};
+            if (trimmed.startsWith('|') || trimmed.startsWith('>')) return {ok: false, block: true};
+            if (window.jsyaml && window.jsyaml.load) {
+                try {
+                    return {ok: true, value: window.jsyaml.load(trimmed)};
+                } catch (e) {
+                    // nothing
+                }
+            }
+            if (trimmed.startsWith('"') && trimmed.endsWith('"') && trimmed.length >= 2) {
+                const inner = trimmed.slice(1, -1);
+                return {ok: true, value: inner.replace(/\\"/g, '"').replace(/\\\\/g, '\\')};
+            }
+            if (trimmed.startsWith('\'') && trimmed.endsWith('\'') && trimmed.length >= 2) {
+                const inner = trimmed.slice(1, -1);
+                return {ok: true, value: inner.replace(/''/g, '\'')};
+            }
+            if (trimmed === 'true' || trimmed === 'false') return {ok: true, value: trimmed === 'true'};
+            if (trimmed === 'null' || trimmed === '~') return {ok: true, value: null};
+            if (isIntLike(trimmed)) return {ok: true, value: parseInt(trimmed, 10)};
+            if (isNumberLike(trimmed)) return {ok: true, value: Number(trimmed)};
+            return {ok: true, value: trimmed};
+        };
+
         const lintYamlModel = (model, schemaTools) => {
             const markers = [];
             const markedLines = new Set();
@@ -587,6 +614,133 @@
                 });
             };
 
+            const valueEquals = (a, b) => {
+                if (a === b) return true;
+                if (typeof a !== typeof b) return false;
+                if (a && b && typeof a === 'object') {
+                    const aIsArray = Array.isArray(a);
+                    const bIsArray = Array.isArray(b);
+                    if (aIsArray !== bIsArray) return false;
+                    if (aIsArray) {
+                        if (a.length !== b.length) return false;
+                        for (let i = 0; i < a.length; i++) {
+                            if (!valueEquals(a[i], b[i])) return false;
+                        }
+                        return true;
+                    }
+                    const aKeys = Object.keys(a);
+                    const bKeys = Object.keys(b);
+                    if (aKeys.length !== bKeys.length) return false;
+                    for (const key of aKeys) {
+                        if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+                        if (!valueEquals(a[key], b[key])) return false;
+                    }
+                    return true;
+                }
+                return false;
+            };
+
+            const schemaAllowsTypeLoose = (schema, actualType) => {
+                if (!schemaTools || !schema) return true;
+                const types = schemaTools.getSchemaTypes(schema);
+                if (types.size === 0) return true;
+                if (actualType === 'integer' && types.has('number')) return true;
+                return types.has(actualType);
+            };
+
+            const collectConstraintSchemas = (schema, actualType) => {
+                if (!schemaTools || !schema) return [];
+                schema = schemaTools.resolveRef(schema);
+                if (!schema) return [];
+                if (Array.isArray(schema.anyOf)) {
+                    const res = [];
+                    for (const alt of schema.anyOf) res.push(...collectConstraintSchemas(alt, actualType));
+                    return res;
+                }
+                if (Array.isArray(schema.oneOf)) {
+                    const res = [];
+                    for (const alt of schema.oneOf) res.push(...collectConstraintSchemas(alt, actualType));
+                    return res;
+                }
+                if (!schemaAllowsTypeLoose(schema, actualType)) return [];
+                return [schema];
+            };
+
+            const getSchemaEnumValues = (schema) => {
+                const values = [];
+                if (Array.isArray(schema.enum)) values.push(...schema.enum);
+                if (Object.prototype.hasOwnProperty.call(schema, 'const')) values.push(schema.const);
+                return values;
+            };
+
+            const checkValueConstraints = (schema, actualType, rawValue, lineNumber, startColumn, endColumn, keyName) => {
+                if (!schemaTools || !schema) return;
+                if (actualType === 'dynamic') return;
+                const parsed = parseYamlValue(rawValue);
+                if (!parsed.ok) return;
+
+                const candidates = collectConstraintSchemas(schema, actualType);
+                if (candidates.length === 0) return;
+
+                const hasConstraints = candidates.some((s) => (
+                    (Array.isArray(s.enum) || Object.prototype.hasOwnProperty.call(s, 'const')) ||
+                    (actualType === 'string' && typeof s.pattern === 'string')
+                ));
+                if (!hasConstraints) return;
+
+                const hasUnconstrained = candidates.some((s) => (
+                    !(Array.isArray(s.enum) || Object.prototype.hasOwnProperty.call(s, 'const')) &&
+                    !(actualType === 'string' && typeof s.pattern === 'string')
+                ));
+                if (hasUnconstrained) return;
+
+                const value = parsed.value;
+                const matchesAny = candidates.some((s) => {
+                    const enums = getSchemaEnumValues(s);
+                    if (enums.length > 0 && !enums.some((v) => valueEquals(v, value))) return false;
+                    if (actualType === 'string' && typeof s.pattern === 'string') {
+                        try {
+                            const re = new RegExp(s.pattern);
+                            if (!re.test(String(value))) return false;
+                        } catch (e) {
+                            return true;
+                        }
+                    }
+                    return true;
+                });
+                if (matchesAny) return;
+
+                const enumValues = [];
+                const patterns = [];
+                for (const s of candidates) {
+                    enumValues.push(...getSchemaEnumValues(s));
+                    if (actualType === 'string' && typeof s.pattern === 'string') patterns.push(s.pattern);
+                }
+                const enumLabel = unique(enumValues).map((v) => toYamlScalar(v)).join(', ');
+                const patternLabel = unique(patterns).join(' | ');
+
+                let message;
+                const label = keyName ? `"${keyName}"` : 'value';
+                if (enumValues.length && patterns.length) {
+                    message = `Value for ${label} must be one of: ${enumLabel}; or match pattern: ${patternLabel}`;
+                } else if (enumValues.length) {
+                    message = `Value for ${label} must be one of: ${enumLabel}`;
+                } else if (patterns.length) {
+                    message = `Value for ${label} must match pattern: ${patternLabel}`;
+                } else {
+                    return;
+                }
+
+                pushMarker({
+                    severity: monaco.MarkerSeverity.Error,
+                    message,
+                    startLineNumber: lineNumber,
+                    startColumn,
+                    endLineNumber: lineNumber,
+                    endColumn: Math.max(startColumn + 1, endColumn),
+                });
+            };
+
             for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
                 let line = model.getLineContent(lineNumber);
                 if (!line.trim()) continue;
@@ -702,12 +856,14 @@
                             const actual = classifyYamlScalar(valueText).type;
                             const valueStartColumn = kv.valueStartIndex + 1 + (kv.after.length - kv.after.trimStart().length);
                             checkValueType(propSchema, actual, lineNumber, valueStartColumn, line.length + 1, kv.key);
+                            checkValueConstraints(propSchema, actual, valueText, lineNumber, valueStartColumn, line.length + 1, kv.key);
                         }
                         continue;
                     }
 
                     const scalar = classifyYamlScalar(listItem.rest).type;
                     checkValueType(itemSchema, scalar, lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
+                    checkValueConstraints(itemSchema, scalar, listItem.rest, lineNumber, listItem.afterDashIndex + 1, line.length + 1, null);
                     continue;
                 }
 
@@ -774,6 +930,7 @@
                 const actual = classifyYamlScalar(kv.after).type;
                 const valueStartColumn = kv.valueStartIndex + 1 + (kv.after.length - kv.after.trimStart().length);
                 checkValueType(propSchema, actual, lineNumber, valueStartColumn, line.length + 1, kv.key);
+                checkValueConstraints(propSchema, actual, kv.after, lineNumber, valueStartColumn, line.length + 1, kv.key);
             }
 
             return markers;
@@ -910,11 +1067,12 @@
                         const props = getObjectProperties(contextSchema);
                         const suggestions = Object.keys(props).map((key) => {
                             const s = resolveRef(props[key]);
-                            const wantsBlock = s && (s.type === 'object' || s.type === 'array' || s.properties);
+                            const wantsArray = s && s.type === 'array';
+                            const wantsBlock = s && (s.type === 'object' || wantsArray || s.properties);
                             const indent = listItem ? ' '.repeat(listItem.contentIndent) : ' '.repeat(countIndent(lineNoComment));
                             const innerIndent = indent + '  ';
 
-                            const insertText = wantsBlock ? `${key}:\n${innerIndent}` : `${key}: `;
+                            const insertText = wantsArray ? `${key}:\n${indent}` : (wantsBlock ? `${key}:\n${innerIndent}` : `${key}: `);
                             const hasValueSuggestions = !wantsBlock && getValueSuggestions(s).length > 0;
 
                             return {

From 86f9f114b5270145d3a32e422884decb3463de9c Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Sat, 27 Dec 2025 12:04:42 +0300
Subject: [PATCH 21/26] Code refactoring for #1980

---
 website/schema.json | 353 ++++++++-----------
 www/config.html     |  50 +--
 www/schema.json     | 824 --------------------------------------------
 www/static.go       |   1 -
 4 files changed, 169 insertions(+), 1059 deletions(-)
 delete mode 100644 www/schema.json

diff --git a/website/schema.json b/website/schema.json
index 726879e3..d9c87e40 100644
--- a/website/schema.json
+++ b/website/schema.json
@@ -29,6 +29,22 @@
         "panic",
         "disabled"
       ]
+    },
+    "source": {
+      "type": "string",
+      "examples": [
+        "rtsp://username:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
+        "rtsp://username:password@192.168.1.123/stream1",
+        "rtsp://username:password@192.168.1.123/h264Preview_01_main",
+        "rtmp://192.168.1.123/bcs/channel0_main.bcs?channel=0&stream=0&user=username&password=password",
+        "http://192.168.1.123/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password",
+        "http://username:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1",
+        "ffmpeg:media.mp4#video=h264#hardware#width=1920#height=1080#rotate=180#audio=copy",
+        "ffmpeg:virtual?video=testsrc&size=4K#video=h264#hardware#bitrate=50M",
+        "exec:ffmpeg -re -i media.mp4 -c copy -rtsp_transport tcp -f rtsp {output}",
+        "onvif://username:password@192.168.1.123:80?subtype=0",
+        "tapo://password@192.168.1.123:8800?channel=0&subtype=0"
+      ]
     }
   },
   "properties": {
@@ -36,13 +52,14 @@
       "type": "object",
       "properties": {
         "listen": {
+          "type": "string",
           "default": ":1984",
           "examples": [
-            "127.0.0.1:8080"
-          ],
-          "$ref": "#/definitions/listen"
+            "127.0.0.1:1984"
+          ]
         },
         "username": {
+          "description": "Basic auth for WebUI",
           "type": "string",
           "examples": [
             "admin"
@@ -52,38 +69,34 @@
           "type": "string"
         },
         "local_auth": {
-          "description": "Allow auth from local network without credentials (uses existing Auth header)",
+          "description": "Enable auth check for localhost requests",
           "type": "boolean",
           "default": false
         },
         "base_path": {
+          "description": "API prefix for serving on suburl (/api => /rtc/api)",
           "type": "string",
           "examples": [
-            "/go2rtc"
+            "/rtc"
           ]
         },
         "static_dir": {
+          "description": "Folder for static files (custom web interface)",
           "type": "string",
           "examples": [
-            "/var/www"
+            "www"
           ]
         },
         "origin": {
-          "description": "Set to \"*\" to enable CORS and allow any Origin",
+          "description": "Allow CORS requests (only * supported)",
           "type": "string",
-          "anyOf": [
-            {
-              "type": "string",
-              "const": "*"
-            },
-            {
-              "type": "string",
-              "const": ""
-            }
+          "enum": [
+            "*",
+            ""
           ]
         },
         "tls_listen": {
-          "$ref": "#/definitions/listen"
+          "type": "string"
         },
         "tls_cert": {
           "type": "string",
@@ -106,16 +119,16 @@
           ]
         },
         "allow_paths": {
-          "description": "Allow only these HTTP paths (full paths, including base_path); when set, all other endpoints are not registered",
+          "description": "Allow only these HTTP paths (full paths, including base_path)",
           "type": "array",
           "items": {
             "type": "string"
           },
           "examples": [
             [
-              "/api/ws",
-              "/api/config",
-              "/api/streams"
+              "/api",
+              "/api/streams",
+              "/api/webrtc"
             ]
           ]
         }
@@ -164,6 +177,7 @@
               "roborock",
               "tapo",
               "tuya",
+              "xiaomi",
               "yandex",
               "debug",
               "ngrok",
@@ -189,13 +203,7 @@
           "type": "array",
           "items": {
             "type": "string"
-          },
-          "examples": [
-            [
-              "ffmpeg",
-              "/usr/bin/ffmpeg"
-            ]
-          ]
+          }
         }
       }
     },
@@ -223,6 +231,26 @@
         "bin": {
           "type": "string",
           "default": "ffmpeg"
+        },
+        "global": {
+          "type": "string",
+          "default": "-hide_banner"
+        },
+        "file": {
+          "type": "string",
+          "default": "-re -i {input}"
+        },
+        "http": {
+          "type": "string",
+          "default": "-fflags nobuffer -flags low_delay -i {input}"
+        },
+        "rtsp": {
+          "type": "string",
+          "default": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -rtsp_flags prefer_tcp -i {input}"
+        },
+        "rtsp/udp": {
+          "type": "string",
+          "default": "-fflags nobuffer -flags low_delay -timeout 5000000 -user_agent go2rtc/ffmpeg -i {input}"
         }
       },
       "additionalProperties": {
@@ -245,57 +273,62 @@
     "homekit": {
       "type": "object",
       "additionalProperties": {
-        "type": "object",
-      "properties": {
-        "pin": {
-          "description": "HomeKit pairing PIN (will be normalized to XXX-XX-XXX); insecure PINs are rejected",
-          "type": "string",
-          "default": "19550224",
-          "anyOf": [
-            {
-              "type": "string",
-              "pattern": "^[0-9]{8}$"
-            },
-            {
-              "type": "string",
-              "pattern": "^[0-9]{3}-[0-9]{2}-[0-9]{3}$"
-            }
-          ]
-        },
-        "name": {
-          "type": "string"
-        },
+        "type": [
+          "object",
+          "null"
+        ],
+        "properties": {
+          "pin": {
+            "description": "HomeKit pairing PIN",
+            "type": "string",
+            "default": "19550224",
+            "anyOf": [
+              {
+                "type": "string",
+                "pattern": "^[0-9]{8}$"
+              },
+              {
+                "type": "string",
+                "pattern": "^[0-9]{3}-[0-9]{2}-[0-9]{3}$"
+              }
+            ]
+          },
+          "name": {
+            "type": "string"
+          },
           "device_id": {
             "type": "string"
           },
-        "device_private": {
-          "type": "string"
-        },
-        "category_id": {
-          "description": "Accessory category: \"bridge\", \"doorbell\" or numeric ID (default: camera)",
-          "type": "string",
-          "anyOf": [
-            {
-              "type": "string",
-              "enum": [
-                "bridge",
-                "doorbell"
-              ]
-            },
-            {
-              "type": "string",
-              "pattern": "^[0-9]+$"
-            },
-            {
-              "type": "string",
-              "const": ""
-            }
-          ]
-        },
-        "pairings": {
-          "type": "array",
-          "items": {
+          "device_private": {
             "type": "string"
+          },
+          "category_id": {
+            "description": "Accessory category: `bridge`, `doorbell` or numeric ID",
+            "type": "string",
+            "default": "camera",
+            "anyOf": [
+              {
+                "type": "string",
+                "enum": [
+                  "bridge",
+                  "camera",
+                  "doorbell"
+                ]
+              },
+              {
+                "type": "string",
+                "pattern": "^[0-9]+$"
+              },
+              {
+                "type": "string",
+                "const": ""
+              }
+            ]
+          },
+          "pairings": {
+            "type": "array",
+            "items": {
+              "type": "string"
             }
           }
         }
@@ -366,24 +399,6 @@
         "api": {
           "$ref": "#/definitions/log_level"
         },
-        "alsa": {
-          "$ref": "#/definitions/log_level"
-        },
-        "bubble": {
-          "$ref": "#/definitions/log_level"
-        },
-        "debug": {
-          "$ref": "#/definitions/log_level"
-        },
-        "doorbird": {
-          "$ref": "#/definitions/log_level"
-        },
-        "dvrip": {
-          "$ref": "#/definitions/log_level"
-        },
-        "eseecloud": {
-          "$ref": "#/definitions/log_level"
-        },
         "echo": {
           "$ref": "#/definitions/log_level"
         },
@@ -399,12 +414,6 @@
           "default": "error",
           "$ref": "#/definitions/log_level"
         },
-        "flussonic": {
-          "$ref": "#/definitions/log_level"
-        },
-        "gopro": {
-          "$ref": "#/definitions/log_level"
-        },
         "hass": {
           "$ref": "#/definitions/log_level"
         },
@@ -414,63 +423,27 @@
         "homekit": {
           "$ref": "#/definitions/log_level"
         },
-        "http": {
-          "$ref": "#/definitions/log_level"
-        },
-        "isapi": {
-          "$ref": "#/definitions/log_level"
-        },
-        "ivideon": {
-          "$ref": "#/definitions/log_level"
-        },
         "mjpeg": {
           "$ref": "#/definitions/log_level"
         },
-        "mpegts": {
-          "$ref": "#/definitions/log_level"
-        },
         "mp4": {
           "$ref": "#/definitions/log_level"
         },
-        "nest": {
-          "$ref": "#/definitions/log_level"
-        },
         "ngrok": {
           "$ref": "#/definitions/log_level"
         },
         "onvif": {
           "$ref": "#/definitions/log_level"
         },
-        "pinggy": {
-          "$ref": "#/definitions/log_level"
-        },
-        "ring": {
-          "$ref": "#/definitions/log_level"
-        },
-        "roborock": {
-          "$ref": "#/definitions/log_level"
-        },
         "rtmp": {
           "$ref": "#/definitions/log_level"
         },
         "rtsp": {
           "$ref": "#/definitions/log_level"
         },
-        "srtp": {
-          "$ref": "#/definitions/log_level"
-        },
         "streams": {
           "$ref": "#/definitions/log_level"
         },
-        "tapo": {
-          "$ref": "#/definitions/log_level"
-        },
-        "tuya": {
-          "$ref": "#/definitions/log_level"
-        },
-        "v4l2": {
-          "$ref": "#/definitions/log_level"
-        },
         "webrtc": {
           "$ref": "#/definitions/log_level"
         },
@@ -479,13 +452,7 @@
         },
         "wyoming": {
           "$ref": "#/definitions/log_level"
-        },
-        "yandex": {
-          "$ref": "#/definitions/log_level"
         }
-      },
-      "additionalProperties": {
-        "$ref": "#/definitions/log_level"
       }
     },
     "ngrok": {
@@ -504,17 +471,17 @@
       "type": "object",
       "properties": {
         "tunnel": {
-          "description": "Expose local address via Pinggy (scheme: http/tcp/tls/tlstcp, host:port is your local address)",
+          "description": "Expose local address via Pinggy",
           "type": "string",
           "examples": [
             "http://127.0.0.1:1984",
-            "tcp://127.0.0.1:8554"
+            "tcp://192.168.1.123:554"
           ]
         }
       }
     },
     "preload": {
-      "description": "Preload streams on startup (map stream name => probe query, default \"video&audio\")",
+      "description": "Preload streams on startup (map stream name => probe query, default `video&audio`)",
       "type": "object",
       "additionalProperties": {
         "type": "string",
@@ -548,10 +515,10 @@
       "type": "object",
       "properties": {
         "listen": {
+          "type": "string",
           "examples": [
             ":1935"
-          ],
-          "$ref": "#/definitions/listen"
+          ]
         }
       }
     },
@@ -559,8 +526,8 @@
       "type": "object",
       "properties": {
         "listen": {
-          "default": ":8554",
-          "$ref": "#/definitions/listen"
+          "type": "string",
+          "default": ":8554"
         },
         "username": {
           "type": "string",
@@ -585,98 +552,56 @@
       "type": "object",
       "properties": {
         "listen": {
-          "default": ":8443",
-          "$ref": "#/definitions/listen"
+          "type": "string",
+          "default": ":8443"
         }
       }
     },
     "streams": {
       "type": "object",
       "additionalProperties": {
-        "title": "Stream",
         "anyOf": [
           {
-            "description": "Source",
-            "type": "string",
-            "examples": [
-              "rtsp://username:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
-              "rtsp://username:password@192.168.1.123/stream1",
-              "rtsp://username:password@192.168.1.123/h264Preview_01_main",
-              "rtmp://192.168.1.123/bcs/channel0_main.bcs?channel=0&stream=0&user=username&password=password",
-              "http://192.168.1.123/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password",
-              "http://username:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1",
-              "ffmpeg:media.mp4#video=h264#hardware#width=1920#height=1080#rotate=180#audio=copy",
-              "ffmpeg:virtual?video=testsrc&size=4K#video=h264#hardware#bitrate=50M",
-              "bubble://username:password@192.168.1.123:34567/bubble/live?ch=0&stream=0",
-              "dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0",
-              "exec:ffmpeg -re -i media.mp4 -c copy -rtsp_transport tcp -f rtsp {output}",
-              "isapi://username:password@192.168.1.123:80/",
-              "kasa://username:password@192.168.1.123:19443/https/stream/mixed",
-              "onvif://username:password@192.168.1.123:80?subtype=0",
-              "tapo://password@192.168.1.123:8800?channel=0&subtype=0",
-              "webtorrent:?share=xxx&pwd=xxx"
-            ]
+            "$ref": "#/definitions/source"
           },
           {
             "type": "array",
             "items": {
-              "description": "Source",
-              "type": "string"
+              "$ref": "#/definitions/source"
             }
           },
           {
-            "type": "object",
-            "properties": {
-              "url": {
-                "description": "Source URL or list of URLs",
-                "anyOf": [
-                  {
-                    "type": "string",
-                    "examples": [
-                      "rtsp://username:password@192.168.1.123/stream1",
-                      "ffmpeg:media.mp4#video=h264#audio=copy"
-                    ]
-                  },
-                  {
-                    "type": "array",
-                    "items": {
-                      "type": "string"
-                    }
-                  }
-                ]
-              }
-            }
+            "type": "null"
           }
         ]
       }
     },
+    "xiaomi": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    },
     "webrtc": {
       "type": "object",
       "properties": {
         "listen": {
-          "default": ":8555/tcp",
           "type": "string",
-          "anyOf": [
-            {
-              "type": "string",
-              "pattern": ":[0-9]{1,5}(/tcp|/udp)?$"
-            },
-            {
-              "type": "string",
-              "const": ""
-            }
+          "default": ":8555",
+          "examples": [
+            ":8555/udp"
           ]
         },
         "candidates": {
           "type": "array",
           "items": {
-            "$ref": "#/definitions/listen/anyOf/0"
-          },
-          "examples": [
-            "216.58.210.174:8555",
-            "stun:8555",
-            "home.duckdns.org:8555"
-          ]
+            "type": "string",
+            "examples": [
+              "216.58.210.174:8555",
+              "stun:8555",
+              "home.duckdns.org:8555"
+            ]
+          }
         },
         "ice_servers": {
           "type": "array",
@@ -730,13 +655,13 @@
               "description": "Use only these network types",
               "type": "array",
               "items": {
+                "type": "string",
                 "enum": [
                   "tcp4",
                   "tcp6",
                   "udp4",
                   "udp6"
-                ],
-                "type": "string"
+                ]
               }
             },
             "udp_ports": {
@@ -784,7 +709,7 @@
         "properties": {
           "listen": {
             "description": "Listen address for Wyoming server",
-            "$ref": "#/definitions/listen"
+            "type": "string"
           },
           "name": {
             "description": "Optional satellite name (default: stream name)",
diff --git a/www/config.html b/www/config.html
index 58f0c3cf..47640957 100644
--- a/www/config.html
+++ b/www/config.html
@@ -31,20 +31,18 @@
 <script src="https://cdn.jsdelivr.net/npm/js-yaml@4.1.0/dist/js-yaml.min.js"></script>
 <script>
     /* global require, monaco */
-    const monacoVersion = '0.55.1';
-    const monacoRoot = `https://cdn.jsdelivr.net/npm/monaco-editor@${monacoVersion}/min`;
-    const monacoBase = `${monacoRoot}/vs`;
+    const monacoRoot = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min';
 
     window.MonacoEnvironment = {
         getWorkerUrl: function () {
             return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
                 self.MonacoEnvironment = { baseUrl: '${monacoRoot}/' };
-                importScripts('${monacoBase}/base/worker/workerMain.js');
+                importScripts('${monacoRoot}/vs/base/worker/workerMain.js');
             `)}`;
         }
     };
 
-    require.config({ paths: { vs: monacoBase } });
+    require.config({paths: {vs: `${monacoRoot}/vs`}});
 
     require(['vs/editor/editor.main'], () => {
         const container = document.getElementById('config');
@@ -122,25 +120,17 @@
 
         const editor = monaco.editor.create(container, {
             language: 'yaml',
-            minimap: { enabled: false },
+            minimap: {enabled: false},
             automaticLayout: true,
             tabSize: 2,
             insertSpaces: true,
-            quickSuggestions: { other: true, comments: false, strings: true },
+            quickSuggestions: {other: true, comments: false, strings: true},
             suggestOnTriggerCharacters: true,
             wordBasedSuggestions: false,
-            suggest: { showWords: false },
+            suggest: {showWords: false},
             scrollBeyondLastLine: false,
         });
 
-        const layout = () => {
-            const top = container.getBoundingClientRect().top;
-            container.style.height = `${Math.max(200, window.innerHeight - top)}px`;
-            editor.layout();
-        };
-        window.addEventListener('resize', layout);
-        layout();
-
         const stripInlineComment = (line) => {
             let inSingle = false;
             let inDouble = false;
@@ -279,7 +269,18 @@
             const isContainer = after.trim() === '' || after.trim().startsWith('#');
             const valueStartIndex = colonIndex + 1;
 
-            return {indent, key, rawKey, isQuoted, isContainer, after, keyStartIndex, keyEndIndex, colonIndex, valueStartIndex};
+            return {
+                indent,
+                key,
+                rawKey,
+                isQuoted,
+                isContainer,
+                after,
+                keyStartIndex,
+                keyEndIndex,
+                colonIndex,
+                valueStartIndex
+            };
         };
 
         const unique = (arr) => [...new Set(arr)];
@@ -754,8 +755,9 @@
                         blockScalarParentIndent = null;
                     } else {
                         continue; // treat as block scalar content
-                    }      
+                    }
                 }
+
                 if (indent === 0 && (hasTopLevelKey || hasTopLevelList)) {
                     const trimmed = line.trim();
                     if (trimmed !== '---' && trimmed !== '...' && !trimmed.startsWith('#')) {
@@ -1169,6 +1171,14 @@
             });
         };
 
+        const layout = () => {
+            const top = container.getBoundingClientRect().top;
+            container.style.height = `${Math.max(200, window.innerHeight - top)}px`;
+            editor.layout();
+        };
+        window.addEventListener('resize', layout);
+        layout();
+
         let dump;
 
         document.getElementById('save').addEventListener('click', async () => {
@@ -1190,8 +1200,8 @@
 
         (async () => {
             try {
-                const schemaRes = await fetch('schema.json', {cache: 'no-cache'});
-                if (schemaRes.ok) setupYamlHints(await schemaRes.json());
+                const r = await fetch('https://go2rtc.org/schema.json', {cache: 'no-cache'});
+                if (r.ok) setupYamlHints(await r.json());
             } catch (e) {
                 // ignore schema load errors
             }
diff --git a/www/schema.json b/www/schema.json
deleted file mode 100644
index 726879e3..00000000
--- a/www/schema.json
+++ /dev/null
@@ -1,824 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "go2rtc",
-  "type": "object",
-  "additionalProperties": false,
-  "definitions": {
-    "listen": {
-      "type": "string",
-      "anyOf": [
-        {
-          "type": "string",
-          "pattern": ":[0-9]{1,5}$"
-        },
-        {
-          "type": "string",
-          "const": ""
-        }
-      ]
-    },
-    "log_level": {
-      "type": "string",
-      "enum": [
-        "trace",
-        "debug",
-        "info",
-        "warn",
-        "error",
-        "fatal",
-        "panic",
-        "disabled"
-      ]
-    }
-  },
-  "properties": {
-    "api": {
-      "type": "object",
-      "properties": {
-        "listen": {
-          "default": ":1984",
-          "examples": [
-            "127.0.0.1:8080"
-          ],
-          "$ref": "#/definitions/listen"
-        },
-        "username": {
-          "type": "string",
-          "examples": [
-            "admin"
-          ]
-        },
-        "password": {
-          "type": "string"
-        },
-        "local_auth": {
-          "description": "Allow auth from local network without credentials (uses existing Auth header)",
-          "type": "boolean",
-          "default": false
-        },
-        "base_path": {
-          "type": "string",
-          "examples": [
-            "/go2rtc"
-          ]
-        },
-        "static_dir": {
-          "type": "string",
-          "examples": [
-            "/var/www"
-          ]
-        },
-        "origin": {
-          "description": "Set to \"*\" to enable CORS and allow any Origin",
-          "type": "string",
-          "anyOf": [
-            {
-              "type": "string",
-              "const": "*"
-            },
-            {
-              "type": "string",
-              "const": ""
-            }
-          ]
-        },
-        "tls_listen": {
-          "$ref": "#/definitions/listen"
-        },
-        "tls_cert": {
-          "type": "string",
-          "examples": [
-            "-----BEGIN CERTIFICATE-----",
-            "/ssl/fullchain.pem"
-          ]
-        },
-        "tls_key": {
-          "type": "string",
-          "examples": [
-            "-----BEGIN PRIVATE KEY-----",
-            "/ssl/privkey.pem"
-          ]
-        },
-        "unix_listen": {
-          "type": "string",
-          "examples": [
-            "/tmp/go2rtc.sock"
-          ]
-        },
-        "allow_paths": {
-          "description": "Allow only these HTTP paths (full paths, including base_path); when set, all other endpoints are not registered",
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "examples": [
-            [
-              "/api/ws",
-              "/api/config",
-              "/api/streams"
-            ]
-          ]
-        }
-      }
-    },
-    "app": {
-      "type": "object",
-      "properties": {
-        "modules": {
-          "description": "Enable only these modules (empty / omitted means all)",
-          "type": "array",
-          "items": {
-            "type": "string",
-            "enum": [
-              "api",
-              "ws",
-              "http",
-              "rtsp",
-              "webrtc",
-              "mp4",
-              "hls",
-              "mjpeg",
-              "hass",
-              "homekit",
-              "onvif",
-              "rtmp",
-              "webtorrent",
-              "wyoming",
-              "echo",
-              "exec",
-              "expr",
-              "ffmpeg",
-              "alsa",
-              "v4l2",
-              "bubble",
-              "doorbird",
-              "dvrip",
-              "eseecloud",
-              "flussonic",
-              "gopro",
-              "isapi",
-              "ivideon",
-              "mpegts",
-              "nest",
-              "ring",
-              "roborock",
-              "tapo",
-              "tuya",
-              "yandex",
-              "debug",
-              "ngrok",
-              "pinggy",
-              "srtp"
-            ]
-          }
-        }
-      }
-    },
-    "env": {
-      "description": "Config variables that can be referenced as ${NAME} / ${NAME:default}",
-      "type": "object",
-      "additionalProperties": {
-        "type": "string"
-      }
-    },
-    "echo": {
-      "type": "object",
-      "properties": {
-        "allow_paths": {
-          "description": "Allow only these binaries for echo: URLs (exact cmd name/path)",
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "examples": [
-            [
-              "ffmpeg",
-              "/usr/bin/ffmpeg"
-            ]
-          ]
-        }
-      }
-    },
-    "exec": {
-      "type": "object",
-      "properties": {
-        "allow_paths": {
-          "description": "Allow only these binaries for exec: URLs (exact cmd name/path)",
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "examples": [
-            [
-              "ffmpeg",
-              "/usr/bin/ffmpeg"
-            ]
-          ]
-        }
-      }
-    },
-    "ffmpeg": {
-      "type": "object",
-      "properties": {
-        "bin": {
-          "type": "string",
-          "default": "ffmpeg"
-        }
-      },
-      "additionalProperties": {
-        "description": "FFmpeg template",
-        "type": "string"
-      }
-    },
-    "hass": {
-      "type": "object",
-      "properties": {
-        "config": {
-          "description": "Home Assistant config directory path",
-          "type": "string",
-          "examples": [
-            "/config"
-          ]
-        }
-      }
-    },
-    "homekit": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "object",
-      "properties": {
-        "pin": {
-          "description": "HomeKit pairing PIN (will be normalized to XXX-XX-XXX); insecure PINs are rejected",
-          "type": "string",
-          "default": "19550224",
-          "anyOf": [
-            {
-              "type": "string",
-              "pattern": "^[0-9]{8}$"
-            },
-            {
-              "type": "string",
-              "pattern": "^[0-9]{3}-[0-9]{2}-[0-9]{3}$"
-            }
-          ]
-        },
-        "name": {
-          "type": "string"
-        },
-          "device_id": {
-            "type": "string"
-          },
-        "device_private": {
-          "type": "string"
-        },
-        "category_id": {
-          "description": "Accessory category: \"bridge\", \"doorbell\" or numeric ID (default: camera)",
-          "type": "string",
-          "anyOf": [
-            {
-              "type": "string",
-              "enum": [
-                "bridge",
-                "doorbell"
-              ]
-            },
-            {
-              "type": "string",
-              "pattern": "^[0-9]+$"
-            },
-            {
-              "type": "string",
-              "const": ""
-            }
-          ]
-        },
-        "pairings": {
-          "type": "array",
-          "items": {
-            "type": "string"
-            }
-          }
-        }
-      }
-    },
-    "log": {
-      "type": "object",
-      "properties": {
-        "format": {
-          "description": "Log format: color/json/text or empty for autodetect",
-          "type": "string",
-          "default": "color",
-          "enum": [
-            "",
-            "color",
-            "json",
-            "text"
-          ]
-        },
-        "level": {
-          "description": "Defaul log level",
-          "default": "info",
-          "$ref": "#/definitions/log_level"
-        },
-        "output": {
-          "description": "Log output: stdout/stderr/file[:path] or empty (memory only)",
-          "type": "string",
-          "default": "stdout",
-          "anyOf": [
-            {
-              "type": "string",
-              "enum": [
-                "",
-                "stdout",
-                "stderr"
-              ]
-            },
-            {
-              "type": "string",
-              "pattern": "^file(:.+)?$",
-              "examples": [
-                "file",
-                "file:go2rtc.log"
-              ]
-            }
-          ]
-        },
-        "time": {
-          "type": "string",
-          "default": "UNIXMS",
-          "anyOf": [
-            {
-              "type": "string",
-              "enum": [
-                "",
-                "UNIXMS",
-                "UNIXMICRO",
-                "UNIXNANO",
-                "2006-01-02T15:04:05Z07:00",
-                "2006-01-02T15:04:05.999999999Z07:00"
-              ]
-            },
-            {
-              "type": "string"
-            }
-          ]
-        },
-        "api": {
-          "$ref": "#/definitions/log_level"
-        },
-        "alsa": {
-          "$ref": "#/definitions/log_level"
-        },
-        "bubble": {
-          "$ref": "#/definitions/log_level"
-        },
-        "debug": {
-          "$ref": "#/definitions/log_level"
-        },
-        "doorbird": {
-          "$ref": "#/definitions/log_level"
-        },
-        "dvrip": {
-          "$ref": "#/definitions/log_level"
-        },
-        "eseecloud": {
-          "$ref": "#/definitions/log_level"
-        },
-        "echo": {
-          "$ref": "#/definitions/log_level"
-        },
-        "exec": {
-          "description": "Value `exec: debug` will print stderr",
-          "$ref": "#/definitions/log_level"
-        },
-        "expr": {
-          "$ref": "#/definitions/log_level"
-        },
-        "ffmpeg": {
-          "description": "Will only be displayed with `exec: debug` setting",
-          "default": "error",
-          "$ref": "#/definitions/log_level"
-        },
-        "flussonic": {
-          "$ref": "#/definitions/log_level"
-        },
-        "gopro": {
-          "$ref": "#/definitions/log_level"
-        },
-        "hass": {
-          "$ref": "#/definitions/log_level"
-        },
-        "hls": {
-          "$ref": "#/definitions/log_level"
-        },
-        "homekit": {
-          "$ref": "#/definitions/log_level"
-        },
-        "http": {
-          "$ref": "#/definitions/log_level"
-        },
-        "isapi": {
-          "$ref": "#/definitions/log_level"
-        },
-        "ivideon": {
-          "$ref": "#/definitions/log_level"
-        },
-        "mjpeg": {
-          "$ref": "#/definitions/log_level"
-        },
-        "mpegts": {
-          "$ref": "#/definitions/log_level"
-        },
-        "mp4": {
-          "$ref": "#/definitions/log_level"
-        },
-        "nest": {
-          "$ref": "#/definitions/log_level"
-        },
-        "ngrok": {
-          "$ref": "#/definitions/log_level"
-        },
-        "onvif": {
-          "$ref": "#/definitions/log_level"
-        },
-        "pinggy": {
-          "$ref": "#/definitions/log_level"
-        },
-        "ring": {
-          "$ref": "#/definitions/log_level"
-        },
-        "roborock": {
-          "$ref": "#/definitions/log_level"
-        },
-        "rtmp": {
-          "$ref": "#/definitions/log_level"
-        },
-        "rtsp": {
-          "$ref": "#/definitions/log_level"
-        },
-        "srtp": {
-          "$ref": "#/definitions/log_level"
-        },
-        "streams": {
-          "$ref": "#/definitions/log_level"
-        },
-        "tapo": {
-          "$ref": "#/definitions/log_level"
-        },
-        "tuya": {
-          "$ref": "#/definitions/log_level"
-        },
-        "v4l2": {
-          "$ref": "#/definitions/log_level"
-        },
-        "webrtc": {
-          "$ref": "#/definitions/log_level"
-        },
-        "webtorrent": {
-          "$ref": "#/definitions/log_level"
-        },
-        "wyoming": {
-          "$ref": "#/definitions/log_level"
-        },
-        "yandex": {
-          "$ref": "#/definitions/log_level"
-        }
-      },
-      "additionalProperties": {
-        "$ref": "#/definitions/log_level"
-      }
-    },
-    "ngrok": {
-      "type": "object",
-      "properties": {
-        "command": {
-          "type": "string",
-          "examples": [
-            "ngrok tcp 8555 --authtoken xxx",
-            "ngrok start --all --config ngrok.yaml"
-          ]
-        }
-      }
-    },
-    "pinggy": {
-      "type": "object",
-      "properties": {
-        "tunnel": {
-          "description": "Expose local address via Pinggy (scheme: http/tcp/tls/tlstcp, host:port is your local address)",
-          "type": "string",
-          "examples": [
-            "http://127.0.0.1:1984",
-            "tcp://127.0.0.1:8554"
-          ]
-        }
-      }
-    },
-    "preload": {
-      "description": "Preload streams on startup (map stream name => probe query, default \"video&audio\")",
-      "type": "object",
-      "additionalProperties": {
-        "type": "string",
-        "examples": [
-          "video&audio",
-          "video"
-        ]
-      }
-    },
-    "publish": {
-      "type": "object",
-      "additionalProperties": {
-        "anyOf": [
-          {
-            "type": "string",
-            "examples": [
-              "rtmp://xxx.rtmp.youtube.com/live2/xxxx-xxxx-xxxx-xxxx-xxxx",
-              "rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx"
-            ]
-          },
-          {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          }
-        ]
-      }
-    },
-    "rtmp": {
-      "type": "object",
-      "properties": {
-        "listen": {
-          "examples": [
-            ":1935"
-          ],
-          "$ref": "#/definitions/listen"
-        }
-      }
-    },
-    "rtsp": {
-      "type": "object",
-      "properties": {
-        "listen": {
-          "default": ":8554",
-          "$ref": "#/definitions/listen"
-        },
-        "username": {
-          "type": "string",
-          "examples": [
-            "admin"
-          ]
-        },
-        "password": {
-          "type": "string"
-        },
-        "default_query": {
-          "type": "string",
-          "default": "video&audio"
-        },
-        "pkt_size": {
-          "type": "integer"
-        }
-      }
-    },
-    "srtp": {
-      "description": "SRTP server for HomeKit",
-      "type": "object",
-      "properties": {
-        "listen": {
-          "default": ":8443",
-          "$ref": "#/definitions/listen"
-        }
-      }
-    },
-    "streams": {
-      "type": "object",
-      "additionalProperties": {
-        "title": "Stream",
-        "anyOf": [
-          {
-            "description": "Source",
-            "type": "string",
-            "examples": [
-              "rtsp://username:password@192.168.1.123/cam/realmonitor?channel=1&subtype=0&unicast=true&proto=Onvif",
-              "rtsp://username:password@192.168.1.123/stream1",
-              "rtsp://username:password@192.168.1.123/h264Preview_01_main",
-              "rtmp://192.168.1.123/bcs/channel0_main.bcs?channel=0&stream=0&user=username&password=password",
-              "http://192.168.1.123/flv?port=1935&app=bcs&stream=channel0_main.bcs&user=username&password=password",
-              "http://username:password@192.168.1.123/cgi-bin/snapshot.cgi?channel=1",
-              "ffmpeg:media.mp4#video=h264#hardware#width=1920#height=1080#rotate=180#audio=copy",
-              "ffmpeg:virtual?video=testsrc&size=4K#video=h264#hardware#bitrate=50M",
-              "bubble://username:password@192.168.1.123:34567/bubble/live?ch=0&stream=0",
-              "dvrip://username:password@192.168.1.123:34567?channel=0&subtype=0",
-              "exec:ffmpeg -re -i media.mp4 -c copy -rtsp_transport tcp -f rtsp {output}",
-              "isapi://username:password@192.168.1.123:80/",
-              "kasa://username:password@192.168.1.123:19443/https/stream/mixed",
-              "onvif://username:password@192.168.1.123:80?subtype=0",
-              "tapo://password@192.168.1.123:8800?channel=0&subtype=0",
-              "webtorrent:?share=xxx&pwd=xxx"
-            ]
-          },
-          {
-            "type": "array",
-            "items": {
-              "description": "Source",
-              "type": "string"
-            }
-          },
-          {
-            "type": "object",
-            "properties": {
-              "url": {
-                "description": "Source URL or list of URLs",
-                "anyOf": [
-                  {
-                    "type": "string",
-                    "examples": [
-                      "rtsp://username:password@192.168.1.123/stream1",
-                      "ffmpeg:media.mp4#video=h264#audio=copy"
-                    ]
-                  },
-                  {
-                    "type": "array",
-                    "items": {
-                      "type": "string"
-                    }
-                  }
-                ]
-              }
-            }
-          }
-        ]
-      }
-    },
-    "webrtc": {
-      "type": "object",
-      "properties": {
-        "listen": {
-          "default": ":8555/tcp",
-          "type": "string",
-          "anyOf": [
-            {
-              "type": "string",
-              "pattern": ":[0-9]{1,5}(/tcp|/udp)?$"
-            },
-            {
-              "type": "string",
-              "const": ""
-            }
-          ]
-        },
-        "candidates": {
-          "type": "array",
-          "items": {
-            "$ref": "#/definitions/listen/anyOf/0"
-          },
-          "examples": [
-            "216.58.210.174:8555",
-            "stun:8555",
-            "home.duckdns.org:8555"
-          ]
-        },
-        "ice_servers": {
-          "type": "array",
-          "items": {
-            "type": "object",
-            "properties": {
-              "urls": {
-                "type": "array",
-                "items": {
-                  "type": "string",
-                  "examples": [
-                    "stun:stun.l.google.com:19302",
-                    "turn:123.123.123.123:3478"
-                  ]
-                }
-              },
-              "username": {
-                "type": "string"
-              },
-              "credential": {
-                "type": "string"
-              }
-            }
-          }
-        },
-        "filters": {
-          "type": "object",
-          "properties": {
-            "candidates": {
-              "description": "Keep only these candidates",
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "interfaces": {
-              "description": "Keep only these interfaces",
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "ips": {
-              "description": "Keep only these IP-addresses",
-              "type": "array",
-              "items": {
-                "type": "string"
-              }
-            },
-            "networks": {
-              "description": "Use only these network types",
-              "type": "array",
-              "items": {
-                "enum": [
-                  "tcp4",
-                  "tcp6",
-                  "udp4",
-                  "udp6"
-                ],
-                "type": "string"
-              }
-            },
-            "udp_ports": {
-              "description": "Use only these UDP ports range [min, max]",
-              "type": "array",
-              "items": {
-                "type": "integer"
-              },
-              "maxItems": 2,
-              "minItems": 2
-            }
-          }
-        }
-      }
-    },
-    "webtorrent": {
-      "type": "object",
-      "properties": {
-        "trackers": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "shares": {
-          "additionalProperties": {
-            "type": "object",
-            "properties": {
-              "pwd": {
-                "type": "string",
-                "minLength": 4
-              },
-              "src": {
-                "type": "string"
-              }
-            }
-          }
-        }
-      }
-    },
-    "wyoming": {
-      "type": "object",
-      "additionalProperties": {
-        "type": "object",
-        "properties": {
-          "listen": {
-            "description": "Listen address for Wyoming server",
-            "$ref": "#/definitions/listen"
-          },
-          "name": {
-            "description": "Optional satellite name (default: stream name)",
-            "type": "string"
-          },
-          "mode": {
-            "description": "Optional mode: mic / snd / default",
-            "type": "string",
-            "enum": [
-              "",
-              "mic",
-              "snd"
-            ]
-          },
-          "event": {
-            "description": "Event handlers (map event type => expr script)",
-            "type": "object",
-            "additionalProperties": {
-              "type": "string"
-            }
-          },
-          "wake_uri": {
-            "description": "Optional WAKE service URI (ex. tcp://host:port?name=...)",
-            "type": "string",
-            "examples": [
-              "tcp://192.168.1.23:10400"
-            ]
-          },
-          "vad_threshold": {
-            "description": "Optional VAD threshold (0.1..3.5 typical)",
-            "type": "number"
-          }
-        }
-      }
-    }
-  }
-}
diff --git a/www/static.go b/www/static.go
index 064fec36..01f50906 100644
--- a/www/static.go
+++ b/www/static.go
@@ -4,5 +4,4 @@ import "embed"
 
 //go:embed *.html
 //go:embed *.js
-//go:embed *.json
 var Static embed.FS

From 1cd55170263d3e9443b1d19dfae4d05364587e4f Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Sat, 27 Dec 2025 12:17:40 +0300
Subject: [PATCH 22/26] Log all modules with custom loggers

---
 internal/app/log.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/internal/app/log.go b/internal/app/log.go
index 9ec89a2c..61fd474c 100644
--- a/internal/app/log.go
+++ b/internal/app/log.go
@@ -14,6 +14,8 @@ import (
 var MemoryLog = newBuffer()
 
 func GetLogger(module string) zerolog.Logger {
+	Logger.Trace().Str("module", module).Msgf("[log] init")
+
 	if s, ok := modules[module]; ok {
 		lvl, err := zerolog.ParseLevel(s)
 		if err == nil {

From 654e78b7c50c5f30e5b82304ac811e80e78c7346 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Sat, 27 Dec 2025 12:34:08 +0300
Subject: [PATCH 23/26] Add suggest button to config editor

---
 www/config.html | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/www/config.html b/www/config.html
index 47640957..fe84275c 100644
--- a/www/config.html
+++ b/www/config.html
@@ -23,6 +23,7 @@
 <main>
     <div>
         <button id="save">Save & Restart</button>
+        <button id="suggest" title="ctrl + space">Suggest</button>
     </div>
 </main>
 <div id="config"></div>
@@ -1198,6 +1199,10 @@
             }
         });
 
+        document.getElementById('suggest').addEventListener('click', () => {
+            editor.trigger('source', 'editor.action.triggerSuggest', {});
+        });
+
         (async () => {
             try {
                 const r = await fetch('https://go2rtc.org/schema.json', {cache: 'no-cache'});

From d183b99a44cbfce68d56cc57ac501009fb80c5ec Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Sat, 27 Dec 2025 15:39:57 +0300
Subject: [PATCH 24/26] Update GitHub Pages site link

---
 README.md                     |   4 +-
 api/README.md                 |   2 +-
 website/index.html            | 193 +++-------------------------------
 website/webtorrent/index.html | 189 +++++++++++++++++++++++++++++++++
 www/README.md                 |   6 +-
 www/links.html                |   2 +-
 6 files changed, 212 insertions(+), 184 deletions(-)
 create mode 100644 website/webtorrent/index.html

diff --git a/README.md b/README.md
index 11325954..5c402925 100644
--- a/README.md
+++ b/README.md
@@ -38,7 +38,7 @@ Ultimate camera streaming application with support for RTSP, WebRTC, HomeKit, FF
 - creator of the project's logo [@v_novoseltsev](https://www.instagram.com/v_novoseltsev) 
 
 > [!CAUTION]
-> There is NO existing website for go2rtc project other than this GitHub repository. The website go2rtc[.]com is in no way associated with the authors of this project.
+> The official website of the project is this GitHub repository and go2rtc.org (hosted on GitHub Pages). The website go2rtc[.]com is in no way associated with the authors of this project.
 
 ---
 
@@ -1120,7 +1120,7 @@ webtorrent:
       src: rtsp-dahua1   # stream name from streams section
 ```
 
-Link example: https://alexxit.github.io/go2rtc/#share=02SNtgjKXY&pwd=wznEQqznxW&media=video+audio
+Link example: https://go2rtc.org/webtorrent/#share=02SNtgjKXY&pwd=wznEQqznxW&media=video+audio
 
 ### Module: ngrok
 
diff --git a/api/README.md b/api/README.md
index 76dc875b..03b99bc4 100644
--- a/api/README.md
+++ b/api/README.md
@@ -4,7 +4,7 @@ Fill free to make any API design proposals.
 
 ## HTTP API
 
-Interactive [OpenAPI](https://alexxit.github.io/go2rtc/api/).
+Interactive [OpenAPI](https://go2rtc.org/api/).
 
 `www/stream.html` - universal viewer with support params in URL:
 
diff --git a/website/index.html b/website/index.html
index 443c925c..e339eb44 100644
--- a/website/index.html
+++ b/website/index.html
@@ -1,189 +1,28 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <title>go2rtc - WebTorrent</title>
+    <meta charset="UTF-8">
+    <title>go2rtc</title>
+    <meta http-equiv="refresh" content="2; URL='https://github.com/AlexxIT/go2rtc'"/>
     <style>
-        body {
-            background-color: black;
-            margin: 0;
-            padding: 0;
-        }
-
-        html, body, video {
+        body, html {
             height: 100%;
-            width: 100%;
-        }
-
-        div {
-            position: absolute;
-            top: 50%;
-            left: 50%;
+            margin: 0;
             display: flex;
             flex-direction: column;
-            transform: translateX(-50%) translateY(-50%);
+            justify-content: center;
+            align-items: center;
+            background-color: white;
+        }
+
+        img {
+            max-width: 100%;
+            height: auto;
         }
     </style>
 </head>
 <body>
-<video id="video" autoplay controls playsinline muted></video>
-<div id="login">
-    <input id="share" type="text" placeholder="share">
-    <input id="pwd" type="text" placeholder="password">
-    <button id="connect">connect</button>
-</div>
-<script>
-    async function PeerConnection(media) {
-        const pc = new RTCPeerConnection({
-            iceServers: [{urls: 'stun:stun.l.google.com:19302'}]
-        })
-
-        const localTracks = []
-
-        if (/camera|microphone/.test(media)) {
-            const tracks = await getMediaTracks('user', {
-                video: media.indexOf('camera') >= 0,
-                audio: media.indexOf('microphone') >= 0,
-            })
-            tracks.forEach(track => {
-                pc.addTransceiver(track, {direction: 'sendonly'})
-                if (track.kind === 'video') localTracks.push(track)
-            })
-        }
-
-        if (media.indexOf('display') >= 0) {
-            const tracks = await getMediaTracks('display', {
-                video: true,
-                audio: media.indexOf('speaker') >= 0,
-            })
-            tracks.forEach(track => {
-                pc.addTransceiver(track, {direction: 'sendonly'})
-                if (track.kind === 'video') localTracks.push(track)
-            })
-        }
-
-        if (/video|audio/.test(media)) {
-            const tracks = ['video', 'audio']
-                .filter(kind => media.indexOf(kind) >= 0)
-                .map(kind => pc.addTransceiver(kind, {direction: 'recvonly'}).receiver.track)
-            localTracks.push(...tracks)
-        }
-
-        document.getElementById('video').srcObject = new MediaStream(localTracks)
-
-        return pc
-    }
-
-    async function getMediaTracks(media, constraints) {
-        try {
-            const stream = media === 'user'
-                ? await navigator.mediaDevices.getUserMedia(constraints)
-                : await navigator.mediaDevices.getDisplayMedia(constraints)
-            return stream.getTracks()
-        } catch (e) {
-            console.warn(e)
-            return []
-        }
-    }
-
-    function getOffer(pc, timeout) {
-        return new Promise((resolve, reject) => {
-            pc.addEventListener('icegatheringstatechange', () => {
-                if (pc.iceGatheringState === 'complete') resolve(pc.localDescription.sdp)
-            })
-
-            pc.createOffer().then(offer => pc.setLocalDescription(offer))
-
-            setTimeout(() => resolve(pc.localDescription.sdp), timeout || 5000)
-        })
-    }
-</script>
-<script>
-    function decode(buffer) {
-        return String.fromCharCode(...new Uint8Array(buffer))
-    }
-
-    function encode(string) {
-        return Uint8Array.from(string, c => c.charCodeAt(0))
-    }
-
-    async function cipher(share, pwd) {
-        const hash = await crypto.subtle.digest('SHA-256', encode(share))
-        const nonce = (Date.now() * 1000000).toString(36)
-
-        const ivData = await crypto.subtle.digest('SHA-256', encode(share + ':' + nonce))
-        const keyData = await crypto.subtle.digest('SHA-256', encode(nonce + ':' + pwd))
-        const key = await crypto.subtle.importKey(
-            'raw', keyData, {name: 'AES-GCM'}, false, ['encrypt', 'decrypt'],
-        )
-
-        return {
-            hash: btoa(decode(hash)),
-            nonce: nonce,
-            encrypt: async function (plaintext) {
-                const cryptotext = await crypto.subtle.encrypt(
-                    {name: 'AES-GCM', iv: ivData.slice(0, 12), additionalData: encode(nonce)},
-                    key, encode(plaintext),
-                )
-                return btoa(decode(cryptotext))
-            },
-            decrypt: async function (cryptotext) {
-                const plaintext = await crypto.subtle.decrypt(
-                    {name: 'AES-GCM', iv: ivData.slice(0, 12), additionalData: encode(nonce)},
-                    key, encode(atob(cryptotext)),
-                )
-                return decode(plaintext)
-            }
-        }
-    }
-</script>
-<script>
-    async function connect(share, pwd, media, tracker) {
-        const crypto = await cipher(share, pwd)
-        const pc = await PeerConnection(media || 'video+audio')
-        const offer = await crypto.encrypt(await getOffer(pc))
-
-        const ws = new WebSocket(tracker || 'wss://tracker.openwebtorrent.com/')
-        ws.addEventListener('open', () => {
-            ws.send(JSON.stringify({
-                action: 'announce',
-                info_hash: crypto.hash,
-                peer_id: Math.random().toString(36).substring(2),
-                offers: [{
-                    offer_id: crypto.nonce,
-                    offer: {type: 'offer', sdp: offer},
-                }],
-                numwant: 1,
-            }))
-        })
-
-        ws.addEventListener('message', async (ev) => {
-            const msg = JSON.parse(ev.data)
-            if (!msg.answer) return
-
-            const answer = await crypto.decrypt(msg.answer.sdp)
-            await pc.setRemoteDescription({type: 'answer', sdp: answer})
-
-            ws.close()
-        })
-    }
-
-    document.getElementById('connect').addEventListener('click', () => {
-        const share = document.getElementById('share').value
-        const pwd = document.getElementById('pwd').value
-        connect(share, pwd)
-        document.getElementById('login').style.display = 'none'
-    })
-
-    if (location.hash) {
-        const params = new URLSearchParams(location.hash.substring(1))
-        const share = params.get('share')
-        const pwd = params.get('pwd')
-        const media = params.get('media')
-        const tracker = params.get('tr')
-        connect(share, pwd, media, tracker)
-        document.getElementById('login').style.display = 'none'
-    }
-</script>
+<img src="https://raw.githubusercontent.com/AlexxIT/go2rtc/master/assets/logo.gif" alt="go2rtc">
+<a href="https://github.com/AlexxIT/go2rtc">github.com/AlexxIT/go2rtc</a>
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/website/webtorrent/index.html b/website/webtorrent/index.html
new file mode 100644
index 00000000..6a4b9057
--- /dev/null
+++ b/website/webtorrent/index.html
@@ -0,0 +1,189 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <title>webtorrent - go2rtc</title>
+    <style>
+        body {
+            background-color: black;
+            margin: 0;
+            padding: 0;
+        }
+
+        html, body, video {
+            height: 100%;
+            width: 100%;
+        }
+
+        div {
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            display: flex;
+            flex-direction: column;
+            transform: translateX(-50%) translateY(-50%);
+        }
+    </style>
+</head>
+<body>
+<video id="video" autoplay controls playsinline muted></video>
+<div id="login">
+    <input id="share" type="text" placeholder="share">
+    <input id="pwd" type="text" placeholder="password">
+    <button id="connect">connect</button>
+</div>
+<script>
+    async function PeerConnection(media) {
+        const pc = new RTCPeerConnection({
+            iceServers: [{urls: 'stun:stun.l.google.com:19302'}]
+        });
+
+        const localTracks = [];
+
+        if (/camera|microphone/.test(media)) {
+            const tracks = await getMediaTracks('user', {
+                video: media.indexOf('camera') >= 0,
+                audio: media.indexOf('microphone') >= 0,
+            });
+            tracks.forEach(track => {
+                pc.addTransceiver(track, {direction: 'sendonly'});
+                if (track.kind === 'video') localTracks.push(track);
+            });
+        }
+
+        if (media.indexOf('display') >= 0) {
+            const tracks = await getMediaTracks('display', {
+                video: true,
+                audio: media.indexOf('speaker') >= 0,
+            });
+            tracks.forEach(track => {
+                pc.addTransceiver(track, {direction: 'sendonly'});
+                if (track.kind === 'video') localTracks.push(track);
+            });
+        }
+
+        if (/video|audio/.test(media)) {
+            const tracks = ['video', 'audio']
+                .filter(kind => media.indexOf(kind) >= 0)
+                .map(kind => pc.addTransceiver(kind, {direction: 'recvonly'}).receiver.track);
+            localTracks.push(...tracks);
+        }
+
+        document.getElementById('video').srcObject = new MediaStream(localTracks);
+
+        return pc;
+    }
+
+    async function getMediaTracks(media, constraints) {
+        try {
+            const stream = media === 'user'
+                ? await navigator.mediaDevices.getUserMedia(constraints)
+                : await navigator.mediaDevices.getDisplayMedia(constraints);
+            return stream.getTracks();
+        } catch (e) {
+            console.warn(e);
+            return [];
+        }
+    }
+
+    function getOffer(pc, timeout) {
+        return new Promise((resolve, reject) => {
+            pc.addEventListener('icegatheringstatechange', () => {
+                if (pc.iceGatheringState === 'complete') resolve(pc.localDescription.sdp);
+            });
+
+            pc.createOffer().then(offer => pc.setLocalDescription(offer));
+
+            setTimeout(() => resolve(pc.localDescription.sdp), timeout || 5000);
+        });
+    }
+</script>
+<script>
+    function decode(buffer) {
+        return String.fromCharCode(...new Uint8Array(buffer));
+    }
+
+    function encode(string) {
+        return Uint8Array.from(string, c => c.charCodeAt(0));
+    }
+
+    async function cipher(share, pwd) {
+        const hash = await crypto.subtle.digest('SHA-256', encode(share));
+        const nonce = (Date.now() * 1000000).toString(36);
+
+        const ivData = await crypto.subtle.digest('SHA-256', encode(share + ':' + nonce));
+        const keyData = await crypto.subtle.digest('SHA-256', encode(nonce + ':' + pwd));
+        const key = await crypto.subtle.importKey(
+            'raw', keyData, {name: 'AES-GCM'}, false, ['encrypt', 'decrypt'],
+        );
+
+        return {
+            hash: btoa(decode(hash)),
+            nonce: nonce,
+            encrypt: async function (plaintext) {
+                const cryptotext = await crypto.subtle.encrypt(
+                    {name: 'AES-GCM', iv: ivData.slice(0, 12), additionalData: encode(nonce)},
+                    key, encode(plaintext),
+                );
+                return btoa(decode(cryptotext));
+            },
+            decrypt: async function (cryptotext) {
+                const plaintext = await crypto.subtle.decrypt(
+                    {name: 'AES-GCM', iv: ivData.slice(0, 12), additionalData: encode(nonce)},
+                    key, encode(atob(cryptotext)),
+                );
+                return decode(plaintext);
+            }
+        };
+    }
+</script>
+<script>
+    async function connect(share, pwd, media, tracker) {
+        const crypto = await cipher(share, pwd);
+        const pc = await PeerConnection(media || 'video+audio');
+        const offer = await crypto.encrypt(await getOffer(pc));
+
+        const ws = new WebSocket(tracker || 'wss://tracker.openwebtorrent.com/');
+        ws.addEventListener('open', () => {
+            ws.send(JSON.stringify({
+                action: 'announce',
+                info_hash: crypto.hash,
+                peer_id: Math.random().toString(36).substring(2),
+                offers: [{
+                    offer_id: crypto.nonce,
+                    offer: {type: 'offer', sdp: offer},
+                }],
+                numwant: 1,
+            }));
+        });
+
+        ws.addEventListener('message', async (ev) => {
+            const msg = JSON.parse(ev.data);
+            if (!msg.answer) return;
+
+            const answer = await crypto.decrypt(msg.answer.sdp);
+            await pc.setRemoteDescription({type: 'answer', sdp: answer});
+
+            ws.close();
+        });
+    }
+
+    document.getElementById('connect').addEventListener('click', () => {
+        const share = document.getElementById('share').value;
+        const pwd = document.getElementById('pwd').value;
+        connect(share, pwd);
+        document.getElementById('login').style.display = 'none';
+    });
+
+    if (location.hash) {
+        const params = new URLSearchParams(location.hash.substring(1));
+        const share = params.get('share');
+        const pwd = params.get('pwd');
+        const media = params.get('media');
+        const tracker = params.get('tr');
+        connect(share, pwd, media, tracker);
+        document.getElementById('login').style.display = 'none';
+    }
+</script>
+</body>
+</html>
\ No newline at end of file
diff --git a/www/README.md b/www/README.md
index 4da49485..e4d36cd2 100644
--- a/www/README.md
+++ b/www/README.md
@@ -81,11 +81,11 @@ https://webrtc.org/getting-started/unified-plan-transition-guide?hl=en
 
 ```html
     <!-- iOS Safari -->
-    <link rel="apple-touch-icon" href="https://alexxit.github.io/go2rtc/icons/apple-touch-icon-180x180.png" sizes="180x180">
+    <link rel="apple-touch-icon" href="https://go2rtc.org/icons/apple-touch-icon-180x180.png" sizes="180x180">
     <!-- Classic, desktop browsers -->
-    <link rel="icon" href="https://alexxit.github.io/go2rtc/icons/favicon.ico">
+    <link rel="icon" href="https://go2rtc.org/icons/favicon.ico">
     <!-- Android Chrome -->
-    <link rel="manifest" href="https://alexxit.github.io/go2rtc/manifest.json">
+    <link rel="manifest" href="https://go2rtc.org/manifest.json">
 ```
 
 ## Useful links
diff --git a/www/links.html b/www/links.html
index f2b35c22..466d30a5 100644
--- a/www/links.html
+++ b/www/links.html
@@ -186,7 +186,7 @@ Telegram: rtmps://xxx-x.rtmp.t.me/s/xxxxxxxxxx:xxxxxxxxxxxxxxxxxxxxxx</pre>
             document.getElementById('local').href = `webrtc.html?${direction}=${src}&media=${media}`;
 
             const share = document.getElementById('shareget');
-            share.href = `https://alexxit.github.io/go2rtc/#${share.dataset.auth}&media=${media}`;
+            share.href = `https://go2rtc.org/webtorrent/#${share.dataset.auth}&media=${media}`;
         }
 
         function share(method) {

From a09e1b2f902c342fba7521e29c626147698f3d37 Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Sat, 27 Dec 2025 17:43:19 +0300
Subject: [PATCH 25/26] Update openapi

---
 api/openapi.yaml | 770 ++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 687 insertions(+), 83 deletions(-)

diff --git a/api/openapi.yaml b/api/openapi.yaml
index 6ec0b492..b6110572 100644
--- a/api/openapi.yaml
+++ b/api/openapi.yaml
@@ -2,8 +2,8 @@ openapi: 3.1.0
 
 info:
   title: go2rtc
+  version: 1.9.13
   license: { name: MIT,url: https://opensource.org/licenses/MIT }
-  version: 1.0.0
   contact: { url: https://github.com/AlexxIT/go2rtc }
   description: |
     Ultimate camera streaming application with support RTSP, RTMP, HTTP-FLV, WebRTC, MSE, HLS, MP4, MJPEG, HomeKit, FFmpeg, etc.
@@ -11,6 +11,28 @@ info:
 servers:
   - url: http://localhost:1984
 
+tags:
+  - name: Application
+    description: "[Module: API](https://github.com/AlexxIT/go2rtc#module-api)"
+  - name: Config
+    description: "[Configuration](https://github.com/AlexxIT/go2rtc#configuration)"
+  - name: Streams list
+    description: "[Module: Streams](https://github.com/AlexxIT/go2rtc#module-streams)"
+  - name: Consume stream
+  - name: HLS
+  - name: Snapshot
+  - name: Produce stream
+  - name: WebSocket
+    description: "WebSocket API endpoint: `/api/ws` (see `api/README.md`)"
+  - name: Discovery
+  - name: HomeKit
+  - name: ONVIF
+  - name: RTSPtoWebRTC
+  - name: WebTorrent
+    description: "[Module: WebTorrent](https://github.com/AlexxIT/go2rtc#module-webtorrent)"
+  - name: FFmpeg
+  - name: Debug
+
 components:
   parameters:
     stream_src_path:
@@ -20,6 +42,7 @@ components:
       required: true
       schema: { type: string }
       example: camera1
+
     stream_dst_path:
       name: dst
       in: path
@@ -27,6 +50,7 @@ components:
       required: true
       schema: { type: string }
       example: camera1
+
     stream_src_query:
       name: src
       in: query
@@ -34,6 +58,15 @@ components:
       required: true
       schema: { type: string }
       example: camera1
+
+    hls_session_id_path:
+      name: id
+      in: path
+      description: HLS session ID (passed as query param `id`)
+      required: true
+      schema: { type: string }
+      example: DvmHdd9w
+
     mp4_filter:
       name: mp4
       in: query
@@ -43,6 +76,7 @@ components:
         type: string
         enum: [ "", flac, all ]
       example: flac
+
     video_filter:
       name: video
       in: query
@@ -51,6 +85,7 @@ components:
         type: string
         enum: [ "", all, h264, h265, mjpeg ]
       example: h264,h265
+
     audio_filter:
       name: audio
       in: query
@@ -59,35 +94,20 @@ components:
         type: string
         enum: [ "", all, aac, opus, pcm, pcmu, pcma ]
       example: aac
+
   responses:
     discovery:
       description: ""
       content:
         application/json:
           example: { streams: [ { "name": "Camera 1","url": "..." } ] }
+
     webtorrent:
       description: ""
       content:
         application/json:
           example: { share: AKDypPy4zz, pwd: H0Km1HLTTP }
 
-tags:
-  - name: Application
-    description: "[Module: API](https://github.com/AlexxIT/go2rtc#module-api)"
-  - name: Config
-    description: "[Configuration](https://github.com/AlexxIT/go2rtc#configuration)"
-  - name: Streams list
-    description: "[Module: Streams](https://github.com/AlexxIT/go2rtc#module-streams)"
-  - name: Consume stream
-  - name: Snapshot
-  - name: Produce stream
-  - name: Discovery
-  - name: ONVIF
-  - name: RTSPtoWebRTC
-  - name: WebTorrent
-    description: "[Module: WebTorrent](https://github.com/AlexxIT/go2rtc#module-webtorrent)"
-  - name: Debug
-
 paths:
   /api:
     get:
@@ -98,7 +118,17 @@ paths:
           description: ""
           content:
             application/json:
-              example: { config_path: "/config/go2rtc.yaml",host: "192.168.1.123:1984",rtsp: { listen: ":8554",default_query: "video&audio" },version: "1.5.0" }
+              schema:
+                type: object
+                properties:
+                  config_path: { type: string, example: "/config/go2rtc.yaml" }
+                  host: { type: string, example: "192.168.1.123:1984" }
+                  rtsp:
+                    type: object
+                    properties:
+                      listen: { type: string, example: ":8554" }
+                      default_query: { type: string, example: "video&audio" }
+                  version: { type: string, example: "1.9.12" }
 
   /api/exit:
     post:
@@ -112,17 +142,39 @@ paths:
           schema: { type: integer }
           example: 100
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
 
   /api/restart:
     post:
-      summary: Restart Daemon
+      summary: Restart daemon
       description: Restarts the daemon.
       tags: [ Application ]
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
+
+  /api/log:
+    get:
+      summary: Get in-memory logs buffer
+      description: |
+        Returns current log output from the in-memory circular buffer.
+      tags: [ Application ]
+      responses:
+        "200":
+          description: OK
+          content:
+            application/jsonlines:
+              example: |
+                {"level":"info","version":"1.9.13","platform":"linux/amd64","revision":"dfe4755","time":1766841087331,"message":"go2rtc"}
+    delete:
+      summary: Clear in-memory logs buffer
+      tags: [ Application ]
+      responses:
+        "200":
+          description: ""
+          content:
+            text/plain: { example: "" }
 
   /api/config:
     get:
@@ -133,6 +185,8 @@ paths:
           description: ""
           content:
             application/yaml: { example: "streams:..." }
+        "404":
+          description: Config file not found
     post:
       summary: Rewrite main config file
       tags: [ Config ]
@@ -140,8 +194,8 @@ paths:
         content:
           "*/*": { example: "streams:..." }
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
     patch:
       summary: Merge changes to main config file
       tags: [ Config ]
@@ -149,8 +203,8 @@ paths:
         content:
           "*/*": { example: "streams:..." }
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
 
 
 
@@ -162,7 +216,16 @@ paths:
         "200":
           description: ""
           content:
-            application/json: { example: { camera1: { producers: [ ],consumers: [ ] } } }
+            application/json:
+              schema:
+                type: object
+                additionalProperties:
+                  type: object
+                  properties:
+                    producers:
+                      type: array
+                    consumers:
+                      type: array
     put:
       summary: Create new stream
       tags: [ Streams list ]
@@ -180,8 +243,8 @@ paths:
           schema: { type: string }
           example: camera1
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
     patch:
       summary: Update stream source
       tags: [ Streams list ]
@@ -199,8 +262,8 @@ paths:
           schema: { type: string }
           example: camera1
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
     delete:
       summary: Delete stream
       tags: [ Streams list ]
@@ -212,8 +275,8 @@ paths:
           schema: { type: string }
           example: camera1
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
     post:
       summary: Send stream from source to destination
       description: "[Stream to camera](https://github.com/AlexxIT/go2rtc#stream-to-camera)"
@@ -232,10 +295,26 @@ paths:
           schema: { type: string }
           example: camera1
       responses:
-            default:
-              description: Default response
-
+        default:
+          description: ""
 
+  /api/streams.dot:
+    get:
+      summary: Get streams graph in Graphviz DOT format
+      tags: [ Streams list ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream name filter. Repeat `src` to include multiple streams.
+          required: false
+          schema: { type: string }
+          example: camera1
+      responses:
+        "200":
+          description: OK
+          content:
+            text/vnd.graphviz:
+              example: "digraph { ... }"
 
   /api/preload:
     get:
@@ -245,7 +324,17 @@ paths:
         "200":
           description: ""
           content:
-            application/json: { example: { camera1: "video&audio", camera2: "video" } }
+            application/json:
+              schema:
+                type: object
+                additionalProperties:
+                  type: object
+                  properties:
+                    consumer:
+                      type: object
+                    query:
+                      type: string
+                      example: "video&audio"
     put:
       summary: Preload new stream
       tags: [ Streams list ]
@@ -275,8 +364,8 @@ paths:
           schema: { type: string }
           example: all,aac,opus,...
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
     delete:
       summary: Delete preloaded stream
       tags: [ Streams list ]
@@ -288,9 +377,22 @@ paths:
           schema: { type: string }
           example: "camera1"
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
 
+  /api/schemes:
+    get:
+      summary: Get supported source URL schemes
+      tags: [ Streams list ]
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json:
+              schema:
+                type: array
+                items: { type: string }
+              example: [ rtsp, rtmp, webrtc, ffmpeg, hass ]
 
 
   /api/streams?src={src}:
@@ -304,7 +406,17 @@ paths:
           description: ""
           content:
             application/json:
-              example: { producers: [ { url: "rtsp://rtsp:12345678@192.168.1.123/av_stream/ch0" } ], consumers: [ ] }
+              schema:
+                type: object
+                additionalProperties:
+                  type: object
+                  properties:
+                    producers:
+                      type: array
+                      items: { type: object }
+                    consumers:
+                      type: array
+                      items: { type: object }
 
   /api/webrtc?src={src}:
     post:
@@ -324,7 +436,6 @@ paths:
           application/json: { example: { type: offer, sdp: "v=0..." } }
           "application/sdp": { example: "v=0..." }
           "*/*": { example: "v=0..." }
-
       responses:
         "200":
           description: "Response on JSON or raw SDP"
@@ -355,6 +466,16 @@ paths:
           required: false
           schema: { type: string }
           example: camera1.mp4
+        - name: rotate
+          in: query
+          description: "Rotate video (degrees). Supported values: 90, 180, 270."
+          required: false
+          schema: { type: integer, enum: [ 90, 180, 270 ] }
+        - name: scale
+          in: query
+          description: Scale video in format `width:height`
+          required: false
+          schema: { type: string, example: "1280:720" }
         - $ref: "#/components/parameters/mp4_filter"
         - $ref: "#/components/parameters/video_filter"
         - $ref: "#/components/parameters/audio_filter"
@@ -367,7 +488,7 @@ paths:
     get:
       summary: Get stream in HLS format
       description: "[Module: HLS](https://github.com/AlexxIT/go2rtc#module-hls)"
-      tags: [ Consume stream ]
+      tags: [ Consume stream, HLS ]
       parameters:
         - $ref: "#/components/parameters/stream_src_path"
         - $ref: "#/components/parameters/mp4_filter"
@@ -378,6 +499,62 @@ paths:
           description: ""
           content: { application/vnd.apple.mpegurl: { example: "" } }
 
+  /api/hls/playlist.m3u8?id={id}:
+    get:
+      summary: Get HLS media playlist for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            application/vnd.apple.mpegurl: { example: "" }
+        "404":
+          description: Session not found
+
+  /api/hls/segment.ts?id={id}:
+    get:
+      summary: Get HLS MPEG-TS segment for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/mp2t: { example: "" }
+        "404":
+          description: Segment or session not found
+
+  /api/hls/init.mp4?id={id}:
+    get:
+      summary: Get HLS fMP4 init segment for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/mp4: { example: "" }
+        "404":
+          description: Segment or session not found
+
+  /api/hls/segment.m4s?id={id}:
+    get:
+      summary: Get HLS fMP4 media segment for an active session
+      tags: [ HLS ]
+      parameters:
+        - $ref: "#/components/parameters/hls_session_id_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/iso.segment: { example: "" }
+        "404":
+          description: Segment or session not found
+
   /api/stream.mjpeg?src={src}:
     get:
       summary: Get stream in MJPEG format
@@ -390,7 +567,91 @@ paths:
           description: ""
           content: { multipart/x-mixed-replace: { example: "" } }
 
+  /api/stream.ascii?src={src}:
+    get:
+      summary: Get stream in ASCII-art format (ANSI escape codes)
+      description: "[Module: MJPEG](https://github.com/AlexxIT/go2rtc#module-mjpeg)"
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+        - name: color
+          in: query
+          description: Foreground mode (`8`, `256`, `rgb` or ANSI SGR code)
+          required: false
+          schema: { type: string }
+        - name: back
+          in: query
+          description: Background mode (`8`, `256`, `rgb` or ANSI SGR code)
+          required: false
+          schema: { type: string }
+        - name: text
+          in: query
+          description: Charset preset (empty/default, `block`) or custom characters
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            text/plain: { example: "" }
+        "404":
+          description: Stream not found
 
+  /api/stream.y4m?src={src}:
+    get:
+      summary: Get stream in YUV4MPEG2 format (y4m)
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            application/octet-stream: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.ts?src={src}:
+    get:
+      summary: Get stream in MPEG-TS format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/mp2t: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.aac?src={src}:
+    get:
+      summary: Get stream audio in AAC (ADTS) format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            audio/aac: { example: "" }
+        "404":
+          description: Stream not found
+
+  /api/stream.flv?src={src}:
+    get:
+      summary: Get stream in FLV format
+      tags: [ Consume stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_src_path"
+      responses:
+        "200":
+          description: OK
+          content:
+            video/x-flv: { example: "" }
+        "404":
+          description: Stream not found
 
   /api/frame.jpeg?src={src}:
     get:
@@ -399,10 +660,37 @@ paths:
       tags: [ Snapshot ]
       parameters:
         - $ref: "#/components/parameters/stream_src_path"
+        - name: name
+          in: query
+          description: Optional stream name to create/update if `src` is a URL
+          required: false
+          schema: { type: string }
+        - name: width
+          in: query
+          description: "Scale output width (alias: `w`)"
+          required: false
+          schema: { type: integer, minimum: 1 }
+        - name: height
+          in: query
+          description: "Scale output height (alias: `h`)"
+          required: false
+          schema: { type: integer, minimum: 1 }
+        - name: rotate
+          in: query
+          description: "Rotate output (degrees). Supported values: 90, 180, 270."
+          required: false
+          schema: { type: integer, enum: [ 90, 180, 270 ] }
+        - name: hardware
+          in: query
+          description: "Hardware acceleration engine for FFmpeg snapshot transcoding (alias: `hw`)"
+          required: false
+          schema: { type: string }
       responses:
-        200:
+        "200":
           description: ""
-          content: { image/jpeg: { example: "" } }
+          content:
+            image/jpeg: { example: "" }
+
   /api/frame.mp4?src={src}:
     get:
       summary: Get snapshot in MP4 format
@@ -410,23 +698,51 @@ paths:
       tags: [ Snapshot ]
       parameters:
         - $ref: "#/components/parameters/stream_src_path"
+        - name: filename
+          in: query
+          description: Download as a file with this name
+          required: false
+          schema: { type: string }
+          example: camera1.mp4
       responses:
         200:
           description: ""
-          content: { video/mp4: { example: "" } }
+          content:
+            video/mp4: { example: "" }
 
 
 
   /api/webrtc?dst={dst}:
     post:
-      summary: Post stream in WebRTC format
+      summary: Post stream in WebRTC format (WHIP)
       description: "[Incoming: WebRTC/WHIP](https://github.com/AlexxIT/go2rtc#incoming-webrtcwhip)"
       tags: [ Produce stream ]
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
       responses:
-            default:
-              description: Default response
+        "201":
+          description: Created
+          headers:
+            Location:
+              description: Resource URL for session
+              schema: { type: string }
+          content:
+            application/sdp: { example: "v=0..." }
+        "404":
+          description: Stream not found
+
+  /api/stream?dst={dst}:
+    post:
+      summary: Post stream in auto-detected format
+      description: |
+        Incoming source with automatic format detection. Use for pushing a stream into an existing `dst` stream.
+      tags: [ Produce stream ]
+      parameters:
+        - $ref: "#/components/parameters/stream_dst_path"
+      responses:
+        default:
+          description: ""
+
   /api/stream.flv?dst={dst}:
     post:
       summary: Post stream in FLV format
@@ -435,8 +751,9 @@ paths:
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
+
   /api/stream.ts?dst={dst}:
     post:
       summary: Post stream in MPEG-TS format
@@ -445,8 +762,9 @@ paths:
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
+
   /api/stream.mjpeg?dst={dst}:
     post:
       summary: Post stream in MJPEG format
@@ -455,10 +773,55 @@ paths:
       parameters:
         - $ref: "#/components/parameters/stream_dst_path"
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
 
 
+  /api/ffmpeg:
+    post:
+      summary: Play file/live/TTS into a stream via FFmpeg
+      description: |
+        Helper endpoint for "stream to camera" scenarios.
+        Exactly one of `file`, `live`, `text` should be provided.
+      tags: [ FFmpeg ]
+      parameters:
+        - name: dst
+          in: query
+          description: Destination stream name
+          required: true
+          schema: { type: string }
+          example: camera1
+        - name: file
+          in: query
+          description: Input URL to treat as file (`#input=file`)
+          required: false
+          schema: { type: string }
+          example: "http://example.com/song.mp3"
+        - name: live
+          in: query
+          description: Live input URL
+          required: false
+          schema: { type: string }
+          example: "http://example.com/live.mp3"
+        - name: text
+          in: query
+          description: Text-to-speech phrase
+          required: false
+          schema: { type: string }
+          example: "Hello"
+        - name: voice
+          in: query
+          description: Optional TTS voice (engine-dependent)
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+        "400":
+          description: Invalid parameters
+        "404":
+          description: Stream not found
+
 
   /api/dvrip:
     get:
@@ -466,8 +829,7 @@ paths:
       description: "[Source: DVRIP](https://github.com/AlexxIT/go2rtc#source-dvrip)"
       tags: [ Discovery ]
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
 
   /api/ffmpeg/devices:
     get:
@@ -475,56 +837,275 @@ paths:
       description: "[Source: FFmpeg Device](https://github.com/AlexxIT/go2rtc#source-ffmpeg-device)"
       tags: [ Discovery ]
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
+  
   /api/ffmpeg/hardware:
     get:
       summary: FFmpeg hardware transcoding discovery
       description: "[Hardware acceleration](https://github.com/AlexxIT/go2rtc/wiki/Hardware-acceleration)"
       tags: [ Discovery ]
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/v4l2:
+    get:
+      summary: V4L2 video devices discovery (Linux)
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/alsa:
+    get:
+      summary: ALSA audio devices discovery (Linux)
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+  
+  /api/gopro:
+    get:
+      summary: GoPro cameras discovery
+      tags: [ Discovery ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+
+  /api/ring:
+    get:
+      summary: Ring cameras discovery
+      description: |
+        Provide either `email`/`password` (and optional `code` for 2FA) or `refresh_token`.
+        If 2FA is required, returns a JSON prompt instead of sources.
+      tags: [ Discovery ]
+      parameters:
+        - name: email
+          in: query
+          required: false
+          schema: { type: string }
+        - name: password
+          in: query
+          required: false
+          schema: { type: string }
+        - name: code
+          in: query
+          required: false
+          schema: { type: string }
+        - name: refresh_token
+          in: query
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json: { example: "" }
+
+  /api/tuya:
+    get:
+      summary: Tuya cameras discovery
+      tags: [ Discovery ]
+      parameters:
+        - name: region
+          in: query
+          description: Tuya API host (region)
+          required: true
+          schema: { type: string }
+          example: "openapi.tuyaus.com"
+        - name: email
+          in: query
+          required: true
+          schema: { type: string }
+        - name: password
+          in: query
+          required: true
+          schema: { type: string }
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
+        "400":
+          description: Invalid parameters
+        "404":
+          description: No cameras found
+  
   /api/hass:
     get:
       summary: Home Assistant cameras discovery
       description: "[Source: Hass](https://github.com/AlexxIT/go2rtc#source-hass)"
       tags: [ Discovery ]
       responses:
-            default:
-              description: Default response
-  /api/homekit:
+        "200": { $ref: "#/components/responses/discovery" }
+        "404": { description: No Hass config }
+
+  /api/discovery/homekit:
     get:
       summary: HomeKit cameras discovery
       description: "[Source: HomeKit](https://github.com/AlexxIT/go2rtc#source-homekit)"
       tags: [ Discovery ]
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
+
   /api/nest:
     get:
       summary: Nest cameras discovery
       tags: [ Discovery ]
+      parameters:
+        - name: client_id
+          in: query
+          required: true
+          schema: { type: string }
+        - name: client_secret
+          in: query
+          required: true
+          schema: { type: string }
+        - name: refresh_token
+          in: query
+          required: true
+          schema: { type: string }
+        - name: project_id
+          in: query
+          required: true
+          schema: { type: string }
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
+
   /api/onvif:
     get:
       summary: ONVIF cameras discovery
       description: "[Source: ONVIF](https://github.com/AlexxIT/go2rtc#source-onvif)"
       tags: [ Discovery ]
+      parameters:
+        - name: src
+          in: query
+          description: Optional ONVIF device URL to enumerate profiles
+          required: false
+          schema: { type: string }
+          example: "onvif://user:pass@192.168.1.50:80"
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
+
   /api/roborock:
     get:
-      summary: Roborock vacuums discovery
+      summary: Roborock vacuums discovery (requires prior auth)
       description: "[Source: Roborock](https://github.com/AlexxIT/go2rtc#source-roborock)"
       tags: [ Discovery ]
       responses:
-            default:
-              description: Default response
+        "200": { $ref: "#/components/responses/discovery" }
+        "404":
+          description: No auth
+    post:
+      summary: Roborock login and discovery
+      tags: [ Discovery ]
+      requestBody:
+        required: true
+        content:
+          multipart/form-data:
+            schema:
+              type: object
+              properties:
+                username: { type: string }
+                password: { type: string }
+              required: [ username, password ]
+      responses:
+        "200": { $ref: "#/components/responses/discovery" }
 
+  /api/homekit:
+    get:
+      summary: Get HomeKit servers state
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Optional stream name (server ID)
+          required: false
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json: { example: "" }
+        "404":
+          description: Server not found
+    post:
+      summary: Pair HomeKit camera and create/update stream
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Stream name to create/update
+          required: true
+          schema: { type: string }
+        - name: src
+          in: query
+          description: HomeKit URL (without pin)
+          required: true
+          schema: { type: string }
+        - name: pin
+          in: query
+          description: HomeKit PIN
+          required: true
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+    delete:
+      summary: Unpair HomeKit camera and delete stream
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Stream name / server ID
+          required: true
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+        "404":
+          description: Stream not found
+
+  /api/homekit/accessories:
+    get:
+      summary: Get HomeKit accessories JSON for a stream
+      tags: [ HomeKit ]
+      parameters:
+        - name: id
+          in: query
+          description: Stream name
+          required: true
+          schema: { type: string }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/json: { example: { } }
+        "404":
+          description: Stream not found
+
+  /pair-setup:
+    post:
+      summary: HomeKit Pair Setup (HAP)
+      description: HomeKit Accessory Protocol endpoint (TLV8).
+      tags: [ HomeKit ]
+      requestBody:
+        required: true
+        content:
+          application/pairing+tlv8: { example: "" }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/pairing+tlv8: { example: "" }
+
+  /pair-verify:
+    post:
+      summary: HomeKit Pair Verify (HAP)
+      description: HomeKit Accessory Protocol endpoint (TLV8).
+      tags: [ HomeKit ]
+      requestBody:
+        required: true
+        content:
+          application/pairing+tlv8: { example: "" }
+      responses:
+        "200":
+          description: OK
+          content:
+            application/pairing+tlv8: { example: "" }
 
 
   /onvif/:
@@ -533,8 +1114,8 @@ paths:
       description: Simple realisation of the ONVIF protocol. Accepts any suburl requests
       tags: [ ONVIF ]
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
 
 
 
@@ -544,8 +1125,33 @@ paths:
       description: Simple API for support [RTSPtoWebRTC](https://www.home-assistant.io/integrations/rtsp_to_webrtc/) integration
       tags: [ RTSPtoWebRTC ]
       responses:
-            default:
-              description: Default response
+        default:
+          description: ""
+
+
+  /api/ws:
+    get:
+      summary: WebSocket endpoint
+      description: |
+        Upgrade to WebSocket and exchange JSON messages:
+        - Request: `{ "type": "...", "value": ... }`
+        - Response: `{ "type": "...", "value": ... }`
+        
+        Supported message types depend on enabled modules (see `api/README.md`).
+      tags: [ WebSocket ]
+      parameters:
+        - name: src
+          in: query
+          description: Stream name (consumer)
+          required: false
+          schema: { type: string }
+        - name: dst
+          in: query
+          description: Stream name (producer)
+          required: false
+          schema: { type: string }
+      responses:
+        "101": { description: Switching Protocols }
 
 
 
@@ -564,15 +1170,13 @@ paths:
         - $ref: "#/components/parameters/stream_src_path"
       responses:
         200: { $ref: "#/components/responses/webtorrent" }
-
     delete:
       summary: Delete WebTorrent share
       tags: [ WebTorrent ]
       parameters:
         - $ref: "#/components/parameters/stream_src_path"
       responses:
-            default:
-              description: Default response
+        default: { description: "" }
 
   /api/webtorrent:
     get:

From 4dae65a5351e415266ceb9589c2494e8dcc8da9f Mon Sep 17 00:00:00 2001
From: Alex X <alexey.khit@gmail.com>
Date: Wed, 31 Dec 2025 17:55:47 +0300
Subject: [PATCH 26/26] Fix audio sample rate for some xiaomi cameras #2006

---
 pkg/xiaomi/miss/client.go | 18 ++++++++++++++++++
 pkg/xiaomi/producer.go    |  2 +-
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/pkg/xiaomi/miss/client.go b/pkg/xiaomi/miss/client.go
index 470c0e0e..f7157ccf 100644
--- a/pkg/xiaomi/miss/client.go
+++ b/pkg/xiaomi/miss/client.go
@@ -271,6 +271,24 @@ type Packet struct {
 	Payload []byte
 }
 
+func (p *Packet) SampleRate() uint32 {
+	// flag:         1 0011 000 - sample rate 16000
+	// flag: 100 00 01 0000 000 - sample rate  8000
+	v := (p.Flags >> 3) & 0b1111
+	if v != 0 {
+		return 16000
+	}
+	return 8000
+}
+
+//func (p *Packet) AudioUnknown1() byte {
+//	return byte((p.Flags >> 7) & 0b11)
+//}
+//
+//func (p *Packet) AudioUnknown2() byte {
+//	return byte((p.Flags >> 9) & 0b11)
+//}
+
 func GenerateKey() ([]byte, []byte, error) {
 	public, private, err := box.GenerateKey(rand.Reader)
 	if err != nil {
diff --git a/pkg/xiaomi/producer.go b/pkg/xiaomi/producer.go
index 09ba7360..dcd419b8 100644
--- a/pkg/xiaomi/producer.go
+++ b/pkg/xiaomi/producer.go
@@ -110,7 +110,7 @@ func probe(client *miss.Client, channel, quality, audio uint8) ([]*core.Media, e
 			}
 		case miss.CodecPCMA:
 			if acodec == nil {
-				acodec = &core.Codec{Name: core.CodecPCMA, ClockRate: 8000}
+				acodec = &core.Codec{Name: core.CodecPCMA, ClockRate: pkt.SampleRate()}
 			}
 		case miss.CodecOPUS:
 			if acodec == nil {