@tiaforge-ui/sinter 0.0.0-stage → 0.1.0

package/dist/ir.js

@@ -0,0 +1,121 @@
+// IR v1: the only contract between compiler and runtime. Plain JSON; every
+// expression is an index into the page module's function table.
+export const IR_VERSION = 1;
+/** Structural check of an IR against v1; returns problems (empty when valid). */
+export function validateIR(ir, fnCount) {
+    const errs = [];
+    const o = ir;
+    const fn = (v, at, nullable = true) => {
+        if (v === null && nullable)
+            return;
+        if (v === undefined && nullable)
+            return;
+        if (!Number.isInteger(v) || v < 0 || v >= fnCount)
+            errs.push(`${at}: bad function index ${String(v)}`);
+    };
+    const url = (u, at) => {
+        if (!Array.isArray(u) || !u.length || typeof u[0] !== 'string') {
+            errs.push(`${at}: URL template must start with a literal`);
+            return;
+        }
+        u.forEach((p, i) => (typeof p === 'string' ? undefined : fn(p, `${at}[${i}]`, false)));
+    };
+    if (!o || o.v !== 1)
+        return ['v must be 1'];
+    for (const k of ['resources', 'syncs', 'roots', 'templates', 'actions'])
+        if (!Array.isArray(o[k]))
+            errs.push(`${k} must be an array`);
+    if (errs.length)
+        return errs;
+    const names = new Set();
+    o.resources.forEach((r, i) => {
+        const at = `resources[${i}]`;
+        if (!/^[A-Za-z_]\w*$/.test(r.name))
+            errs.push(`${at}: bad name`);
+        if (names.has(r.name))
+            errs.push(`${at}: duplicate name ${r.name}`);
+        names.add(r.name);
+        url(r.src, `${at}.src`);
+        fn(r.when, `${at}.when`);
+        if (r.paginate) {
+            if (!['keyset', 'offset', 'append'].includes(r.paginate.mode))
+                errs.push(`${at}: bad paginate mode`);
+            fn(r.paginate.cursor, `${at}.paginate.cursor`);
+        }
+    });
+    o.syncs.forEach((s, i) => {
+        url(s.src, `syncs[${i}].src`);
+        s.events.forEach((e, j) => {
+            const at = `syncs[${i}].events[${j}]`;
+            if (!names.has(e.resource))
+                errs.push(`${at}: unknown resource ${e.resource}`);
+            if (!['upsert', 'patch', 'remove', 'refetch'].includes(e.op))
+                errs.push(`${at}: bad op`);
+            fn(e.item, `${at}.item`);
+            fn(e.set, `${at}.set`);
+            fn(e.when, `${at}.when`);
+        });
+    });
+    const kinds = new Set(['text', 'attr', 'class', 'style', 'show', 'model', 'prop', 'for', 'if', 'else', 'on']);
+    const nodes = (list, at, inTemplate) => list.forEach((n, i) => {
+        const a = `${at}[${i}]`;
+        if (inTemplate ? !Array.isArray(n.path) : !Number.isInteger(n.id))
+            errs.push(`${a}: needs ${inTemplate ? 'path' : 'id'}`);
+        if (n.p >= i)
+            errs.push(`${a}: parent scope must come first`);
+        if (n.state !== undefined) {
+            fn(n.state, `${a}.state`, false);
+            if (!Number.isInteger(n.sid))
+                errs.push(`${a}: state needs sid`);
+        }
+        n.b.forEach((b, j) => {
+            const ba = `${a}.b[${j}]`;
+            if (!kinds.has(b.k))
+                errs.push(`${ba}: bad kind ${b.k}`);
+            if (b.k === 'on') {
+                if (!b.n)
+                    errs.push(`${ba}: on needs an event name`);
+                if (b.x !== undefined) {
+                    if (!o.actions[b.x])
+                        errs.push(`${ba}: bad action ${b.x}`);
+                }
+                else
+                    fn(b.f, `${ba}.f`, false);
+            }
+            else if (b.k === 'for' || b.k === 'if' || b.k === 'else') {
+                if (!o.templates[b.x])
+                    errs.push(`${ba}: bad template ${b.x}`);
+                if (b.k !== 'else')
+                    fn(b.f, `${ba}.f`, false);
+                if (b.y !== undefined && !list[b.y]?.b.some((x) => x.k === 'else'))
+                    errs.push(`${ba}: y must point at an else node`);
+            }
+            else
+                fn(b.f, `${ba}.f`, false);
+            if (b.k === 'model')
+                fn(b.a, `${ba}.a`, false);
+            for (const d of [...(b.d ?? []), ...(b.w ?? [])])
+                if (typeof d !== 'string' || !d)
+                    errs.push(`${ba}: bad path`);
+        });
+    });
+    nodes(o.roots, 'roots', false);
+    o.templates.forEach((t, i) => {
+        if (t.id !== i)
+            errs.push(`templates[${i}]: id must equal its index`);
+        nodes(t.nodes, `templates[${i}].nodes`, true);
+        fn(t.key, `templates[${i}].key`);
+        fn(t.find, `templates[${i}].find`);
+    });
+    o.actions.forEach((a, i) => {
+        const at = `actions[${i}]`;
+        if (!['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].includes(a.method))
+            errs.push(`${at}: bad method`);
+        if (!['block', 'queue', 'latest'].includes(a.concurrency))
+            errs.push(`${at}: bad concurrency`);
+        url(a.url, `${at}.url`);
+        for (const k of ['body', 'optimistic', 'then', 'catch'])
+            fn(a[k], `${at}.${k}`);
+    });
+    return errs;
+}

package/dist/lsp/quickfix.d.ts

@@ -0,0 +1,15 @@
+import type { Range } from './server.js';
+export interface TextEdit {
+    range: Range;
+    newText: string;
+}
+/** The suggestion and the misspelled name it replaces, from a diagnostic's message. */
+export declare function suggestionOf(message: string): {
+    wrong: string;
+    right: string;
+} | null;
+/**
+ * The edit for a diagnostic: the occurrence of the misspelled name on the diagnostic's
+ * lines that is nearest its start, replaced by the suggestion.
+ */
+export declare function didYouMeanEdit(text: string, range: Range, message: string): TextEdit | null;

package/dist/lsp/quickfix.js

@@ -0,0 +1,58 @@
+function distance(a, b) {
+    const prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let diag = prev[0];
+        prev[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = prev[j];
+            prev[j] = Math.min(prev[j] + 1, prev[j - 1] + 1, diag + (a[i - 1] === b[j - 1] ? 0 : 1));
+            diag = tmp;
+        }
+    }
+    return prev[b.length];
+}
+/** The suggestion and the misspelled name it replaces, from a diagnostic's message. */
+export function suggestionOf(message) {
+    const m = /Did you mean [`']([^`']+)[`']\?/.exec(message);
+    if (!m)
+        return null;
+    const right = m[1];
+    const before = message.slice(0, m.index);
+    let best = null;
+    for (const q of before.matchAll(/`([^`]+)`|'([^']+)'/g)) {
+        // `m.inbox_titel`, `$meta.contacts.loadng`: the suggestion replaces the last part
+        const whole = q[1] ?? q[2];
+        const wrong = /^[\w$-]+$/.test(right) ? whole.split(/[.\s/]/).pop() : whole;
+        if (!wrong || wrong === right)
+            continue;
+        const d = distance(wrong, right);
+        if (!best || d < best.d)
+            best = { wrong, d };
+    }
+    return best ? { wrong: best.wrong, right } : null;
+}
+/**
+ * The edit for a diagnostic: the occurrence of the misspelled name on the diagnostic's
+ * lines that is nearest its start, replaced by the suggestion.
+ */
+export function didYouMeanEdit(text, range, message) {
+    const s = suggestionOf(message);
+    if (!s)
+        return null;
+    const lines = text.split('\n');
+    let best = null;
+    for (let l = range.start.line; l <= range.end.line && l < lines.length; l++) {
+        const t = lines[l];
+        for (let at = t.indexOf(s.wrong); at >= 0; at = t.indexOf(s.wrong, at + 1)) {
+            // a whole name, not part of a longer one
+            if (/[\w$]/.test(t[at - 1] ?? '') || /[\w$]/.test(t[at + s.wrong.length] ?? ''))
+                continue;
+            const d = l === range.start.line ? Math.abs(at - range.start.character) : 1e6 + at;
+            if (!best || d < best.d)
+                best = { line: l, at, d };
+        }
+    }
+    if (!best)
+        return null;
+    return { range: { start: { line: best.line, character: best.at }, end: { line: best.line, character: best.at + s.wrong.length } }, newText: s.right };
+}

package/dist/lsp/rpc.d.ts

@@ -0,0 +1,31 @@
+import type { Readable, Writable } from 'node:stream';
+type Handler = (params: any) => unknown;
+export declare class RpcError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export declare class Connection {
+    private output;
+    private buf;
+    private nextId;
+    private pending;
+    private requests;
+    private notifications;
+    private closed;
+    /** called for a notification nothing handles */
+    onUnhandled?: (method: string, params: unknown) => void;
+    onClose?: () => void;
+    /** answers a request nothing handles (default: a method-not-found error) */
+    requestFallback?: (method: string, params: unknown) => unknown;
+    constructor(input: Readable, output: Writable);
+    onRequest(method: string, handler: Handler): void;
+    onNotification(method: string, handler: Handler): void;
+    request<T = any>(method: string, params?: unknown): Promise<T>;
+    notify(method: string, params?: unknown): void;
+    private send;
+    private receive;
+    private dispatch;
+    private log;
+    close(): void;
+}
+export {};

package/dist/lsp/rpc.js

@@ -0,0 +1,120 @@
+export class RpcError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+export class Connection {
+    output;
+    buf = Buffer.alloc(0);
+    nextId = 1;
+    pending = new Map();
+    requests = new Map();
+    notifications = new Map();
+    closed = false;
+    /** called for a notification nothing handles */
+    onUnhandled;
+    onClose;
+    /** answers a request nothing handles (default: a method-not-found error) */
+    requestFallback;
+    constructor(input, output) {
+        this.output = output;
+        input.on('data', (chunk) => this.receive(chunk));
+        input.on('end', () => this.close());
+        input.on('close', () => this.close());
+    }
+    onRequest(method, handler) { this.requests.set(method, handler); }
+    onNotification(method, handler) { this.notifications.set(method, handler); }
+    request(method, params) {
+        if (this.closed)
+            return Promise.reject(new Error(`connection closed (${method})`));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.send({ id, method, params });
+        });
+    }
+    notify(method, params) {
+        if (!this.closed)
+            this.send({ method, params });
+    }
+    send(message) {
+        const body = JSON.stringify({ jsonrpc: '2.0', ...message });
+        this.output.write(`Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`);
+    }
+    receive(chunk) {
+        this.buf = this.buf.length ? Buffer.concat([this.buf, chunk]) : chunk;
+        for (;;) {
+            const end = this.buf.indexOf('\r\n\r\n');
+            if (end < 0)
+                return;
+            const m = /Content-Length:\s*(\d+)/i.exec(this.buf.subarray(0, end).toString('ascii'));
+            if (!m) {
+                this.buf = this.buf.subarray(end + 4);
+                continue;
+            }
+            const len = Number(m[1]);
+            if (this.buf.length < end + 4 + len)
+                return;
+            const body = this.buf.subarray(end + 4, end + 4 + len).toString('utf8');
+            this.buf = this.buf.subarray(end + 4 + len);
+            let msg;
+            try {
+                msg = JSON.parse(body);
+            }
+            catch {
+                continue;
+            }
+            this.dispatch(msg);
+        }
+    }
+    dispatch(msg) {
+        if (msg.method === undefined) {
+            const p = this.pending.get(msg.id);
+            if (!p)
+                return;
+            this.pending.delete(msg.id);
+            if (msg.error)
+                p.reject(new RpcError(msg.error.code, msg.error.message));
+            else
+                p.resolve(msg.result ?? null);
+            return;
+        }
+        if (msg.id === undefined) {
+            const h = this.notifications.get(msg.method);
+            if (h) {
+                try {
+                    void Promise.resolve(h(msg.params)).catch((e) => this.log(msg.method, e));
+                }
+                catch (e) {
+                    this.log(msg.method, e);
+                }
+            }
+            else
+                this.onUnhandled?.(msg.method, msg.params);
+            return;
+        }
+        const fallback = this.requestFallback;
+        const h = this.requests.get(msg.method) ?? (fallback && ((params) => fallback(msg.method, params)));
+        if (!h) {
+            this.send({ id: msg.id, error: { code: -32601, message: `unhandled method ${msg.method}` } });
+            return;
+        }
+        Promise.resolve()
+            .then(() => h(msg.params))
+            .then((result) => this.send({ id: msg.id, result: result ?? null }), (e) => this.send({ id: msg.id, error: { code: e instanceof RpcError ? e.code : -32603, message: e instanceof Error ? e.message : String(e) } }));
+    }
+    log(method, e) {
+        process.stderr.write(`sinter lsp: ${method}: ${e instanceof Error ? e.stack ?? e.message : String(e)}\n`);
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        for (const p of this.pending.values())
+            p.reject(new Error('connection closed'));
+        this.pending.clear();
+        this.onClose?.();
+    }
+}

package/dist/lsp/server.d.ts

@@ -0,0 +1,36 @@
+import type { Readable, Writable } from 'node:stream';
+import { type Diagnostic } from '../compiler/index.js';
+import { Connection } from './rpc.js';
+/** How long typing must pause before TypeScript checks the pages. */
+export declare const TYPECHECK_DELAY = 300;
+export interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface LspDiagnostic {
+    range: Range;
+    severity: 1 | 2;
+    code: string;
+    codeDescription: {
+        href: string;
+    };
+    source: 'sinter';
+    message: string;
+}
+/** The range a diagnostic underlines: the name or word at its position, else one character. */
+export declare function rangeOf(text: string, line: number, col: number): Range;
+export declare function toLsp(d: Diagnostic, text: string): LspDiagnostic;
+export interface ServerOptions {
+    exit?: (code: number) => void;
+    /** milliseconds between the last change and the type check (default TYPECHECK_DELAY) */
+    typecheckDelay?: number;
+    /** TypeScript's `tsc` script for every project (default: resolved from each project) */
+    tsc?: string;
+}
+export declare function startServer(input: Readable, output: Writable, o?: ServerOptions): Connection;
+/** The `src` of an `<sn-include>` when the 0-based position is inside its value, else null. */
+export declare function includeAt(text: string, line: number, character: number): string | null;

package/dist/lsp/server.js

@@ -0,0 +1,281 @@
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { CODES, docsUrl } from '../compiler/index.js';
+import { check, findTsc } from '../check/index.js';
+import { Connection } from './rpc.js';
+import { existsSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { didYouMeanEdit } from './quickfix.js';
+import { TypeScriptBridge, typescriptMajor } from './typescript.js';
+import { Workspace } from './workspace.js';
+/** How long typing must pause before TypeScript checks the pages. */
+export const TYPECHECK_DELAY = 300;
+/** The range a diagnostic underlines: the name or word at its position, else one character. */
+export function rangeOf(text, line, col) {
+    const lines = text.split('\n');
+    const l = Math.max(0, Math.min(line - 1, lines.length - 1));
+    const s = lines[l] ?? '';
+    const c = Math.max(0, Math.min(col - 1, s.length));
+    const m = /^[\w$-]+/.exec(s.slice(c));
+    const end = m ? c + m[0].length : Math.min(c + 1, s.length);
+    return { start: { line: l, character: c }, end: { line: l, character: end > c ? end : c } };
+}
+export function toLsp(d, text) {
+    const name = CODES[d.code];
+    return {
+        range: d.span
+            ? { start: { line: d.span.line - 1, character: d.span.col - 1 }, end: { line: d.span.endLine - 1, character: d.span.endCol - 1 } }
+            : rangeOf(text, d.line, d.col),
+        severity: d.severity === 'error' ? 1 : 2,
+        code: name ? `${d.code} ${name}` : d.code,
+        codeDescription: { href: docsUrl(d.code) },
+        source: 'sinter',
+        message: d.message + (d.hint ? `\nhint: ${d.hint}` : ''),
+    };
+}
+const uriToPath = (uri) => fileURLToPath(uri);
+const pathToUri = (path) => pathToFileURL(path).href;
+export function startServer(input, output, o = {}) {
+    const conn = new Connection(input, output);
+    const last = new Map();
+    /** per project root: the TypeScript bridge, 'cli' for TypeScript before 7 (checked on save), or 'none' */
+    const typescript = new Map();
+    const timers = new Map();
+    const delay = o.typecheckDelay ?? TYPECHECK_DELAY;
+    let disposed = false;
+    const modeOf = (root) => {
+        let m = typescript.get(root);
+        if (m)
+            return m;
+        try {
+            const tsc = o.tsc ?? findTsc(root);
+            m = typescriptMajor(tsc) >= 7 ? new TypeScriptBridge(root, tsc) : 'cli';
+        }
+        catch {
+            m = 'none';
+        }
+        typescript.set(root, m);
+        return m;
+    };
+    const typecheck = async (state) => {
+        const mode = modeOf(state.root);
+        if (mode === 'none')
+            return;
+        if (mode === 'cli') {
+            const p = state.project;
+            const r = check({ root: state.root, units: [...state.units.values()], helpers: p.helpers, types: p.types, openapi: p.openapi, tsc: o.tsc ?? findTsc(state.root) });
+            await workspace.setTypes(state, '*', r.diagnostics);
+            return;
+        }
+        await mode.update(state.project, state.units);
+        for (const page of state.units.keys())
+            await workspace.setTypes(state, page, await mode.diagnostics(page));
+    };
+    const schedule = (state, wait) => {
+        clearTimeout(timers.get(state.root));
+        timers.set(state.root, setTimeout(() => {
+            timers.delete(state.root);
+            typecheck(state).catch((e) => disposed || process.stderr.write(`sinter lsp: type check failed: ${e instanceof Error ? e.stack : String(e)}\n`));
+        }, wait));
+    };
+    const workspace = new Workspace({
+        compiled(state) {
+            // before TypeScript 7 the check runs `tsc` once per save instead
+            if (modeOf(state.root) !== 'cli')
+                schedule(state, delay);
+        },
+        publish(file, diagnostics) {
+            let text = '';
+            try {
+                text = workspace.read(file);
+            }
+            catch { /* deleted: ranges fall back to line starts */ }
+            const params = { uri: pathToUri(file), diagnostics: diagnostics.map((d) => toLsp(d, text)) };
+            const json = JSON.stringify(params.diagnostics);
+            if (last.get(file) === json)
+                return;
+            last.set(file, json);
+            conn.notify('textDocument/publishDiagnostics', params);
+        },
+    });
+    let watchDynamic = false;
+    let shutdown = false;
+    conn.onRequest('initialize', (params) => {
+        watchDynamic = !!params?.capabilities?.workspace?.didChangeWatchedFiles?.dynamicRegistration;
+        const folders = (params?.workspaceFolders ?? []).map((f) => uriToPath(f.uri));
+        if (!folders.length && params?.rootUri)
+            folders.push(uriToPath(params.rootUri));
+        // load the projects of the open folders early, so the first open file is quick
+        for (const f of folders)
+            void workspace.projectFor(f + '/index.html').catch(() => { });
+        return {
+            capabilities: {
+                // full text on every change
+                textDocumentSync: { openClose: true, change: 1, save: { includeText: false } },
+                hoverProvider: true,
+                completionProvider: { triggerCharacters: ['.'], resolveProvider: true },
+                definitionProvider: true,
+                codeActionProvider: { codeActionKinds: ['quickfix'] },
+            },
+            serverInfo: { name: 'sinter' },
+        };
+    });
+    conn.onNotification('initialized', () => {
+        if (!watchDynamic)
+            return;
+        void conn.request('client/registerCapability', {
+            registrations: [{
+                    id: 'sinter-watch',
+                    method: 'workspace/didChangeWatchedFiles',
+                    registerOptions: {
+                        watchers: [
+                            { globPattern: '**/*.html' },
+                            { globPattern: '**/vite.config.{js,ts,mjs,mts,cjs,cts}' },
+                            { globPattern: '**/src/sinter.{helpers,types,config}.{js,ts}' },
+                            { globPattern: '**/src/sinter.types.d.ts' },
+                            { globPattern: '**/*.{yml,yaml,json}' },
+                            { globPattern: '**/src/**/*.{js,ts}' },
+                        ],
+                    },
+                }],
+        }).catch(() => { });
+    });
+    const local = (uri) => uri.startsWith('file:');
+    conn.onNotification('textDocument/didOpen', (p) => {
+        if (local(p.textDocument.uri))
+            return workspace.open(uriToPath(p.textDocument.uri), p.textDocument.text);
+    });
+    conn.onNotification('textDocument/didChange', (p) => {
+        const text = p.contentChanges[p.contentChanges.length - 1]?.text;
+        if (local(p.textDocument.uri) && typeof text === 'string')
+            return workspace.change(uriToPath(p.textDocument.uri), text);
+    });
+    conn.onNotification('textDocument/didClose', (p) => {
+        if (local(p.textDocument.uri))
+            return workspace.close(uriToPath(p.textDocument.uri));
+    });
+    conn.onNotification('textDocument/didSave', async (p) => {
+        if (!local(p.textDocument.uri))
+            return;
+        const file = uriToPath(p.textDocument.uri);
+        await workspace.fileChanged(file);
+        const state = await workspace.projectFor(file);
+        if (modeOf(state.root) === 'cli')
+            schedule(state, 0);
+    });
+    conn.onNotification('workspace/didChangeWatchedFiles', async (p) => {
+        const files = (p.changes ?? []).filter((c) => local(c.uri)).map((c) => uriToPath(c.uri));
+        for (const m of typescript.values())
+            if (m instanceof TypeScriptBridge)
+                m.filesChanged(files.filter((f) => !f.endsWith('.html')));
+        for (const f of files)
+            await workspace.fileChanged(f);
+    });
+    conn.onRequest('textDocument/hover', async (p) => {
+        if (!local(p.textDocument.uri))
+            return null;
+        const file = uriToPath(p.textDocument.uri);
+        const state = await workspace.projectFor(file);
+        const mode = modeOf(state.root);
+        if (!(mode instanceof TypeScriptBridge))
+            return null;
+        // the shadows must reflect the latest edit
+        await mode.update(state.project, state.units);
+        return mode.hover(file, p.position.line + 1, p.position.character + 1);
+    });
+    /** the bridge for a file's project, with its shadows brought up to date */
+    const bridgeFor = async (file) => {
+        const state = await workspace.projectFor(file);
+        const mode = modeOf(state.root);
+        if (!(mode instanceof TypeScriptBridge))
+            return null;
+        await mode.update(state.project, state.units);
+        return { bridge: mode, state };
+    };
+    conn.onRequest('textDocument/completion', async (p) => {
+        if (!local(p.textDocument.uri))
+            return null;
+        const file = uriToPath(p.textDocument.uri);
+        const b = await bridgeFor(file);
+        return b ? b.bridge.completion(file, p.position.line + 1, p.position.character + 1, p.context) : null;
+    });
+    conn.onRequest('completionItem/resolve', async (item) => {
+        const m = item?.data?.sinter ? typescript.get(item.data.sinter) : null;
+        return m instanceof TypeScriptBridge ? m.resolve(item) : item;
+    });
+    const location = (t) => {
+        let text = '';
+        try {
+            text = workspace.read(t.file);
+        }
+        catch { /* the target's range falls back to its start */ }
+        const range = t.endLine !== undefined && t.endCol !== undefined
+            ? { start: { line: t.line - 1, character: t.col - 1 }, end: { line: t.endLine - 1, character: t.endCol - 1 } }
+            : rangeOf(text, t.line, t.col);
+        return { uri: pathToUri(t.file), range };
+    };
+    conn.onRequest('textDocument/definition', async (p) => {
+        if (!local(p.textDocument.uri))
+            return null;
+        const file = uriToPath(p.textDocument.uri);
+        const partial = includeAt(workspace.read(file), p.position.line, p.position.character);
+        if (partial !== null) {
+            const target = resolve(dirname(file), partial);
+            return existsSync(target) ? [{ uri: pathToUri(target), range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } } }] : null;
+        }
+        const b = await bridgeFor(file);
+        if (!b)
+            return null;
+        const targets = await b.bridge.definition(file, p.position.line + 1, p.position.character + 1, b.state.project);
+        return targets.map(location);
+    });
+    conn.onRequest('textDocument/codeAction', (p) => {
+        if (!local(p.textDocument.uri))
+            return [];
+        let text;
+        try {
+            text = workspace.read(uriToPath(p.textDocument.uri));
+        }
+        catch {
+            return [];
+        }
+        const actions = [];
+        for (const d of p.context?.diagnostics ?? []) {
+            if (d.source !== 'sinter')
+                continue;
+            const edit = didYouMeanEdit(text, d.range, d.message);
+            if (!edit)
+                continue;
+            actions.push({
+                title: `Change to '${edit.newText}'`, kind: 'quickfix', isPreferred: true, diagnostics: [d],
+                edit: { changes: { [p.textDocument.uri]: [edit] } },
+            });
+        }
+        return actions;
+    });
+    const dispose = () => {
+        disposed = true;
+        for (const t of timers.values())
+            clearTimeout(t);
+        timers.clear();
+        for (const m of typescript.values())
+            if (m instanceof TypeScriptBridge)
+                m.dispose();
+        typescript.clear();
+    };
+    conn.onRequest('shutdown', () => { shutdown = true; dispose(); return null; });
+    const closed = conn.onClose;
+    conn.onClose = () => { dispose(); closed?.(); };
+    conn.onNotification('exit', () => { conn.close(); o.exit?.(shutdown ? 0 : 1); });
+    conn.onUnhandled = () => { };
+    return conn;
+}
+/** The `src` of an `<sn-include>` when the 0-based position is inside its value, else null. */
+export function includeAt(text, line, character) {
+    const t = text.split('\n')[line] ?? '';
+    for (const m of t.matchAll(/<sn-include\b[^>]*?\bsrc\s*=\s*(["'])([^"']*)\1/g)) {
+        const start = m.index + m[0].length - 1 - m[2].length;
+        if (character >= start && character <= start + m[2].length)
+            return m[2];
+    }
+    return null;
+}

package/dist/lsp/spec-location.d.ts

@@ -0,0 +1,9 @@
+export interface SpecLocation {
+    line: number;
+    col: number;
+}
+/**
+ * The position of `components.schemas.<schema>` in `file`, or of its `properties.<prop>` when
+ * given and present. `schema` is the TypeScript name; the spec's own name is looked up.
+ */
+export declare function specLocation(file: string, schema: string, prop?: string): SpecLocation | null;