@snackbit/opendil 0.0.0 → 0.1.0

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/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/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,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+import { ToggleGroup as ToggleGroupPrimitive } from "radix-ui";
+import { toggleVariants } from "./toggle";
+declare function ToggleGroup({ className, variant, size, spacing, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+}): 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,45 @@
+import * as React from "react";
+import * as RechartsPrimitive from "recharts";
+import type { TooltipValueType } from "recharts";
+declare const THEMES: {
+    readonly light: "";
+    readonly dark: ".dark";
+};
+type TooltipNameType = number | string;
+export type ChartConfig = Record<string, {
+    label?: React.ReactNode;
+    icon?: React.ComponentType;
+} & ({
+    color?: string;
+    theme?: never;
+} | {
+    color?: never;
+    theme: Record<keyof typeof THEMES, string>;
+})>;
+declare function ChartContainer({ id, className, children, config, overlay, initialDimension, ...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 ChartStyle: ({ id, config }: {
+    id: string;
+    config: ChartConfig;
+}) => React.JSX.Element | null;
+declare const ChartTooltip: typeof RechartsPrimitive.Tooltip;
+declare function ChartTooltipContent({ active, payload, className, indicator, hideLabel, hideIndicator, label, labelFormatter, labelClassName, formatter, color, nameKey, labelKey, }: React.ComponentProps<typeof RechartsPrimitive.Tooltip> & React.ComponentProps<"div"> & {
+    hideLabel?: boolean;
+    hideIndicator?: boolean;
+    indicator?: "line" | "dot" | "dashed";
+    nameKey?: string;
+    labelKey?: string;
+} & 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, ChartStyle, };

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";
+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/popover.d.ts

@@ -0,0 +1,10 @@
+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;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): 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,11 @@
+import { type ComponentProps } from "react";
+export declare function usePortalScope(): {
+    container: HTMLElement | null;
+    boundary?: Element;
+};
+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;

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

@@ -0,0 +1,14 @@
+import { type ComponentType, type ReactNode } from "react";
+import type { DilComponentProps } from "./customization";
+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,55 @@
+import { type Ref } from "react";
+import type { DilRendererHandle } from "./renderer-handle";
+import { type DilCustomization } from "./customization";
+import { type RendererMetrics } from "./renderer-environment";
+import type { ProgressiveReveal } from "./view/reveal-options";
+import type { AutoScroll } from "./view/scroll-options";
+import { type UpdateInterval } from "./runtime/presentation-scheduler";
+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/completion label without affecting errors. */
+    showStatus?: boolean;
+    /** Stagger newly shown blocks; disabled by default and under reduced motion. */
+    progressiveReveal?: ProgressiveReveal;
+    autoScroll?: AutoScroll;
+    /** Maximum streaming presentation frequency; user interaction remains immediate. */
+    updateInterval?: UpdateInterval;
+    onFollowChange?: (following: boolean) => void;
+    onInput?: (detail: {
+        length: number;
+    }) => void;
+    onCommit?: (detail: RendererMetrics) => void;
+}
+export interface DilIsolatedRendererProps extends DilCommonProps {
+    mode?: "isolated";
+    runtimeBaseUrl?: string;
+    components?: never;
+    componentConfig?: never;
+    classNames?: never;
+    slots?: never;
+    tokens?: never;
+    className?: never;
+    appearance?: never;
+    shadowStyles?: never;
+}
+interface DilStyledRendererProps extends DilCommonProps, DilCustomization {
+    runtimeBaseUrl?: never;
+    className?: string;
+    tokens?: Readonly<Record<`--${string}`, string>>;
+    appearance?: "light" | "dark";
+}
+export interface DilHostRendererProps extends DilStyledRendererProps {
+    mode: "host";
+    shadowStyles?: never;
+}
+export interface DilShadowRendererProps extends DilStyledRendererProps {
+    mode: "shadow";
+    /** Trusted application CSS installed inside this renderer's ShadowRoot. */
+    shadowStyles?: string;
+}
+export type DilRendererProps = DilIsolatedRendererProps | DilHostRendererProps | DilShadowRendererProps;
+export declare function DilRenderer(props: DilRendererProps): import("react").JSX.Element;
+export {};

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

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

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

@@ -0,0 +1,22 @@
+import { type Ref } from "react";
+import type { DilRendererHandle } from "../renderer-handle";
+import type { RendererMetrics } from "../renderer-environment";
+import type { ProgressiveReveal } from "../view/reveal-options";
+import type { AutoScroll } from "../view/scroll-options";
+import type { UpdateInterval } from "../runtime/presentation-scheduler";
+export interface IsolatedRendererProps {
+    ref?: Ref<DilRendererHandle> | undefined;
+    text: string;
+    isStreaming?: boolean;
+    showStatus?: boolean;
+    progressiveReveal?: ProgressiveReveal;
+    autoScroll?: AutoScroll;
+    updateInterval?: UpdateInterval;
+    onFollowChange?: (following: boolean) => void;
+    runtimeBaseUrl?: string;
+    onInput?: (detail: {
+        length: number;
+    }) => void;
+    onCommit?: (detail: RendererMetrics) => void;
+}
+export declare function IsolatedRenderer({ ref, text, isStreaming, showStatus, progressiveReveal, autoScroll, updateInterval, onFollowChange, runtimeBaseUrl, onInput, onCommit, }: IsolatedRendererProps): import("react").JSX.Element;

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,6 @@
+import type { FrameViewport } from "../renderer-environment";
+/** Coalesce measurement corrections after layout; discard them if the reader moved meanwhile. */
+export declare function viewportScroller(viewport: FrameViewport, 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,16 @@
+import { type Ref } from "react";
+import type { DilRendererHandle } from "./renderer-handle";
+import type { ProgressiveReveal } from "./view/reveal-options";
+import type { AutoScroll } from "./view/scroll-options";
+import type { UpdateInterval } from "./runtime/presentation-scheduler";
+export interface MessageRendererProps {
+    rendererRef?: Ref<DilRendererHandle> | undefined;
+    text: string;
+    isStreaming?: boolean;
+    showStatus?: boolean;
+    progressiveReveal?: ProgressiveReveal;
+    autoScroll?: AutoScroll;
+    updateInterval?: UpdateInterval;
+    onFollowChange?: ((following: boolean) => void) | undefined;
+}
+export declare function MessageRenderer({ rendererRef, text, isStreaming, showStatus, progressiveReveal, autoScroll, updateInterval, onFollowChange, }: MessageRendererProps): import("react").JSX.Element;

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

@@ -0,0 +1,33 @@
+import type { DilNode, TreeBatch } from "./types";
+/** Append-only parser. Closed tokens are never scanned again. */
+export declare class DilParser {
+    private source;
+    private cursor;
+    private textStart;
+    private tokenStart;
+    private mode;
+    private lexical;
+    private fence;
+    private tokenNode;
+    private nodes;
+    private children;
+    private stack;
+    private dirty;
+    private links;
+    private declarations;
+    private revision;
+    constructor();
+    private get parent();
+    private closeFrame;
+    private create;
+    private touch;
+    private markdown;
+    private flushText;
+    private finishMarkdown;
+    private finish;
+    private fail;
+    private directive;
+    private tag;
+    append(suffix: string, complete?: boolean): TreeBatch;
+    snapshot(): DilNode[];
+}

package/dist/types/dil/parser/lexical.d.ts

@@ -0,0 +1,16 @@
+import type { Attribute } from "./types";
+export declare class LexicalState {
+    depth: number;
+    quote: string;
+    escaped: boolean;
+    comment: string;
+    regex: boolean;
+    characterClass: boolean;
+    previous: string;
+    templates: number[];
+    consume(char: string, next: string): number;
+    get neutral(): boolean;
+}
+export declare function fenceMarker(source: string, cursor: number, current: string): string | undefined;
+export declare function braceEnd(source: string, start: number): number;
+export declare function parseAttributes(source: string): Record<string, Attribute>;

package/dist/types/dil/parser/stream-worker.d.ts

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

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

@@ -0,0 +1,32 @@
+export type NodeKind = "root" | "element" | "markdown" | "if" | "branch" | "each" | "pending";
+export type NodeStatus = "streaming" | "ready" | "error";
+export interface Attribute {
+    expression?: string;
+    literal?: string | boolean;
+}
+export interface DilNode {
+    id: number;
+    kind: NodeKind;
+    name: string;
+    attributes: Record<string, Attribute>;
+    text: string;
+    expressions: string[];
+    status: NodeStatus;
+    offset: number;
+    error: string;
+}
+export interface TreeBatch {
+    revision: number;
+    nodes: DilNode[];
+    links: {
+        parent: number;
+        child: number;
+    }[];
+    declarations: string[];
+    complete: boolean;
+    scanned: number;
+}
+export interface StreamInput {
+    suffix: string;
+    complete: boolean;
+}

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

@@ -0,0 +1,22 @@
+export interface FrameViewport {
+    offset: number;
+    revision: number;
+    height: number;
+    width: number;
+    listeners: Set<() => void>;
+}
+export interface RendererMetrics {
+    scanned: number;
+    complete: boolean;
+}
+export interface RendererEnvironment {
+    viewport?: FrameViewport;
+    scrollTo?: (offset: number) => void;
+    copy?: (text: string) => Promise<boolean>;
+    onInput?: (detail: {
+        length: number;
+    }) => void;
+    onCommit?: (detail: RendererMetrics) => void;
+}
+export declare const RendererEnvironmentContext: import("react").Context<RendererEnvironment>;
+export declare function useRendererEnvironment(): RendererEnvironment;

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

@@ -0,0 +1,4 @@
+export interface DilRendererHandle {
+    /** Explicitly resume following this streaming message and move to its tail. */
+    resumeAutoScroll(): void;
+}

package/dist/types/dil/runtime/action-receipt.d.ts

@@ -0,0 +1,5 @@
+/** A local edit waits for an evaluated value at or after this interaction. */
+export declare class ActionReceipt {
+    readonly revision: number;
+    constructor(revision: number);
+}

package/dist/types/dil/runtime/child-list.d.ts

@@ -0,0 +1,8 @@
+export declare class ChildList {
+    readonly length: number;
+    private readonly pages;
+    constructor(pages?: readonly (readonly number[])[], length?: number);
+    get(index: number): number;
+    append(values: readonly number[]): ChildList;
+    toArray(): number[];
+}

package/dist/types/dil/runtime/document.d.ts

@@ -0,0 +1,42 @@
+import { type StoreApi } from "zustand/vanilla";
+import type { DilNode, TreeBatch } from "../parser/types";
+import { ChildList } from "./child-list";
+import { ExpressionEngine, type Scope } from "./expressions";
+import { RenderBudget } from "./render-budget";
+import { PresentationHistory } from "./presentation-history";
+import { PresentationScheduler } from "./presentation-scheduler";
+export interface NodeState {
+    node: DilNode;
+    children: ChildList;
+}
+export interface DocumentStatus {
+    complete: boolean;
+    revision: number;
+    scanned: number;
+    error: string;
+    /** Latest clipboard outcome, keyed by the intent of the action that requested it. */
+    clipboard: {
+        intent: number;
+        ok: boolean;
+    } | null;
+}
+export declare class DilDocument {
+    readonly updates: PresentationScheduler;
+    readonly presentation: PresentationHistory;
+    readonly renderBudget: RenderBudget;
+    renderLimited: boolean;
+    reportRenderLimit(): void;
+    readonly nodes: Map<number, NodeState>;
+    private readonly stores;
+    private readonly parents;
+    private readonly flows;
+    readonly status: StoreApi<DocumentStatus>;
+    readonly engine: ExpressionEngine;
+    readonly drafts: Map<string, string>;
+    constructor();
+    apply(batch: TreeBatch): void;
+    private presentedChildren;
+    flowChildren(id: number): StoreApi<ChildList>;
+    node(id: number): StoreApi<NodeState>;
+    attributes(node: DilNode, scope: Scope): Record<string, unknown>;
+}

package/dist/types/dil/runtime/evaluation-cache.d.ts

@@ -0,0 +1,24 @@
+export type Scope = Readonly<Record<string, unknown>>;
+export interface EvaluationEntry {
+    source: string;
+    scope: Scope;
+    owners: number;
+    oneShot: boolean;
+    ready: boolean;
+    dirty: boolean;
+    value: unknown;
+    dependencies?: readonly string[];
+    revision: number;
+    invalidated: number;
+    handles: readonly number[];
+}
+export declare class EvaluationCache {
+    readonly entries: Map<string, EvaluationEntry>;
+    key(source: string, scope: Scope): string;
+    ensure(source: string, scope: Scope): {
+        key: string;
+        entry: EvaluationEntry;
+    };
+    touch(key: string): void;
+    prune(busy: (key: string) => boolean, evict: (key: string, entry: EvaluationEntry) => void): void;
+}

package/dist/types/dil/runtime/execution-queue.d.ts

@@ -0,0 +1,55 @@
+export interface ExecutionReply {
+    id: number;
+    value?: unknown;
+    error?: string;
+    changed?: boolean;
+    revision?: number;
+    dependencies?: string[];
+    bindings?: string[];
+    handles?: number[];
+    copy?: string;
+    /** The VM can no longer be trusted; the document must stop. */
+    fatal?: string;
+}
+/** Worker replies cross the VM boundary; keep only well-formed fields. */
+export declare function readReply(data: unknown): ExecutionReply | undefined;
+export interface ExecutionJob {
+    type: string;
+    payload: Record<string, unknown>;
+    key?: string;
+    setter?: string;
+}
+/** Bounded transport window; waiting evaluations never consume execution deadlines. */
+export declare class ExecutionQueue {
+    private readonly post;
+    private readonly receive;
+    private readonly failure;
+    private next;
+    private pending;
+    private evaluations;
+    private activeKeys;
+    private mutations;
+    private setters;
+    private draining;
+    private stopped;
+    constructor(post: (message: Record<string, unknown>) => void, receive: (job: ExecutionJob, reply: ExecutionReply) => void, failure: (message: string) => void);
+    get stats(): {
+        inFlight: number;
+        evaluations: number;
+        queued: number;
+        mutations: number;
+    };
+    has(key: string): boolean;
+    evaluate(key: string, payload: Record<string, unknown>): boolean;
+    cancel(key: string): void;
+    mutate(job: ExecutionJob): {
+        payload: Record<string, unknown>;
+        type: string;
+        key?: string;
+        setter?: string;
+    } | undefined;
+    reply(data: unknown): void;
+    private dispatch;
+    private drain;
+    stop(): void;
+}