@player-ui/player 0.15.3 → 0.15.4--canary.881.37421

package/dist/index.mjs

@@ -2646,13 +2646,13 @@ var ValidatorRegistry = class {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/view.ts
-import { SyncHook as SyncHook4 } from "tapable-ts";
+import { SyncHook as SyncHook9 } from "tapable-ts";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/resolver/index.ts
-import { SyncHook as SyncHook3, SyncWaterfallHook as SyncWaterfallHook5 } from "tapable-ts";
-import { addLast, clone, setIn as setIn5 } from "timm";
+import { SyncHook as SyncHook8, SyncWaterfallHook as SyncWaterfallHook9 } from "tapable-ts";
+import { addLast, clone, setIn as setIn6 } from "timm";
 import dlv from "dlv";
-import { dequal } from "dequal";
+import { dequal as dequal2 } from "dequal";
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/parser/index.ts
 import { setIn as setIn4 } from "timm";
@@ -2828,978 +2828,1128 @@ function toNodeResolveOptions(resolverOptions) {
   };
 }
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/resolver/index.ts
-var withContext = (model) => {
-  return {
-    get: (binding, options) => {
-      return model.get(binding, {
-        context: { model },
-        ...options
-      });
-    },
-    set: (transaction, options) => {
-      return model.set(transaction, {
-        context: { model },
-        ...options
-      });
-    },
-    delete: (binding, options) => {
-      return model.delete(binding, {
-        context: { model },
-        ...options
-      });
-    }
-  };
-};
-var Resolver = class {
-  constructor(root, options) {
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/resolver/types.ts
+var ResolverStage = /* @__PURE__ */ ((ResolverStage2) => {
+  ResolverStage2["ResolveOptions"] = "resolveOptions";
+  ResolverStage2["SkipResolve"] = "skipResolve";
+  ResolverStage2["BeforeResolve"] = "beforeResolve";
+  ResolverStage2["Resolve"] = "resolve";
+  ResolverStage2["AfterResolve"] = "afterResolve";
+  ResolverStage2["AfterNodeUpdate"] = "afterNodeUpdate";
+  return ResolverStage2;
+})(ResolverStage || {});
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/flow/flow.ts
+import { SyncBailHook as SyncBailHook4, SyncHook as SyncHook3, SyncWaterfallHook as SyncWaterfallHook5 } from "tapable-ts";
+import defer from "p-defer";
+var FlowInstance = class {
+  constructor(id, flow, options) {
+    this.isTransitioning = false;
     this.hooks = {
-      skipResolve: new SyncWaterfallHook5(),
-      beforeUpdate: new SyncHook3(),
-      afterUpdate: new SyncHook3(),
-      resolveOptions: new SyncWaterfallHook5(),
-      beforeResolve: new SyncWaterfallHook5(),
-      resolve: new SyncWaterfallHook5(),
-      afterResolve: new SyncWaterfallHook5(),
-      afterNodeUpdate: new SyncHook3()
+      beforeStart: new SyncBailHook4(),
+      onStart: new SyncHook3(),
+      onEnd: new SyncHook3(),
+      skipTransition: new SyncBailHook4(),
+      beforeTransition: new SyncWaterfallHook5(),
+      resolveTransitionNode: new SyncWaterfallHook5(),
+      transition: new SyncHook3(),
+      afterTransition: new SyncHook3()
     };
-    this.root = root;
-    this.options = options;
-    this.resolveCache = /* @__PURE__ */ new Map();
-    this.ASTMap = /* @__PURE__ */ new Map();
-    this.logger = options.logger;
-    this.idCache = /* @__PURE__ */ new Set();
-  }
-  getSourceNode(convertedAST) {
-    return this.ASTMap.get(convertedAST);
-  }
-  update(dataChanges, nodeChanges) {
-    this.hooks.beforeUpdate.call(dataChanges);
-    const resolveCache = /* @__PURE__ */ new Map();
-    this.idCache.clear();
-    const prevASTMap = new Map(this.ASTMap);
-    this.ASTMap.clear();
-    const realNodeChanges = /* @__PURE__ */ new Set();
-    for (const node of nodeChanges?.values() ?? []) {
-      let current = node;
-      while (current) {
-        const original = prevASTMap.get(current) ?? current;
-        if (realNodeChanges.has(original)) {
-          break;
+    this.id = id;
+    this.flow = flow;
+    this.log = options?.logger;
+    this.history = [];
+    this.hooks.transition.tap(
+      "startPromise",
+      async (_oldState, nextState) => {
+        const newState = nextState.value;
+        if (this.flowPromise && newState.state_type === "END") {
+          this.flowPromise.resolve(newState);
         }
-        realNodeChanges.add(original);
-        current = current.parent;
       }
-    }
-    const updated = this.computeTree(
-      this.root,
-      void 0,
-      dataChanges,
-      resolveCache,
-      toNodeResolveOptions(this.options),
-      void 0,
-      prevASTMap,
-      realNodeChanges
     );
-    this.resolveCache = resolveCache;
-    this.hooks.afterUpdate.call(updated.value);
-    return updated.value;
   }
-  getResolveCache() {
-    return new Map(this.resolveCache);
+  /** Start the state machine */
+  async start() {
+    if (this.flowPromise) {
+      this.log?.warn("Already called start for flow");
+      return this.flowPromise.promise;
+    }
+    this.flow = this.hooks.beforeStart.call(this.flow) || this.flow;
+    if (this.flow.onStart) {
+      this.hooks.onStart.call(this.flow.onStart);
+    }
+    const initialState = this.flow.startState;
+    if (!initialState) {
+      return Promise.reject(new Error("No 'startState' defined for flow"));
+    }
+    this.flowPromise = defer();
+    this.pushHistory(initialState);
+    return this.flowPromise.promise;
   }
-  getPreviousResult(node) {
-    if (!node) {
-      return;
+  /**
+   * Get the flow-level error transitions map
+   */
+  getFlowErrorTransitions() {
+    return this.flow.errorTransitions;
+  }
+  /**
+   * Helper to lookup a key in a map with wildcard fallback
+   */
+  lookupInMap(map, key) {
+    if (!map)
+      return void 0;
+    return map[key] || map["*"];
+  }
+  /** Check if the flow has a transition for the given error type in its current state. */
+  getErrorTransitionState(errorType) {
+    if (this.currentState?.value.state_type === "END") {
+      this.log?.warn("Cannot error transition from END state");
+      return void 0;
     }
-    const isFirstUpdate = this.resolveCache.size === 0;
-    const id = getNodeID(node);
-    if (id) {
-      if (this.idCache.has(id)) {
-        if (isFirstUpdate) {
-          if (node.type === "asset" /* Asset */ || node.type === "view" /* View */) {
-            this.logger?.error(
-              `Cache conflict: Found Asset/View nodes that have conflicting ids: ${id}, may cause cache issues.`
-            );
-          } else if (node.type === "value" /* Value */) {
-            this.logger?.info(
-              `Cache conflict: Found Value nodes that have conflicting ids: ${id}, may cause cache issues. To improve performance make value node IDs globally unique.`
-            );
-          }
+    if (this.currentState) {
+      const nodeState = this.lookupInMap(
+        this.currentState.value.errorTransitions,
+        errorType
+      );
+      if (nodeState) {
+        if (!Object.prototype.hasOwnProperty.call(this.flow, nodeState)) {
+          this.log?.debug(
+            `Node-level errorTransition references non-existent state "${nodeState}", trying flow-level fallback`
+          );
+        } else {
+          this.log?.debug(
+            `Error transition (node-level) from ${this.currentState.name} to ${nodeState} using ${errorType}`
+          );
+          return nodeState;
         }
-        return;
       }
-      this.idCache.add(id);
     }
-    return this.resolveCache.get(node);
+    const flowState = this.lookupInMap(this.flow.errorTransitions, errorType);
+    if (flowState) {
+      if (!Object.prototype.hasOwnProperty.call(this.flow, flowState)) {
+        this.log?.debug(
+          `Flow-level errorTransition references non-existent state "${flowState}"`
+        );
+      } else {
+        this.log?.debug(
+          `Error transition (flow-level) to ${flowState} using ${errorType}${this.currentState ? ` from ${this.currentState.name}` : ""}`
+        );
+        return flowState;
+      }
+    }
+    return void 0;
   }
-  cloneNode(node) {
-    const clonedNode = clone(node);
-    Object.keys(clonedNode).forEach((key) => {
-      if (key === "parent")
+  /**
+   * Navigate using errorTransitions map.
+   * Tries node-level first, then falls back to flow-level.
+   * Bypasses validation hooks and expression resolution.
+   * @throws Error if errorTransitions references a non-existent state
+   */
+  errorTransition(errorType) {
+    const transitionState = this.getErrorTransitionState(errorType);
+    if (transitionState === void 0) {
+      this.log?.warn(
+        `No errorTransition found for ${errorType} (checked node and flow level)`
+      );
+      return;
+    }
+    this.pushHistory(transitionState);
+  }
+  transition(transitionValue, options) {
+    if (this.isTransitioning) {
+      throw new Error(
+        `Transitioning while ongoing transition from ${this.currentState?.name} is in progress is not supported`
+      );
+    }
+    if (this.currentState?.value.state_type === "END") {
+      this.log?.warn(
+        `Skipping transition using ${transitionValue}. Already at END state`
+      );
+      return;
+    }
+    if (this.currentState === void 0) {
+      throw new Error("Cannot transition when there's no current state");
+    }
+    const currentState = this.currentState.value;
+    if (options?.force) {
+      this.log?.debug(`Forced transition. Skipping validation checks`);
+    } else {
+      const skipTransition = this.hooks.skipTransition.call(this.currentState);
+      if (skipTransition) {
+        this.log?.debug(
+          `Skipping transition from ${this.currentState.name} b/c hook told us to`
+        );
         return;
-      const value = clonedNode[key];
-      if (typeof value === "object" && value !== null) {
-        clonedNode[key] = Array.isArray(value) ? [...value] : { ...value };
       }
-    });
-    return clonedNode;
-  }
-  computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap, nodeChanges) {
-    const dependencyModel = new DependencyModel(options.data.model);
-    dependencyModel.trackSubset("core");
-    const depModelWithParser = withContext(
-      withParser(dependencyModel, this.options.parseBinding)
-    );
-    const resolveOptions = this.hooks.resolveOptions.call(
-      {
-        ...options,
-        data: {
-          ...options.data,
-          model: depModelWithParser
-        },
-        evaluate: (exp) => this.options.evaluator.evaluate(exp, { model: depModelWithParser }),
-        node
-      },
-      node
-    );
-    const previousResult = this.getPreviousResult(node);
-    const previousDeps = previousResult?.dependencies;
-    const isChanged = nodeChanges.has(node);
-    const dataChanged = caresAboutDataChanges(dataChanges, previousDeps);
-    const shouldUseLastValue = this.hooks.skipResolve.call(
-      !dataChanged && !isChanged,
-      node,
-      resolveOptions
-    );
-    if (previousResult && shouldUseLastValue) {
-      const update2 = {
-        ...previousResult,
-        updated: false
-      };
-      const repopulateASTMapFromCache = (resolvedNode, AST, ASTParent) => {
-        const { node: resolvedASTLocal } = resolvedNode;
-        this.ASTMap.set(resolvedASTLocal, AST);
-        const resolvedUpdate = {
-          ...resolvedNode,
-          updated: false
-        };
-        cacheUpdate.set(AST, resolvedUpdate);
-        const handleChildNode = (childNode) => {
-          const originalChildNode = prevASTMap.get(childNode) ?? childNode;
-          const previousChildResult = this.getPreviousResult(originalChildNode);
-          if (!previousChildResult)
-            return;
-          repopulateASTMapFromCache(
-            previousChildResult,
-            originalChildNode,
-            AST
-          );
-        };
-        if ("children" in resolvedASTLocal) {
-          resolvedASTLocal.children?.forEach(
-            ({ value: childAST }) => handleChildNode(childAST)
-          );
-        } else if (resolvedASTLocal.type === "multi-node" /* MultiNode */) {
-          resolvedASTLocal.values.forEach(handleChildNode);
-        }
-        this.hooks.afterNodeUpdate.call(AST, ASTParent, resolvedUpdate);
-      };
-      previousResult.node.parent = partiallyResolvedParent;
-      repopulateASTMapFromCache(previousResult, node, rawParent);
-      return update2;
     }
-    const clonedNode = {
-      ...this.cloneNode(node),
-      parent: partiallyResolvedParent
-    };
-    const resolvedAST = this.hooks.beforeResolve.call(
-      clonedNode,
-      resolveOptions
-    ) ?? {
-      type: "empty" /* Empty */
-    };
-    resolvedAST.parent = partiallyResolvedParent;
-    resolveOptions.node = resolvedAST;
-    this.ASTMap.set(resolvedAST, node);
-    let resolved = this.hooks.resolve.call(
-      void 0,
-      resolvedAST,
-      resolveOptions
+    const state = this.hooks.beforeTransition.call(
+      currentState,
+      transitionValue
     );
-    let updated = !dequal(previousResult?.value, resolved);
-    if (previousResult && !updated) {
-      resolved = previousResult?.value;
+    if (!("transitions" in state)) {
+      throw new Error(`No transitions defined for ${this.currentState.value}`);
     }
-    const childDependencies = /* @__PURE__ */ new Set();
-    dependencyModel.trackSubset("children");
-    if ("children" in resolvedAST) {
-      const newChildren = resolvedAST.children?.map((child) => {
-        const computedChildTree = this.computeTree(
-          child.value,
-          node,
-          dataChanges,
-          cacheUpdate,
-          resolveOptions,
-          resolvedAST,
-          prevASTMap,
-          nodeChanges
-        );
-        const {
-          dependencies: childTreeDeps,
-          node: childNode,
-          updated: childUpdated,
-          value: childValue
-        } = computedChildTree;
-        childTreeDeps.forEach((binding) => childDependencies.add(binding));
-        if (childValue) {
-          if (childNode.type === "multi-node" /* MultiNode */ && !childNode.override) {
-            const arr = addLast(
-              dlv(resolved, child.path, []),
-              childValue
-            );
-            resolved = setIn5(resolved, child.path, arr);
-          } else {
-            resolved = setIn5(resolved, child.path, childValue);
-          }
-        }
-        updated = updated || childUpdated;
-        return { ...child, value: childNode };
-      });
-      resolvedAST.children = newChildren;
-    } else if (resolvedAST.type === "multi-node" /* MultiNode */) {
-      const childValue = [];
-      const rawParentToPassIn = node;
-      resolvedAST.values = resolvedAST.values.map((mValue) => {
-        const mTree = this.computeTree(
-          mValue,
-          rawParentToPassIn,
-          dataChanges,
-          cacheUpdate,
-          resolveOptions,
-          resolvedAST,
-          prevASTMap,
-          nodeChanges
-        );
-        if (mTree.value !== void 0 && mTree.value !== null) {
-          mTree.dependencies.forEach(
-            (bindingDep) => childDependencies.add(bindingDep)
-          );
-          updated = updated || mTree.updated;
-          childValue.push(mTree.value);
-        }
-        return mTree.node;
-      });
-      resolved = childValue;
+    const { transitions } = state;
+    const nextState = transitions[transitionValue] || transitions["*"];
+    if (nextState === void 0) {
+      this.log?.warn(
+        `No transition from ${this.currentState.name} using ${transitionValue} or *`
+      );
+      return;
     }
-    childDependencies.forEach(
-      (bindingDep) => dependencyModel.addChildReadDep(bindingDep)
+    this.log?.debug(
+      `Transitioning from ${this.currentState.name} to ${nextState} using ${transitionValue} `
     );
-    dependencyModel.trackSubset("core");
-    if (previousResult && !updated) {
-      resolved = previousResult?.value;
-    }
-    resolved = this.hooks.afterResolve.call(resolved, resolvedAST, {
-      ...resolveOptions,
-      getDependencies: (scope) => dependencyModel.getDependencies(scope)
-    });
-    const update = {
-      node: resolvedAST,
-      updated,
-      value: resolved,
-      dependencies: /* @__PURE__ */ new Set([
-        ...dependencyModel.getDependencies(),
-        ...childDependencies
-      ])
-    };
-    this.hooks.afterNodeUpdate.call(node, rawParent, update);
-    cacheUpdate.set(node, update);
-    return update;
-  }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/view.ts
-var CrossfieldProvider = class {
-  constructor(initialView, parser, logger) {
-    this.allValidations = /* @__PURE__ */ new Set();
-    this.byBinding = /* @__PURE__ */ new Map();
-    this.logger = logger;
-    this.parse(initialView, parser);
+    return this.pushHistory(nextState, options);
   }
-  parse(contentView, parser) {
-    const xfieldRefs = contentView.validation;
-    if (xfieldRefs === void 0) {
-      return;
+  pushHistory(stateName, options) {
+    if (!Object.prototype.hasOwnProperty.call(this.flow, stateName)) {
+      throw new Error(`No flow definition for: ${stateName} was found.`);
     }
-    if (!Array.isArray(xfieldRefs)) {
-      this.logger?.warn(
-        `Unable to register view validations for id: ${contentView.id}. 'validation' property must be an Array.`
-      );
+    let nextState = this.flow[stateName];
+    if (!this.flow[stateName] || typeof nextState !== "object" || !("state_type" in nextState)) {
+      this.log?.error(`Flow doesn't contain any states named: ${stateName}`);
       return;
     }
-    xfieldRefs.forEach((vRef) => {
-      const withDefaults = {
-        trigger: "navigation",
-        severity: "error",
-        ...vRef
-      };
-      this.allValidations.add(withDefaults);
-      const { ref } = vRef;
-      if (ref) {
-        const parsed = parser(ref);
-        if (this.byBinding.has(parsed)) {
-          this.byBinding.get(parsed)?.push(withDefaults);
-        } else {
-          this.byBinding.set(parsed, [withDefaults]);
-        }
-      }
+    const prevState = this.currentState;
+    this.isTransitioning = true;
+    nextState = this.hooks.resolveTransitionNode.call(
+      nextState
+    );
+    const newCurrentState = {
+      name: stateName,
+      value: nextState
+    };
+    this.currentState = newCurrentState;
+    this.history.push(stateName);
+    if (newCurrentState.value.state_type === "END" && this.flow.onEnd) {
+      this.hooks.onEnd.call(this.flow.onEnd);
+    }
+    this.hooks.transition.call(prevState, {
+      ...newCurrentState
     });
-  }
-  getValidationsForBinding(binding) {
-    return this.byBinding.get(binding);
+    this.isTransitioning = false;
+    this.hooks.afterTransition.call(this);
   }
 };
-var ViewInstance = class {
-  constructor(initialView, resolverOptions) {
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/flow/controller.ts
+import { SyncHook as SyncHook4 } from "tapable-ts";
+var FlowController = class {
+  constructor(navigation, options) {
     this.hooks = {
-      onUpdate: new SyncHook4(),
-      parser: new SyncHook4(),
-      resolver: new SyncHook4(),
-      templatePlugin: new SyncHook4()
+      flow: new SyncHook4()
     };
-    this.initialView = initialView;
-    this.resolverOptions = resolverOptions;
+    this.navigation = navigation;
+    this.navStack = [];
+    this.log = options?.logger;
+    this.start = this.start.bind(this);
+    this.run = this.run.bind(this);
+    this.transition = this.transition.bind(this);
+    this.addNewFlow = this.addNewFlow.bind(this);
   }
-  /** @deprecated use ViewController.updateViewAST */
-  updateAsync(asyncNode) {
-    const update = this.resolver?.update();
-    this.lastUpdate = update;
-    this.hooks.onUpdate.call(update);
+  /** Navigate to another state in the state-machine */
+  transition(stateTransition, options) {
+    if (this.current === void 0) {
+      throw new Error("Not currently in a flow. Cannot transition.");
+    }
+    this.current.transition(stateTransition, options);
   }
-  update(changes, nodeChanges) {
-    if (this.rootNode === void 0) {
-      this.validationProvider = new CrossfieldProvider(
-        this.initialView,
-        this.resolverOptions.parseBinding,
-        this.resolverOptions.logger
+  addNewFlow(flow) {
+    this.navStack.push(flow);
+    this.current = flow;
+    this.hooks.flow.call(flow);
+  }
+  async run(startState) {
+    if (!Object.prototype.hasOwnProperty.call(this.navigation, startState)) {
+      return Promise.reject(new Error(`No flow defined for: ${startState}`));
+    }
+    const startFlow = this.navigation[startState];
+    if (startFlow === null || typeof startFlow !== "object") {
+      return Promise.reject(
+        new Error(`Flow: ${startState} needs to be an object`)
       );
-      if (this.templatePlugin) {
-        this.hooks.templatePlugin.call(this.templatePlugin);
-      } else {
-        this.resolverOptions.logger?.warn(
-          "templatePlugin not set for View, legacy templates may not work"
-        );
-      }
-      const parser = new Parser();
-      this.hooks.parser.call(parser);
-      this.rootNode = parser.parseView(this.initialView);
-      this.resolver = new Resolver(this.rootNode, {
-        ...this.resolverOptions,
-        parseNode: parser.parseObject.bind(parser)
-      });
-      this.hooks.resolver.call(this.resolver);
     }
-    const update = this.resolver?.update(changes, nodeChanges);
-    if (this.lastUpdate === update) {
-      return this.lastUpdate;
+    this.log?.debug(`Starting flow: ${startState}`);
+    const flow = new FlowInstance(startState, startFlow, { logger: this.log });
+    this.addNewFlow(flow);
+    flow.hooks.afterTransition.tap("flow-controller", (flowInstance) => {
+      if (flowInstance.currentState?.value.state_type === "FLOW") {
+        const subflowId = flowInstance.currentState?.value.ref;
+        this.log?.debug(`Loading subflow ${subflowId}`);
+        this.run(subflowId).then((subFlowEndState) => {
+          this.log?.debug(
+            `Subflow ended. Using outcome: ${subFlowEndState.outcome}`
+          );
+          flowInstance.transition(subFlowEndState?.outcome);
+        });
+      }
+    });
+    const end = await flow.start();
+    this.navStack.pop();
+    if (this.navStack.length > 0) {
+      const firstItem = 0;
+      this.current = this.navStack[firstItem];
     }
-    this.lastUpdate = update;
-    this.hooks.onUpdate.call(update);
-    return update;
-  }
-  getValidationsForBinding(binding) {
-    return this.validationProvider?.getValidationsForBinding(binding);
+    return end;
   }
-  setTemplatePlugin(plugin) {
-    this.templatePlugin = plugin;
+  async start() {
+    if (!this.navigation.BEGIN) {
+      return Promise.reject(new Error("Must supply a BEGIN state"));
+    }
+    return this.run(this.navigation.BEGIN);
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/builder/index.ts
-var Builder = class _Builder {
-  /**
-   * Creates an asset node
-   *
-   * @param value - the value to put in the asset node
-   */
-  static asset(value) {
-    return {
-      type: "asset" /* Asset */,
-      value
-    };
-  }
-  static assetWrapper(value) {
-    const valueNode = _Builder.value();
-    _Builder.addChild(valueNode, "asset", value);
-    return valueNode;
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/validation/controller.ts
+import { SyncHook as SyncHook5, SyncWaterfallHook as SyncWaterfallHook6 } from "tapable-ts";
+import { setIn as setIn5 } from "timm";
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/utils/replaceParams.ts
+var ANY_CHAR_REGEX = /%([a-zA-Z]+)/g;
+function replaceParams(message, params) {
+  return message.slice().replace(ANY_CHAR_REGEX, (keyExpr) => params[keyExpr.slice(1)] || keyExpr);
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/validation/binding-tracker.ts
+var CONTEXT = "validation-binding-tracker";
+var ValidationBindingTrackerViewPlugin = class {
+  constructor(options) {
+    this.trackedBindings = /* @__PURE__ */ new Set();
+    this.options = options;
   }
-  /**
-   * Creates a value node
-   *
-   * @param v - The object to put in the value node
-   */
-  static value(v) {
-    return {
-      type: "value" /* Value */,
-      value: v
-    };
+  /** Fetch the tracked bindings in the current view */
+  getBindings() {
+    return this.trackedBindings;
   }
-  /**
-   * Creates a multiNode and associates the multiNode as the parent
-   * of all the value nodes
-   *
-   * @param values - the value, applicability or async nodes to put in the multinode
-   */
-  static multiNode(...values) {
-    const m = {
-      type: "multi-node" /* MultiNode */,
-      override: true,
-      values
-    };
-    values.forEach((v) => {
-      v.parent = m;
-    });
-    return m;
+  /** Add a binding to the tracked set */
+  trackBinding(binding) {
+    if (this.trackedBindings.has(binding)) {
+      return;
+    }
+    this.trackedBindings.add(binding);
+    this.options.callbacks?.onAdd?.(binding);
   }
-  /**
-   * Creates an async node
-   *
-   * @param id - the id of async node. It should be identical for each async node
-   */
-  static asyncNode(id, flatten2 = true, onValueReceived) {
-    return {
-      id,
-      type: "async" /* Async */,
-      flatten: flatten2,
-      onValueReceived,
-      value: {
-        type: "value" /* Value */,
-        value: {
-          id
+  /** Attach hooks to the given resolver */
+  applyResolver(resolver) {
+    this.trackedBindings.clear();
+    const tracked = /* @__PURE__ */ new Map();
+    const sections = /* @__PURE__ */ new Map();
+    let lastViewUpdateChangeSet;
+    const lastComputedBindingTree = /* @__PURE__ */ new Map();
+    let currentBindingTree = /* @__PURE__ */ new Map();
+    const lastSectionBindingTree = /* @__PURE__ */ new Map();
+    const resolvedNodeMap = /* @__PURE__ */ new Map();
+    resolver.hooks.beforeUpdate.tap(CONTEXT, (changes) => {
+      lastViewUpdateChangeSet = changes;
+    });
+    resolver.hooks.skipResolve.tap(CONTEXT, (shouldSkip, node) => {
+      const trackedBindingsForNode = lastComputedBindingTree.get(node);
+      if (!shouldSkip || !lastViewUpdateChangeSet || !trackedBindingsForNode) {
+        return shouldSkip;
+      }
+      const intersection = new Set(
+        [...lastViewUpdateChangeSet].filter(
+          (b) => trackedBindingsForNode.has(b)
+        )
+      );
+      return intersection.size === 0;
+    });
+    resolver.hooks.resolveOptions.tap(CONTEXT, (options, node) => {
+      if (options.validation === void 0) {
+        return options;
+      }
+      tracked.delete(node);
+      const track = (binding) => {
+        const parsed = isBinding(binding) ? binding : this.options.parseBinding(binding);
+        if (tracked.has(node)) {
+          tracked.get(node)?.add(parsed);
+        } else {
+          tracked.set(node, /* @__PURE__ */ new Set([parsed]));
+        }
+        let { parent } = node;
+        while (parent) {
+          if (sections.has(parent)) {
+            sections.get(parent)?.add(node);
+            break;
+          } else {
+            parent = parent.parent;
+          }
+        }
+        this.trackedBindings.add(parsed);
+        this.options.callbacks?.onAdd?.(parsed);
+      };
+      return {
+        ...options,
+        validation: {
+          ...options.validation,
+          get: (binding, getOptions) => {
+            if (getOptions?.track) {
+              track(binding);
+            }
+            const eows = options.validation?._getValidationForBinding(binding)?.getAll(getOptions);
+            const firstFieldEOW = eows?.find(
+              (eow) => eow.displayTarget === "field" || eow.displayTarget === void 0
+            );
+            return firstFieldEOW;
+          },
+          getValidationsForBinding(binding, getOptions) {
+            if (getOptions?.track) {
+              track(binding);
+            }
+            return options.validation?._getValidationForBinding(binding)?.getAll(getOptions) ?? [];
+          },
+          getChildren: (type) => {
+            const validations = new Array();
+            lastComputedBindingTree.get(node)?.forEach((binding) => {
+              const eow = options.validation?._getValidationForBinding(binding)?.get();
+              if (eow && (type === void 0 || type === eow.displayTarget)) {
+                validations.push(eow);
+              }
+            });
+            return validations;
+          },
+          getValidationsForSection: () => {
+            const validations = new Array();
+            lastSectionBindingTree.get(node)?.forEach((binding) => {
+              const eow = options.validation?._getValidationForBinding(binding)?.get();
+              if (eow && eow.displayTarget === "section") {
+                validations.push(eow);
+              }
+            });
+            return validations;
+          },
+          register: (registerOptions) => {
+            if (registerOptions?.type === "section") {
+              if (!sections.has(node)) {
+                sections.set(node, /* @__PURE__ */ new Set());
+              }
+            }
+          },
+          track
+        }
+      };
+    });
+    resolver.hooks.afterNodeUpdate.tap(
+      CONTEXT,
+      (originalNode, parent, update) => {
+        const { updated, node: resolvedNode } = update;
+        resolvedNodeMap.set(resolvedNode, originalNode);
+        if (updated) {
+          const newlyComputed = new Set(tracked.get(originalNode));
+          if (resolvedNode.type === "multi-node" /* MultiNode */) {
+            resolvedNode.values.forEach(
+              (value) => currentBindingTree.get(value)?.forEach((b) => newlyComputed.add(b))
+            );
+          }
+          if ("children" in resolvedNode && resolvedNode.children) {
+            resolvedNode.children.forEach((child) => {
+              currentBindingTree.get(child.value)?.forEach((b) => newlyComputed.add(b));
+            });
+          }
+          currentBindingTree.set(resolvedNode, newlyComputed);
+        } else {
+          currentBindingTree.set(
+            resolvedNode,
+            lastComputedBindingTree.get(originalNode) ?? /* @__PURE__ */ new Set()
+          );
+        }
+        if (originalNode === resolver.root) {
+          this.trackedBindings = new Set(currentBindingTree.get(resolvedNode));
+          lastComputedBindingTree.clear();
+          currentBindingTree.forEach((value, key) => {
+            const node = resolvedNodeMap.get(key);
+            if (node) {
+              lastComputedBindingTree.set(node, value);
+            }
+          });
+          lastSectionBindingTree.clear();
+          sections.forEach((nodeSet, sectionNode) => {
+            const temp = /* @__PURE__ */ new Set();
+            nodeSet.forEach((n) => {
+              tracked.get(n)?.forEach(temp.add, temp);
+            });
+            lastSectionBindingTree.set(sectionNode, temp);
+          });
+          tracked.clear();
+          sections.clear();
+          currentBindingTree = /* @__PURE__ */ new Map();
         }
       }
-    };
+    );
   }
-  /**
-   * Adds a child node to a node
-   *
-   * @param node - The node to add a child to
-   * @param path - The path at which to add the child
-   * @param child - The child node
-   */
-  static addChild(node, path, child) {
-    child.parent = node;
-    const newChild = {
-      path: Array.isArray(path) ? path : [path],
-      value: child
+  apply(view) {
+    view.hooks.resolver.tap(CONTEXT, this.applyResolver.bind(this));
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/validation/controller.ts
+var SCHEMA_VALIDATION_PROVIDER_NAME = "schema";
+var VIEW_VALIDATION_PROVIDER_NAME = "view";
+var VALIDATION_PROVIDER_NAME_SYMBOL = Symbol.for(
+  "validation-provider-name"
+);
+function isSubset(subset, containingSet) {
+  if (subset.size > containingSet.size)
+    return false;
+  for (const entry of subset)
+    if (!containingSet.has(entry))
+      return false;
+  return true;
+}
+function createStatefulValidationObject(obj) {
+  return {
+    value: obj,
+    type: obj.severity,
+    state: "none",
+    isBlockingNavigation: false
+  };
+}
+var ValidatedBinding = class {
+  constructor(possibleValidations, onDismiss, log, weakBindings) {
+    this.applicableValidations = [];
+    this.validationsByState = {
+      load: [],
+      change: [],
+      navigation: []
     };
-    node.children = node.children || [];
-    node.children.push(newChild);
-    return node;
+    this.onDismiss = onDismiss;
+    possibleValidations.forEach((vObj) => {
+      const { trigger } = vObj;
+      if (this.validationsByState[trigger]) {
+        const statefulValidationObject = createStatefulValidationObject(vObj);
+        this.validationsByState[trigger].push(statefulValidationObject);
+      } else {
+        log?.warn(`Unknown validation trigger: ${trigger}`);
+      }
+    });
+    this.weakBindings = weakBindings ?? /* @__PURE__ */ new Set();
   }
-  /**
-   * Updates children of a node of the same path and preserves order
-   *
-   * @param node - The node to update children for
-   * @param pathToMatch - The path to match against child paths
-   * @param mapFn - Function to transform matching children
-   */
-  static updateChildrenByPath(node, pathToMatch, updateFn) {
-    if (!node.children)
-      return node;
-    const updatedChildren = node.children.map(
-      (child) => (
-        // Check if paths match exactly
-        child.path.join() === pathToMatch.join() ? { ...child, value: updateFn(child) } : child
-      )
+  get allValidations() {
+    return Object.values(this.validationsByState).flat();
+  }
+  checkIfBlocking(statefulObj) {
+    if (statefulObj.state === "active") {
+      const { isBlockingNavigation } = statefulObj;
+      return isBlockingNavigation;
+    }
+    return false;
+  }
+  getAll() {
+    return this.applicableValidations.reduce((all, statefulObj) => {
+      if (statefulObj.state === "active" && statefulObj.response) {
+        all.push({
+          ...statefulObj.response,
+          blocking: this.checkIfBlocking(statefulObj)
+        });
+      }
+      return all;
+    }, []);
+  }
+  get() {
+    const firstInvalid = this.applicableValidations.find((statefulObj) => {
+      return statefulObj.state === "active" && statefulObj.response;
+    });
+    if (firstInvalid?.state === "active") {
+      return {
+        ...firstInvalid.response,
+        blocking: this.checkIfBlocking(firstInvalid)
+      };
+    }
+  }
+  runApplicableValidations(runner, canDismiss, phase) {
+    this.applicableValidations = this.applicableValidations.map(
+      (originalValue) => {
+        if (originalValue.state === "dismissed") {
+          return originalValue;
+        }
+        const blocking = originalValue.value.blocking ?? (originalValue.value.severity === "warning" && "once" || true);
+        const obj = setIn5(
+          originalValue,
+          ["value", "blocking"],
+          blocking
+        );
+        const isBlockingNavigation = blocking === true || blocking === "once" && !canDismiss;
+        if (phase === "navigation" && obj.state === "active" && obj.value.blocking !== true) {
+          if (obj.value.severity === "warning") {
+            const warn = obj;
+            if (warn.dismissable && warn.response.dismiss && (warn.response.blocking !== "once" || !warn.response.blocking)) {
+              warn.response.dismiss();
+            } else {
+              if (warn?.response.blocking === "once") {
+                warn.response.blocking = false;
+              }
+              warn.dismissable = true;
+            }
+            return warn;
+          }
+        }
+        const response = runner(obj.value);
+        const newState = {
+          type: obj.type,
+          value: obj.value,
+          state: response ? "active" : "none",
+          isBlockingNavigation,
+          dismissable: obj.value.severity === "warning" && phase === "navigation",
+          response: response ? {
+            ...obj.value,
+            message: response.message ?? "Something is broken",
+            severity: obj.value.severity,
+            displayTarget: obj.value.displayTarget ?? "field"
+          } : void 0
+        };
+        if (newState.state === "active" && obj.value.severity === "warning") {
+          newState.response.dismiss = () => {
+            newState.state = "dismissed";
+            this.onDismiss?.();
+          };
+        }
+        return newState;
+      }
     );
-    return {
-      ...node,
-      children: updatedChildren
-    };
-  }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/template.ts
-import { SyncWaterfallHook as SyncWaterfallHook6 } from "tapable-ts";
-var templateSymbol = Symbol("template");
-var TemplatePlugin = class {
-  constructor(options) {
-    this.hooks = {
-      resolveTemplateSubstitutions: new SyncWaterfallHook6()
-    };
-    this.options = options;
   }
-  parseTemplate(parseObject, node, options) {
-    const { template, depth } = node;
-    const data = options.data.model.get(node.data);
-    if (!data) {
-      return null;
+  update(phase, canDismiss, runner) {
+    const newApplicableValidations = [];
+    if (phase === "load" && this.currentPhase !== void 0) {
+      return;
     }
-    if (!Array.isArray(data)) {
-      throw new Error(`Template using '${node.data}' but is not an array`);
+    if (this.currentPhase === "navigation" || phase === this.currentPhase) {
+      this.runApplicableValidations(runner, canDismiss, phase);
+      return;
     }
-    const values = [];
-    data.forEach((dataItem, index) => {
-      const templateSubstitutions = this.hooks.resolveTemplateSubstitutions.call(
-        [
-          {
-            expression: new RegExp(`_index${depth || ""}_`),
-            value: String(index)
-          }
-        ],
-        {
-          depth,
-          data: dataItem,
-          index
-        }
-      );
-      let templateStr = JSON.stringify(template);
-      for (const { expression, value } of templateSubstitutions) {
-        let flags = "g";
-        if (typeof expression === "object") {
-          flags = `${expression.flags}${expression.global ? "" : "g"}`;
+    if (phase === "load") {
+      this.currentPhase = "load";
+      this.applicableValidations = [...this.validationsByState.load];
+    } else if (phase === "change" && this.currentPhase === "load") {
+      this.currentPhase = "change";
+      this.applicableValidations = [
+        ...this.applicableValidations,
+        ...this.validationsByState.change
+      ];
+    } else if (phase === "navigation" && (this.currentPhase === "load" || this.currentPhase === "change")) {
+      this.applicableValidations.forEach((element) => {
+        if (!(element.type === "error" && element.state === "active" && element.isBlockingNavigation === false)) {
+          newApplicableValidations.push(element);
         }
-        templateStr = templateStr.replace(new RegExp(expression, flags), value);
-      }
-      const parsed = parseObject(JSON.parse(templateStr), "value" /* Value */, {
-        templateDepth: node.depth + 1
       });
-      if (parsed) {
-        values.push(parsed);
-      }
-    });
-    const result = {
-      type: "multi-node" /* MultiNode */,
-      override: false,
-      values
-    };
-    if (node.placement !== void 0) {
-      result[templateSymbol] = node.placement;
+      this.applicableValidations = [
+        ...newApplicableValidations,
+        ...this.validationsByState.navigation,
+        ...this.currentPhase === "load" ? this.validationsByState.change : []
+      ];
+      this.currentPhase = "navigation";
     }
-    return result;
+    this.runApplicableValidations(runner, canDismiss, phase);
   }
-  applyParser(parser) {
-    parser.hooks.onCreateASTNode.tap("template", (node) => {
-      if (node && node.type === "template" /* Template */ && !node.dynamic) {
-        return this.parseTemplate(
-          parser.parseObject.bind(parser),
-          node,
-          this.options
-        );
-      }
-      return node;
-    });
-    parser.hooks.onCreateASTNode.tap("template", (node) => {
-      function getTemplateSymbolValue(node2) {
-        if (node2.type === "multi-node" /* MultiNode */) {
-          return node2[templateSymbol];
-        } else if (node2.type === "template" /* Template */) {
-          return node2.placement;
+};
+var ValidationController = class {
+  constructor(schema, options) {
+    this.hooks = {
+      /** A hook called to tap into the validator registry for adding more validators */
+      createValidatorRegistry: new SyncHook5(),
+      /** A callback/event when a new validation is added to the view */
+      onAddValidation: new SyncWaterfallHook6(),
+      /** The inverse of onAddValidation, this is called when a validation is removed from the list */
+      onRemoveValidation: new SyncWaterfallHook6(),
+      resolveValidationProviders: new SyncWaterfallHook6(),
+      /** A hook called when a binding is added to the tracker */
+      onTrackBinding: new SyncHook5()
+    };
+    this.validations = /* @__PURE__ */ new Map();
+    this.weakBindingTracker = /* @__PURE__ */ new Set();
+    this.schema = schema;
+    this.options = options;
+    this.reset();
+  }
+  setOptions(options) {
+    this.options = options;
+  }
+  /** Return the middleware for the data-model to stop propagation of invalid data */
+  getDataMiddleware() {
+    return [
+      {
+        set: (transaction, options, next) => {
+          return next?.set(transaction, options) ?? [];
+        },
+        get: (binding, options, next) => {
+          return next?.get(binding, options);
+        },
+        delete: (binding, options, next) => {
+          this.validations = removeBindingAndChildrenFromMap(
+            this.validations,
+            binding
+          );
+          return next?.delete(binding, options);
         }
-        return void 0;
-      }
-      if (node && (node.type === "view" /* View */ || node.type === "asset" /* Asset */) && Array.isArray(node.children)) {
-        node.children = node.children.sort((a, b) => {
-          const aPath = a.path.join();
-          const bPath = b.path.join();
-          const pathsEqual = aPath === bPath;
-          if (pathsEqual) {
-            const aPlacement = getTemplateSymbolValue(a.value);
-            const bPlacement = getTemplateSymbolValue(b.value);
-            if (aPlacement !== void 0 && bPlacement === void 0) {
-              return aPlacement === "prepend" ? -1 : 1;
-            } else if (bPlacement !== void 0 && aPlacement === void 0) {
-              return bPlacement === "prepend" ? 1 : -1;
-            } else if (aPlacement !== void 0 && bPlacement !== void 0) {
-              if (aPlacement === bPlacement) {
-                return 0;
-              }
-              return aPlacement === "prepend" ? -1 : 1;
+      },
+      new ValidationMiddleware(
+        (binding) => {
+          if (!this.options) {
+            return;
+          }
+          this.updateValidationsForBinding(binding, "change", this.options);
+          const strongValidation = this.getValidationForBinding(binding);
+          if (strongValidation?.get()?.severity === "error") {
+            return strongValidation.get();
+          }
+          const newInvalidBindings = /* @__PURE__ */ new Set();
+          this.validations.forEach((weakValidation, strongBinding) => {
+            if (caresAboutDataChanges(
+              /* @__PURE__ */ new Set([binding]),
+              weakValidation.weakBindings
+            ) && weakValidation?.get()?.severity === "error") {
+              weakValidation?.weakBindings.forEach((weakBinding) => {
+                if (weakBinding === strongBinding) {
+                  newInvalidBindings.add({
+                    binding: weakBinding,
+                    isStrong: true
+                  });
+                } else {
+                  newInvalidBindings.add({
+                    binding: weakBinding,
+                    isStrong: false
+                  });
+                }
+              });
             }
-            return 0;
+          });
+          if (newInvalidBindings.size > 0) {
+            return newInvalidBindings;
           }
-          return aPath > bPath ? 1 : -1;
-        });
-      }
-      return node;
-    });
-    parser.hooks.parseNode.tap(
-      "template",
-      (obj, _nodeType, options, childOptions) => {
-        if (childOptions && hasTemplateKey(childOptions.key)) {
-          return obj.map((template) => {
-            const templateAST = parser.createASTNode(
-              {
-                type: "template" /* Template */,
-                depth: options.templateDepth ?? 0,
-                data: template.data,
-                template: template.value,
-                dynamic: template.dynamic ?? false,
-                placement: template.placement
-              },
-              template
+        },
+        { logger: new ProxyLogger(() => this.options?.logger) }
+      )
+    ];
+  }
+  getValidationProviders() {
+    if (this.providers) {
+      return this.providers;
+    }
+    this.providers = this.hooks.resolveValidationProviders.call([
+      {
+        source: SCHEMA_VALIDATION_PROVIDER_NAME,
+        provider: this.schema
+      },
+      {
+        source: VIEW_VALIDATION_PROVIDER_NAME,
+        provider: {
+          getValidationsForBinding: (binding) => {
+            return this.viewValidationProvider?.getValidationsForBinding?.(
+              binding
             );
-            if (!templateAST)
-              return;
-            if (templateAST.type === "multi-node" /* MultiNode */) {
-              templateAST.values.forEach((v) => {
-                v.parent = templateAST;
-              });
+          },
+          getValidationsForView: () => {
+            return this.viewValidationProvider?.getValidationsForView?.();
+          }
+        }
+      }
+    ]);
+    return this.providers;
+  }
+  reset() {
+    this.validations.clear();
+    this.tracker = void 0;
+  }
+  onView(view) {
+    this.validations.clear();
+    if (!this.options) {
+      return;
+    }
+    const bindingTrackerPlugin = new ValidationBindingTrackerViewPlugin({
+      ...this.options,
+      callbacks: {
+        onAdd: (binding) => {
+          if (!this.options || this.getValidationForBinding(binding) !== void 0) {
+            return;
+          }
+          const originalValue = this.options.model.get(binding);
+          const withoutDefault = this.options.model.get(binding, {
+            ignoreDefaultValue: true
+          });
+          if (originalValue !== withoutDefault) {
+            this.options.model.set([[binding, originalValue]], {
+              silent: true
+            });
+          }
+          this.updateValidationsForBinding(
+            binding,
+            "load",
+            this.options,
+            () => {
+              view.update(/* @__PURE__ */ new Set([binding]));
             }
-            return {
-              path: [...childOptions.path, template.output],
-              value: templateAST
-            };
-          }).filter(Boolean);
+          );
+          this.hooks.onTrackBinding.call(binding);
         }
       }
-    );
-  }
-  applyResolverHooks(resolver) {
-    resolver.hooks.beforeResolve.tap("template", (node, options) => {
-      if (node && node.type === "template" /* Template */ && node.dynamic) {
-        return this.parseTemplate(options.parseNode, node, options);
-      }
-      return node;
     });
+    this.tracker = bindingTrackerPlugin;
+    this.viewValidationProvider = view;
+    bindingTrackerPlugin.apply(view);
   }
-  apply(view) {
-    view.hooks.parser.tap("template", this.applyParser.bind(this));
-    view.hooks.resolver.tap("template", this.applyResolverHooks.bind(this));
-    view.setTemplatePlugin(this);
-  }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/string-resolver.ts
-import { set } from "timm";
-var createPatternMatcher = (start, end) => {
-  return (testStr) => {
-    const startLocation = testStr.indexOf(start);
-    if (startLocation === -1) {
-      return false;
+  updateValidationsForBinding(binding, trigger, validationContext, onDismiss) {
+    const context = validationContext ?? this.options;
+    if (!context) {
+      throw new Error(`Context is required for executing validations`);
     }
-    const endLocation = testStr.indexOf(end);
-    if (endLocation === -1) {
-      return false;
+    if (trigger === "load") {
+      const possibleValidations = this.getValidationProviders().reduce((vals, provider) => {
+        vals.push(
+          ...provider.provider.getValidationsForBinding?.(binding)?.map((valObj) => ({
+            ...valObj,
+            [VALIDATION_PROVIDER_NAME_SYMBOL]: provider.source
+          })) ?? []
+        );
+        return vals;
+      }, []);
+      if (possibleValidations.length === 0) {
+        return;
+      }
+      this.validations.set(
+        binding,
+        new ValidatedBinding(
+          possibleValidations,
+          onDismiss,
+          this.options?.logger
+        )
+      );
+    }
+    const trackedValidations = this.validations.get(binding);
+    trackedValidations?.update(trigger, true, (validationObj) => {
+      const response = this.validationRunner(validationObj, binding, context);
+      if (this.weakBindingTracker.size > 0) {
+        const t2 = this.validations.get(binding);
+        this.weakBindingTracker.forEach((b) => t2.weakBindings.add(b));
+      }
+      return response ? { message: response.message } : void 0;
+    });
+    if (trigger !== "load") {
+      this.validations.forEach((validation, vBinding) => {
+        if (vBinding !== binding && caresAboutDataChanges(/* @__PURE__ */ new Set([binding]), validation.weakBindings)) {
+          validation.update(trigger, true, (validationObj) => {
+            const response = this.validationRunner(
+              validationObj,
+              vBinding,
+              context
+            );
+            return response ? { message: response.message } : void 0;
+          });
+        }
+      });
     }
-    return startLocation < endLocation;
-  };
-};
-var bindingResolveLookup = createPatternMatcher("{{", "}}");
-var expressionResolveLookup = createPatternMatcher("@[", "]@");
-function hasSomethingToResolve(str) {
-  return bindingResolveLookup(str) || expressionResolveLookup(str);
-}
-function resolveString(str, resolveOptions) {
-  return hasSomethingToResolve(str) ? resolveDataRefs(str, {
-    model: resolveOptions.data.model,
-    evaluate: resolveOptions.evaluate
-  }) : str;
-}
-function resolveAllRefs(node, resolveOptions, propertiesToSkip) {
-  if (node === null || node === void 0 || typeof node !== "object" && typeof node !== "string") {
-    return node;
-  }
-  if (typeof node === "string") {
-    return resolveString(node, resolveOptions);
   }
-  let newNode = node;
-  Object.keys(node).forEach((key) => {
-    if (propertiesToSkip.has(key)) {
-      return;
+  validationRunner(validationObj, binding, context = this.options) {
+    if (!context) {
+      throw new Error("No context provided to validation runner");
     }
-    const val = node[key];
-    let newVal = val;
-    if (typeof val === "object") {
-      newVal = resolveAllRefs(val, resolveOptions, propertiesToSkip);
-    } else if (typeof val === "string") {
-      newVal = resolveString(val, resolveOptions);
+    const handler = validationObj.handler ?? this.getValidator(validationObj.type);
+    const weakBindings = /* @__PURE__ */ new Set();
+    const model = {
+      get(b, options) {
+        weakBindings.add(isBinding(b) ? binding : context.parseBinding(b));
+        return context.model.get(b, { ...options, includeInvalid: true });
+      },
+      set: context.model.set,
+      delete: context.model.delete
+    };
+    const result = handler?.(
+      {
+        ...context,
+        evaluate: (exp, options = { model }) => context.evaluate(exp, options),
+        model,
+        validation: validationObj,
+        schemaType: this.schema.getType(binding)
+      },
+      context.model.get(binding, {
+        includeInvalid: true,
+        formatted: validationObj.dataTarget === "formatted"
+      }),
+      validationObj
+    );
+    this.weakBindingTracker = weakBindings;
+    if (result) {
+      let { message } = result;
+      const { parameters } = result;
+      if (validationObj.message) {
+        message = resolveDataRefs(validationObj.message, {
+          model,
+          evaluate: context.evaluate
+        });
+        if (parameters) {
+          message = replaceParams(message, parameters);
+        }
+      }
+      return {
+        message
+      };
     }
-    if (newVal !== val) {
-      newNode = set(newNode, key, newVal);
+  }
+  updateValidationsForView(trigger) {
+    const isNavigationTrigger = trigger === "navigation";
+    const lastActiveBindings = this.activeBindings;
+    const updateValidations = (dismissValidations) => {
+      this.getBindings().forEach((binding) => {
+        this.validations.get(binding)?.update(trigger, dismissValidations, (obj) => {
+          if (!this.options) {
+            return;
+          }
+          return this.validationRunner(obj, binding, this.options);
+        });
+      });
+    };
+    updateValidations(!isNavigationTrigger);
+    if (isNavigationTrigger) {
+      const { activeBindings } = this;
+      if (isSubset(activeBindings, lastActiveBindings)) {
+        updateValidations(true);
+      }
     }
-  });
-  return newNode;
-}
-var findBasePath = (node, resolver) => {
-  const parentNode = node.parent;
-  if (!parentNode) {
-    return [];
   }
-  if ("children" in parentNode) {
-    const original = resolver.getSourceNode(node);
-    return parentNode.children?.find((child) => child.value === original)?.path ?? [];
+  get activeBindings() {
+    return new Set(
+      Array.from(this.getBindings()).filter(
+        (b) => this.validations.get(b)?.get() !== void 0
+      )
+    );
   }
-  if (parentNode.type !== "multi-node" /* MultiNode */) {
-    return [];
+  getValidator(type) {
+    if (this.validatorRegistry) {
+      return this.validatorRegistry.get(type);
+    }
+    const registry = new ValidatorRegistry();
+    this.hooks.createValidatorRegistry.call(registry);
+    this.validatorRegistry = registry;
+    return registry.get(type);
   }
-  return findBasePath(parentNode, resolver);
-};
-var StringResolverPlugin = class {
-  constructor() {
-    this.propertiesToSkipCache = /* @__PURE__ */ new Map();
+  getBindings() {
+    return this.tracker?.getBindings() ?? /* @__PURE__ */ new Set();
   }
-  applyResolver(resolver) {
-    resolver.hooks.resolve.tap("string-resolver", (value, node, options) => {
-      if (node.type === "empty" /* Empty */ || node.type === "unknown" /* Unknown */) {
-        return null;
-      }
-      if (node.type === "value" /* Value */ || node.type === "asset" /* Asset */ || node.type === "view" /* View */) {
-        let propsToSkip;
-        if (node.type === "asset" /* Asset */ || node.type === "view" /* View */) {
-          propsToSkip = new Set(
-            node.plugins?.stringResolver?.propertiesToSkip ?? ["exp"]
-          );
-          if (node.value?.id) {
-            this.propertiesToSkipCache.set(node.value.id, propsToSkip);
-          }
-        } else if (node.parent?.type === "multi-node" /* MultiNode */ && (node.parent?.parent?.type === "asset" /* Asset */ || node.parent?.parent?.type === "view" /* View */) && node.parent.parent.value?.id && this.propertiesToSkipCache.has(node.parent.parent.value.id)) {
-          propsToSkip = this.propertiesToSkipCache.get(
-            node.parent.parent.value.id
+  trackBinding(binding) {
+    this.tracker?.trackBinding(binding);
+  }
+  /** Executes all known validations for the tracked bindings using the given model */
+  validateView(trigger = "navigation") {
+    this.updateValidationsForView(trigger);
+    const validations = /* @__PURE__ */ new Map();
+    let canTransition = true;
+    this.getBindings().forEach((b) => {
+      const allValidations = this.getValidationForBinding(b)?.getAll();
+      allValidations?.forEach((v) => {
+        if (trigger === "navigation" && v.blocking) {
+          this.options?.logger.debug(
+            `Validation on binding: ${b.asString()} is preventing navigation. ${JSON.stringify(
+              v
+            )}`
           );
-        } else {
-          propsToSkip = /* @__PURE__ */ new Set(["exp"]);
+          canTransition = false;
         }
-        const nodePath = findBasePath(node, resolver);
-        if (nodePath.length > 0 && nodePath.some((segment) => propsToSkip.has(segment.toString()))) {
-          return node.value;
+        if (!validations.has(b)) {
+          validations.set(b, v);
         }
-        return resolveAllRefs(node.value, options, propsToSkip);
-      }
-      return value;
+      });
     });
+    return {
+      canTransition,
+      validations: validations.size ? validations : void 0
+    };
   }
-  apply(view) {
-    view.hooks.resolver.tap("string-resolver", this.applyResolver.bind(this));
-  }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/applicability.ts
-import { omit as omit2 } from "timm";
-var ApplicabilityPlugin = class {
-  isApplicability(obj) {
-    return obj && Object.prototype.hasOwnProperty.call(obj, "applicability");
+  /** Get the current tracked validation for the given binding */
+  getValidationForBinding(binding) {
+    return this.validations.get(binding);
   }
-  applyResolver(resolver) {
-    resolver.hooks.beforeResolve.tap(
-      "applicability",
-      (node, options) => {
-        let newNode = node;
-        if (node?.type === "applicability" /* Applicability */) {
-          const isApplicable = options.evaluate(node.expression);
-          if (isApplicable === false) {
-            return null;
-          }
-          newNode = node.value;
+  forView(parser) {
+    return {
+      _getValidationForBinding: (binding) => {
+        return this.getValidationForBinding(
+          isBinding(binding) ? binding : parser(binding)
+        );
+      },
+      getAll: () => {
+        const bindings = this.getBindings();
+        if (bindings.size === 0) {
+          return void 0;
         }
-        return newNode;
-      }
-    );
-  }
-  applyParser(parser) {
-    parser.hooks.parseNode.tap(
-      "applicability",
-      (obj, nodeType, options, childOptions) => {
-        if (this.isApplicability(obj)) {
-          const parsedApplicability = parser.parseObject(
-            omit2(obj, "applicability"),
-            nodeType,
-            options
-          );
-          if (!parsedApplicability) {
-            return childOptions ? [] : null;
-          }
-          const applicabilityNode = parser.createASTNode(
-            {
-              type: "applicability" /* Applicability */,
-              expression: obj.applicability,
-              value: parsedApplicability
-            },
-            obj
-          );
-          if (!applicabilityNode) {
-            return childOptions ? [] : null;
-          }
-          if (applicabilityNode.type === "applicability" /* Applicability */) {
-            applicabilityNode.value.parent = applicabilityNode;
+        const validationMapping = /* @__PURE__ */ new Map();
+        bindings.forEach((b) => {
+          const validation = this.getValidationForBinding(b)?.get();
+          if (validation) {
+            validationMapping.set(b, validation);
           }
-          return childOptions ? [
-            {
-              path: [...childOptions.path, childOptions.key],
-              value: applicabilityNode
-            }
-          ] : applicabilityNode;
-        }
-      }
-    );
-  }
-  apply(view) {
-    view.hooks.resolver.tap("applicability", this.applyResolver.bind(this));
-    view.hooks.parser.tap("applicability", this.applyParser.bind(this));
+        });
+        return validationMapping.size === 0 ? void 0 : validationMapping;
+      },
+      get() {
+        throw new Error("Error Access be provided by the view plugin");
+      },
+      getValidationsForBinding() {
+        throw new Error("Error rollup should be provided by the view plugin");
+      },
+      getChildren() {
+        throw new Error("Error rollup should be provided by the view plugin");
+      },
+      getValidationsForSection() {
+        throw new Error("Error rollup should be provided by the view plugin");
+      },
+      track: () => {
+        throw new Error("Tracking should be provided by the view plugin");
+      },
+      register: () => {
+        throw new Error(
+          "Section functionality should be provided by the view plugin"
+        );
+      },
+      type: (binding) => this.schema.getType(isBinding(binding) ? binding : parser(binding))
+    };
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/switch.ts
-var SwitchPlugin = class {
-  constructor(options) {
-    this.options = options;
-  }
-  resolveSwitch(node, options) {
-    for (const switchCase of node.cases) {
-      const isApplicable = options.evaluate(switchCase.case);
-      if (isApplicable) {
-        return switchCase.value;
-      }
-    }
-    return EMPTY_NODE;
-  }
-  isSwitch(obj) {
-    return obj && (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch"));
-  }
-  applyParser(parser) {
-    parser.hooks.onCreateASTNode.tap("switch", (node) => {
-      if (node && node.type === "switch" /* Switch */ && !node.dynamic) {
-        return this.resolveSwitch(node, this.options);
-      }
-      return node;
-    });
-    parser.hooks.parseNode.tap(
-      "switch",
-      (obj, _nodeType, options, childOptions) => {
-        if (this.isSwitch(obj) || childOptions && hasSwitchKey(childOptions.key)) {
-          const objToParse = childOptions && hasSwitchKey(childOptions.key) ? { [childOptions.key]: obj } : obj;
-          const dynamic = "dynamicSwitch" in objToParse;
-          const switchContent = dynamic ? objToParse.dynamicSwitch : objToParse.staticSwitch;
-          const cases = switchContent.map(
-            (switchCase) => {
-              const { case: switchCaseExpr, ...switchBody } = switchCase;
-              const value = parser.parseObject(
-                switchBody,
-                "value" /* Value */,
-                options
-              );
-              if (value) {
-                return {
-                  case: switchCaseExpr,
-                  value
-                };
-              }
-              return;
-            }
-          ).filter(Boolean);
-          const switchAST = parser.createASTNode(
-            {
-              type: "switch" /* Switch */,
-              dynamic,
-              cases
-            },
-            objToParse
-          );
-          if (!switchAST || switchAST.type === "empty" /* Empty */) {
-            return childOptions ? [] : null;
-          }
-          if (switchAST.type === "switch" /* Switch */) {
-            switchAST.cases.forEach((sCase) => {
-              sCase.value.parent = switchAST;
-            });
-          }
-          if (childOptions) {
-            let path = [...childOptions.path, childOptions.key];
-            let value = switchAST;
-            if (switchAST.type === "value" /* Value */ && switchAST.children?.length === 1 && switchAST.value === void 0) {
-              const firstChild = switchAST.children[0];
-              path = [...path, ...firstChild.path];
-              value = firstChild.value;
-            }
-            return [{ path, value }];
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/view/controller.ts
+import { SyncHook as SyncHook6, SyncWaterfallHook as SyncWaterfallHook7 } from "tapable-ts";
+import queueMicrotask from "queue-microtask";
+import { Registry } from "@player-ui/partial-match-registry";
+var mergeSets = (setA, setB) => {
+  return /* @__PURE__ */ new Set([...setA?.values() ?? [], ...setB?.values() ?? []]);
+};
+var ViewController = class {
+  constructor(initialViews, options) {
+    this.hooks = {
+      resolveView: new SyncWaterfallHook7(),
+      view: new SyncHook6()
+    };
+    this.transformRegistry = new Registry();
+    this.optimizeUpdates = true;
+    this.viewOptions = options;
+    this.viewMap = initialViews.reduce(
+      (viewMap, view) => {
+        viewMap[view.id] = view;
+        return viewMap;
+      },
+      {}
+    );
+    options.flowController.hooks.flow.tap(
+      "viewController",
+      (flow) => {
+        flow.hooks.transition.tap("viewController", (_oldState, newState) => {
+          if (newState.value.state_type === "VIEW") {
+            this.onView(newState.value);
+          } else {
+            this.currentView = void 0;
           }
-          return switchAST;
+        });
+      }
+    );
+    const update = (updates, silent = false) => {
+      if (this.currentView) {
+        if (this.optimizeUpdates) {
+          this.queueUpdate(updates, void 0, silent);
+        } else {
+          this.updateView();
         }
       }
+    };
+    options.model.hooks.onUpdate.tap(
+      "viewController",
+      (updates, updateOptions) => {
+        update(
+          new Set(updates.map((t2) => t2.binding)),
+          updateOptions?.silent ?? false
+        );
+      }
     );
-  }
-  applyResolver(resolver) {
-    resolver.hooks.beforeResolve.tap("switch", (node, options) => {
-      if (node && node.type === "switch" /* Switch */ && node.dynamic) {
-        return this.resolveSwitch(node, options);
+    options.model.hooks.onDelete.tap("viewController", (binding) => {
+      const parentBinding = binding.parent();
+      const property = binding.key();
+      if (typeof property === "number" && parentBinding) {
+        update(/* @__PURE__ */ new Set([parentBinding]));
+      } else {
+        update(/* @__PURE__ */ new Set([binding]));
       }
-      return node;
     });
+    this.viewPlugins = this.createViewPlugins();
   }
-  apply(view) {
-    view.hooks.parser.tap("switch", this.applyParser.bind(this));
-    view.hooks.resolver.tap("switch", this.applyResolver.bind(this));
+  queueUpdate(bindings, nodes, silent = false) {
+    if (!this.pendingUpdate) {
+      this.pendingUpdate = {
+        scheduled: false
+      };
+    }
+    this.pendingUpdate = {
+      ...this.pendingUpdate,
+      changedBindings: mergeSets(this.pendingUpdate.changedBindings, bindings),
+      changedNodes: mergeSets(this.pendingUpdate.changedNodes, nodes)
+    };
+    if (!this.pendingUpdate.scheduled && !silent) {
+      this.pendingUpdate.scheduled = true;
+      queueMicrotask(() => {
+        const { changedBindings, changedNodes } = this.pendingUpdate ?? {};
+        this.pendingUpdate = void 0;
+        this.updateView(changedBindings, changedNodes);
+      });
+    }
   }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/multi-node.ts
-var MultiNodePlugin = class {
-  applyParser(parser) {
-    parser.hooks.parseNode.tap(
-      "multi-node",
-      (obj, nodeType, options, childOptions) => {
-        if ((childOptions === void 0 || !hasTemplateKey(childOptions.key)) && Array.isArray(obj)) {
-          const values = obj.map(
-            (childVal) => parser.parseObject(childVal, "value" /* Value */, options)
-          ).filter((child) => !!child);
-          if (!values.length) {
-            return [];
-          }
-          const multiNode = parser.createASTNode(
-            {
-              type: "multi-node" /* MultiNode */,
-              override: childOptions !== void 0 && !hasTemplateValues(childOptions.parentObj, childOptions.key),
-              values
-            },
-            obj
-          );
-          if (!multiNode) {
-            return [];
-          }
-          if (multiNode.type === "multi-node" /* MultiNode */) {
-            multiNode.values.forEach((v) => {
-              v.parent = multiNode;
-            });
-          }
-          return childOptions === void 0 ? multiNode : [
-            {
-              path: [...childOptions.path, childOptions.key],
-              value: multiNode
-            }
-          ];
-        }
-      }
-    );
+  updateView(changedBindings, changedNodes) {
+    try {
+      this.currentView?.update(changedBindings, changedNodes);
+    } catch (exception) {
+      const err = exception instanceof Error ? exception : new Error(String(exception));
+      this.queueUpdate(changedBindings, changedNodes, true);
+      this.viewOptions.errorController.captureError(err);
+    }
   }
-  apply(view) {
-    view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
+  getViewForRef(viewRef) {
+    if (this.viewMap[viewRef]) {
+      return this.viewMap[viewRef];
+    }
+    const matchingViewId = Object.keys(this.viewMap).find(
+      (possibleViewIdMatch) => viewRef === resolveDataRefsInString(possibleViewIdMatch, {
+        model: this.viewOptions.model,
+        evaluate: this.viewOptions.evaluator.evaluate
+      })
+    );
+    if (matchingViewId && this.viewMap[matchingViewId]) {
+      return this.viewMap[matchingViewId];
+    }
   }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/asset.ts
-var AssetPlugin = class {
-  applyParser(parser) {
-    parser.hooks.parseNode.tap(
-      "asset",
-      (obj, nodeType, options, childOptions) => {
-        if (childOptions?.key === "asset" && typeof obj === "object") {
-          const assetAST = parser.parseObject(obj, "asset" /* Asset */, options);
-          if (!assetAST) {
-            return [];
-          }
-          return [
-            {
-              path: [...childOptions.path, childOptions.key],
-              value: assetAST
-            }
-          ];
-        }
-      }
+  onView(state) {
+    const viewId = state.ref;
+    const source = this.hooks.resolveView.call(
+      this.getViewForRef(viewId),
+      viewId,
+      state
     );
+    if (!source) {
+      throw new Error(`No view with id ${viewId}`);
+    }
+    const view = new ViewInstance(source, this.viewOptions);
+    this.currentView = view;
+    this.applyViewPlugins(view);
+    this.hooks.view.call(view);
+    this.updateView();
   }
-  apply(view) {
-    view.hooks.parser.tap("asset", this.applyParser.bind(this));
+  applyViewPlugins(view) {
+    for (const plugin of this.viewPlugins) {
+      plugin.apply(view);
+    }
+  }
+  createViewPlugins() {
+    const pluginOptions = toNodeResolveOptions(this.viewOptions);
+    return [
+      new AssetPlugin(),
+      new SwitchPlugin(pluginOptions),
+      new ApplicabilityPlugin(),
+      new AssetTransformCorePlugin(this.transformRegistry),
+      new StringResolverPlugin(),
+      new TemplatePlugin(pluginOptions),
+      new MultiNodePlugin()
+    ];
+  }
+  /** Marks all AST nodes in `nodes` as changed, triggering the view to update and re-resolve these nodes. View updates are triggered asynchronously and many calls to this in a short time will batch into a single update.
+   *
+   * NOTE: In most cases view updates are handled automatically by changes to data or any other built-in functionality that would require a view update. Only call this function if absolutely necessary.
+   */
+  updateViewAST(nodes) {
+    this.queueUpdate(void 0, nodes);
   }
 };
 
@@ -3847,1385 +3997,1645 @@ var LocalStateStore = class {
         localState.push(initialState);
       }
       const value = localState[oldCount];
-      return [
-        value,
-        (newState) => {
-          const oldValue = localState[oldCount];
-          localState[oldCount] = newState;
-          if (oldValue !== newState) {
-            this.updateCallback?.();
-          }
-        }
-      ];
-    };
-  }
-};
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/asset-transform.ts
-function findUp(node, target) {
-  if (node === target) {
-    return true;
-  }
-  if (node.parent) {
-    return findUp(node.parent, target);
-  }
-  return false;
-}
-var AssetTransformCorePlugin = class {
-  constructor(registry) {
-    this.registry = registry;
-    this.stateStore = /* @__PURE__ */ new Map();
-    this.beforeResolveSymbol = Symbol("before resolve");
-    this.resolveSymbol = Symbol("resolve");
-    this.beforeResolveCountSymbol = Symbol("before resolve count");
-    this.resolveCountSymbol = Symbol("resolve count");
-  }
-  apply(view) {
-    this.stateStore.clear();
-    view.hooks.resolver.tap("asset-transform", (resolver) => {
-      let lastUpdatedNode;
-      const updateState = (node) => {
-        lastUpdatedNode = node;
-        view.update(/* @__PURE__ */ new Set());
-      };
-      const getStore = (node, stepKey) => {
-        let store;
-        const countKey = stepKey === this.resolveSymbol ? this.resolveCountSymbol : this.beforeResolveCountSymbol;
-        const storedState = this.stateStore.get(node);
-        if (storedState) {
-          store = storedState;
-          store.removeKey(countKey);
-        } else {
-          store = new LocalStateStore(() => {
-            updateState(node);
-          });
-          this.stateStore.set(node, store);
-        }
-        return {
-          useSharedState: (key) => {
-            return store.useSharedState(key);
-          },
-          useLocalState: (initialState) => {
-            return store.getLocalStateFunction(
-              stepKey,
-              countKey
-            )(initialState);
-          }
-        };
-      };
-      resolver.hooks.beforeResolve.tap("asset-transform", (node, options) => {
-        if (node && (node.type === "asset" || node.type === "view")) {
-          const transform = this.registry.get(node.value);
-          if (transform?.beforeResolve) {
-            const store = getStore(
-              options.node ?? node,
-              this.beforeResolveSymbol
-            );
-            return transform.beforeResolve(node, options, store);
-          }
-        }
-        return node;
-      });
-      resolver.hooks.afterUpdate.tap("asset-transform", () => {
-        lastUpdatedNode = void 0;
-      });
-      resolver.hooks.skipResolve.tap("asset-transform", (skip, node) => {
-        if (!skip || !lastUpdatedNode) {
-          return skip;
-        }
-        const isParentOfUpdated = findUp(lastUpdatedNode, node);
-        const isChildOfUpdated = findUp(node, lastUpdatedNode);
-        return !isParentOfUpdated && !isChildOfUpdated;
-      });
-      resolver.hooks.afterResolve.tap(
-        "asset-transform",
-        (value, node, options) => {
-          if (node.type !== "asset" /* Asset */ && node.type !== "view" /* View */) {
-            return value;
-          }
-          const originalNode = resolver.getSourceNode(node);
-          if (!originalNode) {
-            return value;
-          }
-          const transform = this.registry.get(value);
-          if (transform?.resolve) {
-            const store = getStore(originalNode, this.resolveSymbol);
-            return transform?.resolve(value, options, store);
+      return [
+        value,
+        (newState) => {
+          const oldValue = localState[oldCount];
+          localState[oldCount] = newState;
+          if (oldValue !== newState) {
+            this.updateCallback?.();
           }
-          return value;
         }
-      );
-    });
+      ];
+    };
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/player.ts
-import { setIn as setIn7 } from "timm";
-import deferred from "p-defer";
-import queueMicrotask2 from "queue-microtask";
-import { SyncHook as SyncHook10, SyncWaterfallHook as SyncWaterfallHook11 } from "tapable-ts";
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/data/controller.ts
+import { SyncHook as SyncHook7, SyncWaterfallHook as SyncWaterfallHook8, SyncBailHook as SyncBailHook5 } from "tapable-ts";
+import { dequal } from "dequal";
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/flow/flow.ts
-import { SyncBailHook as SyncBailHook4, SyncHook as SyncHook5, SyncWaterfallHook as SyncWaterfallHook7 } from "tapable-ts";
-import defer from "p-defer";
-var FlowInstance = class {
-  constructor(id, flow, options) {
-    this.isTransitioning = false;
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/data/utils.ts
+var ReadOnlyDataController = class {
+  constructor(controller) {
+    this.controller = controller;
+  }
+  get(binding, options) {
+    return this.controller.get(binding, options);
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/data/controller.ts
+var DataController = class {
+  constructor(model, options) {
     this.hooks = {
-      beforeStart: new SyncBailHook4(),
-      onStart: new SyncHook5(),
-      onEnd: new SyncHook5(),
-      skipTransition: new SyncBailHook4(),
-      beforeTransition: new SyncWaterfallHook7(),
-      resolveTransitionNode: new SyncWaterfallHook7(),
-      transition: new SyncHook5(),
-      afterTransition: new SyncHook5()
+      resolve: new SyncWaterfallHook8(),
+      resolveDataStages: new SyncWaterfallHook8(),
+      // On any set or get of an undefined value, redirect the value to be the default
+      resolveDefaultValue: new SyncBailHook5(),
+      onDelete: new SyncHook7(),
+      onSet: new SyncHook7(),
+      onGet: new SyncHook7(),
+      onUpdate: new SyncHook7(),
+      format: new SyncWaterfallHook8(),
+      deformat: new SyncWaterfallHook8(),
+      serialize: new SyncWaterfallHook8()
     };
-    this.id = id;
-    this.flow = flow;
-    this.log = options?.logger;
-    this.history = [];
-    this.hooks.transition.tap(
-      "startPromise",
-      async (_oldState, nextState) => {
-        const newState = nextState.value;
-        if (this.flowPromise && newState.state_type === "END") {
-          this.flowPromise.resolve(newState);
-        }
-      }
-    );
+    this.logger = options.logger;
+    const middleware = options.middleware || [];
+    this.baseMiddleware = [new LocalModel(model), ...middleware];
+    this.trash = /* @__PURE__ */ new Set();
+    this.pathResolver = options.pathResolver;
   }
-  /** Start the state machine */
-  async start() {
-    if (this.flowPromise) {
-      this.log?.warn("Already called start for flow");
-      return this.flowPromise.promise;
-    }
-    this.flow = this.hooks.beforeStart.call(this.flow) || this.flow;
-    if (this.flow.onStart) {
-      this.hooks.onStart.call(this.flow.onStart);
-    }
-    const initialState = this.flow.startState;
-    if (!initialState) {
-      return Promise.reject(new Error("No 'startState' defined for flow"));
+  getModel() {
+    if (!this.model) {
+      const stages = this.hooks.resolveDataStages.call(this.baseMiddleware);
+      const model = new PipelinedDataModel();
+      model.setMiddleware(stages);
+      this.model = model;
     }
-    this.flowPromise = defer();
-    this.pushHistory(initialState);
-    return this.flowPromise.promise;
+    return this.model;
   }
-  transition(transitionValue, options) {
-    if (this.isTransitioning) {
-      throw new Error(
-        `Transitioning while ongoing transition from ${this.currentState?.name} is in progress is not supported`
-      );
+  resolveDataValue(binding, value, deformat) {
+    if (deformat) {
+      return this.hooks.deformat.call(value, binding);
     }
-    if (this.currentState?.value.state_type === "END") {
-      this.log?.warn(
-        `Skipping transition using ${transitionValue}. Already at and END state`
+    return value;
+  }
+  set(transaction, options) {
+    let normalizedTransaction = [];
+    if (Array.isArray(transaction)) {
+      normalizedTransaction = transaction.map(([binding, value]) => {
+        const parsed = this.pathResolver.parse(binding);
+        return [
+          parsed,
+          this.resolveDataValue(parsed, value, Boolean(options?.formatted))
+        ];
+      });
+    } else {
+      normalizedTransaction = Object.keys(transaction).map(
+        (binding) => {
+          const parsed = this.pathResolver.parse(binding);
+          const val = transaction[binding];
+          return [
+            parsed,
+            this.resolveDataValue(parsed, val, Boolean(options?.formatted))
+          ];
+        }
       );
-      return;
-    }
-    if (this.currentState === void 0) {
-      throw new Error("Cannot transition when there's no current state");
     }
-    if (options?.force) {
-      this.log?.debug(`Forced transition. Skipping validation checks`);
-    } else {
-      const skipTransition = this.hooks.skipTransition.call(this.currentState);
-      if (skipTransition) {
-        this.log?.debug(
-          `Skipping transition from ${this.currentState.name} b/c hook told us to`
+    const setUpdates = normalizedTransaction.reduce(
+      (updates, [binding, newVal]) => {
+        const oldVal = this.get(binding, { includeInvalid: true });
+        const update = {
+          binding,
+          newValue: newVal,
+          oldValue: oldVal
+        };
+        if (dequal(oldVal, newVal)) {
+          this.logger?.debug(
+            `Skipping update for path: ${binding.asString()}. Value was unchanged: ${oldVal}`
+          );
+        } else {
+          updates.push(update);
+          this.logger?.debug(
+            `Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`
+          );
+        }
+        return updates;
+      },
+      []
+    );
+    const result = this.getModel().set(normalizedTransaction, options);
+    const setUpdateBindings = new Set(setUpdates.map((su) => su.binding));
+    result.forEach((tr) => {
+      if (!setUpdateBindings.has(tr.binding) && (tr.force === true || !dequal(tr.oldValue, tr.newValue))) {
+        this.logger?.debug(
+          `Path: ${tr.binding.asString()} was changed from: ${tr.oldValue} to: ${tr.newValue}`
         );
-        return;
+        setUpdates.push(tr);
       }
+    });
+    this.hooks.onSet.call(normalizedTransaction);
+    if (setUpdates.length > 0) {
+      this.hooks.onUpdate.call(setUpdates, options);
     }
-    const state = this.hooks.beforeTransition.call(
-      this.currentState.value,
-      transitionValue
-    );
-    if (!("transitions" in state)) {
-      throw new Error(`No transitions defined for ${this.currentState.value}`);
+    return result;
+  }
+  resolve(binding, readOnly) {
+    return Array.isArray(binding) || typeof binding === "string" ? this.pathResolver.parse(binding, { readOnly }) : binding;
+  }
+  get(binding, options) {
+    const resolved = binding instanceof BindingInstance ? binding : this.resolve(binding, true);
+    let result = this.getModel().get(resolved, options);
+    if (result === void 0 && !options?.ignoreDefaultValue) {
+      const defaultVal = this.hooks.resolveDefaultValue.call(resolved);
+      if (defaultVal !== result) {
+        result = defaultVal;
+      }
     }
-    const { transitions } = state;
-    const nextState = transitions[transitionValue] || transitions["*"];
-    if (nextState === void 0) {
-      this.log?.warn(
-        `No transition from ${this.currentState.name} using ${transitionValue} or *`
-      );
-      return;
+    if (options?.formatted) {
+      result = this.hooks.format.call(result, resolved);
+    } else if (options?.formatted === false) {
+      result = this.hooks.deformat.call(result, resolved);
     }
-    this.log?.debug(
-      `Transitioning from ${this.currentState.name} to ${nextState} using ${transitionValue} `
-    );
-    return this.pushHistory(nextState, options);
+    this.hooks.onGet.call(binding, result);
+    return result;
   }
-  pushHistory(stateName, options) {
-    if (!Object.prototype.hasOwnProperty.call(this.flow, stateName)) {
-      throw new Error(`No flow definition for: ${stateName} was found.`);
-    }
-    let nextState = this.flow[stateName];
-    if (!this.flow[stateName] || typeof nextState !== "object" || !("state_type" in nextState)) {
-      this.log?.error(`Flow doesn't contain any states named: ${stateName}`);
-      return;
+  delete(binding, options) {
+    if (typeof binding !== "string" && !Array.isArray(binding) && !(binding instanceof BindingInstance)) {
+      throw new Error("Invalid arguments: delete expects a data path (string)");
     }
-    const prevState = this.currentState;
-    this.isTransitioning = true;
-    nextState = this.hooks.resolveTransitionNode.call(nextState);
-    const newCurrentState = {
-      name: stateName,
-      value: nextState
-    };
-    this.currentState = newCurrentState;
-    this.history.push(stateName);
-    if (newCurrentState.value.state_type === "END" && this.flow.onEnd) {
-      this.hooks.onEnd.call(this.flow.onEnd);
+    const resolved = binding instanceof BindingInstance ? binding : this.resolve(binding, false);
+    const parentBinding = resolved.parent();
+    const property = resolved.key();
+    const parentValue = this.get(parentBinding);
+    const existedBeforeDelete = typeof parentValue === "object" && parentValue !== null && Object.prototype.hasOwnProperty.call(parentValue, property);
+    this.getModel().delete(resolved, options);
+    if (existedBeforeDelete && !this.get(resolved)) {
+      this.trash.add(resolved);
     }
-    this.hooks.transition.call(prevState, {
-      ...newCurrentState
-    });
-    this.isTransitioning = false;
-    this.hooks.afterTransition.call(this);
+    this.hooks.onDelete.call(resolved);
+  }
+  serialize() {
+    return this.hooks.serialize.call(this.get(""));
+  }
+  makeReadOnly() {
+    return new ReadOnlyDataController(this);
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/flow/controller.ts
-import { SyncHook as SyncHook6 } from "tapable-ts";
-var FlowController = class {
-  constructor(navigation, options) {
-    this.hooks = {
-      flow: new SyncHook6()
-    };
-    this.navigation = navigation;
-    this.navStack = [];
-    this.log = options?.logger;
-    this.start = this.start.bind(this);
-    this.run = this.run.bind(this);
-    this.transition = this.transition.bind(this);
-    this.addNewFlow = this.addNewFlow.bind(this);
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/constants/utils.ts
+function flatten(obj, roots = [], sep = ".") {
+  return Object.keys(obj).reduce(
+    (memo, prop) => ({
+      // create a new object
+      // include previously returned object
+      ...memo,
+      ...Object.prototype.toString.call(obj[prop]) === "[object Object]" ? (
+        // keep working if value is an object
+        flatten(obj[prop], roots.concat([prop]))
+      ) : (
+        // include current prop and value and prefix prop with the roots
+        { [roots.concat([prop]).join(sep)]: obj[prop] }
+      )
+    }),
+    {}
+  );
+}
+function objectToBatchSet(obj) {
+  const flattenedObj = flatten(obj);
+  const batchTxn = [];
+  Object.keys(flattenedObj).forEach((key) => {
+    batchTxn.push([new BindingInstance(key), flattenedObj[key]]);
+  });
+  return batchTxn;
+}
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/constants/index.ts
+var ConstantsController = class {
+  constructor() {
+    this.store = /* @__PURE__ */ new Map();
+    this.tempStore = /* @__PURE__ */ new Map();
   }
-  /** Navigate to another state in the state-machine */
-  transition(stateTransition, options) {
-    if (this.current === void 0) {
-      throw new Error("Not currently in a flow. Cannot transition.");
+  addConstants(data, namespace) {
+    if (this.store.has(namespace)) {
+      this.store.get(namespace)?.set(objectToBatchSet(data));
+    } else {
+      this.store.set(namespace, new LocalModel(data));
     }
-    this.current.transition(stateTransition, options);
   }
-  addNewFlow(flow) {
-    this.navStack.push(flow);
-    this.current = flow;
-    this.hooks.flow.call(flow);
+  getConstants(key, namespace, fallback) {
+    const path = new BindingInstance(key);
+    return this.tempStore.get(namespace)?.get(path) ?? this.store.get(namespace)?.get(path) ?? fallback;
   }
-  async run(startState) {
-    if (!Object.prototype.hasOwnProperty.call(this.navigation, startState)) {
-      return Promise.reject(new Error(`No flow defined for: ${startState}`));
-    }
-    const startFlow = this.navigation[startState];
-    if (startFlow === null || typeof startFlow !== "object") {
-      return Promise.reject(
-        new Error(`Flow: ${startState} needs to be an object`)
-      );
-    }
-    this.log?.debug(`Starting flow: ${startState}`);
-    const flow = new FlowInstance(startState, startFlow, { logger: this.log });
-    this.addNewFlow(flow);
-    flow.hooks.afterTransition.tap("flow-controller", (flowInstance) => {
-      if (flowInstance.currentState?.value.state_type === "FLOW") {
-        const subflowId = flowInstance.currentState?.value.ref;
-        this.log?.debug(`Loading subflow ${subflowId}`);
-        this.run(subflowId).then((subFlowEndState) => {
-          this.log?.debug(
-            `Subflow ended. Using outcome: ${subFlowEndState.outcome}`
-          );
-          flowInstance.transition(subFlowEndState?.outcome);
-        });
-      }
-    });
-    const end = await flow.start();
-    this.navStack.pop();
-    if (this.navStack.length > 0) {
-      const firstItem = 0;
-      this.current = this.navStack[firstItem];
+  setTemporaryValues(data, namespace) {
+    if (this.tempStore.has(namespace)) {
+      this.tempStore.get(namespace)?.set(objectToBatchSet(data));
+    } else {
+      this.tempStore.set(namespace, new LocalModel(data));
     }
-    return end;
   }
-  async start() {
-    if (!this.navigation.BEGIN) {
-      return Promise.reject(new Error("Must supply a BEGIN state"));
+  clearTemporaryValues(namespace) {
+    if (namespace) {
+      this.tempStore.get(namespace)?.reset();
+    } else {
+      this.tempStore.forEach((value) => {
+        value.reset();
+      });
     }
-    return this.run(this.navigation.BEGIN);
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/validation/controller.ts
-import { SyncHook as SyncHook7, SyncWaterfallHook as SyncWaterfallHook8 } from "tapable-ts";
-import { setIn as setIn6 } from "timm";
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/utils/replaceParams.ts
-var ANY_CHAR_REGEX = /%([a-zA-Z]+)/g;
-function replaceParams(message, params) {
-  return message.slice().replace(ANY_CHAR_REGEX, (keyExpr) => params[keyExpr.slice(1)] || keyExpr);
-}
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/error/controller.ts
+import { SyncBailHook as SyncBailHook6 } from "tapable-ts";
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/validation/binding-tracker.ts
-var CONTEXT = "validation-binding-tracker";
-var ValidationBindingTrackerViewPlugin = class {
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/error/middleware.ts
+var ERROR_BINDING_PREFIX = "errorState";
+var isErrorBinding = (binding) => binding.asArray()[0] === ERROR_BINDING_PREFIX;
+var ErrorStateMiddleware = class {
   constructor(options) {
-    this.trackedBindings = /* @__PURE__ */ new Set();
-    this.options = options;
-  }
-  /** Fetch the tracked bindings in the current view */
-  getBindings() {
-    return this.trackedBindings;
-  }
-  /** Add a binding to the tracked set */
-  trackBinding(binding) {
-    if (this.trackedBindings.has(binding)) {
-      return;
-    }
-    this.trackedBindings.add(binding);
-    this.options.callbacks?.onAdd?.(binding);
+    this.name = "error-state-middleware";
+    // Internal model for error state to avoid data serialization
+    this.dataModel = new LocalModel();
+    this.logger = options.logger;
+    this.writeSymbol = options.writeSymbol;
   }
-  /** Attach hooks to the given resolver */
-  applyResolver(resolver) {
-    this.trackedBindings.clear();
-    const tracked = /* @__PURE__ */ new Map();
-    const sections = /* @__PURE__ */ new Map();
-    let lastViewUpdateChangeSet;
-    const lastComputedBindingTree = /* @__PURE__ */ new Map();
-    let currentBindingTree = /* @__PURE__ */ new Map();
-    const lastSectionBindingTree = /* @__PURE__ */ new Map();
-    const resolvedNodeMap = /* @__PURE__ */ new Map();
-    resolver.hooks.beforeUpdate.tap(CONTEXT, (changes) => {
-      lastViewUpdateChangeSet = changes;
-    });
-    resolver.hooks.skipResolve.tap(CONTEXT, (shouldSkip, node) => {
-      const trackedBindingsForNode = lastComputedBindingTree.get(node);
-      if (!shouldSkip || !lastViewUpdateChangeSet || !trackedBindingsForNode) {
-        return shouldSkip;
-      }
-      const intersection = new Set(
-        [...lastViewUpdateChangeSet].filter(
-          (b) => trackedBindingsForNode.has(b)
-        )
-      );
-      return intersection.size === 0;
-    });
-    resolver.hooks.resolveOptions.tap(CONTEXT, (options, node) => {
-      if (options.validation === void 0) {
-        return options;
-      }
-      tracked.delete(node);
-      const track = (binding) => {
-        const parsed = isBinding(binding) ? binding : this.options.parseBinding(binding);
-        if (tracked.has(node)) {
-          tracked.get(node)?.add(parsed);
-        } else {
-          tracked.set(node, /* @__PURE__ */ new Set([parsed]));
-        }
-        let { parent } = node;
-        while (parent) {
-          if (sections.has(parent)) {
-            sections.get(parent)?.add(node);
-            break;
-          } else {
-            parent = parent.parent;
-          }
-        }
-        this.trackedBindings.add(parsed);
-        this.options.callbacks?.onAdd?.(parsed);
-      };
-      return {
-        ...options,
-        validation: {
-          ...options.validation,
-          get: (binding, getOptions) => {
-            if (getOptions?.track) {
-              track(binding);
-            }
-            const eows = options.validation?._getValidationForBinding(binding)?.getAll(getOptions);
-            const firstFieldEOW = eows?.find(
-              (eow) => eow.displayTarget === "field" || eow.displayTarget === void 0
-            );
-            return firstFieldEOW;
-          },
-          getValidationsForBinding(binding, getOptions) {
-            if (getOptions?.track) {
-              track(binding);
-            }
-            return options.validation?._getValidationForBinding(binding)?.getAll(getOptions) ?? [];
-          },
-          getChildren: (type) => {
-            const validations = new Array();
-            lastComputedBindingTree.get(node)?.forEach((binding) => {
-              const eow = options.validation?._getValidationForBinding(binding)?.get();
-              if (eow && (type === void 0 || type === eow.displayTarget)) {
-                validations.push(eow);
-              }
-            });
-            return validations;
-          },
-          getValidationsForSection: () => {
-            const validations = new Array();
-            lastSectionBindingTree.get(node)?.forEach((binding) => {
-              const eow = options.validation?._getValidationForBinding(binding)?.get();
-              if (eow && eow.displayTarget === "section") {
-                validations.push(eow);
-              }
-            });
-            return validations;
-          },
-          register: (registerOptions) => {
-            if (registerOptions?.type === "section") {
-              if (!sections.has(node)) {
-                sections.set(node, /* @__PURE__ */ new Set());
-              }
-            }
-          },
-          track
-        }
-      };
+  set(transaction, options, next) {
+    const filteredTransaction = [];
+    const errorTransaction = [];
+    transaction.forEach((transaction2) => {
+      const [binding] = transaction2;
+      const targetArray = isErrorBinding(binding) ? errorTransaction : filteredTransaction;
+      targetArray.push(transaction2);
     });
-    resolver.hooks.afterNodeUpdate.tap(
-      CONTEXT,
-      (originalNode, parent, update) => {
-        const { updated, node: resolvedNode } = update;
-        resolvedNodeMap.set(resolvedNode, originalNode);
-        if (updated) {
-          const newlyComputed = new Set(tracked.get(originalNode));
-          if (resolvedNode.type === "multi-node" /* MultiNode */) {
-            resolvedNode.values.forEach(
-              (value) => currentBindingTree.get(value)?.forEach((b) => newlyComputed.add(b))
-            );
-          }
-          if ("children" in resolvedNode && resolvedNode.children) {
-            resolvedNode.children.forEach((child) => {
-              currentBindingTree.get(child.value)?.forEach((b) => newlyComputed.add(b));
-            });
-          }
-          currentBindingTree.set(resolvedNode, newlyComputed);
-        } else {
-          currentBindingTree.set(
-            resolvedNode,
-            lastComputedBindingTree.get(originalNode) ?? /* @__PURE__ */ new Set()
-          );
-        }
-        if (originalNode === resolver.root) {
-          this.trackedBindings = new Set(currentBindingTree.get(resolvedNode));
-          lastComputedBindingTree.clear();
-          currentBindingTree.forEach((value, key) => {
-            const node = resolvedNodeMap.get(key);
-            if (node) {
-              lastComputedBindingTree.set(node, value);
-            }
-          });
-          lastSectionBindingTree.clear();
-          sections.forEach((nodeSet, sectionNode) => {
-            const temp = /* @__PURE__ */ new Set();
-            nodeSet.forEach((n) => {
-              tracked.get(n)?.forEach(temp.add, temp);
-            });
-            lastSectionBindingTree.set(sectionNode, temp);
-          });
-          tracked.clear();
-          sections.clear();
-          currentBindingTree = /* @__PURE__ */ new Map();
-        }
-      }
-    );
+    const nonErrorResults = next?.set(filteredTransaction, options) ?? [];
+    const errorResults = options?.writeSymbol === this.writeSymbol ? this.dataModel.set(errorTransaction) : errorTransaction.map((transaction2) => {
+      const [binding] = transaction2;
+      this.logger?.warn(
+        `[ErrorStateMiddleware] Blocked write to protected path: ${binding.asString()}`
+      );
+      const oldValue = next?.get(binding, options);
+      return {
+        binding,
+        oldValue,
+        newValue: oldValue,
+        // Keep old value
+        force: false
+      };
+    });
+    return [...nonErrorResults, ...errorResults];
   }
-  apply(view) {
-    view.hooks.resolver.tap(CONTEXT, this.applyResolver.bind(this));
+  get(binding, options, next) {
+    return isErrorBinding(binding) ? this.dataModel.get(binding) : next?.get(binding, options);
+  }
+  delete(binding, options, next) {
+    if (!isErrorBinding(binding)) {
+      next?.delete(binding, options);
+      return;
+    }
+    if (options?.writeSymbol !== this.writeSymbol) {
+      this.logger?.warn(
+        `[ErrorStateMiddleware] Blocked delete of protected path: ${binding.asString()}`
+      );
+      return;
+    }
+    this.dataModel.delete(binding);
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/validation/controller.ts
-var SCHEMA_VALIDATION_PROVIDER_NAME = "schema";
-var VIEW_VALIDATION_PROVIDER_NAME = "view";
-var VALIDATION_PROVIDER_NAME_SYMBOL = Symbol.for(
-  "validation-provider-name"
-);
-function isSubset(subset, containingSet) {
-  if (subset.size > containingSet.size)
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/error/types.ts
+var ErrorSeverity = /* @__PURE__ */ ((ErrorSeverity2) => {
+  ErrorSeverity2["FATAL"] = "fatal";
+  ErrorSeverity2["ERROR"] = "error";
+  ErrorSeverity2["WARNING"] = "warning";
+  return ErrorSeverity2;
+})(ErrorSeverity || {});
+var ErrorTypes = {
+  EXPRESSION: "expression",
+  BINDING: "binding",
+  VIEW: "view",
+  ASSET: "asset",
+  NAVIGATION: "navigation",
+  VALIDATION: "validation",
+  DATA: "data",
+  SCHEMA: "schema",
+  NETWORK: "network",
+  PLUGIN: "plugin",
+  RENDER: "render",
+  EXTERNAL_STATE: "externalState"
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/error/utils/isErrorWithMetadata.ts
+var SEVERITY_SET = new Set(Object.values(ErrorSeverity));
+var isErrorWithMetadata = (error) => {
+  if (!("type" in error) || typeof error.type !== "string") {
     return false;
-  for (const entry of subset)
-    if (!containingSet.has(entry))
-      return false;
-  return true;
-}
-function createStatefulValidationObject(obj) {
-  return {
-    value: obj,
-    type: obj.severity,
-    state: "none",
-    isBlockingNavigation: false
+  }
+  if ("severity" in error && error.severity !== void 0 && (typeof error.severity !== "string" || !SEVERITY_SET.has(error.severity))) {
+    return false;
+  }
+  return !("metadata" in error) || error.metadata === void 0 || typeof error.metadata === "object" && error.metadata !== null && !Array.isArray(error.metadata);
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/error/utils/makeJsonStringifyReplacer.ts
+var makeJsonStringifyReplacer = () => {
+  const cache = /* @__PURE__ */ new Set();
+  return (_, value) => {
+    if (typeof value === "object" && value !== null) {
+      if (cache.has(value)) {
+        return "[CIRCULAR]";
+      }
+      cache.add(value);
+    }
+    return value;
   };
-}
-var ValidatedBinding = class {
-  constructor(possibleValidations, onDismiss, log, weakBindings) {
-    this.applicableValidations = [];
-    this.validationsByState = {
-      load: [],
-      change: [],
-      navigation: []
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/error/controller.ts
+var errorControllerWriteSymbol = Symbol(
+  "errorControllerWrite"
+);
+var ErrorController = class {
+  constructor(options) {
+    this.hooks = {
+      onError: new SyncBailHook6()
     };
-    this.onDismiss = onDismiss;
-    possibleValidations.forEach((vObj) => {
-      const { trigger } = vObj;
-      if (this.validationsByState[trigger]) {
-        const statefulValidationObject = createStatefulValidationObject(vObj);
-        this.validationsByState[trigger].push(statefulValidationObject);
-      } else {
-        log?.warn(`Unknown validation trigger: ${trigger}`);
-      }
+    /**
+     * Complete history of all captured errors in chronological order
+     * Newest errors are APPENDED to the end of the array
+     */
+    this.errorHistory = [];
+    this.options = options;
+    this.middleware = new ErrorStateMiddleware({
+      logger: options.logger,
+      writeSymbol: errorControllerWriteSymbol
     });
-    this.weakBindings = weakBindings ?? /* @__PURE__ */ new Set();
   }
-  get allValidations() {
-    return Object.values(this.validationsByState).flat();
+  /**
+   * Get the middleware for protecting errorState
+   * This should be added to DataController's middleware array
+   */
+  getDataMiddleware() {
+    return this.middleware;
   }
-  checkIfBlocking(statefulObj) {
-    if (statefulObj.state === "active") {
-      const { isBlockingNavigation } = statefulObj;
-      return isBlockingNavigation;
-    }
-    return false;
+  /**
+   * Set the DataController after initialization
+   */
+  setOptions(options) {
+    this.options.model = options.model;
   }
-  getAll() {
-    return this.applicableValidations.reduce((all, statefulObj) => {
-      if (statefulObj.state === "active" && statefulObj.response) {
-        all.push({
-          ...statefulObj.response,
-          blocking: this.checkIfBlocking(statefulObj)
-        });
-      }
-      return all;
-    }, []);
+  /**
+   * Capture an error and try to recover. Errors implementing the `PlayerErrorMetadata` interface will be added to history, fire hooks and update data model. As a fallback, all errors will try to trigger an errorTransition. If the error does not have a `type` property, it will default to only using the wildcard navigation.
+   */
+  captureError(error) {
+    if (!isErrorWithMetadata(error)) {
+      this.options.logger.debug(
+        `[ErrorController] Captured error: ${error.message}
+`,
+        "Cannot determine optional error metadata, attempting default error navigation..."
+      );
+      return this.tryNavigateToErrorState(error, "*");
+    }
+    this.errorHistory.push(error);
+    this.currentError = error;
+    this.options.logger.debug(
+      `[ErrorController] Captured error: ${error.message}`,
+      JSON.stringify(
+        {
+          errorType: error.type,
+          severity: error.severity,
+          metadata: error.metadata
+        },
+        makeJsonStringifyReplacer()
+      )
+    );
+    const shouldSkip = this.hooks.onError.call(error) ?? false;
+    if (shouldSkip) {
+      this.options.logger.debug(
+        "[ErrorController] Error state navigation skipped by plugin"
+      );
+      return true;
+    }
+    this.setErrorInDataModel(error);
+    return this.tryNavigateToErrorState(error, error.type);
   }
-  get() {
-    const firstInvalid = this.applicableValidations.find((statefulObj) => {
-      return statefulObj.state === "active" && statefulObj.response;
-    });
-    if (firstInvalid?.state === "active") {
-      return {
-        ...firstInvalid.response,
-        blocking: this.checkIfBlocking(firstInvalid)
-      };
+  /**
+   * Navigate to error state using errorTransitions.
+   * Uses errorTransition() which handles node-level and flow-level fallback internally.
+   */
+  tryNavigateToErrorState(error, transition) {
+    const flowInstance = this.options.flow.current;
+    if (!flowInstance) {
+      this.options.logger.warn(
+        "[ErrorController] No active flow instance for error navigation"
+      );
+      return false;
+    }
+    if (flowInstance.getErrorTransitionState(transition) === void 0) {
+      this.options.fail(error);
+      return false;
+    }
+    try {
+      flowInstance.errorTransition(transition);
+      return true;
+    } catch (e) {
+      this.options.logger.error(
+        `[ErrorController] Error transition failed with unexpected error: ${e}`
+      );
+      this.options.logger.debug("[ErrorController] Rejecting flow with error");
+      this.options.fail(error);
+      return false;
     }
   }
-  runApplicableValidations(runner, canDismiss, phase) {
-    this.applicableValidations = this.applicableValidations.map(
-      (originalValue) => {
-        if (originalValue.state === "dismissed") {
-          return originalValue;
-        }
-        const blocking = originalValue.value.blocking ?? (originalValue.value.severity === "warning" && "once" || true);
-        const obj = setIn6(
-          originalValue,
-          ["value", "blocking"],
-          blocking
-        );
-        const isBlockingNavigation = blocking === true || blocking === "once" && !canDismiss;
-        if (phase === "navigation" && obj.state === "active" && obj.value.blocking !== true) {
-          if (obj.value.severity === "warning") {
-            const warn = obj;
-            if (warn.dismissable && warn.response.dismiss && (warn.response.blocking !== "once" || !warn.response.blocking)) {
-              warn.response.dismiss();
-            } else {
-              if (warn?.response.blocking === "once") {
-                warn.response.blocking = false;
-              }
-              warn.dismissable = true;
-            }
-            return warn;
-          }
-        }
-        const response = runner(obj.value);
-        const newState = {
-          type: obj.type,
-          value: obj.value,
-          state: response ? "active" : "none",
-          isBlockingNavigation,
-          dismissable: obj.value.severity === "warning" && phase === "navigation",
-          response: response ? {
-            ...obj.value,
-            message: response.message ?? "Something is broken",
-            severity: obj.value.severity,
-            displayTarget: obj.value.displayTarget ?? "field"
-          } : void 0
-        };
-        if (newState.state === "active" && obj.value.severity === "warning") {
-          newState.response.dismiss = () => {
-            newState.state = "dismissed";
-            this.onDismiss?.();
-          };
-        }
-        return newState;
-      }
-    );
+  /**
+   * Get most recent error
+   */
+  getCurrentError() {
+    return this.currentError;
   }
-  update(phase, canDismiss, runner) {
-    const newApplicableValidations = [];
-    if (phase === "load" && this.currentPhase !== void 0) {
+  /**
+   * Get error history (read-only)
+   */
+  getErrors() {
+    return this.errorHistory;
+  }
+  /**
+   * Clear all errors (history + current + data model)
+   */
+  clearErrors() {
+    this.errorHistory = [];
+    this.currentError = void 0;
+    this.deleteErrorFromDataModel();
+    this.options.logger.debug("[ErrorController] All errors cleared");
+  }
+  /**
+   * Clear only current error and remove from data model, preserve history
+   */
+  clearCurrentError() {
+    this.currentError = void 0;
+    this.deleteErrorFromDataModel();
+    this.options.logger.debug("[ErrorController] Current error cleared");
+  }
+  /**
+   * Write error to data model errorState
+   */
+  setErrorInDataModel(playerError) {
+    if (!this.options.model) {
+      this.options.logger.warn("[ErrorController] No DataController available");
       return;
     }
-    if (this.currentPhase === "navigation" || phase === this.currentPhase) {
-      this.runApplicableValidations(runner, canDismiss, phase);
+    try {
+      const { type, severity, metadata, name, message } = playerError;
+      this.options.model.set(
+        [
+          [
+            "errorState",
+            {
+              message,
+              name,
+              errorType: type,
+              severity,
+              ...metadata
+            }
+          ]
+        ],
+        { writeSymbol: errorControllerWriteSymbol }
+      );
+      this.options.logger.debug(
+        "[ErrorController] Error set in data model at 'data.errorState'"
+      );
+    } catch (e) {
+      this.options.logger.error(
+        "[ErrorController] Failed to set error in data model",
+        e
+      );
+    }
+  }
+  /**
+   * Remove errorState from data model
+   */
+  deleteErrorFromDataModel() {
+    if (!this.options.model) {
       return;
     }
-    if (phase === "load") {
-      this.currentPhase = "load";
-      this.applicableValidations = [...this.validationsByState.load];
-    } else if (phase === "change" && this.currentPhase === "load") {
-      this.currentPhase = "change";
-      this.applicableValidations = [
-        ...this.applicableValidations,
-        ...this.validationsByState.change
-      ];
-    } else if (phase === "navigation" && (this.currentPhase === "load" || this.currentPhase === "change")) {
-      this.applicableValidations.forEach((element) => {
-        if (!(element.type === "error" && element.state === "active" && element.isBlockingNavigation === false)) {
-          newApplicableValidations.push(element);
-        }
+    try {
+      this.options.model.delete("errorState", {
+        writeSymbol: errorControllerWriteSymbol
+      });
+      this.options.logger.debug(
+        "[ErrorController] errorState deleted from data model"
+      );
+    } catch (e) {
+      this.options.logger.error(
+        "[ErrorController] Failed to delete errorState from data model",
+        e
+      );
+    }
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/resolver/ResolverError.ts
+var ResolverError = class extends Error {
+  constructor(cause, stage, node) {
+    super(`An error in the resolver occurred at stage '${stage}'`);
+    this.cause = cause;
+    this.stage = stage;
+    this.type = ErrorTypes.VIEW;
+    this.severity = "error" /* ERROR */;
+    this.metadata = {
+      node
+    };
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/resolver/index.ts
+var withContext = (model) => {
+  return {
+    get: (binding, options) => {
+      return model.get(binding, {
+        context: { model },
+        ...options
+      });
+    },
+    set: (transaction, options) => {
+      return model.set(transaction, {
+        context: { model },
+        ...options
+      });
+    },
+    delete: (binding, options) => {
+      return model.delete(binding, {
+        context: { model },
+        ...options
       });
-      this.applicableValidations = [
-        ...newApplicableValidations,
-        ...this.validationsByState.navigation,
-        ...this.currentPhase === "load" ? this.validationsByState.change : []
-      ];
-      this.currentPhase = "navigation";
     }
-    this.runApplicableValidations(runner, canDismiss, phase);
-  }
+  };
 };
-var ValidationController = class {
-  constructor(schema, options) {
+var Resolver = class {
+  constructor(root, options) {
     this.hooks = {
-      /** A hook called to tap into the validator registry for adding more validators */
-      createValidatorRegistry: new SyncHook7(),
-      /** A callback/event when a new validation is added to the view */
-      onAddValidation: new SyncWaterfallHook8(),
-      /** The inverse of onAddValidation, this is called when a validation is removed from the list */
-      onRemoveValidation: new SyncWaterfallHook8(),
-      resolveValidationProviders: new SyncWaterfallHook8(),
-      /** A hook called when a binding is added to the tracker */
-      onTrackBinding: new SyncHook7()
+      skipResolve: new SyncWaterfallHook9(),
+      beforeUpdate: new SyncHook8(),
+      afterUpdate: new SyncHook8(),
+      resolveOptions: new SyncWaterfallHook9(),
+      beforeResolve: new SyncWaterfallHook9(),
+      resolve: new SyncWaterfallHook9(),
+      afterResolve: new SyncWaterfallHook9(),
+      afterNodeUpdate: new SyncHook8()
     };
-    this.validations = /* @__PURE__ */ new Map();
-    this.weakBindingTracker = /* @__PURE__ */ new Set();
-    this.schema = schema;
+    this.root = root;
     this.options = options;
-    this.reset();
+    this.resolveCache = /* @__PURE__ */ new Map();
+    this.ASTMap = /* @__PURE__ */ new Map();
+    this.logger = options.logger;
+    this.idCache = /* @__PURE__ */ new Set();
   }
-  setOptions(options) {
-    this.options = options;
+  getSourceNode(convertedAST) {
+    return this.ASTMap.get(convertedAST);
   }
-  /** Return the middleware for the data-model to stop propagation of invalid data */
-  getDataMiddleware() {
-    return [
-      {
-        set: (transaction, options, next) => {
-          return next?.set(transaction, options) ?? [];
-        },
-        get: (binding, options, next) => {
-          return next?.get(binding, options);
-        },
-        delete: (binding, options, next) => {
-          this.validations = removeBindingAndChildrenFromMap(
-            this.validations,
-            binding
-          );
-          return next?.delete(binding, options);
+  update(dataChanges, nodeChanges) {
+    this.hooks.beforeUpdate.call(dataChanges);
+    const resolveCache = /* @__PURE__ */ new Map();
+    this.idCache.clear();
+    const prevASTMap = new Map(this.ASTMap);
+    this.ASTMap.clear();
+    const realNodeChanges = /* @__PURE__ */ new Set();
+    for (const node of nodeChanges?.values() ?? []) {
+      let current = node;
+      while (current) {
+        const original = prevASTMap.get(current) ?? current;
+        if (realNodeChanges.has(original)) {
+          break;
         }
-      },
-      new ValidationMiddleware(
-        (binding) => {
-          if (!this.options) {
-            return;
-          }
-          this.updateValidationsForBinding(binding, "change", this.options);
-          const strongValidation = this.getValidationForBinding(binding);
-          if (strongValidation?.get()?.severity === "error") {
-            return strongValidation.get();
-          }
-          const newInvalidBindings = /* @__PURE__ */ new Set();
-          this.validations.forEach((weakValidation, strongBinding) => {
-            if (caresAboutDataChanges(
-              /* @__PURE__ */ new Set([binding]),
-              weakValidation.weakBindings
-            ) && weakValidation?.get()?.severity === "error") {
-              weakValidation?.weakBindings.forEach((weakBinding) => {
-                if (weakBinding === strongBinding) {
-                  newInvalidBindings.add({
-                    binding: weakBinding,
-                    isStrong: true
-                  });
-                } else {
-                  newInvalidBindings.add({
-                    binding: weakBinding,
-                    isStrong: false
-                  });
-                }
-              });
-            }
-          });
-          if (newInvalidBindings.size > 0) {
-            return newInvalidBindings;
-          }
-        },
-        { logger: new ProxyLogger(() => this.options?.logger) }
-      )
-    ];
+        realNodeChanges.add(original);
+        current = current.parent;
+      }
+    }
+    const updated = this.computeTree(
+      this.root,
+      void 0,
+      dataChanges,
+      resolveCache,
+      toNodeResolveOptions(this.options),
+      void 0,
+      prevASTMap,
+      realNodeChanges
+    );
+    this.resolveCache = resolveCache;
+    this.hooks.afterUpdate.call(updated.value);
+    return updated.value;
   }
-  getValidationProviders() {
-    if (this.providers) {
-      return this.providers;
+  getResolveCache() {
+    return new Map(this.resolveCache);
+  }
+  getPreviousResult(node) {
+    if (!node) {
+      return;
     }
-    this.providers = this.hooks.resolveValidationProviders.call([
-      {
-        source: SCHEMA_VALIDATION_PROVIDER_NAME,
-        provider: this.schema
-      },
-      {
-        source: VIEW_VALIDATION_PROVIDER_NAME,
-        provider: {
-          getValidationsForBinding: (binding) => {
-            return this.viewValidationProvider?.getValidationsForBinding?.(
-              binding
+    const isFirstUpdate = this.resolveCache.size === 0;
+    const id = getNodeID(node);
+    if (id) {
+      if (this.idCache.has(id)) {
+        if (isFirstUpdate) {
+          if (node.type === "asset" /* Asset */ || node.type === "view" /* View */) {
+            this.logger?.error(
+              `Cache conflict: Found Asset/View nodes that have conflicting ids: ${id}, may cause cache issues.`
+            );
+          } else if (node.type === "value" /* Value */) {
+            this.logger?.info(
+              `Cache conflict: Found Value nodes that have conflicting ids: ${id}, may cause cache issues. To improve performance make value node IDs globally unique.`
             );
-          },
-          getValidationsForView: () => {
-            return this.viewValidationProvider?.getValidationsForView?.();
           }
         }
+        return;
       }
-    ]);
-    return this.providers;
+      this.idCache.add(id);
+    }
+    return this.resolveCache.get(node);
   }
-  reset() {
-    this.validations.clear();
-    this.tracker = void 0;
+  cloneNode(node) {
+    const clonedNode = clone(node);
+    Object.keys(clonedNode).forEach((key) => {
+      if (key === "parent")
+        return;
+      const value = clonedNode[key];
+      if (typeof value === "object" && value !== null) {
+        clonedNode[key] = Array.isArray(value) ? [...value] : { ...value };
+      }
+    });
+    return clonedNode;
   }
-  onView(view) {
-    this.validations.clear();
-    if (!this.options) {
-      return;
+  computeTree(node, rawParent, dataChanges, cacheUpdate, options, partiallyResolvedParent, prevASTMap, nodeChanges) {
+    const dependencyModel = new DependencyModel(options.data.model);
+    dependencyModel.trackSubset("core");
+    const depModelWithParser = withContext(
+      withParser(dependencyModel, this.options.parseBinding)
+    );
+    let resolveOptions = {
+      ...options,
+      data: {
+        ...options.data,
+        model: depModelWithParser
+      },
+      evaluate: (exp) => this.options.evaluator.evaluate(exp, { model: depModelWithParser }),
+      node
+    };
+    try {
+      resolveOptions = this.hooks.resolveOptions.call(resolveOptions, node);
+    } catch (err) {
+      throw new ResolverError(err, "resolveOptions" /* ResolveOptions */, node);
     }
-    const bindingTrackerPlugin = new ValidationBindingTrackerViewPlugin({
-      ...this.options,
-      callbacks: {
-        onAdd: (binding) => {
-          if (!this.options || this.getValidationForBinding(binding) !== void 0) {
+    const previousResult = this.getPreviousResult(node);
+    const previousDeps = previousResult?.dependencies;
+    const isChanged = nodeChanges.has(node);
+    const dataChanged = caresAboutDataChanges(dataChanges, previousDeps);
+    let shouldUseLastValue = !dataChanged && !isChanged;
+    try {
+      shouldUseLastValue = this.hooks.skipResolve.call(
+        shouldUseLastValue,
+        node,
+        resolveOptions
+      );
+    } catch (err) {
+      throw new ResolverError(err, "skipResolve" /* SkipResolve */, node);
+    }
+    if (previousResult && shouldUseLastValue) {
+      const update2 = {
+        ...previousResult,
+        updated: false
+      };
+      const repopulateASTMapFromCache = (resolvedNode, AST, ASTParent) => {
+        const { node: resolvedASTLocal } = resolvedNode;
+        this.ASTMap.set(resolvedASTLocal, AST);
+        const resolvedUpdate = {
+          ...resolvedNode,
+          updated: false
+        };
+        cacheUpdate.set(AST, resolvedUpdate);
+        const handleChildNode = (childNode) => {
+          const originalChildNode = prevASTMap.get(childNode) ?? childNode;
+          const previousChildResult = this.getPreviousResult(originalChildNode);
+          if (!previousChildResult)
             return;
-          }
-          const originalValue = this.options.model.get(binding);
-          const withoutDefault = this.options.model.get(binding, {
-            ignoreDefaultValue: true
-          });
-          if (originalValue !== withoutDefault) {
-            this.options.model.set([[binding, originalValue]], {
-              silent: true
-            });
-          }
-          this.updateValidationsForBinding(
-            binding,
-            "load",
-            this.options,
-            () => {
-              view.update(/* @__PURE__ */ new Set([binding]));
-            }
+          repopulateASTMapFromCache(
+            previousChildResult,
+            originalChildNode,
+            AST
           );
-          this.hooks.onTrackBinding.call(binding);
+        };
+        if ("children" in resolvedASTLocal) {
+          resolvedASTLocal.children?.forEach(
+            ({ value: childAST }) => handleChildNode(childAST)
+          );
+        } else if (resolvedASTLocal.type === "multi-node" /* MultiNode */) {
+          resolvedASTLocal.values.forEach(handleChildNode);
         }
-      }
-    });
-    this.tracker = bindingTrackerPlugin;
-    this.viewValidationProvider = view;
-    bindingTrackerPlugin.apply(view);
-  }
-  updateValidationsForBinding(binding, trigger, validationContext, onDismiss) {
-    const context = validationContext ?? this.options;
-    if (!context) {
-      throw new Error(`Context is required for executing validations`);
+        try {
+          this.hooks.afterNodeUpdate.call(AST, ASTParent, resolvedUpdate);
+        } catch (err) {
+          throw new ResolverError(err, "afterNodeUpdate" /* AfterNodeUpdate */, node);
+        }
+      };
+      previousResult.node.parent = partiallyResolvedParent;
+      repopulateASTMapFromCache(previousResult, node, rawParent);
+      return update2;
+    }
+    let resolvedAST = {
+      ...this.cloneNode(node),
+      parent: partiallyResolvedParent
+    };
+    try {
+      resolvedAST = this.hooks.beforeResolve.call(
+        resolvedAST,
+        resolveOptions
+      ) ?? {
+        type: "empty" /* Empty */
+      };
+    } catch (err) {
+      throw new ResolverError(err, "beforeResolve" /* BeforeResolve */, node);
     }
-    if (trigger === "load") {
-      const possibleValidations = this.getValidationProviders().reduce((vals, provider) => {
-        vals.push(
-          ...provider.provider.getValidationsForBinding?.(binding)?.map((valObj) => ({
-            ...valObj,
-            [VALIDATION_PROVIDER_NAME_SYMBOL]: provider.source
-          })) ?? []
-        );
-        return vals;
-      }, []);
-      if (possibleValidations.length === 0) {
-        return;
-      }
-      this.validations.set(
-        binding,
-        new ValidatedBinding(
-          possibleValidations,
-          onDismiss,
-          this.options?.logger
-        )
+    resolvedAST.parent = partiallyResolvedParent;
+    resolveOptions.node = resolvedAST;
+    this.ASTMap.set(resolvedAST, node);
+    let resolved = void 0;
+    try {
+      resolved = this.hooks.resolve.call(
+        void 0,
+        resolvedAST,
+        resolveOptions
       );
+    } catch (err) {
+      throw new ResolverError(err, "resolve" /* Resolve */, node);
     }
-    const trackedValidations = this.validations.get(binding);
-    trackedValidations?.update(trigger, true, (validationObj) => {
-      const response = this.validationRunner(validationObj, binding, context);
-      if (this.weakBindingTracker.size > 0) {
-        const t2 = this.validations.get(binding);
-        this.weakBindingTracker.forEach((b) => t2.weakBindings.add(b));
-      }
-      return response ? { message: response.message } : void 0;
-    });
-    if (trigger !== "load") {
-      this.validations.forEach((validation, vBinding) => {
-        if (vBinding !== binding && caresAboutDataChanges(/* @__PURE__ */ new Set([binding]), validation.weakBindings)) {
-          validation.update(trigger, true, (validationObj) => {
-            const response = this.validationRunner(
-              validationObj,
-              vBinding,
-              context
+    let updated = !dequal2(previousResult?.value, resolved);
+    if (previousResult && !updated) {
+      resolved = previousResult?.value;
+    }
+    const childDependencies = /* @__PURE__ */ new Set();
+    dependencyModel.trackSubset("children");
+    if ("children" in resolvedAST) {
+      const newChildren = resolvedAST.children?.map((child) => {
+        const computedChildTree = this.computeTree(
+          child.value,
+          node,
+          dataChanges,
+          cacheUpdate,
+          resolveOptions,
+          resolvedAST,
+          prevASTMap,
+          nodeChanges
+        );
+        const {
+          dependencies: childTreeDeps,
+          node: childNode,
+          updated: childUpdated,
+          value: childValue
+        } = computedChildTree;
+        childTreeDeps.forEach((binding) => childDependencies.add(binding));
+        if (childValue) {
+          if (childNode.type === "multi-node" /* MultiNode */ && !childNode.override) {
+            const arr = addLast(
+              dlv(resolved, child.path, []),
+              childValue
             );
-            return response ? { message: response.message } : void 0;
-          });
+            resolved = setIn6(resolved, child.path, arr);
+          } else {
+            resolved = setIn6(resolved, child.path, childValue);
+          }
+        }
+        updated = updated || childUpdated;
+        return { ...child, value: childNode };
+      });
+      resolvedAST.children = newChildren;
+    } else if (resolvedAST.type === "multi-node" /* MultiNode */) {
+      const childValue = [];
+      const rawParentToPassIn = node;
+      resolvedAST.values = resolvedAST.values.map((mValue) => {
+        const mTree = this.computeTree(
+          mValue,
+          rawParentToPassIn,
+          dataChanges,
+          cacheUpdate,
+          resolveOptions,
+          resolvedAST,
+          prevASTMap,
+          nodeChanges
+        );
+        if (mTree.value !== void 0 && mTree.value !== null) {
+          mTree.dependencies.forEach(
+            (bindingDep) => childDependencies.add(bindingDep)
+          );
+          updated = updated || mTree.updated;
+          childValue.push(mTree.value);
         }
+        return mTree.node;
       });
+      resolved = childValue;
     }
-  }
-  validationRunner(validationObj, binding, context = this.options) {
-    if (!context) {
-      throw new Error("No context provided to validation runner");
+    childDependencies.forEach(
+      (bindingDep) => dependencyModel.addChildReadDep(bindingDep)
+    );
+    dependencyModel.trackSubset("core");
+    if (previousResult && !updated) {
+      resolved = previousResult?.value;
     }
-    const handler = validationObj.handler ?? this.getValidator(validationObj.type);
-    const weakBindings = /* @__PURE__ */ new Set();
-    const model = {
-      get(b, options) {
-        weakBindings.add(isBinding(b) ? binding : context.parseBinding(b));
-        return context.model.get(b, { ...options, includeInvalid: true });
-      },
-      set: context.model.set,
-      delete: context.model.delete
+    try {
+      resolved = this.hooks.afterResolve.call(resolved, resolvedAST, {
+        ...resolveOptions,
+        getDependencies: (scope) => dependencyModel.getDependencies(scope)
+      });
+    } catch (err) {
+      throw new ResolverError(err, "afterResolve" /* AfterResolve */, node);
+    }
+    const update = {
+      node: resolvedAST,
+      updated,
+      value: resolved,
+      dependencies: /* @__PURE__ */ new Set([
+        ...dependencyModel.getDependencies(),
+        ...childDependencies
+      ])
     };
-    const result = handler?.(
-      {
-        ...context,
-        evaluate: (exp, options = { model }) => context.evaluate(exp, options),
-        model,
-        validation: validationObj,
-        schemaType: this.schema.getType(binding)
-      },
-      context.model.get(binding, {
-        includeInvalid: true,
-        formatted: validationObj.dataTarget === "formatted"
-      }),
-      validationObj
-    );
-    this.weakBindingTracker = weakBindings;
-    if (result) {
-      let { message } = result;
-      const { parameters } = result;
-      if (validationObj.message) {
-        message = resolveDataRefs(validationObj.message, {
-          model,
-          evaluate: context.evaluate
-        });
-        if (parameters) {
-          message = replaceParams(message, parameters);
+    try {
+      this.hooks.afterNodeUpdate.call(node, rawParent, update);
+    } catch (err) {
+      throw new ResolverError(err, "afterNodeUpdate" /* AfterNodeUpdate */, node);
+    }
+    cacheUpdate.set(node, update);
+    return update;
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/view.ts
+var CrossfieldProvider = class {
+  constructor(initialView, parser, logger) {
+    this.allValidations = /* @__PURE__ */ new Set();
+    this.byBinding = /* @__PURE__ */ new Map();
+    this.logger = logger;
+    this.parse(initialView, parser);
+  }
+  parse(contentView, parser) {
+    const xfieldRefs = contentView.validation;
+    if (xfieldRefs === void 0) {
+      return;
+    }
+    if (!Array.isArray(xfieldRefs)) {
+      this.logger?.warn(
+        `Unable to register view validations for id: ${contentView.id}. 'validation' property must be an Array.`
+      );
+      return;
+    }
+    xfieldRefs.forEach((vRef) => {
+      const withDefaults = {
+        trigger: "navigation",
+        severity: "error",
+        ...vRef
+      };
+      this.allValidations.add(withDefaults);
+      const { ref } = vRef;
+      if (ref) {
+        const parsed = parser(ref);
+        if (this.byBinding.has(parsed)) {
+          this.byBinding.get(parsed)?.push(withDefaults);
+        } else {
+          this.byBinding.set(parsed, [withDefaults]);
         }
       }
-      return {
-        message
-      };
-    }
+    });
   }
-  updateValidationsForView(trigger) {
-    const isNavigationTrigger = trigger === "navigation";
-    const lastActiveBindings = this.activeBindings;
-    const updateValidations = (dismissValidations) => {
-      this.getBindings().forEach((binding) => {
-        this.validations.get(binding)?.update(trigger, dismissValidations, (obj) => {
-          if (!this.options) {
-            return;
-          }
-          return this.validationRunner(obj, binding, this.options);
-        });
-      });
+  getValidationsForBinding(binding) {
+    return this.byBinding.get(binding);
+  }
+};
+var ViewInstance = class {
+  constructor(initialView, resolverOptions) {
+    this.hooks = {
+      onUpdate: new SyncHook9(),
+      parser: new SyncHook9(),
+      resolver: new SyncHook9(),
+      templatePlugin: new SyncHook9()
     };
-    updateValidations(!isNavigationTrigger);
-    if (isNavigationTrigger) {
-      const { activeBindings } = this;
-      if (isSubset(activeBindings, lastActiveBindings)) {
-        updateValidations(true);
+    this.initialView = initialView;
+    this.resolverOptions = resolverOptions;
+  }
+  /** @deprecated use ViewController.updateViewAST */
+  updateAsync(asyncNode) {
+    const update = this.resolver?.update();
+    this.lastUpdate = update;
+    this.hooks.onUpdate.call(update);
+  }
+  update(changes, nodeChanges) {
+    if (this.rootNode === void 0) {
+      this.validationProvider = new CrossfieldProvider(
+        this.initialView,
+        this.resolverOptions.parseBinding,
+        this.resolverOptions.logger
+      );
+      if (this.templatePlugin) {
+        this.hooks.templatePlugin.call(this.templatePlugin);
+      } else {
+        this.resolverOptions.logger?.warn(
+          "templatePlugin not set for View, legacy templates may not work"
+        );
       }
+      const parser = new Parser();
+      this.hooks.parser.call(parser);
+      this.rootNode = parser.parseView(this.initialView);
+      this.resolver = new Resolver(this.rootNode, {
+        ...this.resolverOptions,
+        parseNode: parser.parseObject.bind(parser)
+      });
+      this.hooks.resolver.call(this.resolver);
+    }
+    const update = this.resolver?.update(changes, nodeChanges);
+    if (this.lastUpdate === update) {
+      return this.lastUpdate;
     }
+    this.lastUpdate = update;
+    this.hooks.onUpdate.call(update);
+    return update;
   }
-  get activeBindings() {
-    return new Set(
-      Array.from(this.getBindings()).filter(
-        (b) => this.validations.get(b)?.get() !== void 0
-      )
-    );
+  getValidationsForBinding(binding) {
+    return this.validationProvider?.getValidationsForBinding(binding);
   }
-  getValidator(type) {
-    if (this.validatorRegistry) {
-      return this.validatorRegistry.get(type);
-    }
-    const registry = new ValidatorRegistry();
-    this.hooks.createValidatorRegistry.call(registry);
-    this.validatorRegistry = registry;
-    return registry.get(type);
+  setTemplatePlugin(plugin) {
+    this.templatePlugin = plugin;
   }
-  getBindings() {
-    return this.tracker?.getBindings() ?? /* @__PURE__ */ new Set();
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/builder/index.ts
+var Builder = class _Builder {
+  /**
+   * Creates an asset node
+   *
+   * @param value - the value to put in the asset node
+   */
+  static asset(value) {
+    return {
+      type: "asset" /* Asset */,
+      value
+    };
   }
-  trackBinding(binding) {
-    this.tracker?.trackBinding(binding);
+  static assetWrapper(value) {
+    const valueNode = _Builder.value();
+    _Builder.addChild(valueNode, "asset", value);
+    return valueNode;
   }
-  /** Executes all known validations for the tracked bindings using the given model */
-  validateView(trigger = "navigation") {
-    this.updateValidationsForView(trigger);
-    const validations = /* @__PURE__ */ new Map();
-    let canTransition = true;
-    this.getBindings().forEach((b) => {
-      const allValidations = this.getValidationForBinding(b)?.getAll();
-      allValidations?.forEach((v) => {
-        if (trigger === "navigation" && v.blocking) {
-          this.options?.logger.debug(
-            `Validation on binding: ${b.asString()} is preventing navigation. ${JSON.stringify(
-              v
-            )}`
-          );
-          canTransition = false;
-        }
-        if (!validations.has(b)) {
-          validations.set(b, v);
-        }
-      });
-    });
+  /**
+   * Creates a value node
+   *
+   * @param v - The object to put in the value node
+   */
+  static value(v) {
     return {
-      canTransition,
-      validations: validations.size ? validations : void 0
+      type: "value" /* Value */,
+      value: v
     };
   }
-  /** Get the current tracked validation for the given binding */
-  getValidationForBinding(binding) {
-    return this.validations.get(binding);
+  /**
+   * Creates a multiNode and associates the multiNode as the parent
+   * of all the value nodes
+   *
+   * @param values - the value, applicability or async nodes to put in the multinode
+   */
+  static multiNode(...values) {
+    const m = {
+      type: "multi-node" /* MultiNode */,
+      override: true,
+      values
+    };
+    values.forEach((v) => {
+      v.parent = m;
+    });
+    return m;
   }
-  forView(parser) {
+  /**
+   * Creates an async node
+   *
+   * @param id - the id of async node. It should be identical for each async node
+   */
+  static asyncNode(id, flatten2 = true, onValueReceived) {
     return {
-      _getValidationForBinding: (binding) => {
-        return this.getValidationForBinding(
-          isBinding(binding) ? binding : parser(binding)
-        );
-      },
-      getAll: () => {
-        const bindings = this.getBindings();
-        if (bindings.size === 0) {
-          return void 0;
+      id,
+      type: "async" /* Async */,
+      flatten: flatten2,
+      onValueReceived,
+      value: {
+        type: "value" /* Value */,
+        value: {
+          id
         }
-        const validationMapping = /* @__PURE__ */ new Map();
-        bindings.forEach((b) => {
-          const validation = this.getValidationForBinding(b)?.get();
-          if (validation) {
-            validationMapping.set(b, validation);
-          }
-        });
-        return validationMapping.size === 0 ? void 0 : validationMapping;
-      },
-      get() {
-        throw new Error("Error Access be provided by the view plugin");
-      },
-      getValidationsForBinding() {
-        throw new Error("Error rollup should be provided by the view plugin");
-      },
-      getChildren() {
-        throw new Error("Error rollup should be provided by the view plugin");
-      },
-      getValidationsForSection() {
-        throw new Error("Error rollup should be provided by the view plugin");
-      },
-      track: () => {
-        throw new Error("Tracking should be provided by the view plugin");
-      },
-      register: () => {
-        throw new Error(
-          "Section functionality should be provided by the view plugin"
-        );
-      },
-      type: (binding) => this.schema.getType(isBinding(binding) ? binding : parser(binding))
+      }
+    };
+  }
+  /**
+   * Adds a child node to a node
+   *
+   * @param node - The node to add a child to
+   * @param path - The path at which to add the child
+   * @param child - The child node
+   */
+  static addChild(node, path, child) {
+    child.parent = node;
+    const newChild = {
+      path: Array.isArray(path) ? path : [path],
+      value: child
+    };
+    node.children = node.children || [];
+    node.children.push(newChild);
+    return node;
+  }
+  /**
+   * Updates children of a node of the same path and preserves order
+   *
+   * @param node - The node to update children for
+   * @param pathToMatch - The path to match against child paths
+   * @param mapFn - Function to transform matching children
+   */
+  static updateChildrenByPath(node, pathToMatch, updateFn) {
+    if (!node.children)
+      return node;
+    const updatedChildren = node.children.map(
+      (child) => (
+        // Check if paths match exactly
+        child.path.join() === pathToMatch.join() ? { ...child, value: updateFn(child) } : child
+      )
+    );
+    return {
+      ...node,
+      children: updatedChildren
     };
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/view/controller.ts
-import { SyncHook as SyncHook8, SyncWaterfallHook as SyncWaterfallHook9 } from "tapable-ts";
-import queueMicrotask from "queue-microtask";
-import { Registry } from "@player-ui/partial-match-registry";
-var mergeSets = (setA, setB) => {
-  return /* @__PURE__ */ new Set([...setA?.values() ?? [], ...setB?.values() ?? []]);
-};
-var ViewController = class {
-  constructor(initialViews, options) {
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/template.ts
+import { SyncWaterfallHook as SyncWaterfallHook10 } from "tapable-ts";
+var templateSymbol = Symbol("template");
+var TemplatePlugin = class {
+  constructor(options) {
     this.hooks = {
-      resolveView: new SyncWaterfallHook9(),
-      view: new SyncHook8()
+      resolveTemplateSubstitutions: new SyncWaterfallHook10()
     };
-    this.transformRegistry = new Registry();
-    this.optimizeUpdates = true;
-    this.viewOptions = options;
-    this.viewMap = initialViews.reduce(
-      (viewMap, view) => {
-        viewMap[view.id] = view;
-        return viewMap;
-      },
-      {}
-    );
-    options.flowController.hooks.flow.tap(
-      "viewController",
-      (flow) => {
-        flow.hooks.transition.tap("viewController", (_oldState, newState) => {
-          if (newState.value.state_type === "VIEW") {
-            this.onView(newState.value);
-          } else {
-            this.currentView = void 0;
+    this.options = options;
+  }
+  parseTemplate(parseObject, node, options) {
+    const { template, depth } = node;
+    const data = options.data.model.get(node.data);
+    if (!data) {
+      return null;
+    }
+    if (!Array.isArray(data)) {
+      throw new Error(`Template using '${node.data}' but is not an array`);
+    }
+    const values = [];
+    data.forEach((dataItem, index) => {
+      const templateSubstitutions = this.hooks.resolveTemplateSubstitutions.call(
+        [
+          {
+            expression: new RegExp(`_index${depth || ""}_`),
+            value: String(index)
           }
-        });
-      }
-    );
-    const update = (updates, silent = false) => {
-      if (this.currentView) {
-        if (this.optimizeUpdates) {
-          this.queueUpdate(updates, void 0, silent);
-        } else {
-          this.currentView.update();
+        ],
+        {
+          depth,
+          data: dataItem,
+          index
+        }
+      );
+      let templateStr = JSON.stringify(template);
+      for (const { expression, value } of templateSubstitutions) {
+        let flags = "g";
+        if (typeof expression === "object") {
+          flags = `${expression.flags}${expression.global ? "" : "g"}`;
         }
+        templateStr = templateStr.replace(new RegExp(expression, flags), value);
+      }
+      const parsed = parseObject(JSON.parse(templateStr), "value" /* Value */, {
+        templateDepth: node.depth + 1
+      });
+      if (parsed) {
+        values.push(parsed);
       }
+    });
+    const result = {
+      type: "multi-node" /* MultiNode */,
+      override: false,
+      values
     };
-    options.model.hooks.onUpdate.tap(
-      "viewController",
-      (updates, updateOptions) => {
-        update(
-          new Set(updates.map((t2) => t2.binding)),
-          updateOptions?.silent ?? false
+    if (node.placement !== void 0) {
+      result[templateSymbol] = node.placement;
+    }
+    return result;
+  }
+  applyParser(parser) {
+    parser.hooks.onCreateASTNode.tap("template", (node) => {
+      if (node && node.type === "template" /* Template */ && !node.dynamic) {
+        return this.parseTemplate(
+          parser.parseObject.bind(parser),
+          node,
+          this.options
         );
       }
+      return node;
+    });
+    parser.hooks.onCreateASTNode.tap("template", (node) => {
+      function getTemplateSymbolValue(node2) {
+        if (node2.type === "multi-node" /* MultiNode */) {
+          return node2[templateSymbol];
+        } else if (node2.type === "template" /* Template */) {
+          return node2.placement;
+        }
+        return void 0;
+      }
+      if (node && (node.type === "view" /* View */ || node.type === "asset" /* Asset */) && Array.isArray(node.children)) {
+        node.children = node.children.sort((a, b) => {
+          const aPath = a.path.join();
+          const bPath = b.path.join();
+          const pathsEqual = aPath === bPath;
+          if (pathsEqual) {
+            const aPlacement = getTemplateSymbolValue(a.value);
+            const bPlacement = getTemplateSymbolValue(b.value);
+            if (aPlacement !== void 0 && bPlacement === void 0) {
+              return aPlacement === "prepend" ? -1 : 1;
+            } else if (bPlacement !== void 0 && aPlacement === void 0) {
+              return bPlacement === "prepend" ? 1 : -1;
+            } else if (aPlacement !== void 0 && bPlacement !== void 0) {
+              if (aPlacement === bPlacement) {
+                return 0;
+              }
+              return aPlacement === "prepend" ? -1 : 1;
+            }
+            return 0;
+          }
+          return aPath > bPath ? 1 : -1;
+        });
+      }
+      return node;
+    });
+    parser.hooks.parseNode.tap(
+      "template",
+      (obj, _nodeType, options, childOptions) => {
+        if (childOptions && hasTemplateKey(childOptions.key)) {
+          return obj.map((template) => {
+            const templateAST = parser.createASTNode(
+              {
+                type: "template" /* Template */,
+                depth: options.templateDepth ?? 0,
+                data: template.data,
+                template: template.value,
+                dynamic: template.dynamic ?? false,
+                placement: template.placement
+              },
+              template
+            );
+            if (!templateAST)
+              return;
+            if (templateAST.type === "multi-node" /* MultiNode */) {
+              templateAST.values.forEach((v) => {
+                v.parent = templateAST;
+              });
+            }
+            return {
+              path: [...childOptions.path, template.output],
+              value: templateAST
+            };
+          }).filter(Boolean);
+        }
+      }
     );
-    options.model.hooks.onDelete.tap("viewController", (binding) => {
-      const parentBinding = binding.parent();
-      const property = binding.key();
-      if (typeof property === "number" && parentBinding) {
-        update(/* @__PURE__ */ new Set([parentBinding]));
-      } else {
-        update(/* @__PURE__ */ new Set([binding]));
+  }
+  applyResolverHooks(resolver) {
+    resolver.hooks.beforeResolve.tap("template", (node, options) => {
+      if (node && node.type === "template" /* Template */ && node.dynamic) {
+        return this.parseTemplate(options.parseNode, node, options);
       }
+      return node;
     });
-    this.viewPlugins = this.createViewPlugins();
   }
-  queueUpdate(bindings, nodes, silent = false) {
-    if (!this.pendingUpdate) {
-      this.pendingUpdate = {
-        scheduled: false
-      };
+  apply(view) {
+    view.hooks.parser.tap("template", this.applyParser.bind(this));
+    view.hooks.resolver.tap("template", this.applyResolverHooks.bind(this));
+    view.setTemplatePlugin(this);
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/string-resolver.ts
+import { set } from "timm";
+var createPatternMatcher = (start, end) => {
+  return (testStr) => {
+    const startLocation = testStr.indexOf(start);
+    if (startLocation === -1) {
+      return false;
     }
-    this.pendingUpdate = {
-      ...this.pendingUpdate,
-      changedBindings: mergeSets(this.pendingUpdate.changedBindings, bindings),
-      changedNodes: mergeSets(this.pendingUpdate.changedNodes, nodes)
-    };
-    if (!this.pendingUpdate.scheduled && !silent) {
-      this.pendingUpdate.scheduled = true;
-      queueMicrotask(() => {
-        const { changedBindings, changedNodes } = this.pendingUpdate ?? {};
-        this.pendingUpdate = void 0;
-        this.currentView?.update(changedBindings, changedNodes);
-      });
+    const endLocation = testStr.indexOf(end);
+    if (endLocation === -1) {
+      return false;
     }
+    return startLocation < endLocation;
+  };
+};
+var bindingResolveLookup = createPatternMatcher("{{", "}}");
+var expressionResolveLookup = createPatternMatcher("@[", "]@");
+function hasSomethingToResolve(str) {
+  return bindingResolveLookup(str) || expressionResolveLookup(str);
+}
+function resolveString(str, resolveOptions) {
+  return hasSomethingToResolve(str) ? resolveDataRefs(str, {
+    model: resolveOptions.data.model,
+    evaluate: resolveOptions.evaluate
+  }) : str;
+}
+function resolveAllRefs(node, resolveOptions, propertiesToSkip) {
+  if (node === null || node === void 0 || typeof node !== "object" && typeof node !== "string") {
+    return node;
   }
-  getViewForRef(viewRef) {
-    if (this.viewMap[viewRef]) {
-      return this.viewMap[viewRef];
+  if (typeof node === "string") {
+    return resolveString(node, resolveOptions);
+  }
+  let newNode = node;
+  Object.keys(node).forEach((key) => {
+    if (propertiesToSkip.has(key)) {
+      return;
     }
-    const matchingViewId = Object.keys(this.viewMap).find(
-      (possibleViewIdMatch) => viewRef === resolveDataRefsInString(possibleViewIdMatch, {
-        model: this.viewOptions.model,
-        evaluate: this.viewOptions.evaluator.evaluate
-      })
-    );
-    if (matchingViewId && this.viewMap[matchingViewId]) {
-      return this.viewMap[matchingViewId];
+    const val = node[key];
+    let newVal = val;
+    if (typeof val === "object") {
+      newVal = resolveAllRefs(val, resolveOptions, propertiesToSkip);
+    } else if (typeof val === "string") {
+      newVal = resolveString(val, resolveOptions);
     }
-  }
-  onView(state) {
-    const viewId = state.ref;
-    const source = this.hooks.resolveView.call(
-      this.getViewForRef(viewId),
-      viewId,
-      state
-    );
-    if (!source) {
-      throw new Error(`No view with id ${viewId}`);
+    if (newVal !== val) {
+      newNode = set(newNode, key, newVal);
     }
-    const view = new ViewInstance(source, this.viewOptions);
-    this.currentView = view;
-    this.applyViewPlugins(view);
-    this.hooks.view.call(view);
-    view.update();
+  });
+  return newNode;
+}
+var findBasePath = (node, resolver) => {
+  const parentNode = node.parent;
+  if (!parentNode) {
+    return [];
   }
-  applyViewPlugins(view) {
-    for (const plugin of this.viewPlugins) {
-      plugin.apply(view);
-    }
+  if ("children" in parentNode) {
+    const original = resolver.getSourceNode(node);
+    return parentNode.children?.find((child) => child.value === original)?.path ?? [];
   }
-  createViewPlugins() {
-    const pluginOptions = toNodeResolveOptions(this.viewOptions);
-    return [
-      new AssetPlugin(),
-      new SwitchPlugin(pluginOptions),
-      new ApplicabilityPlugin(),
-      new AssetTransformCorePlugin(this.transformRegistry),
-      new StringResolverPlugin(),
-      new TemplatePlugin(pluginOptions),
-      new MultiNodePlugin()
-    ];
+  if (parentNode.type !== "multi-node" /* MultiNode */) {
+    return [];
+  }
+  return findBasePath(parentNode, resolver);
+};
+var StringResolverPlugin = class {
+  constructor() {
+    this.propertiesToSkipCache = /* @__PURE__ */ new Map();
+  }
+  applyResolver(resolver) {
+    resolver.hooks.resolve.tap("string-resolver", (value, node, options) => {
+      if (node.type === "empty" /* Empty */ || node.type === "unknown" /* Unknown */) {
+        return null;
+      }
+      if (node.type === "value" /* Value */ || node.type === "asset" /* Asset */ || node.type === "view" /* View */) {
+        let propsToSkip;
+        if (node.type === "asset" /* Asset */ || node.type === "view" /* View */) {
+          propsToSkip = new Set(
+            node.plugins?.stringResolver?.propertiesToSkip ?? ["exp"]
+          );
+          if (node.value?.id) {
+            this.propertiesToSkipCache.set(node.value.id, propsToSkip);
+          }
+        } else if (node.parent?.type === "multi-node" /* MultiNode */ && (node.parent?.parent?.type === "asset" /* Asset */ || node.parent?.parent?.type === "view" /* View */) && node.parent.parent.value?.id && this.propertiesToSkipCache.has(node.parent.parent.value.id)) {
+          propsToSkip = this.propertiesToSkipCache.get(
+            node.parent.parent.value.id
+          );
+        } else {
+          propsToSkip = /* @__PURE__ */ new Set(["exp"]);
+        }
+        const nodePath = findBasePath(node, resolver);
+        if (nodePath.length > 0 && nodePath.some((segment) => propsToSkip.has(segment.toString()))) {
+          return node.value;
+        }
+        return resolveAllRefs(node.value, options, propsToSkip);
+      }
+      return value;
+    });
   }
-  /** Marks all AST nodes in `nodes` as changed, triggering the view to update and re-resolve these nodes. View updates are triggered asynchronously and many calls to this in a short time will batch into a single update.
-   *
-   * NOTE: In most cases view updates are handled automatically by changes to data or any other built-in functionality that would require a view update. Only call this function if absolutely necessary.
-   */
-  updateViewAST(nodes) {
-    this.queueUpdate(void 0, nodes);
+  apply(view) {
+    view.hooks.resolver.tap("string-resolver", this.applyResolver.bind(this));
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/data/controller.ts
-import { SyncHook as SyncHook9, SyncWaterfallHook as SyncWaterfallHook10, SyncBailHook as SyncBailHook5 } from "tapable-ts";
-import { dequal as dequal2 } from "dequal";
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/data/utils.ts
-var ReadOnlyDataController = class {
-  constructor(controller, logger) {
-    this.controller = controller;
-    this.logger = logger;
-  }
-  get(binding, options) {
-    return this.controller.get(binding, options);
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/applicability.ts
+import { omit as omit2 } from "timm";
+var ApplicabilityPlugin = class {
+  isApplicability(obj) {
+    return obj && Object.prototype.hasOwnProperty.call(obj, "applicability");
   }
-  set(transaction, options) {
-    this.logger?.error(
-      "Error: Tried to set in a read only instance of the DataController"
+  applyResolver(resolver) {
+    resolver.hooks.beforeResolve.tap(
+      "applicability",
+      (node, options) => {
+        let newNode = node;
+        if (node?.type === "applicability" /* Applicability */) {
+          const isApplicable = options.evaluate(node.expression);
+          if (isApplicable === false) {
+            return null;
+          }
+          newNode = node.value;
+        }
+        return newNode;
+      }
     );
-    return [];
   }
-  delete(binding, options) {
-    this.logger?.error(
-      "Error: Tried to delete in a read only instance of the DataController"
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "applicability",
+      (obj, nodeType, options, childOptions) => {
+        if (this.isApplicability(obj)) {
+          const parsedApplicability = parser.parseObject(
+            omit2(obj, "applicability"),
+            nodeType,
+            options
+          );
+          if (!parsedApplicability) {
+            return childOptions ? [] : null;
+          }
+          const applicabilityNode = parser.createASTNode(
+            {
+              type: "applicability" /* Applicability */,
+              expression: obj.applicability,
+              value: parsedApplicability
+            },
+            obj
+          );
+          if (!applicabilityNode) {
+            return childOptions ? [] : null;
+          }
+          if (applicabilityNode.type === "applicability" /* Applicability */) {
+            applicabilityNode.value.parent = applicabilityNode;
+          }
+          return childOptions ? [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: applicabilityNode
+            }
+          ] : applicabilityNode;
+        }
+      }
     );
   }
+  apply(view) {
+    view.hooks.resolver.tap("applicability", this.applyResolver.bind(this));
+    view.hooks.parser.tap("applicability", this.applyParser.bind(this));
+  }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/data/controller.ts
-var DataController = class {
-  constructor(model, options) {
-    this.hooks = {
-      resolve: new SyncWaterfallHook10(),
-      resolveDataStages: new SyncWaterfallHook10(),
-      // On any set or get of an undefined value, redirect the value to be the default
-      resolveDefaultValue: new SyncBailHook5(),
-      onDelete: new SyncHook9(),
-      onSet: new SyncHook9(),
-      onGet: new SyncHook9(),
-      onUpdate: new SyncHook9(),
-      format: new SyncWaterfallHook10(),
-      deformat: new SyncWaterfallHook10(),
-      serialize: new SyncWaterfallHook10()
-    };
-    this.logger = options.logger;
-    const middleware = options.middleware || [];
-    this.baseMiddleware = [new LocalModel(model), ...middleware];
-    this.trash = /* @__PURE__ */ new Set();
-    this.pathResolver = options.pathResolver;
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/switch.ts
+var SwitchPlugin = class {
+  constructor(options) {
+    this.options = options;
   }
-  getModel() {
-    if (!this.model) {
-      const stages = this.hooks.resolveDataStages.call(this.baseMiddleware);
-      const model = new PipelinedDataModel();
-      model.setMiddleware(stages);
-      this.model = model;
+  resolveSwitch(node, options) {
+    for (const switchCase of node.cases) {
+      const isApplicable = options.evaluate(switchCase.case);
+      if (isApplicable) {
+        return switchCase.value;
+      }
     }
-    return this.model;
+    return EMPTY_NODE;
   }
-  resolveDataValue(binding, value, deformat) {
-    if (deformat) {
-      return this.hooks.deformat.call(value, binding);
-    }
-    return value;
+  isSwitch(obj) {
+    return obj && (Object.prototype.hasOwnProperty.call(obj, "dynamicSwitch") || Object.prototype.hasOwnProperty.call(obj, "staticSwitch"));
   }
-  set(transaction, options) {
-    let normalizedTransaction = [];
-    if (Array.isArray(transaction)) {
-      normalizedTransaction = transaction.map(([binding, value]) => {
-        const parsed = this.pathResolver.parse(binding);
-        return [
-          parsed,
-          this.resolveDataValue(parsed, value, Boolean(options?.formatted))
-        ];
-      });
-    } else {
-      normalizedTransaction = Object.keys(transaction).map(
-        (binding) => {
-          const parsed = this.pathResolver.parse(binding);
-          const val = transaction[binding];
-          return [
-            parsed,
-            this.resolveDataValue(parsed, val, Boolean(options?.formatted))
-          ];
-        }
-      );
-    }
-    const setUpdates = normalizedTransaction.reduce(
-      (updates, [binding, newVal]) => {
-        const oldVal = this.get(binding, { includeInvalid: true });
-        const update = {
-          binding,
-          newValue: newVal,
-          oldValue: oldVal
-        };
-        if (dequal2(oldVal, newVal)) {
-          this.logger?.debug(
-            `Skipping update for path: ${binding.asString()}. Value was unchanged: ${oldVal}`
+  applyParser(parser) {
+    parser.hooks.onCreateASTNode.tap("switch", (node) => {
+      if (node && node.type === "switch" /* Switch */ && !node.dynamic) {
+        return this.resolveSwitch(node, this.options);
+      }
+      return node;
+    });
+    parser.hooks.parseNode.tap(
+      "switch",
+      (obj, _nodeType, options, childOptions) => {
+        if (this.isSwitch(obj) || childOptions && hasSwitchKey(childOptions.key)) {
+          const objToParse = childOptions && hasSwitchKey(childOptions.key) ? { [childOptions.key]: obj } : obj;
+          const dynamic = "dynamicSwitch" in objToParse;
+          const switchContent = dynamic ? objToParse.dynamicSwitch : objToParse.staticSwitch;
+          const cases = switchContent.map(
+            (switchCase) => {
+              const { case: switchCaseExpr, ...switchBody } = switchCase;
+              const value = parser.parseObject(
+                switchBody,
+                "value" /* Value */,
+                options
+              );
+              if (value) {
+                return {
+                  case: switchCaseExpr,
+                  value
+                };
+              }
+              return;
+            }
+          ).filter(Boolean);
+          const switchAST = parser.createASTNode(
+            {
+              type: "switch" /* Switch */,
+              dynamic,
+              cases
+            },
+            objToParse
           );
-        } else {
-          updates.push(update);
-          this.logger?.debug(
-            `Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`
+          if (!switchAST || switchAST.type === "empty" /* Empty */) {
+            return childOptions ? [] : null;
+          }
+          if (switchAST.type === "switch" /* Switch */) {
+            switchAST.cases.forEach((sCase) => {
+              sCase.value.parent = switchAST;
+            });
+          }
+          if (childOptions) {
+            let path = [...childOptions.path, childOptions.key];
+            let value = switchAST;
+            if (switchAST.type === "value" /* Value */ && switchAST.children?.length === 1 && switchAST.value === void 0) {
+              const firstChild = switchAST.children[0];
+              path = [...path, ...firstChild.path];
+              value = firstChild.value;
+            }
+            return [{ path, value }];
+          }
+          return switchAST;
+        }
+      }
+    );
+  }
+  applyResolver(resolver) {
+    resolver.hooks.beforeResolve.tap("switch", (node, options) => {
+      if (node && node.type === "switch" /* Switch */ && node.dynamic) {
+        return this.resolveSwitch(node, options);
+      }
+      return node;
+    });
+  }
+  apply(view) {
+    view.hooks.parser.tap("switch", this.applyParser.bind(this));
+    view.hooks.resolver.tap("switch", this.applyResolver.bind(this));
+  }
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/multi-node.ts
+var MultiNodePlugin = class {
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "multi-node",
+      (obj, nodeType, options, childOptions) => {
+        if ((childOptions === void 0 || !hasTemplateKey(childOptions.key)) && Array.isArray(obj)) {
+          const values = obj.map(
+            (childVal) => parser.parseObject(childVal, "value" /* Value */, options)
+          ).filter((child) => !!child);
+          if (!values.length) {
+            return [];
+          }
+          const multiNode = parser.createASTNode(
+            {
+              type: "multi-node" /* MultiNode */,
+              override: childOptions !== void 0 && !hasTemplateValues(childOptions.parentObj, childOptions.key),
+              values
+            },
+            obj
           );
+          if (!multiNode) {
+            return [];
+          }
+          if (multiNode.type === "multi-node" /* MultiNode */) {
+            multiNode.values.forEach((v) => {
+              v.parent = multiNode;
+            });
+          }
+          return childOptions === void 0 ? multiNode : [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: multiNode
+            }
+          ];
         }
-        return updates;
-      },
-      []
-    );
-    const result = this.getModel().set(normalizedTransaction, options);
-    const setUpdateBindings = new Set(setUpdates.map((su) => su.binding));
-    result.forEach((tr) => {
-      if (!setUpdateBindings.has(tr.binding) && (tr.force === true || !dequal2(tr.oldValue, tr.newValue))) {
-        this.logger?.debug(
-          `Path: ${tr.binding.asString()} was changed from: ${tr.oldValue} to: ${tr.newValue}`
-        );
-        setUpdates.push(tr);
       }
-    });
-    this.hooks.onSet.call(normalizedTransaction);
-    if (setUpdates.length > 0) {
-      this.hooks.onUpdate.call(setUpdates, options);
-    }
-    return result;
+    );
   }
-  resolve(binding, readOnly) {
-    return Array.isArray(binding) || typeof binding === "string" ? this.pathResolver.parse(binding, { readOnly }) : binding;
+  apply(view) {
+    view.hooks.parser.tap("multi-node", this.applyParser.bind(this));
   }
-  get(binding, options) {
-    const resolved = binding instanceof BindingInstance ? binding : this.resolve(binding, true);
-    let result = this.getModel().get(resolved, options);
-    if (result === void 0 && !options?.ignoreDefaultValue) {
-      const defaultVal = this.hooks.resolveDefaultValue.call(resolved);
-      if (defaultVal !== result) {
-        result = defaultVal;
+};
+
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/asset.ts
+var AssetPlugin = class {
+  applyParser(parser) {
+    parser.hooks.parseNode.tap(
+      "asset",
+      (obj, nodeType, options, childOptions) => {
+        if (childOptions?.key === "asset" && typeof obj === "object") {
+          const assetAST = parser.parseObject(obj, "asset" /* Asset */, options);
+          if (!assetAST) {
+            return [];
+          }
+          return [
+            {
+              path: [...childOptions.path, childOptions.key],
+              value: assetAST
+            }
+          ];
+        }
       }
-    }
-    if (options?.formatted) {
-      result = this.hooks.format.call(result, resolved);
-    } else if (options?.formatted === false) {
-      result = this.hooks.deformat.call(result, resolved);
-    }
-    this.hooks.onGet.call(binding, result);
-    return result;
-  }
-  delete(binding, options) {
-    if (typeof binding !== "string" && !Array.isArray(binding) && !(binding instanceof BindingInstance)) {
-      throw new Error("Invalid arguments: delete expects a data path (string)");
-    }
-    const resolved = binding instanceof BindingInstance ? binding : this.resolve(binding, false);
-    const parentBinding = resolved.parent();
-    const property = resolved.key();
-    const parentValue = this.get(parentBinding);
-    const existedBeforeDelete = typeof parentValue === "object" && parentValue !== null && Object.prototype.hasOwnProperty.call(parentValue, property);
-    this.getModel().delete(resolved, options);
-    if (existedBeforeDelete && !this.get(resolved)) {
-      this.trash.add(resolved);
-    }
-    this.hooks.onDelete.call(resolved);
-  }
-  serialize() {
-    return this.hooks.serialize.call(this.get(""));
+    );
   }
-  makeReadOnly() {
-    return new ReadOnlyDataController(this, this.logger);
+  apply(view) {
+    view.hooks.parser.tap("asset", this.applyParser.bind(this));
   }
 };
 
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/constants/utils.ts
-function flatten(obj, roots = [], sep = ".") {
-  return Object.keys(obj).reduce(
-    (memo, prop) => ({
-      // create a new object
-      // include previously returned object
-      ...memo,
-      ...Object.prototype.toString.call(obj[prop]) === "[object Object]" ? (
-        // keep working if value is an object
-        flatten(obj[prop], roots.concat([prop]))
-      ) : (
-        // include current prop and value and prefix prop with the roots
-        { [roots.concat([prop]).join(sep)]: obj[prop] }
-      )
-    }),
-    {}
-  );
-}
-function objectToBatchSet(obj) {
-  const flattenedObj = flatten(obj);
-  const batchTxn = [];
-  Object.keys(flattenedObj).forEach((key) => {
-    batchTxn.push([new BindingInstance(key), flattenedObj[key]]);
-  });
-  return batchTxn;
-}
-
-// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/controllers/constants/index.ts
-var ConstantsController = class {
-  constructor() {
-    this.store = /* @__PURE__ */ new Map();
-    this.tempStore = /* @__PURE__ */ new Map();
-  }
-  addConstants(data, namespace) {
-    if (this.store.has(namespace)) {
-      this.store.get(namespace)?.set(objectToBatchSet(data));
-    } else {
-      this.store.set(namespace, new LocalModel(data));
-    }
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/view/plugins/asset-transform.ts
+function findUp(node, target) {
+  if (node === target) {
+    return true;
   }
-  getConstants(key, namespace, fallback) {
-    const path = new BindingInstance(key);
-    return this.tempStore.get(namespace)?.get(path) ?? this.store.get(namespace)?.get(path) ?? fallback;
+  if (node.parent) {
+    return findUp(node.parent, target);
   }
-  setTemporaryValues(data, namespace) {
-    if (this.tempStore.has(namespace)) {
-      this.tempStore.get(namespace)?.set(objectToBatchSet(data));
-    } else {
-      this.tempStore.set(namespace, new LocalModel(data));
-    }
+  return false;
+}
+var AssetTransformCorePlugin = class {
+  constructor(registry) {
+    this.registry = registry;
+    this.stateStore = /* @__PURE__ */ new Map();
+    this.beforeResolveSymbol = Symbol("before resolve");
+    this.resolveSymbol = Symbol("resolve");
+    this.beforeResolveCountSymbol = Symbol("before resolve count");
+    this.resolveCountSymbol = Symbol("resolve count");
   }
-  clearTemporaryValues(namespace) {
-    if (namespace) {
-      this.tempStore.get(namespace)?.reset();
-    } else {
-      this.tempStore.forEach((value) => {
-        value.reset();
+  apply(view) {
+    this.stateStore.clear();
+    view.hooks.resolver.tap("asset-transform", (resolver) => {
+      let lastUpdatedNode;
+      const updateState = (node) => {
+        lastUpdatedNode = node;
+        view.update(/* @__PURE__ */ new Set());
+      };
+      const getStore = (node, stepKey) => {
+        let store;
+        const countKey = stepKey === this.resolveSymbol ? this.resolveCountSymbol : this.beforeResolveCountSymbol;
+        const storedState = this.stateStore.get(node);
+        if (storedState) {
+          store = storedState;
+          store.removeKey(countKey);
+        } else {
+          store = new LocalStateStore(() => {
+            updateState(node);
+          });
+          this.stateStore.set(node, store);
+        }
+        return {
+          useSharedState: (key) => {
+            return store.useSharedState(key);
+          },
+          useLocalState: (initialState) => {
+            return store.getLocalStateFunction(
+              stepKey,
+              countKey
+            )(initialState);
+          }
+        };
+      };
+      resolver.hooks.beforeResolve.tap("asset-transform", (node, options) => {
+        if (node && (node.type === "asset" || node.type === "view")) {
+          const transform = this.registry.get(node.value);
+          if (transform?.beforeResolve) {
+            const store = getStore(
+              options.node ?? node,
+              this.beforeResolveSymbol
+            );
+            return transform.beforeResolve(node, options, store);
+          }
+        }
+        return node;
       });
-    }
+      resolver.hooks.afterUpdate.tap("asset-transform", () => {
+        lastUpdatedNode = void 0;
+      });
+      resolver.hooks.skipResolve.tap("asset-transform", (skip, node) => {
+        if (!skip || !lastUpdatedNode) {
+          return skip;
+        }
+        const isParentOfUpdated = findUp(lastUpdatedNode, node);
+        const isChildOfUpdated = findUp(node, lastUpdatedNode);
+        return !isParentOfUpdated && !isChildOfUpdated;
+      });
+      resolver.hooks.afterResolve.tap(
+        "asset-transform",
+        (value, node, options) => {
+          if (node.type !== "asset" /* Asset */ && node.type !== "view" /* View */) {
+            return value;
+          }
+          const originalNode = resolver.getSourceNode(node);
+          if (!originalNode) {
+            return value;
+          }
+          const transform = this.registry.get(value);
+          if (transform?.resolve) {
+            const store = getStore(originalNode, this.resolveSymbol);
+            return transform?.resolve(value, options, store);
+          }
+          return value;
+        }
+      );
+    });
   }
 };
 
+// ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/player.ts
+import { setIn as setIn7 } from "timm";
+import deferred from "p-defer";
+import queueMicrotask2 from "queue-microtask";
+import { SyncHook as SyncHook10, SyncWaterfallHook as SyncWaterfallHook11 } from "tapable-ts";
+
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/plugins/flow-exp-plugin.ts
 var FlowExpPlugin = class {
   constructor() {
@@ -5304,8 +5714,8 @@ var NOT_STARTED_STATE = {
 };
 
 // ../../../../../../../../../../execroot/_main/bazel-out/k8-fastbuild/bin/core/player/src/player.ts
-var PLAYER_VERSION = true ? "0.15.3" : "unknown";
-var COMMIT = true ? "635ec38f97e5afa4d5f7ff4ddd3e4f7a6fbe0988" : "unknown";
+var PLAYER_VERSION = true ? "0.15.4--canary.881.37421" : "unknown";
+var COMMIT = true ? "b139e69374bc1b7f35ddd797a0f005be4b0e26e6" : "unknown";
 var _Player = class _Player {
   constructor(config) {
     this.logger = new TapableLogger();
@@ -5320,6 +5730,7 @@ var _Player = class _Player {
       schema: new SyncHook10(),
       validationController: new SyncHook10(),
       bindingParser: new SyncHook10(),
+      errorController: new SyncHook10(),
       state: new SyncHook10(),
       onStart: new SyncHook10(),
       onEnd: new SyncHook10(),
@@ -5410,9 +5821,18 @@ var _Player = class _Player {
     this.hooks.schema.call(schema);
     const validationController = new ValidationController(schema);
     this.hooks.validationController.call(validationController);
+    const errorController = new ErrorController({
+      logger: this.logger,
+      flow: flowController,
+      fail: flowResultDeferred.reject
+    });
+    this.hooks.errorController.call(errorController);
     dataController = new DataController(userFlow.data, {
       pathResolver,
-      middleware: validationController.getDataMiddleware(),
+      middleware: [
+        ...validationController.getDataMiddleware(),
+        errorController.getDataMiddleware()
+      ],
       logger: this.logger
     });
     dataController.hooks.format.tap("player", (value, binding) => {
@@ -5427,6 +5847,9 @@ var _Player = class _Player {
       "player",
       (binding) => schema.getApparentType(binding)?.default
     );
+    errorController.setOptions({
+      model: dataController
+    });
     let viewController;
     expressionEvaluator = new ExpressionEvaluator({
       model: dataController,
@@ -5565,7 +5988,8 @@ var _Player = class _Player {
         ...validationController.forView(parseBinding),
         type: (b) => schema.getType(parseBinding(b))
       },
-      constants: this.constantsController
+      constants: this.constantsController,
+      errorController
     });
     viewController.hooks.view.tap("player", (view) => {
       validationController.onView(view);
@@ -5595,7 +6019,8 @@ var _Player = class _Player {
           schema,
           expression: expressionEvaluator,
           binding: pathResolver,
-          validation: validationController
+          validation: validationController,
+          error: errorController
         },
         fail: flowResultDeferred.reject,
         flow: userFlow,
@@ -5670,6 +6095,11 @@ export {
   DependencyModel,
   DependencyTracker,
   EMPTY_NODE,
+  ERROR_BINDING_PREFIX,
+  ErrorController,
+  ErrorSeverity,
+  ErrorStateMiddleware,
+  ErrorTypes,
   ExpNodeOpaqueIdentifier,
   ExpressionEvaluator,
   FlowController,
@@ -5689,6 +6119,8 @@ export {
   ProxyLogger,
   ROOT_BINDING,
   Resolver,
+  ResolverError,
+  ResolverStage,
   SCHEMA_VALIDATION_PROVIDER_NAME,
   SIMPLE_BINDING_REGEX,
   SchemaController,