@snackbit/opendil 0.0.0 → 0.2.0

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

@@ -0,0 +1,74 @@
+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;
+    private textStart;
+    private tokenStart;
+    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;
+    private stack;
+    private dirty;
+    private links;
+    private declarations;
+    private issues;
+    private revision;
+    constructor(options?: DilParserOptions);
+    /** Registers component names for tags that start after this call. */
+    allow(components: unknown): void;
+    private get parent();
+    private closeFrame;
+    private create;
+    private touch;
+    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

@@ -0,0 +1,27 @@
+import type { Attribute } from "./types.js";
+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 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/stream-worker.d.ts

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

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

@@ -0,0 +1,53 @@
+export type NodeKind = "root" | "element" | "markdown" | "if" | "branch" | "each" | "pending";
+/**
+ * `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;
+}
+export interface DilNode {
+    id: number;
+    kind: NodeKind;
+    name: string;
+    attributes: Record<string, Attribute>;
+    text: string;
+    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[];
+    links: {
+        parent: number;
+        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

@@ -0,0 +1,33 @@
+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?: 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/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,54 @@
+import { type StoreApi } from "zustand/vanilla";
+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;
+    /** 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>;
+    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;
+    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,56 @@
+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 answered;
+    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, kind: "runtime" | "limit") => 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;
+}

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

@@ -0,0 +1,62 @@
+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>;
+    catalog: number;
+}
+export declare class EvaluationPending extends Error {
+    constructor();
+}
+export declare class ExpressionEngine {
+    readonly events: EventTarget;
+    private readonly updates;
+    readonly store: import("zustand").StoreApi<BindingState>;
+    /** Started by the first job, so documents without expressions or state never load QuickJS. */
+    private runtime;
+    private readonly cache;
+    private readonly queue;
+    private intent;
+    private failed;
+    private gestureUntil;
+    private handleRefs;
+    private released;
+    private pendingChanges;
+    private urgentKeys;
+    compilations: number;
+    get stopped(): boolean;
+    get stats(): {
+        cached: number;
+        handles: number;
+        inFlight: number;
+        evaluations: number;
+        queued: number;
+        mutations: number;
+    };
+    markGesture(): void;
+    constructor(events?: EventTarget, updates?: PresentationScheduler);
+    private start;
+    private reference;
+    private replaceHandles;
+    private retire;
+    private notify;
+    private fill;
+    private receive;
+    /** 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;
+    read(source: string, scope?: Scope): unknown;
+    hasValue(source: string, scope?: Scope): boolean;
+    isFresh(source: string, scope?: Scope): boolean;
+    evaluate(source: string, scope?: Scope): unknown;
+    private check;
+    evaluationRevision(source: string | undefined, scope?: Scope): number;
+    signature(expressions: readonly string[], scope: Scope, state: BindingState): string;
+    declare(source: string): void;
+    private call;
+    private decode;
+    private revive;
+}

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/markdown-stream.d.ts

@@ -0,0 +1,17 @@
+export interface MarkdownBlock {
+    offset: number;
+    text: string;
+}
+export interface MarkdownSnapshot {
+    source: string;
+    offset: number;
+    blocks: readonly MarkdownBlock[];
+    complete: boolean;
+    trailing?: MarkdownBlock;
+}
+export declare const EMPTY_MARKDOWN: MarkdownSnapshot;
+/** Only the trailing block is reparsed; completed blocks keep their values and keys. */
+export declare function advanceMarkdown(previous: MarkdownSnapshot, source: string, complete: boolean): MarkdownSnapshot;
+export declare function currentMarkdown(snapshot: MarkdownSnapshot): readonly MarkdownBlock[];
+export declare function markdownIndent(source: string): number | undefined;
+export declare function normalizeMarkdown(source: string, indentation: number): string;

package/dist/types/dil/runtime/presentation-history.d.ts

@@ -0,0 +1,14 @@
+export type PresentationPhase = "ready" | "revealing" | "visible";
+/** Logical message state survives view replacement and virtualization. */
+export declare class PresentationHistory {
+    private phases;
+    private attributes;
+    private virtual;
+    phase(key: string): PresentationPhase | undefined;
+    set(key: string, phase: PresentationPhase): void;
+    last(key: string): Record<string, unknown> | undefined;
+    remember(key: string, value: Record<string, unknown>): void;
+    visited(key: string): boolean;
+    visit(key: string): void;
+    forget(prefix: string): void;
+}

package/dist/types/dil/runtime/presentation-scheduler.d.ts

@@ -0,0 +1,16 @@
+export type UpdateInterval = "instant" | number;
+export declare function parseUpdateInterval(value: unknown): UpdateInterval;
+/** Latest work per owner, bounded by cadence rather than waiting for a quiet stream. */
+export declare class PresentationScheduler {
+    private pending;
+    private timer;
+    private last;
+    private interval;
+    private disposed;
+    configure(value: UpdateInterval): void;
+    enqueue(key: string, task: () => void, urgent?: boolean): void;
+    cancel(key: string): void;
+    private schedule;
+    private flush;
+    dispose(): void;
+}

package/dist/types/dil/runtime/render-budget.d.ts

@@ -0,0 +1,10 @@
+/** Bounds mounted presentation work, including multiplicative repeated templates. */
+export declare class RenderBudget {
+    readonly limit: number;
+    private leases;
+    private total;
+    constructor(limit?: number);
+    get used(): number;
+    reserve(id: string, cost: number): boolean;
+    release(id: string): void;
+}

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

@@ -0,0 +1,10 @@
+import type { DilDocument } from "./document.js";
+import type { Scope } from "./expressions.js";
+export interface CostDocument {
+    nodes: DilDocument["nodes"];
+    engine: Pick<DilDocument["engine"], "read">;
+    attributes: DilDocument["attributes"];
+}
+/** Pure, short-circuiting preflight; unresolved expressions cost a local placeholder. */
+export declare function nodeCost(document: CostDocument, id: number, scope: Scope, svg: boolean, limit: number): number;
+export declare function childrenCost(document: CostDocument, ids: readonly number[], scope: Scope, svg: boolean, limit: number): number;