@syntrologie/adapt-viz 2.8.0-canary.140

package/dist/ChartWidgetLit.d.ts

@@ -0,0 +1,28 @@
+/**
+ * adaptive-viz — Lit web component
+ *
+ * <syntro-viz-chart> renders a chart from the typed ChartProps. Vega-Lite
+ * is dynamically imported on first render so the core SDK bundle stays
+ * slim — first chart in a session pays the load cost; subsequent charts
+ * share the loaded module.
+ */
+import { LitElement } from 'lit';
+import type { ChartProps } from './types';
+export declare class ChartWidgetLit extends LitElement {
+    #private;
+    static properties: {
+        chartProps: {
+            attribute: boolean;
+        };
+    };
+    chartProps: ChartProps | undefined;
+    createRenderRoot(): this;
+    updated(changed: Map<string, unknown>): Promise<void>;
+    render(): import("lit-html").TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'syntro-viz-chart': ChartWidgetLit;
+    }
+}
+//# sourceMappingURL=ChartWidgetLit.d.ts.map

package/dist/ChartWidgetLit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartWidgetLit.d.ts","sourceRoot":"","sources":["../src/ChartWidgetLit.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAQ,UAAU,EAAE,MAAM,KAAK,CAAC;AAGvC,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,SAAS,CAAC;AAExD,qBAAa,cAAe,SAAQ,UAAU;;IAC5C,OAAgB,UAAU;;;;MAExB;IAEF,UAAU,EAAE,UAAU,GAAG,SAAS,CAAa;IAGtC,gBAAgB;IAIV,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAM3D,MAAM;CAkChB;AAED,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,qBAAqB;QAC7B,kBAAkB,EAAE,cAAc,CAAC;KACpC;CACF"}

package/dist/ChartWidgetLit.js

@@ -0,0 +1,68 @@
+/**
+ * adaptive-viz — Lit web component
+ *
+ * <syntro-viz-chart> renders a chart from the typed ChartProps. Vega-Lite
+ * is dynamically imported on first render so the core SDK bundle stays
+ * slim — first chart in a session pays the load cost; subsequent charts
+ * share the loaded module.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ChartWidgetLit_instances, _ChartWidgetLit_renderChart;
+import { html, LitElement } from 'lit';
+import { compileToVegaLite } from './layouts';
+import { buildVegaLiteConfigFromCssVars } from './theme';
+export class ChartWidgetLit extends LitElement {
+    constructor() {
+        super(...arguments);
+        _ChartWidgetLit_instances.add(this);
+        this.chartProps = undefined;
+    }
+    // Render into light DOM so the parent shadow root's CSS variables flow through.
+    createRenderRoot() {
+        return this;
+    }
+    async updated(changed) {
+        if (changed.has('chartProps')) {
+            await __classPrivateFieldGet(this, _ChartWidgetLit_instances, "m", _ChartWidgetLit_renderChart).call(this);
+        }
+    }
+    render() {
+        return html `<div data-syntro-viz-chart-container style="width:100%; min-height:200px;"></div>`;
+    }
+}
+_ChartWidgetLit_instances = new WeakSet(), _ChartWidgetLit_renderChart = async function _ChartWidgetLit_renderChart() {
+    const container = this.querySelector('[data-syntro-viz-chart-container]');
+    if (!container)
+        return;
+    if (!this.chartProps) {
+        container.textContent = '(no chart configured)';
+        return;
+    }
+    let spec;
+    try {
+        spec = compileToVegaLite(this.chartProps);
+    }
+    catch (err) {
+        container.textContent = `Chart error: ${err.message}`;
+        return;
+    }
+    const config = buildVegaLiteConfigFromCssVars(this);
+    try {
+        const { default: embed } = await import('vega-embed');
+        await embed(container, spec, {
+            actions: false,
+            config: config,
+            renderer: 'svg',
+        });
+    }
+    catch (err) {
+        container.textContent = `Chart render error: ${err.message}`;
+    }
+};
+ChartWidgetLit.properties = {
+    chartProps: { attribute: false },
+};

package/dist/cdn.d.ts

@@ -0,0 +1,14 @@
+/**
+ * adaptive-viz — CDN entrypoint
+ *
+ * Loaded by the runtime SDK's AppLoader when a tile references
+ * adaptive-viz:chart and the package isn't bundled (it isn't — see
+ * `syntrologie.bundlingMode: cdn-only` in package.json).
+ *
+ * The act of importing ./runtime registers the <syntro-viz-chart> custom
+ * element and exposes the widget mountable on the manifest.
+ */
+import { runtime } from './runtime';
+export { runtime };
+export default runtime;
+//# sourceMappingURL=cdn.d.ts.map

package/dist/cdn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../src/cdn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,OAAO,EAAE,OAAO,EAAE,CAAC;AACnB,eAAe,OAAO,CAAC"}

package/dist/cdn.js

@@ -0,0 +1,19 @@
+/**
+ * adaptive-viz — CDN entrypoint
+ *
+ * Loaded by the runtime SDK's AppLoader when a tile references
+ * adaptive-viz:chart and the package isn't bundled (it isn't — see
+ * `syntrologie.bundlingMode: cdn-only` in package.json).
+ *
+ * The act of importing ./runtime registers the <syntro-viz-chart> custom
+ * element and exposes the widget mountable on the manifest.
+ */
+import { runtime } from './runtime';
+if (typeof window !== 'undefined') {
+    const synOS = window.SynOS;
+    if (synOS?.appRegistry?.register) {
+        synOS.appRegistry.register(runtime);
+    }
+}
+export { runtime };
+export default runtime;

package/dist/layouts/bar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * adaptive-viz — Bar layout → Vega-Lite spec
+ */
+import type { z } from 'zod';
+import type { barLayoutSchema } from '../schema';
+import type { VegaLiteSpec } from '../types';
+type BarProps = z.infer<typeof barLayoutSchema>;
+export declare function barToVegaLite(props: BarProps): VegaLiteSpec;
+export {};
+//# sourceMappingURL=bar.d.ts.map

package/dist/layouts/bar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bar.d.ts","sourceRoot":"","sources":["../../src/layouts/bar.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI7C,KAAK,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAEhD,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,GAAG,YAAY,CAsB3D"}

package/dist/layouts/bar.js

@@ -0,0 +1,23 @@
+/**
+ * adaptive-viz — Bar layout → Vega-Lite spec
+ */
+const VEGA_LITE_SCHEMA_URL = 'https://vega.github.io/schema/vega-lite/v5.json';
+export function barToVegaLite(props) {
+    const encoding = {
+        x: { field: props.xField, type: 'nominal' },
+        y: { field: props.yField, type: 'quantitative' },
+    };
+    if (props.colorField) {
+        encoding.color = { field: props.colorField, type: 'nominal' };
+    }
+    const spec = {
+        $schema: VEGA_LITE_SCHEMA_URL,
+        data: { values: props.data },
+        mark: 'bar',
+        encoding,
+    };
+    if (props.title) {
+        spec.title = props.title;
+    }
+    return spec;
+}

package/dist/layouts/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * adaptive-viz — Layout dispatcher
+ *
+ * Given validated ChartProps, produce a Vega-Lite spec ready for rendering.
+ * Dispatches by `layout` key. The custom path passes the spec through
+ * after the runtime self-contained-data check.
+ */
+import type { ChartProps, VegaLiteSpec } from '../types';
+export declare function compileToVegaLite(props: ChartProps): VegaLiteSpec;
+export { barToVegaLite } from './bar';
+export { lineToVegaLite } from './line';
+export { tableToVegaLite } from './table';
+//# sourceMappingURL=index.d.ts.map

package/dist/layouts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/layouts/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAMzD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAgBjE;AAED,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}

package/dist/layouts/index.js

@@ -0,0 +1,29 @@
+/**
+ * adaptive-viz — Layout dispatcher
+ *
+ * Given validated ChartProps, produce a Vega-Lite spec ready for rendering.
+ * Dispatches by `layout` key. The custom path passes the spec through
+ * after the runtime self-contained-data check.
+ */
+import { assertSelfContainedData } from '../validation';
+import { barToVegaLite } from './bar';
+import { lineToVegaLite } from './line';
+import { tableToVegaLite } from './table';
+export function compileToVegaLite(props) {
+    switch (props.layout) {
+        case 'bar':
+            return barToVegaLite(props);
+        case 'line':
+            return lineToVegaLite(props);
+        case 'table':
+            return tableToVegaLite(props);
+        case 'custom':
+            assertSelfContainedData(props.spec);
+            return props.spec;
+        default:
+            throw new Error(`Unknown chart layout: ${props.layout ?? 'undefined'}`);
+    }
+}
+export { barToVegaLite } from './bar';
+export { lineToVegaLite } from './line';
+export { tableToVegaLite } from './table';

package/dist/layouts/line.d.ts

@@ -0,0 +1,10 @@
+/**
+ * adaptive-viz — Line layout → Vega-Lite spec
+ */
+import type { z } from 'zod';
+import type { lineLayoutSchema } from '../schema';
+import type { VegaLiteSpec } from '../types';
+type LineProps = z.infer<typeof lineLayoutSchema>;
+export declare function lineToVegaLite(props: LineProps): VegaLiteSpec;
+export {};
+//# sourceMappingURL=line.d.ts.map

package/dist/layouts/line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/layouts/line.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI7C,KAAK,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAElD,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,YAAY,CAsB7D"}

package/dist/layouts/line.js

@@ -0,0 +1,23 @@
+/**
+ * adaptive-viz — Line layout → Vega-Lite spec
+ */
+const VEGA_LITE_SCHEMA_URL = 'https://vega.github.io/schema/vega-lite/v5.json';
+export function lineToVegaLite(props) {
+    const encoding = {
+        x: { field: props.xField, type: 'quantitative' },
+        y: { field: props.yField, type: 'quantitative' },
+    };
+    if (props.seriesField) {
+        encoding.color = { field: props.seriesField, type: 'nominal' };
+    }
+    const spec = {
+        $schema: VEGA_LITE_SCHEMA_URL,
+        data: { values: props.data },
+        mark: 'line',
+        encoding,
+    };
+    if (props.title) {
+        spec.title = props.title;
+    }
+    return spec;
+}

package/dist/layouts/table.d.ts

@@ -0,0 +1,15 @@
+/**
+ * adaptive-viz — Table layout → Vega-Lite spec
+ *
+ * Renders a tabular layout as a layered Vega-Lite spec where each column
+ * is its own text-mark layer positioned by ordinal x. Suitable for small
+ * data tables (<= 50 rows). For large tables, prefer a custom layout
+ * with a more efficient rendering strategy.
+ */
+import type { z } from 'zod';
+import type { tableLayoutSchema } from '../schema';
+import type { VegaLiteSpec } from '../types';
+type TableProps = z.infer<typeof tableLayoutSchema>;
+export declare function tableToVegaLite(props: TableProps): VegaLiteSpec;
+export {};
+//# sourceMappingURL=table.d.ts.map

package/dist/layouts/table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.d.ts","sourceRoot":"","sources":["../../src/layouts/table.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAI7C,KAAK,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAEpD,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAwB/D"}

package/dist/layouts/table.js

@@ -0,0 +1,30 @@
+/**
+ * adaptive-viz — Table layout → Vega-Lite spec
+ *
+ * Renders a tabular layout as a layered Vega-Lite spec where each column
+ * is its own text-mark layer positioned by ordinal x. Suitable for small
+ * data tables (<= 50 rows). For large tables, prefer a custom layout
+ * with a more efficient rendering strategy.
+ */
+const VEGA_LITE_SCHEMA_URL = 'https://vega.github.io/schema/vega-lite/v5.json';
+export function tableToVegaLite(props) {
+    const layer = props.columns.map((col, idx) => ({
+        mark: { type: 'text', align: 'left', baseline: 'middle' },
+        encoding: {
+            x: { value: idx * 120 },
+            y: { field: '_row', type: 'ordinal', axis: null },
+            text: { field: col.field },
+        },
+    }));
+    // Add a row index so y-encoding has something stable to bind to
+    const dataWithRowIdx = props.data.map((row, i) => ({ ...row, _row: i }));
+    const spec = {
+        $schema: VEGA_LITE_SCHEMA_URL,
+        data: { values: dataWithRowIdx },
+        layer,
+    };
+    if (props.title) {
+        spec.title = props.title;
+    }
+    return spec;
+}

package/dist/runtime.d.ts

@@ -0,0 +1,46 @@
+/**
+ * adaptive-viz — Runtime manifest
+ *
+ * Exports the runtime descriptor consumed by the SDK's AppLoader.
+ * Registers the <syntro-viz-chart> custom element as a side effect of
+ * importing this module, and exposes the widget mountable used by
+ * SmartCanvasRuntime's WidgetRegistry.
+ */
+import type { ChartProps } from './types';
+/**
+ * Mountable widget interface: receives a container element and the tile's
+ * props (validated upstream against chartSchema), returns an unmount fn.
+ */
+export declare const ChartWidgetMountable: {
+    mount(container: HTMLElement, config?: ChartProps & {
+        instanceId?: string;
+    }): () => void;
+};
+export declare const runtime: {
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    /**
+     * No DOM-mutation executors — this widget renders only.
+     */
+    executors: never[];
+    /**
+     * Widget definitions for the runtime's WidgetRegistry.
+     */
+    widgets: {
+        id: string;
+        component: {
+            mount(container: HTMLElement, config?: ChartProps & {
+                instanceId?: string;
+            }): () => void;
+        };
+        metadata: {
+            name: string;
+            description: string;
+            icon: string;
+        };
+    }[];
+};
+export default runtime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAQ1C;;;GAGG;AACH,eAAO,MAAM,oBAAoB;qBACd,WAAW,WAAW,UAAU,GAAG;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;CAU5E,CAAC;AAEF,eAAO,MAAM,OAAO;;;;;IAOlB;;OAEG;;IAGH;;OAEG;;;;6BA1Bc,WAAW,WAAW,UAAU,GAAG;gBAAE,UAAU,CAAC,EAAE,MAAM,CAAA;aAAE;;;;;;;;CAsC5E,CAAC;AAEF,eAAe,OAAO,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,51 @@
+/**
+ * adaptive-viz — Runtime manifest
+ *
+ * Exports the runtime descriptor consumed by the SDK's AppLoader.
+ * Registers the <syntro-viz-chart> custom element as a side effect of
+ * importing this module, and exposes the widget mountable used by
+ * SmartCanvasRuntime's WidgetRegistry.
+ */
+import { ChartWidgetLit } from './ChartWidgetLit';
+const TAG = 'syntro-viz-chart';
+if (typeof customElements !== 'undefined' && !customElements.get(TAG)) {
+    customElements.define(TAG, ChartWidgetLit);
+}
+/**
+ * Mountable widget interface: receives a container element and the tile's
+ * props (validated upstream against chartSchema), returns an unmount fn.
+ */
+export const ChartWidgetMountable = {
+    mount(container, config) {
+        const { instanceId: _instanceId, ...chartProps } = (config ?? {});
+        const el = document.createElement(TAG);
+        el.chartProps = chartProps;
+        container.appendChild(el);
+        return () => el.remove();
+    },
+};
+export const runtime = {
+    id: 'adaptive-viz',
+    version: '1.0.0',
+    name: 'Chart',
+    description: 'Vega-Lite-backed data visualization tile with baked layouts (bar, line, table) plus a custom escape hatch.',
+    /**
+     * No DOM-mutation executors — this widget renders only.
+     */
+    executors: [],
+    /**
+     * Widget definitions for the runtime's WidgetRegistry.
+     */
+    widgets: [
+        {
+            id: 'adaptive-viz:chart',
+            component: ChartWidgetMountable,
+            metadata: {
+                name: 'Chart',
+                description: 'Bar / line / table / custom Vega-Lite chart',
+                icon: '📊',
+            },
+        },
+    ],
+};
+export default runtime;

package/dist/schema.d.ts

@@ -0,0 +1,307 @@
+/**
+ * adaptive-viz — Zod schema (source of truth for tile config validation)
+ *
+ * Discriminated union over `layout`:
+ *   - "bar" | "line" | "table"  → typed wrappers; compiled to Vega-Lite internally
+ *   - "custom"                   → free-form Vega-Lite spec; data must be inline
+ */
+import { z } from 'zod';
+declare const barLayoutSchema: z.ZodObject<{
+    layout: z.ZodLiteral<"bar">;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    xField: z.ZodString;
+    yField: z.ZodString;
+    colorField: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "bar";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    colorField?: string | undefined;
+    title?: string | undefined;
+}, {
+    layout: "bar";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    colorField?: string | undefined;
+    title?: string | undefined;
+}>;
+declare const lineLayoutSchema: z.ZodObject<{
+    layout: z.ZodLiteral<"line">;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    xField: z.ZodString;
+    yField: z.ZodString;
+    seriesField: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "line";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    title?: string | undefined;
+    seriesField?: string | undefined;
+}, {
+    layout: "line";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    title?: string | undefined;
+    seriesField?: string | undefined;
+}>;
+declare const tableLayoutSchema: z.ZodObject<{
+    layout: z.ZodLiteral<"table">;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    columns: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        header: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        field: string;
+        header: string;
+    }, {
+        field: string;
+        header: string;
+    }>, "many">;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "table";
+    data: Record<string, unknown>[];
+    columns: {
+        field: string;
+        header: string;
+    }[];
+    title?: string | undefined;
+}, {
+    layout: "table";
+    data: Record<string, unknown>[];
+    columns: {
+        field: string;
+        header: string;
+    }[];
+    title?: string | undefined;
+}>;
+export declare const customLayoutSchema: z.ZodEffects<z.ZodObject<{
+    layout: z.ZodLiteral<"custom">;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}>, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}>;
+/**
+ * z.discriminatedUnion requires plain ZodObject members (no .refine() wrappers).
+ * customLayoutSchema uses .refine(), so we use z.union here instead.
+ * Runtime performance is still good because all members start with .strict()
+ * and the discriminator `layout` literal eliminates candidates early.
+ */
+export declare const chartSchema: z.ZodUnion<[z.ZodObject<{
+    layout: z.ZodLiteral<"bar">;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    xField: z.ZodString;
+    yField: z.ZodString;
+    colorField: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "bar";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    colorField?: string | undefined;
+    title?: string | undefined;
+}, {
+    layout: "bar";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    colorField?: string | undefined;
+    title?: string | undefined;
+}>, z.ZodObject<{
+    layout: z.ZodLiteral<"line">;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    xField: z.ZodString;
+    yField: z.ZodString;
+    seriesField: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "line";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    title?: string | undefined;
+    seriesField?: string | undefined;
+}, {
+    layout: "line";
+    data: Record<string, unknown>[];
+    xField: string;
+    yField: string;
+    title?: string | undefined;
+    seriesField?: string | undefined;
+}>, z.ZodObject<{
+    layout: z.ZodLiteral<"table">;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+    columns: z.ZodArray<z.ZodObject<{
+        field: z.ZodString;
+        header: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        field: string;
+        header: string;
+    }, {
+        field: string;
+        header: string;
+    }>, "many">;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "table";
+    data: Record<string, unknown>[];
+    columns: {
+        field: string;
+        header: string;
+    }[];
+    title?: string | undefined;
+}, {
+    layout: "table";
+    data: Record<string, unknown>[];
+    columns: {
+        field: string;
+        header: string;
+    }[];
+    title?: string | undefined;
+}>, z.ZodEffects<z.ZodObject<{
+    layout: z.ZodLiteral<"custom">;
+    spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    title: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}>, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}, {
+    layout: "custom";
+    spec: Record<string, unknown>;
+    title?: string | undefined;
+}>]>;
+/**
+ * Tile widget definitions for unified JSON Schema generation.
+ * Maps widget IDs to their props validation schema so the build script
+ * can inject if/then constraints on tile.props.
+ */
+export declare const tileWidgets: {
+    widget: string;
+    defName: string;
+    propsSchema: z.ZodUnion<[z.ZodObject<{
+        layout: z.ZodLiteral<"bar">;
+        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        xField: z.ZodString;
+        yField: z.ZodString;
+        colorField: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        layout: "bar";
+        data: Record<string, unknown>[];
+        xField: string;
+        yField: string;
+        colorField?: string | undefined;
+        title?: string | undefined;
+    }, {
+        layout: "bar";
+        data: Record<string, unknown>[];
+        xField: string;
+        yField: string;
+        colorField?: string | undefined;
+        title?: string | undefined;
+    }>, z.ZodObject<{
+        layout: z.ZodLiteral<"line">;
+        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        xField: z.ZodString;
+        yField: z.ZodString;
+        seriesField: z.ZodOptional<z.ZodString>;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        layout: "line";
+        data: Record<string, unknown>[];
+        xField: string;
+        yField: string;
+        title?: string | undefined;
+        seriesField?: string | undefined;
+    }, {
+        layout: "line";
+        data: Record<string, unknown>[];
+        xField: string;
+        yField: string;
+        title?: string | undefined;
+        seriesField?: string | undefined;
+    }>, z.ZodObject<{
+        layout: z.ZodLiteral<"table">;
+        data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">;
+        columns: z.ZodArray<z.ZodObject<{
+            field: z.ZodString;
+            header: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            field: string;
+            header: string;
+        }, {
+            field: string;
+            header: string;
+        }>, "many">;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        layout: "table";
+        data: Record<string, unknown>[];
+        columns: {
+            field: string;
+            header: string;
+        }[];
+        title?: string | undefined;
+    }, {
+        layout: "table";
+        data: Record<string, unknown>[];
+        columns: {
+            field: string;
+            header: string;
+        }[];
+        title?: string | undefined;
+    }>, z.ZodEffects<z.ZodObject<{
+        layout: z.ZodLiteral<"custom">;
+        spec: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        title: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        layout: "custom";
+        spec: Record<string, unknown>;
+        title?: string | undefined;
+    }, {
+        layout: "custom";
+        spec: Record<string, unknown>;
+        title?: string | undefined;
+    }>, {
+        layout: "custom";
+        spec: Record<string, unknown>;
+        title?: string | undefined;
+    }, {
+        layout: "custom";
+        spec: Record<string, unknown>;
+        title?: string | undefined;
+    }>]>;
+}[];
+export { barLayoutSchema, lineLayoutSchema, tableLayoutSchema };
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;EASV,CAAC;AAEZ,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;EASX,CAAC;AAEZ,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOZ,CAAC;AAkBZ,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;EAS3B,CAAC;AAEL;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAKtB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAEvB,CAAC;AAGF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/schema.js

@@ -0,0 +1,87 @@
+/**
+ * adaptive-viz — Zod schema (source of truth for tile config validation)
+ *
+ * Discriminated union over `layout`:
+ *   - "bar" | "line" | "table"  → typed wrappers; compiled to Vega-Lite internally
+ *   - "custom"                   → free-form Vega-Lite spec; data must be inline
+ */
+import { z } from 'zod';
+const dataRow = z.record(z.string(), z.unknown());
+const barLayoutSchema = z
+    .object({
+    layout: z.literal('bar'),
+    data: z.array(dataRow),
+    xField: z.string(),
+    yField: z.string(),
+    colorField: z.string().optional(),
+    title: z.string().optional(),
+})
+    .strict();
+const lineLayoutSchema = z
+    .object({
+    layout: z.literal('line'),
+    data: z.array(dataRow),
+    xField: z.string(),
+    yField: z.string(),
+    seriesField: z.string().optional(),
+    title: z.string().optional(),
+})
+    .strict();
+const tableLayoutSchema = z
+    .object({
+    layout: z.literal('table'),
+    data: z.array(dataRow),
+    columns: z.array(z.object({ field: z.string(), header: z.string() }).strict()),
+    title: z.string().optional(),
+})
+    .strict();
+/**
+ * Detect whether a Vega-Lite spec has inline data.
+ * Vega-Lite supports `data: { values: [...] }` (inline) or `data: { url, name, source }`
+ * (external). Self-contained means inline only.
+ */
+function hasInlineData(spec) {
+    if (!spec || typeof spec !== 'object')
+        return false;
+    const data = spec.data;
+    if (!data || typeof data !== 'object')
+        return false;
+    const d = data;
+    // Reject any external-data forms outright
+    if ('url' in d || 'name' in d || 'source' in d)
+        return false;
+    // Accept inline values array
+    return Array.isArray(d.values);
+}
+export const customLayoutSchema = z
+    .object({
+    layout: z.literal('custom'),
+    spec: z.record(z.string(), z.unknown()),
+    title: z.string().optional(),
+})
+    .strict()
+    .refine((v) => hasInlineData(v.spec), {
+    message: 'Custom Vega-Lite spec must contain inline data (data.values: [...])',
+});
+/**
+ * z.discriminatedUnion requires plain ZodObject members (no .refine() wrappers).
+ * customLayoutSchema uses .refine(), so we use z.union here instead.
+ * Runtime performance is still good because all members start with .strict()
+ * and the discriminator `layout` literal eliminates candidates early.
+ */
+export const chartSchema = z.union([
+    barLayoutSchema,
+    lineLayoutSchema,
+    tableLayoutSchema,
+    customLayoutSchema,
+]);
+/**
+ * Tile widget definitions for unified JSON Schema generation.
+ * Maps widget IDs to their props validation schema so the build script
+ * can inject if/then constraints on tile.props.
+ */
+export const tileWidgets = [
+    { widget: 'adaptive-viz:chart', defName: 'vizChartProps', propsSchema: chartSchema },
+];
+// Internal re-exports for type derivation (used by types.ts)
+export { barLayoutSchema, lineLayoutSchema, tableLayoutSchema };

package/dist/theme.d.ts

@@ -0,0 +1,18 @@
+/**
+ * adaptive-viz — Theme bridge
+ *
+ * Reads the Syntro CSS variables off the host element's computed style and
+ * produces a Vega-Lite `config` block that matches the customer brand at
+ * compile time. Vega-Lite uses this config as defaults applied across all
+ * marks, axes, legends, and titles.
+ */
+export interface VegaLiteConfig {
+    mark?: Record<string, unknown>;
+    title?: Record<string, unknown>;
+    axis?: Record<string, unknown>;
+    legend?: Record<string, unknown>;
+    view?: Record<string, unknown>;
+    background?: string;
+}
+export declare function buildVegaLiteConfigFromCssVars(host: HTMLElement): VegaLiteConfig;
+//# sourceMappingURL=theme.d.ts.map

package/dist/theme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"theme.d.ts","sourceRoot":"","sources":["../src/theme.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAOD,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,WAAW,GAAG,cAAc,CA+BhF"}

package/dist/theme.js

@@ -0,0 +1,37 @@
+/**
+ * adaptive-viz — Theme bridge
+ *
+ * Reads the Syntro CSS variables off the host element's computed style and
+ * produces a Vega-Lite `config` block that matches the customer brand at
+ * compile time. Vega-Lite uses this config as defaults applied across all
+ * marks, axes, legends, and titles.
+ */
+function readVar(style, name) {
+    const v = style.getPropertyValue(name).trim();
+    return v.length > 0 ? v : undefined;
+}
+export function buildVegaLiteConfigFromCssVars(host) {
+    const style = getComputedStyle(host);
+    const colorPrimary = readVar(style, '--sc-color-primary');
+    const fontFamily = readVar(style, '--sc-font-family');
+    const textColor = readVar(style, '--sc-overlay-text-color');
+    const tileBg = readVar(style, '--sc-tile-background');
+    const config = {};
+    if (colorPrimary) {
+        config.mark = { color: colorPrimary };
+    }
+    if (fontFamily) {
+        config.title = { font: fontFamily };
+        config.axis = { labelFont: fontFamily, titleFont: fontFamily };
+        config.legend = { labelFont: fontFamily, titleFont: fontFamily };
+    }
+    if (textColor) {
+        config.axis = { ...(config.axis ?? {}), labelColor: textColor, titleColor: textColor };
+        config.legend = { ...(config.legend ?? {}), labelColor: textColor, titleColor: textColor };
+        config.title = { ...(config.title ?? {}), color: textColor };
+    }
+    if (tileBg) {
+        config.background = tileBg;
+    }
+    return config;
+}

package/dist/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * adaptive-viz — Shared TypeScript types
+ *
+ * The Zod schema in schema.ts is the source of truth for runtime validation.
+ * These types are derived from the schema (z.infer) for compile-time use.
+ */
+import type { z } from 'zod';
+import type { chartSchema, customLayoutSchema } from './schema';
+export type ChartProps = z.infer<typeof chartSchema>;
+export type CustomLayoutProps = z.infer<typeof customLayoutSchema>;
+/**
+ * Vega-Lite spec — typed loosely as `unknown` for now since vega-lite v5's
+ * full TS types are heavy and not needed at our boundary. We pass specs
+ * straight through to vega-embed which validates them itself.
+ */
+export type VegaLiteSpec = Record<string, unknown>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAC7B,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEhE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AACrD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEnE;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * adaptive-viz — Shared TypeScript types
+ *
+ * The Zod schema in schema.ts is the source of truth for runtime validation.
+ * These types are derived from the schema (z.infer) for compile-time use.
+ */
+export {};

package/dist/validation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * adaptive-viz — Runtime validation
+ *
+ * Defensive checks applied after Zod schema validation, before vega-embed
+ * compiles + renders the spec. Belt-and-suspenders for things the schema
+ * can't statically verify on `custom` layouts.
+ */
+import type { VegaLiteSpec } from './types';
+/**
+ * Throw if the spec's top-level data isn't inline.
+ *
+ * TODO(security): This check covers the top-level `data` field only. A
+ * thorough security review should also walk:
+ *   - spec.transform[*].lookup.from.data — transform-level data sources
+ *   - spec.layer[*].data — per-layer data sources
+ *   - spec.facet / spec.repeat / spec.concat / spec.hconcat / spec.vconcat — composite specs
+ *   - spec.params[*] — parameter sources
+ *   - mark: 'image' marks with a url field — image fetch URLs
+ *   - geoshape projection sources
+ * Until we do that pass, treat the `custom` escape hatch as elevated trust.
+ */
+export declare function assertSelfContainedData(spec: VegaLiteSpec): void;
+//# sourceMappingURL=validation.d.ts.map

package/dist/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../src/validation.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAiBhE"}

package/dist/validation.js

@@ -0,0 +1,36 @@
+/**
+ * adaptive-viz — Runtime validation
+ *
+ * Defensive checks applied after Zod schema validation, before vega-embed
+ * compiles + renders the spec. Belt-and-suspenders for things the schema
+ * can't statically verify on `custom` layouts.
+ */
+/**
+ * Throw if the spec's top-level data isn't inline.
+ *
+ * TODO(security): This check covers the top-level `data` field only. A
+ * thorough security review should also walk:
+ *   - spec.transform[*].lookup.from.data — transform-level data sources
+ *   - spec.layer[*].data — per-layer data sources
+ *   - spec.facet / spec.repeat / spec.concat / spec.hconcat / spec.vconcat — composite specs
+ *   - spec.params[*] — parameter sources
+ *   - mark: 'image' marks with a url field — image fetch URLs
+ *   - geoshape projection sources
+ * Until we do that pass, treat the `custom` escape hatch as elevated trust.
+ */
+export function assertSelfContainedData(spec) {
+    if (!spec || typeof spec !== 'object') {
+        throw new Error('Spec must be an object');
+    }
+    const data = spec.data;
+    if (!data || typeof data !== 'object') {
+        throw new Error('Spec must have a `data` field with inline `values`');
+    }
+    const d = data;
+    if ('url' in d || 'name' in d || 'source' in d) {
+        throw new Error('Custom Vega-Lite spec must have inline data. Got data.url / data.name / data.source — these external-data forms are rejected.');
+    }
+    if (!Array.isArray(d.values)) {
+        throw new Error('Spec data.values must be an inline array');
+    }
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@syntrologie/adapt-viz",
+  "version": "2.8.0-canary.140",
+  "description": "Adaptive Viz — Vega-Lite-backed data visualization tile with baked layouts (bar, line, table) and a custom escape hatch.",
+  "license": "Proprietary",
+  "private": false,
+  "author": "Syntrologie <eng@syntrologie.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SyntropyForge/amazing-demos.git",
+    "directory": "packages/adaptives/adaptive-viz"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "syntrologie": {
+    "bundlingMode": "cdn-only"
+  },
+  "type": "module",
+  "exports": {
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    },
+    "./cdn": {
+      "types": "./dist/cdn.d.ts",
+      "import": "./dist/cdn.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "biome check ."
+  },
+  "peerDependencies": {
+    "lit": "^3.0.0",
+    "zod": "^3.0.0"
+  },
+  "dependencies": {
+    "vega": "5.30.0",
+    "vega-lite": "5.21.0",
+    "vega-embed": "6.26.0"
+  },
+  "devDependencies": {
+    "@open-wc/testing": "4.0.0",
+    "@open-wc/testing-helpers": "3.0.1",
+    "jsdom": "26.1.0",
+    "lit": "3.3.2",
+    "typescript": "5.9.3",
+    "vitest": "4.0.18",
+    "zod": "3.25.76"
+  }
+}