@snackbit/opendil 0.0.0 → 0.2.0

package/dist/types/dil/styled-renderer.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from "react";
+import type { DilRendererHandle } from "./renderer-handle.js";
+import { type DilCustomization } from "./customization.js";
+import { type RendererMetrics } from "./renderer-environment.js";
+import type { DilRenderError } from "./render-error.js";
+import type { ProgressiveReveal } from "./view/reveal-options.js";
+import type { AutoScroll, ScrollContainer } from "./view/scroll-options.js";
+import type { UpdateInterval } from "./runtime/presentation-scheduler.js";
+import type { Appearance, ThemeTokens } from "./isolation/frame-theme.js";
+type Optional<T> = {
+    [Key in keyof T]?: T[Key] | undefined;
+};
+export interface StyledRendererProps extends Optional<DilCustomization> {
+    mode: "host" | "shadow";
+    rendererRef?: Ref<DilRendererHandle> | undefined;
+    text: string;
+    isStreaming: boolean;
+    showStatus: boolean;
+    progressiveReveal: ProgressiveReveal;
+    autoScroll: AutoScroll;
+    scrollContainer?: ScrollContainer | undefined;
+    updateInterval: UpdateInterval;
+    onFollowChange?: ((following: boolean) => void) | undefined;
+    onInput?: ((detail: {
+        length: number;
+    }) => void) | undefined;
+    onCommit?: ((detail: RendererMetrics) => void) | undefined;
+    onError?: ((error: DilRenderError) => void) | undefined;
+    className?: string | undefined;
+    appearance: Appearance;
+    tokens?: ThemeTokens | undefined;
+    shadowStyles?: string | undefined;
+}
+/**
+ * Host and Shadow DOM rendering run the parser and QuickJS workers in the page,
+ * so this module and its embedded workers load only when a page uses those modes.
+ */
+export declare function StyledRenderer(props: StyledRendererProps): import("react").JSX.Element;
+export {};

package/dist/types/dil/view/conditional-view.d.ts

@@ -0,0 +1,12 @@
+import type { ChildList } from "../runtime/child-list.js";
+import type { DilDocument } from "../runtime/document.js";
+import type { Scope } from "../runtime/expressions.js";
+export interface ConditionalViewProps {
+    childrenIds: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    svg: boolean;
+    inline: boolean;
+    instance: string;
+}
+export declare function ConditionalView({ childrenIds, document, scope, svg, inline, instance, }: ConditionalViewProps): import("react").JSX.Element | null;

package/dist/types/dil/view/loading-block.d.ts

@@ -0,0 +1,7 @@
+export interface LoadingBlockProps {
+    name?: string;
+    table?: false | "body" | "row";
+    svg?: boolean;
+    error?: string | undefined;
+}
+export declare function LoadingBlock({ name: _name, table, svg, error, }: LoadingBlockProps): import("react").JSX.Element;

package/dist/types/dil/view/markdown-node.d.ts

@@ -0,0 +1,12 @@
+import { type Scope } from "../runtime/expressions.js";
+import type { DilNode } from "../parser/types.js";
+import type { DilDocument } from "../runtime/document.js";
+export interface MarkdownNodeProps {
+    node: DilNode;
+    document: DilDocument;
+    scope: Scope;
+    inline: boolean;
+    svg: boolean;
+    instance: string;
+}
+export declare function MarkdownNode({ node, document, scope, inline, svg, instance, }: MarkdownNodeProps): import("react").JSX.Element | null;

package/dist/types/dil/view/node-children.d.ts

@@ -0,0 +1,13 @@
+import type { DilDocument } from "../runtime/document.js";
+import type { Scope } from "../runtime/expressions.js";
+import type { ChildList } from "../runtime/child-list.js";
+export interface NodeChildrenProps {
+    childrenIds: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    inline: boolean;
+    svg: boolean;
+    instance: string;
+    flowParent?: number | undefined;
+}
+export declare function NodeChildren({ childrenIds, document, scope, inline, svg, instance, flowParent, }: NodeChildrenProps): import("react").JSX.Element | import("react").JSX.Element[];

package/dist/types/dil/view/node-view.d.ts

@@ -0,0 +1,11 @@
+import type { DilDocument } from "../runtime/document.js";
+import type { Scope } from "../runtime/expressions.js";
+export interface NodeViewProps {
+    id: number;
+    document: DilDocument;
+    scope?: Scope;
+    inline?: boolean;
+    svg?: boolean;
+    instance?: string;
+}
+export declare const NodeView: import("react").NamedExoticComponent<NodeViewProps>;

package/dist/types/dil/view/progressive-reveal.d.ts

@@ -0,0 +1,7 @@
+import { type RefObject } from "react";
+import type { DilDocument } from "../runtime/document.js";
+import type { RendererViewport } from "../renderer-environment.js";
+import { type ProgressiveReveal } from "./reveal-options.js";
+import { RevealController } from "./reveal/controller.js";
+export declare function revealDelay(index: number, staggerMs?: number): number;
+export declare function useProgressiveReveal(root: RefObject<HTMLElement | null>, options: ProgressiveReveal, document: DilDocument | null, viewport?: RendererViewport): RevealController;

package/dist/types/dil/view/render-boundary.d.ts

@@ -0,0 +1,35 @@
+import { Component, type ReactNode } from "react";
+import type { DilDocument } from "../runtime/document.js";
+import type { DilRenderError } from "../render-error.js";
+interface RenderBoundaryProps {
+    revision: string;
+    streaming: boolean;
+    children: ReactNode;
+    /** Receives the error readers see once the message is final. */
+    onError?: ((message: string) => void) | undefined;
+}
+interface BoundaryState {
+    error: string;
+    revision: string;
+}
+export declare class RenderBoundary extends Component<RenderBoundaryProps, BoundaryState> {
+    state: BoundaryState;
+    static getDerivedStateFromProps(props: RenderBoundaryProps, state: BoundaryState): {
+        revision: string;
+        error: string;
+    } | null;
+    static getDerivedStateFromError(error: unknown): {
+        error: string;
+    };
+    componentDidMount(): void;
+    componentDidUpdate(): void;
+    private reportShownError;
+    render(): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | import("react").JSX.Element | null | undefined;
+}
+/**
+ * Reports a problem that readers see once the message is final; until then,
+ * later source can still resolve it. Reporting from an effect keeps the host's
+ * onError out of React's render phase. The document drops repeated reports.
+ */
+export declare function useReportProblem(document: DilDocument, problem: DilRenderError | undefined): void;
+export {};

package/dist/types/dil/view/render-limit.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { DilDocument } from "../runtime/document.js";
+type BudgetDocument = Pick<DilDocument, "renderBudget" | "reportRenderLimit">;
+export declare const RenderAllowance: import("react").Context<number>;
+export interface RenderLimitProps {
+    document: BudgetDocument;
+    cost?: number;
+    children: ReactNode;
+}
+export declare function RenderExceeded({ document }: {
+    document: BudgetDocument;
+}): null;
+export declare function RenderLimit({ document, cost, children, }: RenderLimitProps): import("react").JSX.Element | null;
+export {};

package/dist/types/dil/view/repeated-nodes.d.ts

@@ -0,0 +1,15 @@
+import type { DilNode } from "../parser/types.js";
+import type { ChildList } from "../runtime/child-list.js";
+import type { DilDocument } from "../runtime/document.js";
+import type { Scope } from "../runtime/expressions.js";
+interface RepeatedNodesProps {
+    node: DilNode;
+    childrenIds: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    svg: boolean;
+    instance: string;
+    attributes: Record<string, unknown>;
+}
+export declare function RepeatedNodes(props: RepeatedNodesProps): import("react").JSX.Element | import("react").JSX.Element[] | null;
+export {};

package/dist/types/dil/view/reveal/controller.d.ts

@@ -0,0 +1,32 @@
+import type { PresentationHistory } from "../../runtime/presentation-history.js";
+import type { RevealTiming } from "../reveal-options.js";
+export declare class RevealController {
+    readonly history: PresentationHistory;
+    private readonly viewport;
+    private timing;
+    private targets;
+    private queued;
+    private frame;
+    private started;
+    private reduced;
+    private nextStart;
+    constructor(history: PresentationHistory, viewport: () => {
+        top: number;
+        bottom: number;
+    });
+    configure(timing: RevealTiming | null): void;
+    start(): () => void;
+    register(key: string, element: HTMLElement, eligible: boolean, skip: boolean): () => void;
+    /**
+     * Stops tracking a target. A reveal in progress completes at once. A target
+     * that never started revealing stays "ready" in history, so registering it
+     * again, as React does when it replays refs, reveals it.
+     */
+    private release;
+    private restore;
+    private prepare;
+    private finish;
+    showAll(): void;
+    private schedule;
+    private flush;
+}

package/dist/types/dil/view/reveal/presentation.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+import type { RevealController } from "./controller.js";
+export declare const RevealContext: import("react").Context<RevealController | null>;
+export declare function usePresentationKey(identity: string): string;
+export declare function usePresentationTarget(identity: string, eligible?: boolean): (element: HTMLElement | null) => void;
+export declare function VirtualPresentation({ identity, returning, children, }: {
+    identity: string;
+    returning: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function BranchPresentation({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/dil/view/reveal-options.d.ts

@@ -0,0 +1,11 @@
+export interface ProgressiveRevealOptions {
+    staggerMs?: number;
+    durationMs?: number;
+}
+export type ProgressiveReveal = boolean | ProgressiveRevealOptions;
+export interface RevealTiming {
+    staggerMs: number;
+    durationMs: number;
+}
+export declare function revealTiming(value: ProgressiveReveal): RevealTiming | null;
+export declare function readReveal(value: unknown): ProgressiveReveal;

package/dist/types/dil/view/scroll/controller.d.ts

@@ -0,0 +1,42 @@
+import type { scrollSettings } from "../scroll-options.js";
+import type { ScrollRootTracker } from "./root-tracker.js";
+import { ScrollRoot } from "./scroll-root.js";
+type Settings = ReturnType<typeof scrollSettings>;
+/** Listens for reading gestures inside the scroller that `scope` returns (null: the page). */
+export type GestureListener = (view: Window, pause: () => void, scope: () => ScrollRoot) => () => void;
+/** One moving-target animation per message. Native smooth scrolling would restart on each chunk. */
+export declare class ScrollFollower {
+    private readonly element;
+    private readonly settings;
+    private readonly changed;
+    private readonly roots?;
+    private readonly view;
+    private readonly page;
+    private readonly reduced;
+    private readonly observer;
+    private readonly unlisten;
+    private readonly unsubscribe;
+    private releaseAnchor;
+    private observed;
+    private frame;
+    private previous;
+    private position;
+    private following;
+    private notified;
+    private ended;
+    /** How far the last tick left the view from the message's end. */
+    private gap;
+    constructor(element: HTMLElement, settings: () => Settings, changed: (following: boolean) => void, listen: GestureListener, roots?: ScrollRootTracker | undefined);
+    private get root();
+    /** Moves anchoring and size observation to the current scroller. */
+    private rebind;
+    private report;
+    start(): void;
+    end(): void;
+    resume: () => void;
+    pause: () => void;
+    refresh: () => void;
+    private tick;
+    dispose(): void;
+}
+export {};

package/dist/types/dil/view/scroll/host-viewport.d.ts

@@ -0,0 +1,24 @@
+import type { RendererViewport } from "../../renderer-environment.js";
+import type { ScrollRootTracker } from "./root-tracker.js";
+/**
+ * The visible area of a host or Shadow DOM renderer, measured from the
+ * renderer's top like the iframe runtime's frame viewport, so that layout
+ * outside the renderer never shifts virtualized positions.
+ */
+export declare class HostViewport implements RendererViewport {
+    private readonly target;
+    private readonly roots;
+    private readonly listeners;
+    private stop;
+    private last;
+    constructor(target: () => HTMLElement | null, roots: ScrollRootTracker);
+    private measure;
+    get offset(): number;
+    get height(): number;
+    get width(): number;
+    origin(): number;
+    scrollTo(offset: number): void;
+    subscribe(listener: () => void): () => void;
+    private notify;
+    private observe;
+}

package/dist/types/dil/view/scroll/root-tracker.d.ts

@@ -0,0 +1,17 @@
+import { type RefObject } from "react";
+import { type ScrollContainer } from "../scroll-options.js";
+import { ScrollRoot } from "./scroll-root.js";
+/** Keeps track of the scroller around one renderer and announces when it changes. */
+export declare class ScrollRootTracker {
+    private root;
+    private readonly listeners;
+    /** The tracked scroller, or null before the renderer is attached. */
+    get current(): ScrollRoot | null;
+    /** The tracked scroller, or the window of `element` before tracking starts. */
+    rootFor(element: Element): ScrollRoot | null;
+    subscribe(listener: () => void): () => void;
+    /** Follows `target`'s scroller until the returned cleanup runs. */
+    attach(target: HTMLElement, container: ScrollContainer): () => void;
+}
+/** The scroller around `target`; `enabled` is false where an outer frame owns scrolling. */
+export declare function useScrollRoot(target: RefObject<HTMLElement | null>, option: unknown, enabled?: boolean): ScrollRootTracker;

package/dist/types/dil/view/scroll/scroll-root.d.ts

@@ -0,0 +1,36 @@
+/** Visible part of a scrolling viewport, in client coordinates. */
+export interface ScrollBounds {
+    top: number;
+    bottom: number;
+    width: number;
+}
+/** The window or element whose scrolling moves a renderer. */
+export declare class ScrollRoot {
+    readonly view: Window;
+    /** The scrolling element, or null when the window scrolls. */
+    readonly element: HTMLElement | null;
+    constructor(view: Window, 
+    /** The scrolling element, or null when the window scrolls. */
+    element: HTMLElement | null);
+    get top(): number;
+    get maximum(): number;
+    /** The scroller's visible area, clipped to the window when it extends beyond it. */
+    bounds(): ScrollBounds;
+    scrollTo(top: number): void;
+    /** The element whose `overflow-anchor` governs this scroller. */
+    get anchor(): HTMLElement;
+    /** Whether an event happened inside this scroller. The window contains every event. */
+    contains(event: Event): boolean;
+    /** Whether a pointer event pressed this scroller's own vertical scrollbar. */
+    scrollbar(event: PointerEvent): boolean;
+}
+/** The nearest ancestor that scrolls, across Shadow DOM boundaries, or null for the window. */
+export declare function findScrollContainer(start: Element): HTMLElement | null;
+/**
+ * Calls `listener` in the capture phase for scroll events that can move
+ * `target`. Scroll events do not cross Shadow DOM boundaries, so besides the
+ * document this listens on every shadow root around `target`.
+ */
+export declare function listenForScroll(target: Element, listener: (event: Event) => void): () => void;
+/** Whether `node` is `element` or one of its flat-tree ancestors. */
+export declare function encloses(node: Node, element: Element): boolean;

package/dist/types/dil/view/scroll-options.d.ts

@@ -0,0 +1,25 @@
+import type { RefObject } from "react";
+export interface AutoScrollOptions {
+    behavior?: "instant" | "smooth";
+    /** Extra distance beyond the message tail, clamped to available document space. */
+    padding?: number;
+}
+export type AutoScroll = boolean | AutoScrollOptions;
+/**
+ * What scrolls the conversation around a renderer. `"auto"` uses the nearest
+ * ancestor that scrolls vertically, crossing Shadow DOM boundaries, and the
+ * window when none does; it re-checks when layout changes. `"window"` always
+ * uses the page. An element, or a ref to one, names the scroller directly; a
+ * ref that is still empty, or `null`, behaves like `"auto"`.
+ */
+export type ScrollContainer = "auto" | "window" | HTMLElement | RefObject<HTMLElement | null> | null;
+export declare function scrollSettings(value: AutoScroll): {
+    behavior: "instant" | "smooth";
+    padding: number;
+} | null;
+/** Checks the option at the API boundary; untyped callers can pass anything. */
+export declare function readScrollContainer(value: unknown): ScrollContainer;
+/** Whether the option fixes the scroller for good: the window or an element, not a ref. */
+export declare function namesScroller(value: ScrollContainer): value is HTMLElement | "window";
+/** The element the option names right now, `null` for the window, or undefined to detect it. */
+export declare function chosenScroller(value: ScrollContainer): HTMLElement | null | undefined;

package/dist/types/dil/view/stream-follow.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from "react";
+import { type AutoScroll } from "./scroll-options.js";
+import type { ScrollRootTracker } from "./scroll/root-tracker.js";
+import { ScrollRoot } from "./scroll/scroll-root.js";
+/**
+ * Pauses on reading gestures inside the scroller that `scope` returns. With a
+ * scroll container, gestures elsewhere on the page, such as wheeling a
+ * sidebar, leave following alone.
+ */
+export declare function listenForScrollAway(view: Window, pause: () => void, scope?: () => ScrollRoot): () => void;
+/** Only deliberate reading gestures suspend following, never layout or anchor adjustments. */
+export declare function useStreamFollow(root: RefObject<HTMLElement | null>, options: AutoScroll, streaming: boolean, onChange?: ((following: boolean) => void) | undefined, scroller?: ScrollRootTracker): {
+    pause: () => void | undefined;
+    resume: () => void | undefined;
+};

package/dist/types/dil/view/table-context.d.ts

@@ -0,0 +1,15 @@
+import { type FocusEvent, type ReactNode } from "react";
+export declare const TableScope: import("react").Context<false | "body" | "row">;
+interface RowMeasurement {
+    index: number;
+    group: string;
+    measure: (element: HTMLElement | null) => void;
+    focus: (event: FocusEvent<HTMLElement>) => void;
+    blur: (event: FocusEvent<HTMLElement>) => void;
+}
+export declare const VirtualRowScope: import("react").Context<RowMeasurement | null>;
+export declare function DilTableRow({ children, presentationRef, }: {
+    children: ReactNode;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}): import("react").JSX.Element;
+export {};

package/dist/types/dil/view/virtual-flow.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+import type { ChildList } from "../runtime/child-list.js";
+import type { DilDocument } from "../runtime/document.js";
+import type { Scope } from "../runtime/expressions.js";
+export interface VirtualFlowProps {
+    identity?: string;
+    count: number;
+    childIds?: ChildList;
+    document: DilDocument;
+    scope: Scope;
+    instance: string;
+    renderItem?: (index: number) => ReactNode;
+    itemKey?: (index: number) => string | number;
+}
+export declare function VirtualFlow({ identity, count, childIds, document, scope, instance, renderItem, itemKey, }: VirtualFlowProps): import("react").JSX.Element;

package/dist/types/dil/widgets/action-feedback.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from "react";
+import type { StoreApi } from "zustand/vanilla";
+import type { DocumentStatus } from "../runtime/document.js";
+export type ActionFeedback = "idle" | "copied" | "failed";
+/** Shows the clipboard outcome of the action this control started, briefly. */
+export declare function useActionFeedback(status: StoreApi<DocumentStatus>): readonly [ActionFeedback, (result: unknown) => void];
+/** Always mounted around the control so showing feedback never remounts or blurs it. */
+export declare function ActionFeedbackTooltip({ feedback, children, }: {
+    feedback: ActionFeedback;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/dil/widgets/async-image.d.ts

@@ -0,0 +1,6 @@
+export interface AsyncImageProps {
+    query: string;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+/** Offline illustration. A host-mode component override can supply an image service. */
+export declare function AsyncImage({ query, presentationRef }: AsyncImageProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/chart-hover.d.ts

@@ -0,0 +1,17 @@
+import type { ChartItem } from "./chart-selection.js";
+/** The datum under the pointer: one row of one series, or one pie slice. */
+export interface ChartTarget {
+    index: number;
+    item: ChartItem;
+    row: Record<string, unknown>;
+}
+export interface ChartHit {
+    target: ChartTarget;
+    clientX: number;
+    clientY: number;
+}
+/**
+ * Coalesces pointer updates to one per animation frame. The latest update wins,
+ * so leaving one mark and entering the next does not close and reopen the tooltip.
+ */
+export declare function useFrameHover(onHover: (hit: ChartHit | null) => void): (hit: ChartHit | null) => void;

package/dist/types/dil/widgets/charts/chart-legend.d.ts

@@ -0,0 +1,10 @@
+import type { ChartItem } from "./chart-selection.js";
+export interface ChartLegendProps {
+    items: readonly ChartItem[];
+    hidden: ReadonlySet<string>;
+    hovered: string | null;
+    select: (id: string, toggle: boolean) => void;
+    highlight: (id: string | null) => void;
+    interactive: boolean;
+}
+export declare function ChartLegend({ items, hidden, hovered, select, highlight, interactive, }: ChartLegendProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/chart-pie.d.ts

@@ -0,0 +1,16 @@
+import type { ChartHit, ChartTarget } from "./chart-hover.js";
+export interface ChartPieProps {
+    slices: readonly ChartTarget[];
+    valueKey: string;
+    nameKey: string;
+    /** Slice emphasized from the legend. Slice hover and focus emphasis is CSS-only. */
+    emphasized: string | null;
+    hover: (hit: ChartHit | null) => void;
+    highlight: (id: string | null) => void;
+}
+/**
+ * Recharts remounts every sector whenever a Pie re-renders, which loses the
+ * pointer and keyboard focus. Memoize the Pie so hover and focus state do not
+ * re-render it.
+ */
+export declare const ChartPie: import("react").NamedExoticComponent<ChartPieProps>;

package/dist/types/dil/widgets/charts/chart-selection.d.ts

@@ -0,0 +1,8 @@
+export interface ChartItem {
+    id: string;
+    label: string;
+    color: string;
+}
+/** Grafana: isolate on plain click, toggle individually with Ctrl/Cmd. */
+export declare function selectChartItem(ids: readonly string[], hidden: ReadonlySet<string>, id: string, toggle: boolean): Set<string>;
+export declare function reconcileChartSelection(ids: readonly string[], hidden: ReadonlySet<string>): Set<string>;

package/dist/types/dil/widgets/charts/chart-series.d.ts

@@ -0,0 +1,19 @@
+import type { ChartHit } from "./chart-hover.js";
+import type { ChartItem } from "./chart-selection.js";
+export interface ChartSeriesProps {
+    item: ChartItem;
+    index: number;
+    type: string;
+    hidden: boolean;
+    muted: boolean;
+    rows: Record<string, unknown>[];
+    highlight: (id: string | null) => void;
+    /** Bar hover: report the bar under the pointer, or null after leaving it. */
+    hover: (hit: ChartHit | null) => void;
+    /**
+     * Show Recharts' own active dots. Only keyboard navigation wants them; on pointer
+     * hover Recharts keeps a stale active index next to the snapped point.
+     */
+    markers: boolean;
+}
+export declare function ChartSeries({ item, index, type, hidden, muted, rows, highlight, hover, markers, }: ChartSeriesProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/chart-snapping.d.ts

@@ -0,0 +1,13 @@
+import type { ChartItem } from "./chart-selection.js";
+import type { ChartTarget } from "./chart-hover.js";
+export interface ChartPoint extends ChartTarget {
+    x: number;
+    y: number;
+    value: number;
+}
+type AxisScale = (value: unknown, options?: {
+    position: "middle";
+}) => number | undefined;
+export declare function projectChartPoints(rows: Record<string, unknown>[], items: readonly ChartItem[], xKey: string, xScale: AxisScale, yScale: AxisScale): ChartPoint[];
+export declare function nearestChartPoint(points: readonly ChartPoint[], x: number, y: number, scatter: boolean): ChartPoint | undefined;
+export {};

package/dist/types/dil/widgets/charts/dil-chart.d.ts

@@ -0,0 +1,5 @@
+export interface DilChartProps {
+    content: unknown;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function DilChart({ content, presentationRef }: DilChartProps): import("react").JSX.Element;

package/dist/types/dil/widgets/charts/snap-cursor.d.ts

@@ -0,0 +1,12 @@
+import { type ChartHit } from "./chart-hover.js";
+import type { ChartItem } from "./chart-selection.js";
+export interface SnapCursorProps {
+    rows: Record<string, unknown>[];
+    items: readonly ChartItem[];
+    xKey: string;
+    scatter: boolean;
+    hit: ChartHit | null;
+    onHover: (hit: ChartHit | null) => void;
+}
+/** Line and scatter hover: snap from anywhere in the plot to the nearest datum. */
+export declare function SnapCursor({ rows, items, xKey, scatter, hit, onHover, }: SnapCursorProps): import("react").JSX.Element | null;

package/dist/types/dil/widgets/charts/snap-tooltip.d.ts

@@ -0,0 +1,12 @@
+import type { ChartItem } from "./chart-selection.js";
+import type { ChartHit } from "./chart-hover.js";
+export interface SnapTooltipProps {
+    hit: ChartHit | null;
+    items: readonly ChartItem[];
+    /** category: x label with every visible series; scatter: x and y; slice: one pie slice. */
+    kind: "category" | "scatter" | "slice";
+    xKey: string;
+    valueKey: string;
+    onHover: (hit: ChartHit | null) => void;
+}
+export declare function SnapTooltip({ hit, items, kind, xKey, valueKey, onHover, }: SnapTooltipProps): import("react").JSX.Element | null;

package/dist/types/dil/widgets/code/code-editor.d.ts

@@ -0,0 +1,9 @@
+import { type ChangeEvent } from "react";
+export interface CodeEditorProps {
+    source: string;
+    language: string;
+    ready: boolean;
+    wrapped: boolean;
+    onChange: (event: ChangeEvent<HTMLTextAreaElement>) => void;
+}
+export declare function CodeEditor({ source, language, ready, wrapped, onChange, }: CodeEditorProps): import("react").JSX.Element;

package/dist/types/dil/widgets/code/highlighted-code.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from "react";
+declare const highlighter: {
+    highlight: (language: string, value: string, options?: Readonly<import("lowlight").Options> | null | undefined) => import("hast").Root;
+    highlightAuto: (value: string, options?: Readonly<import("lowlight").AutoOptions> | null | undefined) => import("hast").Root;
+    listLanguages: () => Array<string>;
+    register: {
+        (grammars: Readonly<Record<string, import("highlight.js").LanguageFn>>): undefined;
+        (name: string, grammar: import("highlight.js").LanguageFn): undefined;
+    };
+    registerAlias: {
+        (aliases: Readonly<Record<string, ReadonlyArray<string> | string>>): undefined;
+        (language: string, alias: ReadonlyArray<string> | string): undefined;
+    };
+    registered: (aliasOrName: string) => boolean;
+};
+type Tree = ReturnType<typeof highlighter.highlight>;
+export declare function renderTokens(node: Tree | Tree["children"][number], count: {
+    value: number;
+}): ReactNode;
+/** Highlight AST nodes become React text/spans; authored code never becomes raw HTML. */
+export declare const HighlightedCode: import("react").NamedExoticComponent<{
+    source: string;
+    language: string;
+}>;
+export {};

package/dist/types/dil/widgets/code-block.d.ts

@@ -0,0 +1,11 @@
+import type { DilDocument } from "../runtime/document.js";
+export interface CodeBlockProps {
+    source: string;
+    language: string;
+    editable: boolean;
+    ready: boolean;
+    document: DilDocument;
+    identity: string;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function CodeBlock({ source, language, editable, ready, document, identity, presentationRef, }: CodeBlockProps): import("react").JSX.Element;

package/dist/types/dil/widgets/control-revision.d.ts

@@ -0,0 +1 @@
+export declare const ControlRevisionContext: import("react").Context<number>;