@happyvertical/smrt-reports 0.55.23 → 0.56.0

package/dist/svelte/playground.d.ts

@@ -0,0 +1,132 @@
+declare const _default: {
+    packageName: string;
+    displayName: string;
+    description: string;
+    entries: ({
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./SavedReports.svelte").Props, {}, "">>;
+        props: {
+            client: import("./types.js").RuntimeReportsClient;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportDetail.svelte").Props, {}, "">>;
+        props: {
+            id: string;
+            client: import("./types.js").RuntimeReportsClient;
+            locale: string;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportConfirmation.svelte").Props, {}, "">>;
+        props: {
+            proposal: import("./types.js").RuntimeReportProposal;
+            confirm: () => Promise<import("./types.js").SavedRuntimeReport>;
+            client?: undefined;
+            id?: undefined;
+            locale?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportPicker.svelte").Props, {}, "">>;
+        props: {
+            client: import("./types.js").RuntimeReportsClient;
+            reportId: string;
+            measure: string;
+            dimension: string;
+            onchange: () => void;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            serverAvailable?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./RuntimeReportsRoute.svelte").Props, {}, "">>;
+        props: {
+            serverAvailable: boolean;
+            client?: undefined;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            result?: undefined;
+        };
+        order: number;
+    } | {
+        id: string;
+        title: string;
+        description: string;
+        loadComponent: () => Promise<import("svelte").Component<import("./ReportResult.svelte").Props, {}, "">>;
+        props: {
+            result: {
+                rows: never[];
+                rowCount: number;
+                version: 1;
+                specHash: string;
+                title: string;
+                columns: import("../runtime-compiler.js").RuntimeReportColumn[];
+                truncated: boolean;
+                ranAt: string;
+                chart: import("../runtime-spec.js").RuntimeReportChart;
+            };
+            client?: undefined;
+            id?: undefined;
+            locale?: undefined;
+            proposal?: undefined;
+            confirm?: undefined;
+            reportId?: undefined;
+            measure?: undefined;
+            dimension?: undefined;
+            onchange?: undefined;
+            serverAvailable?: undefined;
+        };
+        order: number;
+    })[];
+};
+export default _default;
+//# sourceMappingURL=playground.d.ts.map

package/dist/svelte/playground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playground.d.ts","sourceRoot":"","sources":["../../src/svelte/playground.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEA,wBAkEE"}

package/dist/svelte/playground.js

@@ -0,0 +1,62 @@
+import { client, proposal, result, saved } from './preview-data.js';
+export default {
+    packageName: '@happyvertical/smrt-reports',
+    displayName: 'Reports',
+    description: 'Saved runtime reports and live results.',
+    entries: [
+        {
+            id: 'saved-reports',
+            title: 'Saved reports',
+            description: 'Shared reports, author filter, and archive controls.',
+            loadComponent: () => import('./SavedReports.svelte').then((m) => m.default),
+            props: { client: client() },
+            order: 1,
+        },
+        {
+            id: 'report-detail',
+            title: 'Report detail',
+            description: 'Money values with chart and table views.',
+            loadComponent: () => import('./ReportDetail.svelte').then((m) => m.default),
+            props: { id: saved.id, client: client(), locale: 'en-US' },
+            order: 2,
+        },
+        {
+            id: 'report-confirmation',
+            title: 'Report confirmation',
+            description: 'Review a bounded proposal before saving.',
+            loadComponent: () => import('./ReportConfirmation.svelte').then((m) => m.default),
+            props: { proposal, confirm: async () => saved },
+            order: 3,
+        },
+        {
+            id: 'report-picker',
+            title: 'Report picker',
+            description: 'Choose a saved report and its measure.',
+            loadComponent: () => import('./ReportPicker.svelte').then((m) => m.default),
+            props: {
+                client: client(),
+                reportId: saved.id,
+                measure: 'total',
+                dimension: 'region',
+                onchange: () => { },
+            },
+            order: 4,
+        },
+        {
+            id: 'reports-unavailable',
+            title: 'Reports unavailable',
+            description: 'Static hosts do not make server requests.',
+            loadComponent: () => import('./RuntimeReportsRoute.svelte').then((m) => m.default),
+            props: { serverAvailable: false },
+            order: 5,
+        },
+        {
+            id: 'report-empty',
+            title: 'Empty report',
+            description: 'A valid report with no matching rows.',
+            loadComponent: () => import('./ReportResult.svelte').then((m) => m.default),
+            props: { result: { ...result, rows: [], rowCount: 0 } },
+            order: 6,
+        },
+    ],
+};

package/dist/svelte/preview-data.d.ts

@@ -0,0 +1,7 @@
+import type { RuntimeReportProposal, RuntimeReportResult, RuntimeReportSpec, RuntimeReportsClient, SavedRuntimeReport } from './types.js';
+export declare const spec: RuntimeReportSpec;
+export declare const result: RuntimeReportResult;
+export declare const saved: SavedRuntimeReport;
+export declare const proposal: RuntimeReportProposal;
+export declare function client(overrides?: Partial<RuntimeReportsClient>): RuntimeReportsClient;
+//# sourceMappingURL=preview-data.d.ts.map

package/dist/svelte/preview-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview-data.d.ts","sourceRoot":"","sources":["../../src/svelte/preview-data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAEpB,eAAO,MAAM,IAAI,EAAE,iBAWlB,CAAC;AACF,eAAO,MAAM,MAAM,EAAE,mBAmBpB,CAAC;AACF,eAAO,MAAM,KAAK,EAAE,kBAQnB,CAAC;AACF,eAAO,MAAM,QAAQ,EAAE,qBAOtB,CAAC;AACF,wBAAgB,MAAM,CACpB,SAAS,GAAE,OAAO,CAAC,oBAAoB,CAAM,GAC5C,oBAAoB,CAStB"}

package/dist/svelte/preview-data.js

@@ -0,0 +1,59 @@
+export const spec = {
+    version: 1,
+    title: 'Sales by region',
+    source: 'sales',
+    dimensions: [{ field: 'region', as: 'region' }],
+    measures: [{ fn: 'sum', field: 'amount', as: 'total' }],
+    filters: [],
+    having: [],
+    sort: [],
+    limit: 100,
+    chart: { type: 'bar', x: 'region', y: ['total'] },
+};
+export const result = {
+    version: 1,
+    specHash: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+    title: spec.title,
+    columns: [
+        { id: 'region', label: 'Region', role: 'dimension', type: 'string' },
+        {
+            id: 'total',
+            label: 'Total',
+            role: 'measure',
+            type: 'integer',
+            format: 'money',
+        },
+    ],
+    rows: [{ region: 'West', total: 12345 }],
+    rowCount: 1,
+    truncated: false,
+    ranAt: '2026-10-13T12:00:00Z',
+    chart: spec.chart,
+};
+export const saved = {
+    id: 'report-1',
+    title: spec.title,
+    sourceId: 'sales',
+    createdByUserId: 'alice',
+    status: 'active',
+    spec,
+    canArchive: true,
+};
+export const proposal = {
+    status: 'awaiting_confirmation',
+    specHash: result.specHash,
+    spec,
+    preview: result,
+    sourceLabel: 'Sales',
+    confirmPath: '/api/_reports/runtime/confirm',
+};
+export function client(overrides = {}) {
+    return {
+        list: async () => [saved],
+        get: async () => saved,
+        run: async () => result,
+        archive: async () => { },
+        confirm: async () => saved,
+        ...overrides,
+    };
+}

package/dist/svelte/result.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeReportResult } from './types.js';
+export declare function reportError(error: unknown): 'reports.denied' | 'reports.invalid' | 'reports.error';
+/** Validate untrusted result data before formatting, including integer precision. */
+export declare function validReportResult(value: unknown): value is RuntimeReportResult;
+export declare function reportCell(value: unknown, column: RuntimeReportResult['columns'][number], locale: string, currency: string): string;
+/** Narrow the UI projection; canonical spec validation remains server-owned. */
+export declare function validReportProposal(value: unknown): value is import('./types.js').RuntimeReportProposal;
+//# sourceMappingURL=result.d.ts.map

package/dist/svelte/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/svelte/result.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,wBAAgB,WAAW,CACzB,KAAK,EAAE,OAAO,GACb,gBAAgB,GAAG,iBAAiB,GAAG,eAAe,CAQxD;AAED,qFAAqF;AACrF,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,mBAAmB,CAkD9B;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,OAAO,EACd,MAAM,EAAE,mBAAmB,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EAC9C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,MAAM,CAcR;AAED,gFAAgF;AAChF,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,OAAO,YAAY,EAAE,qBAAqB,CA8BrD"}

package/dist/svelte/result.js

@@ -0,0 +1,99 @@
+import { formatWidgetValue } from '@happyvertical/smrt-ui/charts/format';
+import { validRuntimeReportSpec } from './spec.js';
+export function reportError(error) {
+    if (error && typeof error === 'object') {
+        const e = error;
+        if (e.status === 401 || e.status === 403 || e.code === 'unknown_field')
+            return 'reports.denied';
+        if (e.code === 'invalid_result')
+            return 'reports.invalid';
+    }
+    return 'reports.error';
+}
+/** Validate untrusted result data before formatting, including integer precision. */
+export function validReportResult(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const r = value;
+    return (r.version === 1 &&
+        typeof r.title === 'string' &&
+        typeof r.specHash === 'string' &&
+        typeof r.ranAt === 'string' &&
+        typeof r.truncated === 'boolean' &&
+        Array.isArray(r.columns) &&
+        r.columns.length > 0 &&
+        r.columns.length <= 10 &&
+        new Set(r.columns.map((c) => c?.id)).size === r.columns.length &&
+        r.columns.every((c) => c &&
+            typeof c.id === 'string' &&
+            typeof c.label === 'string' &&
+            ['dimension', 'measure'].includes(c.role) &&
+            ['string', 'integer', 'decimal', 'boolean', 'datetime', 'id'].includes(c.type)) &&
+        Array.isArray(r.rows) &&
+        r.rows.length <= 1000 &&
+        r.rowCount === r.rows.length &&
+        r.rows.every((row) => row &&
+            typeof row === 'object' &&
+            r.columns.every((c) => {
+                const v = row[c.id];
+                if (v === null)
+                    return true;
+                if (c.type === 'integer')
+                    return typeof v === 'number' && Number.isSafeInteger(v);
+                if (c.type === 'decimal')
+                    return typeof v === 'number' && Number.isFinite(v);
+                if (c.type === 'boolean')
+                    return typeof v === 'boolean';
+                return typeof v === 'string';
+            })) &&
+        !!r.chart &&
+        ['bar', 'line', 'table', 'pie', 'stat'].includes(r.chart.type) &&
+        (r.chart.y === undefined ||
+            (Array.isArray(r.chart.y) &&
+                r.chart.y.every((id) => r.columns.some((c) => c.id === id && c.role === 'measure')))) &&
+        (r.chart.x === undefined || r.columns.some((c) => c.id === r.chart.x)));
+}
+export function reportCell(value, column, locale, currency) {
+    if (value === null || value === undefined)
+        return '–';
+    if (typeof value === 'number')
+        return formatWidgetValue(value, {
+            format: column.format === 'money'
+                ? 'money'
+                : column.type === 'integer'
+                    ? 'integer'
+                    : 'decimal',
+            locale,
+            currency,
+        });
+    return String(value);
+}
+/** Narrow the UI projection; canonical spec validation remains server-owned. */
+export function validReportProposal(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const p = value;
+    if (p.status !== 'awaiting_confirmation' ||
+        typeof p.specHash !== 'string' ||
+        !/^[a-f0-9]{64}$/.test(p.specHash) ||
+        typeof p.sourceLabel !== 'string' ||
+        p.sourceLabel.length < 1 ||
+        p.sourceLabel.length > 120 ||
+        typeof p.confirmPath !== 'string' ||
+        p.confirmPath.length > 2048 ||
+        !p.confirmPath.startsWith('/') ||
+        p.confirmPath.startsWith('//') ||
+        !validReportResult(p.preview) ||
+        p.preview.specHash !== p.specHash ||
+        !p.spec)
+        return false;
+    if (!validRuntimeReportSpec(p.spec) || p.preview.title !== p.spec.title)
+        return false;
+    const roles = new Map([
+        ...p.spec.dimensions.map((entry) => [entry.as, 'dimension']),
+        ...p.spec.measures.map((entry) => [entry.as, 'measure']),
+    ]);
+    return (p.preview.columns.length === roles.size &&
+        p.preview.columns.every((column) => roles.get(column.id) === column.role) &&
+        JSON.stringify(p.preview.chart) === JSON.stringify(p.spec.chart));
+}

package/dist/svelte/spec.d.ts

@@ -0,0 +1,5 @@
+import type { RuntimeReportSpec } from './types.js';
+/** Browser-safe validation of the server's already-normalized closed grammar. */
+export declare function validRuntimeReportSpec(value: unknown): value is RuntimeReportSpec;
+export declare function runtimeReportSpecFromWire(value: unknown): RuntimeReportSpec | null;
+//# sourceMappingURL=spec.d.ts.map

package/dist/svelte/spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spec.d.ts","sourceRoot":"","sources":["../../src/svelte/spec.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AA+JpD,iFAAiF;AACjF,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,iBAAiB,CA4I5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,GACb,iBAAiB,GAAG,IAAI,CAW1B"}

package/dist/svelte/spec.js

@@ -0,0 +1,282 @@
+const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]*$/;
+const ALIAS = /^[a-z][a-z0-9_]*$/;
+const SOURCE = /^[A-Za-z@][A-Za-z0-9_@./:-]*$/;
+// biome-ignore lint/suspicious/noControlCharactersInRegex: mirrors the server grammar's printable-text guard
+const CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/;
+const BUCKETS = new Set([
+    'minute',
+    'hour',
+    'day',
+    'week',
+    'month',
+    'quarter',
+    'year',
+]);
+const MEASURES = new Set([
+    'count',
+    'countDistinct',
+    'sum',
+    'avg',
+    'min',
+    'max',
+]);
+const FILTERS = new Set([
+    'eq',
+    'ne',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'in',
+    'notIn',
+    'contains',
+    'isNull',
+    'isNotNull',
+]);
+const HAVING = new Set(['eq', 'ne', 'gt', 'gte', 'lt', 'lte']);
+const CHARTS = new Set(['table', 'bar', 'line', 'pie', 'stat']);
+const RESERVED = new Set([
+    'all',
+    'and',
+    'as',
+    'asc',
+    'between',
+    'by',
+    'case',
+    'cast',
+    'check',
+    'column',
+    'constraint',
+    'create',
+    'cross',
+    'default',
+    'delete',
+    'desc',
+    'distinct',
+    'drop',
+    'else',
+    'end',
+    'except',
+    'exists',
+    'false',
+    'for',
+    'foreign',
+    'from',
+    'full',
+    'group',
+    'having',
+    'in',
+    'inner',
+    'insert',
+    'intersect',
+    'into',
+    'is',
+    'join',
+    'left',
+    'like',
+    'limit',
+    'natural',
+    'not',
+    'null',
+    'offset',
+    'on',
+    'or',
+    'order',
+    'outer',
+    'primary',
+    'references',
+    'right',
+    'select',
+    'set',
+    'table',
+    'then',
+    'to',
+    'true',
+    'union',
+    'unique',
+    'update',
+    'user',
+    'using',
+    'values',
+    'when',
+    'where',
+    'with',
+]);
+function record(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null
+        ? value
+        : null;
+}
+function keys(value, allowed) {
+    return Object.keys(value).every((key) => allowed.includes(key));
+}
+function text(value, max, optional = false) {
+    if (value === undefined)
+        return optional;
+    if (typeof value !== 'string')
+        return false;
+    const trimmed = value.trim();
+    return (trimmed.length > 0 &&
+        trimmed.length <= max &&
+        trimmed === value &&
+        !CONTROL.test(trimmed));
+}
+function field(value) {
+    return (typeof value === 'string' && value.length <= 64 && IDENTIFIER.test(value));
+}
+function alias(value) {
+    return (typeof value === 'string' &&
+        value.length <= 40 &&
+        ALIAS.test(value) &&
+        !RESERVED.has(value));
+}
+function scalar(value) {
+    return ((typeof value === 'string' &&
+        value.length <= 256 &&
+        !value.includes('\u0000')) ||
+        (typeof value === 'number' && Number.isFinite(value)) ||
+        typeof value === 'boolean');
+}
+/** Browser-safe validation of the server's already-normalized closed grammar. */
+export function validRuntimeReportSpec(value) {
+    const spec = record(value);
+    if (!spec ||
+        !keys(spec, [
+            'version',
+            'title',
+            'description',
+            'source',
+            'dimensions',
+            'measures',
+            'filters',
+            'having',
+            'sort',
+            'limit',
+            'chart',
+        ]) ||
+        spec.version !== 1 ||
+        !text(spec.title, 120) ||
+        !text(spec.description, 500, true) ||
+        typeof spec.source !== 'string' ||
+        spec.source.length === 0 ||
+        spec.source.length > 120 ||
+        !SOURCE.test(spec.source) ||
+        !Array.isArray(spec.dimensions) ||
+        spec.dimensions.length > 4 ||
+        !Array.isArray(spec.measures) ||
+        spec.measures.length < 1 ||
+        spec.measures.length > 6 ||
+        !Array.isArray(spec.filters) ||
+        spec.filters.length > 12 ||
+        !Array.isArray(spec.having) ||
+        spec.having.length > 4 ||
+        !Array.isArray(spec.sort) ||
+        spec.sort.length > 3 ||
+        !Number.isSafeInteger(spec.limit) ||
+        spec.limit < 1 ||
+        spec.limit > 1000)
+        return false;
+    const dimensions = new Set();
+    const measures = new Set();
+    const aliases = new Set();
+    for (const value of spec.dimensions) {
+        const item = record(value);
+        if (!item ||
+            !keys(item, ['field', 'as', 'bucket']) ||
+            !field(item.field) ||
+            !alias(item.as) ||
+            (item.bucket !== undefined &&
+                (typeof item.bucket !== 'string' || !BUCKETS.has(item.bucket))) ||
+            aliases.has(item.as))
+            return false;
+        aliases.add(item.as);
+        dimensions.add(item.as);
+    }
+    for (const value of spec.measures) {
+        const item = record(value);
+        if (!item ||
+            !keys(item, ['fn', 'field', 'as']) ||
+            typeof item.fn !== 'string' ||
+            !MEASURES.has(item.fn) ||
+            !alias(item.as) ||
+            aliases.has(item.as) ||
+            (item.field !== undefined && !field(item.field)) ||
+            (item.fn !== 'count' && item.field === undefined))
+            return false;
+        aliases.add(item.as);
+        measures.add(item.as);
+    }
+    for (const value of spec.filters) {
+        const item = record(value);
+        if (!item ||
+            !keys(item, ['field', 'op', 'value']) ||
+            !field(item.field) ||
+            typeof item.op !== 'string' ||
+            !FILTERS.has(item.op))
+            return false;
+        if (item.op === 'isNull' || item.op === 'isNotNull') {
+            if (item.value !== undefined)
+                return false;
+        }
+        else if (item.op === 'in' || item.op === 'notIn') {
+            if (!Array.isArray(item.value) ||
+                item.value.length < 1 ||
+                item.value.length > 100 ||
+                !item.value.every(scalar))
+                return false;
+        }
+        else if (!scalar(item.value) ||
+            (item.op === 'contains' && typeof item.value !== 'string'))
+            return false;
+    }
+    for (const value of spec.having) {
+        const item = record(value);
+        if (!item ||
+            !keys(item, ['measure', 'op', 'value']) ||
+            !alias(item.measure) ||
+            !measures.has(item.measure) ||
+            typeof item.op !== 'string' ||
+            !HAVING.has(item.op) ||
+            typeof item.value !== 'number' ||
+            !Number.isFinite(item.value))
+            return false;
+    }
+    for (const value of spec.sort) {
+        const item = record(value);
+        if (!item ||
+            !keys(item, ['by', 'direction']) ||
+            !alias(item.by) ||
+            !aliases.has(item.by) ||
+            (item.direction !== 'asc' && item.direction !== 'desc'))
+            return false;
+    }
+    const chart = record(spec.chart);
+    if (!chart ||
+        !keys(chart, ['type', 'x', 'y']) ||
+        typeof chart.type !== 'string' ||
+        !CHARTS.has(chart.type) ||
+        (chart.x !== undefined && (!alias(chart.x) || !dimensions.has(chart.x))) ||
+        (chart.y !== undefined &&
+            (!Array.isArray(chart.y) ||
+                chart.y.length > 6 ||
+                !chart.y.every((name) => alias(name) && measures.has(name)))))
+        return false;
+    return true;
+}
+export function runtimeReportSpecFromWire(value) {
+    let candidate = value;
+    if (typeof value === 'string') {
+        if (value.length > 64 * 1024)
+            return null;
+        try {
+            candidate = JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    }
+    return validRuntimeReportSpec(candidate) ? candidate : null;
+}

package/dist/svelte/tool-result.d.ts

@@ -0,0 +1,11 @@
+import type { Component } from 'svelte';
+import type { RuntimeReportProposal } from './types.js';
+export interface ToolResultMessage {
+    toolCallData?: unknown;
+}
+export declare function runtimeReportProposalFromMessage(message: ToolResultMessage): RuntimeReportProposal | null;
+/** Host selector for AssistantDock's generic `toolResultComponent` seam. */
+export declare function runtimeReportToolResultComponent(message: ToolResultMessage): Component<{
+    message: ToolResultMessage;
+}> | undefined;
+//# sourceMappingURL=tool-result.d.ts.map