@tiaforge-ui/sinter 0.0.0-stage → 0.1.0

package/dist/lsp/spec-location.js

@@ -0,0 +1,42 @@
+// Where a named schema (or one of its properties) is written in an OpenAPI spec
+// file, for go to definition on types generated from it. YAML and JSON alike: the
+// `yaml` parser reads both and keeps source ranges.
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { typeName } from '../check/openapi-types.js';
+/** The key named `name` in a YAML map node. */
+function pair(map, name) {
+    return map?.items?.find((p) => p.key?.value === name);
+}
+function lineCol(text, offset) {
+    let line = 1;
+    let start = 0;
+    for (let i = 0; i < offset && i < text.length; i++)
+        if (text[i] === '\n') {
+            line++;
+            start = i + 1;
+        }
+    return { line, col: offset - start + 1 };
+}
+/**
+ * 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 function specLocation(file, schema, prop) {
+    let text;
+    try {
+        text = readFileSync(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const yaml = createRequire(import.meta.url)('yaml');
+    const doc = yaml.parseDocument(text);
+    const schemas = pair(pair(doc.contents, 'components')?.value, 'schemas')?.value;
+    const entry = schemas?.items?.find((p) => typeof p.key?.value === 'string' && typeName(p.key.value) === schema);
+    if (!entry?.key?.range)
+        return null;
+    const property = prop ? pair(pair(entry.value, 'properties')?.value, prop) : undefined;
+    const at = property?.key?.range ?? entry.key.range;
+    return lineCol(text, at[0]);
+}

package/dist/lsp/typescript.d.ts

@@ -0,0 +1,77 @@
+import { type Region } from '../check/shadow.js';
+import type { CheckUnit } from '../compiler/check-unit.js';
+import type { Diagnostic } from '../compiler/index.js';
+import type { Project } from '../project.js';
+/** The major version of the project's TypeScript, from the package next to its `tsc`. */
+export declare function typescriptMajor(tsc: string): number;
+interface OpenShadow {
+    unit: CheckUnit;
+    path: string;
+    uri: string;
+    text: string;
+    lines: string[];
+    regions: Region[];
+    brokenFrom: number | null;
+    version: number;
+}
+/** A place in a file, 1-based; `end` when known. */
+export interface Target {
+    file: string;
+    line: number;
+    col: number;
+    endLine?: number;
+    endCol?: number;
+}
+interface LspRange {
+    start: {
+        line: number;
+        character: number;
+    };
+    end: {
+        line: number;
+        character: number;
+    };
+}
+export declare class TypeScriptBridge {
+    readonly root: string;
+    private conn;
+    private child;
+    private ready;
+    private shadows;
+    private support;
+    readonly outDir: string;
+    constructor(root: string, tsc: string);
+    /** Brings the shadows in line with the pages' latest check units. */
+    update(project: Project, units: Map<string, CheckUnit>): Promise<void>;
+    /** TypeScript's errors in a page's expressions, at their HTML positions. */
+    diagnostics(page: string): Promise<Diagnostic[]>;
+    /** The page shadow and shadow position for a 1-based HTML position, if it is in an expression. */
+    locate(file: string, line: number, col: number): {
+        shadow: OpenShadow;
+        line: number;
+        col: number;
+    } | null;
+    /** Maps a shadow range back to the HTML; null when it is not inside one expression. */
+    private toHtml;
+    hover(file: string, line: number, col: number): Promise<{
+        contents: unknown;
+        range?: LspRange;
+    } | null>;
+    /** Completions at a 1-based HTML position inside an expression, with edits mapped to the HTML. */
+    completion(file: string, line: number, col: number, context: unknown): Promise<{
+        isIncomplete: boolean;
+        items: any[];
+    } | null>;
+    /** Details for a completion item this bridge returned (documentation, signature). */
+    resolve(item: any): Promise<any>;
+    /**
+     * Definitions of the name at a 1-based HTML position: where the HTML declares it (resources,
+     * state, loop variables), the spec for types generated from OpenAPI, else TypeScript's own
+     * answer (helpers, the types module).
+     */
+    definition(file: string, line: number, col: number, project: Project): Promise<Target[]>;
+    /** Tells TypeScript that files it may have read changed on disk. */
+    filesChanged(files: string[]): void;
+    dispose(): void;
+}
+export {};

package/dist/lsp/typescript.js

@@ -0,0 +1,242 @@
+// The bridge to TypeScript 7's own language server (`tsc --lsp --stdio`). It keeps
+// one shadow file per page open there, pulls type errors for them and answers hovers,
+// mapping positions between the HTML and the shadows.
+import { spawn } from 'node:child_process';
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { COMPILER_OPTIONS, shadowOf, shadowPath, typeDiagnostic, writeSupport } from '../check/index.js';
+import { mapPosition, shadowPosition } from '../check/shadow.js';
+import { Connection } from './rpc.js';
+import { specLocation } from './spec-location.js';
+/** The major version of the project's TypeScript, from the package next to its `tsc`. */
+export function typescriptMajor(tsc) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dirname(tsc), '..', 'package.json'), 'utf8'));
+        return Number(/^(\d+)/.exec(pkg.version ?? '')?.[1] ?? 0);
+    }
+    catch {
+        return 0;
+    }
+}
+/** Names the shadow declares for itself, never offered as completions. */
+const INTERNAL = /^(\$any|\$item|\$p|\$e\d+)$/;
+export class TypeScriptBridge {
+    root;
+    conn;
+    child;
+    ready;
+    shadows = new Map();
+    support = null;
+    outDir;
+    constructor(root, tsc) {
+        this.root = root;
+        this.outDir = join(root, '.sinter', 'lsp');
+        mkdirSync(this.outDir, { recursive: true });
+        writeFileSync(join(this.outDir, 'tsconfig.json'), JSON.stringify({ compilerOptions: COMPILER_OPTIONS, include: ['**/*.js', '*.d.ts'] }, null, 2) + '\n');
+        this.child = spawn(process.execPath, [tsc, '--lsp', '--stdio'], { cwd: this.outDir, stdio: ['pipe', 'pipe', 'ignore'] });
+        this.conn = new Connection(this.child.stdout, this.child.stdin);
+        // workspace/configuration, client/registerCapability, progress: nothing to say
+        this.conn.requestFallback = (method, params) => (method === 'workspace/configuration' ? (params?.items ?? []).map(() => null) : null);
+        this.conn.onUnhandled = () => { };
+        this.child.on('error', () => this.conn.close());
+        this.child.stdin.on('error', () => this.conn.close());
+        this.ready = this.conn.request('initialize', {
+            processId: process.pid,
+            rootUri: pathToFileURL(this.outDir).href,
+            capabilities: {
+                textDocument: { diagnostic: {}, hover: { contentFormat: ['markdown', 'plaintext'] }, synchronization: {} },
+                workspace: { configuration: true, didChangeWatchedFiles: { dynamicRegistration: true } },
+            },
+        }).then(() => this.conn.notify('initialized', {}), () => { });
+    }
+    /** Brings the shadows in line with the pages' latest check units. */
+    async update(project, units) {
+        await this.ready;
+        const support = writeSupport({ root: this.root, outDir: this.outDir, types: project.types, openapi: project.openapi });
+        // a reloaded project may have new type names or spec declarations
+        if (this.support && JSON.stringify(support) !== JSON.stringify(this.support))
+            this.filesChanged([support.declarations, ...support.openapi]);
+        this.support = support;
+        for (const [page, unit] of units) {
+            const s = shadowOf(unit, support, this.root, project.helpers);
+            const prev = this.shadows.get(page);
+            if (prev?.text === s.text) {
+                prev.unit = unit;
+                prev.regions = s.regions;
+                prev.brokenFrom = s.brokenFrom;
+                continue;
+            }
+            const path = shadowPath(support, this.root, page);
+            const uri = pathToFileURL(path).href;
+            const next = { unit, path, uri, text: s.text, lines: s.text.split('\n'), regions: s.regions, brokenFrom: s.brokenFrom, version: (prev?.version ?? 0) + 1 };
+            this.shadows.set(page, next);
+            if (prev) {
+                this.conn.notify('textDocument/didChange', { textDocument: { uri, version: next.version }, contentChanges: [{ text: s.text }] });
+            }
+            else {
+                // on disk too, so the tsconfig's `include` puts it in the project
+                mkdirSync(dirname(path), { recursive: true });
+                writeFileSync(path, s.text);
+                this.conn.notify('textDocument/didOpen', { textDocument: { uri, languageId: 'javascript', version: next.version, text: s.text } });
+            }
+        }
+        for (const [page, s] of this.shadows) {
+            if (units.has(page))
+                continue;
+            this.conn.notify('textDocument/didClose', { textDocument: { uri: s.uri } });
+            rmSync(s.path, { force: true });
+            this.shadows.delete(page);
+        }
+    }
+    /** TypeScript's errors in a page's expressions, at their HTML positions. */
+    async diagnostics(page) {
+        const s = this.shadows.get(page);
+        if (!s)
+            return [];
+        const report = await this.conn.request('textDocument/diagnostic', { textDocument: { uri: s.uri } });
+        const out = [];
+        for (const item of report?.items ?? []) {
+            // hints and suggestions (unused imports of the shadow itself) are not the page's business
+            if (item.severity !== 1)
+                continue;
+            const { start, end } = item.range;
+            // broken expressions are the compiler's to report
+            if (s.brokenFrom !== null && start.line + 1 >= s.brokenFrom)
+                continue;
+            const d = typeDiagnostic(s.unit, s.regions, start.line + 1, start.character + 1, `TS${item.code}`, item.message, this.root);
+            const a = mapPosition(s.regions, start.line + 1, start.character + 1);
+            const b = mapPosition(s.regions, end.line + 1, end.character + 1);
+            if (a && b && a.file === b.file && (b.line > a.line || (b.line === a.line && b.col > a.col))) {
+                d.span = { line: a.line, col: a.col, endLine: b.line, endCol: b.col };
+            }
+            out.push(d);
+        }
+        return out;
+    }
+    /** The page shadow and shadow position for a 1-based HTML position, if it is in an expression. */
+    locate(file, line, col) {
+        // the page itself first, then pages that include `file`
+        const order = [...this.shadows].sort(([a], [b]) => Number(b === file) - Number(a === file));
+        for (const [, s] of order) {
+            const p = shadowPosition(s.regions, s.lines, file, line, col);
+            if (p)
+                return { shadow: s, ...p };
+        }
+        return null;
+    }
+    /** Maps a shadow range back to the HTML; null when it is not inside one expression. */
+    toHtml(s, r, file) {
+        const a = mapPosition(s.regions, r.start.line + 1, r.start.character + 1);
+        const b = mapPosition(s.regions, r.end.line + 1, r.end.character + 1);
+        if (!a || !b || a.file !== file || b.file !== file)
+            return null;
+        return { start: { line: a.line - 1, character: a.col - 1 }, end: { line: b.line - 1, character: b.col - 1 } };
+    }
+    async hover(file, line, col) {
+        await this.ready;
+        const at = this.locate(file, line, col);
+        if (!at)
+            return null;
+        const h = await this.conn.request('textDocument/hover', {
+            textDocument: { uri: at.shadow.uri }, position: { line: at.line - 1, character: at.col - 1 },
+        });
+        if (!h)
+            return null;
+        const range = h.range ? this.toHtml(at.shadow, h.range, file) : null;
+        return range ? { contents: h.contents, range } : { contents: h.contents };
+    }
+    /** Completions at a 1-based HTML position inside an expression, with edits mapped to the HTML. */
+    async completion(file, line, col, context) {
+        await this.ready;
+        const at = this.locate(file, line, col);
+        if (!at)
+            return null;
+        const r = await this.conn.request('textDocument/completion', {
+            textDocument: { uri: at.shadow.uri }, position: { line: at.line - 1, character: at.col - 1 }, context,
+        });
+        if (!r)
+            return null;
+        const list = Array.isArray(r) ? r : r.items ?? [];
+        const items = [];
+        for (const item of list) {
+            // the shadow's own names, and auto-imports that would edit the shadow's header
+            if (INTERNAL.test(item.label) || item.additionalTextEdits?.length)
+                continue;
+            const edit = item.textEdit;
+            if (edit) {
+                const range = edit.range ?? edit.replace;
+                const mapped = range && this.toHtml(at.shadow, range, file);
+                if (mapped)
+                    item.textEdit = { range: mapped, newText: edit.newText };
+                else
+                    delete item.textEdit;
+            }
+            item.data = { sinter: this.root, ts: item.data ?? null, uri: at.shadow.uri };
+            items.push(item);
+        }
+        return { isIncomplete: Array.isArray(r) ? false : !!r.isIncomplete, items };
+    }
+    /** Details for a completion item this bridge returned (documentation, signature). */
+    async resolve(item) {
+        const ours = item.data;
+        const r = await this.conn.request('completionItem/resolve', { ...item, data: ours.ts, textEdit: undefined });
+        return { ...item, documentation: r?.documentation ?? item.documentation, detail: r?.detail ?? item.detail };
+    }
+    /**
+     * Definitions of the name at a 1-based HTML position: where the HTML declares it (resources,
+     * state, loop variables), the spec for types generated from OpenAPI, else TypeScript's own
+     * answer (helpers, the types module).
+     */
+    async definition(file, line, col, project) {
+        await this.ready;
+        const at = this.locate(file, line, col);
+        if (!at)
+            return [];
+        const r = await this.conn.request('textDocument/definition', {
+            textDocument: { uri: at.shadow.uri }, position: { line: at.line - 1, character: at.col - 1 },
+        });
+        const list = !r ? [] : Array.isArray(r) ? r : [r];
+        const out = [];
+        for (const d of list) {
+            const uri = d.targetUri ?? d.uri;
+            const range = d.targetSelectionRange ?? d.range;
+            if (!uri?.startsWith('file:') || !range)
+                continue;
+            const path = fileURLToPath(uri);
+            const shadow = [...this.shadows.values()].find((s) => s.path === path);
+            if (shadow) {
+                const loc = mapPosition(shadow.regions, range.start.line + 1, range.start.character + 1);
+                if (loc)
+                    out.push({ file: loc.file, line: loc.line, col: loc.col });
+                continue;
+            }
+            const spec = this.support?.openapi.indexOf(path) ?? -1;
+            if (spec >= 0) {
+                const text = readFileSync(path, 'utf8').split('\n')[range.start.line] ?? '';
+                const name = /^export (?:interface|type) ([\w$]+)/.exec(text)?.[1];
+                const ident = text.slice(range.start.character, range.end.character);
+                const specFile = project.openapi[spec]?.file;
+                const loc = name && specFile ? specLocation(specFile, name, ident !== name ? ident : undefined) : null;
+                if (loc && specFile)
+                    out.push({ file: specFile, ...loc });
+                continue;
+            }
+            // sinter's own declarations say nothing useful about the app
+            if (path === this.support?.declarations)
+                continue;
+            out.push({ file: path, line: range.start.line + 1, col: range.start.character + 1, endLine: range.end.line + 1, endCol: range.end.character + 1 });
+        }
+        return out;
+    }
+    /** Tells TypeScript that files it may have read changed on disk. */
+    filesChanged(files) {
+        if (!files.length)
+            return;
+        this.conn.notify('workspace/didChangeWatchedFiles', { changes: files.map((f) => ({ uri: pathToFileURL(f).href, type: 2 })) });
+    }
+    dispose() {
+        this.conn.close();
+        this.child.kill();
+    }
+}

package/dist/lsp/workspace.d.ts

@@ -0,0 +1,56 @@
+import type { CheckUnit } from '../compiler/check-unit.js';
+import { type Diagnostic } from '../compiler/index.js';
+import { type Project, type ProjectOptions } from '../project.js';
+export interface ProjectState {
+    root: string;
+    options: ProjectOptions;
+    project: Project;
+    /** HTML entries from the Vite config */
+    entries: Set<string>;
+    /** every page compiled so far (entries, plus open HTML files no page includes) */
+    pages: Set<string>;
+    /** per page: the files it includes */
+    includes: Map<string, string[]>;
+    /** per page: its last compile's diagnostics */
+    diagnostics: Map<string, Diagnostic[]>;
+    /** per page: its last compile's check unit */
+    units: Map<string, CheckUnit>;
+    /** TypeScript's diagnostics, per page (or per check run); they lag behind compiles */
+    types: Map<string, Diagnostic[]>;
+    /** files whose change reloads the project: Vite config, helpers, types, specs */
+    inputs: Set<string>;
+}
+export interface WorkspaceHooks {
+    /** the diagnostics of `file` changed (an empty list clears them) */
+    publish(file: string, diagnostics: Diagnostic[]): void;
+    /** pages were compiled; their check units are in `state.units` */
+    compiled?(state: ProjectState, pages: string[]): void;
+}
+export declare class Workspace {
+    private hooks;
+    /** open buffers by absolute path */
+    readonly docs: Map<string, string>;
+    readonly projects: Map<string, Promise<ProjectState>>;
+    /** files that currently have diagnostics published */
+    private published;
+    constructor(hooks: WorkspaceHooks);
+    /** The project a file belongs to: the nearest folder with a Vite config, else with a package.json. */
+    rootOf(file: string): string;
+    projectFor(file: string): Promise<ProjectState>;
+    private load;
+    open(file: string, text: string): Promise<void>;
+    change(file: string, text: string): Promise<void>;
+    close(file: string): Promise<void>;
+    /** A file changed on disk (saved, or changed by another program). */
+    fileChanged(file: string): Promise<void>;
+    /** a non-HTML file: reload projects that read it */
+    private otherChanged;
+    private htmlChanged;
+    /** the text of a file: the open buffer, else the disk */
+    read(file: string): string;
+    private compilePages;
+    /** Sets TypeScript's diagnostics under `key` (a page) and publishes. Ignored for a replaced project state. */
+    setTypes(state: ProjectState, key: string, list: Diagnostic[]): Promise<void>;
+    /** Publishes every file's diagnostics, merged across the pages that include it. */
+    private publishAll;
+}

package/dist/lsp/workspace.js

@@ -0,0 +1,227 @@
+// What the language server knows: the projects under the editor's folders, their
+// pages and partials, open buffers, and the diagnostics of each file. Independent of
+// LSP itself, so tests drive it directly.
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { compile } from '../compiler/index.js';
+import { project, viteProject } from '../project.js';
+const VITE_CONFIGS = ['vite.config.ts', 'vite.config.js', 'vite.config.mts', 'vite.config.mjs', 'vite.config.cts', 'vite.config.cjs'];
+export class Workspace {
+    hooks;
+    /** open buffers by absolute path */
+    docs = new Map();
+    projects = new Map();
+    /** files that currently have diagnostics published */
+    published = new Set();
+    constructor(hooks) {
+        this.hooks = hooks;
+    }
+    /** The project a file belongs to: the nearest folder with a Vite config, else with a package.json. */
+    rootOf(file) {
+        let pkg = null;
+        for (let dir = dirname(file);; dir = dirname(dir)) {
+            if (VITE_CONFIGS.some((c) => existsSync(join(dir, c))))
+                return dir;
+            if (!pkg && existsSync(join(dir, 'package.json')))
+                pkg = dir;
+            if (dirname(dir) === dir)
+                return pkg ?? dirname(file);
+        }
+    }
+    projectFor(file) {
+        const root = this.rootOf(file);
+        let p = this.projects.get(root);
+        if (!p) {
+            p = this.load(root);
+            this.projects.set(root, p);
+        }
+        return p;
+    }
+    async load(root) {
+        let pages = [];
+        let options = {};
+        try {
+            ({ pages, options } = await viteProject(root));
+        }
+        catch (e) {
+            process.stderr.write(`sinter lsp: reading the Vite config in ${root} failed: ${e.message}\n`);
+        }
+        const p = project(root, options);
+        const inputs = new Set(VITE_CONFIGS.map((c) => join(root, c)));
+        for (const f of [p.helpersFile, p.types, ...p.openapi.map((s) => s.file)])
+            if (f)
+                inputs.add(f);
+        for (const spec of options.openapi == null ? [] : [].concat(options.openapi))
+            inputs.add(resolve(root, spec));
+        for (const ext of ['.js', '.ts']) {
+            inputs.add(join(root, 'src/sinter.helpers' + ext));
+            inputs.add(join(root, 'src/sinter.types' + ext));
+        }
+        inputs.add(join(root, 'src/sinter.types.d.ts'));
+        for (const m of Object.values(p.helpers.namespaces))
+            if (m.module.startsWith('/'))
+                inputs.add(join(root, m.module));
+        const state = {
+            root, options, project: p, entries: new Set(pages), pages: new Set(pages),
+            includes: new Map(), diagnostics: new Map(), units: new Map(), types: new Map(), inputs,
+        };
+        for (const [file] of this.docs)
+            if (file.endsWith('.html') && this.rootOf(file) === root)
+                state.pages.add(file);
+        this.compilePages(state, [...state.pages]);
+        return state;
+    }
+    async open(file, text) {
+        this.docs.set(file, text);
+        if (file.endsWith('.html'))
+            await this.htmlChanged(file);
+        else
+            await this.otherChanged(file);
+    }
+    async change(file, text) {
+        this.docs.set(file, text);
+        if (file.endsWith('.html'))
+            await this.htmlChanged(file);
+    }
+    async close(file) {
+        this.docs.delete(file);
+        if (!file.endsWith('.html'))
+            return;
+        const state = await this.projectFor(file);
+        // a page that is neither an entry nor open is forgotten; its diagnostics go with it
+        if (!state.entries.has(file) && state.pages.has(file)) {
+            state.pages.delete(file);
+            state.includes.delete(file);
+            state.diagnostics.delete(file);
+            state.units.delete(file);
+            state.types.delete(file);
+            this.publishAll(state);
+            return;
+        }
+        await this.htmlChanged(file);
+    }
+    /** A file changed on disk (saved, or changed by another program). */
+    async fileChanged(file) {
+        if (file.endsWith('.html')) {
+            if (!this.docs.has(file))
+                await this.htmlChanged(file);
+            return;
+        }
+        await this.otherChanged(file);
+    }
+    /** a non-HTML file: reload projects that read it */
+    async otherChanged(file) {
+        for (const [root, p] of this.projects) {
+            const state = await p;
+            if (!state.inputs.has(file))
+                continue;
+            const next = this.load(root);
+            this.projects.set(root, next);
+            const fresh = await next;
+            // pages the old state knew but the new one doesn't lose their diagnostics
+            for (const page of state.pages)
+                if (!fresh.pages.has(page))
+                    state.diagnostics.delete(page);
+            this.publishAll(fresh);
+        }
+    }
+    async htmlChanged(file) {
+        const state = await this.projectFor(file);
+        const includers = [...state.includes].filter(([, files]) => files.includes(file)).map(([page]) => page);
+        const pages = new Set(includers);
+        if (state.pages.has(file) || !includers.length) {
+            if (this.docs.has(file) || existsSync(file)) {
+                state.pages.add(file);
+                pages.add(file);
+            }
+        }
+        this.compilePages(state, [...pages]);
+    }
+    /** the text of a file: the open buffer, else the disk */
+    read(file) {
+        return this.docs.get(file) ?? readFileSync(file, 'utf8');
+    }
+    compilePages(state, pages) {
+        const p = state.project;
+        const readFile = (path) => {
+            const disk = p.readFile(path); // refuses files outside the root
+            return this.docs.get(resolve(path)) ?? disk;
+        };
+        for (const page of pages) {
+            let html;
+            try {
+                html = this.read(page);
+            }
+            catch {
+                continue;
+            }
+            // a page that is now included by another one is a partial, not a page
+            if (!state.entries.has(page) && [...state.includes].some(([other, files]) => other !== page && files.includes(page))) {
+                state.pages.delete(page);
+                state.diagnostics.delete(page);
+                state.includes.delete(page);
+                state.units.delete(page);
+                state.types.delete(page);
+                continue;
+            }
+            try {
+                const out = compile(html, {
+                    file: page, root: state.root, dev: false, helpers: p.helpers, config: p.config, readFile, check: true, openapi: p.openapi,
+                });
+                state.includes.set(page, out.files.map((f) => resolve(f)).filter((f) => f !== page));
+                state.diagnostics.set(page, out.diagnostics);
+                if (out.check)
+                    state.units.set(page, out.check);
+            }
+            catch (e) {
+                state.diagnostics.set(page, [{ severity: 'error', code: 'SN401', message: `sinter could not compile this page: ${e.message}`, file: page, line: 1, col: 1 }]);
+            }
+        }
+        this.publishAll(state);
+        this.hooks.compiled?.(state, pages.filter((x) => state.pages.has(x)));
+    }
+    /** Sets TypeScript's diagnostics under `key` (a page) and publishes. Ignored for a replaced project state. */
+    async setTypes(state, key, list) {
+        if ((await this.projects.get(state.root)) !== state)
+            return;
+        state.types.set(key, list);
+        this.publishAll(state);
+    }
+    /** Publishes every file's diagnostics, merged across the pages that include it. */
+    publishAll(state) {
+        const byFile = new Map();
+        const seen = new Set();
+        const add = (d) => {
+            const key = `${d.file}\0${d.line}\0${d.col}\0${d.code}\0${d.message}`;
+            if (seen.has(key))
+                return;
+            seen.add(key);
+            const list = byFile.get(d.file) ?? [];
+            list.push(d);
+            byFile.set(d.file, list);
+        };
+        for (const d of state.project.diagnostics)
+            add(d);
+        for (const page of state.pages)
+            for (const d of state.diagnostics.get(page) ?? [])
+                add(d);
+        for (const list of state.types.values())
+            for (const d of list)
+                add(d);
+        // files of this project that had diagnostics and now have none
+        for (const file of this.published) {
+            if (byFile.has(file) || this.rootOf(file) !== state.root)
+                continue;
+            this.published.delete(file);
+            this.hooks.publish(file, []);
+        }
+        for (const [file, list] of byFile) {
+            this.published.add(file);
+            this.hooks.publish(file, list);
+        }
+        // open files without problems get an empty list, so editors show them as checked
+        for (const file of this.docs.keys())
+            if (!byFile.has(file) && this.rootOf(file) === state.root)
+                this.hooks.publish(file, []);
+    }
+}

package/dist/optimistic.d.ts

@@ -0,0 +1,3 @@
+import type { Feature } from './runtime/app.js';
+declare const optimistic: Feature;
+export default optimistic;

package/dist/optimistic.js

@@ -0,0 +1,15 @@
+const optimistic = {
+    name: 'optimistic',
+    install(app) {
+        app.ext.optimistic = {
+            begin(fn, scope) {
+                return app.record(() => {
+                    const s = Object.create(scope);
+                    s.$f = app.storeFns(null);
+                    app.fns[fn](s);
+                });
+            },
+        };
+    },
+};
+export default optimistic;

package/dist/paginate.d.ts

@@ -0,0 +1,3 @@
+import type { Feature } from './runtime/app.js';
+declare const paginate: Feature;
+export default paginate;