@syncular/typegen 0.5.0 → 0.6.0

package/dist/lsp.js

@@ -1,56 +1,41 @@
-/**
- * `syncular lsp` — a minimal `.syql` language server (DESIGN-queries.md
- * §10, staged Q5). Zero dependencies: hand-rolled JSON-RPC over stdio with
- * Content-Length framing, and the SAME parser/checker the generator runs —
- * diagnostics are generate-time truth, not a re-implementation.
- *
- * Capabilities:
- * - diagnostics (on open/change): parse errors, lowering errors (B1,
- *   knob conflicts), and — when a `syncular.json` is found above the file —
- *   the full SQLite-checked analysis (types, unknown columns, naming
- *   collisions).
- * - hover: a query name shows its lowered, checked SQL (what actually
- *   runs); an `@fragment` ref shows the fragment body.
- * - definition: an `@fragment` ref jumps to its declaration (same file —
- *   fragments are file-scoped).
- *
- * The server core is a pure(ish) class (`SyqlLanguageServer.handle`)
- * so tests drive it without stdio; `runLspStdio` is the thin transport.
- */
+/** Revision-1 SYQL language server backed by the compiler frontend (§21). */
 import { existsSync, readFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
+import { dirname, relative, resolve, sep } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { TypegenError } from './errors.js';
-import { buildIr, loadMigrations, makeQueryDb } from './generate.js';
+import { formatSyql } from './fmt.js';
+import { buildIr, loadMigrations, loadQueries, makeQueryDb } from './generate.js';
 import { MANIFEST_FILENAME, parseManifest } from './manifest.js';
-import { analyzeSyqlFile, parseSyqlFile } from './syql.js';
-// ---------------------------------------------------------------------------
-// Text/position helpers
-// ---------------------------------------------------------------------------
+import { SyqlFrontendError } from './syql-lexer.js';
+import { lowerSyqlQuery } from './syql-lowering.js';
+import { buildSyqlModuleGraph } from './syql-modules.js';
+import { parseSyqlSyntaxFile, } from './syql-parser.js';
+import { analyzeSyqlSemantics, } from './syql-semantics.js';
+import { validateSyqlProgram } from './syql-validator.js';
 function offsetToPosition(text, offset) {
     const clamped = Math.max(0, Math.min(offset, text.length));
     let line = 0;
     let lineStart = 0;
-    for (let i = 0; i < clamped; i++) {
-        if (text[i] === '\n') {
+    for (let index = 0; index < clamped; index += 1) {
+        if (text[index] === '\n') {
             line += 1;
-            lineStart = i + 1;
+            lineStart = index + 1;
         }
     }
     return { line, character: clamped - lineStart };
 }
 function positionToOffset(text, position) {
     let line = 0;
-    let i = 0;
-    while (i < text.length && line < position.line) {
-        if (text[i] === '\n')
+    let index = 0;
+    while (index < text.length && line < position.line) {
+        if (text[index] === '\n')
             line += 1;
-        i += 1;
+        index += 1;
     }
-    return Math.min(text.length, i + position.character);
+    return Math.min(text.length, index + position.character);
 }
-/** The `@word` / `word` under the cursor, with its range. */
 function wordAt(text, offset) {
-    const isWord = (ch) => ch !== undefined && /[A-Za-z0-9_@]/.test(ch);
+    const isWord = (character) => character !== undefined && /[A-Za-z0-9_@]/.test(character);
     if (!isWord(text[offset]) && !isWord(text[offset - 1]))
         return null;
     let start = isWord(text[offset]) ? offset : offset - 1;
@@ -65,24 +50,50 @@ function uriToPath(uri) {
     return uri.startsWith('file://') ? decodeURIComponent(uri.slice(7)) : uri;
 }
 function findManifestDir(fromPath) {
-    let dir = dirname(fromPath);
-    for (let i = 0; i < 20; i++) {
-        if (existsSync(resolve(dir, MANIFEST_FILENAME)))
-            return dir;
-        const parent = dirname(dir);
-        if (parent === dir)
+    let directory = dirname(fromPath);
+    for (let count = 0; count < 20; count += 1) {
+        if (existsSync(resolve(directory, MANIFEST_FILENAME)))
+            return directory;
+        const parent = dirname(directory);
+        if (parent === directory)
             return null;
-        dir = parent;
+        directory = parent;
     }
     return null;
 }
-// ---------------------------------------------------------------------------
-// The server
-// ---------------------------------------------------------------------------
+function isWithin(root, file) {
+    const path = relative(root, file);
+    return path === '' || (!path.startsWith(`..${sep}`) && path !== '..');
+}
+function spanRange(text, span) {
+    const start = offsetToPosition(text, span.start.offset);
+    const end = offsetToPosition(text, span.end.offset);
+    return {
+        start,
+        end: end.line === start.line && end.character === start.character
+            ? { line: end.line, character: end.character + 1 }
+            : end,
+    };
+}
+function typeText(type) {
+    return type === undefined
+        ? 'inferred'
+        : `${type.base}${type.nullable ? ' | null' : ''}`;
+}
+function parameterHover(parameter) {
+    if (parameter.kind === 'switch') {
+        return `switch \`${parameter.name}\` — false/absent or true`;
+    }
+    if (parameter.kind === 'group') {
+        return `optional group \`${parameter.name}\`\n\n${parameter.members
+            .map((member) => `- \`${member.name}: ${typeText(member.type)}\``)
+            .join('\n')}`;
+    }
+    return `${parameter.optional ? 'optional' : 'required'} input \`${parameter.name}: ${typeText(parameter.type)}\``;
+}
 export class SyqlLanguageServer {
     #documents = new Map();
     #contexts = new Map();
-    /** Handle one incoming message; returns the outgoing messages. */
     handle(message) {
         const { method, id } = message;
         if (method === 'initialize') {
@@ -92,11 +103,14 @@ export class SyqlLanguageServer {
                     id,
                     result: {
                         capabilities: {
-                            textDocumentSync: 1, // full
+                            textDocumentSync: 1,
                             hoverProvider: true,
                             definitionProvider: true,
+                            referencesProvider: true,
+                            documentSymbolProvider: true,
+                            documentFormattingProvider: true,
                         },
-                        serverInfo: { name: 'syncular-syql-lsp', version: '0.0.1' },
+                        serverInfo: { name: 'syncular-syql-lsp', version: '1.0.0' },
                     },
                 },
             ];
@@ -108,10 +122,9 @@ export class SyqlLanguageServer {
         }
         if (method === 'textDocument/didChange') {
             const params = message.params;
-            const last = params.contentChanges[params.contentChanges.length - 1];
-            if (last !== undefined) {
+            const last = params.contentChanges.at(-1);
+            if (last !== undefined)
                 this.#documents.set(params.textDocument.uri, last.text);
-            }
             return [this.#publishDiagnostics(params.textDocument.uri)];
         }
         if (method === 'textDocument/didClose') {
@@ -119,15 +132,27 @@ export class SyqlLanguageServer {
             this.#documents.delete(params.textDocument.uri);
             return [];
         }
+        if (method === 'workspace/didChangeWatchedFiles') {
+            this.invalidateProjects();
+            return [...this.#documents.keys()].map((uri) => this.#publishDiagnostics(uri));
+        }
         if (method === 'textDocument/hover') {
             return [{ jsonrpc: '2.0', id, result: this.#hover(message.params) }];
         }
         if (method === 'textDocument/definition') {
             return [{ jsonrpc: '2.0', id, result: this.#definition(message.params) }];
         }
-        if (method === 'shutdown') {
-            return [{ jsonrpc: '2.0', id, result: null }];
+        if (method === 'textDocument/references') {
+            return [{ jsonrpc: '2.0', id, result: this.#references(message.params) }];
+        }
+        if (method === 'textDocument/documentSymbol') {
+            return [{ jsonrpc: '2.0', id, result: this.#symbols(message.params) }];
         }
+        if (method === 'textDocument/formatting') {
+            return [{ jsonrpc: '2.0', id, result: this.#formatting(message.params) }];
+        }
+        if (method === 'shutdown')
+            return [{ jsonrpc: '2.0', id, result: null }];
         if (id !== undefined && method !== undefined) {
             return [
                 {
@@ -139,7 +164,6 @@ export class SyqlLanguageServer {
         }
         return [];
     }
-    /** Reset cached manifest contexts (e.g. after schema edits). */
     invalidateProjects() {
         this.#contexts = new Map();
     }
@@ -147,192 +171,335 @@ export class SyqlLanguageServer {
         const path = uriToPath(uri);
         const manifestDir = findManifestDir(path);
         if (manifestDir === null)
-            return null;
+            return { kind: 'none' };
         const cached = this.#contexts.get(manifestDir);
         if (cached !== undefined)
             return cached;
         try {
             const manifest = parseManifest(JSON.parse(readFileSync(resolve(manifestDir, MANIFEST_FILENAME), 'utf8')));
-            const migrations = loadMigrations(resolve(manifestDir, manifest.migrations));
-            const ir = buildIr(manifest, migrations);
+            const ir = buildIr(manifest, loadMigrations(resolve(manifestDir, manifest.migrations)));
             const { db } = makeQueryDb(ir);
             const targets = ['ts'];
-            const context = {
-                ir,
-                db,
-                manifestDir,
-                naming: {
-                    naming: manifest.naming,
-                    targets,
-                    backend: manifest.queryBackend,
+            if (manifest.output.swift !== undefined)
+                targets.push('swift');
+            if (manifest.output.kotlin !== undefined)
+                targets.push('kotlin');
+            if (manifest.output.dart !== undefined)
+                targets.push('dart');
+            const lookup = {
+                kind: 'ready',
+                context: {
+                    ir,
+                    db,
+                    manifestDir,
+                    queriesRoot: resolve(manifestDir, manifest.queries),
+                    naming: {
+                        naming: manifest.naming,
+                        targets,
+                        backend: manifest.queryBackend,
+                    },
                 },
             };
-            this.#contexts.set(manifestDir, context);
-            return context;
+            this.#contexts.set(manifestDir, lookup);
+            return lookup;
         }
-        catch {
-            this.#contexts.set(manifestDir, null);
-            return null;
+        catch (error) {
+            const lookup = { kind: 'error', error };
+            this.#contexts.set(manifestDir, lookup);
+            return lookup;
         }
     }
+    #openText(file) {
+        for (const [uri, text] of this.#documents) {
+            if (resolve(uriToPath(uri)) === resolve(file))
+                return text;
+        }
+        return undefined;
+    }
+    #compilerView(uri, text) {
+        const file = resolve(uriToPath(uri));
+        const lookup = this.#context(uri);
+        if (lookup.kind === 'error')
+            throw lookup.error;
+        const project = lookup.kind === 'ready' ? lookup.context : undefined;
+        const root = project !== undefined && isWithin(project.queriesRoot, file)
+            ? project.queriesRoot
+            : dirname(file);
+        const sourceByFile = new Map();
+        const entries = [];
+        if (project !== undefined && root === project.queriesRoot) {
+            for (const input of loadQueries(root)) {
+                if (!input.file.endsWith('.syql'))
+                    continue;
+                const absolute = resolve(root, input.file);
+                sourceByFile.set(absolute, this.#openText(absolute) ?? input.sql);
+                entries.push(input.file);
+            }
+        }
+        sourceByFile.set(file, text);
+        const currentEntry = relative(root, file).split(sep).join('/');
+        if (!entries.includes(currentEntry))
+            entries.push(currentEntry);
+        entries.sort();
+        const graph = buildSyqlModuleGraph(root, entries, (candidate) => {
+            const open = this.#openText(candidate);
+            if (open !== undefined)
+                return open;
+            const loaded = sourceByFile.get(candidate);
+            if (loaded !== undefined)
+                return loaded;
+            return existsSync(candidate)
+                ? readFileSync(candidate, 'utf8')
+                : undefined;
+        });
+        const semantic = analyzeSyqlSemantics(graph);
+        const module = graph.moduleByPath.get(file);
+        if (module === undefined)
+            throw new TypegenError(file, 'current SYQL module missing');
+        const lowered = project === undefined
+            ? []
+            : validateSyqlProgram(semantic, project.ir, project.db, project.naming).queries.map((query) => lowerSyqlQuery(query, project.ir, project.db, project.naming));
+        return { root, file, module, semantic, lowered };
+    }
     #publishDiagnostics(uri) {
         const text = this.#documents.get(uri) ?? '';
-        const diagnostics = this.#diagnose(uri, text);
         return {
             jsonrpc: '2.0',
             method: 'textDocument/publishDiagnostics',
-            params: { uri, diagnostics },
+            params: { uri, diagnostics: this.#diagnose(uri, text) },
         };
     }
     #diagnose(uri, text) {
-        const path = uriToPath(uri);
-        const context = this.#context(uri);
         try {
-            if (context !== null) {
-                // The full generate-time analysis: parse + lower + SQLite check.
-                const rel = relative(context.manifestDir, path).split('\\').join('/');
-                analyzeSyqlFile(rel, text, context.ir, context.db, context.naming);
-            }
-            else {
-                // No manifest reachable: parser + lowering only.
-                const parsed = parseSyqlFile(path, text);
-                void parsed;
-            }
+            this.#compilerView(uri, text);
             return [];
         }
         catch (error) {
-            return [this.#errorToDiagnostic(error, text)];
+            return [this.#errorToDiagnostic(error, text, resolve(uriToPath(uri)))];
         }
     }
-    #errorToDiagnostic(error, text) {
+    #errorToDiagnostic(error, text, file) {
         const message = error instanceof Error ? error.message : String(error);
-        let range = {
-            start: { line: 0, character: 0 },
-            end: { line: 0, character: 1 },
-        };
-        if (error instanceof TypegenError) {
-            // Cursor errors carry `file:line`; lowering errors carry
-            // `file (query name)` — anchor those at the declaration.
-            const lineMatch = /:(\d+): /.exec(message);
-            const queryMatch = /\(query ([A-Za-z][A-Za-z0-9]*)\)/.exec(message);
-            if (lineMatch !== null) {
-                const line = Number.parseInt(lineMatch[1], 10) - 1;
-                range = {
-                    start: { line, character: 0 },
-                    end: { line, character: 200 },
-                };
-            }
-            else if (queryMatch !== null) {
-                try {
-                    const parsed = parseSyqlFile('doc', text);
-                    const decl = parsed.queries.find((q) => q.name === queryMatch[1]);
-                    if (decl !== undefined) {
-                        const start = offsetToPosition(text, decl.offset);
-                        range = {
-                            start,
-                            end: { line: start.line, character: start.character + 200 },
-                        };
-                    }
-                }
-                catch {
-                    // fall through to line 0
-                }
-            }
+        if (error instanceof SyqlFrontendError &&
+            resolve(error.sourceFile) === file) {
+            return {
+                range: spanRange(text, error.span),
+                severity: 1,
+                source: 'syncular',
+                code: error.code,
+                message,
+            };
         }
-        return { range, severity: 1, source: 'syncular', message };
+        return {
+            range: {
+                start: { line: 0, character: 0 },
+                end: {
+                    line: 0,
+                    character: Math.max(1, text.split('\n')[0]?.length ?? 1),
+                },
+            },
+            severity: 1,
+            source: 'syncular',
+            ...(error instanceof SyqlFrontendError ? { code: error.code } : {}),
+            message: this.#context(pathToFileURL(file).href).kind === 'error'
+                ? `SYQL9001_PROJECT_CONTEXT: ${message}`
+                : message,
+        };
     }
-    #hover(params) {
-        const p = params;
-        const text = this.#documents.get(p.textDocument.uri);
+    #request(params) {
+        const request = params;
+        const text = this.#documents.get(request.textDocument.uri);
         if (text === undefined)
             return null;
-        const offset = positionToOffset(text, p.position);
+        const offset = positionToOffset(text, request.position);
         const found = wordAt(text, offset);
         if (found === null)
             return null;
-        let parsed;
         try {
-            parsed = parseSyqlFile('doc', text);
+            return {
+                uri: request.textDocument.uri,
+                text,
+                offset,
+                found,
+                view: this.#compilerView(request.textDocument.uri, text),
+            };
         }
         catch {
             return null;
         }
-        // `@fragment` ref → the fragment's body.
+    }
+    #hover(params) {
+        const request = this.#request(params);
+        if (request === null)
+            return null;
+        const { found, view, offset } = request;
+        if (found.word === '@scope' || found.word === '@cover') {
+            return {
+                contents: {
+                    kind: 'markdown',
+                    value: found.word === '@scope'
+                        ? '`@scope` constructs exact reactive dependency keys and the same SQL predicate.'
+                        : '`@cover` constructs exact dependencies plus checked window coverage.',
+                },
+            };
+        }
         if (found.word.startsWith('@')) {
-            const fragment = parsed.fragments.find((f) => f.name === found.word.slice(1));
-            if (fragment === undefined)
+            const predicate = view.semantic.predicateScopes
+                .get(view.file)
+                ?.get(found.word.slice(1));
+            if (predicate === undefined)
                 return null;
             return {
                 contents: {
                     kind: 'markdown',
-                    value: `\`\`\`sql\n${fragment.body}\n\`\`\``,
+                    value: `predicate \`${predicate.declaration.name}\` from \`${relative(view.root, predicate.module.file)}\`\n\n\`\`\`sql\n${predicate.declaration.body.text.trim()}\n\`\`\``,
                 },
             };
         }
-        // A query name → the lowered, checked SQL (needs the project schema).
-        const query = parsed.queries.find((q) => q.name === found.word);
+        const query = view.module.queries.find((candidate) => offset >= candidate.span.start.offset &&
+            offset <= candidate.span.end.offset);
         if (query !== undefined) {
-            const context = this.#context(p.textDocument.uri);
-            if (context === null)
-                return null;
-            try {
-                const analyzed = analyzeSyqlFile('doc.syql', text, context.ir, context.db, context.naming).find((q) => q.name === found.word);
-                if (analyzed === undefined)
-                    return null;
-                const lines = [
-                    '```sql',
-                    analyzed.sql,
-                    '```',
-                    '',
-                    `tables: ${analyzed.tables.join(', ')}`,
-                    ...(analyzed.variants !== undefined
-                        ? [`variants: ${analyzed.variants.length} enumerated statements`]
-                        : []),
-                ];
-                return { contents: { kind: 'markdown', value: lines.join('\n') } };
+            const parameter = query.parameters.find((candidate) => candidate.name === found.word);
+            if (parameter !== undefined) {
+                return {
+                    contents: { kind: 'markdown', value: parameterHover(parameter) },
+                };
             }
-            catch {
-                return null;
+            if (query.sort?.control === found.word) {
+                return {
+                    contents: {
+                        kind: 'markdown',
+                        value: `sort control \`${found.word}\`; default profile \`${query.sort.defaultProfile}\``,
+                    },
+                };
+            }
+            const profile = query.sort?.profiles.find((candidate) => candidate.name === found.word);
+            if (profile !== undefined) {
+                return {
+                    contents: {
+                        kind: 'markdown',
+                        value: `sort profile \`${profile.name}\`\n\n\`\`\`sql\n${profile.order.text.trim()}\n\`\`\``,
+                    },
+                };
             }
+            if (query.page?.control === found.word) {
+                return {
+                    contents: {
+                        kind: 'markdown',
+                        value: `page control \`${found.word}\`: default ${query.page.defaultSize}, maximum ${query.page.maxSize}`,
+                    },
+                };
+            }
+        }
+        if (query?.name === found.word) {
+            const lowered = view.lowered.find((candidate) => candidate.validated.logical.declaration === query);
+            if (lowered === undefined)
+                return null;
+            const defaultStatement = lowered.selected.statements.find((statement) => (statement.activationMask === undefined ||
+                statement.activationMask === 0) &&
+                (lowered.validated.sort === undefined ||
+                    statement.sortProfile === lowered.validated.sort.defaultProfile));
+            return {
+                contents: {
+                    kind: 'markdown',
+                    value: [
+                        `backend: **${lowered.selected.backend}** (${lowered.selected.statements.length} checked statement${lowered.selected.statements.length === 1 ? '' : 's'})`,
+                        '',
+                        '```sql',
+                        defaultStatement?.sql ?? lowered.analysis.sql,
+                        '```',
+                        '',
+                        `tables: ${lowered.analysis.tables.join(', ')}`,
+                    ].join('\n'),
+                },
+            };
         }
         return null;
     }
     #definition(params) {
-        const p = params;
-        const text = this.#documents.get(p.textDocument.uri);
-        if (text === undefined)
+        const request = this.#request(params);
+        if (request === null || !request.found.word.startsWith('@'))
             return null;
-        const offset = positionToOffset(text, p.position);
-        const found = wordAt(text, offset);
-        if (found === null || !found.word.startsWith('@'))
+        const predicate = request.view.semantic.predicateScopes
+            .get(request.view.file)
+            ?.get(request.found.word.slice(1));
+        if (predicate === undefined)
             return null;
-        let parsed;
+        const text = this.#openText(predicate.module.file) ?? predicate.module.source;
+        return {
+            uri: pathToFileURL(predicate.module.file).href,
+            range: spanRange(text, predicate.declaration.nameSpan),
+        };
+    }
+    #references(params) {
+        const request = this.#request(params);
+        if (request === null || !request.found.word.startsWith('@'))
+            return [];
+        const target = request.view.semantic.predicateScopes
+            .get(request.view.file)
+            ?.get(request.found.word.slice(1));
+        if (target === undefined)
+            return [];
+        const locations = [];
+        for (const module of request.view.semantic.graph.modules) {
+            const scope = request.view.semantic.predicateScopes.get(module.file);
+            for (const token of module.tokens) {
+                if (token.kind !== 'at-identifier')
+                    continue;
+                const resolved = scope?.get(token.text.slice(1));
+                if (resolved?.id !== target.id)
+                    continue;
+                locations.push({
+                    uri: pathToFileURL(module.file).href,
+                    range: spanRange(module.source, token.span),
+                });
+            }
+        }
+        return locations;
+    }
+    #symbols(params) {
+        const request = params;
+        const text = this.#documents.get(request.textDocument.uri);
+        if (text === undefined)
+            return [];
         try {
-            parsed = parseSyqlFile('doc', text);
+            const parsed = parseSyqlSyntaxFile(uriToPath(request.textDocument.uri), text);
+            return parsed.declarations.map((declaration) => ({
+                name: declaration.name,
+                kind: declaration.kind === 'query' ? 12 : 12,
+                range: spanRange(text, declaration.span),
+                selectionRange: spanRange(text, declaration.nameSpan),
+            }));
         }
         catch {
-            return null;
+            return [];
         }
-        const fragment = parsed.fragments.find((f) => f.name === found.word.slice(1));
-        if (fragment === undefined)
-            return null;
-        const start = offsetToPosition(text, fragment.offset);
-        return {
-            uri: p.textDocument.uri,
-            range: {
-                start,
-                end: {
-                    line: start.line,
-                    character: start.character + 'fragment '.length + fragment.name.length,
+    }
+    #formatting(params) {
+        const request = params;
+        const text = this.#documents.get(request.textDocument.uri);
+        if (text === undefined)
+            return [];
+        try {
+            const formatted = formatSyql(uriToPath(request.textDocument.uri), text);
+            if (formatted === text)
+                return [];
+            return [
+                {
+                    range: {
+                        start: { line: 0, character: 0 },
+                        end: offsetToPosition(text, text.length),
+                    },
+                    newText: formatted,
                 },
-            },
-        };
+            ];
+        }
+        catch {
+            return [];
+        }
     }
 }
-// ---------------------------------------------------------------------------
-// stdio transport (Content-Length framing)
-// ---------------------------------------------------------------------------
-/** Run the language server over stdio until `exit`. */
+/** Run the LSP over Content-Length-framed JSON-RPC stdio. */
 export async function runLspStdio() {
     const server = new SyqlLanguageServer();
     let buffer = Buffer.alloc(0);
@@ -356,21 +523,28 @@ export async function runLspStdio() {
                 continue;
             }
             const length = Number.parseInt(lengthMatch[1], 10);
-            if (buffer.length < headerEnd + 4 + length)
+            const bodyStart = headerEnd + 4;
+            if (buffer.length < bodyStart + length)
                 break;
-            const body = buffer.subarray(headerEnd + 4, headerEnd + 4 + length);
-            buffer = buffer.subarray(headerEnd + 4 + length);
-            let message;
+            const body = buffer
+                .subarray(bodyStart, bodyStart + length)
+                .toString('utf8');
+            buffer = buffer.subarray(bodyStart + length);
+            let incoming;
             try {
-                message = JSON.parse(body.toString('utf8'));
+                incoming = JSON.parse(body);
             }
             catch {
+                write({
+                    jsonrpc: '2.0',
+                    error: { code: -32700, message: 'parse error' },
+                });
                 continue;
             }
-            if (message.method === 'exit')
-                return;
-            for (const outgoing of server.handle(message))
+            for (const outgoing of server.handle(incoming))
                 write(outgoing);
+            if (incoming.method === 'exit')
+                return;
         }
     }
 }