@jini-ai/ui 0.4.9 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # @jini-ai/ui
 
+## 0.5.0 — 2026-10-13
+
+- Add framework-neutral chart contracts, browser/table and React hosts, provider-defined kinds and legacy chart wire aliases. Extract Recharts implementations and peers into the private browser artifact; chart component export wrappers are removed (no external consumers found).
+
 ## 0.4.6 — 2026-10-08
 
 - parse5 optional peer widened to `^7.3.0 || ^8.0.1`: 0.4.5 required ^8 while @jini-ai/cms 0.5.3 requires ^7.3, so hosts with both hit ERESOLVE. The srcdoc builder and html-editor source splice typecheck against parse5 7.

package/dist/features/charts/browser.d.ts

@@ -0,0 +1,39 @@
+/** Framework-free mounting, failure recovery and table fallback. No React imports. */
+import { type ChartInstance, type ChartProvider, type ChartSpec, type ChartTheme } from './contract.js';
+import { type ChartProviderRegistry } from './registry.js';
+export { applyChartTheme, renderChartTable } from './table.js';
+export interface MountChartOptions {
+    readonly theme?: ChartTheme;
+    readonly siteProvider?: string | undefined;
+    readonly onProviderError?: (input: {
+        provider: string;
+        error: unknown;
+    }) => void;
+}
+export interface MountedChart extends ChartInstance {
+    readonly ready: Promise<void>;
+    update(input: {
+        spec: ChartSpec;
+        theme?: ChartTheme;
+    }, options?: Record<string, never>): Promise<void>;
+}
+/** Dynamic import is native; the host supplies an admitted immutable module URL and loads its CSS
+ * at the rendering boundary. No manifest URL is itself a trust grant.
+ */
+export declare function loadChartProvider({ url }: {
+    url: string;
+}, { importModule }?: {
+    importModule?: (input: {
+        url: string;
+    }, options?: Record<string, never>) => Promise<unknown>;
+}): Promise<ChartProvider>;
+/** Mount a vanilla provider into its own child node, keeping data visible until ready. Updates and
+ * teardown invalidate pending loads so stale completions never attach to an unmounted host.
+ * @example mountChart({ element, spec, registry }, { siteProvider: 'plugin.recharts' })
+ */
+export declare function mountChart({ element, spec, registry }: {
+    element: HTMLElement;
+    spec: ChartSpec;
+    registry: ChartProviderRegistry;
+}, options?: MountChartOptions): MountedChart;
+//# sourceMappingURL=browser.d.ts.map

package/dist/features/charts/browser.js

@@ -0,0 +1,142 @@
+/** Framework-free mounting, failure recovery and table fallback. No React imports. */
+import { DEFAULT_CHART_THEME } from './contract.js';
+import { selectChartProviders } from './registry.js';
+import { applyChartTheme, renderChartTable } from './table.js';
+export { applyChartTheme, renderChartTable } from './table.js';
+/** Dynamic import is native; the host supplies an admitted immutable module URL and loads its CSS
+ * at the rendering boundary. No manifest URL is itself a trust grant.
+ */
+export async function loadChartProvider({ url }, { importModule = ({ url }) => import(/* @vite-ignore */ url) } = {}) {
+    const module = await importModule({ url });
+    if (typeof module?.mount !== 'function')
+        throw new TypeError('Chart provider must export mount.');
+    return module;
+}
+/** Mount a vanilla provider into its own child node, keeping data visible until ready. Updates and
+ * teardown invalidate pending loads so stale completions never attach to an unmounted host.
+ * @example mountChart({ element, spec, registry }, { siteProvider: 'plugin.recharts' })
+ */
+export function mountChart({ element, spec, registry }, options = {}) {
+    const fallback = element.ownerDocument.createElement('div');
+    fallback.dataset.chartFallback = '';
+    const renderer = element.ownerDocument.createElement('div');
+    renderer.dataset.chartRenderer = '';
+    element.append(fallback, renderer);
+    let input = { spec, theme: options.theme ?? DEFAULT_CHART_THEME };
+    let active;
+    let generation = 0;
+    let revision = 0;
+    let destroyed = false;
+    const failed = new Set();
+    /** Provider errors never prevent other providers or the data table from remaining usable. */
+    function report(entry, error) {
+        try {
+            options.onProviderError?.({ provider: entry.id, error });
+        }
+        catch {
+            // A host diagnostic failure must not strand a renderer or hide the data fallback.
+        }
+    }
+    function dispose() {
+        const previous = active;
+        active = undefined;
+        if (previous) {
+            try {
+                previous.instance.destroy({});
+            }
+            catch (error) {
+                report(previous.entry, error);
+            }
+        }
+        renderer.replaceChildren();
+        fallback.hidden = false;
+    }
+    function showData() {
+        applyChartTheme({ element, theme: input.theme });
+        renderChartTable({ element: fallback, spec: input.spec });
+        fallback.hidden = false;
+    }
+    function candidates() {
+        return selectChartProviders({ registry, spec: input.spec }, { siteProvider: options.siteProvider }).filter(({ id }) => !failed.has(id));
+    }
+    /** Async renderer errors arrive after mount; defer teardown outside the provider's commit. */
+    function renderError(entry, error, token) {
+        queueMicrotask(() => {
+            if (destroyed || token !== generation || active?.entry.id !== entry.id)
+                return;
+            failed.add(entry.id);
+            report(entry, error);
+            generation++;
+            dispose();
+            void attempt(generation);
+        });
+    }
+    async function attempt(token) {
+        for (const entry of candidates()) {
+            let renderRevision = revision;
+            try {
+                const provider = await entry.load({});
+                if (destroyed || token !== generation)
+                    return;
+                const frame = element.ownerDocument.createElement('div');
+                renderer.replaceChildren(frame);
+                renderRevision = revision;
+                const instance = provider.mount({ element: frame, ...input }, { onError: (error) => renderError(entry, error, token) });
+                active = { entry, instance };
+                await instance.ready;
+                if (destroyed || token !== generation || renderRevision !== revision)
+                    return;
+                fallback.hidden = true;
+                return;
+            }
+            catch (error) {
+                if (destroyed || token !== generation || renderRevision !== revision)
+                    return;
+                failed.add(entry.id);
+                report(entry, error);
+                dispose();
+            }
+        }
+    }
+    showData();
+    const ready = attempt(generation);
+    return {
+        ready,
+        async update({ spec: nextSpec, theme = input.theme }, _options = {}) {
+            if (destroyed)
+                return;
+            const updateRevision = ++revision;
+            input = { spec: nextSpec, theme };
+            showData();
+            const preferred = candidates()[0];
+            if (active && preferred?.id === active.entry.id) {
+                const current = active;
+                try {
+                    await current.instance.update(input);
+                    if (!destroyed && active === current && updateRevision === revision)
+                        fallback.hidden = true;
+                    return;
+                }
+                catch (error) {
+                    if (destroyed || active !== current || updateRevision !== revision)
+                        return;
+                    failed.add(current.entry.id);
+                    report(current.entry, error);
+                }
+            }
+            generation++;
+            dispose();
+            await attempt(generation);
+        },
+        destroy(_input = {}, _options = {}) {
+            if (destroyed)
+                return;
+            destroyed = true;
+            generation++;
+            dispose();
+            fallback.remove();
+            renderer.remove();
+        },
+    };
+}
+//# sourceMappingURL=browser.js.map

package/dist/features/charts/contract.d.ts

@@ -0,0 +1,223 @@
+/** Framework-neutral chart data and vanilla provider ABI. Providers declare their own kinds. */
+import { z } from 'zod';
+export type ChartKind = 'bar' | 'line' | 'pie' | (string & {});
+export type ChartValue = string | number | boolean | null | ChartValue[] | {
+    [key: string]: ChartValue;
+};
+/** Serializable, provider-neutral specification; kind admission belongs to each provider. */
+export declare const chartSpecSchema: z.ZodObject<{
+    kind: z.ZodString;
+    data: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodType<ChartValue, z.ZodTypeDef, ChartValue>>, "many">;
+    categoryKey: z.ZodOptional<z.ZodString>;
+    series: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        key: string;
+        label?: string | undefined;
+        color?: string | undefined;
+    }, {
+        key: string;
+        label?: string | undefined;
+        color?: string | undefined;
+    }>, "many">;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    axes: z.ZodOptional<z.ZodObject<{
+        x: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodObject<{
+                locale: z.ZodOptional<z.ZodString>;
+                notation: z.ZodOptional<z.ZodEnum<["standard", "compact"]>>;
+            }, "strict", z.ZodTypeAny, {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            }, {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        }, {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        }>>;
+        y: z.ZodOptional<z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            format: z.ZodOptional<z.ZodObject<{
+                locale: z.ZodOptional<z.ZodString>;
+                notation: z.ZodOptional<z.ZodEnum<["standard", "compact"]>>;
+            }, "strict", z.ZodTypeAny, {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            }, {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        }, {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        x?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+        y?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+    }, {
+        x?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+        y?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+    }>>;
+    format: z.ZodOptional<z.ZodObject<{
+        locale: z.ZodOptional<z.ZodString>;
+        notation: z.ZodOptional<z.ZodEnum<["standard", "compact"]>>;
+    }, "strict", z.ZodTypeAny, {
+        locale?: string | undefined;
+        notation?: "compact" | "standard" | undefined;
+    }, {
+        locale?: string | undefined;
+        notation?: "compact" | "standard" | undefined;
+    }>>;
+    provider: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: string;
+    data: Record<string, ChartValue>[];
+    series: {
+        key: string;
+        label?: string | undefined;
+        color?: string | undefined;
+    }[];
+    title?: string | undefined;
+    provider?: string | undefined;
+    description?: string | undefined;
+    format?: {
+        locale?: string | undefined;
+        notation?: "compact" | "standard" | undefined;
+    } | undefined;
+    categoryKey?: string | undefined;
+    axes?: {
+        x?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+        y?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    kind: string;
+    data: Record<string, ChartValue>[];
+    series: {
+        key: string;
+        label?: string | undefined;
+        color?: string | undefined;
+    }[];
+    title?: string | undefined;
+    provider?: string | undefined;
+    description?: string | undefined;
+    format?: {
+        locale?: string | undefined;
+        notation?: "compact" | "standard" | undefined;
+    } | undefined;
+    categoryKey?: string | undefined;
+    axes?: {
+        x?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+        y?: {
+            label?: string | undefined;
+            format?: {
+                locale?: string | undefined;
+                notation?: "compact" | "standard" | undefined;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}>;
+export type ChartSpec = Omit<z.infer<typeof chartSpecSchema>, 'kind'> & {
+    readonly kind: ChartKind;
+};
+/** CSS token names are common across providers; no library props cross this boundary. */
+export interface ChartTheme {
+    readonly mode: 'light' | 'dark' | 'auto';
+    readonly tokens?: Readonly<Record<string, string>>;
+}
+export declare const DEFAULT_CHART_THEME: ChartTheme;
+export interface ChartRenderInput {
+    readonly spec: ChartSpec;
+    readonly theme: ChartTheme;
+}
+export interface ChartMountOptions {
+    /** Reports errors occurring after mount returns (for example a React commit failure). */
+    readonly onError?: (error: unknown) => void;
+}
+export interface ChartInstance {
+    /** Hosts retain the fallback until an asynchronous first render completes. */
+    readonly ready?: Promise<void>;
+    update(input: ChartRenderInput, options?: Record<string, never>): void | Promise<void>;
+    destroy(input: Record<string, never>, options?: Record<string, never>): void;
+}
+export interface ChartProvider {
+    mount(input: ChartRenderInput & {
+        readonly element: HTMLElement;
+    }, options?: ChartMountOptions): ChartInstance;
+}
+export interface ChartProviderEntry {
+    readonly id: string;
+    readonly kinds: readonly ChartKind[];
+    readonly enabled: boolean;
+    /** Optional stricter admission, e.g. rejecting multi-series specs until implemented. */
+    readonly supports?: (input: {
+        readonly spec: ChartSpec;
+    }, options?: Record<string, never>) => boolean;
+    load(input: Record<string, never>, options?: Record<string, never>): Promise<ChartProvider>;
+}
+//# sourceMappingURL=contract.d.ts.map

package/dist/features/charts/contract.js

@@ -0,0 +1,21 @@
+/** Framework-neutral chart data and vanilla provider ABI. Providers declare their own kinds. */
+import { z } from 'zod';
+const chartValueSchema = z.lazy(() => z.union([
+    z.string(), z.number().finite(), z.boolean(), z.null(), z.array(chartValueSchema), z.record(chartValueSchema),
+]));
+const formatSchema = z.object({ locale: z.string().optional(), notation: z.enum(['standard', 'compact']).optional() }).strict();
+const axisSchema = z.object({ label: z.string().optional(), format: formatSchema.optional() }).strict();
+/** Serializable, provider-neutral specification; kind admission belongs to each provider. */
+export const chartSpecSchema = z.object({
+    kind: z.string().min(1),
+    data: z.array(z.record(chartValueSchema)),
+    categoryKey: z.string().optional(),
+    series: z.array(z.object({ key: z.string(), label: z.string().optional(), color: z.string().optional() }).strict()),
+    title: z.string().optional(),
+    description: z.string().optional(),
+    axes: z.object({ x: axisSchema.optional(), y: axisSchema.optional() }).strict().optional(),
+    format: formatSchema.optional(),
+    provider: z.string().min(1).optional(),
+}).strict();
+export const DEFAULT_CHART_THEME = { mode: 'auto' };
+//# sourceMappingURL=contract.js.map

package/dist/features/charts/index.d.ts

@@ -0,0 +1,5 @@
+/** Headless chart contracts, schemas, theme tokens and registry selection (no React or DOM effects). */
+export * from './contract.js';
+export * from './registry.js';
+export * from './wire.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/features/charts/index.js

@@ -0,0 +1,5 @@
+/** Headless chart contracts, schemas, theme tokens and registry selection (no React or DOM effects). */
+export * from './contract.js';
+export * from './registry.js';
+export * from './wire.js';
+//# sourceMappingURL=index.js.map

package/dist/features/charts/react.d.ts

@@ -0,0 +1,27 @@
+/** The only React adapter for the vanilla chart lifecycle; providers own any internal roots. */
+import { type ReactElement } from 'react';
+import { InteractiveUiRegistry } from '../interactive-ui/registry.js';
+import { type ChartSpec, type ChartTheme } from './contract.js';
+import { type MountChartOptions } from './browser.js';
+import { type ChartProviderRegistry } from './registry.js';
+export interface ChartHostProps {
+    readonly spec: ChartSpec;
+    readonly registry: ChartProviderRegistry;
+    readonly theme?: ChartTheme;
+    readonly siteProvider?: string | undefined;
+    readonly onProviderError?: MountChartOptions['onProviderError'];
+}
+/** React owns only the container; mountChart owns its descendants and lifecycle. */
+export declare function ChartHost({ spec, registry, theme, siteProvider, onProviderError }: ChartHostProps): ReactElement;
+/** Create a snapshot for validation AND rendering. Resolve each legacy alias through its specific
+ * capability, then copy its wire id onto that same entry (same schema and Component).
+ * @example createChartInteractiveRegistry({ registry: base, providers }, { siteProvider: 'plugin.recharts' })
+ */
+export declare function createChartInteractiveRegistry({ registry, providers }: {
+    registry: InteractiveUiRegistry;
+    providers: ChartProviderRegistry;
+}, options?: {
+    siteProvider?: string | undefined;
+    theme?: ChartTheme;
+}): InteractiveUiRegistry;
+//# sourceMappingURL=react.d.ts.map

package/dist/features/charts/react.js

@@ -0,0 +1,73 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** The only React adapter for the vanilla chart lifecycle; providers own any internal roots. */
+import { useEffect, useRef } from 'react';
+import { z } from 'zod';
+import { InteractiveUiRegistry } from '../interactive-ui/registry.js';
+import { chartSpecSchema, DEFAULT_CHART_THEME } from './contract.js';
+import { mountChart } from './browser.js';
+import { chartCapability, chartProvidersByKind } from './registry.js';
+import { chartWireManifests, legacyChartSpec } from './wire.js';
+/** React owns only the container; mountChart owns its descendants and lifecycle. */
+export function ChartHost({ spec, registry, theme = DEFAULT_CHART_THEME, siteProvider, onProviderError }) {
+    const element = useRef(null);
+    const instance = useRef(undefined);
+    const previous = useRef({ spec, theme });
+    useEffect(() => {
+        if (!element.current)
+            return;
+        const mounted = mountChart({ element: element.current, spec, registry }, {
+            theme, siteProvider, ...(onProviderError ? { onProviderError } : {}),
+        });
+        instance.current = mounted;
+        previous.current = { spec, theme };
+        return () => { mounted.destroy({}); instance.current = undefined; };
+        // Registry snapshots and site defaults define a lifecycle. Data/theme changes use update below.
+    }, [registry, siteProvider, onProviderError]);
+    useEffect(() => {
+        if (previous.current.spec === spec && previous.current.theme === theme)
+            return;
+        previous.current = { spec, theme };
+        void instance.current?.update({ spec, theme });
+    }, [spec, theme]);
+    return _jsx("div", { ref: element, className: "jini-chart-host" });
+}
+/** Known wire kinds use the established shapes. Other providers register spec-based entries without
+ * adding fields or kinds to the core grammar. This closure is built once per host snapshot.
+ */
+function chartComponent(kind, providers, options) {
+    return function RegisteredChart(props) {
+        const legacyKind = kind === 'bar' ? 'bar' : kind === 'line' ? 'line' : kind === 'pie' ? 'pie' : undefined;
+        const spec = legacyKind ? legacyChartSpec({ kind: legacyKind, props }) : chartSpecSchema.parse(props.spec);
+        return _jsx(ChartHost, { spec: spec, registry: providers, ...options });
+    };
+}
+/** Create a snapshot for validation AND rendering. Resolve each legacy alias through its specific
+ * capability, then copy its wire id onto that same entry (same schema and Component).
+ * @example createChartInteractiveRegistry({ registry: base, providers }, { siteProvider: 'plugin.recharts' })
+ */
+export function createChartInteractiveRegistry({ registry, providers }, options = {}) {
+    const kinds = [...new Set(['bar', 'line', 'pie', ...providers.list().flatMap(({ kinds }) => kinds)])];
+    const entries = [];
+    for (const kind of kinds) {
+        const capability = chartCapability({ kind });
+        const wire = chartWireManifests.find((manifest) => manifest.capabilities.includes(capability));
+        const Component = chartComponent(kind, providers, options);
+        const propsSchema = wire?.propsSchema ?? z.object({ spec: chartSpecSchema.extend({ kind: z.literal(kind) }) }).passthrough();
+        const selected = chartProvidersByKind({ registry: providers, kind }, options);
+        for (const provider of selected)
+            entries.push({
+                id: `${provider.id}.${capability}`, provider: provider.id, capabilities: ['chart', capability, 'graph'], propsSchema, Component,
+            });
+        if (wire)
+            entries.push({ ...wire, id: `core.table.${capability}`, Component });
+    }
+    const existing = registry.list().filter(({ capabilities }) => !capabilities.includes('chart'));
+    let snapshot = new InteractiveUiRegistry({ entries: [...entries, ...existing] });
+    for (const wire of chartWireManifests) {
+        const capability = wire.capabilities.find((capability) => capability.endsWith('-chart'));
+        const selected = snapshot.resolveByCapability({ capability })[0];
+        snapshot = snapshot.register({ entry: { ...selected, id: wire.id } });
+    }
+    return snapshot;
+}
+//# sourceMappingURL=react.js.map

package/dist/features/charts/registry.d.ts

@@ -0,0 +1,35 @@
+import { InteractiveUiRegistry } from '../interactive-ui/registry.js';
+import type { InteractiveComponentManifest } from '../interactive-ui/types.js';
+import type { ChartKind, ChartProviderEntry, ChartSpec } from './contract.js';
+export type RegisteredChartProvider = ChartProviderEntry & InteractiveComponentManifest;
+export type ChartProviderRegistry = InteractiveUiRegistry<RegisteredChartProvider>;
+/** Each kind has a distinct capability, so a pie-only provider can never satisfy a bar request. */
+export declare function chartCapability({ kind }: {
+    kind: ChartKind;
+}, _options?: Record<string, never>): string;
+/** Register providers in host-supplied preference order, reusing immutable replacement by id.
+ * @example createChartProviderRegistry({ providers: admittedProviders })
+ */
+export declare function createChartProviderRegistry({ providers }: {
+    providers: readonly ChartProviderEntry[];
+}, _options?: Record<string, never>): ChartProviderRegistry;
+/** Apply the two explicit pins to the registry's capability order. Both catalog snapshots and
+ * runtime rendering use this owner; catalog construction never probes supports with invented data.
+ */
+export declare function chartProvidersByKind({ registry, kind }: {
+    registry: ChartProviderRegistry;
+    kind: ChartKind;
+}, { provider, siteProvider }?: {
+    provider?: string | undefined;
+    siteProvider?: string | undefined;
+}): readonly RegisteredChartProvider[];
+/** Skip unsupported specs after ordering. The browser supplies the final core table when this
+ * chain exhausts; provider capability declarations can include any non-empty kind.
+ */
+export declare function selectChartProviders({ registry, spec }: {
+    registry: ChartProviderRegistry;
+    spec: ChartSpec;
+}, { siteProvider }?: {
+    siteProvider?: string | undefined;
+}): readonly RegisteredChartProvider[];
+//# sourceMappingURL=registry.d.ts.map

package/dist/features/charts/registry.js

@@ -0,0 +1,36 @@
+/** Capability ordering belongs to InteractiveUiRegistry, including framework-neutral entries. */
+import { z } from 'zod';
+import { InteractiveUiRegistry } from '../interactive-ui/registry.js';
+/** Each kind has a distinct capability, so a pie-only provider can never satisfy a bar request. */
+export function chartCapability({ kind }, _options = {}) {
+    return `${kind}-chart`;
+}
+/** Register providers in host-supplied preference order, reusing immutable replacement by id.
+ * @example createChartProviderRegistry({ providers: admittedProviders })
+ */
+export function createChartProviderRegistry({ providers }, _options = {}) {
+    let registry = new InteractiveUiRegistry({ entries: [] });
+    for (const provider of providers) {
+        registry = registry.register({ entry: {
+                ...provider, provider: provider.id, kinds: Object.freeze([...provider.kinds]),
+                capabilities: provider.kinds.map((kind) => chartCapability({ kind })), propsSchema: z.object({}),
+            } });
+    }
+    return registry;
+}
+/** Apply the two explicit pins to the registry's capability order. Both catalog snapshots and
+ * runtime rendering use this owner; catalog construction never probes supports with invented data.
+ */
+export function chartProvidersByKind({ registry, kind }, { provider, siteProvider } = {}) {
+    const candidates = registry.resolveByCapability({ capability: chartCapability({ kind }) }).filter((entry) => entry.enabled);
+    const pinned = [provider, siteProvider].flatMap((id) => candidates.filter((entry) => entry.id === id));
+    return [...new Set([...pinned, ...candidates])];
+}
+/** Skip unsupported specs after ordering. The browser supplies the final core table when this
+ * chain exhausts; provider capability declarations can include any non-empty kind.
+ */
+export function selectChartProviders({ registry, spec }, { siteProvider } = {}) {
+    return chartProvidersByKind({ registry, kind: spec.kind }, { provider: spec.provider, siteProvider })
+        .filter((entry) => entry.supports?.({ spec }) ?? true);
+}
+//# sourceMappingURL=registry.js.map

package/dist/features/charts/table.d.ts

@@ -0,0 +1,14 @@
+import type { ChartSpec, ChartTheme } from './contract.js';
+/** Apply only chart tokens; a provider cannot use theme input to style unrelated host chrome. */
+export declare function applyChartTheme({ element, theme }: {
+    element: HTMLElement;
+    theme: ChartTheme;
+}, _options?: Record<string, never>): void;
+/** Keep every row/key, including data from unsupported kinds. textContent supplies escaping;
+ * never feed agent data to innerHTML. Shared table CSS is already loaded at the admin boundary.
+ */
+export declare function renderChartTable({ element, spec }: {
+    element: HTMLElement;
+    spec: ChartSpec;
+}, _options?: Record<string, never>): void;
+//# sourceMappingURL=table.d.ts.map