@greenpandastudios/aug-cli 0.19.0

package/src/interceptors.js

@@ -0,0 +1,70 @@
+/** Lower the checked written order to named entry points. */
+export function interceptorChain(name, layers) {
+    return { body: layers.length ? name + '_body' : name,
+        entries: layers.map((layer, index) => ({ layer, name: index ? name + '_layer_' + index : name,
+            next: index + 1 === layers.length ? name + '_body' : name + '_layer_' + (index + 1) })) };
+}
+/** Conservative delegation facts from syntax, never from comments or text matching. */
+export function interceptorBehavior(body) {
+    const contains = (value, predicate) => {
+        if (!value || typeof value !== 'object')
+            return false;
+        if (Array.isArray(value))
+            return value.some(child => contains(child, predicate));
+        const node = value;
+        return predicate(node) || Object.entries(node).some(([key, child]) => key !== 'span' && contains(child, predicate));
+    };
+    const isNext = (value) => {
+        const node = value;
+        return node?.kind === 'call' && node.callee.kind === 'name' && node.callee.name === 'next';
+    };
+    const mayFail = (value) => contains(value, node => node.kind === 'call' || node.kind === 'binary' && node.op === '/');
+    const expression = (stmt) => stmt.kind === 'return' ? stmt.value : stmt.kind === 'expr' ? stmt.expr : stmt.kind === 'assign' ? stmt.value : undefined;
+    const direct = body.findIndex(stmt => isNext(expression(stmt)));
+    const priorMayExit = direct < 0 || body.slice(0, direct).some(stmt => !(stmt.kind === 'assign' && stmt.target.kind === 'name' && !mayFail(stmt.value) ||
+        stmt.kind === 'expr' && stmt.expr.kind === 'literal'));
+    const call = direct < 0 ? undefined : expression(body[direct]);
+    return { delegates: contains(body, isNext), mayShortCircuit: priorMayExit ||
+            call?.kind === 'call' && call.args.some(mayFail) || direct < 0 };
+}
+/**
+ * Owns target-to-around mapping, hidden dependency forwarding, and next transfer
+ * layout. The native emitter only allocates slots and emits runtime operations.
+ */
+export class InterceptorInvocation {
+    layer;
+    params;
+    original;
+    target;
+    receiver;
+    constructor(layer, params, original, target, receiver) {
+        this.layer = layer;
+        this.params = params;
+        this.original = original;
+        this.target = target;
+        this.receiver = receiver;
+    }
+    dependencies() {
+        return this.layer.constructorInputIndices.map(index => index >= 0 ? this.original[index] : undefined);
+    }
+    inputs() {
+        return this.layer.around.params.map((param, index) => {
+            const target = this.layer.argumentIndices[index];
+            const source = target ?? this.layer.argumentInjectionIndices[index];
+            return { name: param.name, slot: source !== undefined && source >= 0 ? this.original[source] : undefined,
+                reuseOwnedSlot: param.ownership === 'own' && target !== undefined };
+        });
+    }
+    forward(sourceIndices, values) {
+        const args = [...this.original];
+        sourceIndices.forEach((source, index) => {
+            const target = this.layer.argumentIndices[index];
+            if (source !== undefined && target !== undefined)
+                args[target] = values[source];
+        });
+        const transfers = this.params.flatMap((param, index) => param.ownership === 'own' ?
+            [{ original: this.original[index], replacement: args[index] }] : []);
+        return { args, transfers };
+    }
+    get around() { return this.layer.around; }
+}

package/src/javadoc.js

@@ -0,0 +1,67 @@
+function inline(text) {
+    return text
+        .replace(/\{@code\s+([^}]+)\}/g, (_, value) => `\`${value.trim()}\``)
+        .replace(/\{@link\s+([^}\s]+)(?:\s+([^}]+))?\}/g, (_, target, label) => `\`${(label ?? target).trim()}\``);
+}
+function format(lines) {
+    return inline(lines.join('\n').trim()).replace(/\n{3,}/g, '\n\n');
+}
+/** Read the closest immediately preceding Javadoc block, if there is one. */
+export function javadocBefore(source, offset) {
+    let before = source.slice(0, offset);
+    // Extern C declarations start their recorded span at the name after the prefix.
+    before = before.replace(/\b(?:extern\s+C(?:\s+value)?(?:\s+pure)?|fixture)\s*$/, '');
+    const end = before.lastIndexOf('*/');
+    if (end < 0 || before.slice(end + 2).trim())
+        return undefined;
+    const start = before.lastIndexOf('/**', end);
+    if (start < 0 || before.slice(start + 3, end).includes('*/'))
+        return undefined;
+    const raw = before.slice(start + 3, end);
+    const lines = raw.split(/\r?\n/).map(line => line.replace(/^\s*\* ?/, '').trimEnd())
+        .flatMap(line => line.split(/\s+(?=@(?:param|returns?|throws|exception|deprecated|see)\b)/));
+    const description = [];
+    const tags = [];
+    let current;
+    for (const line of lines) {
+        const tag = /^@([A-Za-z]+)\b\s*(.*)$/.exec(line);
+        if (tag) {
+            current = { name: tag[1], value: [tag[2]] };
+            tags.push(current);
+        }
+        else if (current)
+            current.value.push(line);
+        else
+            description.push(line);
+    }
+    const sections = [format(description)];
+    const parameters = new Map();
+    const throws = [];
+    for (const tag of tags) {
+        const value = format(tag.value);
+        if (tag.name === 'param') {
+            const match = /^([A-Za-z_][A-Za-z0-9_]*)\s*([\s\S]*)$/.exec(value);
+            if (match)
+                parameters.set(match[1], match[2].trim());
+        }
+        else if (tag.name === 'return' || tag.name === 'returns') {
+            sections.push(`**Returns** ${value}`);
+        }
+        else if (tag.name === 'throws' || tag.name === 'exception') {
+            const match = /^(\S+)\s*([\s\S]*)$/.exec(value);
+            if (match)
+                throws.push(`- \`${match[1]}\`${match[2] ? `: ${match[2].trim()}` : ''}`);
+        }
+        else if (tag.name === 'deprecated')
+            sections.push(`**Deprecated:** ${value}`);
+        else if (tag.name === 'see')
+            sections.push(`**See also:** ${value}`);
+    }
+    if (parameters.size)
+        sections.push('**Parameters**\n' +
+            [...parameters].map(([name, value]) => `- \`${name}\`${value ? `: ${value}` : ''}`).join('\n'));
+    if (throws.length)
+        sections.push('**Throws**\n' + throws.join('\n'));
+    const markdown = sections.filter(Boolean).join('\n\n');
+    return markdown ? { markdown, parameters, tags: tags.map(tag => ({ name: tag.name, value: format(tag.value) })) } : undefined;
+}

package/src/lexer.js

@@ -0,0 +1,199 @@
+export const reservedKeywords = [
+    'import', 'from', 'export', 'folder', 'bind', 'implement', 'with', 'to', 'class', 'interface',
+    'implements', 'extends', 'function', 'returns', 'throws', 'unless', 'return',
+    'throw', 'if', 'else', 'while', 'try', 'catch', 'unsafe', 'extern', 'C',
+    'resolve', 'own', 'borrow', 'true', 'false', 'null', 'interceptor',
+    'and', 'or', 'not', 'initialize', 'everything', 'test', 'when', 'it', 'pass', 'in', 'out', 'changes', 'uses', 'mutable', 'capability',
+    'record', 'for', 'match', 'some', 'shared', 'fresh', 'scoped', 'scope', 'composition', 'include', 'fixture',
+    'pure',
+    'optional', 'missing',
+    'freeze', 'as',
+    'endpoint', 'serve', 'streams', 'yield', 'handle',
+    'start', 'wait',
+    'always',
+    'lock',
+];
+const keywords = new Set(reservedKeywords);
+export function lex(file, source, comments = false) {
+    const tokens = [];
+    const diagnostics = [];
+    let index = 0;
+    let line = 1;
+    let column = 1;
+    const peek = (offset = 0) => source[index + offset] ?? '';
+    const advance = () => {
+        const char = source[index++] ?? '';
+        if (char === '\n') {
+            line++;
+            column = 1;
+        }
+        else {
+            column++;
+        }
+        return char;
+    };
+    const spanAt = (start, startLine, startColumn) => ({ file, start, end: index, line: startLine, column: startColumn });
+    const emit = (kind, value, start, startLine, startColumn) => tokens.push({ kind, value, span: spanAt(start, startLine, startColumn), endLine: line });
+    const error = (message, startLine, startColumn) => diagnostics.push({ file, line: startLine, column: startColumn, message, code: 'LEX' });
+    const markup = [];
+    while (index < source.length) {
+        const char = peek();
+        const mode = markup.at(-1);
+        if (mode?.mode === 'text' && char !== '<' && char !== '{') {
+            const start = index, startLine = line, startColumn = column;
+            while (peek() && peek() !== '<' && peek() !== '{')
+                advance();
+            emit('jsx_text', source.slice(start, index), start, startLine, startColumn);
+            continue;
+        }
+        if (/\s/.test(char)) {
+            advance();
+            continue;
+        }
+        const start = index;
+        const startLine = line;
+        const startColumn = column;
+        if (mode?.mode === 'text' && char === '<') {
+            advance();
+            mode.closing = peek() === '/';
+            if (mode.closing)
+                advance();
+            else
+                mode.depth++;
+            mode.mode = 'tag';
+            emit(mode.closing ? 'jsx_close' : 'jsx_open', mode.closing ? '</' : '<', start, startLine, startColumn);
+            continue;
+        }
+        if (mode?.mode === 'tag') {
+            if (char === '>' || char === '/' && peek(1) === '>') {
+                const self = char === '/';
+                advance();
+                if (self)
+                    advance();
+                if (self || mode.closing)
+                    mode.depth--;
+                emit(self ? 'jsx_self' : mode.closing ? 'jsx_close_end' : 'jsx_end', self ? '/>' : '>', start, startLine, startColumn);
+                mode.mode = 'text';
+                if (mode.depth === 0)
+                    markup.pop();
+                continue;
+            }
+            if (/[A-Za-z_]/.test(char)) {
+                let value = '';
+                while (/[A-Za-z0-9_:-]/.test(peek()))
+                    value += advance();
+                emit('jsx_name', value, start, startLine, startColumn);
+                continue;
+            }
+        }
+        if (mode && mode.mode !== 'expression' && char === '{') {
+            mode.resume = mode.mode;
+            mode.mode = 'expression';
+            mode.braces = 0;
+        }
+        if (char === '<' && (/[A-Za-z_]/.test(peek(1)) || peek(1) === '>') &&
+            (!tokens.length || ['return', '=', 'to', '(', ',', '[', '{', ':', 'yield'].includes(tokens.at(-1).kind))) {
+            advance();
+            markup.push({ mode: 'tag', braces: 0, depth: 1, closing: false });
+            emit('jsx_open', '<', start, startLine, startColumn);
+            continue;
+        }
+        if (mode?.mode === 'expression') {
+            if (char === '{')
+                mode.braces++;
+            if (char === '}' && --mode.braces === 0) {
+                mode.mode = mode.resume;
+                mode.resume = undefined;
+            }
+        }
+        if (char === '#' || (char === '/' && peek(1) === '/')) {
+            while (peek() && peek() !== '\n')
+                advance();
+            if (comments)
+                emit('comment', source.slice(start, index), start, startLine, startColumn);
+            continue;
+        }
+        if (char === '/' && peek(1) === '*') {
+            advance();
+            advance();
+            while (peek() && !(peek() === '*' && peek(1) === '/'))
+                advance();
+            if (!peek())
+                error('Unterminated block comment', startLine, startColumn);
+            else {
+                advance();
+                advance();
+            }
+            if (comments)
+                emit('comment', source.slice(start, index), start, startLine, startColumn);
+            continue;
+        }
+        if (/[A-Za-z_]/.test(char)) {
+            let value = '';
+            while (/[A-Za-z0-9_]/.test(peek()))
+                value += advance();
+            emit(keywords.has(value) ? value : 'identifier', value, start, startLine, startColumn);
+            if (value === 'missing')
+                diagnostics.push({ file, line: startLine, column: startColumn, code: 'SYNTAX', message: 'Use null instead of missing; optional values have only a value or null' });
+            continue;
+        }
+        if (/[0-9]/.test(char)) {
+            let value = '';
+            while (/[0-9]/.test(peek()))
+                value += advance();
+            if (peek() === '.' && /[0-9]/.test(peek(1))) {
+                value += advance();
+                while (/[0-9]/.test(peek()))
+                    value += advance();
+            }
+            emit('number', value, start, startLine, startColumn);
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            const quote = advance();
+            let value = '';
+            let closed = false;
+            while (peek()) {
+                if (peek() === quote) {
+                    advance();
+                    closed = true;
+                    break;
+                }
+                if (peek() === '\\') {
+                    advance();
+                    const escape = advance();
+                    value += { n: '\n', r: '\r', t: '\t', '0': '\0', '\\': '\\', '"': '"', "'": "'" }[escape] ?? escape;
+                }
+                else
+                    value += advance();
+            }
+            if (!closed)
+                error('Unterminated string literal', startLine, startColumn);
+            emit('string', value, start, startLine, startColumn);
+            continue;
+        }
+        const two = char + peek(1);
+        if (['==', '!=', '<=', '>=', '&&', '||', '->', '=>'].includes(two)) {
+            if (['&&', '||', '=>'].includes(two))
+                diagnostics.push({ file, line: startLine, column: startColumn, code: 'SYNTAX',
+                    message: two === '=>' ? 'Use an initialize block inside the class or record instead of =>'
+                        : `Use ${two === '&&' ? 'and' : 'or'} instead of ${two}; boolean operators use words` });
+            advance();
+            advance();
+            emit(two, two, start, startLine, startColumn);
+            continue;
+        }
+        if ('{}();,.:<>?=+-*/![]'.includes(char)) {
+            if (char === '!')
+                diagnostics.push({ file, line: startLine, column: startColumn, code: 'SYNTAX',
+                    message: 'Use not instead of !; boolean operators use words' });
+            advance();
+            emit(char, char, start, startLine, startColumn);
+            continue;
+        }
+        advance();
+        error(`Unexpected character ${JSON.stringify(char)}`, startLine, startColumn);
+    }
+    tokens.push({ kind: 'eof', value: '', span: { file, start: index, end: index, line, column }, endLine: line });
+    return { tokens, diagnostics };
+}

package/src/libraries.js

@@ -0,0 +1,31 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join, relative } from 'node:path';
+/** The checked-in sources and installed packages expose the same August module paths. */
+export function standardLibraries() {
+    const bundled = join(import.meta.dirname, 'stdlib');
+    if (existsSync(bundled))
+        return { root: bundled, modules: new Map() };
+    const require = createRequire(import.meta.url);
+    const version = JSON.parse(readFileSync(join(import.meta.dirname, '..', 'package.json'), 'utf8')).version;
+    const load = (name) => {
+        const file = require.resolve(`@greenpandastudios/aug-${name}/aug-package.json`);
+        const manifest = JSON.parse(readFileSync(file, 'utf8'));
+        if (manifest.format !== 1 || manifest.version !== version || manifest.compiler !== version)
+            throw new Error(`August ${name} must match compiler ${version}; reinstall the CLI and its pinned libraries.`);
+        return join(dirname(file), manifest.source);
+    };
+    return { root: load('stdlib'), modules: new Map([['web', load('web')], ['crypto', load('crypto')]]) };
+}
+export function libraryChild(libraries, folder, name) {
+    return folder === libraries.root ? libraries.modules.get(name) ?? join(folder, name) : join(folder, name);
+}
+/** Stable identities and import suggestions are independent of npm's disk layout. */
+export function libraryRelative(libraries, file) {
+    for (const [name, folder] of libraries.modules) {
+        const path = relative(folder, file);
+        if (path === '' || (!path.startsWith('..') && !path.startsWith('/')))
+            return join(name, path);
+    }
+    return relative(libraries.root, file);
+}

package/src/lsp.js

@@ -0,0 +1,180 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { SemanticWorkspace } from "./semantic.js";
+import { diagnosticHelp } from "./help.js";
+import { compilerVersion } from "./package-manager.js";
+const tokenTypes = ['class', 'interface', 'function', 'method', 'property', 'variable', 'parameter', 'type', 'keyword', 'decorator', 'typeParameter'];
+const offsetAt = (source, position) => source.split('\n').slice(0, position.line).reduce((offset, line) => offset + line.length + 1, 0) + position.character;
+const positionAt = (source, offset) => {
+    const lines = source.slice(0, offset).split('\n');
+    return { line: lines.length - 1, character: lines.at(-1).length };
+};
+/** LSP 3.17, full-text synchronization and immutable cached semantic revisions. */
+export async function runLanguageServer(root) {
+    const workspace = new SemanticWorkspace(root);
+    const open = new Map();
+    const cancelled = new Set();
+    const send = (message) => { const data = Buffer.from(JSON.stringify(message)); process.stdout.write(`Content-Length: ${data.length}\r\n\r\n`); process.stdout.write(data); };
+    const document = (uri) => workspace.document(fileURLToPath(uri), open.get(uri));
+    const publish = () => {
+        for (const [uri, edit] of open) {
+            const view = document(uri);
+            send({ jsonrpc: '2.0', method: 'textDocument/publishDiagnostics', params: { uri, version: edit.version,
+                    diagnostics: view.diagnostics.filter(issue => issue.file === fileURLToPath(uri)).map(issue => ({
+                        range: { start: { line: issue.line - 1, character: issue.column - 1 }, end: { line: issue.line - 1, character: issue.column } },
+                        message: issue.message, severity: issue.severity === 'warning' ? 2 : 1, code: issue.code, source: 'AugScript',
+                        data: { help: diagnosticHelp[issue.code] }
+                    })) } });
+        }
+    };
+    let publishTimer;
+    const schedule = () => { if (publishTimer)
+        clearTimeout(publishTimer); publishTimer = setTimeout(() => { try {
+        publish();
+    }
+    catch (error) {
+        process.stderr.write(String(error) + '\n');
+    } }, 75); };
+    let shutdown = false;
+    const handle = (message) => {
+        const params = message.params ?? {};
+        let result = null;
+        if (message.method === '$/cancelRequest') {
+            cancelled.add(params.id);
+            return;
+        }
+        if (message.id !== undefined && cancelled.delete(message.id)) {
+            send({ jsonrpc: '2.0', id: message.id, error: { code: -32800, message: 'Request cancelled' } });
+            return;
+        }
+        if (message.method === 'initialize')
+            result = { capabilities: {
+                    textDocumentSync: { openClose: true, change: 1 }, hoverProvider: true, completionProvider: { triggerCharacters: ['.', '(', '=', ' '] },
+                    definitionProvider: true, documentFormattingProvider: true, codeActionProvider: true,
+                    semanticTokensProvider: { legend: { tokenTypes, tokenModifiers: ['declaration'] }, full: true },
+                }, serverInfo: { name: 'AugScript', version: compilerVersion() } };
+        else if (message.method === 'shutdown')
+            shutdown = true;
+        else if (message.method === 'exit') {
+            process.exitCode = shutdown ? 0 : 1;
+            process.stdin.destroy();
+            return;
+        }
+        else if (message.method === 'textDocument/didOpen') {
+            const doc = params.textDocument;
+            open.set(doc.uri, { text: doc.text, version: doc.version });
+            workspace.document(fileURLToPath(doc.uri), open.get(doc.uri));
+            schedule();
+        }
+        else if (message.method === 'textDocument/didChange') {
+            const doc = params.textDocument, previous = open.get(doc.uri);
+            if (!previous || doc.version > previous.version) {
+                open.set(doc.uri, { text: params.contentChanges.at(-1).text, version: doc.version });
+                workspace.document(fileURLToPath(doc.uri), open.get(doc.uri));
+                schedule();
+            }
+        }
+        else if (message.method === 'textDocument/didClose') {
+            open.delete(params.textDocument.uri);
+            workspace.close(fileURLToPath(params.textDocument.uri));
+            send({ jsonrpc: '2.0', method: 'textDocument/publishDiagnostics', params: { uri: params.textDocument.uri, diagnostics: [] } });
+        }
+        else if (message.method === 'workspace/didChangeWatchedFiles')
+            schedule();
+        else if (message.method === 'aug/stats')
+            result = { ...workspace.stats };
+        else if (message.method === 'aug/editor') {
+            const uri = params.uri;
+            if (params.text !== undefined) {
+                const previous = open.get(uri);
+                if (!previous || params.version >= previous.version)
+                    open.set(uri, { text: params.text, version: params.version });
+            }
+            const view = document(uri), offset = params.offset ?? 0;
+            result = params.command === 'hover' ? view.hover(offset) ?? null : params.command === 'complete' ? view.complete(offset) :
+                params.command === 'fixes' ? view.fixes() : params.command === 'semantic-tokens' ? view.tokens() :
+                    params.command === 'format' ? view.format() : params.command === 'definition' ? view.definition(offset) ?? null : params.command === 'diagnostics' ? view.diagnostics.map(issue => ({ ...issue, help: diagnosticHelp[issue.code] })) : view.describe(params.options);
+        }
+        else if (message.method.startsWith('textDocument/')) {
+            const view = document(params.textDocument.uri);
+            const offset = params.position ? offsetAt(view.source, params.position) : 0;
+            if (message.method === 'textDocument/hover') {
+                const hover = view.hover(offset);
+                result = hover ? { contents: { kind: 'markdown', value: `\`\`\`augscript\n${hover.detail}\n\`\`\`\n\n${hover.documentation ?? ''}` } } : null;
+            }
+            else if (message.method === 'textDocument/completion')
+                result = view.complete(offset).map(item => ({ label: item.label,
+                    kind: { method: 2, function: 3, variable: 6, class: 7, interface: 8, property: 10, keyword: 14, snippet: 15, type: 25 }[item.kind] ?? 6,
+                    detail: item.detail, documentation: { kind: 'markdown', value: item.documentation ?? '' }, insertText: item.insertText ?? item.label,
+                    insertTextFormat: item.kind === 'snippet' ? 2 : 1 }));
+            else if (message.method === 'textDocument/definition') {
+                const target = view.definition(offset);
+                result = target ? { uri: pathToFileURL(target.file).href,
+                    range: { start: { line: target.line - 1, character: target.column - 1 }, end: { line: target.line - 1, character: target.column } } } : null;
+            }
+            else if (message.method === 'textDocument/formatting')
+                result = [{ range: { start: { line: 0, character: 0 }, end: positionAt(view.source, view.source.length) }, newText: view.format() }];
+            else if (message.method === 'textDocument/codeAction')
+                result = view.fixes().map(fix => {
+                    const changes = {};
+                    for (const edit of fix.edits) {
+                        const source = workspace.document(edit.file).source, uri = pathToFileURL(edit.file).href;
+                        (changes[uri] ??= []).push({ range: { start: positionAt(source, edit.start), end: positionAt(source, edit.end) }, newText: edit.text });
+                    }
+                    return { title: fix.title, kind: 'quickfix', edit: { changes } };
+                });
+            else if (message.method === 'textDocument/semanticTokens/full') {
+                let line = 0, column = 0;
+                const data = [];
+                for (const token of view.tokens().sort((a, b) => a.line - b.line || a.start - b.start)) {
+                    data.push(token.line - line, token.line === line ? token.start - column : token.start, token.length, tokenTypes.indexOf(token.type), token.declaration ? 1 : 0);
+                    line = token.line;
+                    column = token.start;
+                }
+                result = { data, resultId: view.revision };
+            }
+        }
+        else if (message.id !== undefined) {
+            send({ jsonrpc: '2.0', id: message.id, error: { code: -32601, message: `Unsupported method ${message.method}` } });
+            return;
+        }
+        if (message.id !== undefined)
+            send({ jsonrpc: '2.0', id: message.id, result });
+    };
+    let buffer = Buffer.alloc(0);
+    await new Promise(resolve => {
+        process.stdin.on('data', chunk => {
+            buffer = Buffer.concat([buffer, chunk]);
+            while (true) {
+                const headerEnd = buffer.indexOf('\r\n\r\n');
+                if (headerEnd < 0)
+                    break;
+                const length = Number(/Content-Length:\s*(\d+)/i.exec(buffer.subarray(0, headerEnd).toString())?.[1]);
+                if (!Number.isSafeInteger(length) || length < 0 || length > 16 * 1024 * 1024) {
+                    process.stderr.write('Invalid LSP frame\n');
+                    process.stdin.destroy();
+                    break;
+                }
+                if (buffer.length < headerEnd + 4 + length)
+                    break;
+                const payload = buffer.subarray(headerEnd + 4, headerEnd + 4 + length);
+                buffer = buffer.subarray(headerEnd + 4 + length);
+                let message;
+                try {
+                    message = JSON.parse(payload.toString('utf8'));
+                    handle(message);
+                }
+                catch (error) {
+                    if (message?.id !== undefined)
+                        send({ jsonrpc: '2.0', id: message.id, error: { code: -32603, message: String(error) } });
+                    else
+                        process.stderr.write(String(error) + '\n');
+                }
+            }
+        });
+        process.stdin.on('close', resolve);
+        process.stdin.on('end', resolve);
+    });
+    if (publishTimer)
+        clearTimeout(publishTimer);
+    return process.exitCode === 1 ? 1 : 0;
+}