@microsoft/fast-element 2.10.3 → 3.0.0-rc.1

package/dist/dts/index.d.ts

@@ -1,48 +1,44 @@
-export type { Callable, Class, Constructable, Disposable, FASTGlobal, TrustedTypesPolicy, } from "./interfaces.js";
-export { emptyArray, FAST } from "./platform.js";
-export { DOM, DOMAspect, type DOMPolicy, type DOMSink } from "./dom.js";
-export { ArrayObserver, lengthOf, Sort, sortedCount, Splice, SpliceStrategy, SpliceStrategySupport, type LengthObserver, type SortObserver, } from "./observation/arrays.js";
-export { PropertyChangeNotifier, SubscriberSet, type Notifier, type Subscriber, } from "./observation/notifier.js";
-export { ExecutionContext, Observable, observable, SourceLifetime, volatile, type Accessor, type Expression, type ExpressionController, type ExpressionNotifier, type ExpressionObserver, type ObservationRecord, } from "./observation/observable.js";
-export { Updates, type UpdateQueue } from "./observation/update-queue.js";
+export { AttributeConfiguration, AttributeDefinition, type AttributeMode, attr, booleanConverter, type DecoratorAttributeConfiguration, nullableBooleanConverter, nullableNumberConverter, type ValueConverter, } from "./attr.js";
 export { Binding, type BindingDirective } from "./binding/binding.js";
 export { normalizeBinding } from "./binding/normalize.js";
 export { oneTime } from "./binding/one-time.js";
 export { listener, oneWay } from "./binding/one-way.js";
-export { CSSBindingDirective } from "./styles/css-binding-directive.js";
-export { cssDirective, CSSDirective, type AddBehavior, type CSSDirectiveDefinition, } from "./styles/css-directive.js";
-export { css, type CSSTemplateTag, type CSSValue } from "./styles/css.js";
-export { ElementStyles, type ComposableStyles, type ConstructibleStyleStrategy, } from "./styles/element-styles.js";
-export { type HostBehavior } from "./styles/host.js";
-export type { HostController } from "./styles/host.js";
-export type { StyleStrategy, StyleTarget } from "./styles/style-strategy.js";
-export { children, ChildrenDirective } from "./templating/children.js";
-export type { ChildListDirectiveOptions, ChildrenDirectiveOptions, SubtreeDirectiveOptions, } from "./templating/children.js";
-export { Compiler } from "./templating/compiler.js";
-export type { CompilationStrategy } from "./templating/compiler.js";
-export { HTMLBindingDirective } from "./templating/html-binding-directive.js";
-export type { ContentTemplate, ContentView, } from "./templating/html-binding-directive.js";
-export { htmlDirective, HTMLDirective, StatelessAttachedAttributeDirective, } from "./templating/html-directive.js";
-export type { AddViewBehaviorFactory, Aspected, CompiledViewBehaviorFactory, HTMLDirectiveDefinition, PartialHTMLDirectiveDefinition, ViewBehavior, ViewBehaviorFactory, ViewBehaviorTargets, ViewController, } from "./templating/html-directive.js";
-export { Markup, Parser } from "./templating/markup.js";
-export { elements, NodeObservationDirective } from "./templating/node-observation.js";
-export type { ElementsFilter, NodeBehaviorOptions, } from "./templating/node-observation.js";
-export { ref, RefDirective } from "./templating/ref.js";
-export { render, RenderBehavior, RenderDirective } from "./templating/render.js";
-export { repeat, RepeatBehavior, RepeatDirective } from "./templating/repeat.js";
-export type { RepeatOptions } from "./templating/repeat.js";
-export { slotted, SlottedDirective } from "./templating/slotted.js";
-export type { SlottedDirectiveOptions } from "./templating/slotted.js";
-export { html, InlineTemplateDirective, ViewTemplate } from "./templating/template.js";
-export type { CaptureType, ElementViewTemplate, HTMLTemplateCompilationResult, HTMLTemplateTag, SyntheticViewTemplate, TemplateValue, } from "./templating/template.js";
-export { HTMLView, HydrationBindingError } from "./templating/view.js";
-export type { ElementView, HydratableView, SyntheticView, View, } from "./templating/view.js";
-export { when } from "./templating/when.js";
-export { attr, AttributeConfiguration, AttributeDefinition, booleanConverter, nullableBooleanConverter, nullableNumberConverter, } from "./components/attributes.js";
-export type { AttributeMode, DecoratorAttributeConfiguration, ValueConverter, } from "./components/attributes.js";
-export { ElementController, HydratableElementController, needsHydrationAttribute, Stages, type HydrationControllerCallbacks, } from "./components/element-controller.js";
+export { Signal, signal } from "./binding/signal.js";
+export { type TwoWayBindingOptions, TwoWaySettings, twoWay, } from "./binding/two-way.js";
 export type { ElementControllerStrategy } from "./components/element-controller.js";
-export { FASTElementDefinition, fastElementRegistry, TemplateOptions, type TemplateLifecycleCallbacks, } from "./components/fast-definitions.js";
-export type { PartialFASTElementDefinition, ShadowRootOptions, TypeRegistry, } from "./components/fast-definitions.js";
+export { ElementController, Stages, } from "./components/element-controller.js";
+export type { FASTElementExtension, FASTElementTemplateResolver, PartialFASTElementDefinition, ShadowRootOptions, TypeRegistry, } from "./components/fast-definitions.js";
+export { FASTElementDefinition, fastElementRegistry, type TemplateLifecycleCallbacks, } from "./components/fast-definitions.js";
 export { customElement, FASTElement } from "./components/fast-element.js";
-export { deferHydrationAttribute, isHydratable } from "./components/hydration.js";
+export { enableDebug } from "./debug.js";
+export { type ChildListDirectiveOptions, ChildrenDirective, type ChildrenDirectiveOptions, children, type SubtreeDirectiveOptions, } from "./directives/children.js";
+export { type ElementsFilter, elements, type NodeBehaviorOptions, NodeObservationDirective, } from "./directives/node-observation.js";
+export { RefDirective, ref } from "./directives/ref.js";
+export { RepeatBehavior, RepeatDirective, type RepeatOptions, repeat, } from "./directives/repeat.js";
+export { SlottedDirective, type SlottedDirectiveOptions, slotted, } from "./directives/slotted.js";
+export { when } from "./directives/when.js";
+export * from "./dom.js";
+export { type DOMAspectGuards, type DOMElementGuards, type DOMGuards, DOMPolicy, type DOMPolicyOptions, type DOMSinkGuards, } from "./dom-policy.js";
+export type { Callable, Class, Constructable, Disposable, TrustedTypesPolicy, } from "./interfaces.js";
+export { ArrayObserver, type LengthObserver, lengthOf, Sort, type SortObserver, Splice, SpliceStrategy, SpliceStrategySupport, sortedCount, } from "./observation/arrays.js";
+export { type Notifier, PropertyChangeNotifier, type Subscriber, SubscriberSet, } from "./observation/notifier.js";
+export type { Accessor, Expression, ExpressionController, ExpressionNotifier, ExpressionObserver, ObservationRecord, } from "./observation/observable.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
+export { type UpdateQueue, Updates } from "./observation/update-queue.js";
+export { emptyArray, FAST } from "./platform.js";
+export { type AccessCachedPath, type CachedPath, type CachedPathCommon, type CachedPathMap, type ChildrenMap, type DefaultCachedPath, type EventCachedPath, type JSONSchema, type JSONSchemaCommon, type JSONSchemaDefinition, type RegisterPathConfig, type RepeatCachedPath, Schema, schemaRegistry, } from "./schema.js";
+export * from "./state/exports.js";
+export { type CSSTemplateTag, type CSSValue, css } from "./styles/css.js";
+export { CSSDirective, type CSSDirectiveDefinition, cssDirective, } from "./styles/css-directive.js";
+export type { ComposableStyles, ConstructibleStyleStrategy, } from "./styles/element-styles.js";
+export { ElementStyles } from "./styles/element-styles.js";
+export type { HostBehavior, HostController } from "./styles/host.js";
+export type { StyleStrategy, StyleTarget } from "./styles/style-strategy.js";
+export { type CompilationStrategy, Compiler } from "./templating/compiler.js";
+export { type ContentTemplate, type ContentView, HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { type AddViewBehaviorFactory, type Aspected, type CompiledViewBehaviorFactory, HTMLDirective, type HTMLDirectiveDefinition, htmlDirective, type PartialHTMLDirectiveDefinition, StatelessAttachedAttributeDirective, type ViewBehavior, type ViewBehaviorFactory, type ViewBehaviorTargets, type ViewController, } from "./templating/html-directive.js";
+export { Markup, Parser } from "./templating/markup.js";
+export { RenderBehavior, RenderDirective, render } from "./templating/render.js";
+export { type CaptureType, type ElementViewTemplate, type HTMLTemplateCompilationResult, type HTMLTemplateTag, html, InlineTemplateDirective, type SyntheticViewTemplate, type TemplateValue, ViewTemplate, } from "./templating/template.js";
+export { DefaultExecutionContext, type ElementView, HTMLView, type SyntheticView, type View, } from "./templating/view.js";
+export * from "./utilities.js";

package/dist/dts/index.debug.d.ts

@@ -1,2 +1 @@
-import "./debug.js";
 export * from "./index.js";

package/dist/dts/index.rollup.debug.d.ts

@@ -1,2 +1 @@
-import "./debug.js";
 export * from "./index.js";

package/dist/dts/interfaces.d.ts

@@ -56,55 +56,6 @@ export type Mutable<T> = {
  * @public
  */
 export type ParameterDecorator = (target: Object, propertyKey: string | undefined, parameterIndex: number) => void;
-/**
- * The FAST global.
- * @public
- */
-export interface FASTGlobal {
-    /**
-     * The list of loaded versions.
-     */
-    readonly versions: string[];
-    /**
-     * Gets a kernel value.
-     * @param id - The id to get the value for.
-     * @param initialize - Creates the initial value for the id if not already existing.
-     */
-    getById<T>(id: string | number): T | null;
-    getById<T>(id: string | number, initialize: () => T): T;
-    /**
-     * Sends a warning to the developer.
-     * @param code - The warning code to send.
-     * @param values - Values relevant for the warning message.
-     */
-    warn(code: number, values?: Record<string, any>): void;
-    /**
-     * Creates an error.
-     * @param code - The error code to send.
-     * @param values - Values relevant for the error message.
-     */
-    error(code: number, values?: Record<string, any>): Error;
-    /**
-     * Adds debug messages for errors and warnings.
-     * @param messages - The message dictionary to add.
-     * @remarks
-     * Message can include placeholders like $\{name\} which can be
-     * replaced by values passed at runtime.
-     */
-    addMessages(messages: Record<number, string>): void;
-}
-/**
- * Core services that can be shared across FAST instances.
- * @internal
- */
-type KernelServiceId = {
-    readonly updateQueue: string | number;
-    readonly observable: string | number;
-    readonly contextEvent: string | number;
-    readonly elementRegistry: string | number;
-};
-declare let KernelServiceId: KernelServiceId;
-export { KernelServiceId };
 /**
  * Warning and error messages.
  * @internal
@@ -120,6 +71,7 @@ export declare const enum Message {
     onlySetTemplatePolicyOnce = 1207,
     cannotSetTemplatePolicyAfterCompilation = 1208,
     blockedByDOMPolicy = 1209,
+    invalidHydrationAttributeMarker = 1210,
     missingElementDefinition = 1401,
     noRegistrationForContext = 1501,
     noFactoryForResolver = 1502,

package/dist/dts/observable.d.ts

@@ -1,7 +1,4 @@
-/**
- * Observable exports for easy access to the Observable API
- */
-export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
-export type { Accessor, Expression, ExpressionController, ExpressionNotifier, ExpressionObserver, ObservationRecord, } from "./observation/observable.js";
-export { PropertyChangeNotifier, SubscriberSet } from "./observation/notifier.js";
 export type { Notifier, Subscriber } from "./observation/notifier.js";
+export { PropertyChangeNotifier, SubscriberSet } from "./observation/notifier.js";
+export type { Accessor, Expression, ExpressionController, ExpressionNotifier, ExpressionObserver, ObservationRecord, } from "./observation/observable.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, } from "./observation/observable.js";

package/dist/dts/observation/arrays.d.ts

@@ -226,7 +226,7 @@ export declare const ArrayObserver: Readonly<{
      * Enables the array observation mechanism.
      * @remarks
      * Array observation is enabled automatically when using the
-     * {@link RepeatDirective}, so calling this API manually is
+     * `RepeatDirective`, so calling this API manually is
      * not typically necessary.
      */
     readonly enable: () => void;

package/dist/dts/observation/update-queue.d.ts

@@ -1,4 +1,4 @@
-import { type Callable } from "../interfaces.js";
+import type { Callable } from "../interfaces.js";
 /**
  * A work queue used to synchronize writes to the DOM.
  * @public

package/dist/dts/platform.d.ts

@@ -1,10 +1,31 @@
-import { type FASTGlobal } from "./interfaces.js";
-import "./polyfills.js";
 /**
- * The FAST global.
+ * The FAST messaging API for warnings and errors.
  * @public
  */
-export declare const FAST: FASTGlobal;
+export declare const FAST: {
+    /**
+     * Sends a warning to the developer.
+     * @param code - The warning code to send.
+     * @param values - Values relevant for the warning message.
+     */
+    warn(_code: number, _values?: Record<string, any>): void;
+    /**
+     * Creates an error from a code.
+     * @param code - The error code.
+     * @param values - Values relevant for the error message.
+     */
+    error(code: number, _values?: Record<string, any>): Error;
+    /**
+     * Adds debug messages for errors and warnings.
+     * @param messages - The message dictionary to add.
+     */
+    addMessages(messages: Record<number, string>): void;
+};
+/**
+ * Gets the shared debug message lookup.
+ * @internal
+ */
+export declare function getDebugMessageLookup(): Record<number, string>;
 /**
  * A readonly, empty array.
  * @remarks

package/dist/dts/render.d.ts

@@ -0,0 +1,7 @@
+export type { Binding, BindingDirective } from "./binding/binding.js";
+export type { Subscriber } from "./observation/notifier.js";
+export type { Expression, ExpressionObserver } from "./observation/observable.js";
+export type { ContentTemplate } from "./templating/html-binding-directive.js";
+export type { AddViewBehaviorFactory, HTMLDirective, ViewBehavior, ViewBehaviorFactory, ViewController, } from "./templating/html-directive.js";
+export { RenderBehavior, RenderDirective, render } from "./templating/render.js";
+export type { CaptureType } from "./templating/template.js";

package/dist/dts/schema.d.ts

@@ -0,0 +1 @@
+export { type AccessCachedPath, type CachedPath, type CachedPathCommon, type CachedPathMap, type ChildrenMap, type DefaultCachedPath, type EventCachedPath, type JSONSchema, type JSONSchemaCommon, type JSONSchemaDefinition, type RegisterPathConfig, type RepeatCachedPath, Schema, schemaRegistry, } from "./components/schema.js";

package/dist/dts/state/exports.d.ts

@@ -1,3 +1,3 @@
 export { reactive } from "./reactive.js";
-export { watch } from "./watch.js";
 export * from "./state.js";
+export { watch } from "./watch.js";

package/dist/dts/state/state.d.ts

@@ -39,7 +39,7 @@ export type State<T> = ReadonlyState<T> & {
     current: T;
     /**
      * Sets the current state value.
-     * @param value The new state value.
+     * @param value - The new state value.
      */
     set(value: T): void;
     /**
@@ -121,7 +121,7 @@ export type ComputedBuilder = {
     on: {
         /**
          * Provides a setup callback for the computation.
-         * @param callback The callback to run to setup the computation.
+         * @param callback - The callback to run to setup the computation.
          */
         setup(callback: ComputedSetupCallback): void;
     };

package/dist/dts/styles/css-directive.d.ts

@@ -1,22 +1,16 @@
 import type { Constructable } from "../interfaces.js";
-import type { HostBehavior } from "./host.js";
 import type { ComposableStyles } from "./element-styles.js";
 /**
- * Used to add behaviors when constructing styles.
- * @public
- */
-export type AddBehavior = (behavior: HostBehavior<HTMLElement>) => void;
-/**
- * Directive for use in {@link css}.
+ * Directive for use in CSS templates.
  *
  * @public
  */
 export interface CSSDirective {
     /**
-     * Creates a CSS fragment to interpolate into the CSS document.
-     * @returns - the string to interpolate into CSS
+     * Creates static styles to interpolate into the CSS document.
+     * @returns - the styles to interpolate into CSS
      */
-    createCSS(add: AddBehavior): ComposableStyles;
+    createCSS(): ComposableStyles;
 }
 /**
  * Defines metadata for a CSSDirective.
@@ -29,8 +23,7 @@ export interface CSSDirectiveDefinition<TType extends Constructable<CSSDirective
     readonly type: TType;
 }
 /**
- * Instructs the css engine to provide dynamic styles or
- * associate behaviors with styles.
+ * Instructs the css engine to provide styles during CSS template composition.
  * @public
  */
 export declare const CSSDirective: Readonly<{

package/dist/dts/styles/css.d.ts

@@ -1,36 +1,34 @@
-import { Binding } from "../binding/binding.js";
-import type { Expression } from "../observation/observable.js";
 import { CSSDirective } from "./css-directive.js";
 import { type ComposableStyles, ElementStyles } from "./element-styles.js";
 /**
  * Represents the types of values that can be interpolated into a template.
  * @public
  */
-export type CSSValue<TSource, TParent = any> = Expression<TSource, any, TParent> | Binding<TSource, any, TParent> | ComposableStyles | CSSDirective;
+export type CSSValue = ComposableStyles | CSSDirective;
 /**
  * Transforms a template literal string into styles.
  * @param strings - The string fragments that are interpolated with the values.
  * @param values - The values that are interpolated with the string fragments.
  * @remarks
- * The css helper supports interpolation of strings and ElementStyle instances.
+ * The css helper supports interpolation of static composable styles and CSS directives.
  * Use the .partial method to create partial CSS fragments.
  * @public
  */
-export type CSSTemplateTag = (<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]) => ElementStyles) & {
+export type CSSTemplateTag = ((strings: TemplateStringsArray, ...values: CSSValue[]) => ElementStyles) & {
     /**
      * Transforms a template literal string into partial CSS.
      * @param strings - The string fragments that are interpolated with the values.
      * @param values - The values that are interpolated with the string fragments.
      * @public
      */
-    partial<TSource = any, TParent = any>(strings: TemplateStringsArray, ...values: CSSValue<TSource, TParent>[]): CSSDirective;
+    partial(strings: TemplateStringsArray, ...values: CSSValue[]): CSSDirective;
 };
 /**
  * Transforms a template literal string into styles.
  * @param strings - The string fragments that are interpolated with the values.
  * @param values - The values that are interpolated with the string fragments.
  * @remarks
- * The css helper supports interpolation of strings and ElementStyle instances.
+ * The css helper supports interpolation of static composable styles and CSS directives.
  * @public
  */
 export declare const css: CSSTemplateTag;

package/dist/dts/styles/element-styles.d.ts

@@ -1,5 +1,4 @@
 import type { StyleStrategy, StyleTarget } from "./style-strategy.js";
-import type { HostBehavior } from "./host.js";
 /**
  * Represents styles that can be composed into the ShadowDOM of a custom element.
  * @public
@@ -24,10 +23,6 @@ export declare class ElementStyles {
     readonly styles: ReadonlyArray<ComposableStyles>;
     private targets;
     private _strategy;
-    /**
-     * The behaviors associated with this set of styles.
-     */
-    readonly behaviors: ReadonlyArray<HostBehavior<HTMLElement>> | null;
     /**
      * Gets the StyleStrategy associated with these element styles.
      */
@@ -43,11 +38,6 @@ export declare class ElementStyles {
     removeStylesFrom(target: StyleTarget): void;
     /** @internal */
     isAttachedTo(target: StyleTarget): boolean;
-    /**
-     * Associates behaviors with this set of styles.
-     * @param behaviors - The behaviors to associate.
-     */
-    withBehaviors(...behaviors: HostBehavior<HTMLElement>[]): this;
     /**
      * Sets the strategy that handles adding/removing these styles for an element.
      * @param strategy - The strategy to use.

package/dist/dts/styles.d.ts

@@ -0,0 +1,6 @@
+export type { Constructable } from "./interfaces.js";
+export type { ExecutionContext, ExpressionController, SourceLifetime, } from "./observation/observable.js";
+export { CSSDirective, type CSSDirectiveDefinition, cssDirective, } from "./styles/css-directive.js";
+export { type ComposableStyles, type ConstructibleStyleStrategy, ElementStyles, } from "./styles/element-styles.js";
+export type { HostBehavior, HostController } from "./styles/host.js";
+export type { StyleStrategy, StyleTarget } from "./styles/style-strategy.js";

package/dist/dts/templating/children.d.ts

@@ -59,4 +59,4 @@ export declare class ChildrenDirective extends NodeObservationDirective<Children
  * @param propertyOrOptions - The options used to configure child node observation.
  * @public
  */
-export declare function children<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
+export declare function children<TSource = any>(propertyOrOptions: (keyof TSource & string) | ChildrenDirectiveOptions<keyof TSource & string>): CaptureType;

package/dist/dts/templating/html-binding-directive.d.ts

@@ -39,6 +39,10 @@ export interface ContentTemplate {
      */
     create(): ContentView;
 }
+/**
+ * A template capable of hydrating content from existing DOM nodes.
+ * @beta
+ */
 export interface HydratableContentTemplate extends ContentTemplate {
     /**
      * Hydrates a content view from first/last nodes.
@@ -135,6 +139,12 @@ export declare class HTMLBindingDirective implements HTMLDirective, ViewBehavior
      * Re-evaluates the binding expression via observer.bind() and pushes
      * the new value to the DOM through the updateTarget sink function.
      * This is the reactive update path that keeps the DOM in sync with data.
+     *
+     * Guards against stale notifications: when a view is unbound (e.g., after
+     * a parent `when` directive tears down a child element), coupled-lifetime
+     * observers may still hold active subscriptions. If a property change fires
+     * on the source element while the view is inactive, this guard prevents
+     * the binding expression from evaluating with a null source.
      * @internal
      */
     handleChange(binding: Expression, observer: ExpressionObserver): void;

package/dist/dts/templating/html-directive.d.ts

@@ -18,6 +18,23 @@ export interface ViewController<TSource = any, TParent = any> extends Expression
      * The parts of the view that are targeted by view behaviors.
      */
     readonly targets: ViewBehaviorTargets;
+    /**
+     * When true, directives skip attribute/booleanAttribute DOM
+     * updates during bind(). This is an internal flag set only
+     * during the prerendered bind window.
+     * @internal
+     */
+    readonly _skipAttrUpdates?: boolean;
+    /**
+     * Resolves `true` when the view's host element had prerendered
+     * content (existing shadow root).
+     */
+    readonly isPrerendered?: Promise<boolean>;
+    /**
+     * Resolves `true` after prerendered content has been hydrated,
+     * `false` when client-side rendered or hydration not enabled.
+     */
+    readonly isHydrated?: Promise<boolean>;
 }
 /**
  * Represents an object that can contribute behavior to a view.

package/dist/dts/templating/hydration-view.d.ts

@@ -0,0 +1,109 @@
+import { Hydratable } from "../components/hydration.js";
+import { type ViewBehaviorBoundaries } from "../hydration/target-builder.js";
+import { type ExecutionContext, SourceLifetime } from "../observation/observable.js";
+import type { ViewTemplate } from "../templating/template.js";
+import type { ViewBehaviorFactory, ViewBehaviorTargets, ViewController } from "./html-directive.js";
+import { DefaultExecutionContext, type ElementView, type SyntheticView } from "./view.js";
+/** @public */
+export interface HydratableView<TSource = any, TParent = any> extends ElementView, SyntheticView, DefaultExecutionContext<TParent> {
+    [Hydratable]: symbol;
+    readonly bindingViewBoundaries: Record<string, ViewNodes>;
+    readonly hydrationStage: keyof typeof HydrationStage;
+}
+/**
+ * A view controller that can hydrate existing DOM nodes.
+ * @beta
+ */
+export type HydratableViewController<TSource = any, TParent = any> = HydratableView<TSource, TParent> & ViewController<TSource, TParent>;
+/** @public */
+export interface ViewNodes {
+    first: Node;
+    last: Node;
+}
+/** @public */
+export declare const HydrationStage: {
+    readonly unhydrated: "unhydrated";
+    readonly hydrating: "hydrating";
+    readonly hydrated: "hydrated";
+};
+/** @public */
+export declare class HydrationBindingError extends Error {
+    /**
+     * The factory that was unable to be bound
+     */
+    readonly factory: ViewBehaviorFactory;
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    readonly fragment: DocumentFragment;
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    readonly templateString: string;
+    constructor(
+    /**
+     * The error message
+     */
+    message: string | undefined, 
+    /**
+     * The factory that was unable to be bound
+     */
+    factory: ViewBehaviorFactory, 
+    /**
+     * A DocumentFragment containing a clone of the
+     * view's Nodes.
+     */
+    fragment: DocumentFragment, 
+    /**
+     * String representation of the HTML in the template that
+     * threw the binding error.
+     */
+    templateString: string);
+}
+export declare class HydrationView<TSource = any, TParent = any> extends DefaultExecutionContext<TParent> implements HydratableView {
+    readonly firstChild: Node;
+    readonly lastChild: Node;
+    private sourceTemplate;
+    private hostBindingTarget?;
+    [Hydratable]: symbol;
+    context: ExecutionContext<any>;
+    source: TSource | null;
+    isBound: boolean;
+    get hydrationStage(): "unhydrated" | "hydrating" | "hydrated";
+    get targets(): ViewBehaviorTargets;
+    get bindingViewBoundaries(): ViewBehaviorBoundaries;
+    readonly sourceLifetime: SourceLifetime;
+    private unbindables;
+    private fragment;
+    private behaviors;
+    private factories;
+    private _hydrationStage;
+    private _bindingViewBoundaries;
+    private _targets;
+    constructor(firstChild: Node, lastChild: Node, sourceTemplate: ViewTemplate, hostBindingTarget?: Element | undefined);
+    /**
+     * no-op. Hydrated views are don't need to be moved from a documentFragment
+     * to the target node.
+     */
+    insertBefore(node: Node): void;
+    /**
+     * Appends the view to a node. In cases where this is called before the
+     * view has been removed, the method will no-op.
+     * @param node - the node to append the view to.
+     */
+    appendTo(node: Node): void;
+    remove(): void;
+    bind(source: TSource, context?: ExecutionContext<any>): void;
+    unbind(): void;
+    /**
+     * Removes the view and unbinds its behaviors, disposing of DOM nodes afterward.
+     * Once a view has been disposed, it cannot be inserted or bound again.
+     */
+    dispose(): void;
+    onUnbind(behavior: {
+        unbind(controller: ViewController<TSource, TParent>): void;
+    }): void;
+    private evaluateUnbindables;
+}

package/dist/dts/templating/ref.d.ts

@@ -20,4 +20,4 @@ export declare class RefDirective extends StatelessAttachedAttributeDirective<st
  * @param propertyName - The name of the property to assign the reference to.
  * @public
  */
-export declare const ref: <TSource = any, TParent = any>(propertyName: keyof TSource & string) => CaptureType<TSource, TParent>;
+export declare const ref: <TSource = any>(propertyName: keyof TSource & string) => CaptureType;

package/dist/dts/templating/render.d.ts

@@ -35,7 +35,13 @@ export declare class RenderBehavior<TSource = any> implements ViewBehavior, Subs
      * @param controller - The view controller that manages the lifecycle of this behavior.
      */
     unbind(controller: ViewController): void;
-    /** @internal */
+    /**
+     * Handles changes from data or template binding observers.
+     * Guards against stale notifications that may arrive after the
+     * controller's view has been unbound (e.g., when a parent `when`
+     * directive tears down and later recreates a child element).
+     * @internal
+     */
     handleChange(source: any, observer: ExpressionObserver): void;
     private bindView;
     private refreshView;
@@ -308,5 +314,5 @@ export declare class NodeTemplate implements ContentTemplate, ContentView {
  * RenderInstruction to determine the view.
  * @public
  */
-export declare function render<TSource = any, TItem = any, TParent = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node, TParent> | Binding<TSource, ContentTemplate | string | Node, TParent>): CaptureType<TSource, TParent>;
+export declare function render<TSource = any, TItem = any, TParent = any>(value?: Expression<TSource, TItem> | Binding<TSource, TItem> | {}, template?: ContentTemplate | string | Expression<TSource, ContentTemplate | string | Node, TParent> | Binding<TSource, ContentTemplate | string | Node, TParent>): CaptureType;
 export {};

package/dist/dts/templating/repeat.d.ts

@@ -1,5 +1,5 @@
 import type { Binding, BindingDirective } from "../binding/binding.js";
-import { Sort, Splice } from "../observation/arrays.js";
+import { type Sort, type Splice } from "../observation/arrays.js";
 import type { Subscriber } from "../observation/notifier.js";
 import { type Expression, type ExpressionObserver } from "../observation/observable.js";
 import { type AddViewBehaviorFactory, HTMLDirective, type ViewBehavior, type ViewBehaviorFactory, type ViewController } from "./html-directive.js";
@@ -127,4 +127,4 @@ export declare class RepeatDirective<TSource = any> implements HTMLDirective, Vi
  * @param options - Options used to turn on special repeat features.
  * @public
  */
-export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType<TSource, TParent>;
+export declare function repeat<TSource = any, TArray extends ReadonlyArray<any> = ReadonlyArray<any>, TParent = any>(items: Expression<TSource, TArray, TParent> | Binding<TSource, TArray, TParent> | ReadonlyArray<any>, template: Expression<TSource, ViewTemplate<any, TSource>> | Binding<TSource, ViewTemplate<any, TSource>> | ViewTemplate<any, TSource>, options?: RepeatOptions): CaptureType;

package/dist/dts/templating/slotted.d.ts

@@ -35,4 +35,4 @@ export declare class SlottedDirective extends NodeObservationDirective<SlottedDi
  * @param propertyOrOptions - The options used to configure slotted node observation.
  * @public
  */
-export declare function slotted<TSource = any, TParent = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType<TSource, TParent>;
+export declare function slotted<TSource = any>(propertyOrOptions: (keyof TSource & string) | SlottedDirectiveOptions<keyof TSource & string>): CaptureType;