@xpert-ai/plugin-live-dashboard 0.4.0 → 0.5.0

package/dist/lib/inspection-runtime.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DASHBOARD_INSPECTION_RUNTIME = void 0;
+/** Injected into the isolated dashboard only; it never reads or executes query definitions. */
+exports.DASHBOARD_INSPECTION_RUNTIME = String.raw `
+(() => {
+  const key = '__INSPECTION_SESSION__', channel = 'live-dashboard.inspection';
+  let enabled = false, standard = false, components = [], selected = null, overlay, previousFocus;
+  const tabs = new Map();
+  const post = (type, data = {}) => parent.postMessage({ channel, key, type, ...data }, '*');
+  function outline(element) {
+    selected = element;
+    if (!element || !enabled) { if (overlay) overlay.hidden = true; return; }
+    if (!overlay) {
+      overlay = document.createElement('div');
+      overlay.setAttribute('aria-hidden', 'true');
+      overlay.style.cssText = 'position:fixed;pointer-events:none;z-index:2147483647;border:2px solid #2563eb;background:rgba(37,99,235,.06);box-sizing:border-box';
+      document.documentElement.append(overlay);
+    }
+    const r = element.getBoundingClientRect();
+    Object.assign(overlay.style, { left:r.left+'px', top:r.top+'px', width:r.width+'px', height:r.height+'px' });
+    overlay.hidden = false;
+  }
+  function target(node) {
+    for (let element = node instanceof Element ? node : null; element; element = element.parentElement) {
+      if (components.some(c => c.elementId === (standard ? element.getAttribute('data-layout-block-id') : element.id))) return element;
+    }
+    return null;
+  }
+  function registerTargets() {
+    if (!enabled) return;
+    for (const component of components) {
+      const element = standard ? [...document.querySelectorAll('[data-layout-block-id]')].find(e => e.getAttribute('data-layout-block-id') === component.elementId) : document.getElementById(component.elementId);
+      if (element && !tabs.has(element)) { tabs.set(element, element.getAttribute('tabindex')); element.setAttribute('tabindex', '0'); }
+    }
+  }
+  new MutationObserver(registerTargets).observe(document, { childList:true, subtree:true });
+  function activate(value) {
+    if (value === enabled) return;
+    enabled = value;
+    if (enabled) {
+      previousFocus = document.activeElement;
+      registerTargets();
+    } else {
+      outline(null);
+      for (const [element, value] of tabs) value === null ? element.removeAttribute('tabindex') : element.setAttribute('tabindex', value);
+      tabs.clear();
+      if (previousFocus instanceof HTMLElement && previousFocus.isConnected) previousFocus.focus({ preventScroll:true });
+    }
+  }
+  function choose(event) {
+    if (!enabled) return;
+    event.preventDefault(); event.stopImmediatePropagation();
+    const element = target(event.target), component = components.find(c => c.elementId === (standard ? element?.getAttribute('data-layout-block-id') : element?.id));
+    outline(element);
+    post('selected', { componentId:component?.id ?? null });
+  }
+  window.addEventListener('message', event => {
+    const m = event.data;
+    if (event.source !== parent || !m || m.channel !== channel || m.key !== key) return;
+    if (m.type === 'mode') { components = m.components; standard = m.standard; activate(m.enabled === true); }
+  });
+  window.addEventListener('pointermove', e => { if (enabled) outline(target(e.target)); }, true);
+  window.addEventListener('focusin', e => { if (enabled) outline(target(e.target)); }, true);
+  for (const name of ['pointerdown', 'pointerup', 'mousedown', 'mouseup', 'dblclick']) window.addEventListener(name, e => {
+    if (enabled) { e.preventDefault(); e.stopImmediatePropagation(); }
+  }, true);
+  window.addEventListener('click', choose, true);
+  window.addEventListener('keydown', e => {
+    if (!enabled) return;
+    if (e.key === 'Escape') { e.preventDefault(); e.stopImmediatePropagation(); activate(false); post('exit'); }
+    else if (e.key === 'Enter' || e.key === ' ') choose(e);
+  }, true);
+  window.addEventListener('scroll', () => { if (enabled) outline(selected); }, true);
+  window.addEventListener('resize', () => { if (enabled) outline(selected); });
+  post('ready');
+})();`;

package/dist/lib/json-input.d.ts

@@ -0,0 +1,4 @@
+type JsonInputField = 'requestJson' | 'binding.payloadJson' | 'bindingJson';
+/** Report syntax locations without echoing query text or native errors containing input fragments. */
+export declare function parseJsonInput(text: string, field: JsonInputField): unknown;
+export {};

package/dist/lib/json-input.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseJsonInput = parseJsonInput;
+/** Report syntax locations without echoing query text or native errors containing input fragments. */
+function parseJsonInput(text, field) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        if (!(error instanceof SyntaxError))
+            throw error;
+        const match = /\bat position (\d+)(?: \(line \d+ column \d+\))?$/.exec(error.message);
+        const offset = match ? Number(match[1]) : error.message === 'Unexpected end of JSON input' ? text.length : undefined;
+        if (offset === undefined || offset > text.length) {
+            throw new Error(`DASHBOARD_INVALID_JSON: ${field} contains invalid JSON; the parser did not provide a character position. Supply one complete JSON object without Markdown fences.`);
+        }
+        const lines = text.slice(0, offset).split(/\r\n|\r|\n/);
+        const character = offset === text.length ? 'end of input' : JSON.stringify(String.fromCodePoint(text.codePointAt(offset)));
+        throw new Error(`DASHBOARD_INVALID_JSON: ${field} has invalid JSON at offset ${offset} (0-based UTF-16), line ${lines.length}, column ${lines.at(-1).length + 1} (1-based); found ${character}. Check this position and the preceding JSON delimiter or value.`);
+    }
+}

package/dist/lib/middleware.js

@@ -37,6 +37,7 @@ const resource_card_1 = require("./resource-card");
 const dashboard_icon_1 = require("./dashboard-icon");
 const preview_retry_1 = require("./preview-retry");
 const prompt_workflows_1 = require("./prompt-workflows");
+const json_input_1 = require("./json-input");
 const middlewareOptionsSchema = v3_1.z.object({ allowedFinalProviders: v3_1.z.array(v3_1.z.string().min(1)).min(1).max(20).optional(),
     maxModelCalls: v3_1.z.number().int().min(1).max(64).default(24) }).strict().default({});
 const providerOptionSchema = {
@@ -251,8 +252,8 @@ let DashboardMiddleware = class DashboardMiddleware {
                     return preview(binding);
                 }, { name: 'dashboard_preview', description: 'Run one read-only binding using parameters[].defaultValue. Automatically discovers the source/provider query contract when absent in this run; use dashboard_discover to inspect business metadata or repair invalid queries. Returns validated Dataset fields, first 20 rows, full query completeness and audit. Required before create; changes to binding/defaults require another preview.',
                     schema: agent_schema_1.previewToolSchema, verboseParsingErrors: true, metadata: { toolName: { en_US: 'Verify dashboard data', zh_Hans: '预览并验证看板数据' } } }),
-                (0, tools_1.tool)(async ({ bindingJson }) => preview(plugin_sdk_1.analyticsBindingSchema.parse(JSON.parse(bindingJson))), {
-                    name: 'dashboard_preview_binding', description: 'Preview a complete canonical AnalyticsBinding returned by another tool. Serialize the complete canonical Binding (for example discovery items[].metadata.binding), including parameters[].controlId. bindingPayload is only the payload, not a Binding. If adding a parameter, include name, controlId, type, required and defaultValue. Do not convert it to the simplified dashboard_preview input. Automatically discovers the source/provider query contract when absent in this run; use dashboard_discover for business metadata. Returns the same previewId receipt for dashboard_create.',
+                (0, tools_1.tool)(async ({ bindingJson }) => preview(plugin_sdk_1.analyticsBindingSchema.parse((0, json_input_1.parseJsonInput)(bindingJson, 'bindingJson'))), {
+                    name: 'dashboard_preview_binding', description: 'Preview a complete canonical AnalyticsBinding returned by another tool. When editing an existing dashboard, copy dashboard_open.bindings[], preserve binding.id and existing parameters[].controlId, and change only the requested query/parameters. Binding ID is independent of output.datasetId. Serialize the complete Binding (also supported: discovery items[].metadata.binding), including parameters[].controlId. bindingPayload is only the payload, not a Binding. If adding a parameter, include name, controlId, type, required and defaultValue. Do not convert it to the simplified dashboard_preview input, which derives binding.id from output.datasetId. Automatically discovers the source/provider query contract when absent in this run. Returns a current-run previewId for dashboard_create or dashboard_update; include every intended changed/new Binding receipt and matching controls in the same save.',
                     schema: v3_1.z.object({ bindingJson: v3_1.z.string().min(2).max(200000) }).strict(), verboseParsingErrors: true,
                     metadata: { toolName: { en_US: 'Verify registered dataset', zh_Hans: '验证已注册数据集' } }
                 }),

package/dist/lib/plugin.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveDashboardPlugin = void 0;
+const archive_service_1 = require("./archive.service");
 const projects_service_1 = require("./projects.service");
 const content_capability_1 = require("./content-capability");
 const monitor_1 = require("./monitor");
@@ -24,5 +25,5 @@ let LiveDashboardPlugin = class LiveDashboardPlugin {
 };
 exports.LiveDashboardPlugin = LiveDashboardPlugin;
 exports.LiveDashboardPlugin = LiveDashboardPlugin = __decorate([
-    (0, plugin_sdk_1.XpertServerPlugin)({ controllers: [provider_options_controller_1.DashboardProviderOptionsController], providers: [projects_service_1.DashboardProjectsService, monitor_1.DashboardMonitor, monitor_1.DashboardMonitorMiddleware, artifact_type_provider_1.DashboardArtifactType, content_capability_1.DashboardCapability, content_provider_1.DashboardContentProvider, content_provider_1.DashboardContentEditor, dashboard_service_1.DashboardService, view_provider_1.DashboardViewProvider, middleware_1.DashboardMiddleware, html_validation_1.HtmlDashboardValidation, presentation_provider_1.DashboardPresentationProvider, sharing_service_1.DashboardSharingService] })
+    (0, plugin_sdk_1.XpertServerPlugin)({ controllers: [provider_options_controller_1.DashboardProviderOptionsController], providers: [archive_service_1.DashboardArchiveService, projects_service_1.DashboardProjectsService, monitor_1.DashboardMonitor, monitor_1.DashboardMonitorMiddleware, artifact_type_provider_1.DashboardArtifactType, content_capability_1.DashboardCapability, content_provider_1.DashboardContentProvider, content_provider_1.DashboardContentEditor, dashboard_service_1.DashboardService, view_provider_1.DashboardViewProvider, middleware_1.DashboardMiddleware, html_validation_1.HtmlDashboardValidation, presentation_provider_1.DashboardPresentationProvider, sharing_service_1.DashboardSharingService] })
 ], LiveDashboardPlugin);

package/dist/lib/presentation.provider.d.ts

@@ -11,15 +11,10 @@ export declare class DashboardPresentationProvider implements IArtifactPresentat
     read(context: ArtifactPresentationContext): Promise<{
         meta: {
             saved: {
-                artifactId: string;
-                versionId: string;
-                versionNumber: number;
-                title: string;
-                isDraft: boolean;
                 manifest: {
-                    schema: "xpert.live-dashboard";
-                    id: string;
                     title: string;
+                    id: string;
+                    schema: "xpert.live-dashboard";
                     bindings: import("@xpert-ai/contracts").AnalyticsBinding[];
                     controls: {
                         type: "string" | "number" | "boolean" | "date";
@@ -29,26 +24,46 @@ export declare class DashboardPresentationProvider implements IArtifactPresentat
                         allowedValues?: (string | number | boolean | null)[] | undefined;
                     }[];
                     charts: {
+                        title: string;
                         type: "bar" | "line" | "area" | "pie" | "scatter";
                         id: string;
-                        title: string;
                         datasetId: string;
                         x: string;
                         y: string;
                         color?: string | undefined;
                     }[];
                     tables: {
-                        id: string;
                         title: string;
+                        id: string;
                         datasetId: string;
                         fields: string[];
                     }[];
+                    sourceMetadata?: {
+                        bindingId: string;
+                        title: string;
+                        description?: string | undefined;
+                    }[] | undefined;
+                    components?: {
+                        title: string;
+                        id: string;
+                        elementId: string;
+                        kind: "filter" | "metric" | "chart" | "table" | "text";
+                        sources: {
+                            bindingId: string;
+                            fieldIds?: string[] | undefined;
+                        }[];
+                    }[] | undefined;
                     presentation?: {
                         type: "html";
                         html: string;
                         dependencies?: import("@xpert-ai/plugin-sdk/artifact-document").ArtifactDocumentDependencyLock[] | undefined;
                     } | undefined;
                 };
+                artifactId: string;
+                versionId: string;
+                versionNumber: number;
+                title: string;
+                isDraft: boolean;
                 dependencies: import("@xpert-ai/plugin-sdk/artifact-document").ArtifactDocumentDependencyAsset[];
             };
             dashboards: {

package/dist/lib/presentation.provider.js

@@ -22,6 +22,7 @@ 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");
+const dashboard_sources_1 = require("./dashboard-sources");
 let DashboardPresentationProvider = class DashboardPresentationProvider {
     constructor(runtime) {
         this.runtime = runtime;
@@ -30,7 +31,7 @@ let DashboardPresentationProvider = class DashboardPresentationProvider {
     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: [] } };
+        return { meta: { saved: { ...saved, manifest: (0, dashboard_sources_1.publicDashboardManifest)(saved.manifest) }, dashboards: [{ artifactId: saved.artifactId, versionId: saved.versionId, title: saved.title }], sources: [], versions: [] } };
     }
     async query(context, request) {
         const saved = this.open(context);

package/dist/lib/projects.schema.d.ts

@@ -9,6 +9,20 @@ export declare const projectSearchSchema: z.ZodObject<{
     search?: string | undefined;
     page?: number | undefined;
 }>;
+export declare const dashboardSearchSchema: z.ZodObject<{
+    search: z.ZodDefault<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+} & {
+    projectId: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    search: string;
+    page: number;
+    projectId?: string | undefined;
+}, {
+    search?: string | undefined;
+    page?: number | undefined;
+    projectId?: string | undefined;
+}>;
 export declare const dashboardProjectSchema: z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;

package/dist/lib/projects.schema.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dashboardProjectsSchema = exports.dashboardProjectSchema = exports.projectSearchSchema = void 0;
+exports.dashboardProjectsSchema = exports.dashboardProjectSchema = exports.dashboardSearchSchema = exports.projectSearchSchema = void 0;
 const v3_1 = require("zod/v3");
 exports.projectSearchSchema = v3_1.z.object({ search: v3_1.z.string().trim().max(200).default(''), page: v3_1.z.number().int().positive().default(1) }).strict();
+exports.dashboardSearchSchema = exports.projectSearchSchema.extend({ projectId: v3_1.z.string().uuid().optional() });
 exports.dashboardProjectSchema = v3_1.z.object({ id: v3_1.z.string().uuid(), name: v3_1.z.string() });
 exports.dashboardProjectsSchema = v3_1.z.object({ items: v3_1.z.array(exports.dashboardProjectSchema), page: v3_1.z.number().int().positive(), hasMore: v3_1.z.boolean() });

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

@@ -12,6 +12,8 @@ export declare class DashboardProjectsService {
         id: string;
         name: string;
     } | null>;
+    /** A picker target is untrusted until membership and the Assistant binding are revalidated. */
+    pickerContext(context: XpertResolvedViewHostContext, targetProjectId: string): Promise<XpertResolvedViewHostContext>;
     list(context: XpertResolvedViewHostContext, input: z.infer<typeof projectSearchSchema>): Promise<{
         items: {
             id: string;

package/dist/lib/projects.service.js

@@ -35,6 +35,16 @@ let DashboardProjectsService = class DashboardProjectsService {
         const access = await this.runtime.require(plugin_sdk_1.ProjectAccessRuntimeCapability).assertAssistant({ actor: this.actor(context), projectId: id, assistantId: context.hostId });
         return { id, name: access.name ?? id };
     }
+    /** A picker target is untrusted until membership and the Assistant binding are revalidated. */
+    async pickerContext(context, targetProjectId) {
+        const access = await this.runtime.require(plugin_sdk_1.ProjectAccessRuntimeCapability).assertAssistant({
+            actor: this.actor(context), projectId: targetProjectId, assistantId: context.hostId
+        });
+        if (access.archived || access.projectId !== targetProjectId)
+            throw new common_1.ForbiddenException('DASHBOARD_ACCESS_DENIED');
+        // Domain reads/deletes accept a Project host. Do not fabricate file/conversation grants.
+        return { ...context, hostType: 'project', hostId: access.projectId, runtimeScope: undefined };
+    }
     async list(context, input) {
         const actor = this.actor(context), access = this.runtime.require(plugin_sdk_1.ProjectAccessRuntimeCapability);
         const projects = await access.listReadable({ actor });

package/dist/lib/source-executions.d.ts

@@ -0,0 +1,196 @@
+import { z } from 'zod/v3';
+export declare const sourceDatasetSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"xpert.analytics.dataset">;
+    datasetId: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, "many">;
+    completeness: z.ZodObject<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    freshness: z.ZodObject<{
+        sourceFetchedAt: z.ZodString;
+        executedAt: z.ZodOptional<z.ZodString>;
+        dataAsOf: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sourceFetchedAt: string;
+        executedAt?: string | undefined;
+        dataAsOf?: string | undefined;
+    }, {
+        sourceFetchedAt: string;
+        executedAt?: string | undefined;
+        dataAsOf?: string | undefined;
+    }>;
+    provenance: z.ZodObject<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    schema: z.ZodLiteral<"xpert.analytics.dataset">;
+    datasetId: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, "many">;
+    completeness: z.ZodObject<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    freshness: z.ZodObject<{
+        sourceFetchedAt: z.ZodString;
+        executedAt: z.ZodOptional<z.ZodString>;
+        dataAsOf: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sourceFetchedAt: string;
+        executedAt?: string | undefined;
+        dataAsOf?: string | undefined;
+    }, {
+        sourceFetchedAt: string;
+        executedAt?: string | undefined;
+        dataAsOf?: string | undefined;
+    }>;
+    provenance: z.ZodObject<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    schema: z.ZodLiteral<"xpert.analytics.dataset">;
+    datasetId: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>, "many">;
+    completeness: z.ZodObject<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        truncated: z.ZodBoolean;
+        returnedRows: z.ZodNumber;
+        scope: z.ZodString;
+        totalAccuracy: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+    freshness: z.ZodObject<{
+        sourceFetchedAt: z.ZodString;
+        executedAt: z.ZodOptional<z.ZodString>;
+        dataAsOf: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        sourceFetchedAt: string;
+        executedAt?: string | undefined;
+        dataAsOf?: string | undefined;
+    }, {
+        sourceFetchedAt: string;
+        executedAt?: string | undefined;
+        dataAsOf?: string | undefined;
+    }>;
+    provenance: z.ZodObject<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        executionId: z.ZodString;
+        bindingId: z.ZodString;
+        providerId: z.ZodString;
+    }, z.ZodTypeAny, "passthrough">>;
+}, z.ZodTypeAny, "passthrough">>;
+export type SourceDataset = z.infer<typeof sourceDatasetSchema>;
+export interface SourceExecution {
+    requestId: string;
+    state: 'running' | 'succeeded' | 'failed';
+    controls: Record<string, string | number | boolean | null>;
+    requestedAt: string;
+    finishedAt?: string;
+    result?: SourceDataset;
+    resultControls?: SourceExecution['controls'];
+}
+export type SourceEvent = {
+    bindingId: string;
+    requestId: string;
+} & ({
+    type: 'start';
+    controls: SourceExecution['controls'];
+    at: string;
+} | {
+    type: 'success';
+    result: SourceDataset;
+    at: string;
+} | {
+    type: 'failure';
+    at: string;
+});
+export declare function reduceSourceExecutions(state: Record<string, SourceExecution>, event: SourceEvent): Record<string, SourceExecution>;

package/dist/lib/source-executions.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sourceDatasetSchema = void 0;
+exports.reduceSourceExecutions = reduceSourceExecutions;
+const v3_1 = require("zod/v3");
+const scalar = v3_1.z.union([v3_1.z.string(), v3_1.z.number(), v3_1.z.boolean(), v3_1.z.null()]);
+exports.sourceDatasetSchema = v3_1.z.object({
+    schema: v3_1.z.literal('xpert.analytics.dataset'), datasetId: v3_1.z.string(),
+    fields: v3_1.z.array(v3_1.z.object({ id: v3_1.z.string(), label: v3_1.z.string().optional() }).passthrough()), rows: v3_1.z.array(v3_1.z.record(scalar)),
+    completeness: v3_1.z.object({ truncated: v3_1.z.boolean(), returnedRows: v3_1.z.number(), scope: v3_1.z.string(), totalAccuracy: v3_1.z.string() }).passthrough(),
+    freshness: v3_1.z.object({ sourceFetchedAt: v3_1.z.string(), executedAt: v3_1.z.string().optional(), dataAsOf: v3_1.z.string().optional() }),
+    provenance: v3_1.z.object({ executionId: v3_1.z.string(), bindingId: v3_1.z.string(), providerId: v3_1.z.string() }).passthrough()
+}).passthrough();
+function reduceSourceExecutions(state, event) {
+    const previous = state[event.bindingId];
+    if (event.type === 'start')
+        return { ...state, [event.bindingId]: {
+                requestId: event.requestId, state: 'running', controls: event.controls, requestedAt: event.at,
+                result: previous?.result, resultControls: previous?.resultControls
+            } };
+    if (!previous || previous.requestId !== event.requestId)
+        return state;
+    return { ...state, [event.bindingId]: { ...previous, state: event.type === 'success' ? 'succeeded' : 'failed', finishedAt: event.at,
+            ...(event.type === 'success' ? { result: { ...event.result, rows: event.result.rows.slice(0, 50) }, resultControls: previous.controls } : {}) } };
+}

package/dist/lib/source-validation.d.ts

@@ -0,0 +1,2 @@
+import type { DashboardManifest } from './dashboard.schema';
+export declare function assertComponentElements(manifest: DashboardManifest): void;

package/dist/lib/source-validation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertComponentElements = assertComponentElements;
+const parse5_1 = require("parse5");
+function assertComponentElements(manifest) {
+    if (!manifest.presentation || !manifest.components?.length)
+        return;
+    const ids = new Map();
+    const visit = (node) => {
+        if ('attrs' in node)
+            for (const attr of node.attrs)
+                if (attr.name === 'id')
+                    ids.set(attr.value, (ids.get(attr.value) ?? 0) + 1);
+        if ('childNodes' in node)
+            node.childNodes.forEach(visit);
+    };
+    visit((0, parse5_1.parse)(manifest.presentation.html));
+    for (const component of manifest.components)
+        if (ids.get(component.elementId) !== 1)
+            throw new Error(`DASHBOARD_COMPONENT_ELEMENT_INVALID: ${component.id}`);
+}