@snackbit/opendil 0.0.0 → 0.2.0

package/dist/types/agent-spec.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Primary DIL authoring instructions (genui.agent.md). Put this in the system
+ * prompt of the model that writes documents for this renderer version.
+ */
+export declare const agentSpec: string;
+/**
+ * Complete component and property reference (genui.agent.full.md) for
+ * targeted lookups, such as a retrieval tool or a larger context budget.
+ */
+export declare const agentSpecFull: string;
+/** Executable example catalog (genui.examples.md) with recipes per feature. */
+export declare const agentSpecExamples: string;

package/dist/types/components/ui/controls/button.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+    size?: "default" | "xs" | "sm" | "lg" | "icon" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Button, buttonVariants };

package/dist/types/components/ui/controls/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Checkbox as CheckboxPrimitive } from "radix-ui";
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): React.JSX.Element;
+export { Checkbox };

package/dist/types/components/ui/controls/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+export { Input };

package/dist/types/components/ui/controls/radio-group.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+import { RadioGroup as RadioGroupPrimitive } from "radix-ui";
+declare function RadioGroup({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Root>): React.JSX.Element;
+declare function RadioGroupItem({ className, ...props }: React.ComponentProps<typeof RadioGroupPrimitive.Item>): React.JSX.Element;
+export { RadioGroup, RadioGroupItem };

package/dist/types/components/ui/controls/select.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentProps } from "react";
+import { Select as SelectPrimitive } from "radix-ui";
+declare const Select: import("react").FC<SelectPrimitive.SelectProps>;
+declare const SelectValue: import("react").ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & import("react").RefAttributes<HTMLSpanElement>>;
+declare const SelectGroup: import("react").ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const SelectViewport: import("react").ForwardRefExoticComponent<SelectPrimitive.SelectViewportProps & import("react").RefAttributes<HTMLDivElement>>;
+declare const SelectItemIndicator: import("react").ForwardRefExoticComponent<SelectPrimitive.SelectItemIndicatorProps & import("react").RefAttributes<HTMLSpanElement>>;
+declare const SelectItemText: import("react").ForwardRefExoticComponent<SelectPrimitive.SelectItemTextProps & import("react").RefAttributes<HTMLSpanElement>>;
+declare function SelectPortal(props: ComponentProps<typeof SelectPrimitive.Portal>): import("react").JSX.Element;
+declare function SelectTrigger({ className, ...props }: ComponentProps<typeof SelectPrimitive.Trigger>): import("react").JSX.Element;
+declare function SelectContent({ className, ...props }: ComponentProps<typeof SelectPrimitive.Content>): import("react").JSX.Element;
+declare function SelectItem({ className, ...props }: ComponentProps<typeof SelectPrimitive.Item>): import("react").JSX.Element;
+declare function SelectLabel({ className, ...props }: ComponentProps<typeof SelectPrimitive.Label>): import("react").JSX.Element;
+export { Select, SelectValue, SelectGroup, SelectPortal, SelectViewport, SelectItemIndicator, SelectItemText, SelectTrigger, SelectContent, SelectItem, SelectLabel, };

package/dist/types/components/ui/controls/slider.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Slider as SliderPrimitive } from "radix-ui";
+declare function Slider({ className, defaultValue, value, min, max, ...props }: React.ComponentProps<typeof SliderPrimitive.Root>): React.JSX.Element;
+export { Slider };

package/dist/types/components/ui/controls/tabs.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentProps } from "react";
+import { Tabs as TabsPrimitive } from "radix-ui";
+declare function Tabs(props: ComponentProps<typeof TabsPrimitive.Root>): import("react").JSX.Element;
+declare function TabsList({ className, ...props }: ComponentProps<typeof TabsPrimitive.List>): import("react").JSX.Element;
+declare function TabsTrigger({ className, ...props }: ComponentProps<typeof TabsPrimitive.Trigger>): import("react").JSX.Element;
+declare function TabsContent(props: ComponentProps<typeof TabsPrimitive.Content>): import("react").JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/types/components/ui/controls/textarea.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Textarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+export { Textarea };

package/dist/types/components/ui/controls/toggle-group.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { ToggleGroup as ToggleGroupPrimitive } from "radix-ui";
+import { toggleVariants } from "./toggle.js";
+declare function ToggleGroup({ className, variant, size, spacing, segmented, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+    segmented?: boolean;
+}): React.JSX.Element;
+declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): React.JSX.Element;
+export { ToggleGroup, ToggleGroupItem };

package/dist/types/components/ui/controls/toggle.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { Toggle as TogglePrimitive } from "radix-ui";
+declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "default" | "sm" | "lg" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Toggle({ className, variant, size, ...props }: React.ComponentProps<typeof TogglePrimitive.Root> & VariantProps<typeof toggleVariants>): React.JSX.Element;
+export { Toggle, toggleVariants };

package/dist/types/components/ui/display/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "link" | "default" | "secondary" | "destructive" | "outline" | "ghost" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Badge, badgeVariants };

package/dist/types/components/ui/display/card.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+declare function Card({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

package/dist/types/components/ui/display/chart.d.ts

@@ -0,0 +1,39 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+import type { TooltipValueType } from "recharts";
+type TooltipNameType = number | string;
+export type ChartConfig = Record<string, {
+    label?: React.ReactNode;
+    icon?: React.ComponentType;
+} & ({
+    color?: string;
+    theme?: never;
+} | {
+    color?: never;
+    theme: Record<"light" | "dark", string>;
+})>;
+declare function ChartContainer({ id, className, children, config, overlay, initialDimension, style, ...props }: React.ComponentProps<"div"> & {
+    config: ChartConfig;
+    overlay?: React.ReactNode;
+    children: React.ComponentProps<typeof RechartsPrimitive.ResponsiveContainer>["children"];
+    initialDimension?: {
+        width: number;
+        height: number;
+    };
+}): React.JSX.Element;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, emphasizedKey, }: React.ComponentProps<typeof RechartsPrimitive.Tooltip> & React.ComponentProps<"div"> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+    /** Marks the row whose dataKey matches with `data-emphasized="true"` for styling. */
+    emphasizedKey?: string | undefined;
+} & Omit<RechartsPrimitive.DefaultTooltipContentProps<TooltipValueType, TooltipNameType>, "accessibilityLayer">): React.JSX.Element | null;
+declare const ChartLegend: React.MemoExoticComponent<(outsideProps: RechartsPrimitive.LegendProps) => React.ReactPortal | null>;
+declare function ChartLegendContent({ className, hideIcon, payload, verticalAlign, nameKey, }: React.ComponentProps<"div"> & {
+    hideIcon?: boolean;
+    nameKey?: string;
+} & RechartsPrimitive.DefaultLegendContentProps): React.JSX.Element | null;
+export { ChartContainer, ChartTooltip, ChartTooltipContent, ChartLegend, ChartLegendContent, };

package/dist/types/components/ui/display/separator.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Separator as SeparatorPrimitive } from "radix-ui";
+declare function Separator({ className, orientation, decorative, ...props }: React.ComponentProps<typeof SeparatorPrimitive.Root>): React.JSX.Element;
+export { Separator };

package/dist/types/components/ui/display/skeleton.d.ts

@@ -0,0 +1,2 @@
+declare function Skeleton({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+export { Skeleton };

package/dist/types/components/ui/display/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): React.JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): React.JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): React.JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): React.JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): React.JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): React.JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): React.JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): React.JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/types/components/ui/media/carousel.d.ts

@@ -0,0 +1,19 @@
+import * as React from "react";
+import useEmblaCarousel, { type UseEmblaCarouselType } from "embla-carousel-react";
+import { Button } from "../controls/button.js";
+type CarouselApi = UseEmblaCarouselType[1];
+type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
+type CarouselOptions = UseCarouselParameters[0];
+type CarouselPlugin = UseCarouselParameters[1];
+type CarouselProps = {
+    opts?: CarouselOptions;
+    plugins?: CarouselPlugin;
+    orientation?: "horizontal" | "vertical";
+    setApi?: (api: CarouselApi) => void;
+};
+declare function Carousel({ orientation, opts, setApi, plugins, className, children, ...props }: React.ComponentProps<"div"> & CarouselProps): React.JSX.Element;
+declare function CarouselContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CarouselItem({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CarouselPrevious({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+declare function CarouselNext({ className, variant, size, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+export { type CarouselApi, Carousel, CarouselContent, CarouselItem, CarouselPrevious, CarouselNext, };

package/dist/types/components/ui/overlays/collapsible.d.ts

@@ -0,0 +1,6 @@
+import { Collapsible as CollapsiblePrimitive } from "radix-ui";
+import type { ComponentProps } from "react";
+declare function Collapsible(props: ComponentProps<typeof CollapsiblePrimitive.Root>): import("react").JSX.Element;
+declare function CollapsibleTrigger(props: ComponentProps<typeof CollapsiblePrimitive.Trigger>): import("react").JSX.Element;
+declare function CollapsibleContent(props: ComponentProps<typeof CollapsiblePrimitive.Content>): import("react").JSX.Element;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/types/components/ui/overlays/popover.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+import { Popover as PopoverPrimitive } from "radix-ui";
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): React.JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): React.JSX.Element;
+type PopoverContentProps = React.ComponentProps<typeof PopoverPrimitive.Content>;
+declare function PopoverContent(props: PopoverContentProps): React.JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): React.JSX.Element;
+declare function PopoverHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function PopoverTitle({ className, ...props }: React.ComponentProps<"h2">): React.JSX.Element;
+declare function PopoverDescription({ className, ...props }: React.ComponentProps<"p">): React.JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor, PopoverHeader, PopoverTitle, PopoverDescription, };

package/dist/types/components/ui/overlays/tooltip.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+export interface TooltipProps {
+    label: ReactNode;
+    children: ReactNode;
+    /** Controls visibility; omit for hover and focus behavior. */
+    open?: boolean | undefined;
+}
+export declare function Tooltip({ label, children, open }: TooltipProps): import("react").JSX.Element;

package/dist/types/components/ui/overlays/ui-scope.d.ts

@@ -0,0 +1,27 @@
+import { type ComponentProps } from "react";
+export declare function usePortalScope(): {
+    container: HTMLElement | null;
+    boundary?: Element;
+};
+/**
+ * Space below the viewport that overlays may extend into, in pixels. The
+ * iframe runtime provides it: the host grows a content-sized frame to show an
+ * overlay that extends past its bottom, so an overlay need not flip above its
+ * trigger, where the frame's top would clip it.
+ */
+export interface OverlayRoom {
+    below(): number;
+    subscribe(listener: () => void): () => void;
+}
+export declare const OverlayRoomContext: import("react").Context<OverlayRoom | null>;
+type Side = "top" | "right" | "bottom" | "left";
+export type CollisionPadding = number | Partial<Record<Side, number>>;
+/** Extends an overlay's collision padding by the room below the viewport. */
+export declare function useCollisionPadding(padding?: CollisionPadding): CollisionPadding;
+export interface UiScopeProps extends ComponentProps<"section"> {
+    appearance?: "light" | "dark";
+    tokens?: Readonly<Record<`--${string}`, string>>;
+    boundary?: Element;
+}
+export declare function UiScope({ children, className, style, appearance, tokens, boundary, ...props }: UiScopeProps): import("react").JSX.Element;
+export {};

package/dist/types/dil/custom-component.d.ts

@@ -0,0 +1,14 @@
+import { type ComponentType, type ReactNode } from "react";
+import type { DilComponentProps } from "./customization.js";
+export interface CustomComponentProps {
+    component: ComponentType<DilComponentProps>;
+    name: string;
+    attributes: Readonly<Record<string, unknown>>;
+    config: Readonly<Record<string, unknown>>;
+    children: ReactNode;
+    className: string;
+    slots: Readonly<Record<string, string>>;
+    ready: boolean;
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export declare function CustomComponent({ component: Component, attributes, ...props }: CustomComponentProps): import("react").JSX.Element;

package/dist/types/dil/customization.d.ts

@@ -0,0 +1,21 @@
+import { type ComponentType, type ReactNode } from "react";
+export interface DilComponentProps {
+    name: string;
+    attributes: Readonly<Record<string, unknown>>;
+    config: Readonly<Record<string, unknown>>;
+    children: ReactNode;
+    className: string;
+    slots: Readonly<Record<string, string>>;
+    ready: boolean;
+    invoke: (attribute: string, value?: unknown) => void;
+    /** Forward to the visual root to participate in progressive reveal. */
+    presentationRef?: ((element: HTMLElement | null) => void) | undefined;
+}
+export interface DilCustomization {
+    components?: Readonly<Record<string, ComponentType<DilComponentProps>>>;
+    componentConfig?: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+    classNames?: Readonly<Record<string, string>>;
+    slots?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+}
+export declare const CustomizationContext: import("react").Context<DilCustomization>;
+export declare function useCustomization(): DilCustomization;

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

@@ -0,0 +1,90 @@
+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";
+/**
+ * Starts loading the code that `mode="host"` and `mode="shadow"` share. Once
+ * it resolves, those modes render synchronously: their `ref` is set in the
+ * first commit and `renderToString` includes them.
+ */
+export declare function preloadHostRenderer(): Promise<void>;
+interface DilCommonProps {
+    ref?: Ref<DilRendererHandle> | undefined;
+    /** Append-only source prefix. Remount with a new key to replace it. */
+    text: string;
+    isStreaming?: boolean;
+    /**
+     * Show the "Receiving document", "Incomplete" or "Complete" label. Errors
+     * and the note that a response ended early stay visible when false.
+     */
+    showStatus?: boolean;
+    /** Stagger newly shown blocks; disabled by default and under reduced motion. */
+    progressiveReveal?: ProgressiveReveal;
+    autoScroll?: AutoScroll;
+    /**
+     * What scrolls around the renderer, for `autoScroll` and for virtualized
+     * long content. Defaults to `"auto"`: the nearest ancestor that scrolls
+     * vertically, crossing Shadow DOM boundaries, or the window when none does.
+     * Pass `"window"`, an element, or a ref to an element to choose one.
+     */
+    scrollContainer?: ScrollContainer | undefined;
+    /** Maximum streaming presentation frequency; user interaction remains immediate. */
+    updateInterval?: UpdateInterval;
+    /** Color scheme of the stock components. Defaults to "light". */
+    appearance?: "light" | "dark" | undefined;
+    /**
+     * CSS custom properties applied to the renderer root, such as `--primary` or
+     * `--background`. The iframe mode accepts only values that cannot load
+     * resources and ignores the rest with a console warning.
+     */
+    tokens?: Readonly<Record<`--${string}`, string>> | undefined;
+    /**
+     * URL of the directory that serves frame.html. Defaults to "/opendil/". Only
+     * the iframe mode loads it; host and Shadow DOM modes ignore it, so a mode
+     * chosen at runtime can always pass the app's runtime location.
+     */
+    runtimeBaseUrl?: string | undefined;
+    onFollowChange?: (following: boolean) => void;
+    onInput?: (detail: {
+        length: number;
+    }) => void;
+    onCommit?: (detail: RendererMetrics) => void;
+    /**
+     * Receives each distinct problem once, with a developer-facing message and,
+     * for parse problems, the offset in `text`. Readers see short generic
+     * wording instead. Syntax problems and documents that ended with unfinished
+     * structure are also logged with `console.warn`. One message reports at most
+     * 20 problems, then one `limit` error; the `incomplete` report always
+     * arrives. An exception thrown here is rethrown asynchronously and does not
+     * interrupt rendering.
+     */
+    onError?: ((error: DilRenderError) => void) | undefined;
+}
+export interface DilIsolatedRendererProps extends DilCommonProps {
+    mode?: "isolated" | undefined;
+    components?: undefined;
+    componentConfig?: undefined;
+    classNames?: undefined;
+    slots?: undefined;
+    className?: undefined;
+    shadowStyles?: undefined;
+}
+interface DilStyledRendererProps extends DilCommonProps, DilCustomization {
+    className?: string | undefined;
+}
+export interface DilHostRendererProps extends DilStyledRendererProps {
+    mode: "host";
+    shadowStyles?: undefined;
+}
+export interface DilShadowRendererProps extends DilStyledRendererProps {
+    mode: "shadow";
+    /** Trusted application CSS installed inside this renderer's ShadowRoot. */
+    shadowStyles?: string | undefined;
+}
+export type DilRendererProps = DilIsolatedRendererProps | DilHostRendererProps | DilShadowRendererProps;
+export declare function DilRenderer(props: DilRendererProps): import("react").JSX.Element;
+export {};

package/dist/types/dil/isolation/frame-startup.d.ts

@@ -0,0 +1,18 @@
+/** Package version, compiled into both the renderer and the copied frame runtime. */
+export declare const RUNTIME_VERSION: string;
+/**
+ * The frame script runs before the frame document's load event, so a frame that
+ * loaded without announcing itself is not the OpenDIL runtime.
+ */
+export declare const READY_AFTER_LOAD_MS = 3000;
+/**
+ * frame.html pings the host every second while frame.js downloads, so this
+ * limit applies only to a frame that has sent nothing at all, such as an app
+ * page whose load event fired before the renderer hydrated.
+ */
+export declare const SILENT_FRAME_MS = 20000;
+export declare function startupFailureMessage(url: string): string;
+export declare function reportStartupFailure(url: string): void;
+/** Warns once per frame URL when the copied runtime and the renderer differ. */
+export declare function checkFrameVersion(url: string, version: unknown): void;
+export declare function reportRejectedTokens(names: readonly string[]): void;

package/dist/types/dil/isolation/frame-theme.d.ts

@@ -0,0 +1,14 @@
+export type Appearance = "light" | "dark";
+export type ThemeTokens = Readonly<Record<`--${string}`, string>>;
+export interface FrameTheme {
+    appearance: Appearance;
+    tokens: ThemeTokens;
+}
+export declare function isSafeTokenValue(value: string): boolean;
+/** Keeps valid custom properties and names everything it drops. */
+export declare function readThemeTokens(value: unknown): {
+    tokens: ThemeTokens;
+    rejected: string[];
+};
+/** Parses a port message into a theme, or returns undefined to ignore it. */
+export declare function readFrameTheme(data: object): FrameTheme | undefined;

package/dist/types/dil/isolation/frame-viewport.d.ts

@@ -0,0 +1,30 @@
+import type { ScrollRootTracker } from "../view/scroll/root-tracker.js";
+export interface FrameViewportMessage {
+    type: "viewport";
+    revision: number;
+    offset: number;
+    height: number;
+    width: number;
+}
+/**
+ * Tells the frame which part of it is visible in the host's scroller, the
+ * page or a scroll container, so virtualized content inside can mount.
+ */
+export declare class FrameViewportReporter {
+    private readonly frame;
+    private readonly scroller;
+    private readonly post;
+    private revision;
+    private lastOffset;
+    private observed;
+    private readonly stop;
+    constructor(frame: HTMLIFrameElement, scroller: ScrollRootTracker, post: (message: FrameViewportMessage) => void);
+    private visible;
+    report: () => void;
+    /**
+     * Scrolls the host until frame offset `offset` is at the visible top. A
+     * request from before the reader's latest scroll is discarded.
+     */
+    scroll(offset: number, revision: number): void;
+    dispose(): void;
+}

package/dist/types/dil/isolation/frame.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/dil/isolation/isolated-renderer.d.ts

@@ -0,0 +1,28 @@
+import { type Ref } from "react";
+import type { DilRendererHandle } from "../renderer-handle.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, type ThemeTokens } from "./frame-theme.js";
+export interface IsolatedRendererProps {
+    ref?: Ref<DilRendererHandle> | undefined;
+    text: string;
+    isStreaming?: boolean;
+    showStatus?: boolean;
+    progressiveReveal?: ProgressiveReveal;
+    autoScroll?: AutoScroll;
+    scrollContainer?: ScrollContainer | undefined;
+    updateInterval?: UpdateInterval;
+    onFollowChange?: (following: boolean) => void;
+    runtimeBaseUrl?: string | undefined;
+    appearance?: Appearance | undefined;
+    tokens?: ThemeTokens | undefined;
+    onInput?: (detail: {
+        length: number;
+    }) => void;
+    onCommit?: (detail: RendererMetrics) => void;
+    onError?: ((error: DilRenderError) => void) | undefined;
+}
+export declare function IsolatedRenderer({ ref, text, isStreaming, showStatus, progressiveReveal, autoScroll, scrollContainer, updateInterval, onFollowChange, runtimeBaseUrl, appearance, tokens, onInput, onCommit, onError, }: IsolatedRendererProps): import("react").JSX.Element;

package/dist/types/dil/isolation/overlay-room.d.ts

@@ -0,0 +1,29 @@
+import type { OverlayRoom } from "../../components/ui/overlays/ui-scope.js";
+/**
+ * Decides how far overlays may extend below the frame's bottom. The host grows
+ * the content-sized frame to show an overlay that extends past it, but cannot
+ * grow it upward, so an overlay that flips above a trigger is clipped at the
+ * frame's top.
+ *
+ * Overlays may use the part of the host's scroller that is visible below the
+ * frame, as they would in host mode. When one is clipped at the top anyway, for
+ * example in a short frame at the bottom of the scroller, overlays may extend
+ * any distance below until all of them close, and the reader can scroll to them.
+ */
+export declare class FrameOverlayRoom implements OverlayRoom {
+    private readonly visibleBottom;
+    private readonly frameHeight;
+    private readonly listeners;
+    private room;
+    private unbounded;
+    /** `visibleBottom` is the bottom of the host's visible area, in frame coordinates. */
+    constructor(visibleBottom: () => number, frameHeight: () => number);
+    below: () => number;
+    subscribe: (listener: () => void) => () => void;
+    /** Recomputes the room after the visible area or the frame's height changed. */
+    update: () => void;
+    /** Receives the boxes of the placed, open overlays, in frame coordinates. */
+    track(overlays: readonly {
+        top: number;
+    }[]): void;
+}

package/dist/types/dil/isolation/shadow-renderer.d.ts

@@ -0,0 +1,7 @@
+import { type ReactNode } from "react";
+export interface ShadowRendererProps {
+    children: ReactNode;
+    shadowStyles?: string | undefined;
+}
+/** DOM/style encapsulation only. Expression isolation remains in the QuickJS worker. */
+export declare function ShadowRenderer({ children, shadowStyles, }: ShadowRendererProps): import("react").JSX.Element;

package/dist/types/dil/isolation/shadow-styles.d.ts

@@ -0,0 +1,2 @@
+/** Styles belong to the rendering document; adopted sheets cannot cross documents. */
+export declare function installShadowStyles(root: ShadowRoot, custom: string): void;

package/dist/types/dil/isolation/viewport-scroll.d.ts

@@ -0,0 +1,7 @@
+/** Coalesce measurement corrections after layout; discard them if the reader moved meanwhile. */
+export declare function viewportScroller(viewport: {
+    readonly revision: number;
+}, send: (offset: number, revision: number) => void): {
+    scroll(offset: number): void;
+    dispose(): void;
+};

package/dist/types/dil/isolation/vm-worker.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,17 @@
+import { type Ref } from "react";
+import type { DilRendererHandle } from "./renderer-handle.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";
+export interface MessageRendererProps {
+    rendererRef?: Ref<DilRendererHandle> | undefined;
+    text: string;
+    isStreaming?: boolean;
+    showStatus?: boolean;
+    progressiveReveal?: ProgressiveReveal;
+    autoScroll?: AutoScroll;
+    scrollContainer?: ScrollContainer | undefined;
+    updateInterval?: UpdateInterval;
+    onFollowChange?: ((following: boolean) => void) | undefined;
+}
+export declare function MessageRenderer({ rendererRef, text, isStreaming, showStatus, progressiveReveal, autoScroll, scrollContainer, updateInterval, onFollowChange, }: MessageRendererProps): import("react").JSX.Element;