@pix3/vite-plugin 0.0.0-stage → 2.0.0-alpha.0

package/dist/client/index.d.ts

@@ -0,0 +1,218 @@
+import { HostFilesClient, type HostWriteResult } from './host-files.ts';
+export { HostFilesClient } from './host-files.ts';
+/**
+ * Page side of the plugin (plan §B.2 variant B, §B.3 step 4): runs in the editor tab, imported by
+ * `virtual:pix3/editor-host`. It owns the `/__pix3/ws` connection, answers the plugin's `sync`
+ * and `flush` requests, and is the `EditorHost` the editor mounts against.
+ *
+ * Contract B (S1, finding 3): nothing in the editor's chain may make Vite inject `/@vite/client`
+ * — no `import.meta.hot`, no CSS imports, no non-literal `import()`. The one dynamic import this
+ * file needs (re-importing the script roots with a fresh `?t=`) goes through `Function`, which
+ * Vite's import analysis does not see.
+ */
+export interface ScriptRoots {
+    readonly editorScripts: RootModule;
+    readonly botPolicies: RootModule;
+}
+export interface RootModule {
+    readonly __pix3Revision: number;
+    readonly modules: Record<string, Record<string, unknown>>;
+}
+export interface FsFrame {
+    readonly type: 'pix3:fs';
+    readonly seq: number;
+    readonly revision: string;
+    readonly events: readonly {
+        readonly op: 'create' | 'modify' | 'delete' | 'rename';
+        readonly path: string;
+        readonly kind: 'file' | 'dir';
+        readonly sha256?: string;
+        readonly from?: string;
+        readonly author: 'editor' | 'external';
+    }[];
+    readonly writerId?: string;
+}
+export type HookReply = {
+    readonly ok: boolean;
+    readonly reason?: string;
+} & Record<string, unknown>;
+export interface SyncInfo {
+    readonly rev: number;
+    /** `{path: sha256 | null}` — what the rescan found changed (null = deleted). */
+    readonly changed: Record<string, string | null>;
+    readonly roots: ScriptRoots;
+    /** Project modules only the bot policies import (the game never runs them). */
+    readonly policyOnly: readonly string[];
+}
+/** What the editor plugs in. Every hook is optional: an absent one is a no-op that succeeds. */
+export interface HostSyncHandlers {
+    /** Write dirty scenes now (plan §C.1); waits for pointerup up to `timeoutMs`. */
+    flush?(timeoutMs: number): Promise<HookReply>;
+    /**
+     * The roots were re-imported for a sync: register the new script classes, reload changed
+     * scenes. While play runs, answer `{ok:false, reason:'stale', playing, pending}` (plan §B.3).
+     */
+    applySync?(info: SyncInfo): Promise<HookReply>;
+}
+export interface HostOptions {
+    /** Vite `base` (always ends with `/`). */
+    readonly base: string;
+    /** The roots as the page first imported them (static imports of `editor-host`). */
+    readonly roots: ScriptRoots;
+}
+export interface HostVersions {
+    readonly plugin: string;
+    readonly runtime: string | null;
+    readonly editorCore: string | null;
+    readonly vite: string;
+}
+/** The plugin's `welcome` frame (re-sent after every reconnect). */
+export interface Hello {
+    readonly tabId: string;
+    readonly seq: number;
+    readonly revision: string;
+    readonly writerId: string | null;
+    readonly root: string;
+    readonly resRoot: string;
+    readonly projectName: string;
+    readonly versions: HostVersions;
+}
+export interface HostInfo {
+    readonly base: string;
+    readonly root: string;
+    readonly resRoot: string;
+    readonly projectName: string;
+    readonly tabId: string;
+    readonly seq: number;
+    readonly revision: string;
+    readonly versions: HostVersions;
+}
+export type HostHistoryAuthor = 'editor' | 'external' | 'restore' | 'rejected-draft';
+export interface HostHistoryEntry {
+    readonly id: string;
+    readonly path: string;
+    readonly author: HostHistoryAuthor;
+    readonly at: number;
+    readonly sha256: string;
+    readonly size: number;
+    readonly note?: string;
+}
+export interface HostHistory {
+    list(path: string): Promise<HostHistoryEntry[]>;
+    read(path: string, id: string): Promise<string | null>;
+    record(path: string, text: string, author: 'rejected-draft', note?: string): Promise<HostHistoryEntry>;
+    restore(path: string, id: string, options?: {
+        ifMatch?: string;
+    }): Promise<HostWriteResult>;
+}
+export type HostImageProvider = 'gemini' | 'openai';
+export interface HostImageKeyStatus {
+    readonly set: boolean;
+    /** The key's last four characters (keys of 12+ characters only). */
+    readonly last4?: string;
+}
+/** Image-generation keys and the proxy that uses them (plan §B.1); the page never sees a key. */
+export interface HostImageGen {
+    keys(): Promise<Record<HostImageProvider, HostImageKeyStatus>>;
+    /** Store (`null` / `''` removes) a key on the dev server's machine; answers its status only. */
+    setKey(provider: HostImageProvider, key: string | null): Promise<HostImageKeyStatus & {
+        readonly where: 'home' | 'project';
+    }>;
+    /** `fetch` of `/__pix3/api/proxy/<provider>/<path>`; the plugin adds the key. */
+    fetch(provider: HostImageProvider, path: string, init?: RequestInit): Promise<Response>;
+}
+export interface HostClaim {
+    readonly writerId: string;
+    readonly seq: number;
+    readonly revision: string;
+    readonly hashes: Record<string, string>;
+}
+type Listener<T> = (value: T) => void;
+/**
+ * True when Vite's HMR client got onto this page — contract B is broken and a `full-reload` can
+ * reach the editor. The page's inline probe (`editor-page.ts`) keeps `__PIX3_VITE_CLIENT__`
+ * current for the tab's whole life; the timeline is read too, because the observer reports
+ * asynchronously. Checked at load and on every sync (the answer carries `viteClient: true`), and
+ * `pix3_status` shows it.
+ */
+export declare const viteClientLoaded: () => boolean;
+/**
+ * The page's `EditorHost` (`@pix3/editor-core` defines the contract, `.plans/editor-core-port.md`
+ * §1): what `mountEditor(el, host)` talks to. Structural — the type lives in editor-core and this
+ * package only checks conformance in a spec, so no runtime edge exists between the two.
+ */
+export declare class EditorHostConnection {
+    #private;
+    readonly tabId: string;
+    readonly base: string;
+    readonly files: HostFilesClient;
+    readonly events: {
+        onFs(listener: Listener<FsFrame>): () => void;
+        onConnection(listener: Listener<'open' | 'closed'>): () => void;
+    };
+    readonly scripts: {
+        current(): ScriptRoots;
+        onChange(listener: Listener<ScriptRoots>): () => void;
+    };
+    readonly sync: {
+        setHandlers(handlers: HostSyncHandlers): void;
+        run(options?: {
+            expect?: Record<string, string>;
+            timeoutMs?: number;
+        }): Promise<HookReply>;
+    };
+    readonly writer: {
+        readonly id: string | null;
+        readonly isSelf: boolean;
+        claim(): Promise<HostClaim>;
+        onChange(listener: Listener<string | null>): () => void;
+    };
+    /** The version journal `.pix3/history/` (plan §C.4). */
+    readonly history: HostHistory;
+    readonly imageGen: HostImageGen;
+    private roots;
+    private handlers;
+    private socket;
+    private hello;
+    /** Tab the plugin says may write (from `welcome` and `pix3:writer`). */
+    private writerTab;
+    private readonly helloWaiters;
+    private readonly fsListeners;
+    private readonly connectionListeners;
+    private readonly scriptListeners;
+    private readonly writerListeners;
+    private retryMs;
+    /** The contract-B error is logged once per tab. */
+    private viteClientReported;
+    private closed;
+    constructor(options: HostOptions);
+    /** `/__pix3/api/<route>` for the editor-only routes: the session token on every method. */
+    private sessionCall;
+    private imageGenApi;
+    /** {@link api} with failures as {@link HostFileError} (`network` when nothing answered). */
+    private call;
+    private postJson;
+    /** Filled from the plugin's `welcome`; available once {@link ready} resolved. */
+    get info(): HostInfo;
+    get currentRoots(): ScriptRoots;
+    /** Resolves with the plugin's `welcome` (re-sent after every reconnect). */
+    ready(): Promise<Hello>;
+    connect(): void;
+    close(): void;
+    /** `fetch` against `/__pix3/api/<route>` with the headers mutations need. */
+    api(route: string, init?: RequestInit): Promise<Response>;
+    /** Become the writer (plan §C.3 step 2): the plugin answers with the disk to start from. */
+    private claim;
+    /**
+     * `pix3_sync` from this tab: flush first (this tab's own handler), then the plugin's barrier
+     * with this tab as the one that confirms.
+     */
+    private runSync;
+    private emit;
+    private setWriter;
+    private reimportRoots;
+    private executed;
+    private reply;
+    private onMessage;
+    private onRequest;
+}

package/dist/client/index.js

@@ -0,0 +1,381 @@
+import { failureOf, HostFileError, HostFilesClient, networkError, } from "./host-files.js";
+export { HostFilesClient } from "./host-files.js";
+/**
+ * The editor session token the page was served with (`<meta name="pix3-session">`), read once
+ * and removed from the DOM. Only a top-level navigation of the editor page carries one.
+ */
+const takeSessionToken = () => {
+    if (typeof document === 'undefined')
+        return null;
+    const meta = document.querySelector('meta[name="pix3-session"]');
+    const token = meta?.getAttribute('content') ?? null;
+    meta?.remove();
+    return token;
+};
+const subscribe = (set, listener) => {
+    set.add(listener);
+    return () => set.delete(listener);
+};
+const dynamicImport = new Function('url', 'return import(url)');
+const rootUrl = (base, id) => 
+// Vite strips only `t=\d{13}` from a module URL; anything else would not resolve (S1, finding 4).
+`${base}@id/__x00__${id}?t=${String(Date.now()).padStart(13, '0')}`;
+const newTabId = () => typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function'
+    ? crypto.randomUUID()
+    : `tab-${Math.random().toString(36).slice(2)}-${Date.now()}`;
+/**
+ * True when Vite's HMR client got onto this page — contract B is broken and a `full-reload` can
+ * reach the editor. The page's inline probe (`editor-page.ts`) keeps `__PIX3_VITE_CLIENT__`
+ * current for the tab's whole life; the timeline is read too, because the observer reports
+ * asynchronously. Checked at load and on every sync (the answer carries `viteClient: true`), and
+ * `pix3_status` shows it.
+ */
+export const viteClientLoaded = () => globalThis.__PIX3_VITE_CLIENT__ === true ||
+    (typeof performance !== 'undefined' &&
+        performance
+            .getEntriesByType('resource')
+            .some(entry => new URL(entry.name, location.href).pathname.endsWith('/@vite/client')));
+const VITE_CLIENT_MESSAGE = '[pix3] /@vite/client is loaded on the editor page: a non-literal import(), import.meta.hot or a CSS import reached the editor chain (plan §B.2, contract B; `pix3 check` names the file).';
+/**
+ * The page's `EditorHost` (`@pix3/editor-core` defines the contract, `.plans/editor-core-port.md`
+ * §1): what `mountEditor(el, host)` talks to. Structural — the type lives in editor-core and this
+ * package only checks conformance in a spec, so no runtime edge exists between the two.
+ */
+export class EditorHostConnection {
+    tabId = newTabId();
+    base;
+    files;
+    events;
+    scripts;
+    sync;
+    writer;
+    /** The version journal `.pix3/history/` (plan §C.4). */
+    history;
+    imageGen;
+    #session = takeSessionToken();
+    roots;
+    handlers = {};
+    socket = null;
+    hello = null;
+    /** Tab the plugin says may write (from `welcome` and `pix3:writer`). */
+    writerTab = null;
+    helloWaiters = [];
+    fsListeners = new Set();
+    connectionListeners = new Set();
+    scriptListeners = new Set();
+    writerListeners = new Set();
+    retryMs = 250;
+    /** The contract-B error is logged once per tab. */
+    viteClientReported = false;
+    closed = false;
+    constructor(options) {
+        this.base = options.base;
+        this.roots = options.roots;
+        this.files = new HostFilesClient(this);
+        this.events = {
+            onFs: listener => subscribe(this.fsListeners, listener),
+            onConnection: listener => subscribe(this.connectionListeners, listener),
+        };
+        this.scripts = {
+            current: () => this.roots,
+            onChange: listener => subscribe(this.scriptListeners, listener),
+        };
+        this.sync = {
+            setHandlers: handlers => {
+                this.handlers = handlers;
+            },
+            run: options => this.runSync(options),
+        };
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        const connection = this;
+        this.writer = {
+            get id() {
+                return connection.writerTab;
+            },
+            get isSelf() {
+                return connection.writerTab === connection.tabId;
+            },
+            claim: () => this.claim(),
+            onChange: listener => subscribe(this.writerListeners, listener),
+        };
+        this.imageGen = this.imageGenApi();
+        this.history = {
+            list: async (path) => {
+                const response = await this.call(`history?path=${encodeURIComponent(path)}`);
+                if (!response.ok)
+                    throw await failureOf(response);
+                return (await response.json()).entries;
+            },
+            read: async (path, id) => {
+                const response = await this.call(`history/version?path=${encodeURIComponent(path)}&id=${encodeURIComponent(id)}`);
+                if (response.status === 404)
+                    return null;
+                if (!response.ok)
+                    throw await failureOf(response);
+                return response.text();
+            },
+            record: (path, text, author, note) => this.postJson('history/record', {
+                path,
+                text,
+                author,
+                ...(note ? { note } : {}),
+            }),
+            restore: (path, id, options = {}) => this.postJson('history/restore', { path, id }, options.ifMatch
+                ? { 'If-Match': options.ifMatch === '*' ? '*' : `"${options.ifMatch}"` }
+                : {}),
+        };
+    }
+    /** `/__pix3/api/<route>` for the editor-only routes: the session token on every method. */
+    sessionCall(route, init = {}) {
+        const headers = new Headers(init.headers);
+        headers.set('X-Pix3', '1');
+        if (this.#session)
+            headers.set('X-Pix3-Session', this.#session);
+        return fetch(`${this.base}__pix3/api/${route}`, { ...init, headers });
+    }
+    imageGenApi() {
+        const json = async (response) => {
+            if (!response.ok)
+                throw await failureOf(response);
+            return (await response.json());
+        };
+        return {
+            keys: async () => (await json(await this.sessionCall('keys'))).keys,
+            setKey: async (provider, key) => json(await this.sessionCall('keys', {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ provider, key }),
+            })),
+            fetch: (provider, path, init = {}) => this.sessionCall(`proxy/${provider}/${path.replace(/^\/+/, '')}`, {
+                ...init,
+                method: init.method ?? 'POST',
+            }),
+        };
+    }
+    /** {@link api} with failures as {@link HostFileError} (`network` when nothing answered). */
+    async call(route, init) {
+        try {
+            return await this.api(route, init);
+        }
+        catch (error) {
+            throw networkError(error);
+        }
+    }
+    async postJson(route, body, headers = {}) {
+        const response = await this.call(route, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', ...headers },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok)
+            throw await failureOf(response);
+        return (await response.json());
+    }
+    /** Filled from the plugin's `welcome`; available once {@link ready} resolved. */
+    get info() {
+        const hello = this.hello;
+        if (!hello)
+            throw new Error('The editor host is not connected yet (await host.ready()).');
+        return {
+            base: this.base,
+            root: hello.root,
+            resRoot: hello.resRoot,
+            projectName: hello.projectName,
+            tabId: this.tabId,
+            seq: hello.seq,
+            revision: hello.revision,
+            versions: hello.versions,
+        };
+    }
+    get currentRoots() {
+        return this.roots;
+    }
+    /** Resolves with the plugin's `welcome` (re-sent after every reconnect). */
+    ready() {
+        if (this.hello)
+            return Promise.resolve(this.hello);
+        return new Promise(resolve => this.helloWaiters.push(resolve));
+    }
+    connect() {
+        if (this.closed)
+            return;
+        const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const socket = new WebSocket(`${protocol}//${location.host}${this.base}__pix3/ws`);
+        this.socket = socket;
+        socket.addEventListener('open', () => {
+            this.retryMs = 250;
+            socket.send(JSON.stringify({ type: 'hello', tabId: this.tabId }));
+        });
+        socket.addEventListener('message', event => {
+            void this.onMessage(String(event.data));
+        });
+        socket.addEventListener('close', () => {
+            if (this.socket !== socket)
+                return;
+            this.socket = null;
+            this.emit(this.connectionListeners, 'closed');
+            if (this.closed)
+                return;
+            // The dev server died or restarted: keep editing in memory and try again (plan §C.3).
+            setTimeout(() => this.connect(), this.retryMs);
+            this.retryMs = Math.min(this.retryMs * 2, 5_000);
+        });
+    }
+    close() {
+        this.closed = true;
+        this.socket?.close();
+    }
+    /** `fetch` against `/__pix3/api/<route>` with the headers mutations need. */
+    async api(route, init = {}) {
+        const headers = new Headers(init.headers);
+        const method = (init.method ?? 'GET').toUpperCase();
+        if (method !== 'GET' && method !== 'HEAD') {
+            headers.set('X-Pix3', '1');
+            headers.set('X-Pix3-Writer', this.tabId);
+        }
+        return fetch(`${this.base}__pix3/api/${route}`, { ...init, headers });
+    }
+    /** Become the writer (plan §C.3 step 2): the plugin answers with the disk to start from. */
+    async claim() {
+        const response = await this.api('handover/claim', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ writerId: this.tabId }),
+        });
+        const body = (await response.json());
+        if (!response.ok) {
+            throw new HostFileError({
+                code: 'other',
+                status: response.status,
+                message: typeof body.message === 'string' ? body.message : 'Claim refused.',
+            });
+        }
+        this.setWriter(this.tabId);
+        return body;
+    }
+    /**
+     * `pix3_sync` from this tab: flush first (this tab's own handler), then the plugin's barrier
+     * with this tab as the one that confirms.
+     */
+    async runSync(options = {}) {
+        const timeoutMs = options.timeoutMs ?? 10_000;
+        const flushed = this.handlers.flush ? await this.handlers.flush(timeoutMs) : { ok: true };
+        if (!flushed.ok)
+            return { ...flushed, ok: false, step: 'flush' };
+        const response = await this.api('sync', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ expect: options.expect, timeoutMs, tabId: this.tabId }),
+        });
+        return (await response.json());
+    }
+    emit(listeners, value) {
+        for (const listener of [...listeners]) {
+            try {
+                listener(value);
+            }
+            catch (error) {
+                console.error('[pix3] host listener failed', error);
+            }
+        }
+    }
+    setWriter(writerId) {
+        if (writerId === this.writerTab)
+            return;
+        this.writerTab = writerId;
+        this.emit(this.writerListeners, writerId);
+    }
+    async reimportRoots() {
+        const [editorScripts, botPolicies] = await Promise.all([
+            dynamicImport(rootUrl(this.base, 'virtual:pix3/editor-scripts')),
+            dynamicImport(rootUrl(this.base, 'virtual:pix3/bot-policies')),
+        ]);
+        this.roots = {
+            editorScripts: editorScripts,
+            botPolicies: botPolicies,
+        };
+        return this.roots;
+    }
+    executed() {
+        const stamps = globalThis.__pix3Executed;
+        return { ...(stamps ?? {}) };
+    }
+    reply(id, body) {
+        this.socket?.send(JSON.stringify({ type: 'reply', id, ...body }));
+    }
+    async onMessage(text) {
+        let message;
+        try {
+            message = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        switch (message.type) {
+            case 'welcome': {
+                const hello = { ...message, tabId: this.tabId };
+                this.hello = hello;
+                this.setWriter(hello.writerId);
+                this.emit(this.connectionListeners, 'open');
+                for (const waiter of this.helloWaiters.splice(0))
+                    waiter(hello);
+                return;
+            }
+            case 'pix3:fs':
+                this.emit(this.fsListeners, message);
+                return;
+            case 'pix3:writer':
+                this.setWriter(typeof message.writerId === 'string' ? message.writerId : null);
+                return;
+            case 'pix3:scripts':
+                this.emit(this.scriptListeners, await this.reimportRoots());
+                return;
+            case 'request':
+                await this.onRequest(message);
+                return;
+            default:
+                return;
+        }
+    }
+    async onRequest(message) {
+        const id = String(message.id);
+        try {
+            if (message.kind === 'flush') {
+                const timeoutMs = typeof message.timeoutMs === 'number' ? message.timeoutMs : 10_000;
+                this.reply(id, this.handlers.flush ? await this.handlers.flush(timeoutMs) : { ok: true });
+                return;
+            }
+            if (message.kind === 'sync') {
+                const roots = await this.reimportRoots();
+                const changed = (message.changed ?? {});
+                const rev = roots.editorScripts.__pix3Revision;
+                const policyOnly = Array.isArray(message.policyOnly)
+                    ? message.policyOnly.filter((path) => typeof path === 'string')
+                    : [];
+                const applied = this.handlers.applySync
+                    ? await this.handlers.applySync({ rev, changed, roots, policyOnly })
+                    : { ok: true };
+                const viteClient = viteClientLoaded();
+                if (viteClient && !this.viteClientReported) {
+                    this.viteClientReported = true;
+                    console.error(VITE_CLIENT_MESSAGE);
+                }
+                this.reply(id, {
+                    ...applied,
+                    rev,
+                    executed: this.executed(),
+                    ...(viteClient ? { viteClient: true } : {}),
+                });
+                return;
+            }
+            this.reply(id, { ok: false, reason: 'unknown_request' });
+        }
+        catch (error) {
+            this.reply(id, {
+                ok: false,
+                reason: 'page_error',
+                detail: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+}

package/dist/dev-info.d.ts

@@ -0,0 +1,55 @@
+/**
+ * `.pix3/dev.json` (plan §B.1 «Обнаружение»): how `pix3 editor`, `pix3 check` and the agent kit
+ * find the running dev server. Written when the server listens, removed when it closes — and
+ * only by the process that wrote it, so a second dev server on the same project does not delete
+ * the first one's record on its way out.
+ */
+export interface Versions {
+    readonly plugin: string;
+    readonly runtime: string | null;
+    readonly editorCore: string | null;
+    readonly vite: string;
+}
+export interface DevInfo {
+    readonly url: string;
+    readonly editorUrl: string;
+    readonly port: number;
+    readonly pid: number;
+    readonly versions: Versions;
+    readonly startedAt: string;
+    /**
+     * Where the browser reaches this server when that is not `url` (Remote SSH, plan §E.3: VS Code
+     * forwards 5173 to another local port). `PIX3_PUBLIC_URL` when set, else learnt from the
+     * `Origin` of an editor tab that connected through another address. Absent = `url`.
+     */
+    readonly publicUrl?: string;
+    readonly publicEditorUrl?: string;
+}
+/**
+ * The public base URL for `dev.json`: `PIX3_PUBLIC_URL` (an origin or an origin with the base
+ * path) wins; otherwise a tab's `Origin` that is not this server's own loopback address. Null
+ * when neither says anything new. The result always ends with `base`.
+ */
+export declare const publicUrlOf: (options: {
+    readonly env?: string | undefined;
+    readonly tabOrigin?: string | null;
+    readonly port: number;
+    readonly base: string;
+}) => string | null;
+export declare const devJsonPath: (root: string) => string;
+export declare const writeDevInfo: (root: string, info: DevInfo) => void;
+export declare const clearDevInfo: (root: string, pid?: number) => void;
+/** The plugin's own version (its `package.json`, one level above `src/` and `dist/`). */
+export declare const pluginVersion: () => string;
+/**
+ * Directory of an installed package as the project sees it: `node_modules/<name>` in the root or
+ * any ancestor (hoisting). Not `require.resolve` — `@pix3/runtime` does not export its
+ * `package.json`.
+ */
+export declare const findPackageDir: (root: string, name: string) => string | null;
+export declare const installedVersion: (root: string, name: string) => string | null;
+/**
+ * Plan §A.3 gate: the project's `@pix3/runtime` must equal `@pix3/editor-core` exactly for
+ * prereleases and share major.minor for releases. Returns the problem, or null.
+ */
+export declare const versionMismatch: (runtime: string | null, editorCore: string | null) => string | null;