@xpert-ai/plugin-live-dashboard 0.4.1 → 0.6.0

package/dist/lib/prompt-workflows.js

@@ -6,7 +6,7 @@ const context = `Work in the current authorized Assistant/project scope. Use the
 Resolve source/provider pairs, Artifact IDs, fields and file paths from current tools, not names or previous conversation claims. Use only real query results; no invented business data, targets, thresholds, comparison periods or activity feeds. Keep queries read-only and bounded. Report actual tool failures and diagnosticId when supplied. A missing capability or runtime binding is a blocker, not permission to bypass validation or switch presentation modes.`;
 const metrics = `Confirm metric definitions, units, time range, grain and join keys from metadata and small real samples. Compute ratios from aggregated numerators and denominators, not sums/averages of percentages. Keep unknown/zero denominators as unavailable, not zero. Check join cardinality and avoid duplicate totals. Use chronological date ordering and comparable complete periods. State freshness and gaps; historical data must not be described as current operations. Avoid exposing unnecessary personal or sensitive row-level fields.`;
 const discover = `Call dashboard_list_sources first, then dashboard_discover for exact authorized source/provider pairs. Follow returned inspectRequest/nextRequest and query contracts; do not scan unrelated schemas or guess SQL fields. Prefer existing governed definitions. If the requested source is missing, use analytics_definition_connections and analytics_definition_inspect; register a missing definition with analytics_definition_register only when needed for this requested dashboard, then refresh sources. Never duplicate an existing definition or ask the user to supply internal IDs.`;
-const preview = `Before saving new or changed Bindings, call dashboard_preview or dashboard_preview_binding with the exact final queries and typed default controls in this run. Execute every preview.validation.checks[].suggestedCall with dashboard_test_filter; use observed non-default values and the all-values/null case when applicable. Follow each tool's schema, serialize JSON-string fields correctly, and copy returned bindingJson rather than nesting a Binding inside SQL. Changed queries/defaults need fresh evidence. Use at most eight final Bindings, sharing a query where its metric, grain and filters permit it. Never reuse historical previewIds or hard-code preview rows into the page.`;
+const preview = `Before saving new or changed Bindings, call dashboard_preview or dashboard_preview_binding with the exact final queries and typed default controls in this run. Execute every preview.validation.checks[].suggestedCall with dashboard_test_filter; use observed non-default values and the all-values/null case when applicable. Follow each tool's schema, serialize JSON-string fields correctly, and copy returned bindingJson rather than nesting a Binding inside SQL. Changed queries/defaults need fresh evidence. Respect the installation authoring limit (32 Bindings by default, at most 64), sharing a query where its metric, grain and filters permit it. Never reuse historical previewIds or hard-code preview rows into the page.`;
 const receipt = `Save a working draft and require a successful domain receipt with dashboard.artifactId, status "draft" and draftRevision. File writes, an existing resource card or an older published version are not proof of this save. Open the exact saved Artifact to inspect it; do not update an unchanged copy just to verify persistence. Verify real filter changes and refresh where available, distinguishing tool checks from unperformed viewer checks. Return the saved receipt, sources, metric definitions and a short manual acceptance checklist. Formal publication remains a separate human Workbench action.`;
 const newDashboard = `Create a NEW independent dashboard. Do not modify, rename or replace an existing Artifact, including the currently selected dashboard. Choose a distinct business title. In HTML mode choose an unused workspace-relative named .html path; never reuse an old page just because it has a similar title. Reuse verified source definitions, not an old dashboard's identity. If this run already saved the requested dashboard, keep its Artifact rather than creating a duplicate.`;
 const automaticTheme = `Choose one useful business theme from the authorized data, prioritizing an operational decision such as delivery delays, inventory backlog, supplier performance or production quality. Compare only a few plausible sources by completeness, freshness, metric clarity and actionable detail; then select the strongest one without repeatedly asking the user to choose. Explain who will use it, which decision it supports and which records require attention. If no source supports a defensible theme, report the missing data instead of making a decorative demo.`;

package/dist/lib/query-session.d.ts

@@ -0,0 +1,9 @@
+import type { AnalyticalDataset } from '@xpert-ai/contracts';
+import { type ArtifactQueryInput, type ArtifactQueryPriority } from '@xpert-ai/plugin-sdk/artifact-document';
+import type { DashboardManifest } from './dashboard.schema';
+import { type SourceEvent } from './source-executions';
+/** One saved definition and actor. No cache survives a navigation or a version change. */
+export declare function createDashboardQuerySession(manifest: DashboardManifest, execute: (input: ArtifactQueryInput) => Promise<AnalyticalDataset>, changed: (datasets: AnalyticalDataset[], failures: string[]) => void, event: (event: SourceEvent) => void, busy: (value: boolean) => void): {
+    query(values: ArtifactQueryInput["controls"], priority?: ArtifactQueryPriority, only?: string[]): Promise<void>;
+    dispose(): void;
+};

package/dist/lib/query-session.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDashboardQuerySession = createDashboardQuerySession;
+const artifact_document_1 = require("@xpert-ai/plugin-sdk/artifact-document");
+const source_executions_1 = require("./source-executions");
+/** One saved definition and actor. No cache survives a navigation or a version change. */
+function createDashboardQuerySession(manifest, execute, changed, event, busy) {
+    const results = new Map(), failures = new Set();
+    const keys = new Map(), requests = new Map(), pending = new Set();
+    let sequence = 0, disposed = false;
+    const publish = () => { if (!disposed)
+        changed([...results.values()], [...failures]); };
+    const scheduler = (0, artifact_document_1.createArtifactQueryScheduler)({ execute, onBusy: busy, onState: state => {
+            if (disposed || !['queued', 'running'].includes(state.state))
+                return;
+            event({ type: state.state === 'queued' ? 'queue' : 'start', bindingId: state.bindingId,
+                requestId: requests.get(state.bindingId), controls: state.controls, at: new Date(state.state === 'queued' ? state.queuedAt : state.startedAt).toISOString() });
+        } });
+    return {
+        async query(values, priority = 'interactive', only) {
+            const affected = manifest.bindings.flatMap(binding => {
+                if (only && !only.includes(binding.id))
+                    return [];
+                const controls = Object.fromEntries(binding.parameters.map(parameter => [parameter.controlId,
+                    Object.hasOwn(values, parameter.controlId) ? values[parameter.controlId] : parameter.defaultValue ?? null]));
+                const key = JSON.stringify(controls);
+                if (priority === 'interactive' && keys.get(binding.id) === key && !failures.has(binding.output.datasetId))
+                    return [];
+                // A repeated refresh shares both the physical query and its Sources lifecycle.
+                const requestId = keys.get(binding.id) === key && pending.has(binding.id) ? requests.get(binding.id) : String(++sequence);
+                keys.set(binding.id, key);
+                pending.add(binding.id);
+                requests.set(binding.id, requestId);
+                results.delete(binding.output.datasetId);
+                failures.delete(binding.output.datasetId);
+                return [{ binding, controls, requestId }];
+            });
+            // Remove every affected old-parameter dataset before publishing any new result.
+            publish();
+            await Promise.all(affected.map(async ({ binding, controls, requestId }) => {
+                try {
+                    const result = await scheduler.query({ bindingId: binding.id, controls }, priority);
+                    if (disposed || requests.get(binding.id) !== requestId)
+                        return;
+                    results.set(binding.output.datasetId, result);
+                    if (new TextEncoder().encode(JSON.stringify([...results.values()])).byteLength > 3_000_000) {
+                        results.delete(binding.output.datasetId);
+                        throw new Error('DASHBOARD_RESULT_TOO_LARGE');
+                    }
+                    event({ type: 'success', bindingId: binding.id, requestId, result: source_executions_1.sourceDatasetSchema.parse(result), at: new Date().toISOString() });
+                }
+                catch {
+                    if (disposed || requests.get(binding.id) !== requestId)
+                        return;
+                    failures.add(binding.output.datasetId);
+                    event({ type: 'failure', bindingId: binding.id, requestId, at: new Date().toISOString() });
+                }
+                pending.delete(binding.id);
+                publish();
+            }));
+        },
+        dispose() { disposed = true; scheduler.dispose(); results.clear(); requests.clear(); keys.clear(); pending.clear(); }
+    };
+}

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

@@ -0,0 +1,118 @@
+import { z } from 'zod/v3';
+import type { XpertResolvedViewHostContext } from '@xpert-ai/contracts';
+import { type ManagedQueueJob, type ManagedQueueJobContext, type ManagedQueueService, type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
+import { type ArtifactDocumentDependencyAsset } from '@xpert-ai/plugin-sdk/artifact-document';
+import { DashboardService } from './dashboard.service';
+import { type DashboardManifest } from './dashboard.schema';
+declare const sourceFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    sha256: string;
+}, {
+    path: string;
+    sha256: string;
+}>;
+export declare const saveRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    requestId: string;
+}, {
+    requestId: string;
+}>;
+export declare const waitSaveRequestSchema: z.ZodObject<{
+    requestId: z.ZodString;
+} & {
+    cursor: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    requestId: string;
+    cursor: string;
+}, {
+    requestId: string;
+    cursor: string;
+}>;
+/** Durable save orchestration; domain validation and CAS remain in DashboardService. */
+export declare class DashboardSaveRequests {
+    private readonly service;
+    private readonly runtime;
+    private readonly queue;
+    constructor(service: DashboardService, runtime: RuntimeCapabilityRegistry, queue: ManagedQueueService);
+    submit(context: XpertResolvedViewHostContext, manifest: DashboardManifest, expectedVersionId: string | null, expectedRevision: number, idempotencyKey: string, sourceFile?: z.infer<typeof sourceFileSchema>, dependencies?: ArtifactDocumentDependencyAsset[]): Promise<{
+        cursor: string;
+        nextAction: string;
+        error?: string | undefined;
+        sourceFile?: {
+            path: string;
+            sha256: string;
+        } | undefined;
+        dashboard?: {
+            status: "draft";
+            title: string;
+            artifactId: string;
+            draftRevision: number;
+            draftId: string;
+            baseVersionId: string | null;
+        } | undefined;
+        requestId: string;
+        state: "failed" | "running" | "succeeded" | "queued";
+        stage: string;
+        completed: number;
+        total: number;
+        terminal: boolean;
+    }>;
+    private reference;
+    private enqueue;
+    private read;
+    private snapshot;
+    get(context: XpertResolvedViewHostContext, requestId: string): Promise<{
+        cursor: string;
+        nextAction: string;
+        error?: string | undefined;
+        sourceFile?: {
+            path: string;
+            sha256: string;
+        } | undefined;
+        dashboard?: {
+            status: "draft";
+            title: string;
+            artifactId: string;
+            draftRevision: number;
+            draftId: string;
+            baseVersionId: string | null;
+        } | undefined;
+        requestId: string;
+        state: "failed" | "running" | "succeeded" | "queued";
+        stage: string;
+        completed: number;
+        total: number;
+        terminal: boolean;
+    }>;
+    wait(context: XpertResolvedViewHostContext, requestId: string, cursor: string, signal?: AbortSignal): Promise<{
+        cursor: string;
+        nextAction: string;
+        error?: string | undefined;
+        sourceFile?: {
+            path: string;
+            sha256: string;
+        } | undefined;
+        dashboard?: {
+            status: "draft";
+            title: string;
+            artifactId: string;
+            draftRevision: number;
+            draftId: string;
+            baseVersionId: string | null;
+        } | undefined;
+        requestId: string;
+        state: "failed" | "running" | "succeeded" | "queued";
+        stage: string;
+        completed: number;
+        total: number;
+        terminal: boolean;
+    }>;
+    handle(job: ManagedQueueJob<{
+        requestId: string;
+    }>, identity: ManagedQueueJobContext): Promise<void>;
+}
+export {};

package/dist/lib/save-requests.js

@@ -0,0 +1,199 @@
+"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.DashboardSaveRequests = exports.waitSaveRequestSchema = exports.saveRequestSchema = void 0;
+const common_1 = require("@nestjs/common");
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:timers/promises");
+const v3_1 = require("zod/v3");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const artifact_document_1 = require("@xpert-ai/plugin-sdk/artifact-document");
+const dashboard_service_1 = require("./dashboard.service");
+const dashboard_schema_1 = require("./dashboard.schema");
+const TTL = 86400, MAX_RUNTIME = 10 * 60_000, WAIT_MS = 20_000;
+const hash = (value) => (0, node_crypto_1.createHash)('sha256').update(value).digest('hex');
+const key = (scope, id) => {
+    if (!scope.tenantId || !scope.organizationId)
+        throw new Error('DASHBOARD_SAVE_REQUEST_DENIED');
+    return `live_dashboard:save:${scope.tenantId}:${scope.organizationId}:${id}`;
+};
+const contextSchema = v3_1.z.object({ tenantId: v3_1.z.string().uuid(), organizationId: v3_1.z.string().uuid(), userId: v3_1.z.string().uuid(),
+    hostType: v3_1.z.enum(['agent', 'project']), hostId: v3_1.z.string().uuid(), projectId: v3_1.z.string().uuid().optional() }).strict();
+const fileSchema = v3_1.z.object({ filePath: v3_1.z.string(), workspacePath: v3_1.z.string(), sha256: v3_1.z.string(), size: v3_1.z.number() }).strict();
+const receiptSchema = v3_1.z.object({ artifactId: v3_1.z.string().uuid(), draftId: v3_1.z.string(), draftRevision: v3_1.z.number(), baseVersionId: v3_1.z.string().nullable(), status: v3_1.z.literal('draft'), title: v3_1.z.string() });
+const sourceFileSchema = v3_1.z.object({ path: v3_1.z.string().max(300), sha256: v3_1.z.string().regex(/^[a-f0-9]{64}$/) }).strict();
+const recordSchema = v3_1.z.object({ requestId: v3_1.z.string().uuid(), jobId: v3_1.z.string(), context: contextSchema, file: fileSchema,
+    manifestId: v3_1.z.string().uuid(), expectedRevision: v3_1.z.number(), state: v3_1.z.enum(['queued', 'running', 'succeeded', 'failed']), stage: v3_1.z.string(), completed: v3_1.z.number(), total: v3_1.z.number(),
+    fingerprint: v3_1.z.string(), createdAt: v3_1.z.number(), deadline: v3_1.z.number(), error: v3_1.z.string().optional(), dashboard: receiptSchema.optional(), sourceFile: sourceFileSchema.optional() }).strict();
+const inputSchema = v3_1.z.object({ manifest: dashboard_schema_1.dashboardSchema, expectedVersionId: v3_1.z.string().uuid().nullable(), expectedRevision: v3_1.z.number().int().nonnegative(),
+    dependencies: artifact_document_1.artifactDocumentDependencyAssets.optional() }).strict();
+exports.saveRequestSchema = v3_1.z.object({ requestId: v3_1.z.string().uuid() }).strict();
+exports.waitSaveRequestSchema = exports.saveRequestSchema.extend({ cursor: v3_1.z.string().min(1).max(100) }).strict();
+function trustedScope(context) {
+    return contextSchema.parse({ tenantId: context.tenantId, organizationId: context.organizationId, userId: context.userId,
+        hostType: context.hostType, hostId: context.hostId,
+        ...(context.hostType === 'project' ? { projectId: context.hostId } : context.runtimeScope?.projectId ? { projectId: context.runtimeScope.projectId } : {}) });
+}
+function restoredScope(scope) {
+    return { ...scope, slots: [], ...(scope.projectId ? { runtimeScope: { projectId: scope.projectId, conversationId: null,
+                dataScopeKey: `project:${scope.projectId}`, workspaceFiles: { catalog: 'projects', scopeId: scope.projectId, projectId: scope.projectId } } } : {}) };
+}
+/** Durable save orchestration; domain validation and CAS remain in DashboardService. */
+let DashboardSaveRequests = class DashboardSaveRequests {
+    constructor(service, runtime, queue) {
+        this.service = service;
+        this.runtime = runtime;
+        this.queue = queue;
+    }
+    async submit(context, manifest, expectedVersionId, expectedRevision, idempotencyKey, sourceFile, dependencies) {
+        await this.service.authorizeProject(context, 'write');
+        const scope = trustedScope(context), parsed = inputSchema.parse({ manifest, expectedVersionId, expectedRevision, dependencies });
+        const fingerprint = hash(JSON.stringify({ ...parsed, manifest: { ...parsed.manifest, ...(expectedRevision === 0 ? { id: 'new' } : {}) }, sourceFile }));
+        const previousCount = await this.service.previousBindingCount(context, parsed.manifest);
+        this.service.assertCapacity(parsed.manifest.bindings.length, previousCount);
+        const redis = await this.queue.getRedis(), files = this.runtime.require(plugin_sdk_1.WorkspaceFilesRuntimeCapability);
+        const dedupe = `${key(scope, 'submission')}:${hash(JSON.stringify([scope, idempotencyKey]))}`;
+        const previous = await redis.get(dedupe);
+        if (previous) {
+            if ((await this.read(context, previous)).fingerprint !== fingerprint)
+                throw new Error('DASHBOARD_SAVE_IDEMPOTENCY_CONFLICT');
+            return this.get(context, previous);
+        }
+        const requestId = (0, node_crypto_1.randomUUID)(), buffer = Buffer.from(JSON.stringify(parsed));
+        if (buffer.length > 12_000_000)
+            throw new Error('DASHBOARD_MANIFEST_TOO_LARGE');
+        const stored = await files.uploadBuffer({ tenantId: scope.tenantId, userId: scope.userId, catalog: 'users', buffer,
+            originalName: 'save.json', fileName: 'save.json', folder: `live-dashboard-save/${requestId}`, mimeType: 'application/json' });
+        const record = { requestId, jobId: `dashboard-save-${requestId}`, context: scope,
+            file: { filePath: stored.filePath, workspacePath: stored.workspacePath, sha256: hash(buffer), size: buffer.length },
+            fingerprint, manifestId: manifest.id, expectedRevision, state: 'queued', stage: 'queued', completed: 0, total: manifest.bindings.length, createdAt: Date.now(), deadline: Date.now() + MAX_RUNTIME,
+            ...(sourceFile ? { sourceFile: sourceFileSchema.parse(sourceFile) } : {}) };
+        const winner = await redis.eval("local id=redis.call('GET',KEYS[1]); if id then return id end; redis.call('SET',KEYS[2],ARGV[2],'EX',ARGV[3]); redis.call('SET',KEYS[1],ARGV[1],'EX',ARGV[3]); return ARGV[1]", 2, dedupe, key(scope, requestId), requestId, JSON.stringify(record), TTL);
+        if (winner !== requestId) {
+            await files.deleteFile(this.reference(record));
+            if ((await this.read(context, String(winner))).fingerprint !== fingerprint)
+                throw new Error('DASHBOARD_SAVE_IDEMPOTENCY_CONFLICT');
+            return this.get(context, String(winner));
+        }
+        // Recovery can enqueue the same deterministic job if the process stops at this boundary.
+        await this.enqueue(record);
+        return this.snapshot(record);
+    }
+    reference(record) {
+        return { source: 'platform.workspace.files', tenantId: record.context.tenantId, userId: record.context.userId, catalog: 'users',
+            filePath: record.file.filePath, workspacePath: record.file.workspacePath };
+    }
+    async enqueue(record) {
+        await this.queue.enqueue({ pluginName: dashboard_service_1.PLUGIN_NAME, queueName: 'save-validation', jobName: 'save', payload: { requestId: record.requestId },
+            tenantId: record.context.tenantId, organizationId: record.context.organizationId, userId: record.context.userId,
+            scopeKey: 'system:global', jobId: record.jobId, attempts: 1, removeOnComplete: { age: TTL, count: 1000 }, removeOnFail: { age: TTL, count: 1000 } });
+    }
+    async read(context, requestId) {
+        v3_1.z.string().uuid().parse(requestId);
+        const redis = await this.queue.getRedis(), value = await redis.get(key(context, requestId));
+        if (!value)
+            throw new Error('DASHBOARD_SAVE_REQUEST_UNAVAILABLE');
+        const record = recordSchema.parse(JSON.parse(value));
+        if (JSON.stringify(trustedScope(context)) !== JSON.stringify(record.context))
+            throw new Error('DASHBOARD_SAVE_REQUEST_DENIED');
+        return record;
+    }
+    snapshot(record) {
+        const terminal = record.state === 'succeeded' || record.state === 'failed';
+        const result = { requestId: record.requestId, state: record.state, stage: record.stage, completed: record.completed, total: record.total,
+            terminal, ...(record.dashboard ? { dashboard: record.dashboard, ...(record.sourceFile ? { sourceFile: record.sourceFile } : {}) } : {}),
+            ...(record.error ? { error: record.error } : {}), nextAction: terminal ? 'report_result' : 'wait' };
+        return { ...result, cursor: hash(JSON.stringify(result)) };
+    }
+    async get(context, requestId) {
+        await this.service.authorizeProject(context);
+        let record = await this.read(context, requestId);
+        if (record.state === 'queued' || record.state === 'running') {
+            const job = await this.queue.getJob({ jobId: record.jobId });
+            if (!job && record.deadline > Date.now())
+                await this.enqueue(record);
+            else if (job?.state === 'failed' || !job && record.deadline <= Date.now()) {
+                // A completed domain receipt always wins a racing observation.
+                record = await this.read(context, requestId);
+                if (record.state !== 'succeeded') {
+                    const receipt = await this.service.savedRequestReceipt(context, record.manifestId, record.requestId, record.expectedRevision);
+                    record = receipt ? { ...record, state: 'succeeded', stage: 'saved', completed: record.total, dashboard: receipt }
+                        : { ...record, state: 'failed', error: 'DASHBOARD_SAVE_JOB_FAILED: retrieve the current draft before retrying; no new save receipt was confirmed.' };
+                    await (await this.queue.getRedis()).set(key(record.context, requestId), JSON.stringify(record), 'EX', TTL);
+                    await this.runtime.require(plugin_sdk_1.WorkspaceFilesRuntimeCapability).deleteFile(this.reference(record)).catch(() => undefined);
+                }
+            }
+        }
+        return this.snapshot(record);
+    }
+    async wait(context, requestId, cursor, signal) {
+        const until = Date.now() + WAIT_MS;
+        let current = await this.get(context, requestId);
+        while (!current.terminal && current.cursor === cursor && Date.now() < until) {
+            await (0, promises_1.setTimeout)(Math.min(2000, until - Date.now()), undefined, { signal });
+            current = this.snapshot(await this.read(context, requestId));
+        }
+        return current.terminal || current.cursor !== cursor ? current : this.get(context, requestId);
+    }
+    async handle(job, identity) {
+        const requestId = v3_1.z.string().uuid().parse(job.data.requestId), redis = await this.queue.getRedis();
+        let record = recordSchema.parse(JSON.parse(await redis.get(key(identity, requestId)) ?? 'null'));
+        if (record.context.tenantId !== identity.tenantId || record.context.organizationId !== identity.organizationId || record.context.userId !== identity.userId)
+            throw new Error('DASHBOARD_SAVE_REQUEST_DENIED');
+        if (record.state === 'succeeded')
+            return;
+        let committed = false, terminalPersisted = false;
+        const persist = async () => { await redis.set(key(record.context, requestId), JSON.stringify(record), 'EX', TTL); };
+        const files = this.runtime.require(plugin_sdk_1.WorkspaceFilesRuntimeCapability);
+        try {
+            const file = await files.readBuffer(this.reference(record));
+            if (file.buffer.length !== record.file.size || hash(file.buffer) !== record.file.sha256)
+                throw new Error('DASHBOARD_SAVE_INPUT_CHANGED');
+            const input = inputSchema.parse(JSON.parse(file.buffer.toString('utf8')));
+            const dashboard = await this.service.save(restoredScope(record.context), input.manifest, input.expectedVersionId, input.expectedRevision, input.dependencies, { requestId, progress: async (stage, completed, total) => {
+                    if (Date.now() >= record.deadline)
+                        throw new Error('DASHBOARD_SAVE_DEADLINE');
+                    record = { ...record, state: 'running', stage, completed, total };
+                    await persist();
+                } });
+            committed = true;
+            record = { ...record, state: 'succeeded', stage: 'saved', completed: record.total, dashboard };
+            await persist();
+            terminalPersisted = true;
+        }
+        catch (error) {
+            // Keep frozen input for recovery when the Artifact CAS succeeded but status persistence did not.
+            if (committed)
+                throw new Error('DASHBOARD_SAVE_COMMIT_UNCONFIRMED');
+            // Do not persist native provider messages or private query configuration.
+            const code = error instanceof Error ? error.message.match(/^DASHBOARD_[A-Z_]+/)?.[0] : undefined;
+            record = { ...record, state: 'failed', error: code ?? 'DASHBOARD_SAVE_VALIDATION_FAILED' };
+            await persist();
+            terminalPersisted = true;
+            throw new Error(record.error);
+        }
+        finally {
+            if (terminalPersisted)
+                await files.deleteFile(this.reference(record)).catch(() => undefined);
+        }
+    }
+};
+exports.DashboardSaveRequests = DashboardSaveRequests;
+exports.DashboardSaveRequests = DashboardSaveRequests = __decorate([
+    (0, common_1.Injectable)(),
+    (0, plugin_sdk_1.PluginJobProcessor)({ pluginName: dashboard_service_1.PLUGIN_NAME, queueName: 'save-validation', jobName: 'save', concurrency: 2 }),
+    __param(1, (0, common_1.Inject)(plugin_sdk_1.XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __param(2, (0, common_1.Inject)(plugin_sdk_1.MANAGED_QUEUE_SERVICE_TOKEN)),
+    __metadata("design:paramtypes", [dashboard_service_1.DashboardService, Object, Object])
+], DashboardSaveRequests);