@snackbit/opendil 0.1.0 → 0.2.0

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

@@ -1,9 +1,11 @@
 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";
+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;
@@ -11,12 +13,16 @@ export interface IsolatedRendererProps {
     showStatus?: boolean;
     progressiveReveal?: ProgressiveReveal;
     autoScroll?: AutoScroll;
+    scrollContainer?: ScrollContainer | undefined;
     updateInterval?: UpdateInterval;
     onFollowChange?: (following: boolean) => void;
-    runtimeBaseUrl?: string;
+    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, updateInterval, onFollowChange, runtimeBaseUrl, onInput, onCommit, }: IsolatedRendererProps): import("react").JSX.Element;
+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/viewport-scroll.d.ts

@@ -1,6 +1,7 @@
-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): {
+export declare function viewportScroller(viewport: {
+    readonly revision: number;
+}, send: (offset: number, revision: number) => void): {
     scroll(offset: number): void;
     dispose(): void;
 };

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

@@ -1,8 +1,8 @@
 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";
+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;
@@ -10,7 +10,8 @@ export interface MessageRendererProps {
     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, updateInterval, onFollowChange, }: MessageRendererProps): import("react").JSX.Element;
+export declare function MessageRenderer({ rendererRef, text, isStreaming, showStatus, progressiveReveal, autoScroll, scrollContainer, updateInterval, onFollowChange, }: MessageRendererProps): import("react").JSX.Element;

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

@@ -1,5 +1,13 @@
-import type { DilNode, TreeBatch } from "./types";
-/** Append-only parser. Closed tokens are never scanned again. */
+import type { DilNode, TreeBatch } from "./types.js";
+export interface DilParserOptions {
+    /** Host-registered component names; lowercase ones become DIL tags. */
+    components?: readonly string[];
+}
+/**
+ * Append-only parser. Closed tokens are never scanned again. Text inside an
+ * unclosed code span is held back until its closing backticks arrive; if its
+ * block ends first, only the text since the opener is scanned again as prose.
+ */
 export declare class DilParser {
     private source;
     private cursor;
@@ -8,6 +16,16 @@ export declare class DilParser {
     private mode;
     private lexical;
     private fence;
+    /** The open code span; lineBreak is set while only blanks follow a line feed. */
+    private span;
+    /** Code span opener lengths that have no closer before `until`. */
+    private unmatched;
+    /** Where the current Markdown block began, after the latest tag or block directive. */
+    private blockStart;
+    private readonly vocabulary;
+    private readonly isComponent;
+    private literalTag;
+    private readonly memo;
     private tokenNode;
     private nodes;
     private children;
@@ -15,8 +33,11 @@ export declare class DilParser {
     private dirty;
     private links;
     private declarations;
+    private issues;
     private revision;
-    constructor();
+    constructor(options?: DilParserOptions);
+    /** Registers component names for tags that start after this call. */
+    allow(components: unknown): void;
     private get parent();
     private closeFrame;
     private create;
@@ -24,10 +45,30 @@ export declare class DilParser {
     private markdown;
     private flushText;
     private finishMarkdown;
+    /** Moves scanned code into the open CodeBlock. */
+    private codeText;
+    /** At the end of input, drops a cut-off tag; completion reports it. */
+    private cutToken;
     private finish;
     private fail;
+    /** Open constructs keep what they completed; an unfinished token is dropped. */
+    private finishIncomplete;
+    /** Returns whether the directive ends the current Markdown block. */
     private directive;
     private tag;
     append(suffix: string, complete?: boolean): TreeBatch;
+    private scan;
+    /** Advances through a tag or brace token with JavaScript lexical rules. */
+    private token;
+    private text;
+    private openTag;
+    private startLiteral;
+    /** A literal tag stays text up to its ">", its line end, or a prose brace. */
+    private literal;
+    private fenced;
+    private openSpan;
+    private spanned;
+    /** The span has no closer in its block: its opener is literal text. */
+    private abandonSpan;
     snapshot(): DilNode[];
 }

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

@@ -1,4 +1,4 @@
-import type { Attribute } from "./types";
+import type { Attribute } from "./types.js";
 export declare class LexicalState {
     depth: number;
     quote: string;
@@ -11,6 +11,17 @@ export declare class LexicalState {
     consume(char: string, next: string): number;
     get neutral(): boolean;
 }
-export declare function fenceMarker(source: string, cursor: number, current: string): string | undefined;
+export interface TagStart {
+    name: string;
+    closing: boolean;
+    /** Offset just past the name. */
+    end: number;
+}
+/**
+ * Reads the tag name after "<" or "</" at cursor. Returns undefined while a
+ * streamed name may still grow, and null when the source is not tag-shaped,
+ * such as an autolink, an email address, or a comparison.
+ */
+export declare function tagStart(source: string, cursor: number, complete: boolean): TagStart | null | undefined;
 export declare function braceEnd(source: string, start: number): number;
 export declare function parseAttributes(source: string): Record<string, Attribute>;

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

@@ -0,0 +1,16 @@
+/** An autolink scheme such as "<https:"; tagStart has already rejected it as a tag. */
+export declare const AUTOLINK: RegExp;
+export declare class LiteralTag {
+    private readonly autolink;
+    /** Whether the run ended with its own ">". */
+    closed: boolean;
+    private equals;
+    private quote;
+    private braces;
+    constructor(autolink?: boolean);
+    /**
+     * Returns how many characters at char belong to the literal run, or 0 when
+     * the run ends before char. A run never continues past its line.
+     */
+    step(char: string, next: string): number;
+}

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

@@ -0,0 +1,41 @@
+export declare const WAIT = -1;
+export interface Fence {
+    char: string;
+    length: number;
+}
+/** How far a scan starting at `from` has already looked. */
+export interface Reach {
+    from: number;
+    to: number;
+}
+/**
+ * Unresolved run and line scans. The source only grows, so a scan that waited
+ * for more input resumes where it stopped instead of rescanning a long run.
+ */
+export interface ScanMemo {
+    run: Reach;
+    line: Reach;
+}
+export declare const scanMemo: () => ScanMemo;
+type IsComponent = (name: string) => boolean;
+/** Length of the run of identical characters at cursor. */
+export declare function runLength(source: string, cursor: number, complete: boolean, memo?: ScanMemo): number;
+/**
+ * Whether only indentation, list markers, or blockquote markers precede cursor
+ * on its line. The current Markdown block may also begin at floor, after a tag.
+ */
+export declare function atBlockStart(source: string, cursor: number, floor: number): boolean;
+/** An opening fence at cursor, null when there is none (CommonMark rules). */
+export declare function openingFence(source: string, cursor: number, floor: number, complete: boolean, memo?: ScanMemo): Fence | null | typeof WAIT;
+/**
+ * Length of the closing fence at cursor, or 0 when the line does not close
+ * fence. Besides spaces, only a DIL closing tag or block directive may follow it.
+ */
+export declare function closingFence(source: string, cursor: number, fence: Fence, complete: boolean, memo?: ScanMemo, isComponent?: IsComponent): number;
+/**
+ * Whether the line whose first non-blank character is at cursor starts a block
+ * that a code span cannot continue into: a fence, blockquote, heading, list
+ * item, thematic break, DIL block directive, or DIL component tag.
+ */
+export declare function blockLine(source: string, cursor: number, complete: boolean, isComponent: IsComponent): boolean | typeof WAIT;
+export {};

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

@@ -1,5 +1,10 @@
 export type NodeKind = "root" | "element" | "markdown" | "if" | "branch" | "each" | "pending";
-export type NodeStatus = "streaming" | "ready" | "error";
+/**
+ * `incomplete` marks a construct that was still open when the document was
+ * finalized: elements keep their completed children, while unfinished opening
+ * tags and repeat templates render nothing.
+ */
+export type NodeStatus = "streaming" | "ready" | "incomplete" | "error";
 export interface Attribute {
     expression?: string;
     literal?: string | boolean;
@@ -13,8 +18,15 @@ export interface DilNode {
     expressions: string[];
     status: NodeStatus;
     offset: number;
+    /** Developer-facing reason for an `error` node; readers see generic wording. */
     error: string;
 }
+/** A parse problem reported to the host once, with its source offset. */
+export interface ParseIssue {
+    kind: "syntax" | "incomplete";
+    message: string;
+    offset: number;
+}
 export interface TreeBatch {
     revision: number;
     nodes: DilNode[];
@@ -23,10 +35,19 @@ export interface TreeBatch {
         child: number;
     }[];
     declarations: string[];
+    issues: ParseIssue[];
     complete: boolean;
     scanned: number;
 }
+/** The parser's last reply when a message exceeds its node limit. */
+export interface ParserStop {
+    stopped: "limit";
+    message: string;
+}
+export type ParserReply = TreeBatch | ParserStop;
 export interface StreamInput {
     suffix: string;
     complete: boolean;
+    /** Host-registered component names, sent when they change. */
+    components?: readonly string[];
 }

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

@@ -0,0 +1,22 @@
+import type { DilNode, ParseIssue } from "./types.js";
+import type { TagVocabulary } from "./vocabulary.js";
+/** A tag or brace token that the end of the document cut off. */
+export interface CutToken {
+    source: string;
+    mode: "brace" | "tag";
+    offset: number;
+    /** The node an unfinished opening tag of a known component created. */
+    pending: DilNode | undefined;
+}
+/**
+ * Marks the open constructs (outermost first) and the cut token's pending node
+ * incomplete, so they keep what they completed, and returns one
+ * developer-facing report that lists them.
+ */
+export declare function finishOpen(open: readonly DilNode[], token: CutToken | undefined): ParseIssue | undefined;
+/**
+ * Whether the rest of a finalized source is a cut-off tag: a strict prefix of
+ * the open element's closing tag, a lone "<", or "<" and the start of a
+ * component name that is not a name by itself.
+ */
+export declare function cutTag(rest: string, open: string | undefined, vocabulary: TagVocabulary): boolean;

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

@@ -0,0 +1,12 @@
+export declare const TAG_NAME: RegExp;
+export declare class TagVocabulary {
+    private readonly names;
+    private custom;
+    static stock(): readonly string[];
+    /** Adds host-registered component names; malformed entries are ignored. */
+    allow(names: unknown): void;
+    /** Capitalized names are components; lowercase names must be registered. */
+    isComponent(name: string): boolean;
+    /** Whether some component name starts with this lowercase prefix. */
+    startsName(prefix: string): boolean;
+}

package/dist/types/dil/render-error.d.ts

@@ -0,0 +1,47 @@
+/**
+ * What went wrong:
+ * - `incomplete`: the document was finalized with unfinished structure, for
+ *   example because the reader stopped the response, the model reached its
+ *   output limit, or the stream failed.
+ * - `syntax`: the source contains malformed DIL or names a component that is
+ *   neither a stock component nor one passed in `components`.
+ * - `runtime`: the parser, the expression runtime, or the iframe runtime
+ *   failed, was blocked by the page's security policy, or a declaration failed;
+ *   or, once the message is final, an expression could not be evaluated or a
+ *   component failed to render.
+ * - `limit`: a size, display, or execution limit stopped the message.
+ * - `source`: `text` changed in an unsupported way, such as being replaced or
+ *   growing after the message was finalized.
+ */
+export type DilRenderErrorKind = "incomplete" | "syntax" | "runtime" | "limit" | "source";
+export interface DilRenderError {
+    kind: DilRenderErrorKind;
+    /** Developer-facing description. Readers see shorter wording. */
+    message: string;
+    /** Position in `text`, in UTF-16 code units, when the error has one. */
+    offset?: number;
+}
+/** Reader-facing wording for a part of the message that cannot be shown. */
+export declare const UNSHOWN_PART_MESSAGE = "This part of the response couldn't be shown.";
+/** Problems reported for one message before the rest are summarized. */
+export declare const MAX_REPORTED_PROBLEMS = 20;
+export declare const UNREPORTED_PROBLEMS = "This message has more than 20 problems; later ones are not reported.";
+/**
+ * Decides what reaches `onError` for one message: each distinct problem once,
+ * at most MAX_REPORTED_PROBLEMS of them followed by one `limit` notice, and
+ * the end-of-document report once. Messages are bounded in every mode.
+ */
+export declare class ProblemReports {
+    private readonly seen;
+    private count;
+    private ended;
+    /** Returns the error to report for this problem, or undefined to drop it. */
+    take(problem: DilRenderError): DilRenderError | undefined;
+}
+/**
+ * Calls the host's handler. An exception it throws must not interrupt
+ * rendering, so it is rethrown asynchronously, like an event handler's.
+ */
+export declare function deliverError(onError: ((error: DilRenderError) => void) | undefined, error: DilRenderError): void;
+/** Validates an error received from the iframe runtime. */
+export declare function readRenderError(value: unknown): DilRenderError | undefined;

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

@@ -1,22 +1,33 @@
-export interface FrameViewport {
-    offset: number;
-    revision: number;
-    height: number;
-    width: number;
-    listeners: Set<() => void>;
+import type { DilRenderError } from "./render-error.js";
+/**
+ * The visible part of a renderer's scroller. Offsets are measured from the
+ * renderer's top, so layout around the renderer does not move its content.
+ */
+export interface RendererViewport {
+    /** Distance from the renderer's top to the top of the visible area. */
+    readonly offset: number;
+    readonly height: number;
+    readonly width: number;
+    /** The renderer's top in client coordinates, the origin of `offset`. */
+    origin(): number;
+    subscribe(listener: () => void): () => void;
+    /** Scrolls until `offset` is at the top of the visible area. */
+    scrollTo(offset: number): void;
 }
 export interface RendererMetrics {
     scanned: number;
     complete: boolean;
+    /** The document was finalized while some of its structure was still open. */
+    incomplete: boolean;
 }
 export interface RendererEnvironment {
-    viewport?: FrameViewport;
-    scrollTo?: (offset: number) => void;
+    viewport?: RendererViewport;
     copy?: (text: string) => Promise<boolean>;
     onInput?: (detail: {
         length: number;
     }) => void;
     onCommit?: (detail: RendererMetrics) => void;
+    onError?: (error: DilRenderError) => void;
 }
 export declare const RendererEnvironmentContext: import("react").Context<RendererEnvironment>;
 export declare function useRendererEnvironment(): RendererEnvironment;

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

@@ -1,16 +1,19 @@
 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";
+import type { DilNode, TreeBatch } from "../parser/types.js";
+import { ChildList } from "./child-list.js";
+import { ExpressionEngine, type Scope } from "./expressions.js";
+import { RenderBudget } from "./render-budget.js";
+import { PresentationHistory } from "./presentation-history.js";
+import { PresentationScheduler } from "./presentation-scheduler.js";
+import { type DilRenderError } from "../render-error.js";
 export interface NodeState {
     node: DilNode;
     children: ChildList;
 }
 export interface DocumentStatus {
     complete: boolean;
+    /** The document was finalized while some of its structure was still open. */
+    incomplete: boolean;
     revision: number;
     scanned: number;
     error: string;
@@ -33,6 +36,15 @@ export declare class DilDocument {
     readonly status: StoreApi<DocumentStatus>;
     readonly engine: ExpressionEngine;
     readonly drafts: Map<string, string>;
+    private readonly reports;
+    /**
+     * Receives each distinct problem once, within the ProblemReports budget.
+     * Problems readers see only generic wording for are also logged.
+     */
+    onError: ((error: DilRenderError) => void) | undefined;
+    report(problem: DilRenderError): void;
+    /** Shows a document-level alert and reports it. */
+    fail(error: DilRenderError): void;
     constructor();
     apply(batch: TreeBatch): void;
     private presentedChildren;

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

@@ -25,6 +25,7 @@ export declare class ExecutionQueue {
     private readonly receive;
     private readonly failure;
     private next;
+    private answered;
     private pending;
     private evaluations;
     private activeKeys;
@@ -32,7 +33,7 @@ export declare class ExecutionQueue {
     private setters;
     private draining;
     private stopped;
-    constructor(post: (message: Record<string, unknown>) => void, receive: (job: ExecutionJob, reply: ExecutionReply) => void, failure: (message: string) => void);
+    constructor(post: (message: Record<string, unknown>) => void, receive: (job: ExecutionJob, reply: ExecutionReply) => void, failure: (message: string, kind: "runtime" | "limit") => void);
     get stats(): {
         inFlight: number;
         evaluations: number;

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

@@ -1,6 +1,6 @@
-import { PresentationScheduler } from "./presentation-scheduler";
-import { type Scope } from "./evaluation-cache";
-export type { Scope } from "./evaluation-cache";
+import { PresentationScheduler } from "./presentation-scheduler.js";
+import { type Scope } from "./evaluation-cache.js";
+export type { Scope } from "./evaluation-cache.js";
 export interface BindingState {
     values: Record<string, unknown>;
     versions: Record<string, number>;
@@ -13,7 +13,8 @@ export declare class ExpressionEngine {
     readonly events: EventTarget;
     private readonly updates;
     readonly store: import("zustand").StoreApi<BindingState>;
-    private worker;
+    /** Started by the first job, so documents without expressions or state never load QuickJS. */
+    private runtime;
     private readonly cache;
     private readonly queue;
     private intent;
@@ -35,13 +36,15 @@ export declare class ExpressionEngine {
     };
     markGesture(): void;
     constructor(events?: EventTarget, updates?: PresentationScheduler);
+    private start;
     private reference;
     private replaceHandles;
     private retire;
     private notify;
     private fill;
     private receive;
-    halt(reason: string, report?: boolean): void;
+    /** Stops the runtime; a reported halt reaches the document as a dil:error event. */
+    halt(reason: string, kind?: "runtime" | "limit", report?: boolean): void;
     dispose(): void;
     /** Committed views own demand; cancelled renders never enqueue worker work. */
     retain(expressions: readonly string[], scope?: Scope): () => void;

package/dist/types/dil/runtime/inline-worker.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Host and Shadow DOM renderers run the parser and the QuickJS runtime in blob:
+ * workers, which inherit the page's Content Security Policy. When that policy
+ * blocks them, readers get a plain explanation and developers get the directives
+ * to add, instead of a generic crash message.
+ */
+export declare const POLICY_BLOCKED_MESSAGE = "This content can't be displayed because this page's security policy blocks it.";
+export declare const WASM_BLOCKED_MESSAGE = "Interactive parts of this content can't run because this page's security policy blocks them.";
+/** Name of the Trusted Types policy that turns OpenDIL's own blob: URLs into script URLs. */
+export declare const TRUSTED_TYPES_POLICY = "opendil";
+export interface InlineWorkerOptions<Message> {
+    /** Names the worker in developer diagnostics. */
+    role: string;
+    /** Reader-safe message for failures the page policy does not explain. */
+    crashMessage: string;
+    onMessage: (data: Message) => void;
+    /** Receives one reader-safe message when the worker cannot start or stops. */
+    onStop: (message: string) => void;
+}
+export interface InlineWorker {
+    /** Null when the browser refused to construct the worker. */
+    readonly worker: Worker | null;
+    /** Terminates the worker without reporting a failure. */
+    dispose(): void;
+}
+export declare function startInlineWorker<Message>(source: string, { role, crashMessage, onMessage, onStop }: InlineWorkerOptions<Message>): InlineWorker;
+/** quickjs-emscripten could not instantiate its WebAssembly module (see vm-worker.ts). */
+export declare const RUNTIME_START_FAILURE = "QuickJS failed to start";
+/**
+ * Returns a reader-safe message when the page policy forbids WebAssembly
+ * compilation, which blob: workers inherit; otherwise undefined.
+ */
+export declare function explainRuntimeStartFailure(): string | undefined;

package/dist/types/dil/runtime/view-cost.d.ts

@@ -1,5 +1,5 @@
-import type { DilDocument } from "./document";
-import type { Scope } from "./expressions";
+import type { DilDocument } from "./document.js";
+import type { Scope } from "./expressions.js";
 export interface CostDocument {
     nodes: DilDocument["nodes"];
     engine: Pick<DilDocument["engine"], "read">;

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

@@ -1,6 +1,6 @@
-import type { ChildList } from "../runtime/child-list";
-import type { DilDocument } from "../runtime/document";
-import type { Scope } from "../runtime/expressions";
+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;

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

@@ -1,6 +1,6 @@
-import { type Scope } from "../runtime/expressions";
-import type { DilNode } from "../parser/types";
-import type { DilDocument } from "../runtime/document";
+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;

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

@@ -1,6 +1,6 @@
-import type { DilDocument } from "../runtime/document";
-import type { Scope } from "../runtime/expressions";
-import type { ChildList } from "../runtime/child-list";
+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;