@player-ui/player 0.4.0 → 0.4.1-next.0

package/dist/index.cjs.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var types = require('@player-ui/types');
 var tapableTs = require('tapable-ts');
-var NestedError = require('nested-error-stacks');
+var tsNestedError = require('ts-nested-error');
 var flatten$1 = require('arr-flatten');
 var P = require('parsimmon');
 var ebnf = require('ebnf');
@@ -17,7 +17,6 @@ var partialMatchRegistry = require('@player-ui/partial-match-registry');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var NestedError__default = /*#__PURE__*/_interopDefaultLegacy(NestedError);
 var flatten__default = /*#__PURE__*/_interopDefaultLegacy(flatten$1);
 var P__default = /*#__PURE__*/_interopDefaultLegacy(P);
 var get__default = /*#__PURE__*/_interopDefaultLegacy(get);
@@ -106,7 +105,8 @@ const isIdentifierChar = (char) => {
     return false;
   }
   const charCode = char.charCodeAt(0);
-  return charCode >= 48 && charCode <= 57 || charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || charCode === 95 || charCode === 45 || charCode === 64;
+  const matches = charCode === 32 || charCode === 34 || charCode === 39 || charCode === 40 || charCode === 41 || charCode === 42 || charCode === 46 || charCode === 61 || charCode === 91 || charCode === 93 || charCode === 96 || charCode === 123 || charCode === 125;
+  return !matches;
 };
 const parse$1 = (path) => {
   let index = 1;
@@ -392,7 +392,7 @@ function resolveBindingAST(bindingPathNode, options, hooks) {
       try {
         return options.convertToPath(options.getValue(nestedResolvedValue.path));
       } catch (e) {
-        throw new NestedError__default["default"](`Unable to resolve path segment: ${nestedResolvedValue.path}`, e);
+        throw new tsNestedError.NestedError(`Unable to resolve path segment: ${nestedResolvedValue.path}`, e);
       }
     }
     if (node.name === "Expression") {
@@ -400,7 +400,7 @@ function resolveBindingAST(bindingPathNode, options, hooks) {
         const actualValue = options.evaluate(node.value);
         return options.convertToPath(actualValue);
       } catch (e) {
-        throw new NestedError__default["default"](`Unable to resolve path: ${node.value}`, e);
+        throw new tsNestedError.NestedError(`Unable to resolve path: ${node.value}`, e);
       }
     }
     throw new Error(`Unable to resolve value for node: ${node.name}`);
@@ -470,6 +470,8 @@ var __spreadValues$d = (a, b) => {
   return a;
 };
 const SIMPLE_BINDING_REGEX = /^[\w\-@]+(\.[\w\-@]+)*$/;
+const BINDING_BRACKETS_REGEX = /[\s()*=`{}'"[\]]/;
+const LAZY_BINDING_REGEX = /^[^.]+(\..+)*$/;
 const DEFAULT_OPTIONS = {
   get: () => {
     throw new Error("Not Implemented");
@@ -494,7 +496,7 @@ class BindingParser {
   }
   normalizePath(path, resolveOptions) {
     var _a, _b;
-    if (path.match(SIMPLE_BINDING_REGEX) && this.hooks.skipOptimization.call(path) !== true) {
+    if (!BINDING_BRACKETS_REGEX.test(path) && LAZY_BINDING_REGEX.test(path) && this.hooks.skipOptimization.call(path) !== true) {
       return { path: path.split("."), updates: void 0 };
     }
     const ast = (_a = this.parseCache[path]) != null ? _a : parse$1(path);
@@ -505,7 +507,7 @@ class BindingParser {
     try {
       return resolveBindingAST(ast.path, resolveOptions, this.hooks);
     } catch (e) {
-      throw new NestedError__default["default"](`Cannot resolve binding: ${path}`, e);
+      throw new tsNestedError.NestedError(`Cannot resolve binding: ${path}`, e);
     }
   }
   getBindingForNormalizedResult(normalized) {
@@ -555,7 +557,7 @@ class BindingParser {
       updates = __spreadValues$d(__spreadValues$d({}, updates), normalized.updates);
     }
     const updateKeys = Object.keys(updates);
-    if (updateKeys.length > 0) {
+    if (!options.readOnly && updateKeys.length > 0) {
       const updateTransaction = updateKeys.map((updatedBinding) => [
         this.parse(updatedBinding),
         updates[updatedBinding]
@@ -651,6 +653,10 @@ class DependencyMiddleware extends DependencyTracker {
     this.addReadDep(binding);
     return next == null ? void 0 : next.get(binding, options);
   }
+  delete(binding, options, next) {
+    this.addWriteDep(binding);
+    return next == null ? void 0 : next.delete(binding, options);
+  }
 }
 class DependencyModel extends DependencyTracker {
   constructor(rootModel) {
@@ -667,6 +673,10 @@ class DependencyModel extends DependencyTracker {
     this.addReadDep(binding);
     return this.rootModel.get(binding, options);
   }
+  delete(binding, options) {
+    this.addWriteDep(binding);
+    return this.rootModel.delete(binding, options);
+  }
 }
 
 class NOOPDataModel {
@@ -676,15 +686,18 @@ class NOOPDataModel {
   set() {
     return [];
   }
+  delete() {
+  }
 }
 const NOOP_MODEL = new NOOPDataModel();
 
 const ROOT_BINDING = new BindingInstance([]);
 function withParser(model, parseBinding) {
-  function maybeParse(binding) {
+  function maybeParse(binding, readOnly) {
     const parsed = isBinding(binding) ? binding : parseBinding(binding, {
       get: model.get,
-      set: model.set
+      set: model.set,
+      readOnly
     });
     if (!parsed) {
       throw new Error("Unable to parse binding");
@@ -693,10 +706,13 @@ function withParser(model, parseBinding) {
   }
   return {
     get(binding, options) {
-      return model.get(maybeParse(binding), options);
+      return model.get(maybeParse(binding, true), options);
     },
     set(transaction, options) {
-      return model.set(transaction.map(([key, val]) => [maybeParse(key), val]), options);
+      return model.set(transaction.map(([key, val]) => [maybeParse(key, false), val]), options);
+    },
+    delete(binding, options) {
+      return model.delete(maybeParse(binding, false), options);
     }
   };
 }
@@ -705,8 +721,27 @@ function toModel(middleware, defaultOptions, next) {
     return middleware;
   }
   return {
-    get: (binding, options) => middleware.get(binding, options != null ? options : defaultOptions, next),
-    set: (transaction, options) => middleware.set(transaction, options != null ? options : defaultOptions, next)
+    get: (binding, options) => {
+      const resolvedOptions = options != null ? options : defaultOptions;
+      if (middleware.get) {
+        return middleware.get(binding, resolvedOptions, next);
+      }
+      return next == null ? void 0 : next.get(binding, resolvedOptions);
+    },
+    set: (transaction, options) => {
+      const resolvedOptions = options != null ? options : defaultOptions;
+      if (middleware.set) {
+        return middleware.set(transaction, resolvedOptions, next);
+      }
+      return next == null ? void 0 : next.set(transaction, resolvedOptions);
+    },
+    delete: (binding, options) => {
+      const resolvedOptions = options != null ? options : defaultOptions;
+      if (middleware.delete) {
+        return middleware.delete(binding, resolvedOptions, next);
+      }
+      return next == null ? void 0 : next.delete(binding, resolvedOptions);
+    }
   };
 }
 function constructModelForPipeline(pipeline) {
@@ -714,7 +749,7 @@ function constructModelForPipeline(pipeline) {
     return NOOP_MODEL;
   }
   if (pipeline.length === 1) {
-    return pipeline[0];
+    return toModel(pipeline[0]);
   }
   function createModelWithOptions(options) {
     var _a;
@@ -729,6 +764,10 @@ function constructModelForPipeline(pipeline) {
     set: (transaction, options) => {
       var _a;
       return (_a = createModelWithOptions(options)) == null ? void 0 : _a.set(transaction, options);
+    },
+    delete: (binding, options) => {
+      var _a;
+      return (_a = createModelWithOptions(options)) == null ? void 0 : _a.delete(binding, options);
     }
   };
 }
@@ -765,6 +804,9 @@ class PipelinedDataModel {
   get(binding, options) {
     return this.effectiveDataModel.get(binding, options);
   }
+  delete(binding, options) {
+    return this.effectiveDataModel.delete(binding, options);
+  }
 }
 
 class LocalModel {
@@ -791,11 +833,24 @@ class LocalModel {
     });
     return effectiveOperations;
   }
+  delete(binding) {
+    const parentBinding = binding.parent();
+    if (parentBinding) {
+      const parentValue = this.get(parentBinding);
+      if (parentValue !== void 0) {
+        if (Array.isArray(parentValue)) {
+          this.model = timm.setIn(this.model, parentBinding.asArray(), timm.removeAt(parentValue, binding.key()));
+        } else {
+          this.model = timm.setIn(this.model, parentBinding.asArray(), timm.omit(parentValue, binding.key()));
+        }
+      }
+    }
+  }
 }
 
 const ExpNodeOpaqueIdentifier = Symbol("Expression Node ID");
 function isExpressionNode(x) {
-  return typeof x === "object" && x.__id === ExpNodeOpaqueIdentifier;
+  return typeof x === "object" && x !== null && !Array.isArray(x) && x.__id === ExpNodeOpaqueIdentifier;
 }
 
 const PERIOD_CODE = 46;
@@ -909,7 +964,9 @@ function isIdentifierPart(ch) {
 function isModelRefStart(ch0, ch1) {
   return ch0 === OCURL_CODE && ch1 === OCURL_CODE;
 }
-function parseExpression(expr) {
+function parseExpression(expr, options) {
+  var _a;
+  const strictMode = (_a = options == null ? void 0 : options.strict) != null ? _a : true;
   const charAtFunc = expr.charAt;
   const charCodeAtFunc = expr.charCodeAt;
   const { length } = expr;
@@ -1303,6 +1360,9 @@ function parseExpression(expr) {
       }
       args.push(node);
     }
+    if (charIndex !== termination) {
+      throwError(`Expected ${String.fromCharCode(termination)}`, index);
+    }
     return args;
   }
   function gobbleVariable() {
@@ -1373,28 +1433,41 @@ function parseExpression(expr) {
     };
   }
   const nodes = [];
-  while (index < length) {
-    const chIndex = exprICode(index);
-    if (chIndex === SEMCOL_CODE || chIndex === COMMA_CODE) {
-      index++;
-      continue;
+  try {
+    while (index < length) {
+      const chIndex = exprICode(index);
+      if (chIndex === SEMCOL_CODE || chIndex === COMMA_CODE) {
+        index++;
+        continue;
+      }
+      const node = gobbleExpression();
+      if (node) {
+        nodes.push(node);
+      } else if (index < length) {
+        throwError(`Unexpected "${exprI(index)}"`, index);
+      }
     }
-    const node = gobbleExpression();
-    if (node) {
-      nodes.push(node);
-    } else if (index < length) {
-      throwError(`Unexpected "${exprI(index)}"`, index);
+    if (nodes.length === 1) {
+      return nodes[0];
     }
+    return {
+      __id: ExpNodeOpaqueIdentifier,
+      type: "Compound",
+      body: nodes,
+      location: getLocation(0)
+    };
+  } catch (e) {
+    if (strictMode || !(e instanceof Error)) {
+      throw e;
+    }
+    return {
+      __id: ExpNodeOpaqueIdentifier,
+      type: "Compound",
+      body: nodes,
+      location: getLocation(0),
+      error: e
+    };
   }
-  if (nodes.length === 1) {
-    return nodes[0];
-  }
-  return {
-    __id: ExpNodeOpaqueIdentifier,
-    type: "Compound",
-    body: nodes,
-    location: getLocation(0)
-  };
 }
 
 const setDataVal = (_context, binding, value) => {
@@ -1404,16 +1477,108 @@ const getDataVal = (_context, binding) => {
   return _context.model.get(binding);
 };
 const deleteDataVal = (_context, binding) => {
-  return _context.model.set([[binding, void 0]]);
+  return _context.model.delete(binding);
+};
+const conditional = (ctx, condition, ifTrue, ifFalse) => {
+  const resolution = ctx.evaluate(condition);
+  if (resolution) {
+    return ctx.evaluate(ifTrue);
+  }
+  if (ifFalse) {
+    return ctx.evaluate(ifFalse);
+  }
+  return null;
 };
+conditional.resolveParams = false;
 
 var DEFAULT_EXPRESSION_HANDLERS = /*#__PURE__*/Object.freeze({
   __proto__: null,
   setDataVal: setDataVal,
   getDataVal: getDataVal,
-  deleteDataVal: deleteDataVal
+  deleteDataVal: deleteDataVal,
+  conditional: conditional
 });
 
+function withoutContext(fn) {
+  return (_context, ...args) => fn(...args);
+}
+function isInRange(position, location) {
+  return position.character >= location.start.character && position.character <= location.end.character;
+}
+function findClosestNodeAtPosition(node, position) {
+  var _a, _b, _c, _d, _e;
+  switch (node.type) {
+    case "Modification":
+    case "Assignment":
+    case "LogicalExpression":
+    case "BinaryExpression": {
+      const check = (_a = findClosestNodeAtPosition(node.left, position)) != null ? _a : findClosestNodeAtPosition(node.right, position);
+      if (check) {
+        return check;
+      }
+      break;
+    }
+    case "UnaryExpression": {
+      const checkArg = findClosestNodeAtPosition(node.argument, position);
+      if (checkArg) {
+        return checkArg;
+      }
+      break;
+    }
+    case "MemberExpression": {
+      const checkObject = (_b = findClosestNodeAtPosition(node.object, position)) != null ? _b : findClosestNodeAtPosition(node.property, position);
+      if (checkObject) {
+        return checkObject;
+      }
+      break;
+    }
+    case "ConditionalExpression": {
+      const checkObject = (_d = (_c = findClosestNodeAtPosition(node.test, position)) != null ? _c : findClosestNodeAtPosition(node.consequent, position)) != null ? _d : findClosestNodeAtPosition(node.alternate, position);
+      if (checkObject) {
+        return checkObject;
+      }
+      break;
+    }
+    case "ArrayExpression":
+    case "Compound": {
+      const elements = node.type === "ArrayExpression" ? node.elements : node.body;
+      const anyElements = elements.find((e) => findClosestNodeAtPosition(e, position));
+      if (anyElements) {
+        return anyElements;
+      }
+      break;
+    }
+    case "Object": {
+      const checkObject = node.attributes.reduce((found, next) => {
+        var _a2;
+        return (_a2 = found != null ? found : findClosestNodeAtPosition(next.key, position)) != null ? _a2 : findClosestNodeAtPosition(next.value, position);
+      }, void 0);
+      if (checkObject) {
+        return checkObject;
+      }
+      break;
+    }
+    case "CallExpression": {
+      const anyArgs = (_e = node.args.find((arg) => {
+        return findClosestNodeAtPosition(arg, position);
+      })) != null ? _e : findClosestNodeAtPosition(node.callTarget, position);
+      if (anyArgs) {
+        return anyArgs;
+      }
+      break;
+    }
+  }
+  if (node.location && isInRange(position, node.location)) {
+    return node;
+  }
+}
+function isObjectExpression(expr) {
+  if (isExpressionNode(expr)) {
+    return false;
+  }
+  return typeof expr === "object" && expr !== null && !Array.isArray(expr) && "value" in expr;
+}
+
 var __defProp$c = Object.defineProperty;
 var __defProps$a = Object.defineProperties;
 var __getOwnPropDescs$a = Object.getOwnPropertyDescriptors;
@@ -1474,6 +1639,8 @@ class ExpressionEvaluator {
     this.vars = {};
     this.hooks = {
       resolve: new tapableTs.SyncWaterfallHook(),
+      resolveOptions: new tapableTs.SyncWaterfallHook(),
+      beforeEvaluate: new tapableTs.SyncWaterfallHook(),
       onError: new tapableTs.SyncBailHook()
     };
     this.expressionsCache = new Map();
@@ -1492,21 +1659,25 @@ class ExpressionEvaluator {
   reset() {
     this.expressionsCache.clear();
   }
-  evaluate(expression, options) {
-    const opts = __spreadProps$a(__spreadValues$c(__spreadValues$c({}, this.defaultHookOptions), options), {
-      resolveNode: (node) => this._execAST(node, opts)
-    });
+  evaluate(expr, options) {
+    var _a;
+    const resolvedOpts = this.hooks.resolveOptions.call(__spreadProps$a(__spreadValues$c(__spreadValues$c({}, this.defaultHookOptions), options), {
+      resolveNode: (node) => this._execAST(node, resolvedOpts)
+    }));
+    let expression = (_a = this.hooks.beforeEvaluate.call(expr, resolvedOpts)) != null ? _a : expr;
+    while (isObjectExpression(expression)) {
+      expression = expression.value;
+    }
     if (typeof expression === "number" || typeof expression === "boolean" || expression === void 0 || expression === null) {
       return expression;
     }
     if (isExpressionNode(expression)) {
-      return this._execAST(expression, opts);
+      return this._execAST(expression, resolvedOpts);
     }
-    if (typeof expression === "object") {
-      const values = Array.isArray(expression) ? expression : Object.values(expression);
-      return values.reduce((_nothing, exp) => this.evaluate(exp, options), null);
+    if (Array.isArray(expression)) {
+      return expression.reduce((_nothing, exp) => this.evaluate(exp, options), null);
     }
-    return this._execString(String(expression), opts);
+    return this._execString(String(expression), resolvedOpts);
   }
   addExpressionFunction(name, handler) {
     this.operators.expressions.set(name, handler);
@@ -1544,7 +1715,7 @@ class ExpressionEvaluator {
       this.expressionsCache.set(matchedExp, expAST);
       return this._execAST(expAST, options);
     } catch (e) {
-      if (!this.hooks.onError.call(e)) {
+      if (options.throwErrors || !this.hooks.onError.call(e)) {
         throw e;
       }
     }
@@ -1598,25 +1769,18 @@ class ExpressionEvaluator {
     }
     if (node.type === "CallExpression") {
       const expressionName = node.callTarget.name;
-      if (expressionName === "conditional") {
-        const condition = resolveNode(node.args[0]);
-        if (condition) {
-          return resolveNode(node.args[1]);
-        }
-        if (node.args[2]) {
-          return resolveNode(node.args[2]);
-        }
-        return null;
-      }
       const operator = this.operators.expressions.get(expressionName);
       if (!operator) {
         throw new Error(`Unknown expression function: ${expressionName}`);
       }
+      if ("resolveParams" in operator && operator.resolveParams === false) {
+        return operator(expressionContext, ...node.args);
+      }
       const args = node.args.map((n) => resolveNode(n));
       return operator(expressionContext, ...args);
     }
     if (node.type === "ModelRef") {
-      return model.get(node.ref);
+      return model.get(node.ref, { context: { model: options.model } });
     }
     if (node.type === "MemberExpression") {
       const obj = resolveNode(node.object);
@@ -1668,80 +1832,6 @@ class ExpressionEvaluator {
   }
 }
 
-function withoutContext(fn) {
-  return (_context, ...args) => fn(...args);
-}
-function isInRange(position, location) {
-  return position.character >= location.start.character && position.character <= location.end.character;
-}
-function findClosestNodeAtPosition(node, position) {
-  var _a, _b, _c, _d, _e;
-  switch (node.type) {
-    case "Modification":
-    case "Assignment":
-    case "LogicalExpression":
-    case "BinaryExpression": {
-      const check = (_a = findClosestNodeAtPosition(node.left, position)) != null ? _a : findClosestNodeAtPosition(node.right, position);
-      if (check) {
-        return check;
-      }
-      break;
-    }
-    case "UnaryExpression": {
-      const checkArg = findClosestNodeAtPosition(node.argument, position);
-      if (checkArg) {
-        return checkArg;
-      }
-      break;
-    }
-    case "MemberExpression": {
-      const checkObject = (_b = findClosestNodeAtPosition(node.object, position)) != null ? _b : findClosestNodeAtPosition(node.property, position);
-      if (checkObject) {
-        return checkObject;
-      }
-      break;
-    }
-    case "ConditionalExpression": {
-      const checkObject = (_d = (_c = findClosestNodeAtPosition(node.test, position)) != null ? _c : findClosestNodeAtPosition(node.consequent, position)) != null ? _d : findClosestNodeAtPosition(node.alternate, position);
-      if (checkObject) {
-        return checkObject;
-      }
-      break;
-    }
-    case "ArrayExpression":
-    case "Compound": {
-      const elements = node.type === "ArrayExpression" ? node.elements : node.body;
-      const anyElements = elements.find((e) => findClosestNodeAtPosition(e, position));
-      if (anyElements) {
-        return anyElements;
-      }
-      break;
-    }
-    case "Object": {
-      const checkObject = node.attributes.reduce((found, next) => {
-        var _a2;
-        return (_a2 = found != null ? found : findClosestNodeAtPosition(next.key, position)) != null ? _a2 : findClosestNodeAtPosition(next.value, position);
-      }, void 0);
-      if (checkObject) {
-        return checkObject;
-      }
-      break;
-    }
-    case "CallExpression": {
-      const anyArgs = (_e = node.args.find((arg) => {
-        return findClosestNodeAtPosition(arg, position);
-      })) != null ? _e : findClosestNodeAtPosition(node.callTarget, position);
-      if (anyArgs) {
-        return anyArgs;
-      }
-      break;
-    }
-  }
-  if (node.location && isInRange(position, node.location)) {
-    return node;
-  }
-}
-
 const severities = ["trace", "debug", "info", "warn", "error"];
 
 class ConsoleLogger {
@@ -1898,6 +1988,9 @@ function parse(schema) {
       if (type.isArray) {
         nestedPath.push("[]");
       }
+      if (type.isRecord) {
+        nestedPath.push("{}");
+      }
       if (type.type && schema[type.type]) {
         parseQueue.push({
           path: nestedPath,
@@ -1946,8 +2039,20 @@ class SchemaController {
     if (cached) {
       return cached;
     }
-    const normalized = binding.asArray().map((p) => typeof p === "number" ? "[]" : p).join(".");
-    this.bindingSchemaNormalizedCache.set(binding, normalized);
+    let bindingArray = binding.asArray();
+    let normalized = bindingArray.map((p) => typeof p === "number" ? "[]" : p).join(".");
+    if (normalized) {
+      this.bindingSchemaNormalizedCache.set(binding, normalized);
+      bindingArray = normalized.split(".");
+    }
+    bindingArray.forEach((item) => {
+      const recordBinding = bindingArray.map((p) => p === item ? "{}" : p).join(".");
+      if (this.schema.get(recordBinding)) {
+        this.bindingSchemaNormalizedCache.set(binding, recordBinding);
+        bindingArray = recordBinding.split(".");
+        normalized = recordBinding;
+      }
+    });
     return normalized;
   }
   getType(binding) {
@@ -2034,6 +2139,9 @@ function findNextExp(str) {
   };
 }
 function resolveExpressionsInString(val, { evaluate }) {
+  if (!evaluate) {
+    return val;
+  }
   const expMatch = /@\[.*?\]@/;
   let newVal = val;
   let match = newVal.match(expMatch);
@@ -2051,9 +2159,9 @@ function resolveExpressionsInString(val, { evaluate }) {
   return newVal;
 }
 function resolveDataRefsInString(val, options) {
-  const { model } = options;
+  const { model, formatted = true } = options;
   let workingString = resolveExpressionsInString(val, options);
-  if (typeof workingString !== "string" || workingString.indexOf(DOUBLE_OPEN_CURLY) === -1) {
+  if (!model || typeof workingString !== "string" || workingString.indexOf(DOUBLE_OPEN_CURLY) === -1) {
     return workingString;
   }
   while (workingString.indexOf(DOUBLE_OPEN_CURLY) !== -1) {
@@ -2063,7 +2171,7 @@ function resolveDataRefsInString(val, options) {
     }
     const { start, end } = expLocation;
     const binding = workingString.substring(start + DOUBLE_OPEN_CURLY.length, end - DOUBLE_OPEN_CURLY.length).trim();
-    const evaledVal = model.get(binding, { formatted: true });
+    const evaledVal = model.get(binding, { formatted });
     if (start === 0 && end === workingString.length && typeof evaledVal !== "string") {
       return evaledVal;
     }
@@ -2082,9 +2190,9 @@ function traverseObject(val, options) {
       const keys = Object.keys(val);
       let newVal = val;
       if (keys.length > 0) {
-        for (const key of keys) {
+        keys.forEach((key) => {
           newVal = timm.setIn(newVal, [key], traverseObject(val[key], options));
-        }
+        });
       }
       return newVal;
     }
@@ -2096,6 +2204,36 @@ function resolveDataRefs(val, options) {
   return traverseObject(val, options);
 }
 
+function removeBindingAndChildrenFromMap(sourceMap, binding) {
+  const targetMap = new Map(sourceMap);
+  const parentBinding = binding.parent();
+  const property = binding.key();
+  targetMap.forEach((_value, trackedBinding) => {
+    if (binding === trackedBinding || binding.contains(trackedBinding)) {
+      targetMap.delete(trackedBinding);
+    }
+  });
+  if (typeof property === "number") {
+    const bindingsToRewrite = Array.from(sourceMap.keys()).filter((b) => {
+      if (parentBinding.contains(b)) {
+        const [childIndex] = b.relative(parentBinding);
+        return typeof childIndex === "number" && childIndex > property;
+      }
+      return false;
+    }).sort();
+    bindingsToRewrite.forEach((trackedBinding) => {
+      const [childIndex, ...childPath] = trackedBinding.relative(parentBinding);
+      if (typeof childIndex === "number") {
+        const newSegments = [childIndex - 1, ...childPath];
+        const newChildBinding = parentBinding.descendent(newSegments);
+        targetMap.set(newChildBinding, targetMap.get(trackedBinding));
+        targetMap.delete(trackedBinding);
+      }
+    });
+  }
+  return targetMap;
+}
+
 var __defProp$a = Object.defineProperty;
 var __defProps$8 = Object.defineProperties;
 var __getOwnPropDescs$8 = Object.getOwnPropertyDescriptors;
@@ -2120,12 +2258,15 @@ class ValidationMiddleware {
     this.validator = validator;
     this.shadowModelPaths = new Map();
     this.logger = options == null ? void 0 : options.logger;
+    this.shouldIncludeInvalid = options == null ? void 0 : options.shouldIncludeInvalid;
   }
   set(transaction, options, next) {
     const asModel = toModel(this, __spreadProps$8(__spreadValues$a({}, options), { includeInvalid: true }), next);
     const nextTransaction = [];
+    const includedBindings = new Set();
     transaction.forEach(([binding, value]) => {
       this.shadowModelPaths.set(binding, value);
+      includedBindings.add(binding);
     });
     const invalidBindings = [];
     this.shadowModelPaths.forEach((value, binding) => {
@@ -2136,22 +2277,25 @@ class ValidationMiddleware {
       } else if (validations instanceof Set) {
         validations.forEach((validation) => {
           invalidBindings.push(validation.binding);
-          if (!validation.isStrong) {
+          if (!validation.isStrong && validation.binding.asString() === binding.asString()) {
             nextTransaction.push([validation.binding, value]);
           }
         });
-      } else {
+      } else if (includedBindings.has(binding)) {
+        invalidBindings.push(binding);
         (_a = this.logger) == null ? void 0 : _a.debug(`Invalid value for path: ${binding.asString()} - ${validations.severity} - ${validations.message}`);
       }
     });
+    let validResults = [];
     if (next && nextTransaction.length > 0) {
       nextTransaction.forEach(([binding]) => this.shadowModelPaths.delete(binding));
       const result = next.set(nextTransaction, options);
       if (invalidBindings.length === 0) {
         return result;
       }
+      validResults = result;
     }
-    return invalidBindings.map((binding) => {
+    const invalidResults = invalidBindings.map((binding) => {
       return {
         binding,
         oldValue: asModel.get(binding),
@@ -2159,10 +2303,12 @@ class ValidationMiddleware {
         force: true
       };
     });
+    return [...validResults, ...invalidResults];
   }
   get(binding, options, next) {
+    var _a, _b;
     let val = next == null ? void 0 : next.get(binding, options);
-    if ((options == null ? void 0 : options.includeInvalid) === true) {
+    if ((_b = (_a = this.shouldIncludeInvalid) == null ? void 0 : _a.call(this, options)) != null ? _b : (options == null ? void 0 : options.includeInvalid) === true) {
       this.shadowModelPaths.forEach((shadowValue, shadowBinding) => {
         if (shadowBinding === binding) {
           val = shadowValue;
@@ -2175,6 +2321,10 @@ class ValidationMiddleware {
     }
     return val;
   }
+  delete(binding, options, next) {
+    this.shadowModelPaths = removeBindingAndChildrenFromMap(this.shadowModelPaths, binding);
+    return next == null ? void 0 : next.delete(binding, options);
+  }
 }
 
 class ValidatorRegistry {
@@ -2259,6 +2409,9 @@ class Parser {
     }
     return tapped;
   }
+  hasTemplateValues(obj, localKey) {
+    return Object.hasOwnProperty.call(obj, "template") && Array.isArray(obj == null ? void 0 : obj.template) && obj.template.length && obj.template.find((tmpl) => tmpl.output === localKey);
+  }
   parseObject(obj, type = exports.NodeType.Value, options = { templateDepth: 0 }) {
     var _a;
     const nodeType = this.hooks.determineNodeType.call(obj);
@@ -2276,12 +2429,19 @@ class Parser {
       if (!localObj) {
         return currentValue;
       }
-      const objEntries = Array.isArray(localObj) ? localObj.map((v, i) => [i, v]) : Object.entries(localObj);
+      const objEntries = Array.isArray(localObj) ? localObj.map((v, i) => [i, v]) : [
+        ...Object.entries(localObj),
+        ...Object.getOwnPropertySymbols(localObj).map((s) => [
+          s,
+          localObj[s]
+        ])
+      ];
       const defaultValue = {
         children: [],
         value: currentValue
       };
       const newValue = objEntries.reduce((accumulation, current) => {
+        var _b;
         const _a2 = accumulation, { children: children2 } = _a2, rest = __objRest$1(_a2, ["children"]);
         const [localKey, localValue] = current;
         if (localKey === "asset" && typeof localValue === "object") {
@@ -2299,14 +2459,19 @@ class Parser {
           }
         } else if (this.hooks.determineNodeType.call(localKey) === exports.NodeType.Template && Array.isArray(localValue)) {
           const templateChildren = localValue.map((template) => {
-            var _a3, _b;
+            var _a3, _b2;
             const templateAST = this.hooks.onCreateASTNode.call({
               type: exports.NodeType.Template,
               depth: (_a3 = options.templateDepth) != null ? _a3 : 0,
               data: template.data,
               template: template.value,
-              dynamic: (_b = template.dynamic) != null ? _b : false
+              dynamic: (_b2 = template.dynamic) != null ? _b2 : false
             }, template);
+            if ((templateAST == null ? void 0 : templateAST.type) === exports.NodeType.MultiNode) {
+              templateAST.values.forEach((v) => {
+                v.parent = templateAST;
+              });
+            }
             if (templateAST) {
               return {
                 path: [...path, template.output],
@@ -2320,6 +2485,18 @@ class Parser {
           });
         } else if (localValue && this.hooks.determineNodeType.call(localValue) === exports.NodeType.Switch) {
           const localSwitch = this.hooks.parseNode.call(localValue, exports.NodeType.Value, options, exports.NodeType.Switch);
+          if (localSwitch && localSwitch.type === exports.NodeType.Value && ((_b = localSwitch.children) == null ? void 0 : _b.length) === 1 && localSwitch.value === void 0) {
+            const firstChild = localSwitch.children[0];
+            return __spreadProps$7(__spreadValues$9({}, rest), {
+              children: [
+                ...children2,
+                {
+                  path: [...path, localKey, ...firstChild.path],
+                  value: firstChild.value
+                }
+              ]
+            });
+          }
           if (localSwitch) {
             return __spreadProps$7(__spreadValues$9({}, rest), {
               children: [
@@ -2336,7 +2513,7 @@ class Parser {
           if (childValues.length > 0) {
             const multiNode = this.hooks.onCreateASTNode.call({
               type: exports.NodeType.MultiNode,
-              override: true,
+              override: !this.hasTemplateValues(localObj, localKey),
               values: childValues
             }, localValue);
             if ((multiNode == null ? void 0 : multiNode.type) === exports.NodeType.MultiNode) {
@@ -2359,7 +2536,7 @@ class Parser {
         } else if (localValue && typeof localValue === "object") {
           const determineNodeType = this.hooks.determineNodeType.call(localValue);
           if (determineNodeType === exports.NodeType.Applicability) {
-            const parsedNode = this.hooks.parseNode.call(localValue, type, options, determineNodeType);
+            const parsedNode = this.hooks.parseNode.call(localValue, exports.NodeType.Value, options, determineNodeType);
             if (parsedNode) {
               return __spreadProps$7(__spreadValues$9({}, rest), {
                 children: [
@@ -2481,6 +2658,11 @@ const withContext = (model) => {
       return model.set(transaction, __spreadValues$7({
         context: { model }
       }, options));
+    },
+    delete: (binding, options) => {
+      return model.delete(binding, __spreadValues$7({
+        context: { model }
+      }, options));
     }
   };
 };
@@ -2510,12 +2692,16 @@ class Resolver {
     this.hooks.beforeUpdate.call(changes);
     const resolveCache = new Map();
     this.idCache.clear();
+    const prevASTMap = new Map(this.ASTMap);
     this.ASTMap.clear();
-    const updated = this.computeTree(this.root, void 0, changes, resolveCache, toNodeResolveOptions(this.options));
+    const updated = this.computeTree(this.root, void 0, changes, resolveCache, toNodeResolveOptions(this.options), void 0, prevASTMap);
     this.resolveCache = resolveCache;
     this.hooks.afterUpdate.call(updated.value);
     return updated.value;
   }
+  getResolveCache() {
+    return new Map(this.resolveCache);
+  }
   getNodeID(node) {
     var _a;
     if (!node) {
@@ -2547,7 +2733,19 @@ class Resolver {
     }
     return this.resolveCache.get(node);
   }
-  computeTree(node, parent, dataChanges, cacheUpdate, options) {
+  cloneNode(node) {
+    const clonedNode = timm.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] : __spreadValues$7({}, value);
+      }
+    });
+    return clonedNode;
+  }
+  computeTree(node, parent, dataChanges, cacheUpdate, options, parentNode, prevASTMap) {
     var _a, _b;
     const dependencyModel = new DependencyModel(options.data.model);
     dependencyModel.trackSubset("core");
@@ -2568,34 +2766,40 @@ class Resolver {
         updated: false
       });
       cacheUpdate.set(node, update2);
-      const repopulateASTMapFromCache = (resolvedAST3, AST) => {
+      const repopulateASTMapFromCache = (resolvedNode, AST, ASTParent) => {
         var _a2;
-        this.ASTMap.set(resolvedAST3, AST);
-        if ("children" in resolvedAST3) {
-          (_a2 = resolvedAST3.children) == null ? void 0 : _a2.forEach(({ value: childAST }) => {
-            const { node: childResolvedAST } = this.getPreviousResult(childAST) || {};
-            if (!childResolvedAST)
-              return;
-            repopulateASTMapFromCache(childResolvedAST, childAST);
-            if (childResolvedAST.type === exports.NodeType.MultiNode) {
-              childResolvedAST.values.forEach((mChildAST) => {
-                const { node: mChildResolvedAST } = this.getPreviousResult(mChildAST) || {};
-                if (!mChildResolvedAST)
-                  return;
-                repopulateASTMapFromCache(mChildResolvedAST, mChildAST);
-              });
-            }
-          });
+        const { node: resolvedAST2 } = resolvedNode;
+        this.ASTMap.set(resolvedAST2, AST);
+        const resolvedUpdate = __spreadProps$5(__spreadValues$7({}, resolvedNode), {
+          updated: false
+        });
+        cacheUpdate.set(AST, resolvedUpdate);
+        const handleChildNode = (childNode) => {
+          var _a3;
+          const originalChildNode = (_a3 = prevASTMap.get(childNode)) != null ? _a3 : childNode;
+          const previousChildResult = this.getPreviousResult(originalChildNode);
+          if (!previousChildResult)
+            return;
+          repopulateASTMapFromCache(previousChildResult, originalChildNode, AST);
+        };
+        if ("children" in resolvedAST2) {
+          (_a2 = resolvedAST2.children) == null ? void 0 : _a2.forEach(({ value: childAST }) => handleChildNode(childAST));
+        } else if (resolvedAST2.type === exports.NodeType.MultiNode) {
+          resolvedAST2.values.forEach(handleChildNode);
         }
+        this.hooks.afterNodeUpdate.call(AST, ASTParent, resolvedUpdate);
       };
-      const resolvedAST2 = previousResult.node;
-      repopulateASTMapFromCache(resolvedAST2, node);
-      this.hooks.afterNodeUpdate.call(node, parent, update2);
+      previousResult.node.parent = parentNode;
+      repopulateASTMapFromCache(previousResult, node, parent);
       return update2;
     }
-    const resolvedAST = (_a = this.hooks.beforeResolve.call(node, resolveOptions)) != null ? _a : {
+    const clonedNode = __spreadProps$5(__spreadValues$7({}, this.cloneNode(node)), {
+      parent: parentNode
+    });
+    const resolvedAST = (_a = this.hooks.beforeResolve.call(clonedNode, resolveOptions)) != null ? _a : {
       type: exports.NodeType.Empty
     };
+    resolvedAST.parent = parentNode;
     resolveOptions.node = resolvedAST;
     this.ASTMap.set(resolvedAST, node);
     let resolved = this.hooks.resolve.call(void 0, resolvedAST, resolveOptions);
@@ -2606,22 +2810,15 @@ class Resolver {
     const childDependencies = new Set();
     dependencyModel.trackSubset("children");
     if ("children" in resolvedAST) {
-      (_b = resolvedAST.children) == null ? void 0 : _b.forEach((child) => {
-        const computedChildTree = this.computeTree(child.value, node, dataChanges, cacheUpdate, resolveOptions);
-        let { updated: childUpdated, value: childValue } = computedChildTree;
-        const { node: childNode, dependencies: childTreeDeps } = computedChildTree;
+      const newChildren = (_b = resolvedAST.children) == null ? void 0 : _b.map((child) => {
+        const computedChildTree = this.computeTree(child.value, node, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap);
+        const {
+          dependencies: childTreeDeps,
+          node: childNode,
+          updated: childUpdated,
+          value: childValue
+        } = computedChildTree;
         childTreeDeps.forEach((binding) => childDependencies.add(binding));
-        if (childNode.type === exports.NodeType.MultiNode) {
-          childValue = [];
-          childNode.values.forEach((mValue) => {
-            const mTree = this.computeTree(mValue, node, dataChanges, cacheUpdate, resolveOptions);
-            if (mTree.value !== void 0 && mTree.value !== null) {
-              childValue.push(mTree.value);
-            }
-            mTree.dependencies.forEach((bindingDep) => childDependencies.add(bindingDep));
-            childUpdated = childUpdated || mTree.updated;
-          });
-        }
         if (childValue) {
           if (childNode.type === exports.NodeType.MultiNode && !childNode.override) {
             const arr = timm.addLast(get__default["default"](resolved, child.path, []), childValue);
@@ -2631,7 +2828,22 @@ class Resolver {
           }
         }
         updated = updated || childUpdated;
+        return __spreadProps$5(__spreadValues$7({}, child), { value: childNode });
+      });
+      resolvedAST.children = newChildren;
+    } else if (resolvedAST.type === exports.NodeType.MultiNode) {
+      const childValue = [];
+      const newValues = resolvedAST.values.map((mValue) => {
+        const mTree = this.computeTree(mValue, node, dataChanges, cacheUpdate, resolveOptions, resolvedAST, prevASTMap);
+        if (mTree.value !== void 0 && mTree.value !== null) {
+          childValue.push(mTree.value);
+        }
+        mTree.dependencies.forEach((bindingDep) => childDependencies.add(bindingDep));
+        updated = updated || mTree.updated;
+        return mTree.node;
       });
+      resolvedAST.values = newValues;
+      resolved = childValue;
     }
     childDependencies.forEach((bindingDep) => dependencyModel.addChildReadDep(bindingDep));
     dependencyModel.trackSubset("core");
@@ -2700,13 +2912,10 @@ class TemplatePlugin {
       }
     });
     const result = {
-      parent: node.parent,
       type: exports.NodeType.MultiNode,
+      override: false,
       values
     };
-    result.values.forEach((innerNode) => {
-      innerNode.parent = result;
-    });
     return result;
   }
   applyParser(parser) {
@@ -2800,19 +3009,20 @@ function resolveAllRefs(node, resolveOptions, propertiesToSkip) {
   });
   return newNode;
 }
-const findBasePath = (node) => {
+const findBasePath = (node, resolver) => {
   var _a, _b, _c;
   const parentNode = node.parent;
   if (!parentNode) {
     return [];
   }
   if ("children" in parentNode) {
-    return (_c = (_b = (_a = parentNode.children) == null ? void 0 : _a.find((child) => child.value === node)) == null ? void 0 : _b.path) != null ? _c : [];
+    const original = resolver.getSourceNode(node);
+    return (_c = (_b = (_a = parentNode.children) == null ? void 0 : _a.find((child) => child.value === original)) == null ? void 0 : _b.path) != null ? _c : [];
   }
   if (parentNode.type !== exports.NodeType.MultiNode) {
     return [];
   }
-  return findBasePath(parentNode);
+  return findBasePath(parentNode, resolver);
 };
 class StringResolverPlugin {
   constructor() {
@@ -2836,7 +3046,7 @@ class StringResolverPlugin {
         } else {
           propsToSkip = new Set(["exp"]);
         }
-        const nodePath = findBasePath(node);
+        const nodePath = findBasePath(node, resolver);
         if (nodePath.length > 0 && nodePath.some((segment) => propsToSkip.has(segment.toString()))) {
           return node.value;
         }
@@ -2856,7 +3066,7 @@ class ApplicabilityPlugin {
       let newNode = node;
       if ((node == null ? void 0 : node.type) === exports.NodeType.Applicability) {
         const isApplicable = options.evaluate(node.expression);
-        if (!isApplicable) {
+        if (isApplicable === false) {
           return null;
         }
         newNode = node.value;
@@ -3162,7 +3372,8 @@ class FlowInstance {
       skipTransition: new tapableTs.SyncBailHook(),
       beforeTransition: new tapableTs.SyncWaterfallHook(),
       resolveTransitionNode: new tapableTs.SyncWaterfallHook(),
-      transition: new tapableTs.SyncHook()
+      transition: new tapableTs.SyncHook(),
+      afterTransition: new tapableTs.SyncHook()
     };
     this.id = id;
     this.flow = flow;
@@ -3209,7 +3420,7 @@ class FlowInstance {
     } else {
       const skipTransition = this.hooks.skipTransition.call(this.currentState);
       if (skipTransition) {
-        (_d = this.log) == null ? void 0 : _d.debug(`Skipping transition from ${this.currentState} b/c hook told us to`);
+        (_d = this.log) == null ? void 0 : _d.debug(`Skipping transition from ${this.currentState.name} b/c hook told us to`);
         return;
       }
     }
@@ -3248,6 +3459,7 @@ class FlowInstance {
       this.hooks.onEnd.call(this.flow.onEnd);
     }
     this.hooks.transition.call(prevState, __spreadValues$5({}, newCurrentState));
+    this.hooks.afterTransition.call(this);
   }
 }
 
@@ -3282,6 +3494,7 @@ class FlowController {
     this.start = this.start.bind(this);
     this.run = this.run.bind(this);
     this.transition = this.transition.bind(this);
+    this.addNewFlow = this.addNewFlow.bind(this);
   }
   transition(stateTransition, options) {
     if (this.current === void 0) {
@@ -3290,20 +3503,9 @@ class FlowController {
     this.current.transition(stateTransition, options);
   }
   addNewFlow(flow) {
-    return __async$1(this, null, function* () {
-      this.navStack.push(flow);
-      this.current = flow;
-      flow.hooks.transition.tap("flow-controller", (_oldState, newState) => __async$1(this, null, function* () {
-        var _a, _b;
-        if (newState.value.state_type === "FLOW") {
-          (_a = this.log) == null ? void 0 : _a.debug(`Got FLOW state. Loading flow ${newState.value.ref}`);
-          const endState = yield this.run(newState.value.ref);
-          (_b = this.log) == null ? void 0 : _b.debug(`Flow ended. Using outcome: ${endState.outcome}`);
-          flow.transition(endState.outcome);
-        }
-      }));
-      this.hooks.flow.call(flow);
-    });
+    this.navStack.push(flow);
+    this.current = flow;
+    this.hooks.flow.call(flow);
   }
   run(startState) {
     return __async$1(this, null, function* () {
@@ -3318,6 +3520,18 @@ class FlowController {
       (_a = this.log) == null ? void 0 : _a.debug(`Starting flow: ${startState}`);
       const flow = new FlowInstance(startState, startFlow, { logger: this.log });
       this.addNewFlow(flow);
+      flow.hooks.afterTransition.tap("flow-controller", (flowInstance) => {
+        var _a2, _b, _c;
+        if (((_a2 = flowInstance.currentState) == null ? void 0 : _a2.value.state_type) === "FLOW") {
+          const subflowId = (_b = flowInstance.currentState) == null ? void 0 : _b.value.ref;
+          (_c = this.log) == null ? void 0 : _c.debug(`Loading subflow ${subflowId}`);
+          this.run(subflowId).then((subFlowEndState) => {
+            var _a3;
+            (_a3 = this.log) == null ? void 0 : _a3.debug(`Subflow ended. Using outcome: ${subFlowEndState.outcome}`);
+            flowInstance.transition(subFlowEndState == null ? void 0 : subFlowEndState.outcome);
+          });
+        }
+      });
       const end = yield flow.start();
       this.navStack.pop();
       if (this.navStack.length > 0) {
@@ -3370,11 +3584,18 @@ class ValidationBindingTrackerViewPlugin {
   getBindings() {
     return this.trackedBindings;
   }
+  trackBinding(binding) {
+    var _a, _b;
+    if (this.trackedBindings.has(binding)) {
+      return;
+    }
+    this.trackedBindings.add(binding);
+    (_b = (_a = this.options.callbacks) == null ? void 0 : _a.onAdd) == null ? void 0 : _b.call(_a, binding);
+  }
   applyResolver(resolver) {
     this.trackedBindings.clear();
     const tracked = new Map();
     const sections = new Map();
-    const seenBindings = new Set();
     let lastViewUpdateChangeSet;
     const nodeTree = new Map();
     let lastComputedBindingTree = new Map();
@@ -3421,31 +3642,34 @@ class ValidationBindingTrackerViewPlugin {
             parent = parent.parent;
           }
         }
-        if (!seenBindings.has(parsed)) {
-          seenBindings.add(parsed);
-          (_d = (_c = this.options.callbacks) == null ? void 0 : _c.onAdd) == null ? void 0 : _d.call(_c, parsed);
-        }
+        this.trackedBindings.add(parsed);
+        (_d = (_c = this.options.callbacks) == null ? void 0 : _c.onAdd) == null ? void 0 : _d.call(_c, parsed);
       };
       return __spreadProps$3(__spreadValues$4({}, options), {
         validation: __spreadProps$3(__spreadValues$4({}, options.validation), {
           get: (binding, getOptions) => {
-            var _a;
+            var _a, _b;
             if (getOptions == null ? void 0 : getOptions.track) {
               track(binding);
             }
-            const eow = (_a = options.validation) == null ? void 0 : _a._getValidationForBinding(binding);
-            if ((eow == null ? void 0 : eow.displayTarget) === void 0 || (eow == null ? void 0 : eow.displayTarget) === "field") {
-              return eow;
+            const eows = (_b = (_a = options.validation) == null ? void 0 : _a._getValidationForBinding(binding)) == null ? void 0 : _b.getAll(getOptions);
+            const firstFieldEOW = eows == null ? void 0 : eows.find((eow) => eow.displayTarget === "field" || eow.displayTarget === void 0);
+            return firstFieldEOW;
+          },
+          getValidationsForBinding(binding, getOptions) {
+            var _a, _b, _c;
+            if (getOptions == null ? void 0 : getOptions.track) {
+              track(binding);
             }
-            return void 0;
+            return (_c = (_b = (_a = options.validation) == null ? void 0 : _a._getValidationForBinding(binding)) == null ? void 0 : _b.getAll(getOptions)) != null ? _c : [];
           },
           getChildren: (type) => {
             var _a;
             const validations = new Array();
             (_a = lastComputedBindingTree.get(node)) == null ? void 0 : _a.forEach((binding) => {
-              var _a2;
-              const eow = (_a2 = options.validation) == null ? void 0 : _a2._getValidationForBinding(binding);
-              if (eow && type === eow.displayTarget) {
+              var _a2, _b;
+              const eow = (_b = (_a2 = options.validation) == null ? void 0 : _a2._getValidationForBinding(binding)) == null ? void 0 : _b.get();
+              if (eow && (type === void 0 || type === eow.displayTarget)) {
                 validations.push(eow);
               }
             });
@@ -3455,8 +3679,8 @@ class ValidationBindingTrackerViewPlugin {
             var _a;
             const validations = new Array();
             (_a = lastSectionBindingTree.get(node)) == null ? void 0 : _a.forEach((binding) => {
-              var _a2;
-              const eow = (_a2 = options.validation) == null ? void 0 : _a2._getValidationForBinding(binding);
+              var _a2, _b;
+              const eow = (_b = (_a2 = options.validation) == null ? void 0 : _a2._getValidationForBinding(binding)) == null ? void 0 : _b.get();
               if (eow && eow.displayTarget === "section") {
                 validations.push(eow);
               }
@@ -3475,7 +3699,7 @@ class ValidationBindingTrackerViewPlugin {
       });
     });
     resolver.hooks.afterNodeUpdate.tap(CONTEXT, (node, parent, update) => {
-      var _a, _b, _c;
+      var _a, _b;
       if (parent) {
         addToTree(node, parent);
       }
@@ -3490,7 +3714,7 @@ class ValidationBindingTrackerViewPlugin {
         currentBindingTree.set(node, (_b = lastComputedBindingTree.get(node)) != null ? _b : new Set());
       }
       if (node === resolver.root) {
-        this.trackedBindings = (_c = currentBindingTree.get(node)) != null ? _c : new Set();
+        this.trackedBindings = new Set(currentBindingTree.get(node));
         lastComputedBindingTree = currentBindingTree;
         lastSectionBindingTree.clear();
         sections.forEach((nodeSet, sectionNode) => {
@@ -3532,11 +3756,23 @@ var __spreadValues$3 = (a, b) => {
   return a;
 };
 var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const SCHEMA_VALIDATION_PROVIDER_NAME = "schema";
+const VIEW_VALIDATION_PROVIDER_NAME = "view";
+const 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"
+    state: "none",
+    isBlockingNavigation: false
   };
 }
 class ValidatedBinding {
@@ -3551,44 +3787,68 @@ class ValidatedBinding {
     possibleValidations.forEach((vObj) => {
       const { trigger } = vObj;
       if (this.validationsByState[trigger]) {
-        this.validationsByState[trigger].push(createStatefulValidationObject(vObj));
+        const statefulValidationObject = createStatefulValidationObject(vObj);
+        this.validationsByState[trigger].push(statefulValidationObject);
       } else {
         log == null ? void 0 : log.warn(`Unknown validation trigger: ${trigger}`);
       }
     });
     this.weakBindings = weakBindings != null ? weakBindings : new Set();
   }
+  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) {
+        return [
+          ...all,
+          __spreadProps$2(__spreadValues$3({}, statefulObj.response), {
+            blocking: this.checkIfBlocking(statefulObj)
+          })
+        ];
+      }
+      return all;
+    }, []);
+  }
   get() {
-    const firstError = this.applicableValidations.find((statefulObj) => {
-      const blocking = this.currentPhase === "navigation" ? statefulObj.value.blocking : true;
-      return statefulObj.state === "active" && blocking !== false;
+    const firstInvalid = this.applicableValidations.find((statefulObj) => {
+      return statefulObj.state === "active" && statefulObj.response;
     });
-    if ((firstError == null ? void 0 : firstError.state) === "active") {
-      return firstError.response;
+    if ((firstInvalid == null ? void 0 : firstInvalid.state) === "active") {
+      return __spreadProps$2(__spreadValues$3({}, firstInvalid.response), {
+        blocking: this.checkIfBlocking(firstInvalid)
+      });
     }
   }
-  runApplicableValidations(runner, canDismiss) {
-    this.applicableValidations = this.applicableValidations.map((obj) => {
+  runApplicableValidations(runner, canDismiss, phase) {
+    this.applicableValidations = this.applicableValidations.map((originalValue) => {
       var _a, _b, _c;
-      if (obj.state === "dismissed") {
-        return obj;
+      if (originalValue.state === "dismissed") {
+        return originalValue;
       }
-      const blocking = (_a = obj.value.blocking) != null ? _a : obj.value.severity === "warning" && "once" || obj.value.severity === "error" && true;
-      const dismissable = canDismiss && blocking === "once";
-      if (this.currentPhase === "navigation" && obj.state === "active" && dismissable) {
+      const blocking = (_a = originalValue.value.blocking) != null ? _a : originalValue.value.severity === "warning" && "once" || true;
+      const obj = timm.setIn(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) {
+          if (warn.dismissable && warn.response.dismiss && (warn.response.blocking !== "once" || !warn.response.blocking)) {
             warn.response.dismiss();
           } else {
+            if ((warn == null ? void 0 : warn.response.blocking) === "once") {
+              warn.response.blocking = false;
+            }
             warn.dismissable = true;
           }
-          return obj;
-        }
-        if (obj.value.severity === "error") {
-          const err = obj;
-          err.state = "none";
-          return obj;
+          return warn;
         }
       }
       const response = runner(obj.value);
@@ -3596,7 +3856,8 @@ class ValidatedBinding {
         type: obj.type,
         value: obj.value,
         state: response ? "active" : "none",
-        dismissable: obj.value.severity === "warning" && this.currentPhase === "navigation",
+        isBlockingNavigation,
+        dismissable: obj.value.severity === "warning" && phase === "navigation",
         response: response ? __spreadProps$2(__spreadValues$3({}, obj.value), {
           message: (_b = response.message) != null ? _b : "Something is broken",
           severity: obj.value.severity,
@@ -3614,11 +3875,12 @@ class ValidatedBinding {
     });
   }
   update(phase, canDismiss, runner) {
+    const newApplicableValidations = [];
     if (phase === "load" && this.currentPhase !== void 0) {
       return;
     }
     if (this.currentPhase === "navigation" || phase === this.currentPhase) {
-      this.runApplicableValidations(runner, canDismiss);
+      this.runApplicableValidations(runner, canDismiss, phase);
       return;
     }
     if (phase === "load") {
@@ -3631,14 +3893,19 @@ class ValidatedBinding {
         ...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);
+        }
+      });
       this.applicableValidations = [
-        ...this.applicableValidations,
-        ...this.currentPhase === "load" ? this.validationsByState.change : [],
-        ...this.validationsByState.navigation
+        ...newApplicableValidations,
+        ...this.validationsByState.navigation,
+        ...this.currentPhase === "load" ? this.validationsByState.change : []
       ];
       this.currentPhase = "navigation";
     }
-    this.runApplicableValidations(runner, canDismiss);
+    this.runApplicableValidations(runner, canDismiss, phase);
   }
 }
 class ValidationController {
@@ -3646,20 +3913,34 @@ class ValidationController {
     this.hooks = {
       createValidatorRegistry: new tapableTs.SyncHook(),
       onAddValidation: new tapableTs.SyncWaterfallHook(),
-      onRemoveValidation: new tapableTs.SyncWaterfallHook()
+      onRemoveValidation: new tapableTs.SyncWaterfallHook(),
+      resolveValidationProviders: new tapableTs.SyncWaterfallHook(),
+      onTrackBinding: new tapableTs.SyncHook()
     };
     this.validations = new Map();
     this.weakBindingTracker = new Set();
-    this.lastActiveBindings = new Set();
     this.schema = schema;
     this.options = options;
-    this.providers = [schema];
+    this.reset();
   }
   setOptions(options) {
     this.options = options;
   }
   getDataMiddleware() {
     return [
+      {
+        set: (transaction, options, next) => {
+          var _a;
+          return (_a = next == null ? void 0 : next.set(transaction, options)) != null ? _a : [];
+        },
+        get: (binding, options, next) => {
+          return next == null ? void 0 : next.get(binding, options);
+        },
+        delete: (binding, options, next) => {
+          this.validations = removeBindingAndChildrenFromMap(this.validations, binding);
+          return next == null ? void 0 : next.delete(binding, options);
+        }
+      },
       new ValidationMiddleware((binding) => {
         var _a;
         if (!this.options) {
@@ -3675,13 +3956,17 @@ class ValidationController {
           var _a2;
           if (caresAboutDataChanges(new Set([binding]), weakValidation.weakBindings) && ((_a2 = weakValidation == null ? void 0 : weakValidation.get()) == null ? void 0 : _a2.severity) === "error") {
             weakValidation == null ? void 0 : weakValidation.weakBindings.forEach((weakBinding) => {
-              weakBinding === strongBinding ? newInvalidBindings.add({
-                binding: weakBinding,
-                isStrong: true
-              }) : newInvalidBindings.add({
-                binding: weakBinding,
-                isStrong: false
-              });
+              if (weakBinding === strongBinding) {
+                newInvalidBindings.add({
+                  binding: weakBinding,
+                  isStrong: true
+                });
+              } else {
+                newInvalidBindings.add({
+                  binding: weakBinding,
+                  isStrong: false
+                });
+              }
             });
           }
         });
@@ -3694,6 +3979,35 @@ class ValidationController {
       }) })
     ];
   }
+  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) => {
+            var _a, _b;
+            return (_b = (_a = this.viewValidationProvider) == null ? void 0 : _a.getValidationsForBinding) == null ? void 0 : _b.call(_a, binding);
+          },
+          getValidationsForView: () => {
+            var _a, _b;
+            return (_b = (_a = this.viewValidationProvider) == null ? void 0 : _a.getValidationsForView) == null ? void 0 : _b.call(_a);
+          }
+        }
+      }
+    ]);
+    return this.providers;
+  }
+  reset() {
+    this.validations.clear();
+    this.tracker = void 0;
+  }
   onView(view) {
     this.validations.clear();
     if (!this.options) {
@@ -3702,7 +4016,7 @@ class ValidationController {
     const bindingTrackerPlugin = new ValidationBindingTrackerViewPlugin(__spreadProps$2(__spreadValues$3({}, this.options), {
       callbacks: {
         onAdd: (binding) => {
-          if (!this.options) {
+          if (!this.options || this.getValidationForBinding(binding) !== void 0) {
             return;
           }
           const originalValue = this.options.model.get(binding);
@@ -3717,21 +4031,28 @@ class ValidationController {
           this.updateValidationsForBinding(binding, "load", this.options, () => {
             view.update(new Set([binding]));
           });
+          this.hooks.onTrackBinding.call(binding);
         }
       }
     }));
     this.tracker = bindingTrackerPlugin;
-    this.providers = [this.schema, view];
+    this.viewValidationProvider = view;
     bindingTrackerPlugin.apply(view);
   }
-  updateValidationsForBinding(binding, trigger, context, onDismiss) {
+  updateValidationsForBinding(binding, trigger, validationContext, onDismiss) {
     var _a;
+    const context = validationContext != null ? validationContext : this.options;
+    if (!context) {
+      throw new Error(`Context is required for executing validations`);
+    }
     if (trigger === "load") {
-      const possibleValidations = this.providers.reduce((vals, provider) => {
-        var _a2, _b;
+      const possibleValidations = this.getValidationProviders().reduce((vals, provider) => {
+        var _a2, _b, _c, _d;
         return [
           ...vals,
-          ...(_b = (_a2 = provider.getValidationsForBinding) == null ? void 0 : _a2.call(provider, binding)) != null ? _b : []
+          ...(_d = (_c = (_b = (_a2 = provider.provider).getValidationsForBinding) == null ? void 0 : _b.call(_a2, binding)) == null ? void 0 : _c.map((valObj) => __spreadProps$2(__spreadValues$3({}, valObj), {
+            [VALIDATION_PROVIDER_NAME_SYMBOL]: provider.source
+          }))) != null ? _d : []
         ];
       }, []);
       if (possibleValidations.length === 0) {
@@ -3741,7 +4062,7 @@ class ValidationController {
     }
     const trackedValidations = this.validations.get(binding);
     trackedValidations == null ? void 0 : trackedValidations.update(trigger, true, (validationObj) => {
-      const response = this.validationRunner(validationObj, context, binding);
+      const response = this.validationRunner(validationObj, binding, context);
       if (this.weakBindingTracker.size > 0) {
         const t = this.validations.get(binding);
         this.weakBindingTracker.forEach((b) => t.weakBindings.add(b));
@@ -3752,27 +4073,33 @@ class ValidationController {
       this.validations.forEach((validation, vBinding) => {
         if (vBinding !== binding && caresAboutDataChanges(new Set([binding]), validation.weakBindings)) {
           validation.update(trigger, true, (validationObj) => {
-            const response = this.validationRunner(validationObj, context, vBinding);
+            const response = this.validationRunner(validationObj, vBinding, context);
             return response ? { message: response.message } : void 0;
           });
         }
       });
     }
   }
-  validationRunner(validationObj, context, binding) {
-    const handler = this.getValidator(validationObj.type);
+  validationRunner(validationObj, binding, context = this.options) {
+    var _a;
+    if (!context) {
+      throw new Error("No context provided to validation runner");
+    }
+    const handler = (_a = validationObj.handler) != null ? _a : this.getValidator(validationObj.type);
     const weakBindings = new Set();
     const model = {
-      get(b, options = { includeInvalid: true }) {
+      get(b, options) {
         weakBindings.add(isBinding(b) ? binding : context.parseBinding(b));
-        return context.model.get(b, options);
+        return context.model.get(b, __spreadProps$2(__spreadValues$3({}, options), { includeInvalid: true }));
       },
-      set: context.model.set
+      set: context.model.set,
+      delete: context.model.delete
     };
     const result = handler == null ? void 0 : handler(__spreadProps$2(__spreadValues$3({}, context), {
       evaluate: (exp, options = { model }) => context.evaluate(exp, options),
       model,
-      validation: validationObj
+      validation: validationObj,
+      schemaType: this.schema.getType(binding)
     }), context.model.get(binding, {
       includeInvalid: true,
       formatted: validationObj.dataTarget === "formatted"
@@ -3796,29 +4123,27 @@ class ValidationController {
     }
   }
   updateValidationsForView(trigger) {
-    const { activeBindings } = this;
-    const canDismiss = trigger !== "navigation" || this.setCompare(this.lastActiveBindings, activeBindings);
-    this.getBindings().forEach((binding) => {
-      var _a;
-      (_a = this.validations.get(binding)) == null ? void 0 : _a.update(trigger, canDismiss, (obj) => {
-        if (!this.options) {
-          return;
-        }
-        return this.validationRunner(obj, this.options, binding);
+    const isNavigationTrigger = trigger === "navigation";
+    const lastActiveBindings = this.activeBindings;
+    const updateValidations = (dismissValidations) => {
+      this.getBindings().forEach((binding) => {
+        var _a;
+        (_a = this.validations.get(binding)) == null ? void 0 : _a.update(trigger, dismissValidations, (obj) => {
+          if (!this.options) {
+            return;
+          }
+          return this.validationRunner(obj, binding, this.options);
+        });
       });
-    });
-    if (trigger === "navigation") {
-      this.lastActiveBindings = activeBindings;
+    };
+    updateValidations(!isNavigationTrigger);
+    if (isNavigationTrigger) {
+      const { activeBindings } = this;
+      if (isSubset(activeBindings, lastActiveBindings)) {
+        updateValidations(true);
+      }
     }
   }
-  setCompare(set1, set2) {
-    if (set1.size !== set2.size)
-      return false;
-    for (const entry of set1)
-      if (!set2.has(entry))
-        return false;
-    return true;
-  }
   get activeBindings() {
     return new Set(Array.from(this.getBindings()).filter((b) => {
       var _a;
@@ -3838,19 +4163,30 @@ class ValidationController {
     var _a, _b;
     return (_b = (_a = this.tracker) == null ? void 0 : _a.getBindings()) != null ? _b : new Set();
   }
+  trackBinding(binding) {
+    var _a;
+    (_a = this.tracker) == null ? void 0 : _a.trackBinding(binding);
+  }
   validateView(trigger = "navigation") {
     this.updateValidationsForView(trigger);
     const validations = new Map();
+    let canTransition = true;
     this.getBindings().forEach((b) => {
-      var _a, _b;
-      const invalid = (_a = this.getValidationForBinding(b)) == null ? void 0 : _a.get();
-      if (invalid) {
-        (_b = this.options) == null ? void 0 : _b.logger.debug(`Validation on binding: ${b.asString()} is preventing navigation. ${JSON.stringify(invalid)}`);
-        validations.set(b, invalid);
-      }
+      var _a;
+      const allValidations = (_a = this.getValidationForBinding(b)) == null ? void 0 : _a.getAll();
+      allValidations == null ? void 0 : allValidations.forEach((v) => {
+        var _a2;
+        if (trigger === "navigation" && v.blocking) {
+          (_a2 = this.options) == null ? void 0 : _a2.logger.debug(`Validation on binding: ${b.asString()} is preventing navigation. ${JSON.stringify(v)}`);
+          canTransition = false;
+        }
+        if (!validations.has(b)) {
+          validations.set(b, v);
+        }
+      });
     });
     return {
-      canTransition: validations.size === 0,
+      canTransition,
       validations: validations.size ? validations : void 0
     };
   }
@@ -3860,8 +4196,7 @@ class ValidationController {
   forView(parser) {
     return {
       _getValidationForBinding: (binding) => {
-        var _a;
-        return (_a = this.getValidationForBinding(isBinding(binding) ? binding : parser(binding))) == null ? void 0 : _a.get();
+        return this.getValidationForBinding(isBinding(binding) ? binding : parser(binding));
       },
       getAll: () => {
         const bindings = this.getBindings();
@@ -3881,6 +4216,9 @@ class ValidationController {
       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");
       },
@@ -3891,7 +4229,7 @@ class ValidationController {
         throw new Error("Tracking should be provided by the view plugin");
       },
       register: () => {
-        throw new Error("Section funcationality hould be provided by the view plugin");
+        throw new Error("Section functionality should be provided by the view plugin");
       },
       type: (binding) => this.schema.getType(isBinding(binding) ? binding : parser(binding))
     };
@@ -4007,10 +4345,11 @@ class AssetTransformCorePlugin {
           };
         };
         resolver.hooks.beforeResolve.tap("asset-transform", (node, options) => {
+          var _a;
           if (node && (node.type === "asset" || node.type === "view")) {
             const transform = this.registry.get(node.value);
             if (transform == null ? void 0 : transform.beforeResolve) {
-              const store = getStore(node, this.beforeResolveSymbol);
+              const store = getStore((_a = options.node) != null ? _a : node, this.beforeResolveSymbol);
               return transform.beforeResolve(node, options, store);
             }
           }
@@ -4088,14 +4427,26 @@ class ViewController {
         }
       });
     });
-    options.model.hooks.onUpdate.tap("viewController", (updates) => {
+    const update = (updates) => {
       if (this.currentView) {
         if (this.optimizeUpdates) {
-          this.queueUpdate(new Set(updates.map((t) => t.binding)));
+          this.queueUpdate(updates);
         } else {
           this.currentView.update();
         }
       }
+    };
+    options.model.hooks.onUpdate.tap("viewController", (updates) => {
+      update(new Set(updates.map((t) => t.binding)));
+    });
+    options.model.hooks.onDelete.tap("viewController", (binding) => {
+      const parentBinding = binding.parent();
+      const property = binding.key();
+      if (typeof property === "number" && parentBinding) {
+        update(new Set([parentBinding]));
+      } else {
+        update(new Set([binding]));
+      }
     });
   }
   queueUpdate(bindings) {
@@ -4140,6 +4491,25 @@ class ViewController {
   }
 }
 
+class ReadOnlyDataController {
+  constructor(controller, logger) {
+    this.controller = controller;
+    this.logger = logger;
+  }
+  get(binding, options) {
+    return this.controller.get(binding, options);
+  }
+  set(transaction, options) {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.error("Error: Tried to set in a read only instance of the DataController");
+    return [];
+  }
+  delete(binding, options) {
+    var _a;
+    (_a = this.logger) == null ? void 0 : _a.error("Error: Tried to delete in a read only instance of the DataController");
+  }
+}
+
 class DataController {
   constructor(model, options) {
     this.hooks = {
@@ -4196,16 +4566,19 @@ class DataController {
       });
     }
     const setUpdates = normalizedTransaction.reduce((updates, [binding, newVal]) => {
-      var _a;
+      var _a, _b;
       const oldVal = this.get(binding, { includeInvalid: true });
-      if (!dequal.dequal(oldVal, newVal)) {
-        updates.push({
-          binding,
-          newValue: newVal,
-          oldValue: oldVal
-        });
+      const update = {
+        binding,
+        newValue: newVal,
+        oldValue: oldVal
+      };
+      if (dequal.dequal(oldVal, newVal)) {
+        (_a = this.logger) == null ? void 0 : _a.debug(`Skipping update for path: ${binding.asString()}. Value was unchanged: ${oldVal}`);
+      } else {
+        updates.push(update);
+        (_b = this.logger) == null ? void 0 : _b.debug(`Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`);
       }
-      (_a = this.logger) == null ? void 0 : _a.debug(`Setting path: ${binding.asString()} from: ${oldVal} to: ${newVal}`);
       return updates;
     }, []);
     const result = this.getModel().set(normalizedTransaction, options);
@@ -4218,17 +4591,16 @@ class DataController {
       }
     });
     this.hooks.onSet.call(normalizedTransaction);
-    this.hooks.onSet.call(normalizedTransaction);
     if (setUpdates.length > 0) {
       this.hooks.onUpdate.call(setUpdates, options);
     }
     return result;
   }
-  resolve(binding) {
-    return Array.isArray(binding) || typeof binding === "string" ? this.pathResolver.parse(binding) : binding;
+  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);
+    const resolved = binding instanceof BindingInstance ? binding : this.resolve(binding, true);
     let result = this.getModel().get(resolved, options);
     if (result === void 0 && !(options == null ? void 0 : options.ignoreDefaultValue)) {
       const defaultVal = this.hooks.resolveDefaultValue.call(resolved);
@@ -4238,48 +4610,33 @@ class DataController {
     }
     if (options == null ? void 0 : options.formatted) {
       result = this.hooks.format.call(result, resolved);
+    } else if ((options == null ? void 0 : options.formatted) === false) {
+      result = this.hooks.deformat.call(result, resolved);
     }
     this.hooks.onGet.call(binding, result);
     return result;
   }
-  delete(binding) {
-    if (binding === void 0 || binding === null) {
-      throw new Error(`Invalid arguments: delete expects a data path (string)`);
-    }
-    const resolved = this.resolve(binding);
-    this.hooks.onDelete.call(resolved);
-    this.deleteData(resolved);
-  }
-  getTrash() {
-    return this.trash;
-  }
-  addToTrash(binding) {
-    this.trash.add(binding);
-  }
-  deleteData(binding) {
-    const parentBinding = binding.parent();
-    const parentPath = parentBinding.asString();
-    const property = binding.key();
-    const existedBeforeDelete = Object.prototype.hasOwnProperty.call(this.get(parentBinding), property);
-    if (property !== void 0) {
-      const parent = parentBinding ? this.get(parentBinding) : void 0;
-      if (parentPath && Array.isArray(parent)) {
-        if (parent.length > property) {
-          this.set([[parentBinding, timm.removeAt(parent, property)]]);
-        }
-      } else if (parentPath && parent[property]) {
-        this.set([[parentBinding, timm.omit(parent, property)]]);
-      } else if (!parentPath) {
-        this.getModel().reset(timm.omit(this.get(""), property));
-      }
+  delete(binding, options) {
+    if (typeof binding !== "string" && !Array.isArray(binding) && !(binding instanceof BindingInstance)) {
+      throw new Error("Invalid arguments: delete expects a data path (string)");
     }
-    if (existedBeforeDelete && !this.get(binding)) {
-      this.addToTrash(binding);
+    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);
+  }
 }
 
 var __defProp$1 = Object.defineProperty;
@@ -4336,10 +4693,15 @@ class ConstantsController {
       this.tempStore.set(namespace, new LocalModel(data));
     }
   }
-  clearTemporaryValues() {
-    this.tempStore.forEach((value) => {
-      value.reset();
-    });
+  clearTemporaryValues(namespace) {
+    var _a;
+    if (namespace) {
+      (_a = this.tempStore.get(namespace)) == null ? void 0 : _a.reset();
+    } else {
+      this.tempStore.forEach((value) => {
+        value.reset();
+      });
+    }
   }
 }
 
@@ -4377,6 +4739,39 @@ class FlowExpPlugin {
   }
 }
 
+const createFormatFunction = (schema) => {
+  const handler = (ctx, value, formatName) => {
+    var _a, _b;
+    return (_b = (_a = schema.getFormatterForType({ type: formatName })) == null ? void 0 : _a.format(value)) != null ? _b : value;
+  };
+  return handler;
+};
+class DefaultExpPlugin {
+  constructor() {
+    this.name = "flow-exp-plugin";
+  }
+  apply(player) {
+    let formatFunction;
+    player.hooks.schema.tap(this.name, (schemaController) => {
+      formatFunction = createFormatFunction(schemaController);
+    });
+    player.hooks.expressionEvaluator.tap(this.name, (expEvaluator) => {
+      if (formatFunction) {
+        expEvaluator.addExpressionFunction("format", formatFunction);
+      }
+      expEvaluator.addExpressionFunction("log", (ctx, ...args) => {
+        player.logger.info(...args);
+      });
+      expEvaluator.addExpressionFunction("debug", (ctx, ...args) => {
+        player.logger.debug(...args);
+      });
+      expEvaluator.addExpressionFunction("eval", (ctx, ...args) => {
+        return ctx.evaluate(...args);
+      });
+    });
+  }
+}
+
 const NOT_STARTED_STATE = {
   ref: Symbol("not-started"),
   status: "not-started"
@@ -4421,8 +4816,8 @@ var __async = (__this, __arguments, generator) => {
     step((generator = generator.apply(__this, __arguments)).next());
   });
 };
-const PLAYER_VERSION = "0.4.0";
-const COMMIT = "39b851fc45e4903eae2f5b0697dea142c890443c";
+const PLAYER_VERSION = "0.4.1-next.0";
+const COMMIT = "3fca14a3bf47195b400f5989a2f3ecbc5f73ac4b";
 const _Player = class {
   constructor(config) {
     this.logger = new TapableLogger();
@@ -4443,14 +4838,15 @@ const _Player = class {
       resolveFlowContent: new tapableTs.SyncWaterfallHook()
     };
     var _a;
-    const initialPlugins = [];
-    const flowExpPlugin = new FlowExpPlugin();
-    initialPlugins.push(flowExpPlugin);
     if (config == null ? void 0 : config.logger) {
       this.logger.addHandler(config.logger);
     }
     this.config = config || {};
-    this.config.plugins = [...this.config.plugins || [], ...initialPlugins];
+    this.config.plugins = [
+      new DefaultExpPlugin(),
+      ...this.config.plugins || [],
+      new FlowExpPlugin()
+    ];
     (_a = this.config.plugins) == null ? void 0 : _a.forEach((plugin) => {
       plugin.apply(this);
     });
@@ -4541,10 +4937,11 @@ const _Player = class {
       flowResultDeferred.reject(e);
       return true;
     });
-    function resolveStrings(val) {
+    function resolveStrings(val, formatted) {
       return resolveDataRefs(val, {
         model: dataController,
-        evaluate: expressionEvaluator.evaluate
+        evaluate: expressionEvaluator.evaluate,
+        formatted
       });
     }
     flowController.hooks.flow.tap("player", (flow) => {
@@ -4580,23 +4977,21 @@ const _Player = class {
           newState = timm.setIn(state, ["ref"], resolveStrings(state.ref));
         }
         if ("param" in state) {
-          newState = timm.setIn(state, ["param"], resolveStrings(state.param));
+          newState = timm.setIn(state, ["param"], resolveStrings(state.param, false));
         }
         return newState;
       });
       flow.hooks.transition.tap("player", (_oldState, newState) => {
-        if (newState.value.state_type === "ACTION") {
-          const { exp } = newState.value;
-          queueMicrotask__default["default"](() => {
-            try {
-              flowController == null ? void 0 : flowController.transition(String(expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp)));
-            } catch (error) {
-              const state = this.getState();
-              if (error instanceof Error && state.status === "in-progress") {
-                state.fail(error);
-              }
-            }
-          });
+        if (newState.value.state_type !== "VIEW") {
+          validationController.reset();
+        }
+      });
+      flow.hooks.afterTransition.tap("player", (flowInstance) => {
+        var _a;
+        const value = (_a = flowInstance.currentState) == null ? void 0 : _a.value;
+        if (value && value.state_type === "ACTION") {
+          const { exp } = value;
+          flowController == null ? void 0 : flowController.transition(String(expressionEvaluator == null ? void 0 : expressionEvaluator.evaluate(exp)));
         }
         expressionEvaluator.reset();
       });
@@ -4614,6 +5009,11 @@ const _Player = class {
       parseBinding,
       transition: flowController.transition,
       model: dataController,
+      utils: {
+        findPlugin: (pluginSymbol) => {
+          return this.findPlugin(pluginSymbol);
+        }
+      },
       logger: this.logger,
       flowController,
       schema,
@@ -4627,23 +5027,19 @@ const _Player = class {
       },
       validation: __spreadProps(__spreadValues({}, validationController.forView(parseBinding)), {
         type: (b) => schema.getType(parseBinding(b))
-      })
+      }),
+      constants: this.constantsController
     });
     viewController.hooks.view.tap("player", (view) => {
       validationController.onView(view);
       this.hooks.view.call(view);
     });
     this.hooks.viewController.call(viewController);
-    const formatFunction = (ctx, value, formatName) => {
-      var _a, _b;
-      return (_b = (_a = schema.getFormatterForType({ type: formatName })) == null ? void 0 : _a.format(value)) != null ? _b : value;
-    };
-    expressionEvaluator.addExpressionFunction("format", formatFunction);
     return {
       start: () => {
         flowController.start().then((endState) => {
           const flowResult = {
-            endState: resolveStrings(endState),
+            endState: resolveStrings(endState, false),
             data: dataController.serialize()
           };
           return flowResult;
@@ -4696,7 +5092,9 @@ const _Player = class {
           ref,
           status: "completed",
           flow: state.flow,
-          dataModel: state.controllers.data.getModel()
+          controllers: {
+            data: state.controllers.data.makeReadOnly()
+          }
         };
         return maybeUpdateState(__spreadValues(__spreadValues({}, yield state.flowResult), endProps));
       } catch (error) {
@@ -4720,6 +5118,7 @@ Player.info = {
 
 exports.ApplicabilityPlugin = ApplicabilityPlugin;
 exports.AssetTransformCorePlugin = AssetTransformCorePlugin;
+exports.BINDING_BRACKETS_REGEX = BINDING_BRACKETS_REGEX;
 exports.BindingInstance = BindingInstance;
 exports.BindingParser = BindingParser;
 exports.Builder = Builder;
@@ -4747,12 +5146,15 @@ exports.Player = Player;
 exports.ProxyLogger = ProxyLogger;
 exports.ROOT_BINDING = ROOT_BINDING;
 exports.Resolver = Resolver;
+exports.SCHEMA_VALIDATION_PROVIDER_NAME = SCHEMA_VALIDATION_PROVIDER_NAME;
 exports.SIMPLE_BINDING_REGEX = SIMPLE_BINDING_REGEX;
 exports.SchemaController = SchemaController;
 exports.StringResolverPlugin = StringResolverPlugin;
 exports.SwitchPlugin = SwitchPlugin;
 exports.TapableLogger = TapableLogger;
 exports.TemplatePlugin = TemplatePlugin;
+exports.VALIDATION_PROVIDER_NAME_SYMBOL = VALIDATION_PROVIDER_NAME_SYMBOL;
+exports.VIEW_VALIDATION_PROVIDER_NAME = VIEW_VALIDATION_PROVIDER_NAME;
 exports.ValidationBindingTrackerViewPlugin = ValidationBindingTrackerViewPlugin;
 exports.ValidationController = ValidationController;
 exports.ValidationMiddleware = ValidationMiddleware;
@@ -4767,8 +5169,11 @@ exports.findNextExp = findNextExp;
 exports.getBindingSegments = getBindingSegments;
 exports.isBinding = isBinding;
 exports.isExpressionNode = isExpressionNode;
+exports.isObjectExpression = isObjectExpression;
 exports.maybeConvertToNum = maybeConvertToNum;
 exports.parse = parse;
+exports.parseExpression = parseExpression;
+exports.removeBindingAndChildrenFromMap = removeBindingAndChildrenFromMap;
 exports.resolveDataRefs = resolveDataRefs;
 exports.resolveDataRefsInString = resolveDataRefsInString;
 exports.resolveExpressionsInString = resolveExpressionsInString;