@divlet/core 0.0.1 → 0.0.3

package/dist/core/lib/browser-runtime.d.ts

@@ -0,0 +1,598 @@
+import type { DocumentModel } from './model.ts';
+import type { ProjectSettings } from './project.ts';
+import type { FrameCompiler, PreparedFrame } from './prepare.ts';
+/** Tools this writer runs. `open_divlet` belongs to hosts that can open files; `create_frame` is a hidden host route. */
+export declare const BROWSER_TOOLS: readonly string[];
+interface Entry extends PreparedFrame {
+    render: number;
+    savedVersion: number;
+}
+type Listener = (type: 'state' | 'change', value: unknown) => void;
+export interface BrowserRuntimeOptions {
+    /** The project source (`.divlet` JSON text or the parsed object). */
+    readonly source: unknown;
+    /** A label for the project, shown where the Node host shows its file path. Never a filesystem path. */
+    readonly file: string;
+    /** A stable identifier for this browser copy of the project. */
+    readonly projectId: string;
+    readonly compiler: FrameCompiler;
+    /** Called after every accepted change with the serialized project; a rejection is reported as a diagnostic, never retried. */
+    readonly persist?: (text: string) => Promise<void> | void;
+    /** Capabilities the composition adds (for example `captureFonts: false`); merged into `project.capabilities`. */
+    readonly capabilities?: Record<string, unknown>;
+}
+export declare class BrowserRuntime {
+    #private;
+    readonly file: string;
+    readonly projectId: string;
+    settings: ProjectSettings;
+    documents: Map<string, Entry>;
+    diagnostics: Map<string, any>;
+    observations: Map<string, any>;
+    selection: {
+        ids: string[];
+        revision: number;
+        selectedNodes?: any;
+    };
+    revision: number;
+    stateVersion: number;
+    renderSeq: number;
+    history: any[];
+    seq: number;
+    undoStack: any[];
+    redoStack: any[];
+    groupCounter: number;
+    work: any[];
+    /** `conversation: false`: this host relays no board requests; agents reach it through its MCP tools. */
+    agent: {
+        connected: boolean;
+        busy: boolean;
+        activity: string | null;
+        since: string | null;
+        queued: number;
+        conversation: false;
+    };
+    closed: boolean;
+    url: string;
+    private constructor();
+    /** Validate and render a project source; any invalid frame refuses the whole open (there is no last working state yet). */
+    static open(options: BrowserRuntimeOptions): Promise<BrowserRuntime>;
+    subscribe(listener: Listener): () => void;
+    publish(): void;
+    newGroup(): string;
+    enqueue<T>(task: () => Promise<T> | T): Promise<T>;
+    usedBy(id: string, entries?: Map<string, Entry>): string[];
+    describe(entry: Entry): {
+        id: string;
+        name: string;
+        version: number;
+        render: number;
+        savedVersion: number;
+        artboard: import("./model.ts").Artboard;
+        metadata: import("./model.ts").Metadata;
+        components: string[];
+        instances: number;
+        uses: string[];
+        usedBy: string[];
+    };
+    historyHead(): {
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    };
+    info(): {
+        stateVersion: number;
+        projectId: string;
+        url: string;
+        revision: number;
+        project: {
+            file: string;
+            format: string;
+            capabilities: {
+                properties: boolean;
+                settings: boolean;
+                frames: boolean;
+                saveAs: boolean;
+            };
+            name: string;
+            version: number;
+            tokens: Record<string, string>;
+            css: string;
+            metadata: import("./model.ts").Metadata;
+            outputDir: string | null;
+            resources: never[];
+        };
+        documents: {
+            id: string;
+            name: string;
+            version: number;
+            render: number;
+            savedVersion: number;
+            artboard: import("./model.ts").Artboard;
+            metadata: import("./model.ts").Metadata;
+            components: string[];
+            instances: number;
+            uses: string[];
+            usedBy: string[];
+        }[];
+        diagnostics: any[];
+        selection: {
+            ids: string[];
+            revision: number;
+            selectedNodes?: any;
+        };
+        history: {
+            seq: number;
+            pointId: string;
+            navigation: boolean;
+            canUndo: boolean;
+            canRedo: boolean;
+            undoLabel: any;
+            redoLabel: any;
+        };
+        clients: number;
+        agent: {
+            connected: boolean;
+            busy: boolean;
+            activity: string | null;
+            since: string | null;
+            queued: number;
+            conversation: false;
+        };
+        work: any[];
+        site: null;
+        clientPlugins: never[];
+    };
+    getEntry(id: unknown): Entry;
+    components(): {
+        instances: string[];
+        ref: string;
+        frameId: import("./model.ts").NodeId;
+        nodeId: import("./model.ts").NodeId;
+        name: string;
+        tag: string;
+        texts: Array<{
+            id: import("./model.ts").NodeId;
+            content: string;
+        }>;
+    }[];
+    readTimeline(): import("./history.ts").HistoryTimeline;
+    readHistory({ since, limit, documentId, actor }?: any): {
+        timeline: import("./history.ts").HistoryTimeline;
+        truncated: boolean;
+        changes: any[];
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    };
+    read({ view, documentId, ids, query, depth, limit, route, since }?: any): DocumentModel | {
+        stateVersion: number;
+        projectId: string;
+        url: string;
+        revision: number;
+        project: {
+            file: string;
+            format: string;
+            capabilities: {
+                properties: boolean;
+                settings: boolean;
+                frames: boolean;
+                saveAs: boolean;
+            };
+            name: string;
+            version: number;
+            tokens: Record<string, string>;
+            css: string;
+            metadata: import("./model.ts").Metadata;
+            outputDir: string | null;
+            resources: never[];
+        };
+        documents: {
+            id: string;
+            name: string;
+            version: number;
+            render: number;
+            savedVersion: number;
+            artboard: import("./model.ts").Artboard;
+            metadata: import("./model.ts").Metadata;
+            components: string[];
+            instances: number;
+            uses: string[];
+            usedBy: string[];
+        }[];
+        diagnostics: any[];
+        selection: {
+            ids: string[];
+            revision: number;
+            selectedNodes?: any;
+        };
+        history: {
+            seq: number;
+            pointId: string;
+            navigation: boolean;
+            canUndo: boolean;
+            canRedo: boolean;
+            undoLabel: any;
+            redoLabel: any;
+        };
+        clients: number;
+        agent: {
+            connected: boolean;
+            busy: boolean;
+            activity: string | null;
+            since: string | null;
+            queued: number;
+            conversation: false;
+        };
+        work: any[];
+        site: null;
+        clientPlugins: never[];
+    } | {
+        timeline: import("./history.ts").HistoryTimeline;
+        truncated: boolean;
+        changes: any[];
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    } | {
+        projectVersion: number;
+        components: {
+            instances: string[];
+            ref: string;
+            frameId: import("./model.ts").NodeId;
+            nodeId: import("./model.ts").NodeId;
+            name: string;
+            tag: string;
+            texts: Array<{
+                id: import("./model.ts").NodeId;
+                content: string;
+            }>;
+        }[];
+        projectRevision?: undefined;
+        selection?: undefined;
+        revision?: undefined;
+        diagnostics?: undefined;
+        documentId?: undefined;
+        version?: undefined;
+        nodes?: undefined;
+        observation?: undefined;
+    } | {
+        projectRevision: number;
+        selection: {
+            ids: string[];
+            revision: number;
+            selectedNodes?: any;
+        };
+        projectVersion?: undefined;
+        components?: undefined;
+        revision?: undefined;
+        diagnostics?: undefined;
+        documentId?: undefined;
+        version?: undefined;
+        nodes?: undefined;
+        observation?: undefined;
+    } | {
+        revision: number;
+        diagnostics: any[];
+        projectVersion?: undefined;
+        components?: undefined;
+        projectRevision?: undefined;
+        selection?: undefined;
+        documentId?: undefined;
+        version?: undefined;
+        nodes?: undefined;
+        observation?: undefined;
+    } | {
+        documentId: string;
+        version: number;
+        nodes: import("./model.ts").InspectResult;
+        projectVersion?: undefined;
+        components?: undefined;
+        projectRevision?: undefined;
+        selection?: undefined;
+        revision?: undefined;
+        diagnostics?: undefined;
+        observation?: undefined;
+    } | {
+        documentId: string;
+        version: number;
+        observation: any;
+        projectVersion?: undefined;
+        components?: undefined;
+        projectRevision?: undefined;
+        selection?: undefined;
+        revision?: undefined;
+        diagnostics?: undefined;
+        nodes?: undefined;
+    };
+    /** The preview page of one frame (no bridge: the composition injects its own preview channel). */
+    render(id: string): {
+        documentId: string;
+        version: number;
+        render: number;
+        html: string;
+    };
+    /** Clean standalone HTML of a frame or of some of its nodes, as the Node host exports it (no embedded assets here). */
+    exportDocument(id: string, { nodeId, nodeIds, expectedVersion, expectedProjectVersion }?: any): {
+        html: string;
+        nodeId: any;
+        documentId: string;
+        version: number;
+        fileName?: undefined;
+    } | {
+        html: string;
+        nodeIds: any[];
+        documentId: string;
+        version: number;
+        fileName?: undefined;
+    } | {
+        documentId: string;
+        version: number;
+        html: string;
+        fileName: string;
+    };
+    /** The serialized project, as the Node host would write it to its `.divlet` file. */
+    source(): string;
+    prepare(input: unknown, { frames, settings }?: {
+        frames?: Map<string, DocumentModel>;
+        settings?: ProjectSettings;
+    }): Promise<PreparedFrame>;
+    entryFor(prepared: PreparedFrame, previous?: Entry): Entry;
+    dependentsOf(ids: string[], entries?: Map<string, Entry>): string[];
+    prepareAll(ids: string[], frames: Map<string, DocumentModel>, settings: ProjectSettings): Promise<Map<string, PreparedFrame>>;
+    /** Persist the candidate through the host. A failing store keeps the accepted state and reports a diagnostic. */
+    persist(next: Map<string, Entry>, settings: ProjectSettings): Promise<void>;
+    record({ actor, kind, documentId, name, fromVersion, toVersion, group, label, from, to, text }: any): any;
+    pushUndo(entry: any, { seq, firstSeq }?: {
+        seq?: number;
+        firstSeq?: number;
+    }): void;
+    create({ document, actor, group, label, undoable }: any): Promise<{
+        documentId: string;
+        version: number;
+        render: number;
+        revision: number;
+        seq: any;
+        saved: boolean;
+    }>;
+    _create({ document, actor, group, label, undoable, kind, text }: any): Promise<{
+        documentId: string;
+        version: number;
+        render: number;
+        revision: number;
+        seq: any;
+        saved: boolean;
+    }>;
+    _remove(documentId: string, { actor, group, label, expectedVersion, undoable, kind }: any): Promise<{
+        documentId: string;
+        seq: any;
+        revision: number;
+    }>;
+    patch({ documentId, expectedVersion, expectedRender, patch, actor, group, label, undoable }: any): Promise<{
+        warnings?: string[] | undefined;
+        documentId: any;
+        version: number;
+        render: number;
+        revision: number;
+        seq: any;
+        summary: any;
+        changedNodeIds: string[];
+        rerendered: string[];
+        saved: boolean;
+    }>;
+    _patch({ documentId, expectedVersion, expectedRender, patch, actor, group, label, undoable, kind }: any): Promise<{
+        warnings?: string[] | undefined;
+        documentId: any;
+        version: number;
+        render: number;
+        revision: number;
+        seq: any;
+        summary: any;
+        changedNodeIds: string[];
+        rerendered: string[];
+        saved: boolean;
+    }>;
+    patchProject({ expectedVersion, patch, actor, group, label, undoable }: any): Promise<{
+        project: boolean;
+        version: number;
+        revision: number;
+        seq: any;
+        summary: any;
+        saved: boolean;
+    }>;
+    _patchProject({ expectedVersion, patch, actor, group, label, undoable, kind }: any): Promise<{
+        project: boolean;
+        version: number;
+        revision: number;
+        seq: any;
+        summary: any;
+        saved: boolean;
+    }>;
+    edit({ documentId, expectedVersion, expectedRender, op, actor, group, label }: any): Promise<{
+        ids: any;
+        removed: any;
+        warnings?: string[] | undefined;
+        documentId: any;
+        version: number;
+        render: number;
+        revision: number;
+        seq: any;
+        summary: any;
+        changedNodeIds: string[];
+        rerendered: string[];
+        saved: boolean;
+    }>;
+    freeSpot(rect: any, gap?: number, extra?: any[]): any;
+    createArtboard({ name, width, height, x, y, from, expectedVersion, actor, group, label }?: any): Promise<{
+        documentId: string;
+        version: number;
+        render: number;
+        revision: number;
+        seq: any;
+        saved: boolean;
+    }>;
+    removeDocument({ documentId, expectedVersion, actor, group, label }: any): Promise<{
+        documentId: string;
+        seq: any;
+        revision: number;
+    }>;
+    _applyEntry(entry: any, direction: 'undo' | 'redo', actor: string): Promise<void>;
+    _replay(from: any[], to: any[], direction: 'undo' | 'redo', { documentId, actor, steps }?: any): Promise<{
+        label: any;
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    }>;
+    navigateHistory(options: any): Promise<{
+        changed: boolean;
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    } | {
+        changed: boolean;
+        label: any;
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    }>;
+    undo(options?: any): Promise<{
+        label: any;
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    }>;
+    redo(options?: any): Promise<{
+        label: any;
+        seq: number;
+        pointId: string;
+        navigation: boolean;
+        canUndo: boolean;
+        canRedo: boolean;
+        undoLabel: any;
+        redoLabel: any;
+    }>;
+    markWork({ documentId, nodeIds, note, add }?: any): {
+        marked: {
+            at: string;
+            note?: string | undefined;
+            documentId: any;
+            nodeIds: string[];
+        };
+        work: number;
+    };
+    clearWork({ documentId }?: any): {
+        cleared: number;
+    };
+    setSelection({ ids, nodes }: any): {
+        stateVersion: number;
+        projectId: string;
+        url: string;
+        revision: number;
+        project: {
+            file: string;
+            format: string;
+            capabilities: {
+                properties: boolean;
+                settings: boolean;
+                frames: boolean;
+                saveAs: boolean;
+            };
+            name: string;
+            version: number;
+            tokens: Record<string, string>;
+            css: string;
+            metadata: import("./model.ts").Metadata;
+            outputDir: string | null;
+            resources: never[];
+        };
+        documents: {
+            id: string;
+            name: string;
+            version: number;
+            render: number;
+            savedVersion: number;
+            artboard: import("./model.ts").Artboard;
+            metadata: import("./model.ts").Metadata;
+            components: string[];
+            instances: number;
+            uses: string[];
+            usedBy: string[];
+        }[];
+        diagnostics: any[];
+        selection: {
+            ids: string[];
+            revision: number;
+            selectedNodes?: any;
+        };
+        history: {
+            seq: number;
+            pointId: string;
+            navigation: boolean;
+            canUndo: boolean;
+            canRedo: boolean;
+            undoLabel: any;
+            redoLabel: any;
+        };
+        clients: number;
+        agent: {
+            connected: boolean;
+            busy: boolean;
+            activity: string | null;
+            since: string | null;
+            queued: number;
+            conversation: false;
+        };
+        work: any[];
+        site: null;
+        clientPlugins: never[];
+    };
+    setObservations({ documentId, version, nodes, contentHeight, scrollHeight }: any): {
+        ok: boolean;
+    };
+    /**
+     * What the board shows about an agent working through this page. Unlike the Node host, an idle agent keeps its work marks:
+     * stateless MCP calls carry no turn boundary, so marks end only by `mark_divlet { clear: true }` or replacement.
+     */
+    setAgent(patch?: Partial<BrowserRuntime['agent']>): {
+        connected: boolean;
+        busy: boolean;
+        activity: string | null;
+        since: string | null;
+        queued: number;
+        conversation: false;
+    };
+    /** Run one shared contract tool against this writer (the same `run` Pi, MCP and the CLI use). */
+    callTool(name: string, args: unknown): Promise<any>;
+    /** The shared tool descriptions this writer runs. */
+    tools(): import("./tools.ts").Tool[];
+    close(): Promise<void>;
+}
+export {};