@tiaforge-ui/sinter 0.0.0-stage → 0.2.0

package/dist/each.js

@@ -0,0 +1,121 @@
+const isAbort = (e) => e instanceof DOMException && e.name == 'AbortError';
+/**
+ * Sources are keyed by their resolved URL. An item belongs to a source when it came in that
+ * source's last response, or when `src` resolves to the source's URL with the item itself in
+ * place of the list item, so an item a server event added is replaced by the next response.
+ */
+function fanOut(l, app) {
+    const { def, res: r } = l;
+    const each = def.each;
+    const sources = new Map();
+    const queued = new Set();
+    let pending = 0, again = null;
+    const urlOf = (item) => {
+        if (!item || typeof item != 'object')
+            return null;
+        try {
+            return app.url(def.src, Object.assign(Object.create(l.scope()), { [each.item]: item }));
+        }
+        catch {
+            return null;
+        }
+    };
+    /** the confirmed items minus those of source `u`, plus `items` */
+    const swap = (u, s, items) => {
+        const mine = (x) => s.keys.has(r.keyOf(x)) || urlOf(x) === u;
+        r.replace([...r.base().items.filter((x) => !mine(x)), ...items]);
+    };
+    async function load(u) {
+        const s = sources.get(u);
+        if (!s)
+            return;
+        s.c?.abort();
+        const ctl = (s.c = new AbortController()), n = ++s.seq, mark = r.startLoad();
+        let loaded = false;
+        pending++;
+        l.loading(true);
+        try {
+            const body = await l.get(u, ctl.signal);
+            if (n != s.seq || sources.get(u) != s)
+                return;
+            const items = l.items(body);
+            swap(u, s, items);
+            s.keys = new Set(items.map((x) => r.keyOf(x)));
+            s.answered = loaded = true;
+            r.meta.error = null;
+            // loadedAt: every current source has answered once
+            if ([...sources.values()].every((x) => x.answered))
+                r.meta.loadedAt = app.env.now();
+        }
+        catch (e) {
+            if (n != s.seq || isAbort(e))
+                return;
+            s.answered = true;
+            l.failed(e);
+        }
+        finally {
+            r.endLoad(mark, loaded);
+            if (n == s.seq)
+                s.c = null;
+            l.loading(--pending > 0);
+        }
+    }
+    l.changed = () => {
+        const scope = l.scope();
+        let list = [];
+        try {
+            if (def.when == null || app.fns[def.when](scope))
+                list = app.fns[each.list](scope) ?? [];
+        }
+        catch (e) {
+            app.warn(17, def.name, e.message);
+        }
+        const want = new Set();
+        for (const item of Array.isArray(list) ? list : [...list]) {
+            const u = urlOf(item);
+            if (u != null)
+                want.add(u);
+        }
+        for (const [u, s] of sources) {
+            if (want.has(u))
+                continue;
+            s.seq++;
+            s.c?.abort();
+            sources.delete(u);
+            swap(u, s, []);
+        }
+        for (const u of want) {
+            if (sources.has(u))
+                continue;
+            sources.set(u, { c: null, seq: 0, keys: new Set(), answered: false });
+            void load(u);
+        }
+        // nothing to load: loaded once the list itself is (an empty list is an answer, a pending one is not)
+        if (!sources.size && r.meta.loadedAt == null && (!each.of || app.resource(each.of).meta.loadedAt != null)) {
+            r.meta.loadedAt = app.env.now();
+            r.onDirty('meta');
+        }
+        l.loading(pending > 0);
+    };
+    l.start = () => l.changed();
+    l.load = () => Promise.all([...sources.keys()].map(load)).then(() => { });
+    // a hint (an event's payload) that resolves to one source's URL reloads only that source;
+    // several refetches in one task share one round of requests
+    l.refetch = (hint) => {
+        const u = hint ? urlOf(hint) : null;
+        queued.add(u != null && sources.has(u) ? u : '*');
+        return (again ??= Promise.resolve().then(() => {
+            again = null;
+            const urls = queued.has('*') ? [...sources.keys()] : [...queued];
+            queued.clear();
+            return Promise.all(urls.map(load)).then(() => { });
+        }));
+    };
+}
+const each = {
+    name: 'each',
+    install(app) {
+        app.ext.each = { fanOut: (loader) => fanOut(loader, app) };
+    },
+};
+export default each;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { mount, instance, type App, type CallContext, type Feature, type MountOptions, type StateHandle, type Transport } from './runtime/app.js';
+export { configure, credentials, header, onUnauthorized, loginRedirect, takeReturnUrl, clearPersisted, SinterError, type Config, type Middleware, type LoginRedirectOptions, } from './runtime/config.js';
+export type { Resource, Change, Meta } from './runtime/store.js';
+export { $k } from './runtime/security.js';
+export { date, time, datetime, relative, number, bytes } from './runtime/helpers.js';
+export type { Env } from './runtime/env.js';
+export type { IR } from './ir.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export { mount, instance } from './runtime/app.js';
+export { configure, credentials, header, onUnauthorized, loginRedirect, takeReturnUrl, clearPersisted, SinterError, } from './runtime/config.js';
+export { $k } from './runtime/security.js';
+export { date, time, datetime, relative, number, bytes } from './runtime/helpers.js';

package/dist/ir.d.ts

@@ -0,0 +1,152 @@
+export declare const IR_VERSION = 1;
+/** Literal string parts and function indexes, joined with encodeURIComponent. */
+export type UrlTemplate = Array<string | number>;
+export interface Paginate {
+    mode: 'keyset' | 'offset' | 'append';
+    size: number;
+    sizeParam: string;
+    /** keyset/append: object literal evaluated with the boundary item as `$.$p` */
+    cursor: number | null;
+    directionParam: string;
+    /** keyset/append: the value sent for each direction, where it differs from the direction's name */
+    directionValues?: Partial<Record<'first' | 'prev' | 'next' | 'last', string>>;
+    pageParam: string;
+    /** keyset: offset parameter that lets `page(name, n)` jump; the server skips (n - 1) * size items */
+    offsetParam?: string;
+}
+export interface ResourceDef {
+    name: string;
+    src: UrlTemplate;
+    /** key fields; null for a single-object resource */
+    key: string[] | null;
+    items: string | null;
+    total: string | null;
+    /** field, `-field` for descending */
+    order: string | null;
+    when: number | null;
+    paginate: Paginate | null;
+    /** state and `$url` paths that `src` and `when` read */
+    deps: string[];
+    /** index of the node (in `roots`) whose scope src/when are evaluated in, -1 for page scope */
+    scope: number;
+    /** `data-sn` id of an embedded `<script type="application/json">`, or null */
+    data: number | null;
+    /** `cache`: the oldest cached data to show, in ms (0: any age); absent when not cached */
+    cache?: number;
+    /** `call="ns.fn(args)"`: loaded from an action function instead of `src` (then empty) */
+    call?: CallDef;
+    /** `each="a in accounts"`: one request per list item (src evaluated with `item` in scope), merged into one collection */
+    each?: {
+        item: string;
+        list: number;
+        of?: string;
+    };
+}
+export interface EventDef {
+    name: string;
+    resource: string;
+    op: 'upsert' | 'patch' | 'remove' | 'refetch';
+    item: number | null;
+    set: number | null;
+    when: number | null;
+    fallback: 'refetch' | null;
+}
+export interface SyncDef {
+    src: UrlTemplate;
+    events: EventDef[];
+    /** index of the node (in `roots`) whose scope `src` and the events' expressions are evaluated in, -1 (or absent) for page scope */
+    scope?: number;
+}
+export type BindingKind = 'text' | 'attr' | 'class' | 'style' | 'show' | 'model' | 'prop' | 'for' | 'if' | 'else' | 'on';
+export interface Binding {
+    k: BindingKind;
+    /** value / handler function index */
+    f?: number;
+    /** dependency paths: dot-separated, `*` any segment, `{name}` scope value */
+    d?: string[];
+    /** event name (`on`), control kind (`model`) */
+    n?: string;
+    /** action index (`on`), template id (`for`, `if`, `else`) */
+    x?: number;
+    /** model setter function index */
+    a?: number;
+    /** if: node index of the paired else template */
+    y?: number;
+    /** handler: paths it may change */
+    w?: string[];
+    /** model: persist key */
+    p?: string;
+    /** the expression reads `$el` */
+    e?: 1;
+    /** the expression reads a loop index, so it re-runs when only the row's position changed */
+    i?: 1;
+    /** handler on an element without a method: `data-sn-debounce` milliseconds */
+    ms?: number;
+}
+export interface NodeDef {
+    /** `data-sn` id (roots) */
+    id?: number;
+    /** child indexes from the template content root (template nodes) */
+    path?: number[];
+    tag: string;
+    /** index of the nearest enclosing node in the same list that opens a state scope, -1 for none */
+    p: number;
+    /** state scope: initial value function and scope id (`$s<sid>`) */
+    state?: number;
+    sid?: number;
+    /** persist key for the whole state object */
+    persist?: string;
+    /** the element is a `<dialog>` or inside one of its block, so its bindings wait while that dialog is closed */
+    dl?: 1;
+    b: Binding[];
+}
+export interface TemplateDef {
+    id: number;
+    nodes: NodeDef[];
+    /** for: loop variable, index variable, internal index name */
+    item?: string;
+    index?: string | null;
+    ii?: string;
+    /** for: explicit key function, or resource key fields */
+    key?: number | null;
+    keyFields?: string[] | null;
+    /** for: function that finds the bound elements of one cloned row: (first content node) => elements, in `nodes` order */
+    find?: number;
+}
+/** a local action call: `args` evaluates the arguments (an array), `run(args, ctx)` calls the function */
+export interface CallDef {
+    args: number;
+    run: number;
+}
+export interface ActionDef {
+    /** `CALL`: `data-sn-call`, with `call` set and an empty `url` */
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'CALL';
+    url: UrlTemplate;
+    call?: CallDef;
+    body: number | null;
+    trigger: string;
+    debounce: number;
+    concurrency: 'block' | 'queue' | 'latest';
+    optimistic: number | null;
+    then: number | null;
+    catch: number | null;
+    /** paths `then` and `catch` may change */
+    w: string[];
+    /** element is a form (serialize, disable in block mode) */
+    form: boolean;
+}
+export interface IR {
+    v: 1;
+    resources: ResourceDef[];
+    syncs: SyncDef[];
+    roots: NodeDef[];
+    templates: TemplateDef[];
+    actions: ActionDef[];
+    /** page uses `$now` */
+    now?: boolean;
+    /** `data-sn-path` patterns; `:name` segments of the first match join `$url` */
+    path?: string[];
+}
+export type Fn = (scope: any, value?: any) => any;
+/** Structural check of an IR against v1; returns problems (empty when valid). */
+export declare function validateIR(ir: unknown, fnCount: number): string[];

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;