@xpert-ai/plugin-canvas 0.1.0

package/dist/lib/canvas.service.js

@@ -0,0 +1,1290 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { BadRequestException, Inject, Injectable, NotFoundException, Optional } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { createHash, randomUUID } from 'node:crypto';
+import { extname } from 'node:path';
+import { generateKeyBetween } from 'fractional-indexing';
+import { Repository } from 'typeorm';
+import { XPERT_RUNTIME_CAPABILITIES_TOKEN } from '@xpert-ai/plugin-sdk';
+import { CanvasActionLog, CanvasDocument, CanvasDocumentVersion } from './entities/index.js';
+import { CanvasSnapshotValidationError, compactRecordForAgent, compactSnapshotForAgent, createEmptyCanvasSnapshot, isCanvasSnapshot, normalizeCanvasSnapshot, summarizeSnapshot } from './canvas-snapshot.validation.js';
+import { CANVAS_WORKSPACE_FILES_RUNTIME_CAPABILITY } from './types.js';
+const SNAPSHOT_IMAGE_MIME_TYPES = new Set(['image/png', 'image/jpeg', 'image/webp']);
+let CanvasService = class CanvasService {
+    constructor(documentRepository, versionRepository, logRepository, runtimeCapabilities) {
+        this.documentRepository = documentRepository;
+        this.versionRepository = versionRepository;
+        this.logRepository = logRepository;
+        this.runtimeCapabilities = runtimeCapabilities;
+    }
+    async createDocument(scope, input) {
+        const title = normalizeRequired(input.title, 'Canvas title is required.');
+        const document = await this.documentRepository.save(this.documentRepository.create({
+            ...scopedCreate(scope),
+            assistantId: scope.assistantId ?? null,
+            conversationId: scope.conversationId ?? null,
+            title,
+            description: normalizeOptional(input.description),
+            kind: input.kind ?? 'canvas',
+            status: 'draft',
+            tags: normalizeStringArray(input.tags),
+            source: normalizeOptional(input.source),
+            currentVersionNumber: 0,
+            lastEditedById: scope.userId ?? null,
+            lastEditedAt: new Date()
+        }));
+        await this.writeLog(scope, {
+            documentId: document.id,
+            action: 'document_created',
+            actorType: scope.assistantId ? 'agent' : 'user',
+            message: `Canvas "${title}" was created.`,
+            snapshot: { title, kind: document.kind, source: document.source }
+        });
+        if (hasSnapshotContent(input)) {
+            await this.createVersion(scope, document, {
+                sourceType: 'agent_snapshot',
+                snapshot: normalizeSnapshotInput(input.snapshot),
+                viewState: normalizeObject(input.viewState),
+                selectionSummary: normalizeObject(input.selectionSummary),
+                snapshotImage: input.snapshotImage,
+                changeSummary: normalizeOptional(input.changeSummary) ?? 'Initial canvas'
+            });
+        }
+        return this.getDocument(scope, { documentId: document.id, includeSnapshot: true });
+    }
+    async saveSnapshot(scope, input) {
+        const document = await this.requireDocument(scope, input.documentId);
+        const version = await this.createVersion(scope, document, {
+            sourceType: input.sourceType ?? 'agent_snapshot',
+            snapshot: normalizeSnapshotInput(input.snapshot),
+            viewState: normalizeObject(input.viewState),
+            selectionSummary: normalizeObject(input.selectionSummary),
+            snapshotImage: input.snapshotImage,
+            changeSummary: normalizeOptional(input.changeSummary) ?? 'Canvas snapshot saved'
+        });
+        await this.writeLog(scope, {
+            documentId: document.id,
+            versionId: version.id,
+            action: 'snapshot_saved',
+            actorType: input.sourceType === 'workbench' ? 'user' : 'agent',
+            message: input.changeSummary,
+            snapshot: summarizeSnapshot(version.snapshot)
+        });
+        return {
+            success: true,
+            message: 'Canvas snapshot was saved.',
+            document: await this.getDocument(scope, { documentId: document.id, includeSnapshot: true }),
+            version
+        };
+    }
+    async autosaveSnapshot(scope, input) {
+        const document = await this.requireDocument(scope, input.documentId);
+        const snapshot = normalizeSnapshotInput(input.snapshot);
+        const viewState = normalizeObject(input.viewState);
+        const selectionSummary = normalizeObject(input.selectionSummary);
+        const imageFields = await this.uploadSnapshotImage(scope, document, input.snapshotImage, {
+            mode: 'current',
+            sourceType: 'workbench',
+            versionNumber: document.currentVersionNumber ?? 0
+        });
+        const autosaveUpdatedAt = new Date();
+        const savedDocument = await this.documentRepository.save({
+            ...document,
+            autosaveSnapshot: snapshot,
+            autosaveViewState: viewState,
+            autosaveSelectionSummary: selectionSummary,
+            autosaveUpdatedAt,
+            autosaveBaseVersionId: document.currentVersionId ?? null,
+            ...imageFields,
+            status: document.status === 'archived' ? document.status : 'draft',
+            lastEditedById: scope.userId ?? null,
+            lastEditedAt: autosaveUpdatedAt
+        });
+        return {
+            success: true,
+            message: 'Canvas working copy was autosaved.',
+            document: await this.getDocument(scope, { documentId: savedDocument.id, includeSnapshot: true }),
+            autosave: {
+                documentId: savedDocument.id,
+                autosaveUpdatedAt,
+                autosaveBaseVersionId: savedDocument.autosaveBaseVersionId,
+                snapshotImagePath: savedDocument.snapshotImagePath,
+                snapshotImageUrl: savedDocument.snapshotImageUrl,
+                snapshotImageChecksum: savedDocument.snapshotImageChecksum,
+                snapshotSummary: summarizeSnapshot(snapshot)
+            }
+        };
+    }
+    async patchRecords(scope, input) {
+        const document = await this.requireDocument(scope, input.documentId);
+        const currentState = await this.getCurrentCanvasState(scope, document);
+        const snapshot = structuredClone(currentState.snapshot);
+        if (!isCanvasSnapshot(snapshot)) {
+            throw new BadRequestException('Current canvas snapshot is invalid.');
+        }
+        const nextStore = { ...snapshot.store };
+        const removeIds = collectUniqueStrings(input.removeRecordIds ?? [], 'removeRecordIds');
+        for (const id of removeIds) {
+            delete nextStore[id];
+        }
+        for (const record of input.putRecords ?? []) {
+            if (!isPlainObject(record) || typeof record.id !== 'string' || !record.id.trim()) {
+                throw new BadRequestException('Every putRecords item must be a tldraw record with a non-empty id.');
+            }
+            nextStore[record.id] = record;
+        }
+        const normalized = normalizeSnapshotInput({
+            ...snapshot,
+            store: nextStore
+        });
+        const viewState = {
+            ...normalizeObject(currentState.viewState),
+            ...normalizeObject(input.viewStatePatch)
+        };
+        const version = await this.createVersion(scope, document, {
+            sourceType: 'agent_patch',
+            snapshot: normalized,
+            viewState,
+            selectionSummary: input.selectionSummary === undefined ? normalizeObject(currentState.selectionSummary) : normalizeObject(input.selectionSummary),
+            changeSummary: normalizeOptional(input.changeSummary) ?? 'Canvas records patched'
+        });
+        await this.writeLog(scope, {
+            documentId: document.id,
+            versionId: version.id,
+            action: 'records_patched',
+            actorType: 'agent',
+            message: input.changeSummary,
+            snapshot: {
+                putRecordCount: input.putRecords?.length ?? 0,
+                removeRecordIds: removeIds,
+                summary: summarizeSnapshot(normalized)
+            }
+        });
+        return {
+            success: true,
+            message: 'Canvas records were patched.',
+            document: await this.getDocument(scope, { documentId: document.id, includeSnapshot: false }),
+            version: compactVersion(version)
+        };
+    }
+    async insertImage(scope, input) {
+        const dataUrl = normalizeImageDataUrl(input);
+        const imageSize = readImageSizeFromDataUrl(dataUrl, input);
+        const document = input.documentId
+            ? await this.requireDocument(scope, input.documentId)
+            : (await this.createDocument(scope, {
+                title: input.title ?? 'Untitled Canvas',
+                description: input.description,
+                kind: input.kind ?? 'image-board',
+                source: 'agent_image'
+            })).item;
+        const currentState = await this.getCurrentCanvasState(scope, document);
+        const snapshot = structuredClone(currentState.snapshot);
+        if (!isCanvasSnapshot(snapshot)) {
+            throw new BadRequestException('Current canvas snapshot is invalid.');
+        }
+        const store = { ...snapshot.store };
+        const anchorShape = input.anchorShapeId ? store[input.anchorShapeId] : null;
+        const pageId = normalizeOptional(input.pageId) ?? findPageIdForShape(store, anchorShape?.id) ?? findFirstPageId(store);
+        if (!pageId || !store[pageId]) {
+            throw new BadRequestException('Could not determine target canvas page.');
+        }
+        const holderPlacement = isAiImageHolder(anchorShape);
+        const parentId = holderPlacement ? anchorShape.id : anchorShape?.parentId && store[anchorShape.parentId]?.typeName === 'page' ? anchorShape.parentId : pageId;
+        const anchorBounds = holderPlacement ? null : pageBoundsForShape(store, anchorShape);
+        const holderBounds = holderPlacement ? pageBoundsForShape(store, anchorShape) : null;
+        const matchAnchor = input.matchAnchor !== false && (holderBounds || anchorBounds);
+        const displayWidth = positiveNumber(input.displayWidth) ?? (matchAnchor ? (holderBounds ?? anchorBounds)?.w : Math.min(imageSize.width, 512)) ?? imageSize.width;
+        const displayHeight = positiveNumber(input.displayHeight) ??
+            (matchAnchor ? (holderBounds ?? anchorBounds)?.h : Math.round(displayWidth * (imageSize.height / imageSize.width))) ??
+            imageSize.height;
+        const bounds = holderPlacement
+            ? { x: 0, y: 0, w: displayWidth, h: displayHeight }
+            : choosePlacement({
+                store,
+                pageId,
+                parentId,
+                anchorShape,
+                width: displayWidth,
+                height: displayHeight,
+                margin: Math.max(0, input.margin ?? 40),
+                placement: input.placement ?? 'right'
+            });
+        const seed = sanitizeIdPart(input.fileName ?? `canvas-image-${Date.now()}`);
+        const assetId = uniqueRecordId(store, 'asset', seed);
+        const shapeId = uniqueRecordId(store, 'shape', seed);
+        const fileName = sanitizeFileName(input.fileName ?? `${seed}.${extensionFromMimeType(dataUrl.mimeType).replace('.', '')}`, dataUrl.mimeType);
+        const fileSize = Buffer.byteLength(dataUrl.base64, 'base64');
+        const index = chooseIndex(store, parentId);
+        const assetRecord = {
+            id: assetId,
+            typeName: 'asset',
+            type: 'image',
+            props: {
+                name: fileName,
+                src: dataUrl.url,
+                w: imageSize.width,
+                h: imageSize.height,
+                fileSize,
+                mimeType: dataUrl.mimeType,
+                isAnimated: false
+            },
+            meta: normalizeObject(input.assetMeta)
+        };
+        const shapeRecord = {
+            x: bounds.x,
+            y: bounds.y,
+            rotation: 0,
+            isLocked: false,
+            opacity: 1,
+            meta: {
+                ...(holderPlacement ? { canvasGeneratedForAiImageHolder: anchorShape.id } : { canvasGeneratedStandalone: true }),
+                ...normalizeObject(input.shapeMeta)
+            },
+            id: shapeId,
+            type: 'image',
+            props: {
+                w: bounds.w,
+                h: bounds.h,
+                assetId,
+                playing: true,
+                url: '',
+                crop: null,
+                flipX: false,
+                flipY: false,
+                altText: normalizeOptional(input.altText) ?? 'Canvas inserted image'
+            },
+            parentId,
+            index,
+            typeName: 'shape'
+        };
+        store[assetId] = assetRecord;
+        store[shapeId] = shapeRecord;
+        const normalized = normalizeSnapshotInput({
+            ...snapshot,
+            store
+        });
+        const version = await this.createVersion(scope, document, {
+            sourceType: 'agent_image',
+            snapshot: normalized,
+            viewState: normalizeObject(currentState.viewState),
+            selectionSummary: {
+                selectedShapes: [shapeRecord],
+                insertedShapeId: shapeId,
+                source: 'canvas_insert_image'
+            },
+            changeSummary: normalizeOptional(input.changeSummary) ?? 'Image inserted'
+        });
+        await this.writeLog(scope, {
+            documentId: document.id,
+            versionId: version.id,
+            action: 'image_inserted',
+            actorType: 'agent',
+            message: input.changeSummary,
+            snapshot: {
+                assetId,
+                shapeId,
+                pageId,
+                parentId,
+                anchorShapeId: input.anchorShapeId,
+                bounds,
+                imageSize
+            }
+        });
+        return {
+            success: true,
+            message: 'Image was inserted into the canvas.',
+            document: await this.getDocument(scope, { documentId: document.id, includeSnapshot: false }),
+            version: compactVersion(version),
+            insertion: {
+                pageId,
+                parentId,
+                anchorShapeId: input.anchorShapeId,
+                assetId,
+                shapeId,
+                index,
+                imageSize,
+                bounds
+            }
+        };
+    }
+    async searchDocuments(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 documents = await this.documentRepository.find({
+            where: scopedWhere(scope),
+            order: {
+                updatedAt: 'DESC'
+            }
+        });
+        const filtered = documents.filter((document) => {
+            if (query.status && document.status !== query.status) {
+                return false;
+            }
+            if (query.kind && document.kind !== query.kind) {
+                return false;
+            }
+            if (!search) {
+                return true;
+            }
+            return [document.title, document.description, document.kind, ...(document.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 getDocument(scope, input) {
+        const document = await this.requireDocument(scope, input.documentId);
+        const versionLimit = Math.max(1, Math.min(input.versionLimit ?? 20, 100));
+        const logLimit = Math.max(1, Math.min(input.logLimit ?? 10, 50));
+        const logWhere = scopedWhere(scope, { documentId: document.id });
+        const [versions, logs] = await Promise.all([
+            this.versionRepository.find({
+                where: scopedWhere(scope, { documentId: document.id }),
+                order: {
+                    versionNumber: 'DESC'
+                },
+                take: versionLimit
+            }),
+            input.includeLogs
+                ? this.logRepository.find({
+                    where: logWhere,
+                    order: {
+                        createdAt: 'DESC'
+                    },
+                    take: logLimit
+                })
+                : Promise.resolve([])
+        ]);
+        const currentVersion = versions.find((version) => version.id === document.currentVersionId) ?? versions[0] ?? null;
+        const requestedVersion = selectRequestedVersion({ currentVersion, versions }, input);
+        const explicitVersion = hasExplicitVersionRequest(input);
+        const workingCopy = formatWorkingCopy(document, Boolean(input.includeSnapshot));
+        const effectiveSnapshot = explicitVersion ? requestedVersion?.snapshot ?? null : document.autosaveSnapshot ?? currentVersion?.snapshot ?? null;
+        const effectiveSceneSource = explicitVersion ? 'version' : document.autosaveSnapshot ? 'autosave' : 'version';
+        return {
+            item: document,
+            currentVersion: formatVersionForResponse(currentVersion, Boolean(input.includeSnapshot)),
+            requestedVersion: requestedVersion && requestedVersion.id !== currentVersion?.id ? formatVersionForResponse(requestedVersion, Boolean(input.includeSnapshot)) : null,
+            workingCopy,
+            versions: versions.map((version) => compactVersion(version)),
+            logs,
+            snapshotSummary: summarizeSnapshot(effectiveSnapshot),
+            scene: input.includeSnapshot ? effectiveSnapshot : compactSnapshotForAgent(effectiveSnapshot),
+            sceneSource: effectiveSceneSource,
+            snapshotImagePath: explicitVersion ? requestedVersion?.snapshotImagePath ?? null : document.snapshotImagePath ?? currentVersion?.snapshotImagePath ?? null,
+            snapshotImageUrl: explicitVersion ? requestedVersion?.snapshotImageUrl ?? null : document.snapshotImageUrl ?? currentVersion?.snapshotImageUrl ?? null,
+            snapshotImageUpdatedAt: explicitVersion ? requestedVersion?.createdAt ?? null : document.autosaveUpdatedAt ?? currentVersion?.createdAt ?? null,
+            nextActions: [
+                'Open the Canvas Workbench to review or edit the canvas.',
+                'Use canvas_get_record for exact record JSON before targeted edits.',
+                'Use canvas_patch_records for small changes or canvas_save_snapshot for a full replacement.'
+            ]
+        };
+    }
+    async getRecord(scope, input) {
+        const explicitVersion = hasExplicitVersionRequest(input);
+        const payload = await this.getDocument(scope, {
+            documentId: input.documentId,
+            versionId: input.versionId,
+            versionNumber: input.versionNumber,
+            includeSnapshot: true
+        });
+        const version = explicitVersion ? payload.requestedVersion ?? payload.currentVersion : payload.currentVersion;
+        const snapshot = explicitVersion && isVersionWithSnapshot(version) ? version.snapshot : payload.scene;
+        if (!isCanvasSnapshot(snapshot)) {
+            throw new NotFoundException('Canvas snapshot was not found.');
+        }
+        const record = snapshot.store[input.recordId];
+        if (!record) {
+            throw new NotFoundException('Canvas record was not found.');
+        }
+        return {
+            document: payload.item,
+            version: compactVersion(isVersionWithSnapshot(version) ? version : null),
+            sceneSource: payload.sceneSource,
+            record
+        };
+    }
+    async getRecordForAgent(scope, input) {
+        const result = await this.getRecord(scope, input);
+        return {
+            ...result,
+            record: compactRecordForAgent(result.record)
+        };
+    }
+    async updateDocumentStatus(scope, input) {
+        const document = await this.requireDocument(scope, input.documentId);
+        document.status = input.status;
+        document.lastEditedById = scope.userId ?? null;
+        document.lastEditedAt = new Date();
+        await this.documentRepository.save(document);
+        await this.writeLog(scope, {
+            documentId: document.id,
+            action: input.status === 'archived' ? 'document_archived' : 'status_updated',
+            actorType: scope.assistantId ? 'agent' : 'user',
+            message: input.reason,
+            snapshot: { status: input.status }
+        });
+        return {
+            success: true,
+            message: `Canvas status updated to ${input.status}.`,
+            document
+        };
+    }
+    async reportFailure(scope, input) {
+        await this.writeLog(scope, {
+            documentId: input.documentId,
+            versionId: input.versionId,
+            action: 'failure_reported',
+            actorType: 'agent',
+            message: input.operation,
+            errorMessage: normalizeRequired(input.errorMessage, 'Error message is required.'),
+            snapshot: {
+                operation: input.operation,
+                recoverable: input.recoverable ?? true,
+                evidence: input.evidence
+            }
+        });
+        return {
+            success: true,
+            message: 'Canvas failure was recorded.'
+        };
+    }
+    async restoreVersion(scope, documentId, versionId, changeSummary) {
+        const document = await this.requireDocument(scope, documentId);
+        const version = await this.versionRepository.findOne({
+            where: scopedWhere(scope, { documentId: document.id, id: versionId })
+        });
+        if (!version) {
+            throw new NotFoundException('Canvas version was not found.');
+        }
+        const restored = await this.createVersion(scope, document, {
+            sourceType: 'restore',
+            snapshot: normalizeSnapshotInput(version.snapshot),
+            viewState: normalizeObject(version.viewState),
+            selectionSummary: normalizeObject(version.selectionSummary),
+            changeSummary: normalizeOptional(changeSummary) ?? `Restored version ${version.versionNumber}`
+        });
+        await this.writeLog(scope, {
+            documentId: document.id,
+            versionId: restored.id,
+            action: 'version_restored',
+            actorType: scope.assistantId ? 'agent' : 'user',
+            message: changeSummary,
+            snapshot: { restoredVersionId: version.id, restoredVersionNumber: version.versionNumber }
+        });
+        return {
+            success: true,
+            message: 'Canvas version was restored.',
+            document: await this.getDocument(scope, { documentId: document.id, includeSnapshot: true }),
+            version: restored
+        };
+    }
+    async deleteDocument(scope, documentId) {
+        const document = await this.requireDocument(scope, documentId);
+        const versions = await this.versionRepository.find({
+            where: scopedWhere(scope, { documentId: document.id })
+        });
+        const workspaceFiles = this.runtimeCapabilities?.get(CANVAS_WORKSPACE_FILES_RUNTIME_CAPABILITY);
+        if (workspaceFiles) {
+            const cleanupTargets = [
+                document.snapshotImagePath
+                    ? {
+                        filePath: document.snapshotImagePath,
+                        scope: resolveDocumentWorkspaceScope(scope, document)
+                    }
+                    : null,
+                ...versions.map((version) => version.snapshotImagePath
+                    ? {
+                        filePath: version.snapshotImagePath,
+                        scope: resolveVersionWorkspaceScope(scope, version)
+                    }
+                    : null)
+            ].filter(Boolean);
+            await Promise.all(cleanupTargets.map(async (target) => {
+                try {
+                    await workspaceFiles.deleteFile({
+                        ...target.scope,
+                        filePath: target.filePath
+                    });
+                }
+                catch {
+                    // Workspace file cleanup is best-effort; database deletion is authoritative.
+                }
+            }));
+        }
+        await Promise.all([
+            this.versionRepository.delete(scopedWhere(scope, { documentId: document.id })),
+            this.logRepository.delete(scopedWhere(scope, { documentId: document.id }))
+        ]);
+        await this.documentRepository.delete(scopedWhere(scope, { id: document.id }));
+        return {
+            success: true,
+            message: 'Canvas document was deleted.'
+        };
+    }
+    async prepareAssistantPrompt(scope, input) {
+        const document = await this.requireDocument(scope, input.documentId);
+        const instruction = normalizeOptional(input.instruction) ?? '请根据当前画布内容继续协助我。';
+        const imagePath = normalizeOptional(document.snapshotImagePath);
+        const lines = [
+            `当前 Canvas 文档 id: ${document.id}`,
+            `标题: ${document.title}`,
+            `当前版本: ${document.currentVersionNumber ?? 0}`,
+            `当前场景来源: ${document.autosaveSnapshot ? 'autosave' : 'version'}`,
+            ...(imagePath
+                ? [
+                    `当前 viewport 快照图片路径: ${imagePath}`,
+                    `快照更新时间: ${document.autosaveUpdatedAt?.toISOString?.() ?? ''}`,
+                    `请先调用 view_image，参数 path 为 "${imagePath}"，读取这张图片后再分析画布视觉内容。`
+                ]
+                : ['当前画布还没有可供 view_image 读取的 viewport 快照图片；如需视觉分析，请先在 Workbench 自动保存或保存画布。']),
+            '',
+            instruction,
+            '',
+            '如果需要精确修改 shape，请使用 Canvas middleware tools 读取 document/record 后再 patch。'
+        ];
+        return {
+            commandKey: 'assistant.chat.send_message',
+            payload: {
+                text: lines.join('\n')
+            },
+            documentId: document.id,
+            snapshotImagePath: imagePath ?? null,
+            snapshotImageUpdatedAt: document.autosaveUpdatedAt ?? null
+        };
+    }
+    workspaceFiles() {
+        const files = this.runtimeCapabilities?.get(CANVAS_WORKSPACE_FILES_RUNTIME_CAPABILITY);
+        if (!files) {
+            throw new BadRequestException('Xpert workspace file runtime capability is required for Canvas snapshot image storage.');
+        }
+        return files;
+    }
+    async uploadSnapshotImage(scope, document, image, options) {
+        if (!image) {
+            throw new BadRequestException('Canvas snapshot image is required.');
+        }
+        const normalized = normalizeSnapshotImageData(image);
+        const checksumValue = checksum(normalized.buffer);
+        const workspaceScope = resolveDocumentWorkspaceScope(scope, document);
+        const documentId = requireEntityId(document.id, 'Canvas document id is required.');
+        const folder = options.mode === 'current'
+            ? buildCanvasSnapshotFolder(documentId)
+            : `${buildCanvasSnapshotFolder(documentId)}/versions`;
+        const fileName = options.mode === 'current' ? 'current.png' : `v${options.versionNumber}-${checksumValue.slice(0, 8)}.png`;
+        const workspaceFile = await this.workspaceFiles().uploadBuffer({
+            ...workspaceScope,
+            buffer: normalized.buffer,
+            originalName: normalizeOptional(image.fileName) ?? fileName,
+            mimeType: normalized.mimeType,
+            size: normalized.buffer.byteLength,
+            folder,
+            fileName,
+            metadata: {
+                documentType: 'canvas-snapshot-image',
+                documentId,
+                versionNumber: options.versionNumber,
+                sourceType: options.sourceType,
+                snapshotImageRole: options.mode,
+                pageId: normalizeOptional(image.pageId),
+                capturedAt: normalizeOptional(image.capturedAt),
+                width: image.width,
+                height: image.height,
+                camera: image.camera
+            }
+        });
+        return {
+            snapshotImagePath: workspaceFile.filePath,
+            snapshotImageUrl: normalizeOptional(workspaceFile.fileUrl) ?? normalizeOptional(workspaceFile.url),
+            snapshotImageMimeType: normalized.mimeType,
+            snapshotImageSize: normalized.buffer.byteLength,
+            snapshotImageChecksum: checksumValue,
+            workspaceCatalog: workspaceScope.catalog,
+            workspaceScopeId: workspaceScope.scopeId
+        };
+    }
+    async getCurrentCanvasState(scope, document) {
+        const currentVersion = await this.getCurrentVersion(scope, document);
+        if (isCanvasSnapshot(document.autosaveSnapshot)) {
+            return {
+                source: 'autosave',
+                version: currentVersion,
+                snapshot: document.autosaveSnapshot,
+                viewState: normalizeObject(document.autosaveViewState),
+                selectionSummary: normalizeObject(document.autosaveSelectionSummary)
+            };
+        }
+        return {
+            source: 'version',
+            version: currentVersion,
+            snapshot: currentVersion?.snapshot ?? createEmptyCanvasSnapshot(),
+            viewState: normalizeObject(currentVersion?.viewState),
+            selectionSummary: normalizeObject(currentVersion?.selectionSummary)
+        };
+    }
+    async createVersion(scope, document, input) {
+        const versionNumber = (document.currentVersionNumber ?? 0) + 1;
+        const [latestImageFields, versionImageFields] = input.snapshotImage
+            ? await Promise.all([
+                this.uploadSnapshotImage(scope, document, input.snapshotImage, {
+                    mode: 'current',
+                    sourceType: input.sourceType ?? 'workbench',
+                    versionNumber
+                }),
+                this.uploadSnapshotImage(scope, document, input.snapshotImage, {
+                    mode: 'version',
+                    sourceType: input.sourceType ?? 'workbench',
+                    versionNumber
+                })
+            ])
+            : [null, null];
+        const version = await this.versionRepository.save(this.versionRepository.create({
+            ...scopedCreate(scope),
+            documentId: document.id,
+            versionNumber,
+            sourceType: input.sourceType,
+            snapshot: input.snapshot,
+            viewState: input.viewState ?? null,
+            selectionSummary: input.selectionSummary ?? null,
+            ...(versionImageFields ?? {}),
+            changeSummary: normalizeOptional(input.changeSummary),
+            assistantId: scope.assistantId ?? null,
+            conversationId: scope.conversationId ?? null
+        }));
+        document.currentVersionId = version.id;
+        document.currentVersionNumber = version.versionNumber;
+        document.autosaveSnapshot = input.snapshot;
+        document.autosaveViewState = input.viewState ?? null;
+        document.autosaveSelectionSummary = input.selectionSummary ?? null;
+        document.autosaveUpdatedAt = new Date();
+        document.autosaveBaseVersionId = version.id;
+        if (latestImageFields) {
+            document.snapshotImagePath = latestImageFields.snapshotImagePath;
+            document.snapshotImageUrl = latestImageFields.snapshotImageUrl;
+            document.snapshotImageMimeType = latestImageFields.snapshotImageMimeType;
+            document.snapshotImageSize = latestImageFields.snapshotImageSize;
+            document.snapshotImageChecksum = latestImageFields.snapshotImageChecksum;
+            document.workspaceCatalog = latestImageFields.workspaceCatalog;
+            document.workspaceScopeId = latestImageFields.workspaceScopeId;
+        }
+        document.lastEditedById = scope.userId ?? scope.assistantId ?? null;
+        document.lastEditedAt = new Date();
+        await this.documentRepository.save(document);
+        return version;
+    }
+    async getCurrentVersion(scope, document) {
+        if (!document.currentVersionId) {
+            return null;
+        }
+        return this.versionRepository.findOne({
+            where: scopedWhere(scope, { id: document.currentVersionId, documentId: document.id })
+        });
+    }
+    async requireDocument(scope, documentId) {
+        const document = await this.documentRepository.findOne({
+            where: scopedWhere(scope, { id: normalizeRequired(documentId, 'Canvas document id is required.') })
+        });
+        if (!document) {
+            throw new NotFoundException('Canvas document was not found.');
+        }
+        return document;
+    }
+    async writeLog(scope, input) {
+        return this.logRepository.save(this.logRepository.create({
+            ...scopedCreate(scope),
+            documentId: input.documentId ?? 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
+        }));
+    }
+};
+CanvasService = __decorate([
+    Injectable(),
+    __param(0, InjectRepository(CanvasDocument)),
+    __param(1, InjectRepository(CanvasDocumentVersion)),
+    __param(2, InjectRepository(CanvasActionLog)),
+    __param(3, Optional()),
+    __param(3, Inject(XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Repository,
+        Repository,
+        Repository, Object])
+], CanvasService);
+export { CanvasService };
+function normalizeSnapshotInput(snapshot) {
+    try {
+        return normalizeCanvasSnapshot(snapshot ?? createEmptyCanvasSnapshot());
+    }
+    catch (error) {
+        if (error instanceof CanvasSnapshotValidationError) {
+            throw new BadRequestException(error.message);
+        }
+        throw error;
+    }
+}
+function normalizeSnapshotImageData(input) {
+    const dataUrl = normalizeOptional(input.dataUrl);
+    let mimeType;
+    let base64;
+    if (dataUrl) {
+        const parsed = parseDataUrl(dataUrl);
+        if (!parsed) {
+            throw new BadRequestException('snapshotImage.dataUrl must be a valid image data URL.');
+        }
+        mimeType = parsed.mimeType;
+        base64 = parsed.base64;
+    }
+    else {
+        base64 = normalizeRequired(input.base64, 'snapshotImage base64 or dataUrl is required.');
+        mimeType = normalizeMimeType(input.mimeType);
+    }
+    if (!SNAPSHOT_IMAGE_MIME_TYPES.has(mimeType)) {
+        throw new BadRequestException('Canvas snapshot images must be PNG, JPEG, or WebP.');
+    }
+    const buffer = Buffer.from(base64, 'base64');
+    if (buffer.byteLength === 0) {
+        throw new BadRequestException('Canvas snapshot image is empty.');
+    }
+    if (detectImageMimeType(buffer) !== mimeType) {
+        throw new BadRequestException('Canvas snapshot image bytes do not match the declared MIME type.');
+    }
+    return {
+        mimeType,
+        buffer
+    };
+}
+function normalizeImageDataUrl(input) {
+    const explicit = normalizeOptional(input.dataUrl);
+    if (explicit) {
+        const parsed = parseDataUrl(explicit);
+        if (!parsed) {
+            throw new BadRequestException('dataUrl must be a valid image data URL.');
+        }
+        return parsed;
+    }
+    const base64 = normalizeOptional(input.base64);
+    if (!base64) {
+        throw new BadRequestException('Canvas image insertion requires dataUrl or base64.');
+    }
+    const mimeType = normalizeMimeType(input.mimeType);
+    return {
+        mimeType,
+        base64,
+        url: `data:${mimeType};base64,${base64}`
+    };
+}
+function detectImageMimeType(buffer) {
+    if (buffer.length >= 24 && buffer[0] === 0x89 && buffer.toString('ascii', 1, 4) === 'PNG') {
+        return 'image/png';
+    }
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff) {
+        return 'image/jpeg';
+    }
+    if (buffer.length >= 16 && buffer.toString('ascii', 0, 4) === 'RIFF' && buffer.toString('ascii', 8, 12) === 'WEBP') {
+        return 'image/webp';
+    }
+    return null;
+}
+function parseDataUrl(value) {
+    const match = /^data:([^;,]+)?(?:;[^,]*)?,(.*)$/s.exec(value);
+    if (!match) {
+        return null;
+    }
+    const mimeType = normalizeMimeType(match[1]);
+    const encoded = match[2];
+    const isBase64 = /^data:[^,]*;base64,/i.test(value);
+    const base64 = isBase64 ? encoded : Buffer.from(decodeURIComponent(encoded)).toString('base64');
+    return {
+        mimeType,
+        base64,
+        url: `data:${mimeType};base64,${base64}`
+    };
+}
+function readImageSizeFromDataUrl(dataUrl, input) {
+    const explicitWidth = positiveNumber(input.width);
+    const explicitHeight = positiveNumber(input.height);
+    if (explicitWidth && explicitHeight) {
+        return { width: explicitWidth, height: explicitHeight };
+    }
+    const buffer = Buffer.from(dataUrl.base64, 'base64');
+    const detected = detectImageSize(buffer);
+    return {
+        width: explicitWidth ?? detected?.width ?? positiveNumber(input.displayWidth) ?? 512,
+        height: explicitHeight ?? detected?.height ?? positiveNumber(input.displayHeight) ?? 512
+    };
+}
+function detectImageSize(buffer) {
+    if (buffer.length >= 24 && buffer.toString('ascii', 1, 4) === 'PNG') {
+        return { width: buffer.readUInt32BE(16), height: buffer.readUInt32BE(20) };
+    }
+    if (buffer.length >= 10 && buffer[0] === 0xff && buffer[1] === 0xd8) {
+        let offset = 2;
+        while (offset < buffer.length - 9) {
+            if (buffer[offset] !== 0xff) {
+                break;
+            }
+            const marker = buffer[offset + 1];
+            const size = buffer.readUInt16BE(offset + 2);
+            if ((marker >= 0xc0 && marker <= 0xc3) || (marker >= 0xc5 && marker <= 0xc7) || (marker >= 0xc9 && marker <= 0xcb) || (marker >= 0xcd && marker <= 0xcf)) {
+                return { width: buffer.readUInt16BE(offset + 7), height: buffer.readUInt16BE(offset + 5) };
+            }
+            offset += 2 + size;
+        }
+    }
+    if (buffer.length >= 30 && buffer.toString('ascii', 0, 4) === 'RIFF' && buffer.toString('ascii', 8, 12) === 'WEBP') {
+        const chunk = buffer.toString('ascii', 12, 16);
+        if (chunk === 'VP8X') {
+            return {
+                width: 1 + buffer.readUIntLE(24, 3),
+                height: 1 + buffer.readUIntLE(27, 3)
+            };
+        }
+    }
+    return null;
+}
+function selectRequestedVersion(payload, input) {
+    const versions = Array.isArray(payload.versions) ? payload.versions : [];
+    if (input.versionId) {
+        const version = versions.find((candidate) => candidate.id === input.versionId);
+        if (!version) {
+            throw new NotFoundException('Requested Canvas version was not found.');
+        }
+        return version;
+    }
+    if (input.versionNumber !== undefined) {
+        const version = versions.find((candidate) => candidate.versionNumber === input.versionNumber);
+        if (!version) {
+            throw new NotFoundException('Requested Canvas version was not found.');
+        }
+        return version;
+    }
+    return payload.currentVersion ?? versions[0] ?? null;
+}
+function hasExplicitVersionRequest(input) {
+    return Boolean(input.versionId || input.versionNumber !== undefined);
+}
+function formatWorkingCopy(document, includeSnapshot) {
+    if (!isCanvasSnapshot(document.autosaveSnapshot)) {
+        return null;
+    }
+    return {
+        snapshot: includeSnapshot ? document.autosaveSnapshot : undefined,
+        scene: includeSnapshot ? undefined : compactSnapshotForAgent(document.autosaveSnapshot),
+        viewState: document.autosaveViewState,
+        selectionSummary: document.autosaveSelectionSummary,
+        autosaveUpdatedAt: document.autosaveUpdatedAt,
+        autosaveBaseVersionId: document.autosaveBaseVersionId,
+        snapshotImagePath: document.snapshotImagePath,
+        snapshotImageUrl: document.snapshotImageUrl,
+        snapshotImageMimeType: document.snapshotImageMimeType,
+        snapshotImageSize: document.snapshotImageSize,
+        snapshotImageChecksum: document.snapshotImageChecksum,
+        snapshotSummary: summarizeSnapshot(document.autosaveSnapshot)
+    };
+}
+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 formatVersionForResponse(version, includeSnapshot) {
+    if (!version) {
+        return null;
+    }
+    return includeSnapshot
+        ? version
+        : {
+            ...compactVersion(version),
+            scene: compactSnapshotForAgent(version.snapshot)
+        };
+}
+function compactVersion(version) {
+    if (!version) {
+        return null;
+    }
+    return {
+        id: version.id,
+        documentId: version.documentId,
+        versionNumber: version.versionNumber,
+        sourceType: version.sourceType,
+        viewState: version.viewState,
+        selectionSummary: version.selectionSummary,
+        snapshotImagePath: version.snapshotImagePath,
+        snapshotImageUrl: version.snapshotImageUrl,
+        snapshotImageMimeType: version.snapshotImageMimeType,
+        snapshotImageSize: version.snapshotImageSize,
+        snapshotImageChecksum: version.snapshotImageChecksum,
+        changeSummary: version.changeSummary,
+        createdAt: version.createdAt,
+        snapshotSummary: summarizeSnapshot(version.snapshot)
+    };
+}
+function isVersionWithSnapshot(value) {
+    return Boolean(value && 'snapshot' in value);
+}
+function hasSnapshotContent(input) {
+    return Boolean(input.snapshot || input.viewState || input.selectionSummary);
+}
+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 normalizeStringArray(values) {
+    const normalized = (values ?? []).map((value) => normalizeOptional(value)).filter(isString);
+    return normalized.length ? Array.from(new Set(normalized)) : undefined;
+}
+function normalizeObject(value) {
+    return isPlainObject(value) ? value : {};
+}
+function normalizeMimeType(value) {
+    const normalized = typeof value === 'string' && value.trim() ? value.trim().toLowerCase() : 'image/png';
+    return normalized.startsWith('image/') ? normalized : 'image/png';
+}
+function collectUniqueStrings(values, label) {
+    const seen = new Set();
+    for (const value of values) {
+        const normalized = normalizeRequired(value, `${label} must contain non-empty strings.`);
+        if (seen.has(normalized)) {
+            throw new BadRequestException(`${label} contains duplicate id "${normalized}".`);
+        }
+        seen.add(normalized);
+    }
+    return Array.from(seen);
+}
+function isString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isPlainObject(value) {
+    return Boolean(value && typeof value === 'object' && !Array.isArray(value));
+}
+function positiveNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : null;
+}
+function sanitizeFileName(name, mimeType) {
+    const extension = extname(name) || extensionFromMimeType(mimeType);
+    const rawBase = name.slice(0, name.length - extname(name).length);
+    const baseName = rawBase.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    return `${baseName || 'image'}${extension}`;
+}
+function extensionFromMimeType(mimeType) {
+    switch (mimeType) {
+        case 'image/apng':
+            return '.apng';
+        case 'image/avif':
+            return '.avif';
+        case 'image/gif':
+            return '.gif';
+        case 'image/jpeg':
+            return '.jpg';
+        case 'image/svg+xml':
+            return '.svg';
+        case 'image/webp':
+            return '.webp';
+        default:
+            return '.png';
+    }
+}
+function sanitizeIdPart(value) {
+    return (value
+        .replace(/\.[^.]+$/, '')
+        .replace(/[^a-zA-Z0-9_-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 80) || randomUUID());
+}
+function resolveDocumentWorkspaceScope(scope, document) {
+    if (document.workspaceCatalog === 'projects' && document.workspaceScopeId) {
+        return {
+            tenantId: scope.tenantId,
+            userId: scope.userId,
+            catalog: 'projects',
+            scopeId: document.workspaceScopeId,
+            projectId: document.workspaceScopeId
+        };
+    }
+    if (document.workspaceCatalog === 'xperts' && document.workspaceScopeId) {
+        return {
+            tenantId: scope.tenantId,
+            userId: scope.userId,
+            catalog: 'xperts',
+            scopeId: document.workspaceScopeId,
+            xpertId: document.workspaceScopeId,
+            isolateByUser: false
+        };
+    }
+    const projectId = normalizeOptional(scope.projectId) ?? normalizeOptional(document.projectId);
+    if (projectId) {
+        return {
+            tenantId: scope.tenantId,
+            userId: scope.userId,
+            catalog: 'projects',
+            scopeId: projectId,
+            projectId
+        };
+    }
+    const xpertId = normalizeOptional(scope.assistantId) ?? normalizeOptional(document.assistantId);
+    if (!xpertId) {
+        throw new BadRequestException('Canvas workspace storage requires an assistant or project scope.');
+    }
+    return {
+        tenantId: scope.tenantId,
+        userId: scope.userId,
+        catalog: 'xperts',
+        scopeId: xpertId,
+        xpertId,
+        isolateByUser: false
+    };
+}
+function resolveVersionWorkspaceScope(scope, version) {
+    if (version.workspaceCatalog === 'projects' && version.workspaceScopeId) {
+        return {
+            tenantId: scope.tenantId,
+            userId: scope.userId,
+            catalog: 'projects',
+            scopeId: version.workspaceScopeId,
+            projectId: version.workspaceScopeId
+        };
+    }
+    if (version.workspaceCatalog === 'xperts' && version.workspaceScopeId) {
+        return {
+            tenantId: scope.tenantId,
+            userId: scope.userId,
+            catalog: 'xperts',
+            scopeId: version.workspaceScopeId,
+            xpertId: version.workspaceScopeId,
+            isolateByUser: false
+        };
+    }
+    const projectId = normalizeOptional(scope.projectId);
+    if (projectId) {
+        return {
+            tenantId: scope.tenantId,
+            userId: scope.userId,
+            catalog: 'projects',
+            scopeId: projectId,
+            projectId
+        };
+    }
+    const xpertId = normalizeOptional(scope.assistantId);
+    if (!xpertId) {
+        throw new BadRequestException('Canvas version workspace scope is missing.');
+    }
+    return {
+        tenantId: scope.tenantId,
+        userId: scope.userId,
+        catalog: 'xperts',
+        scopeId: xpertId,
+        xpertId,
+        isolateByUser: false
+    };
+}
+function buildCanvasSnapshotFolder(documentId) {
+    return `files/canvas/documents/${normalizePathSegment(documentId, 'Canvas document id is required.')}/snapshots`;
+}
+function normalizePathSegment(value, message) {
+    const normalized = normalizeRequired(value, message);
+    const segment = normalized.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    if (!segment || segment === '.' || segment === '..') {
+        throw new BadRequestException('Invalid workspace path segment.');
+    }
+    return segment;
+}
+function requireEntityId(value, message) {
+    return normalizeRequired(value, message);
+}
+function checksum(buffer) {
+    return createHash('sha256').update(buffer).digest('hex');
+}
+function uniqueRecordId(store, prefix, seed) {
+    const cleanSeed = sanitizeIdPart(seed);
+    let candidate = `${prefix}:${cleanSeed}`;
+    let counter = 2;
+    while (store[candidate]) {
+        candidate = `${prefix}:${cleanSeed}-${counter}`;
+        counter += 1;
+    }
+    return candidate;
+}
+function chooseIndex(store, parentId) {
+    const siblingIndexes = Object.values(store)
+        .filter((record) => record.typeName === 'shape' && record.parentId === parentId && typeof record.index === 'string')
+        .map((record) => record.index)
+        .sort();
+    return generateKeyBetween(siblingIndexes.at(-1) ?? null, null);
+}
+function findFirstPageId(store) {
+    return Object.values(store).find((record) => record.typeName === 'page')?.id;
+}
+function findPageIdForShape(store, shapeId) {
+    if (!shapeId) {
+        return null;
+    }
+    let record = store[shapeId];
+    const visited = new Set();
+    while (record && !visited.has(record.id)) {
+        visited.add(record.id);
+        if (record.typeName === 'page') {
+            return record.id;
+        }
+        const parentId = record.parentId;
+        if (!parentId) {
+            break;
+        }
+        const parent = store[parentId];
+        if (parent?.typeName === 'page') {
+            return parent.id;
+        }
+        record = parent;
+    }
+    return null;
+}
+function isAiImageHolder(shape) {
+    return Boolean(shape?.typeName === 'shape' && shape.type === 'frame' && (shape.meta?.canvasAiImageHolder === true || shape.meta?.cowartAiImageHolder === true));
+}
+function localBoundsForShape(shape) {
+    if (!shape || shape.typeName !== 'shape') {
+        return null;
+    }
+    if (shape.type === 'arrow') {
+        const start = normalizePoint(shape.props?.start);
+        const end = normalizePoint(shape.props?.end);
+        const minX = Math.min(start.x, end.x);
+        const minY = Math.min(start.y, end.y);
+        const maxX = Math.max(start.x, end.x);
+        const maxY = Math.max(start.y, end.y);
+        return { x: minX, y: minY, w: Math.max(1, maxX - minX), h: Math.max(1, maxY - minY) };
+    }
+    const w = typeof shape.props?.w === 'number' ? shape.props.w : shape.type === 'text' ? 160 : 1;
+    const h = typeof shape.props?.h === 'number' ? shape.props.h : shape.type === 'text' ? 40 : 1;
+    return { x: 0, y: 0, w, h };
+}
+function pageBoundsForShape(store, shape) {
+    const local = localBoundsForShape(shape);
+    if (!shape || !local) {
+        return null;
+    }
+    let x = finiteNumber(shape.x, 0) + local.x;
+    let y = finiteNumber(shape.y, 0) + local.y;
+    let parent = store[shape.parentId];
+    const visited = new Set([shape.id]);
+    while (parent?.typeName === 'shape' && !visited.has(parent.id)) {
+        visited.add(parent.id);
+        x += finiteNumber(parent.x, 0);
+        y += finiteNumber(parent.y, 0);
+        parent = store[parent.parentId];
+    }
+    return { x, y, w: local.w, h: local.h };
+}
+function choosePlacement(input) {
+    if (input.placement === 'center' || !input.anchorShape) {
+        return { x: 0, y: 0, w: input.width, h: input.height };
+    }
+    const anchorBounds = pageBoundsForShape(input.store, input.anchorShape);
+    let x = anchorBounds ? anchorBounds.x + anchorBounds.w + input.margin : 0;
+    let y = anchorBounds ? anchorBounds.y : 0;
+    if (input.placement === 'left' && anchorBounds) {
+        x = anchorBounds.x - input.width - input.margin;
+    }
+    if (input.placement === 'below' && anchorBounds) {
+        x = anchorBounds.x;
+        y = anchorBounds.y + anchorBounds.h + input.margin;
+    }
+    const pageShapes = getPageShapes(input.store, input.pageId);
+    const obstacles = pageShapes
+        .filter((shape) => shape.parentId === input.parentId && shape.id !== input.anchorShape?.id)
+        .map((shape) => pageBoundsForShape(input.store, shape))
+        .filter(Boolean);
+    const stepX = Math.max(input.width + input.margin, 1);
+    const stepY = Math.max(input.height + input.margin, 1);
+    for (let attempt = 0; attempt < 60; attempt += 1) {
+        const candidate = { x, y, w: input.width, h: input.height };
+        if (!obstacles.some((bounds) => rectsOverlap(candidate, bounds, input.margin / 2))) {
+            return candidate;
+        }
+        if (input.placement === 'below') {
+            y += stepY;
+        }
+        else if (input.placement === 'left') {
+            x -= stepX;
+        }
+        else {
+            x += stepX;
+        }
+    }
+    return { x, y, w: input.width, h: input.height };
+}
+function getPageShapes(store, pageId) {
+    const shapes = [];
+    const byParent = new Map();
+    for (const record of Object.values(store)) {
+        if (record.typeName !== 'shape') {
+            continue;
+        }
+        const siblings = byParent.get(record.parentId) ?? [];
+        siblings.push(record);
+        byParent.set(record.parentId, siblings);
+    }
+    const queue = [...(byParent.get(pageId) ?? [])];
+    while (queue.length > 0) {
+        const shape = queue.shift();
+        shapes.push(shape);
+        queue.push(...(byParent.get(shape.id) ?? []));
+    }
+    return shapes;
+}
+function rectsOverlap(a, b, padding = 0) {
+    return !(a.x + a.w + padding <= b.x || b.x + b.w + padding <= a.x || a.y + a.h + padding <= b.y || b.y + b.h + padding <= a.y);
+}
+function normalizePoint(value) {
+    const object = isPlainObject(value) ? value : {};
+    return {
+        x: finiteNumber(object.x, 0),
+        y: finiteNumber(object.y, 0)
+    };
+}
+function finiteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+//# sourceMappingURL=canvas.service.js.map