@microsoft/fast-element 2.10.4 → 3.0.0-rc.2

package/dist/esm/hydration/target-builder.js

@@ -1,4 +1,6 @@
 import { HydrationMarkup } from "../components/hydration.js";
+import { getHostName, getHydrationDiagnostic, } from "./diagnostics.js";
+import { expectedContentAfterStartMarker, expectedContentEndMarker, expectedElementBoundaryEndMarker, formatNoMoreAttributeBindings, formatNoMoreContentBindings, } from "./messages.js";
 export class HydrationTargetElementError extends Error {
     constructor(
     /**
@@ -12,10 +14,24 @@ export class HydrationTargetElementError extends Error {
     /**
      * The node to target factory.
      */
-    node) {
+    node, 
+    /**
+     * Structured description of the binding the hydration walk was
+     * attempting to apply when the mismatch was detected. Free-form
+     * string for structural errors that do not correspond to a single
+     * binding factory.
+     */
+    expected, 
+    /**
+     * Structured description of the server-rendered DOM that was
+     * encountered at the mismatch point.
+     */
+    received) {
         super(message);
         this.factories = factories;
         this.node = node;
+        this.expected = expected;
+        this.received = received;
     }
 }
 function isComment(node) {
@@ -39,26 +55,24 @@ export function createRangeForNodes(first, last) {
     range.setEnd(last, isComment(last) || isText(last) ? last.data.length : last.childNodes.length);
     return range;
 }
-function isShadowRoot(node) {
-    return node instanceof DocumentFragment && "mode" in node;
-}
 /**
  * Maps compiled ViewBehaviorFactory IDs to their corresponding DOM nodes in the
  * server-rendered shadow root. Uses a TreeWalker to scan the existing DOM between
- * firstNode and lastNode, parsing hydration markers to build the targets map.
+ * firstNode and lastNode, processing data-free sequential hydration markers.
  *
- * For element nodes: parses `data-fe-b` (or variant) attributes to identify which
- * factories target each element, then removes the marker attribute.
+ * A sequential factory pointer advances through the factories array in DFS order.
+ * Since the template compiler and hydration walker both traverse the DOM in
+ * identical depth-first order, no embedded indices are needed in markers.
  *
- * For comment nodes: parses content binding markers (`fe-b$$start/end$$`) to find
- * the DOM range controlled by each content binding. Single text nodes become the
- * direct target; multi-node ranges are stored in boundaries for structural directives.
- * Element boundary markers (`fe-eb$$start/end$$`) cause the walker to skip over
- * nested custom elements that handle their own hydration.
+ * For element nodes: parses `data-fe="N"` to determine the count of attribute
+ * binding factories, then consumes N factories sequentially.
+ *
+ * For comment nodes: `fe:b` markers consume the next factory for content bindings,
+ * using balanced depth counting for nested marker pairing. `fe:e` markers cause
+ * the walker to skip nested custom element subtrees.
  *
  * Host bindings (targetNodeId='h') appear at the start of the factories array but
- * have no SSR markers — getHydrationIndexOffset() computes how many to skip so that
- * marker indices align with the correct non-host factories.
+ * have no SSR markers — getHydrationIndexOffset() computes the initial pointer value.
  *
  * @param firstNode - The first node of the view.
  * @param lastNode -  The last node of the view.
@@ -68,7 +82,6 @@ function isShadowRoot(node) {
 export function buildViewBindingTargets(firstNode, lastNode, factories) {
     const range = createRangeForNodes(firstNode, lastNode);
     const treeRoot = range.commonAncestorContainer;
-    const hydrationIndexOffset = getHydrationIndexOffset(factories);
     const walker = document.createTreeWalker(treeRoot, NodeFilter.SHOW_ELEMENT + NodeFilter.SHOW_COMMENT + NodeFilter.SHOW_TEXT, {
         acceptNode(node) {
             return range.comparePoint(node, 0) === 0
@@ -78,15 +91,67 @@ export function buildViewBindingTargets(firstNode, lastNode, factories) {
     });
     const targets = {};
     const boundaries = {};
+    // Sequential factory pointer — skip host bindings at the start
+    const hydrationIndexOffset = getHydrationIndexOffset(factories);
+    let factoryPointer = hydrationIndexOffset;
     let node = (walker.currentNode = firstNode);
     while (node !== null) {
         switch (node.nodeType) {
             case Node.ELEMENT_NODE: {
-                targetElement(node, factories, targets, hydrationIndexOffset);
+                const element = node;
+                const legacyIndices = HydrationMarkup.parseLegacyAttributeBindingIndices(element);
+                if (legacyIndices !== null) {
+                    for (const index of legacyIndices) {
+                        const factoryIndex = index + hydrationIndexOffset;
+                        const factory = factories[factoryIndex];
+                        if (!factory) {
+                            const expected = formatNoMoreAttributeBindings(factories.length);
+                            const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+                            throw new HydrationTargetElementError(result.message, factories, element, result.expected, result.received);
+                        }
+                        targetFactory(factory, node, targets);
+                        factoryPointer = Math.max(factoryPointer, factoryIndex + 1);
+                    }
+                    HydrationMarkup.removeLegacyAttributeBindingMarkers(element);
+                    break;
+                }
+                const count = HydrationMarkup.parseAttributeBindingCount(element);
+                if (count !== null) {
+                    for (let i = 0; i < count; i++) {
+                        const factory = factories[factoryPointer++];
+                        if (!factory) {
+                            const expected = formatNoMoreAttributeBindings(factories.length);
+                            const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+                            throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+                        }
+                        targetFactory(factory, node, targets);
+                    }
+                    element.removeAttribute(HydrationMarkup.attributeMarkerName);
+                }
                 break;
             }
             case Node.COMMENT_NODE: {
-                targetComment(node, walker, factories, targets, boundaries, hydrationIndexOffset);
+                const data = node.data;
+                if (HydrationMarkup.isElementBoundaryStartMarker(node)) {
+                    // Element boundary — clear start marker and skip subtree
+                    node.data = "";
+                    skipToElementBoundaryEnd(walker, factories, node);
+                }
+                else if (HydrationMarkup.isContentBindingStartMarker(data)) {
+                    // Content binding — consume next factory
+                    const legacyIndex = HydrationMarkup.parseLegacyContentBindingStartIndex(data);
+                    const factoryIndex = legacyIndex === null
+                        ? factoryPointer++
+                        : legacyIndex + hydrationIndexOffset;
+                    const factory = factories[factoryIndex];
+                    factoryPointer = Math.max(factoryPointer, factoryIndex + 1);
+                    if (!factory) {
+                        const expected = formatNoMoreContentBindings(factories.length);
+                        const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+                        throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+                    }
+                    targetContentBinding(node, walker, factory, factories, targets, boundaries);
+                }
                 break;
             }
         }
@@ -95,100 +160,88 @@ export function buildViewBindingTargets(firstNode, lastNode, factories) {
     range.detach();
     return { targets, boundaries };
 }
-function targetElement(node, factories, targets, hydrationIndexOffset) {
-    var _a, _b;
-    // Check for attributes and map any factories.
-    const attrFactoryIds = (_b = (_a = HydrationMarkup.parseAttributeBinding(node)) !== null && _a !== void 0 ? _a : HydrationMarkup.parseEnumeratedAttributeBinding(node)) !== null && _b !== void 0 ? _b : HydrationMarkup.parseCompactAttributeBinding(node);
-    if (attrFactoryIds !== null) {
-        for (const id of attrFactoryIds) {
-            const factory = factories[id + hydrationIndexOffset];
-            if (!factory) {
-                throw new HydrationTargetElementError(`HydrationView was unable to successfully target factory on ${node.nodeName} inside ${node.getRootNode().host.nodeName}. This likely indicates a template mismatch between SSR rendering and hydration.`, factories, node);
-            }
-            targetFactory(factory, node, targets);
-        }
-        node.removeAttribute(HydrationMarkup.attributeMarkerName);
-    }
-}
-function targetComment(node, walker, factories, targets, boundaries, hydrationIndexOffset) {
-    if (HydrationMarkup.isElementBoundaryStartMarker(node)) {
-        skipToElementBoundaryEndMarker(node, walker);
-        return;
+function targetContentBinding(node, walker, factory, factories, targets, boundaries) {
+    const nodes = [];
+    let current = walker.nextSibling();
+    node.data = "";
+    if (current === null) {
+        const expected = expectedContentAfterStartMarker;
+        const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+        throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
     }
-    if (HydrationMarkup.isContentBindingStartMarker(node.data)) {
-        const parsed = HydrationMarkup.parseContentBindingStartMarker(node.data);
-        if (parsed === null) {
-            return;
-        }
-        const [index, id] = parsed;
-        const factory = factories[index + hydrationIndexOffset];
-        const nodes = [];
-        let current = walker.nextSibling();
-        node.data = "";
-        const first = current;
-        // Search for the binding end marker that closes the binding.
-        while (current !== null) {
-            if (isComment(current)) {
-                const parsed = HydrationMarkup.parseContentBindingEndMarker(current.data);
-                if (parsed && parsed[1] === id) {
+    const first = current;
+    // Balanced depth counting for nested content markers
+    let depth = 0;
+    while (current !== null) {
+        if (isComment(current)) {
+            if (HydrationMarkup.isContentBindingStartMarker(current.data)) {
+                depth++;
+            }
+            else if (HydrationMarkup.isContentBindingEndMarker(current.data)) {
+                if (depth === 0)
                     break;
-                }
+                depth--;
             }
-            nodes.push(current);
-            current = walker.nextSibling();
-        }
-        if (current === null) {
-            const root = node.getRootNode();
-            throw new Error(`Error hydrating Comment node inside "${isShadowRoot(root) ? root.host.nodeName : root.nodeName}".`);
         }
-        current.data = "";
-        if (nodes.length === 1 && isText(nodes[0])) {
-            targetFactory(factory, nodes[0], targets);
-        }
-        else {
-            // If current === first, it means there is no content in
-            // the view. This happens when a `when` directive evaluates false,
-            // or whenever a content binding returns null or undefined.
-            // In that case, there will never be any content
-            // to hydrate and Binding can simply create a HTMLView
-            // whenever it needs to.
-            if (current !== first && current.previousSibling !== null) {
-                boundaries[factory.targetNodeId] = {
-                    first,
-                    last: current.previousSibling,
-                };
-            }
-            // Binding evaluates to null / undefined or a template.
-            // If binding revaluates to string, it will replace content in target
-            // So we always insert a text node to ensure that
-            // text content binding will be written to this text node instead of comment
-            const dummyTextNode = current.parentNode.insertBefore(document.createTextNode(""), current);
-            targetFactory(factory, dummyTextNode, targets);
+        nodes.push(current);
+        current = walker.nextSibling();
+    }
+    if (current === null) {
+        const expected = expectedContentEndMarker;
+        const result = getHydrationDiagnostic().formatStructuralError(node, getHostName(node), expected);
+        throw new HydrationTargetElementError(result.message, factories, node, result.expected, result.received);
+    }
+    current.data = "";
+    if (nodes.length === 1 && isText(nodes[0])) {
+        targetFactory(factory, nodes[0], targets);
+    }
+    else {
+        // If current === first, it means there is no content in
+        // the view. This happens when a `when` directive evaluates false,
+        // or whenever a content binding returns null or undefined.
+        if (current !== first && current.previousSibling !== null) {
+            boundaries[factory.targetNodeId] = {
+                first,
+                last: current.previousSibling,
+            };
         }
+        // Insert a text node so text content binding targets it
+        const dummyTextNode = current.parentNode.insertBefore(document.createTextNode(""), current);
+        targetFactory(factory, dummyTextNode, targets);
     }
 }
 /**
- * Moves TreeWalker to element boundary end marker
- * @param node - element boundary start marker node
- * @param walker - tree walker
+ * Skips past a nested custom element's shadow content using balanced
+ * depth counting to handle nested element boundaries correctly.
  */
-function skipToElementBoundaryEndMarker(node, walker) {
-    const id = HydrationMarkup.parseElementBoundaryStartMarker(node.data);
+function skipToElementBoundaryEnd(walker, factories, startNode) {
+    let depth = 0;
     let current = walker.nextSibling();
     while (current !== null) {
         if (isComment(current)) {
-            const parsed = HydrationMarkup.parseElementBoundaryEndMarker(current.data);
-            if (parsed && parsed === id) {
-                break;
+            if (HydrationMarkup.isElementBoundaryStartMarker(current)) {
+                current.data = "";
+                depth++;
+            }
+            else if (HydrationMarkup.isElementBoundaryEndMarker(current)) {
+                if (depth === 0) {
+                    current.data = "";
+                    return;
+                }
+                current.data = "";
+                depth--;
             }
         }
         current = walker.nextSibling();
     }
+    const expected = expectedElementBoundaryEndMarker;
+    const result = getHydrationDiagnostic().formatStructuralError(startNode, getHostName(startNode), expected);
+    throw new HydrationTargetElementError(result.message, factories, startNode, result.expected, result.received);
 }
 /**
  * Counts how many factories at the start of the array are host bindings (targetNodeId='h').
  * Host bindings target the custom element itself and are not represented by SSR markers,
- * so the marker indices must be offset by this count to align with the correct factory.
+ * so the factory pointer must start past them.
  */
 function getHydrationIndexOffset(factories) {
     let offset = 0;

package/dist/esm/hydration.js

@@ -0,0 +1,6 @@
+export { deferHydrationAttribute, enableHydration, StopHydration, } from "./components/enable-hydration.js";
+export { isHydratable } from "./components/hydration.js";
+export { HydrationTracker } from "./components/hydration-tracker.js";
+export { DOMPolicy, } from "./dom-policy.js";
+export { hydrationDebugger } from "./hydration/hydration-debugger.js";
+export { HydrationBindingError, HydrationStage, } from "./templating/hydration-view.js";

package/dist/esm/index.debug.js

@@ -1,2 +1,3 @@
-import "./debug.js";
+import { enableDebug } from "./debug.js";
+enableDebug();
 export * from "./index.js";

package/dist/esm/index.js

@@ -1,39 +1,48 @@
-export { emptyArray, FAST } from "./platform.js";
-// DOM
-export { DOM, DOMAspect } from "./dom.js";
-// Observation
-export { ArrayObserver, lengthOf, Sort, sortedCount, Splice, SpliceStrategy, SpliceStrategySupport, } from "./observation/arrays.js";
-export { PropertyChangeNotifier, SubscriberSet, } from "./observation/notifier.js";
-export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
-export { Updates } from "./observation/update-queue.js";
+/**
+ * Core APIs for building standards-based Web Components with FAST Element.
+ * @packageDocumentation
+ */
+// Kernel
+// Components
+export { AttributeConfiguration, AttributeDefinition, attr, booleanConverter, nullableBooleanConverter, nullableNumberConverter, } from "./attr.js";
 // Binding
 export { Binding } 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 { Signal, signal } from "./binding/signal.js";
+export { TwoWaySettings, twoWay, } from "./binding/two-way.js";
+export { ElementController, Stages, } from "./components/element-controller.js";
+export { FASTElementDefinition, fastElementRegistry, } from "./components/fast-definitions.js";
+export { customElement, FASTElement, } from "./components/fast-element.js";
+export { enableDebug } from "./debug.js";
+// Directives
+export { ChildrenDirective, children, } from "./directives/children.js";
+export { elements, NodeObservationDirective, } from "./directives/node-observation.js";
+export { RefDirective, ref } from "./directives/ref.js";
+export { RepeatBehavior, RepeatDirective, repeat, } from "./directives/repeat.js";
+export { SlottedDirective, slotted, } from "./directives/slotted.js";
+export { when } from "./directives/when.js";
+export { DOM, DOMAspect } from "./dom.js";
+export { DOMPolicy, } from "./dom-policy.js";
+export { ArrayObserver, lengthOf, Sort, Splice, SpliceStrategy, SpliceStrategySupport, sortedCount, } from "./observation/arrays.js";
+// Observation
+export { PropertyChangeNotifier, SubscriberSet, } from "./observation/notifier.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
+export { Updates } from "./observation/update-queue.js";
+export { emptyArray, FAST } from "./platform.js";
+export { Schema, schemaRegistry, } from "./schema.js";
+export * from "./state/exports.js";
 // Styles
-export { CSSBindingDirective } from "./styles/css-binding-directive.js";
-export { cssDirective, CSSDirective, } from "./styles/css-directive.js";
 export { css } from "./styles/css.js";
-export { ElementStyles, } from "./styles/element-styles.js";
-export {} from "./styles/host.js";
+export { CSSDirective, cssDirective, } from "./styles/css-directive.js";
+export { ElementStyles } from "./styles/element-styles.js";
 // Templating
-export { children, ChildrenDirective } from "./templating/children.js";
 export { Compiler } from "./templating/compiler.js";
-export { HTMLBindingDirective } from "./templating/html-binding-directive.js";
-export { htmlDirective, HTMLDirective, StatelessAttachedAttributeDirective, } from "./templating/html-directive.js";
+export { HTMLBindingDirective, } from "./templating/html-binding-directive.js";
+export { HTMLDirective, htmlDirective, StatelessAttachedAttributeDirective, } from "./templating/html-directive.js";
 export { Markup, Parser } from "./templating/markup.js";
-export { elements, NodeObservationDirective } 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 { slotted, SlottedDirective } from "./templating/slotted.js";
-export { html, InlineTemplateDirective, ViewTemplate } from "./templating/template.js";
-export { HTMLView, HydrationBindingError } from "./templating/view.js";
-export { when } from "./templating/when.js";
-// Components
-export { attr, AttributeConfiguration, AttributeDefinition, booleanConverter, nullableBooleanConverter, nullableNumberConverter, } from "./components/attributes.js";
-export { ElementController, HydratableElementController, needsHydrationAttribute, Stages, } from "./components/element-controller.js";
-export { FASTElementDefinition, fastElementRegistry, TemplateOptions, } from "./components/fast-definitions.js";
-export { customElement, FASTElement } from "./components/fast-element.js";
-export { deferHydrationAttribute, isHydratable } from "./components/hydration.js";
+export { RenderBehavior, RenderDirective, render } from "./templating/render.js";
+export { html, InlineTemplateDirective, ViewTemplate, } from "./templating/template.js";
+export { DefaultExecutionContext, HTMLView, } from "./templating/view.js";
+export * from "./utilities.js";

package/dist/esm/index.rollup.debug.js

@@ -1,5 +1,6 @@
-import "./debug.js";
-import { DOMPolicy } from "./dom-policy.js";
+import { enableDebug } from "./debug.js";
 import { DOM } from "./dom.js";
+import { DOMPolicy } from "./dom-policy.js";
+enableDebug();
 export * from "./index.js";
 DOM.setPolicy(DOMPolicy.create());

package/dist/esm/index.rollup.js

@@ -1,4 +1,4 @@
-import { DOMPolicy } from "./dom-policy.js";
 import { DOM } from "./dom.js";
+import { DOMPolicy } from "./dom-policy.js";
 export * from "./index.js";
 DOM.setPolicy(DOMPolicy.create());

package/dist/esm/interfaces.js

@@ -1,48 +1,3 @@
-let kernelMode;
-const kernelAttr = "fast-kernel";
-try {
-    if (document.currentScript) {
-        kernelMode = document.currentScript.getAttribute(kernelAttr);
-    }
-    else {
-        const scripts = document.getElementsByTagName("script");
-        const currentScript = scripts[scripts.length - 1];
-        kernelMode = currentScript.getAttribute(kernelAttr);
-    }
-}
-catch (e) {
-    kernelMode = "isolate";
-}
-let KernelServiceId;
-switch (kernelMode) {
-    case "share": // share the kernel across major versions
-        KernelServiceId = Object.freeze({
-            updateQueue: 1,
-            observable: 2,
-            contextEvent: 3,
-            elementRegistry: 4,
-        });
-        break;
-    case "share-v2": // only share the kernel with other v2 instances
-        KernelServiceId = Object.freeze({
-            updateQueue: 1.2,
-            observable: 2.2,
-            contextEvent: 3.2,
-            elementRegistry: 4.2,
-        });
-        break;
-    default:
-        // fully isolate the kernel from all other FAST instances
-        const postfix = `-${Math.random().toString(36).substring(2, 8)}`;
-        KernelServiceId = Object.freeze({
-            updateQueue: `1.2${postfix}`,
-            observable: `2.2${postfix}`,
-            contextEvent: `3.2${postfix}`,
-            elementRegistry: `4.2${postfix}`,
-        });
-        break;
-}
-export { KernelServiceId };
 /**
  * Warning and error messages.
  * @internal
@@ -62,6 +17,8 @@ export var Message;
     Message[Message["onlySetTemplatePolicyOnce"] = 1207] = "onlySetTemplatePolicyOnce";
     Message[Message["cannotSetTemplatePolicyAfterCompilation"] = 1208] = "cannotSetTemplatePolicyAfterCompilation";
     Message[Message["blockedByDOMPolicy"] = 1209] = "blockedByDOMPolicy";
+    Message[Message["invalidHydrationAttributeMarker"] = 1210] = "invalidHydrationAttributeMarker";
+    Message[Message["duplicateRenderInstruction"] = 1211] = "duplicateRenderInstruction";
     // 1301 - 1400 Styles
     // 1401 - 1500 Components
     Message[Message["missingElementDefinition"] = 1401] = "missingElementDefinition";

package/dist/esm/metadata.js

@@ -34,19 +34,13 @@ export const Metadata = Object.freeze({
      * @param Type - The type to get the metadata for.
      * @returns The metadata array or a frozen empty array if no metadata is found.
      */
-    getDesignParamTypes: (Type) => {
-        var _a;
-        return ((_a = Reflect.getOwnMetadata(designParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray);
-    },
+    getDesignParamTypes: (Type) => { var _a; return ((_a = Reflect.getOwnMetadata(designParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray); },
     /**
      * Gets the "annotation:paramtypes" metadata for the specified type.
      * @param Type - The type to get the metadata for.
      * @returns The metadata array or a frozen empty array if no metadata is found.
      */
-    getAnnotationParamTypes: (Type) => {
-        var _a;
-        return ((_a = Reflect.getOwnMetadata(annotationParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray);
-    },
+    getAnnotationParamTypes: (Type) => { var _a; return ((_a = Reflect.getOwnMetadata(annotationParamTypesKey, Type)) !== null && _a !== void 0 ? _a : emptyArray); },
     /**
      * Gets the "annotation:paramtypes" metadata for the specified type. If none is found,
      * an empty, mutable metadata array is created and added.

package/dist/esm/observable.js

@@ -1,5 +1,2 @@
-/**
- * Observable exports for easy access to the Observable API
- */
-export { ExecutionContext, Observable, observable, SourceLifetime, volatile, } from "./observation/observable.js";
 export { PropertyChangeNotifier, SubscriberSet } from "./observation/notifier.js";
+export { ExecutionContext, Observable, observable, SourceLifetime, } from "./observation/observable.js";

package/dist/esm/observation/arrays.js

@@ -589,7 +589,7 @@ export const ArrayObserver = Object.freeze({
      * 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.
      */
     enable() {

package/dist/esm/observation/notifier.js

@@ -138,12 +138,10 @@ export class PropertyChangeNotifier {
         var _a, _b;
         let subscribers;
         if (propertyToWatch) {
-            subscribers =
-                (_a = this.subscribers[propertyToWatch]) !== null && _a !== void 0 ? _a : (this.subscribers[propertyToWatch] = new SubscriberSet(this.subject));
+            subscribers = (_a = this.subscribers[propertyToWatch]) !== null && _a !== void 0 ? _a : (this.subscribers[propertyToWatch] = new SubscriberSet(this.subject));
         }
         else {
-            subscribers =
-                (_b = this.subjectSubscribers) !== null && _b !== void 0 ? _b : (this.subjectSubscribers = new SubscriberSet(this.subject));
+            subscribers = (_b = this.subjectSubscribers) !== null && _b !== void 0 ? _b : (this.subjectSubscribers = new SubscriberSet(this.subject));
         }
         subscribers.subscribe(subscriber);
     }

package/dist/esm/observation/observable.js

@@ -1,4 +1,4 @@
-import { isFunction, isString, KernelServiceId, Message, } from "../interfaces.js";
+import { isFunction, isString, Message, } from "../interfaces.js";
 import { createMetadataLocator, FAST, makeSerializationNoop } from "../platform.js";
 import { PropertyChangeNotifier, SubscriberSet } from "./notifier.js";
 import { Updates } from "./update-queue.js";
@@ -21,7 +21,7 @@ export const SourceLifetime = Object.freeze({
  * Common Observable APIs.
  * @public
  */
-export const Observable = FAST.getById(KernelServiceId.observable, () => {
+export const Observable = (() => {
     const queueUpdate = Updates.enqueue;
     const volatileRegex = /(:|&&|\|\||if|\?\.)/;
     const notifierLookup = new WeakMap();
@@ -264,7 +264,7 @@ export const Observable = FAST.getById(KernelServiceId.observable, () => {
             return volatileRegex.test(expression.toString());
         },
     });
-});
+})();
 /**
  * Decorator: Defines an observable property on the target.
  * @param target - The target to define the observable on.
@@ -289,7 +289,7 @@ export function volatile(target, name, descriptor) {
         },
     });
 }
-const contextEvent = FAST.getById(KernelServiceId.contextEvent, () => {
+const contextEvent = (() => {
     let current = null;
     return {
         get() {
@@ -299,7 +299,7 @@ const contextEvent = FAST.getById(KernelServiceId.contextEvent, () => {
             current = event;
         },
     };
-});
+})();
 /**
  * Provides additional contextual information available to behaviors and expressions.
  * @public