@lightspeed-js/core 0.1.0

package/dist/types/src/runtime/components/types/index.d.ts

@@ -0,0 +1,34 @@
+export interface ComponentDefinition {
+    id: string;
+    template: string;
+    /** Static placeholder shown until this component hydrates. */
+    skeleton?: string;
+    /**
+     * Cell keys the component declared it cannot render without.
+     *
+     * Travels on the definition so a *usage* of it inherits the wait: a caller
+     * should not have to know the child's data dependencies, which is the
+     * coupling a prop chain has. Merged with any `$needs` the placement adds.
+     */
+    needs?: string[];
+    style: string;
+    /**
+     * The component's compiled logic.
+     *
+     * A real function built by the compiler, not a string evaluated at mount:
+     * that is what lets logic `import` project modules and what keeps the
+     * browser free of `new Function`. See [[ADR-016]].
+     */
+    setup?: (context: Record<string, unknown>) => void;
+    /**
+     * Handler names an event expression is compiled with, in order.
+     *
+     * Fixed at build so the compiled signature cannot depend on what the
+     * instance happened to register. See [[ADR-016]].
+     */
+    handlers?: string[];
+    /** Per-component hash stamped on owned elements for style scoping. */
+    /** Deferred CSS, applied when the component hydrates. */
+    styleDeferred?: string;
+    scopeId?: string;
+}

package/dist/types/src/runtime/core.d.ts

@@ -0,0 +1,251 @@
+import { ComponentInstance, type ComponentDefinition } from "./components/index.js";
+import type { MarkerRange } from "./dom/Mounter.js";
+/**
+ * A mounted root. Hold onto it to unmount that island later.
+ *
+ * `instance` is replaced when the root is remounted (hot reload), so read it
+ * through the handle rather than caching it.
+ */
+export interface MountHandle {
+    id: string;
+    componentId: string;
+    instance: ComponentInstance;
+    props: any;
+    /** Set when mounted imperatively into a container element. */
+    container?: Element;
+    /** Set when discovered as an island marker in markup. */
+    range?: MarkerRange;
+    /**
+     * Original slot markup. Kept as a string so a remount can rebuild the
+     * content it consumed.
+     */
+    slotHtml?: string;
+}
+export declare function registerPageExpressions(expressions?: Record<string, any>, writers?: Record<string, any>): void;
+export declare class LightspeedRuntime {
+    private componentRegistry;
+    /** Keyed by instance id ("button#2"), not component id. */
+    private instances;
+    private globalSignals;
+    private cells;
+    private initialised;
+    private instanceCounter;
+    /**
+     * Independently mounted islands. Lightspeed does not own the page - a HUD, a
+     * form and an overlay are three roots that happen to share a runtime.
+     */
+    /**
+     * Component id to a dynamic import.
+     *
+     * Supplied by the build's virtual module. Each import is a chunk boundary,
+     * so a component's code arrives only when something mounts it - which is
+     * what makes `$hydrate` defer bytes rather than only execution.
+     */
+    private loaders;
+    private loading;
+    /** Skeleton markup and scope for components that have not loaded yet. */
+    private pageMetadata;
+    private roots;
+    private rootCounter;
+    private ssg;
+    /** Cancels for islands still waiting on a hydration trigger. */
+    private pendingIslands;
+    private reactiveProxy;
+    private updateScheduler;
+    private bindingEvaluator;
+    private eventBinder;
+    private globalFunctions;
+    /**
+     * Instances with `onMounted` callbacks that have not run yet.
+     *
+     * Order is mount order, which puts children before parents: a child mounts
+     * during its parent's collection, so it queues first. A parent that measures
+     * something a child rendered therefore sees it.
+     */
+    private pendingMounts;
+    /** Guards against a callback that mounts something re-entering the flush. */
+    private flushing;
+    private mounter;
+    private styleManager;
+    constructor(options?: {
+        ssg?: boolean;
+    });
+    /**
+     * Instances whose `onUpdate` is running, so their writes do not queue again.
+     *
+     * The write is not lost - the bindings evaluate immediately after, in this
+     * same pass. See the guard in the `ReactiveProxy` callback above.
+     */
+    private updating;
+    private runUpdateCallbacks;
+    /**
+     * Apply a batch of state changes.
+     *
+     * Each owner is the instance whose state changed, so only its bindings are
+     * re-evaluated. A null owner comes from the window-global `reactive()`,
+     * which has no instance - that falls back to updating the whole tree.
+     */
+    private handleUpdate;
+    registerComponent(component: ComponentDefinition): void;
+    /**
+     * Metadata the page inlined for components that may not have loaded.
+     *
+     * Read from the document rather than passed in, so an app never has to wire
+     * up something the build already knows.
+     */
+    private readPageMetadata;
+    /**
+     * Content the build resolved and baked into the page.
+     *
+     * Seeded in the constructor, so cells hold their values before anything
+     * mounts - `$needs` gates are already open, and what the client renders
+     * matches the HTML, so adoption does not bail out.
+     */
+    /**
+     * Resolve `route` from the URL, for a page whose paths were not knowable at
+     * build.
+     *
+     * A baked route ships its params in the state payload; a rewritten one ships
+     * only the pattern, because one file answers many URLs. Seeding the same
+     * cell either way is what lets a component read `shared.route.params.id`
+     * without knowing or caring which kind of page it is on.
+     *
+     * Runs before `setup()`, so the value is present for the first render rather
+     * than arriving as an update.
+     */
+    private readPageRoute;
+    private readPageState;
+    /** Hand the runtime a lazy import per component. */
+    useComponents(loaders: Record<string, () => Promise<any>>, 
+    /**
+     * Expressions a page contributes, from its island markers.
+     *
+     * They belong to no component, so they arrive here - with the entry chunk
+     * that hydration itself comes from, which is the only place guaranteed to
+     * be present when the first island mounts.
+     */
+    page?: {
+        expressions?: Record<string, any>;
+        writers?: Record<string, any>;
+    }): void;
+    /**
+     * A component's definition, fetching it if it has not arrived yet.
+     *
+     * Concurrent requests share one import - two islands using the same
+     * component must not trigger two fetches.
+     */
+    private resolveComponent;
+    updateComponent(id: string, component: ComponentDefinition): void;
+    /**
+     * Create an instance and run its logic. Called by the mounter for every
+     * <lsp-mount> it encounters, so one definition yields many instances.
+     */
+    /**
+     * Let an instance hear about the objects it was handed.
+     *
+     * A form shares one mutable object - the parent owns it, children write into
+     * it with `$model`. Writing notifies whoever *wrapped* the object, which is
+     * the parent alone, so a sibling reading the same object kept rendering the
+     * previous value until something else happened to update it. Registering
+     * every holder is what makes a shared object behave like shared state.
+     */
+    private shareObjectProps;
+    private createInstance;
+    private createExecutionContext;
+    /** Whether this render declared any build-time content. */
+    hasBuildData(): boolean;
+    /** Wait for build-time content, and let a failure fail the build. */
+    settleBuildData(): Promise<void>;
+    /** Resolved build-time content, for the page to carry to the client. */
+    buildPayload(): Record<string, unknown>;
+    /** Seed content the build resolved, before anything mounts. */
+    /**
+     * What each mounted island would need the browser for, if anything.
+     *
+     * Per instance, and per instance only. What one island needs from another is
+     * visible in the markers rather than here - see `flattenStatic`.
+     */
+    hydrationReport(options?: {
+        routeIsLive?: boolean;
+    }): {
+        id: string;
+        componentId: string;
+        live: boolean;
+        reasons: string[];
+    }[];
+    seedState(values: Record<string, unknown>): void;
+    /**
+     * A shared cell, from outside any component.
+     *
+     * Needed by `$needs`, which is a promise that *someone* fills the cell - and
+     * that someone cannot be the gated component itself, whose logic has not run.
+     * A page-level script, an earlier island, or a cell initialiser fills it; this
+     * is how the first of those reaches it.
+     *
+     * Unscoped, so a subscription here lives until its returned unsubscribe is
+     * called. Component logic gets the instance-bound facade instead.
+     */
+    shared(key: string, init?: any, options?: any): {
+        key: string;
+        value: any;
+        readonly pending: boolean;
+        set: (next: any) => void;
+        subscribe: (listener: (value: any) => void) => () => void;
+    };
+    /**
+     * A cell facade bound to one instance, so manual subscriptions are dropped
+     * when that instance is destroyed - same contract as scoped signals.
+     */
+    private scopedCell;
+    private defaultProps;
+    /**
+     * Mount a component into a container as an independent root.
+     *
+     * Call it as many times as there are islands on the page. Roots share this
+     * runtime - and therefore signals and styles - but nothing else.
+     *
+     * Replaces the container's contents. Attaching to server-rendered markup
+     * instead is deferred until there is markup to attach to.
+     */
+    mount(componentId: string, target: Element | string, props?: any, slotHtml?: string): Promise<MountHandle | null>;
+    /** Tear down one root, leaving the others alone. */
+    unmount(handle: MountHandle): void;
+    private remountAll;
+    /**
+     * Find and mount every island in the markup.
+     *
+     * This is the primary path: a page - hand-written or server-rendered - marks
+     * its islands with <lsp-mount>, and nobody hand-maintains a list of mount()
+     * calls beside it. The same marker the compiler emits for a nested child in a
+     * template marks a top-level island in a page; one concept, two contexts.
+     *
+     * Only outermost markers are scanned. A marker nested inside another belongs
+     * to that island's tree and is mounted with it.
+     *
+     * The <lsp-mount> element is kept in the DOM as a wrapper rather than being
+     * replaced, giving a stable anchor for remounts and, later, for deferred
+     * hydration. It is styled `display: contents` so it does not affect layout.
+     */
+    hydrate(scope?: ParentNode): Promise<MountHandle[]>;
+    /**
+     * Run the `onMounted` callbacks whose nodes are now in the document.
+     *
+     * Drains rather than iterates: a callback is allowed to mount something,
+     * and whatever that queues belongs to the next pass rather than to a list
+     * being walked. Each callback is isolated - one that throws is the
+     * component's fault and must not stop the others, which is a real failure
+     * mode when a page has a dozen islands and one has a typo.
+     */
+    private flushMounted;
+    /** Bring a discovered island to life and register it as a root. */
+    private mountIsland;
+    private parseSlotHtml;
+    private resolveTarget;
+    private unregisterSubtree;
+    /** Convenience for the single-root case. */
+    init(rootComponentId?: string, target?: Element | string): Promise<void>;
+    destroy(): void;
+}
+export declare function createLightspeedApp(options?: {
+    ssg?: boolean;
+}): LightspeedRuntime;

package/dist/types/src/runtime/diagnostics.d.ts

@@ -0,0 +1,33 @@
+/**
+ * One place that decides what the runtime says, and when.
+ *
+ * The distinction that matters is **fault versus chatter**, not dev versus
+ * production:
+ *
+ * - A *fault* means the page will not behave as written - a binding that threw,
+ *   a component that could not be found, an island that had to be rebuilt.
+ *   These are always reported. Hiding them behind a DEV flag is how a page ends
+ *   up quietly broken in the one environment users see: adoption bail-outs were
+ *   DEV-gated, so a bug that left *nothing on a built page interactive* reported
+ *   zero problems while six components failed. Twice this was chased down the
+ *   wrong path because the evidence was suppressed.
+ *
+ * - *Chatter* is useful while building and noise otherwise - "mounted x",
+ *   "styles updated". That stays behind DEV.
+ *
+ * Everything carries a prefix so it can be filtered, and so a warning from
+ * Lightspeed is distinguishable from one the application produced.
+ */
+/** Something is wrong and the page will not behave as written. */
+export declare function warn(message: string, ...detail: unknown[]): void;
+/** Something failed outright. */
+export declare function fail(message: string, ...detail: unknown[]): void;
+/**
+ * Extra context for a fault - a compiled source dump, a full stack.
+ *
+ * Reported only in dev, because it is unreadable in a production console and
+ * can be large. The fault itself is always reported first.
+ */
+export declare function detail(message: string, ...args: unknown[]): void;
+/** Useful while developing, noise in production. */
+export declare function debug(message: string, ...args: unknown[]): void;

package/dist/types/src/runtime/dom/ForBlock.d.ts

@@ -0,0 +1,127 @@
+import type { ComponentInstance } from "../components/ComponentInstance.js";
+import type { Binding } from "../bindings/index.js";
+/**
+ * Anything that can own bindings and be torn down: a component instance, or a
+ * single row of a `$for`.
+ */
+export interface BindingHolder {
+    addBinding(binding: Binding): void;
+    addCleanup(cleanup: Function): void;
+    addBlock(block: ForBlock): void;
+}
+/**
+ * One iteration of a `$for`.
+ *
+ * Owns everything created for it, so removing an item tears down exactly that
+ * item's bindings, listeners, child components and nested blocks.
+ */
+export declare class Row implements BindingHolder {
+    locals: any[];
+    key: string;
+    nodes: Node[];
+    bindings: Binding[];
+    blocks: ForBlock[];
+    cleanup: Function[];
+    instances: ComponentInstance[];
+    /** Loop variables in scope here: outer aliases first, then this row's item. */
+    constructor(locals: any[]);
+    addBinding(binding: Binding): void;
+    addCleanup(cleanup: Function): void;
+    addBlock(block: ForBlock): void;
+    get item(): any;
+    set item(value: any);
+}
+export interface RowRenderer {
+    createRow(block: ForBlock, item: any): Promise<Row>;
+    refreshRow(block: ForBlock, row: Row): void;
+    destroyRow(block: ForBlock, row: Row): void;
+    /**
+     * Rows have landed in the document.
+     *
+     * A block places its own nodes rather than going through `fillRange`, so
+     * without this nothing told the runtime that anything inside them was
+     * connected - and `onMounted` for a component in a row never ran.
+     */
+    connected?(): void;
+}
+/** `$for="n in 5"` and iterables, not just arrays. */
+export declare function toIterable(value: any): any[];
+/**
+ * A `$for` block: an anchor, a row template, and a keyed set of rows.
+ *
+ * Rows are always keyed. Unkeyed reuse looks fine for text but silently hands
+ * one row's carried state - a child component, an input's value, focus - to a
+ * different item. See ADR-007.
+ */
+export declare class ForBlock {
+    owner: ComponentInstance;
+    anchor: Comment;
+    /**
+     * One template for `$for`; one per branch for an `$if` chain, indexed by
+     * the branch the condition selects.
+     */
+    templates: Element[];
+    /** null for `$if`, which has no loop variable. */
+    alias: string | null;
+    /** Alias names in scope from enclosing blocks, outermost first. */
+    params: string[];
+    /** Live reference to the enclosing row's locals, if nested. */
+    parentLocals: any[];
+    keyFor: ((locals: any[]) => any) | null;
+    private renderer;
+    /** `$if`: zero or one row, driven by a condition rather than a list. */
+    conditional: boolean;
+    /** The collection expression, kept so adoption can re-evaluate it. */
+    itemsExpr: string;
+    rows: Map<string, Row>;
+    order: string[];
+    private pendingItems;
+    private running;
+    private warnedDuplicates;
+    constructor(owner: ComponentInstance, anchor: Comment, 
+    /**
+     * One template for `$for`; one per branch for an `$if` chain, indexed by
+     * the branch the condition selects.
+     */
+    templates: Element[], 
+    /** null for `$if`, which has no loop variable. */
+    alias: string | null, 
+    /** Alias names in scope from enclosing blocks, outermost first. */
+    params: string[], 
+    /** Live reference to the enclosing row's locals, if nested. */
+    parentLocals: any[], keyFor: ((locals: any[]) => any) | null, renderer: RowRenderer, 
+    /** `$if`: zero or one row, driven by a condition rather than a list. */
+    conditional?: boolean, 
+    /** The collection expression, kept so adoption can re-evaluate it. */
+    itemsExpr?: string);
+    /**
+     * Turn a bound expression into the rows it implies.
+     *
+     * `$if` is the degenerate case - a block whose collection is empty or a
+     * single placeholder - so it needs no reconciliation logic of its own.
+     */
+    toItems(value: any): any[];
+    /** The markup a row should clone. */
+    templateFor(item: any): Element;
+    /**
+     * Queue a reconcile.
+     *
+     * Rows containing components mount asynchronously, so a reconcile can still
+     * be in flight when the collection changes again. Only the latest snapshot
+     * matters, so it replaces any queued one and the loop runs until settled.
+     */
+    schedule(items: any[]): void;
+    private drain;
+    /** Public so adoption can match rendered rows to the current data. */
+    keysFor(items: any[]): string[];
+    private reconcile;
+    /**
+     * Put rows in order before the anchor.
+     *
+     * Walks backwards so each row is inserted before the one after it, and skips
+     * nodes already in place. No longest-increasing-subsequence pass - simple
+     * moves are proportionate for the list sizes this targets.
+     */
+    private position;
+    destroy(): void;
+}

package/dist/types/src/runtime/dom/Mounter.d.ts

@@ -0,0 +1,223 @@
+import type { ComponentRegistry } from "../components/ComponentRegistry.js";
+import type { ComponentInstance } from "../components/ComponentInstance.js";
+import type { BindingEvaluator } from "../bindings/index.js";
+import type { EventBinder } from "../events/index.js";
+import { ForBlock, Row, type RowRenderer } from "./ForBlock.js";
+import { type MarkerPayload } from "../../marker.js";
+/** An island boundary found while walking, plus what sits between it. */
+export interface MarkerRange {
+    start: Comment;
+    end: Comment;
+    payload: MarkerPayload;
+    /** Nodes between the comments - slot content, owned by the parent. */
+    slotNodes: Node[];
+    /**
+     * This range was found by adopting build-rendered DOM, so whatever sits
+     * between its comments is rendered output.
+     *
+     * Only *top-level* markers carry the `ssr` flag, so a nested island had no
+     * way to know its own content came from the build. A deferred one would
+     * rebuild itself when its trigger fired - throwing away correct DOM, losing
+     * focus and scroll, in the exact case ADR-011 exists to prevent.
+     */
+    adopted?: boolean;
+}
+export type InitInstance = (componentId: string, parent: ComponentInstance | null, props: any) => Promise<ComponentInstance | null>;
+/** Drop an instance and everything below it from the runtime's registry. */
+export type ReleaseInstance = (instance: ComponentInstance) => void;
+/**
+ * Builds the instance tree and the DOM for it.
+ *
+ * A component's template is cloned per usage, so every <lsp-mount> becomes its
+ * own instance with its own state. The whole tree is built detached and
+ * inserted once, so nothing intermediate is ever painted.
+ */
+export declare class Mounter implements RowRenderer {
+    private registry;
+    private bindings;
+    private events;
+    private initInstance;
+    private releaseInstance;
+    /** Fetches a component's definition if it has not arrived yet. */
+    private resolve;
+    /** Skeleton and scope for a component that has not been fetched. */
+    private metadata;
+    /** Build-time rendering: mount everything that is not waiting on data. */
+    private ssg;
+    /** Emits the `$shimmer` placeholder styles on first use. */
+    private styles;
+    constructor(registry: ComponentRegistry, bindings: BindingEvaluator, events: EventBinder, initInstance: InitInstance, releaseInstance?: ReleaseInstance, 
+    /** Fetches a component's definition if it has not arrived yet. */
+    resolve?: (componentId: string) => Promise<any>, 
+    /** Skeleton and scope for a component that has not been fetched. */
+    metadata?: (componentId: string) => {
+        scope?: string;
+        skeleton?: string;
+    } | null, 
+    /** Build-time rendering: mount everything that is not waiting on data. */
+    ssg?: boolean, 
+    /** Emits the `$shimmer` placeholder styles on first use. */
+    styles?: {
+        ensurePendingStyles(): void;
+    } | null);
+    mountRoot(componentId: string, container: Element, props?: any, slotNodes?: Node[]): Promise<ComponentInstance | null>;
+    mount(componentId: string, parent: ComponentInstance | null, props: any, slotNodes: Node[], preserved?: Map<string, Node[]>, 
+    /** Server-rendered nodes to bind to instead of building fresh. */
+    adopt?: Node[], 
+    /**
+     * Detaches nested build-rendered content, for the rebuild path only.
+     *
+     * Deliberately lazy. Doing it eagerly guts the very DOM adoption is about
+     * to walk: every nested marker comes back empty, every nested component
+     * bails out, and the page silently rebuilds everything. Only called if
+     * adoption is not attempted or does not succeed.
+     */
+    rescue?: () => Map<string, Node[]>): Promise<ComponentInstance | null>;
+    /** Remove an instance's DOM and tear down its subtree. */
+    unmount(instance: ComponentInstance): void;
+    private parseTemplate;
+    private fillSlots;
+    /**
+     * Walk a subtree, attaching bindings and listeners to the owning instance
+     * and queueing any nested mount points.
+     */
+    private collect;
+    /**
+     * Walk a node's children, treating an island boundary as a unit.
+     *
+     * Index-based rather than per-node, because a marker claims a *range* of
+     * siblings rather than a single element.
+     */
+    /**
+     * `$needs` on an ordinary element: hold its children until the cells resolve.
+     *
+     * The lightweight tier of ADR-010. A component with a `<skeleton>` is the
+     * answer when the placeholder deserves real markup; this is for the case
+     * where one value is outstanding and a component would be ceremony.
+     */
+    private collectNeeds;
+    private collectChildren;
+    /**
+     * Detach the content of every nested marker inside a range.
+     *
+     * Called before the range is rebuilt, while the rendered DOM is still there.
+     * Nodes are moved into a fragment rather than referenced, because filling the
+     * range removes anything still attached.
+     */
+    private rescueRendered;
+    private takeRescued;
+    /**
+     * Bind to server-rendered DOM instead of rebuilding it.
+     *
+     * Walks the template and the rendered nodes in lockstep. Every divergence -
+     * a different tag, a missing block anchor, the wrong number of rows - returns
+     * false, and the caller rebuilds that component the way it always has. So
+     * adoption can be a performance win but never a correctness risk: a mismatch
+     * costs a rebuild and a dev warning rather than leaving bindings pointed at
+     * DOM that does not match the data.
+     *
+     * That guard matters more since ADR-010, because most components now render
+     * real content at build. Anything time- or environment-dependent (a
+     * timestamp, a persisted cell) legitimately differs between build and client.
+     */
+    private adoptNodes;
+    /**
+     * Adopt a `$for` / `$if` block against its rendered anchor and rows.
+     *
+     * Returns how many rendered nodes were consumed, or -1 to bail out.
+     *
+     * Rather than rebuilding rows, this pre-populates the block so the first
+     * reconcile matches them by key and calls refreshRow - the existing keyed
+     * path does the rest.
+     */
+    private adoptBlock;
+    /**
+     * Called once nodes have been inserted somewhere connected to the document.
+     *
+     * The runtime uses it to run `onMounted`. Here rather than at the end of a
+     * mount, because a component built fresh lands in a *fragment* first - its
+     * nodes are not in the document until an ancestor is inserted, and a
+     * callback that measures anything before then measures nothing.
+     */
+    onConnected?: () => void;
+    /** Replace whatever sits between a marker pair. */
+    private fillRange;
+    private collectElement;
+    /**
+     * Turn `$for="item in expr"` into an anchored block.
+     *
+     * The element is replaced by a comment anchor and kept as the row template.
+     * A comment, not an element: a `$for` inside <tbody> or <select> cannot
+     * carry a wrapper, and unlike an empty text node a comment survives
+     * serialisation, which matters once markup is server-rendered.
+     */
+    private createBlock;
+    /**
+     * Hand a block the rows already in the document.
+     *
+     * Keys are recomputed from the current data rather than shipped, so the
+     * first reconcile matches these by key and refreshes them in place instead
+     * of building replacements.
+     */
+    private adoptRows;
+    /**
+     * Collect an `$if` / `$else-if` / `$else` chain from adjacent siblings.
+     *
+     * `nextElementSibling` skips the whitespace and comments between them. Each
+     * branch is detached as it is claimed, so a later walk cannot mistake a
+     * consumed `$else` for a stray one.
+     */
+    private gatherBranches;
+    createRow(block: ForBlock, item: any): Promise<Row>;
+    /** A block placed its rows in the document. See `RowRenderer.connected`. */
+    connected(): void;
+    refreshRow(block: ForBlock, row: Row): void;
+    destroyRow(block: ForBlock, row: Row): void;
+    private cellsProxy;
+    private applyDirective;
+    /**
+     * A bare name resolves to a handler; anything else is an expression.
+     *
+     * Expressions are what make per-row actions possible - `@click="remove(item)"`
+     * inside a `$for` needs the loop variable, which a handler name cannot carry.
+     * Handler names and loop aliases are passed as parameters so free identifiers
+     * in the expression resolve without a scope object or `with`.
+     */
+    private bindEvent;
+    private mountMarker;
+    /**
+     * Leave a skeleton between the markers and mount when the trigger fires.
+     *
+     * Slot content is detached first: rendering the skeleton clears the range,
+     * and those nodes already carry bindings the parent collected, so they must
+     * be preserved rather than rebuilt.
+     */
+    private deferMarker;
+    /** Evaluate a `$is` expression to a component id. */
+    private resolveDynamicId;
+    /** Show a component's static placeholder, scoped so its own styles apply. */
+    renderSkeleton(range: MarkerRange): void;
+    private completeMount;
+    /**
+     * Top-level island markers in a scope.
+     *
+     * Depth tracking rather than containment: comments have no children, so a
+     * nested marker is one that appears between another's boundaries.
+     */
+    findIslands(scope: ParentNode): MarkerRange[];
+    /** Mount a discovered island into its own boundary. */
+    mountRange(range: MarkerRange, props: any, slotNodes: Node[]): Promise<ComponentInstance | null>;
+    /** Attributes the parent wrote, applied to the child's root. */
+    private applyForwarded;
+}
+/**
+ * Collapse an if/else-if/else chain into one expression yielding the index of
+ * the winning branch, or -1 when none matches.
+ *
+ * Doing it in a single expression keeps "first truthy wins" in one place, and
+ * means the chain needs no evaluation machinery beyond an ordinary binding.
+ */
+export declare function composeBranchExpression(branches: Array<{
+    condition: string | null;
+    el: Element;
+}>): string;