@xpert-ai/plugin-excalidraw 0.1.0

package/dist/lib/excalidraw.plugin.d.ts

@@ -0,0 +1,8 @@
+import type { IOnPluginBootstrap, IOnPluginDestroy } from '@xpert-ai/plugin-sdk';
+import { ExcalidrawActionLog, ExcalidrawDrawing, ExcalidrawDrawingVersion } from './entities/index.js';
+export declare const EXCALIDRAW_ENTITIES: (typeof ExcalidrawActionLog | typeof ExcalidrawDrawing | typeof ExcalidrawDrawingVersion)[];
+export declare class ExcalidrawPlugin implements IOnPluginBootstrap, IOnPluginDestroy {
+    onPluginBootstrap(): void | Promise<void>;
+    onPluginDestroy(): void | Promise<void>;
+}
+//# sourceMappingURL=excalidraw.plugin.d.ts.map

package/dist/lib/excalidraw.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excalidraw.plugin.d.ts","sourceRoot":"","sources":["../../src/lib/excalidraw.plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAEhF,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAKtG,eAAO,MAAM,mBAAmB,6FAAqE,CAAA;AAErG,qBAMa,gBAAiB,YAAW,kBAAkB,EAAE,gBAAgB;IAC3E,iBAAiB,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAIzC,eAAe,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CAGxC"}

package/dist/lib/excalidraw.plugin.js

@@ -0,0 +1,27 @@
+var ExcalidrawPlugin_1;
+import { __decorate } from "tslib";
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { XpertServerPlugin } from '@xpert-ai/plugin-sdk';
+import { ExcalidrawActionLog, ExcalidrawDrawing, ExcalidrawDrawingVersion } from './entities/index.js';
+import { ExcalidrawMiddleware } from './excalidraw.middleware.js';
+import { ExcalidrawService } from './excalidraw.service.js';
+import { ExcalidrawViewProvider } from './excalidraw-view.provider.js';
+export const EXCALIDRAW_ENTITIES = [ExcalidrawDrawing, ExcalidrawDrawingVersion, ExcalidrawActionLog];
+let ExcalidrawPlugin = ExcalidrawPlugin_1 = class ExcalidrawPlugin {
+    onPluginBootstrap() {
+        console.log(`${ExcalidrawPlugin_1.name} is being bootstrapped...`);
+    }
+    onPluginDestroy() {
+        console.log(`${ExcalidrawPlugin_1.name} is being destroyed...`);
+    }
+};
+ExcalidrawPlugin = ExcalidrawPlugin_1 = __decorate([
+    XpertServerPlugin({
+        imports: [TypeOrmModule.forFeature(EXCALIDRAW_ENTITIES)],
+        entities: EXCALIDRAW_ENTITIES,
+        providers: [ExcalidrawService, ExcalidrawMiddleware, ExcalidrawViewProvider],
+        exports: [ExcalidrawService]
+    })
+], ExcalidrawPlugin);
+export { ExcalidrawPlugin };
+//# sourceMappingURL=excalidraw.plugin.js.map

package/dist/lib/excalidraw.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"excalidraw.plugin.js","sourceRoot":"","sources":["../../src/lib/excalidraw.plugin.ts"],"names":[],"mappings":";;AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AACxD,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AACtG,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAEtE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,iBAAiB,EAAE,wBAAwB,EAAE,mBAAmB,CAAC,CAAA;AAQ9F,IAAM,gBAAgB,wBAAtB,MAAM,gBAAgB;IAC3B,iBAAiB;QACf,OAAO,CAAC,GAAG,CAAC,GAAG,kBAAgB,CAAC,IAAI,2BAA2B,CAAC,CAAA;IAClE,CAAC;IAED,eAAe;QACb,OAAO,CAAC,GAAG,CAAC,GAAG,kBAAgB,CAAC,IAAI,wBAAwB,CAAC,CAAA;IAC/D,CAAC;CACF,CAAA;AARY,gBAAgB;IAN5B,iBAAiB,CAAC;QACjB,OAAO,EAAE,CAAC,aAAa,CAAC,UAAU,CAAC,mBAAmB,CAAC,CAAC;QACxD,QAAQ,EAAE,mBAAmB;QAC7B,SAAS,EAAE,CAAC,iBAAiB,EAAE,oBAAoB,EAAE,sBAAsB,CAAC;QAC5E,OAAO,EAAE,CAAC,iBAAiB,CAAC;KAC7B,CAAC;GACW,gBAAgB,CAQ5B"}

package/dist/lib/excalidraw.service.d.ts

@@ -0,0 +1,169 @@
+import { Repository } from 'typeorm';
+import { ExcalidrawActionLog, ExcalidrawDrawing, ExcalidrawDrawingVersion } from './entities/index.js';
+import type { CreateExcalidrawDrawingInput, ExcalidrawScope, PatchExcalidrawSceneInput, ReportExcalidrawFailureInput, SaveExcalidrawMermaidDraftInput, SaveExcalidrawSceneVersionInput, SearchExcalidrawDrawingsInput, UpdateExcalidrawDrawingStatusInput } from './types.js';
+export declare class ExcalidrawService {
+    private readonly drawingRepository;
+    private readonly versionRepository;
+    private readonly logRepository;
+    constructor(drawingRepository: Repository<ExcalidrawDrawing>, versionRepository: Repository<ExcalidrawDrawingVersion>, logRepository: Repository<ExcalidrawActionLog>);
+    createDrawing(scope: ExcalidrawScope, input: CreateExcalidrawDrawingInput): Promise<{
+        item: ExcalidrawDrawing;
+        currentVersion: ExcalidrawDrawingVersion;
+        versions: ExcalidrawDrawingVersion[];
+        logs: ExcalidrawActionLog[];
+        total: number;
+        summary: {
+            versionCount: number;
+            currentVersionNumber: number;
+            hasMermaidDraft: boolean;
+        };
+    }>;
+    saveSceneVersion(scope: ExcalidrawScope, input: SaveExcalidrawSceneVersionInput): Promise<{
+        success: boolean;
+        message: string;
+        drawing: {
+            item: ExcalidrawDrawing;
+            currentVersion: ExcalidrawDrawingVersion;
+            versions: ExcalidrawDrawingVersion[];
+            logs: ExcalidrawActionLog[];
+            total: number;
+            summary: {
+                versionCount: number;
+                currentVersionNumber: number;
+                hasMermaidDraft: boolean;
+            };
+        };
+        version: ExcalidrawDrawingVersion;
+    }>;
+    patchScene(scope: ExcalidrawScope, input: PatchExcalidrawSceneInput): Promise<{
+        success: boolean;
+        message: string;
+        drawing: {
+            item: ExcalidrawDrawing;
+            currentVersion: ExcalidrawDrawingVersion;
+            versions: ExcalidrawDrawingVersion[];
+            logs: ExcalidrawActionLog[];
+            total: number;
+            summary: {
+                versionCount: number;
+                currentVersionNumber: number;
+                hasMermaidDraft: boolean;
+            };
+        };
+        version: ExcalidrawDrawingVersion;
+    }>;
+    saveMermaidDraft(scope: ExcalidrawScope, input: SaveExcalidrawMermaidDraftInput): Promise<{
+        success: boolean;
+        message: string;
+        drawing: {
+            item: ExcalidrawDrawing;
+            currentVersion: ExcalidrawDrawingVersion;
+            versions: ExcalidrawDrawingVersion[];
+            logs: ExcalidrawActionLog[];
+            total: number;
+            summary: {
+                versionCount: number;
+                currentVersionNumber: number;
+                hasMermaidDraft: boolean;
+            };
+        };
+        version: ExcalidrawDrawingVersion;
+    }>;
+    searchDrawings(scope: ExcalidrawScope, query?: SearchExcalidrawDrawingsInput): Promise<{
+        items: ExcalidrawDrawing[];
+        total: number;
+        page: number;
+        pageSize: number;
+        search: string;
+    }>;
+    getDrawing(scope: ExcalidrawScope, drawingId: string): Promise<{
+        item: ExcalidrawDrawing;
+        currentVersion: ExcalidrawDrawingVersion;
+        versions: ExcalidrawDrawingVersion[];
+        logs: ExcalidrawActionLog[];
+        total: number;
+        summary: {
+            versionCount: number;
+            currentVersionNumber: number;
+            hasMermaidDraft: boolean;
+        };
+    }>;
+    getWorkbenchData(scope: ExcalidrawScope, query?: SearchExcalidrawDrawingsInput & {
+        drawingId?: string;
+    }): Promise<{
+        item: ExcalidrawDrawing;
+        currentVersion: ExcalidrawDrawingVersion;
+        versions: ExcalidrawDrawingVersion[];
+        logs: ExcalidrawActionLog[];
+        total: number;
+        summary: {
+            versionCount: number;
+            currentVersionNumber: number;
+            hasMermaidDraft: boolean;
+        };
+    } | {
+        summary: {
+            page: number;
+            pageSize: number;
+            search: string;
+        };
+        items: ExcalidrawDrawing[];
+        total: number;
+        page: number;
+        pageSize: number;
+        search: string;
+    }>;
+    updateDrawingStatus(scope: ExcalidrawScope, input: UpdateExcalidrawDrawingStatusInput): Promise<{
+        success: boolean;
+        message: string;
+        item: {
+            status: import("./types.js").ExcalidrawDrawingStatus;
+            lastEditedById: string;
+            lastEditedAt: Date;
+            id?: string;
+            tenantId?: string;
+            organizationId?: string;
+            workspaceId?: string;
+            projectId?: string;
+            createdById?: string;
+            assistantId?: string;
+            conversationId?: string;
+            title: string;
+            description?: string;
+            kind?: import("./types.js").ExcalidrawDrawingKind;
+            tags?: string[];
+            source?: string;
+            currentVersionId?: string;
+            currentVersionNumber?: number;
+            createdAt?: Date;
+            updatedAt?: Date;
+        } & ExcalidrawDrawing;
+    }>;
+    restoreVersion(scope: ExcalidrawScope, drawingId: string, versionId: string, changeSummary?: string): Promise<{
+        success: boolean;
+        message: string;
+        drawing: {
+            item: ExcalidrawDrawing;
+            currentVersion: ExcalidrawDrawingVersion;
+            versions: ExcalidrawDrawingVersion[];
+            logs: ExcalidrawActionLog[];
+            total: number;
+            summary: {
+                versionCount: number;
+                currentVersionNumber: number;
+                hasMermaidDraft: boolean;
+            };
+        };
+        version: ExcalidrawDrawingVersion;
+    }>;
+    reportFailure(scope: ExcalidrawScope, input: ReportExcalidrawFailureInput): Promise<{
+        success: boolean;
+        message: string;
+        log: ExcalidrawActionLog;
+    }>;
+    private createVersion;
+    private getCurrentVersion;
+    private requireDrawing;
+    private writeLog;
+}
+//# sourceMappingURL=excalidraw.service.d.ts.map

package/dist/lib/excalidraw.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"excalidraw.service.d.ts","sourceRoot":"","sources":["../../src/lib/excalidraw.service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AACtG,OAAO,KAAK,EACV,4BAA4B,EAG5B,eAAe,EAGf,yBAAyB,EACzB,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,6BAA6B,EAC7B,kCAAkC,EACnC,MAAM,YAAY,CAAA;AASnB,qBACa,iBAAiB;IAG1B,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAElC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAElC,OAAO,CAAC,QAAQ,CAAC,aAAa;gBAJb,iBAAiB,EAAE,UAAU,CAAC,iBAAiB,CAAC,EAEhD,iBAAiB,EAAE,UAAU,CAAC,wBAAwB,CAAC,EAEvD,aAAa,EAAE,UAAU,CAAC,mBAAmB,CAAC;IAG3D,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,4BAA4B;;;;;;;;;;;;IA0CzE,gBAAgB,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,+BAA+B;;;;;;;;;;;;;;;;;IAmB/E,UAAU,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,yBAAyB;;;;;;;;;;;;;;;;;IAyCnE,gBAAgB,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,+BAA+B;;;;;;;;;;;;;;;;;IAsC/E,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,GAAE,6BAAkC;;;;;;;IAmChF,UAAU,CAAC,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM;;;;;;;;;;;;IAgCpD,gBAAgB,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,GAAE,6BAA6B,GAAG;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAO;;;;;;;;;;;;;;;;;;;;;;;IAe3G,mBAAmB,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;IAyBrF,cAAc,CAAC,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;IAmCnG,aAAa,CAAC,KAAK,EAAE,eAAe,EAAE,KAAK,EAAE,4BAA4B;;;;;YAqBjE,aAAa;YAoDb,iBAAiB;YASjB,cAAc;YAUd,QAAQ;CA0BvB"}

package/dist/lib/excalidraw.service.js

@@ -0,0 +1,441 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { ExcalidrawActionLog, ExcalidrawDrawing, ExcalidrawDrawingVersion } from './entities/index.js';
+let ExcalidrawService = class ExcalidrawService {
+    constructor(drawingRepository, versionRepository, logRepository) {
+        this.drawingRepository = drawingRepository;
+        this.versionRepository = versionRepository;
+        this.logRepository = logRepository;
+    }
+    async createDrawing(scope, input) {
+        const title = normalizeRequired(input.title, 'Drawing title is required.');
+        const drawing = await this.drawingRepository.save(this.drawingRepository.create({
+            ...scopedCreate(scope),
+            assistantId: scope.assistantId ?? null,
+            conversationId: scope.conversationId ?? null,
+            createdById: scope.userId ?? null,
+            title,
+            description: normalizeOptional(input.description),
+            kind: input.kind ?? 'diagram',
+            status: 'draft',
+            tags: normalizeStringArray(input.tags),
+            source: normalizeOptional(input.source),
+            currentVersionNumber: 0,
+            lastEditedById: scope.userId ?? null,
+            lastEditedAt: new Date()
+        }));
+        await this.writeLog(scope, {
+            drawingId: drawing.id,
+            action: 'drawing_created',
+            actorType: scope.assistantId ? 'agent' : 'user',
+            message: `Drawing "${title}" was created.`,
+            snapshot: { title, kind: drawing.kind, source: drawing.source }
+        });
+        if (hasSceneContent(input)) {
+            await this.createVersion(scope, drawing, {
+                sourceType: input.mermaidSource ? 'agent_mermaid' : 'agent_json',
+                elements: normalizeElements(input.elements),
+                appState: normalizeObject(input.appState),
+                files: normalizeObject(input.files),
+                mermaidSource: normalizeNullableText(input.mermaidSource),
+                changeSummary: normalizeOptional(input.changeSummary) ?? 'Initial scene'
+            });
+        }
+        return this.getDrawing(scope, drawing.id);
+    }
+    async saveSceneVersion(scope, input) {
+        const drawing = await this.requireDrawing(scope, input.drawingId);
+        const version = await this.createVersion(scope, drawing, {
+            sourceType: input.sourceType ?? 'agent_json',
+            elements: normalizeElements(input.elements),
+            appState: normalizeObject(input.appState),
+            files: normalizeObject(input.files),
+            mermaidSource: normalizeNullableText(input.mermaidSource),
+            changeSummary: normalizeOptional(input.changeSummary)
+        });
+        return {
+            success: true,
+            message: 'Excalidraw scene version was saved.',
+            drawing: await this.getDrawing(scope, drawing.id),
+            version
+        };
+    }
+    async patchScene(scope, input) {
+        const drawing = await this.requireDrawing(scope, input.drawingId);
+        const currentVersion = await this.getCurrentVersion(scope, drawing);
+        const patchedElements = applyElementPatch(currentVersion?.elements ?? [], input);
+        const appState = {
+            ...(isPlainObject(currentVersion?.appState) ? currentVersion?.appState : {}),
+            ...(isPlainObject(input.appStatePatch) ? input.appStatePatch : {})
+        };
+        const version = await this.createVersion(scope, drawing, {
+            sourceType: 'agent_patch',
+            elements: patchedElements,
+            appState,
+            files: input.files === undefined ? normalizeObject(currentVersion?.files) : normalizeObject(input.files),
+            mermaidSource: input.mermaidSource === undefined
+                ? normalizeNullableText(currentVersion?.mermaidSource)
+                : normalizeNullableText(input.mermaidSource),
+            changeSummary: normalizeOptional(input.changeSummary) ?? 'Agent patch'
+        });
+        await this.writeLog(scope, {
+            drawingId: drawing.id,
+            versionId: version.id,
+            action: 'scene_patched',
+            actorType: 'agent',
+            message: input.changeSummary,
+            snapshot: {
+                addCount: input.addElements?.length ?? 0,
+                updateCount: input.updateElements?.length ?? 0,
+                deleteCount: input.deleteElementIds?.length ?? 0
+            }
+        });
+        return {
+            success: true,
+            message: 'Excalidraw scene patch was saved as a new version.',
+            drawing: await this.getDrawing(scope, drawing.id),
+            version
+        };
+    }
+    async saveMermaidDraft(scope, input) {
+        const mermaidSource = normalizeRequired(input.mermaidSource, 'Mermaid source is required.');
+        const drawing = input.drawingId
+            ? await this.requireDrawing(scope, input.drawingId)
+            : (await this.createDrawing(scope, {
+                title: input.title ?? 'Untitled Mermaid Diagram',
+                description: input.description,
+                kind: input.kind ?? 'flowchart'
+            })).item;
+        const version = await this.createVersion(scope, drawing, {
+            sourceType: 'agent_mermaid',
+            elements: [],
+            appState: {},
+            files: {},
+            mermaidSource,
+            changeSummary: normalizeOptional(input.changeSummary) ?? 'Mermaid draft'
+        });
+        await this.writeLog(scope, {
+            drawingId: drawing.id,
+            versionId: version.id,
+            action: 'mermaid_draft_saved',
+            actorType: 'agent',
+            message: input.changeSummary,
+            snapshot: { mermaidSource }
+        });
+        return {
+            success: true,
+            message: 'Mermaid draft was saved. Convert it in the Excalidraw workbench to make it editable.',
+            drawing: await this.getDrawing(scope, drawing.id),
+            version
+        };
+    }
+    async searchDrawings(scope, query = {}) {
+        const page = Math.max(1, query.page ?? 1);
+        const pageSize = Math.max(1, Math.min(query.pageSize ?? 20, 100));
+        const search = query.search?.trim().toLowerCase() ?? '';
+        const drawings = await this.drawingRepository.find({
+            where: scopedWhere(scope),
+            order: {
+                updatedAt: 'DESC'
+            }
+        });
+        const filtered = drawings.filter((drawing) => {
+            if (query.status && drawing.status !== query.status) {
+                return false;
+            }
+            if (query.kind && drawing.kind !== query.kind) {
+                return false;
+            }
+            if (!search) {
+                return true;
+            }
+            return [drawing.title, drawing.description, drawing.kind, ...(drawing.tags ?? [])]
+                .filter(isString)
+                .some((value) => value.toLowerCase().includes(search));
+        });
+        const start = (page - 1) * pageSize;
+        return {
+            items: filtered.slice(start, start + pageSize),
+            total: filtered.length,
+            page,
+            pageSize,
+            search
+        };
+    }
+    async getDrawing(scope, drawingId) {
+        const drawing = await this.requireDrawing(scope, drawingId);
+        const [versions, logs] = await Promise.all([
+            this.versionRepository.find({
+                where: scopedWhere(scope, { drawingId }),
+                order: {
+                    versionNumber: 'DESC'
+                }
+            }),
+            this.logRepository.find({
+                where: scopedWhere(scope, { drawingId }),
+                order: {
+                    createdAt: 'DESC'
+                }
+            })
+        ]);
+        const currentVersion = versions.find((version) => version.id === drawing.currentVersionId) ?? versions[0] ?? null;
+        return {
+            item: drawing,
+            currentVersion,
+            versions,
+            logs,
+            total: versions.length,
+            summary: {
+                versionCount: versions.length,
+                currentVersionNumber: drawing.currentVersionNumber ?? currentVersion?.versionNumber ?? 0,
+                hasMermaidDraft: versions.some((version) => Boolean(version.mermaidSource))
+            }
+        };
+    }
+    async getWorkbenchData(scope, query = {}) {
+        if (query.drawingId) {
+            return this.getDrawing(scope, query.drawingId);
+        }
+        const result = await this.searchDrawings(scope, query);
+        return {
+            ...result,
+            summary: {
+                page: result.page,
+                pageSize: result.pageSize,
+                search: result.search
+            }
+        };
+    }
+    async updateDrawingStatus(scope, input) {
+        const drawing = await this.requireDrawing(scope, input.drawingId);
+        const updated = await this.drawingRepository.save({
+            ...drawing,
+            status: input.status,
+            lastEditedById: scope.userId ?? null,
+            lastEditedAt: new Date()
+        });
+        await this.writeLog(scope, {
+            drawingId: drawing.id,
+            versionId: drawing.currentVersionId,
+            action: input.status === 'archived' ? 'drawing_archived' : 'status_updated',
+            actorType: scope.assistantId ? 'agent' : 'user',
+            message: input.reason ?? `Status updated to ${input.status}`,
+            snapshot: { status: input.status }
+        });
+        return {
+            success: true,
+            message: 'Excalidraw drawing status was updated.',
+            item: updated
+        };
+    }
+    async restoreVersion(scope, drawingId, versionId, changeSummary) {
+        const drawing = await this.requireDrawing(scope, drawingId);
+        const version = await this.versionRepository.findOne({
+            where: scopedWhere(scope, { id: versionId, drawingId })
+        });
+        if (!version) {
+            throw new NotFoundException('Excalidraw drawing version was not found.');
+        }
+        const restored = await this.createVersion(scope, drawing, {
+            sourceType: 'restore',
+            elements: normalizeElements(version.elements),
+            appState: normalizeObject(version.appState),
+            files: normalizeObject(version.files),
+            mermaidSource: normalizeNullableText(version.mermaidSource),
+            changeSummary: normalizeOptional(changeSummary) ?? `Restored version ${version.versionNumber}`
+        });
+        await this.writeLog(scope, {
+            drawingId,
+            versionId: restored.id,
+            action: 'version_restored',
+            actorType: 'user',
+            message: changeSummary,
+            snapshot: { restoredFromVersionId: versionId, restoredFromVersionNumber: version.versionNumber }
+        });
+        return {
+            success: true,
+            message: 'Excalidraw drawing version was restored.',
+            drawing: await this.getDrawing(scope, drawingId),
+            version: restored
+        };
+    }
+    async reportFailure(scope, input) {
+        const log = await this.writeLog(scope, {
+            drawingId: input.drawingId,
+            versionId: input.versionId,
+            action: 'failure_reported',
+            actorType: scope.assistantId ? 'agent' : 'system',
+            message: input.operation,
+            errorMessage: input.errorMessage,
+            snapshot: {
+                recoverable: input.recoverable,
+                evidence: input.evidence
+            }
+        });
+        return {
+            success: true,
+            message: 'Excalidraw drawing failure was recorded.',
+            log
+        };
+    }
+    async createVersion(scope, drawing, input) {
+        const currentVersionNumber = drawing.currentVersionNumber ?? 0;
+        const versionNumber = currentVersionNumber + 1;
+        const version = await this.versionRepository.save(this.versionRepository.create({
+            ...scopedCreate(scope),
+            drawingId: drawing.id,
+            versionNumber,
+            sourceType: input.sourceType,
+            elements: normalizeElements(input.elements),
+            appState: normalizeObject(input.appState),
+            files: normalizeObject(input.files),
+            mermaidSource: normalizeNullableText(input.mermaidSource),
+            changeSummary: normalizeOptional(input.changeSummary),
+            createdById: scope.userId ?? null,
+            assistantId: scope.assistantId ?? null,
+            conversationId: scope.conversationId ?? null
+        }));
+        await this.drawingRepository.save({
+            ...drawing,
+            currentVersionId: version.id,
+            currentVersionNumber: version.versionNumber,
+            lastEditedById: scope.userId ?? null,
+            lastEditedAt: new Date()
+        });
+        await this.writeLog(scope, {
+            drawingId: drawing.id,
+            versionId: version.id,
+            action: 'version_saved',
+            actorType: input.sourceType.startsWith('agent') ? 'agent' : 'user',
+            message: input.changeSummary,
+            snapshot: {
+                versionNumber,
+                sourceType: input.sourceType,
+                elementCount: version.elements?.length ?? 0,
+                hasMermaidSource: Boolean(version.mermaidSource)
+            }
+        });
+        return version;
+    }
+    async getCurrentVersion(scope, drawing) {
+        if (!drawing.currentVersionId) {
+            return null;
+        }
+        return this.versionRepository.findOne({
+            where: scopedWhere(scope, { id: drawing.currentVersionId, drawingId: drawing.id })
+        });
+    }
+    async requireDrawing(scope, drawingId) {
+        const drawing = await this.drawingRepository.findOne({
+            where: scopedWhere(scope, { id: normalizeRequired(drawingId, 'Drawing id is required.') })
+        });
+        if (!drawing) {
+            throw new NotFoundException('Excalidraw drawing was not found.');
+        }
+        return drawing;
+    }
+    async writeLog(scope, input) {
+        return this.logRepository.save(this.logRepository.create({
+            ...scopedCreate(scope),
+            drawingId: input.drawingId ?? null,
+            versionId: input.versionId ?? null,
+            action: input.action,
+            actorType: input.actorType ?? 'system',
+            actorId: scope.userId ?? scope.assistantId ?? null,
+            message: normalizeOptional(input.message),
+            errorMessage: normalizeOptional(input.errorMessage),
+            snapshot: input.snapshot
+        }));
+    }
+};
+ExcalidrawService = __decorate([
+    Injectable(),
+    __param(0, InjectRepository(ExcalidrawDrawing)),
+    __param(1, InjectRepository(ExcalidrawDrawingVersion)),
+    __param(2, InjectRepository(ExcalidrawActionLog)),
+    __metadata("design:paramtypes", [Repository,
+        Repository,
+        Repository])
+], ExcalidrawService);
+export { ExcalidrawService };
+function scopedCreate(scope) {
+    return {
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId ?? null,
+        workspaceId: scope.workspaceId ?? null,
+        projectId: scope.projectId ?? null,
+        createdById: scope.userId ?? null
+    };
+}
+function scopedWhere(scope, extra) {
+    const where = {
+        tenantId: scope.tenantId
+    };
+    if (scope.organizationId != null) {
+        where.organizationId = scope.organizationId;
+    }
+    if (scope.projectId != null) {
+        where.projectId = scope.projectId;
+    }
+    else if (scope.workspaceId != null) {
+        where.workspaceId = scope.workspaceId;
+    }
+    return {
+        ...where,
+        ...(extra ?? {})
+    };
+}
+function normalizeRequired(value, message) {
+    const normalized = normalizeOptional(value);
+    if (!normalized) {
+        throw new BadRequestException(message);
+    }
+    return normalized;
+}
+function normalizeOptional(value) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+}
+function normalizeNullableText(value) {
+    return normalizeOptional(value) ?? null;
+}
+function normalizeStringArray(values) {
+    const normalized = (values ?? []).map((value) => normalizeOptional(value)).filter(isString);
+    return normalized.length ? Array.from(new Set(normalized)) : undefined;
+}
+function normalizeElements(elements) {
+    return Array.isArray(elements) ? elements : [];
+}
+function normalizeObject(value) {
+    return isPlainObject(value) ? value : {};
+}
+function hasSceneContent(input) {
+    return Boolean((Array.isArray(input.elements) && input.elements.length > 0) || input.mermaidSource || input.appState || input.files);
+}
+function applyElementPatch(elements, input) {
+    const deleteIds = new Set(input.deleteElementIds ?? []);
+    const updates = new Map((input.updateElements ?? []).map((item) => [item.id, item]));
+    const next = elements
+        .filter((element) => {
+        const id = readElementId(element);
+        return !id || !deleteIds.has(id);
+    })
+        .map((element) => {
+        const id = readElementId(element);
+        const update = id ? updates.get(id) : null;
+        return update && isPlainObject(element) ? { ...element, ...update } : element;
+    });
+    return [...next, ...normalizeElements(input.addElements)];
+}
+function readElementId(element) {
+    return isPlainObject(element) && typeof element.id === 'string' ? element.id : null;
+}
+function isPlainObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function isString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+//# sourceMappingURL=excalidraw.service.js.map