@xpert-ai/plugin-live-dashboard 0.0.0-stage → 0.1.0

package/dist/lib/presentation.provider.js

@@ -0,0 +1,72 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardPresentationProvider = void 0;
+const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const dashboard_service_1 = require("./dashboard.service");
+const document_package_1 = require("./document-package");
+const remote_entry_1 = require("./remote-entry");
+const dashboard_schema_1 = require("./dashboard.schema");
+const dashboard_queries_1 = require("./dashboard-queries");
+const renderer_1 = require("./renderer");
+let DashboardPresentationProvider = class DashboardPresentationProvider {
+    constructor(runtime) {
+        this.runtime = runtime;
+        this.operations = ['query', 'query-binding'];
+    }
+    getEntry() { return (0, remote_entry_1.dashboardRemoteEntry)(true); }
+    async read(context) {
+        const saved = this.open(context);
+        return { meta: { saved, dashboards: [{ artifactId: saved.artifactId, versionId: saved.versionId, title: saved.title }], sources: [], versions: [] } };
+    }
+    async query(context, request) {
+        const saved = this.open(context);
+        const parsed = (request.operation === 'query-binding' ? dashboard_schema_1.queryBindingSchema : dashboard_schema_1.querySchema).safeParse(request.input);
+        if (!parsed.success)
+            throw new common_1.BadRequestException('DASHBOARD_INVALID_QUERY');
+        const input = parsed.data;
+        if (input.artifactId !== saved.artifactId || input.versionId !== saved.versionId || input.draftRevision !== undefined)
+            throw new common_1.ForbiddenException('DASHBOARD_SHARED_VERSION_REQUIRED');
+        if (request.operation === 'query-binding' && 'bindingId' in input && typeof input.bindingId === 'string')
+            return (0, dashboard_queries_1.queryDashboardBinding)(this.runtime, context.actor, saved.manifest, input.bindingId, input.controls);
+        if (request.operation !== 'query')
+            throw new common_1.ForbiddenException('DASHBOARD_ACTION_UNSUPPORTED');
+        const datasets = await (0, dashboard_queries_1.queryDashboard)(this.runtime, context.actor, saved.manifest, input.controls);
+        return { datasets, ...(saved.manifest.presentation ? {} : { payload: (0, renderer_1.toDataAnalyticsPayload)(saved.manifest, datasets) }) };
+    }
+    open(context) {
+        const { artifact, version, content } = context;
+        if (artifact.pluginName !== dashboard_service_1.PLUGIN_NAME || artifact.resourceType !== 'live-dashboard' || artifact.id !== version.artifactId ||
+            artifact.tenantId !== context.actor.tenantId || artifact.organizationId !== context.actor.organizationId)
+            throw new common_1.ForbiddenException('DASHBOARD_ACCESS_DENIED');
+        if (version.mimeType !== 'application/json' || content.length > document_package_1.MAX_DASHBOARD_PACKAGE_BYTES)
+            throw new common_1.BadRequestException('DASHBOARD_VERSION_UNAVAILABLE');
+        if (!version.sha256 || (0, node_crypto_1.createHash)('sha256').update(content).digest('hex') !== version.sha256)
+            throw new common_1.BadRequestException('DASHBOARD_VERSION_CONTENT_CHANGED');
+        const { manifest, dependencies } = (0, document_package_1.decodeDashboardPackage)(content);
+        const prefix = artifact.projectId ? `project/${artifact.projectId}/` : artifact.xpertId ? `agent/${artifact.xpertId}/` : null;
+        if (!prefix || artifact.resourceId !== `${prefix}${manifest.id}`)
+            throw new common_1.BadRequestException('DASHBOARD_IDENTITY_MISMATCH');
+        return { artifactId: artifact.id, versionId: version.id, versionNumber: version.versionNumber,
+            title: version.title ?? manifest.title, isDraft: false, manifest, dependencies };
+    }
+};
+exports.DashboardPresentationProvider = DashboardPresentationProvider;
+exports.DashboardPresentationProvider = DashboardPresentationProvider = __decorate([
+    (0, plugin_sdk_1.ArtifactPresentationProvider)({ pluginName: dashboard_service_1.PLUGIN_NAME, resourceType: 'live-dashboard' }),
+    __param(0, (0, common_1.Inject)(plugin_sdk_1.XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], DashboardPresentationProvider);

package/dist/lib/remote-entry.d.ts

@@ -0,0 +1,4 @@
+export declare function dashboardRemoteEntry(readOnly?: boolean): Promise<{
+    html: string;
+    contentType: "text/html; charset=utf-8";
+}>;

package/dist/lib/remote-entry.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardRemoteEntry = dashboardRemoteEntry;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+async function dashboardRemoteEntry(readOnly = false) {
+    const [appScript, appCss, renderer] = await Promise.all([(0, promises_1.readFile)((0, node_path_1.join)(__dirname, '../remote/app.js'), 'utf8'), (0, promises_1.readFile)((0, node_path_1.join)(__dirname, '../remote/app.css'), 'utf8'), (0, promises_1.readFile)((0, node_path_1.join)(__dirname, '../remote/renderer.html'), 'utf8')]);
+    return { html: (0, plugin_sdk_1.renderRemoteReactIframeHtml)({ title: 'Live dashboards', reactUmd: '', reactDomUmd: '',
+            appScript: `window.__DASHBOARD_READ_ONLY__=${readOnly};window.__ANALYTICS_RENDERER_HTML__=${JSON.stringify(renderer).replace(/</g, '\\u003c')};\n${appScript}`, appCss }),
+        contentType: 'text/html; charset=utf-8' };
+}

package/dist/lib/renderer.d.ts

@@ -0,0 +1,58 @@
+import type { AnalyticalDataset } from '@xpert-ai/contracts';
+import type { DashboardManifest } from './dashboard.schema';
+/** The only Data Analytics v1 translation. Providers never see chart encoding syntax. */
+export declare function toDataAnalyticsPayload(manifest: DashboardManifest, datasets: AnalyticalDataset[]): {
+    ok: boolean;
+    widget_type: string;
+    surface: string;
+    sources: never[];
+    manifest: {
+        version: number;
+        surface: string;
+        title: string;
+        cards: never[];
+        filters: never[];
+        sources: never[];
+        charts: {
+            id: string;
+            title: string;
+            type: "bar" | "line" | "area" | "pie" | "scatter";
+            dataset: string;
+            encodings: {
+                color?: {
+                    field: string;
+                } | undefined;
+                x: {
+                    field: string;
+                };
+                y: {
+                    field: string;
+                };
+            };
+        }[];
+        tables: {
+            id: string;
+            title: string;
+            dataset: string;
+            columns: {
+                field: string;
+                label: string;
+            }[];
+        }[];
+        blocks: ({
+            id: string;
+            type: string;
+            chartId: string;
+        } | {
+            id: string;
+            type: string;
+            tableId: string;
+        })[];
+    };
+    snapshot: {
+        version: number;
+        generatedAt: string;
+        status: string;
+        datasets: any;
+    };
+};

package/dist/lib/renderer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toDataAnalyticsPayload = toDataAnalyticsPayload;
+/** The only Data Analytics v1 translation. Providers never see chart encoding syntax. */
+function toDataAnalyticsPayload(manifest, datasets) {
+    const snapshot = Object.fromEntries(datasets.flatMap((dataset) => [
+        [dataset.datasetId, dataset.rows],
+        ...(!manifest.charts.some((chart) => chart.datasetId === dataset.datasetId) ? [] : [[`__plot.${dataset.datasetId}`, dataset.rows.map((row) => Object.fromEntries(dataset.fields.map((field) => [field.id, manifest.charts.some((chart) => chart.datasetId === dataset.datasetId && [chart.x, chart.y].includes(field.id)) ? renderValue(row[field.id], field.logicalType) : row[field.id]])))]])
+    ]));
+    const payload = {
+        ok: true, widget_type: 'artifact', surface: 'dashboard', sources: [],
+        manifest: { version: 1, surface: 'dashboard', title: manifest.title, cards: [], filters: [], sources: [],
+            charts: manifest.charts.map((chart) => ({ id: chart.id, title: chart.title, type: chart.type, dataset: `__plot.${chart.datasetId}`,
+                encodings: { x: { field: chart.x }, y: { field: chart.y }, ...(chart.color ? { color: { field: chart.color } } : {}) } })),
+            tables: manifest.tables.map((table) => ({ id: table.id, title: table.title, dataset: table.datasetId,
+                columns: table.fields.map((id) => ({ field: id, label: datasets.find((dataset) => dataset.datasetId === table.datasetId)?.fields.find((field) => field.id === id)?.label ?? id })) })),
+            blocks: [...manifest.charts.map((chart) => ({ id: `chart.${chart.id}`, type: 'chart', chartId: chart.id })),
+                ...manifest.tables.map((table) => ({ id: `table.${table.id}`, type: 'table', tableId: table.id }))] },
+        snapshot: { version: 1, generatedAt: new Date().toISOString(), status: datasets.some((dataset) => dataset.completeness.truncated) ? 'partial' : 'ready', datasets: snapshot }
+    };
+    if (new TextEncoder().encode(JSON.stringify(payload)).byteLength > 3_000_000)
+        throw new Error('DASHBOARD_RESULT_TOO_LARGE');
+    return payload;
+}
+function renderValue(value, type) {
+    if (value === null || (type !== 'int64' && type !== 'decimal'))
+        return value;
+    // Dataset retains exact strings. Refuse values that the existing numeric renderer cannot represent safely.
+    if (typeof value !== 'string' || !Number.isFinite(Number(value)) || Math.abs(Number(value)) > Number.MAX_SAFE_INTEGER || value.replace(/[-.]/g, '').replace(/^0+/, '').length > 15)
+        throw new Error('DASHBOARD_NUMERIC_PRECISION_UNSUPPORTED');
+    return Number(value);
+}

package/dist/lib/resource-card.d.ts

@@ -0,0 +1,21 @@
+import type { RunnableConfig } from '@langchain/core/runnables';
+import type { ConversationResourceCard, XpertResolvedViewHostContext } from '@xpert-ai/contracts';
+type DashboardCard = {
+    artifactId: string;
+    title: string;
+} & ({
+    state: 'draft';
+    revision: number;
+} | {
+    state: 'published';
+    versionNumber: number;
+    versionId?: string;
+});
+/** Snapshot only. Opening a draft resolves current state; explicit historical reads pin a version. */
+export declare function dashboardResourceCard(scope: XpertResolvedViewHostContext, saved: DashboardCard): ConversationResourceCard;
+export declare function emitDashboardCard(scope: XpertResolvedViewHostContext, saved: DashboardCard, config?: RunnableConfig): Promise<{
+    status: "emitted";
+} | {
+    status: "unavailable";
+}>;
+export {};

package/dist/lib/resource-card.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardResourceCard = dashboardResourceCard;
+exports.emitDashboardCard = emitDashboardCard;
+const common_1 = require("@nestjs/common");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const dashboard_navigation_1 = require("./dashboard-navigation");
+const dashboard_icon_1 = require("./dashboard-icon");
+const logger = new common_1.Logger('DashboardResourceCard');
+/** Snapshot only. Opening a draft resolves current state; explicit historical reads pin a version. */
+function dashboardResourceCard(scope, saved) {
+    return {
+        resource: { namespace: 'live_dashboard', type: 'live-dashboard', id: saved.artifactId, artifactId: saved.artifactId },
+        title: saved.title,
+        description: saved.state === 'draft' ? `Dashboard · Draft r${saved.revision}` : `Dashboard · v${saved.versionNumber}`,
+        icon: dashboard_icon_1.dashboardIcon,
+        open: {
+            ...(scope.hostType === 'project' ? { target: 'assistant.project', projectId: scope.hostId } : { target: 'workbench.view' }),
+            viewKey: dashboard_navigation_1.DASHBOARD_VIEW_KEY, selectionId: saved.artifactId,
+            ...(saved.state === 'published' && saved.versionId ? { parameters: { versionId: saved.versionId } } : {})
+        }
+    };
+}
+async function emitDashboardCard(scope, saved, config) {
+    try {
+        await (0, plugin_sdk_1.emitResourceCard)(dashboardResourceCard(scope, saved), config);
+        return { status: 'emitted' };
+    }
+    catch {
+        logger.warn('Dashboard operation succeeded; resource card delivery failed');
+        return { status: 'unavailable' };
+    }
+}

package/dist/lib/save-evidence.d.ts

@@ -0,0 +1,24 @@
+import { type WorkspaceFilesApi } from '@xpert-ai/plugin-sdk';
+type SaveAttempt = {
+    token: number;
+    generations: Map<string, number>;
+    supersedesPaths?: string[];
+    confirmation?: 'source' | 'draft';
+};
+/** A domain receipt covers only the exact edited file bytes consumed by that save. */
+export declare function dashboardSaveEvidence(files: () => WorkspaceFilesApi): {
+    opened(path: string, artifactId: string): void;
+    has(path: string): boolean;
+    write(path: string): void;
+    trackWrite<T>(path: string, run: () => Promise<T>): Promise<T>;
+    beginSave(supersedesPaths?: string[], confirmation?: "source" | "draft"): {
+        token: number;
+        generations: Map<string, number>;
+        supersedesPaths: string[];
+        confirmation: "source" | "draft";
+    };
+    accept(save: SaveAttempt, output: unknown): Promise<void>;
+    readonly pending: boolean;
+    readonly pendingPaths: string[];
+};
+export {};

package/dist/lib/save-evidence.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardSaveEvidence = dashboardSaveEvidence;
+const node_crypto_1 = require("node:crypto");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const dashboard_receipt_1 = require("./dashboard-receipt");
+/** A domain receipt covers only the exact edited file bytes consumed by that save. */
+function dashboardSaveEvidence(files) {
+    const saves = (0, plugin_sdk_1.createMutationEvidence)();
+    const edits = new Map();
+    const activeWrites = new Map();
+    const abandonCandidates = (save, savedPath) => {
+        for (const path of save.supersedesPaths ?? []) {
+            const candidate = edits.get(path);
+            if (path !== savedPath && candidate && !candidate.artifactId && !activeWrites.has(path) && candidate.generation === save.generations.get(path))
+                candidate.pending = false;
+        }
+    };
+    const fingerprint = async (path) => {
+        try {
+            return (0, node_crypto_1.createHash)('sha256').update((await files().readRuntimeBuffer(path)).buffer).digest('hex');
+        }
+        catch {
+            return undefined;
+        } // An unreadable file cannot establish that a mutation was a no-op.
+    };
+    return {
+        opened(path, artifactId) { edits.set(path, { artifactId, generation: 0, pending: false }); },
+        has(path) { return edits.has(path); },
+        write(path) {
+            const edit = edits.get(path) ?? { generation: 0, pending: false };
+            edits.set(path, { ...edit, generation: edit.generation + 1, pending: true });
+        },
+        async trackWrite(path, run) {
+            // A receipt cannot confirm bytes while any writer may still change this path.
+            activeWrites.set(path, (activeWrites.get(path) ?? 0) + 1);
+            try {
+                const before = await fingerprint(path), previous = edits.get(path);
+                const edit = { ...previous, generation: (previous?.generation ?? 0) + 1, pending: true };
+                edits.set(path, edit);
+                try {
+                    return await run();
+                }
+                finally {
+                    // File tools may return a domain error with status=success. Verify bytes rather than
+                    // guessing from tool names/error text; preserve earlier or concurrent unsaved edits.
+                    if (before !== undefined && before === await fingerprint(path) && edits.get(path) === edit) {
+                        if (previous)
+                            edits.set(path, previous);
+                        else
+                            edits.delete(path);
+                    }
+                }
+            }
+            finally {
+                const remaining = activeWrites.get(path) - 1;
+                if (remaining)
+                    activeWrites.set(path, remaining);
+                else
+                    activeWrites.delete(path);
+            }
+        },
+        beginSave(supersedesPaths = [], confirmation = 'source') {
+            for (const path of supersedesPaths) {
+                const edit = edits.get(path);
+                if (!edit?.pending || edit.artifactId || activeWrites.has(path))
+                    throw new Error('DASHBOARD_SUPERSEDE_INVALID: only idle, unsaved creation candidates from this run may be abandoned');
+            }
+            return { token: saves.begin(), generations: new Map([...edits].map(([path, edit]) => [path, edit.generation])), supersedesPaths, confirmation };
+        },
+        async accept(save, output) {
+            const receipt = (0, dashboard_receipt_1.createdDashboard)(output);
+            if (!receipt)
+                return;
+            saves.accept(save.token, receipt);
+            const source = (0, dashboard_receipt_1.savedDashboardSource)(output);
+            if (!source) {
+                // A standard dashboard has no HTML source; its domain receipt can explicitly
+                // abandon creation prototypes without claiming those files were persisted.
+                if (save.confirmation === 'draft')
+                    abandonCandidates(save);
+                return;
+            }
+            const edit = edits.get(source.path);
+            if (!edit || activeWrites.has(source.path) || save.generations.get(source.path) !== edit.generation || edit.artifactId && edit.artifactId !== receipt.artifactId)
+                return;
+            const current = await files().readRuntimeBuffer(source.path);
+            if (!activeWrites.has(source.path) && edits.get(source.path) === edit && (0, node_crypto_1.createHash)('sha256').update(current.buffer).digest('hex') === source.sha256) {
+                edit.pending = false;
+                edit.artifactId = receipt.artifactId;
+                // Explicit replacement applies only after exact-byte confirmation. Do not infer intent
+                // from names/titles, delete files, or clear edits made concurrently with this save.
+                abandonCandidates(save, source.path);
+            }
+        },
+        get pending() { return saves.pending || activeWrites.size > 0 || [...edits.values()].some(edit => edit.pending); },
+        get pendingPaths() { return [...new Set([...activeWrites.keys(), ...[...edits].filter(([, edit]) => edit.pending).map(([path]) => path)])]; }
+    };
+}

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

@@ -0,0 +1,93 @@
+import { z } from 'zod/v3';
+import type { XpertResolvedViewHostContext } from '@xpert-ai/contracts';
+import { type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
+import { DashboardService } from './dashboard.service';
+export declare const shareInput: z.ZodEffects<z.ZodObject<{
+    artifactId: z.ZodString;
+    versionMode: z.ZodEnum<["latest", "version"]>;
+    versionId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    artifactId: string;
+    versionMode: "version" | "latest";
+    versionId?: string | undefined;
+}, {
+    artifactId: string;
+    versionMode: "version" | "latest";
+    versionId?: string | undefined;
+}>, {
+    artifactId: string;
+    versionMode: "version" | "latest";
+    versionId?: string | undefined;
+}, {
+    artifactId: string;
+    versionMode: "version" | "latest";
+    versionId?: string | undefined;
+}>;
+export declare class DashboardSharingService {
+    private readonly dashboards;
+    private readonly runtime;
+    constructor(dashboards: DashboardService, runtime: RuntimeCapabilityRegistry);
+    inspect(context: XpertResolvedViewHostContext, artifactId: string, versionId?: string): Promise<{
+        published: {
+            current: boolean;
+            artifactId: string;
+            versionId: string | null | undefined;
+            versionNumber: number | undefined;
+            title: string | null | undefined;
+            updatedAt: string | Date | undefined;
+        } | null;
+        issues: {
+            code: string;
+            bindingId?: string;
+        }[];
+        link: {
+            status: import("@xpert-ai/contracts").ArtifactLinkStatus;
+            versionMode: import("@xpert-ai/contracts").ArtifactLinkVersionMode;
+            versionId: string | null | undefined;
+            url: string | undefined;
+            expiresAt: string | Date | null | undefined;
+        } | null;
+    }>;
+    share(context: XpertResolvedViewHostContext, input: z.infer<typeof shareInput>): Promise<{
+        published: {
+            current: boolean;
+            artifactId: string;
+            versionId: string | null | undefined;
+            versionNumber: number | undefined;
+            title: string | null | undefined;
+            updatedAt: string | Date | undefined;
+        } | null;
+        issues: {
+            code: string;
+            bindingId?: string;
+        }[];
+        link: {
+            status: import("@xpert-ai/contracts").ArtifactLinkStatus;
+            versionMode: import("@xpert-ai/contracts").ArtifactLinkVersionMode;
+            versionId: string | null | undefined;
+            url: string | undefined;
+            expiresAt: string | Date | null | undefined;
+        } | null;
+    }>;
+    revoke(context: XpertResolvedViewHostContext, artifactId: string): Promise<{
+        published: {
+            current: boolean;
+            artifactId: string;
+            versionId: string | null | undefined;
+            versionNumber: number | undefined;
+            title: string | null | undefined;
+            updatedAt: string | Date | undefined;
+        } | null;
+        issues: {
+            code: string;
+            bindingId?: string;
+        }[];
+        link: {
+            status: import("@xpert-ai/contracts").ArtifactLinkStatus;
+            versionMode: import("@xpert-ai/contracts").ArtifactLinkVersionMode;
+            versionId: string | null | undefined;
+            url: string | undefined;
+            expiresAt: string | Date | null | undefined;
+        } | null;
+    }>;
+}

package/dist/lib/sharing.service.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardSharingService = exports.shareInput = void 0;
+const common_1 = require("@nestjs/common");
+const v3_1 = require("zod/v3");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const dashboard_service_1 = require("./dashboard.service");
+exports.shareInput = v3_1.z.object({ artifactId: v3_1.z.string().uuid(), versionMode: v3_1.z.enum(['latest', 'version']), versionId: v3_1.z.string().uuid().optional() }).strict()
+    .refine(value => value.versionMode !== 'version' || !!value.versionId, 'A fixed share requires a published version');
+const SHARE_KEY = 'team-readonly';
+let DashboardSharingService = class DashboardSharingService {
+    constructor(dashboards, runtime) {
+        this.dashboards = dashboards;
+        this.runtime = runtime;
+    }
+    async inspect(context, artifactId, versionId) {
+        const versions = await this.dashboards.history(context, artifactId);
+        const selected = versionId ? versions.find(version => version.versionId === versionId) : versions.find(version => version.current);
+        const link = await this.runtime.require(plugin_sdk_1.ArtifactsRuntimeCapability).getArtifactShare({ artifactId, shareKey: SHARE_KEY });
+        const issues = [];
+        if (!selected?.versionId)
+            issues.push({ code: 'DASHBOARD_PUBLISH_BEFORE_SHARING' });
+        else {
+            const saved = await this.dashboards.open(context, artifactId, selected.versionId);
+            const sources = await this.dashboards.sources(context);
+            for (const binding of saved.manifest.bindings) {
+                const provider = sources.find(source => source.id === binding.dataSourceId)?.providers.find(provider => provider.id === binding.providerId);
+                if (!provider)
+                    issues.push({ code: 'DASHBOARD_SOURCE_UNAVAILABLE', bindingId: binding.id });
+                else if (provider.sharing?.mode === 'owner_only')
+                    issues.push({ code: provider.sharing.reasonCode ?? 'DASHBOARD_PRIVATE_DEPENDENCY', bindingId: binding.id });
+            }
+        }
+        return { published: selected ?? null, issues, link: link ? { status: link.status, versionMode: link.versionMode,
+                versionId: link.artifactVersionId, url: link.presentationUrl, expiresAt: link.expiresAt } : null };
+    }
+    async share(context, input) {
+        const state = await this.inspect(context, input.artifactId, input.versionMode === 'version' ? input.versionId : undefined);
+        if (state.issues.length || !state.published?.versionId)
+            throw new common_1.BadRequestException({ code: 'DASHBOARD_SHARE_BLOCKED', issues: state.issues });
+        const result = await this.runtime.require(plugin_sdk_1.ArtifactsRuntimeCapability).ensureArtifactShare({ artifactId: input.artifactId, shareKey: SHARE_KEY,
+            versionMode: input.versionMode, ...(input.versionMode === 'version' ? { artifactVersionId: state.published.versionId } : {}),
+            access: { mode: 'organization_all' }, presentation: { allowDownload: false, disposition: 'inline', safeHtmlProfile: 'strict' } });
+        if (!result.link.presentationUrl)
+            throw new common_1.BadRequestException('DASHBOARD_PRESENTATION_HOST_REQUIRED');
+        return this.inspect(context, input.artifactId, input.versionMode === 'version' ? input.versionId : undefined);
+    }
+    async revoke(context, artifactId) {
+        await this.dashboards.history(context, artifactId);
+        await this.runtime.require(plugin_sdk_1.ArtifactsRuntimeCapability).revokeArtifactShare({ artifactId, shareKey: SHARE_KEY });
+        return this.inspect(context, artifactId);
+    }
+};
+exports.DashboardSharingService = DashboardSharingService;
+exports.DashboardSharingService = DashboardSharingService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(1, (0, common_1.Inject)(plugin_sdk_1.XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [dashboard_service_1.DashboardService, Object])
+], DashboardSharingService);