ember-source 6.4.0-alpha.2 → 6.4.0-alpha.4

package/dist/packages/@glimmer/opcode-compiler/index.js

@@ -1,28 +1,66 @@
-import { isSmallInt, encodeImmediate, assert as debugAssert, EMPTY_STRING_ARRAY, unwrap, reverse, expect, debugToString as debugToString$1, Stack as StackImpl, isPresentArray, encodeHandle, EMPTY_ARRAY, assign, enumerate, dict } from '../util/index.js';
-import { Op, MachineOp, $v0, $fp, InternalComponentCapabilities, $s0, $sp, ContentType, $s1, TYPE_SIZE, isMachineOp, MACHINE_MASK, ARG_SHIFT } from '../vm/index.js';
+import { EMPTY_STRING_ARRAY, reverse, enumerate, dict, EMPTY_ARRAY, assign, Stack as StackImpl } from '../util/index.js';
 import { InstructionEncoderImpl } from '../encoder/index.js';
+import { $v0, $fp, $s0, $sp, InternalComponentCapabilities, $s1, TYPE_SIZE, MACHINE_MASK, ARG_SHIFT, ContentType } from '../vm/index.js';
 import { SexpOpcodes as opcodes } from '../wire-format/index.js';
 import { hasCapability } from '../manager/index.js';
 import { isDevelopingApp } from '@embroider/macros';
 
+let debugToString;
+if (isDevelopingApp()) {
+  let getFunctionName = fn => {
+      let functionName = fn.name;
+      if ("" === functionName) {
+        let match = /function (\w+)\s*\(/u.exec(String(fn));
+        functionName = match && match[1] || "";
+      }
+      return functionName.replace(/^bound /u, "");
+    },
+    getObjectName = obj => {
+      let name, className;
+      // If the class has a decent looking name, and the `toString` is one of the
+      // default Ember toStrings, replace the constructor portion of the toString
+      // with the class name. We check the length of the class name to prevent doing
+      // this when the value is minified.
+      return "function" == typeof obj.constructor && (className = getFunctionName(obj.constructor)), "toString" in obj && obj.toString !== Object.prototype.toString && obj.toString !== Function.prototype.toString && (
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      name = obj.toString()), name && /<.*:ember\d+>/u.test(name) && className && "_" !== className[0] && className.length > 2 && "Class" !== className ? name.replace(/<.*:/u, `<${className}:`) : name || className;
+    },
+    getPrimitiveName = value => String(value);
+  debugToString = value => "function" == typeof value ? getFunctionName(value) || "(unknown function)" : "object" == typeof value && null !== value ? getObjectName(value) || "(unknown object)" : getPrimitiveName(value);
+}
+var debugToString$1 = debugToString;
+function encodeImmediate(num) {
+  return (num |= 0) < 0 ? function (num) {
+    return -536870913 & num;
+  }(num) : function (num) {
+    return ~num;
+  }(num);
+}
 let debugCompiler;
 function makeResolutionTypeVerifier(typeToVerify) {
   return opcode => {
     if (!function (opcode) {
       return Array.isArray(opcode) && 2 === opcode.length;
-    }(opcode)) return !1;
+    }(opcode)) return false;
     let type = opcode[0];
     return type === opcodes.GetStrictKeyword || type === opcodes.GetLexicalSymbol || type === typeToVerify;
   };
 }
-new Array(Op.Size).fill(null), new Array(Op.Size).fill(null);
+[1, -1].forEach(x => {
+  return num = encodeImmediate(x), (num |= 0) > -536870913 ? function (num) {
+    return ~num;
+  }(num) : function (num) {
+    return 536870912 | num;
+  }(num);
+  var num;
+});
 const isGetFreeComponent = makeResolutionTypeVerifier(opcodes.GetFreeAsComponentHead),
   isGetFreeModifier = makeResolutionTypeVerifier(opcodes.GetFreeAsModifierHead),
   isGetFreeHelper = makeResolutionTypeVerifier(opcodes.GetFreeAsHelperHead),
   isGetFreeComponentOrHelper = makeResolutionTypeVerifier(opcodes.GetFreeAsComponentOrHelperHead);
 function assertResolverInvariants(meta) {
   if (isDevelopingApp()) {
-    if (!meta.upvars) throw new Error("Attempted to resolve a component, helper, or modifier, but no free vars were found");
+    if (!meta.symbols.upvars) throw new Error("Attempted to resolve a component, helper, or modifier, but no free vars were found");
     if (!meta.owner) throw new Error("Attempted to resolve a component, helper, or modifier, but no owner was associated with the template it was being resolved from");
   }
   return meta;
@@ -35,75 +73,46 @@ function assertResolverInvariants(meta) {
  */
 function lookupBuiltInHelper(expr, resolver, meta, constants, type) {
   let {
-      upvars: upvars
+      symbols: {
+        upvars: upvars
+      }
     } = assertResolverInvariants(meta),
-    name = unwrap(upvars[expr[1]]),
-    helper = resolver.lookupBuiltInHelper(name);
+    name = upvars[expr[1]],
+    helper = resolver?.lookupBuiltInHelper?.(name) ?? null;
   if (isDevelopingApp() && null === helper)
     // Keyword helper did not exist, which means that we're attempting to use a
     // value of some kind that is not in scope
-    throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve a ${type} in a strict mode template, but that value was not in scope: ${meta.upvars[expr[1]] ?? "{unknown variable}"}`);
+    throw meta.isStrictMode, new Error(`Attempted to resolve a ${type} in a strict mode template, but that value was not in scope: ${
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+    meta.symbols.upvars[expr[1]] ?? "{unknown variable}"}`);
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
   return constants.helper(helper, name);
 }
-const HighLevelResolutionOpcodes = {
-    Modifier: 1003,
-    Component: 1004,
-    Helper: 1005,
-    ComponentOrHelper: 1007,
-    OptionalComponentOrHelper: 1008,
-    Local: 1010,
-    TemplateLocal: 1011
-  },
-  HighLevelBuilderOpcodes = {
-    Label: 1e3,
-    StartLabels: 1001,
-    StopLabels: 1002,
-    Start: 1e3,
-    End: 1002
-  },
-  HighLevelOperands = {
-    Label: 1,
-    IsStrictMode: 2,
-    DebugSymbols: 3,
-    Block: 4,
-    StdLib: 5,
-    NonSmallInt: 6,
-    SymbolTable: 7,
-    Layout: 8
-  };
 function labelOperand(value) {
   return {
-    type: HighLevelOperands.Label,
+    type: 1,
     value: value
   };
 }
-function isStrictMode() {
-  return {
-    type: HighLevelOperands.IsStrictMode,
-    value: void 0
-  };
-}
 function stdlibOperand(value) {
   return {
-    type: HighLevelOperands.StdLib,
+    type: 5,
     value: value
   };
 }
 function symbolTableOperand(value) {
   return {
-    type: HighLevelOperands.SymbolTable,
+    type: 7,
     value: value
   };
 }
 function layoutOperand(value) {
   return {
-    type: HighLevelOperands.Layout,
+    type: 8,
     value: value
   };
 }
 class Labels {
-  labels = dict();
-  targets = [];
   label(name, index) {
     this.labels[name] = index;
   }
@@ -122,44 +131,62 @@ class Labels {
       at: at,
       target: target
     } of targets) {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
       let address = labels[target] - at;
-      debugAssert(-1 === heap.getbyaddr(at), "Expected heap to contain a placeholder, but it did not"), heap.setbyaddr(at, address);
+      heap.getbyaddr(at), heap.setbyaddr(at, address);
     }
   }
+  constructor() {
+    this.labels = dict(), this.targets = [];
+  }
 }
-function encodeOp(encoder, constants, resolver, meta, op) {
+function encodeOp(encoder, context, meta, op) {
+  let {
+    program: {
+      constants: constants
+    },
+    resolver: resolver
+  } = context;
   if (function (op) {
-    return op < HighLevelBuilderOpcodes.Start;
+    return op < 1e3;
   }(op[0])) {
     let [type, ...operands] = op;
     encoder.push(constants, type, ...operands);
   } else switch (op[0]) {
-    case HighLevelBuilderOpcodes.Label:
+    case 1e3:
       return encoder.label(op[1]);
-    case HighLevelBuilderOpcodes.StartLabels:
+    case 1001:
       return encoder.startLabels();
-    case HighLevelBuilderOpcodes.StopLabels:
+    case 1002:
       return encoder.stopLabels();
-    case HighLevelResolutionOpcodes.Component:
+    case 1004:
       return function (resolver, constants, meta, [, expr, then]) {
-        debugAssert(isGetFreeComponent(expr), "Attempted to resolve a component with incorrect opcode");
+        isGetFreeComponent(expr);
         let type = expr[0];
-        if (isDevelopingApp() && expr[0] === opcodes.GetStrictKeyword) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve a component in a strict mode template, but that value was not in scope: ${meta.upvars[expr[1]] ?? "{unknown variable}"}`);
+        if (isDevelopingApp() && expr[0] === opcodes.GetStrictKeyword) throw meta.isStrictMode, new Error(`Attempted to resolve a component in a strict mode template, but that value was not in scope: ${
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+        meta.symbols.upvars[expr[1]] ?? "{unknown variable}"}`);
         if (type === opcodes.GetLexicalSymbol) {
           let {
               scopeValues: scopeValues,
-              owner: owner
+              owner: owner,
+              symbols: {
+                lexical: lexical
+              }
             } = meta,
-            definition = expect(scopeValues, "BUG: scopeValues must exist if template symbol is used")[expr[1]];
-          then(constants.component(definition, expect(owner, "BUG: expected owner when resolving component definition")));
+            definition = scopeValues[expr[1]];
+          then(constants.component(definition, owner, false, lexical?.at(expr[1])));
         } else {
           let {
-              upvars: upvars,
+              symbols: {
+                upvars: upvars
+              },
               owner: owner
             } = assertResolverInvariants(meta),
-            name = unwrap(upvars[expr[1]]),
-            definition = resolver.lookupComponent(name, owner);
-          if (isDevelopingApp() && ("object" != typeof definition || null === definition)) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
+            name = upvars[expr[1]],
+            definition = resolver?.lookupComponent?.(name, owner) ?? null;
+          if (isDevelopingApp() && ("object" != typeof definition || null === definition)) throw meta.isStrictMode, new Error(`Attempted to resolve \`${name}\`, which was expected to be a component, but nothing was found.`);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
           then(constants.resolvedComponent(definition, name));
         }
       }
@@ -167,92 +194,112 @@ function encodeOp(encoder, constants, resolver, meta, op) {
       * (helper)
       * (helper arg)
       */(resolver, constants, meta, op);
-    case HighLevelResolutionOpcodes.Modifier:
+    case 1003:
       /**
       * <div {{modifier}}/>
       * <div {{modifier arg}}/>
       * <Foo {{modifier}}/>
       */
       return function (resolver, constants, meta, [, expr, then]) {
-        debugAssert(isGetFreeModifier(expr), "Attempted to resolve a modifier with incorrect opcode");
+        isGetFreeModifier(expr);
         let type = expr[0];
         if (type === opcodes.GetLexicalSymbol) {
           let {
-              scopeValues: scopeValues
+              scopeValues: scopeValues,
+              symbols: {
+                lexical: lexical
+              }
             } = meta,
-            definition = expect(scopeValues, "BUG: scopeValues must exist if template symbol is used")[expr[1]];
-          then(constants.modifier(definition));
+            definition = scopeValues[expr[1]];
+          then(constants.modifier(definition, lexical?.at(expr[1]) ?? void 0));
         } else if (type === opcodes.GetStrictKeyword) {
           let {
-              upvars: upvars
+              symbols: {
+                upvars: upvars
+              }
             } = assertResolverInvariants(meta),
-            name = unwrap(upvars[expr[1]]),
-            modifier = resolver.lookupBuiltInModifier(name);
-          if (isDevelopingApp() && null === modifier) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve a modifier in a strict mode template, but it was not in scope: ${name}`);
+            name = upvars[expr[1]],
+            modifier = resolver?.lookupBuiltInModifier?.(name) ?? null;
+          if (isDevelopingApp() && null === modifier) throw meta.isStrictMode, new Error(`Attempted to resolve a modifier in a strict mode template, but it was not in scope: ${name}`);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
           then(constants.modifier(modifier, name));
         } else {
           let {
-              upvars: upvars,
+              symbols: {
+                upvars: upvars
+              },
               owner: owner
             } = assertResolverInvariants(meta),
-            name = unwrap(upvars[expr[1]]),
-            modifier = resolver.lookupModifier(name, owner);
-          if (isDevelopingApp() && null === modifier) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve \`${name}\`, which was expected to be a modifier, but nothing was found.`);
-          then(constants.modifier(modifier, name));
+            name = upvars[expr[1]],
+            modifier = resolver?.lookupModifier?.(name, owner) ?? null;
+          if (isDevelopingApp() && null === modifier) throw meta.isStrictMode, new Error(`Attempted to resolve \`${name}\`, which was expected to be a modifier, but nothing was found.`);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+          then(constants.modifier(modifier));
         }
       }
       /**
       * {{component-or-helper arg}}
       */(resolver, constants, meta, op);
-    case HighLevelResolutionOpcodes.Helper:
+    case 1005:
       return function (resolver, constants, meta, [, expr, then]) {
-        debugAssert(isGetFreeHelper(expr), "Attempted to resolve a helper with incorrect opcode");
+        isGetFreeHelper(expr);
         let type = expr[0];
         if (type === opcodes.GetLexicalSymbol) {
           let {
               scopeValues: scopeValues
             } = meta,
-            definition = expect(scopeValues, "BUG: scopeValues must exist if template symbol is used")[expr[1]];
+            definition = scopeValues[expr[1]];
           then(constants.helper(definition));
         } else if (type === opcodes.GetStrictKeyword) then(lookupBuiltInHelper(expr, resolver, meta, constants, "helper"));else {
           let {
-              upvars: upvars,
+              symbols: {
+                upvars: upvars
+              },
               owner: owner
             } = assertResolverInvariants(meta),
-            name = unwrap(upvars[expr[1]]),
-            helper = resolver.lookupHelper(name, owner);
-          if (isDevelopingApp() && null === helper) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve \`${name}\`, which was expected to be a helper, but nothing was found.`);
+            name = upvars[expr[1]],
+            helper = resolver?.lookupHelper?.(name, owner) ?? null;
+          if (isDevelopingApp() && null === helper) throw meta.isStrictMode, new Error(`Attempted to resolve \`${name}\`, which was expected to be a helper, but nothing was found.`);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
           then(constants.helper(helper, name));
         }
       }(resolver, constants, meta, op);
-    case HighLevelResolutionOpcodes.ComponentOrHelper:
+    case 1007:
       return function (resolver, constants, meta, [, expr, {
         ifComponent: ifComponent,
         ifHelper: ifHelper
       }]) {
-        debugAssert(isGetFreeComponentOrHelper(expr), "Attempted to resolve a component or helper with incorrect opcode");
+        isGetFreeComponentOrHelper(expr);
         let type = expr[0];
         if (type === opcodes.GetLexicalSymbol) {
           let {
               scopeValues: scopeValues,
-              owner: owner
+              owner: owner,
+              symbols: {
+                lexical: lexical
+              }
             } = meta,
-            definition = expect(scopeValues, "BUG: scopeValues must exist if template symbol is used")[expr[1]],
-            component = constants.component(definition, expect(owner, "BUG: expected owner when resolving component definition"), !0);
+            definition = scopeValues[expr[1]],
+            component = constants.component(definition, owner, true, lexical?.at(expr[1]));
           if (null !== component) return void ifComponent(component);
-          let helper = constants.helper(definition, null, !0);
-          if (isDevelopingApp() && null === helper) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to use a value as either a component or helper, but it did not have a component manager or helper manager associated with it. The value was: ${debugToString$1(definition)}`);
-          ifHelper(expect(helper, "BUG: helper must exist"));
+          let helper = constants.helper(definition, null, true);
+          if (isDevelopingApp() && null === helper) throw meta.isStrictMode, new Error(
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+          `Attempted to use a value as either a component or helper, but it did not have a component manager or helper manager associated with it. The value was: ${debugToString$1(definition)}`);
+          ifHelper(helper);
         } else if (type === opcodes.GetStrictKeyword) ifHelper(lookupBuiltInHelper(expr, resolver, meta, constants, "component or helper"));else {
           let {
-              upvars: upvars,
+              symbols: {
+                upvars: upvars
+              },
               owner: owner
             } = assertResolverInvariants(meta),
-            name = unwrap(upvars[expr[1]]),
-            definition = resolver.lookupComponent(name, owner);
+            name = upvars[expr[1]],
+            definition = resolver?.lookupComponent?.(name, owner) ?? null;
           if (null !== definition) ifComponent(constants.resolvedComponent(definition, name));else {
-            let helper = resolver.lookupHelper(name, owner);
-            if (isDevelopingApp() && null === helper) throw debugAssert(!meta.isStrictMode, "Strict mode errors should already be handled at compile time"), new Error(`Attempted to resolve \`${name}\`, which was expected to be a component or helper, but nothing was found.`);
+            let helper = resolver?.lookupHelper?.(name, owner) ?? null;
+            if (isDevelopingApp() && null === helper) throw meta.isStrictMode, new Error(`Attempted to resolve \`${name}\`, which was expected to be a component or helper, but nothing was found.`);
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
             ifHelper(constants.helper(helper, name));
           }
         }
@@ -260,51 +307,56 @@ function encodeOp(encoder, constants, resolver, meta, op) {
       /**
       * {{maybeHelperOrComponent}}
       */(resolver, constants, meta, op);
-    case HighLevelResolutionOpcodes.OptionalComponentOrHelper:
+    case 1008:
       return function (resolver, constants, meta, [, expr, {
         ifComponent: ifComponent,
         ifHelper: ifHelper,
         ifValue: ifValue
       }]) {
-        debugAssert(isGetFreeComponentOrHelper(expr), "Attempted to resolve an optional component or helper with incorrect opcode");
+        isGetFreeComponentOrHelper(expr);
         let type = expr[0];
         if (type === opcodes.GetLexicalSymbol) {
           let {
               scopeValues: scopeValues,
-              owner: owner
+              owner: owner,
+              symbols: {
+                lexical: lexical
+              }
             } = meta,
-            definition = expect(scopeValues, "BUG: scopeValues must exist if template symbol is used")[expr[1]];
+            definition = scopeValues[expr[1]];
           if ("function" != typeof definition && ("object" != typeof definition || null === definition))
             // The value is not an object, so it can't be a component or helper.
             return void ifValue(constants.value(definition));
-          let component = constants.component(definition, expect(owner, "BUG: expected owner when resolving component definition"), !0);
+          let component = constants.component(definition, owner, true, lexical?.at(expr[1]));
           if (null !== component) return void ifComponent(component);
-          let helper = constants.helper(definition, null, !0);
+          let helper = constants.helper(definition, null, true);
           if (null !== helper) return void ifHelper(helper);
           ifValue(constants.value(definition));
         } else if (type === opcodes.GetStrictKeyword) ifHelper(lookupBuiltInHelper(expr, resolver, meta, constants, "value"));else {
           let {
-              upvars: upvars,
+              symbols: {
+                upvars: upvars
+              },
               owner: owner
             } = assertResolverInvariants(meta),
-            name = unwrap(upvars[expr[1]]),
-            definition = resolver.lookupComponent(name, owner);
+            name = upvars[expr[1]],
+            definition = resolver?.lookupComponent?.(name, owner) ?? null;
           if (null !== definition) return void ifComponent(constants.resolvedComponent(definition, name));
-          let helper = resolver.lookupHelper(name, owner);
+          let helper = resolver?.lookupHelper?.(name, owner) ?? null;
           null !== helper && ifHelper(constants.helper(helper, name));
         }
       }(resolver, constants, meta, op);
-    case HighLevelResolutionOpcodes.Local:
+    case 1010:
       {
-        let freeVar = op[1],
-          name = expect(meta.upvars, "BUG: attempted to resolve value but no upvars found")[freeVar];
-        (0, op[2])(name, meta.moduleName);
+        let [, freeVar, andThen] = op;
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
+        andThen(meta.symbols.upvars[freeVar], meta.moduleName);
         break;
       }
-    case HighLevelResolutionOpcodes.TemplateLocal:
+    case 1011:
       {
         let [, valueIndex, then] = op,
-          value = expect(meta.scopeValues, "BUG: Attempted to get a template local, but template does not have any")[valueIndex];
+          value = meta.scopeValues[valueIndex];
         then(constants.value(value));
         break;
       }
@@ -313,29 +365,27 @@ function encodeOp(encoder, constants, resolver, meta, op) {
   }
 }
 class EncoderImpl {
-  labelsStack = new StackImpl();
-  encoder = new InstructionEncoderImpl([]);
-  errors = [];
-  handle;
   constructor(heap, meta, stdlib) {
-    this.heap = heap, this.meta = meta, this.stdlib = stdlib, this.handle = heap.malloc();
+    this.heap = heap, this.meta = meta, this.stdlib = stdlib, this.labelsStack = new StackImpl(), this.encoder = new InstructionEncoderImpl([]), this.errors = [], this.handle = heap.malloc();
   }
   error(error) {
-    this.encoder.encode(Op.Primitive, 0), this.errors.push(error);
+    this.encoder.encode(30, 0), this.errors.push(error);
   }
   commit(size) {
     let handle = this.handle;
-    return this.heap.pushMachine(MachineOp.Return), this.heap.finishMalloc(handle, size), isPresentArray(this.errors) ? {
+    return this.heap.pushMachine(5), this.heap.finishMalloc(handle, size), (list = this.errors) && list.length > 0 ? {
       errors: this.errors,
       handle: handle
     } : handle;
+    var list;
   }
   push(constants, type, ...args) {
     let {
       heap: heap
     } = this;
     if (isDevelopingApp() && type > TYPE_SIZE) throw new Error(`Opcode type over 8-bits. Got ${type}.`);
-    let first = type | (isMachineOp(type) ? MACHINE_MASK : 0) | args.length << ARG_SHIFT;
+    var value;
+    let first = type | ((value = type) >= 0 && value <= 15 ? MACHINE_MASK : 0) | args.length << ARG_SHIFT;
     heap.pushRaw(first);
     for (let i = 0; i < args.length; i++) {
       let op = args[i];
@@ -345,31 +395,30 @@ class EncoderImpl {
   operand(constants, operand) {
     if ("number" == typeof operand) return operand;
     if ("object" == typeof operand && null !== operand) {
-      if (Array.isArray(operand)) return encodeHandle(constants.array(operand));
+      if (Array.isArray(operand)) return constants.array(operand);
       switch (operand.type) {
-        case HighLevelOperands.Label:
+        case 1:
           return this.currentLabels.target(this.heap.offset, operand.value), -1;
-        case HighLevelOperands.IsStrictMode:
-          return encodeHandle(constants.value(this.meta.isStrictMode));
-        case HighLevelOperands.DebugSymbols:
-          return encodeHandle(constants.array(this.meta.evalSymbols || EMPTY_STRING_ARRAY));
-        case HighLevelOperands.Block:
-          return encodeHandle(constants.value((block = operand.value, containing = this.meta, new CompilableTemplateImpl(block[0], containing, {
-            parameters: block[1] || EMPTY_ARRAY
-          }))));
-        case HighLevelOperands.StdLib:
-          return expect(this.stdlib, "attempted to encode a stdlib operand, but the encoder did not have a stdlib. Are you currently building the stdlib?")[operand.value];
-        case HighLevelOperands.NonSmallInt:
-        case HighLevelOperands.SymbolTable:
-        case HighLevelOperands.Layout:
+        case 2:
+          return constants.value(this.meta.isStrictMode);
+        case 3:
+        case 6:
+        case 7:
+        case 8:
           return constants.value(operand.value);
+        case 4:
+          return constants.value((block = operand.value, containing = this.meta, new CompilableTemplateImpl(block[0], containing, {
+            parameters: block[1] || EMPTY_ARRAY
+          })));
+        case 5:
+          return this.stdlib[operand.value];
       }
     }
     var block, containing;
-    return encodeHandle(constants.value(operand));
+    return constants.value(operand);
   }
   get currentLabels() {
-    return expect(this.labelsStack.current, "bug: not in a label stack");
+    return this.labelsStack.current;
   }
   label(name) {
     this.currentLabels.label(name, this.heap.offset + 1);
@@ -378,64 +427,38 @@ class EncoderImpl {
     this.labelsStack.push(new Labels());
   }
   stopLabels() {
-    expect(this.labelsStack.pop(), "unbalanced push and pop labels").patch(this.heap);
+    this.labelsStack.pop().patch(this.heap);
   }
 }
-class StdLib {
-  constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {
-    this.main = main, this.trustingGuardedAppend = trustingGuardedAppend, this.cautiousGuardedAppend = cautiousGuardedAppend, this.trustingNonDynamicAppend = trustingNonDynamicAppend, this.cautiousNonDynamicAppend = cautiousNonDynamicAppend;
-  }
-  get "trusting-append"() {
-    return this.trustingGuardedAppend;
-  }
-  get "cautious-append"() {
-    return this.cautiousGuardedAppend;
-  }
-  get "trusting-non-dynamic-append"() {
-    return this.trustingNonDynamicAppend;
-  }
-  get "cautious-non-dynamic-append"() {
-    return this.cautiousNonDynamicAppend;
-  }
-  getAppend(trusting) {
-    return trusting ? this.trustingGuardedAppend : this.cautiousGuardedAppend;
-  }
+function templateCompilationContext(evaluation, meta) {
+  return {
+    evaluation: evaluation,
+    encoder: new EncoderImpl(evaluation.program.heap, meta, evaluation.stdlib),
+    meta: meta
+  };
 }
-class NamedBlocksImpl {
-  names;
-  constructor(blocks) {
-    this.blocks = blocks, this.names = blocks ? Object.keys(blocks) : [];
-  }
-  get(name) {
-    return this.blocks && this.blocks[name] || null;
-  }
-  has(name) {
-    let {
-      blocks: blocks
-    } = this;
-    return null !== blocks && name in blocks;
+class Compilers {
+  add(name, func) {
+    this.names[name] = this.funcs.push(func) - 1;
   }
-  with(name, block) {
-    let {
-      blocks: blocks
-    } = this;
-    return new NamedBlocksImpl(blocks ? assign({}, blocks, {
-      [name]: block
-    }) : {
-      [name]: block
-    });
+  compile(op, sexp) {
+    let name = sexp[0],
+      index = this.names[name],
+      func = this.funcs[index];
+    sexp[0], func(op, sexp);
   }
-  get hasAny() {
-    return null !== this.blocks;
+  constructor() {
+    this.names = {},
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    this.funcs = [];
   }
 }
-const EMPTY_BLOCKS = new NamedBlocksImpl(null);
-function namedBlocks(blocks) {
-  if (null === blocks) return EMPTY_BLOCKS;
-  let out = dict(),
-    [keys, values] = blocks;
-  for (const [i, key] of enumerate(keys)) out[key] = unwrap(values[i]);
-  return new NamedBlocksImpl(out);
+const EXPRESSIONS = new Compilers();
+function withPath(op, path) {
+  if (void 0 !== path && 0 !== path.length) for (let i = 0; i < path.length; i++) op(22, path[i]);
+}
+function expr(op, expression) {
+  Array.isArray(expression) ? EXPRESSIONS.compile(op, expression) : (PushPrimitive(op, expression), op(31));
 }
 
 /**
@@ -443,7 +466,7 @@ function namedBlocks(blocks) {
  * @param value A JavaScript primitive (undefined, null, boolean, number or string)
  */
 function PushPrimitiveReference(op, value) {
-  PushPrimitive(op, value), op(Op.PrimitiveReference);
+  PushPrimitive(op, value), op(31);
 }
 
 /**
@@ -454,10 +477,12 @@ function PushPrimitiveReference(op, value) {
 function PushPrimitive(op, primitive) {
   let p = primitive;
   var value;
-  "number" == typeof p && (p = isSmallInt(p) ? encodeImmediate(p) : (debugAssert(!isSmallInt(value = p), "Attempted to make a operand for an int that was not a small int, you should encode this as an immediate"), {
-    type: HighLevelOperands.NonSmallInt,
-    value: value
-  })), op(Op.Primitive, p);
+  "number" == typeof p && (p = (value = p) % 1 == 0 && value <= 536870911 && value >= -536870912 ? encodeImmediate(p) : function (value) {
+    return {
+      type: 6,
+      value: value
+    };
+  }(p)), op(30, p);
 }
 
 /**
@@ -469,7 +494,7 @@ function PushPrimitive(op, primitive) {
  * @param named An optional list of named arguments (name + expression) to compile
  */
 function Call(op, handle, positional, named) {
-  op(MachineOp.PushFrame), SimpleArgs(op, positional, named, !1), op(Op.Helper, handle), op(MachineOp.PopFrame), op(Op.Fetch, $v0);
+  op(0), SimpleArgs(op, positional, named, false), op(16, handle), op(1), op(36, $v0);
 }
 
 /**
@@ -480,7 +505,7 @@ function Call(op, handle, positional, named) {
  * @param named An optional list of named arguments (name + expression) to compile
  */
 function CallDynamic(op, positional, named, append) {
-  op(MachineOp.PushFrame), SimpleArgs(op, positional, named, !1), op(Op.Dup, $fp, 1), op(Op.DynamicHelper), append ? (op(Op.Fetch, $v0), append(), op(MachineOp.PopFrame), op(Op.Pop, 1)) : (op(MachineOp.PopFrame), op(Op.Pop, 1), op(Op.Fetch, $v0));
+  op(0), SimpleArgs(op, positional, named, false), op(33, $fp, 1), op(107), append ? (op(36, $v0), append(), op(1), op(34, 1)) : (op(1), op(34, 1), op(36, $v0));
 }
 
 /**
@@ -492,79 +517,10 @@ function CallDynamic(op, positional, named, append) {
  * @param block a function that returns a list of statements to evaluate
  */
 function Curry(op, type, definition, positional, named) {
-  op(MachineOp.PushFrame), SimpleArgs(op, positional, named, !1), op(Op.CaptureArgs), expr(op, definition), op(Op.Curry, type, isStrictMode()), op(MachineOp.PopFrame), op(Op.Fetch, $v0);
-}
-class Compilers {
-  names = {};
-  funcs = [];
-  add(name, func) {
-    this.names[name] = this.funcs.push(func) - 1;
-  }
-  compile(op, sexp) {
-    let name = sexp[0],
-      index = unwrap(this.names[name]),
-      func = this.funcs[index];
-    debugAssert(!!func, `expected an implementation for ${sexp[0]}`), func(op, sexp);
-  }
-}
-const EXPRESSIONS = new Compilers();
-function withPath(op, path) {
-  if (void 0 !== path && 0 !== path.length) for (let i = 0; i < path.length; i++) op(Op.GetProperty, path[i]);
-}
-function expr(op, expression) {
-  Array.isArray(expression) ? EXPRESSIONS.compile(op, expression) : (PushPrimitive(op, expression), op(Op.PrimitiveReference));
-}
-
-/**
- * Compile arguments, pushing an Arguments object onto the stack.
- *
- * @param args.params
- * @param args.hash
- * @param args.blocks
- * @param args.atNames
- */
-function SimpleArgs(op, positional, named, atNames) {
-  if (null === positional && null === named) return void op(Op.PushEmptyArgs);
-  let flags = CompilePositional(op, positional) << 4;
-  atNames && (flags |= 8);
-  let names = EMPTY_STRING_ARRAY;
-  if (named) {
-    names = named[0];
-    let val = named[1];
-    for (let i = 0; i < val.length; i++) expr(op, val[i]);
-  }
-  op(Op.PushArgs, names, EMPTY_STRING_ARRAY, flags);
-}
-
-/**
- * Compile an optional list of positional arguments, which pushes each argument
- * onto the stack and returns the number of parameters compiled
- *
- * @param positional an optional list of positional arguments
- */
-function CompilePositional(op, positional) {
-  if (null === positional) return 0;
-  for (let i = 0; i < positional.length; i++) expr(op, positional[i]);
-  return positional.length;
-}
-function meta(layout) {
-  let [, symbols,, upvars] = layout.block;
-  return {
-    evalSymbols: evalSymbols(layout),
-    upvars: upvars,
-    scopeValues: layout.scope?.() ?? null,
-    isStrictMode: layout.isStrictMode,
-    moduleName: layout.moduleName,
-    owner: layout.owner,
-    size: symbols.length
-  };
-}
-function evalSymbols(layout) {
-  let {
-      block: block
-    } = layout,
-    [, symbols, hasEval] = block;
-  return hasEval ? symbols : null;
+  op(0), SimpleArgs(op, positional, named, false), op(86), expr(op, definition), op(77, type, {
+    type: 2,
+    value: void 0
+  }), op(1), op(36, $v0);
 }
 
 /**
@@ -574,7 +530,7 @@ function evalSymbols(layout) {
  * @param params optional block parameters to yield to the block
  */
 function YieldBlock(op, to, positional) {
-  SimpleArgs(op, positional, null, !0), op(Op.GetBlock, to), op(Op.SpreadBlock), op(Op.CompileBlock), op(Op.InvokeYield), op(Op.PopScope), op(MachineOp.PopFrame);
+  SimpleArgs(op, positional, null, true), op(23, to), op(24), op(61), op(64), op(40), op(1);
 }
 
 /**
@@ -585,10 +541,10 @@ function YieldBlock(op, to, positional) {
  */
 function PushYieldableBlock(op, block) {
   !function (op, parameters) {
-    null !== parameters ? op(Op.PushSymbolTable, symbolTableOperand({
+    null !== parameters ? op(63, symbolTableOperand({
       parameters: parameters
     })) : PushPrimitive(op, null);
-  }(op, block && block[1]), op(Op.PushBlockScope), PushCompilable(op, block);
+  }(op, block && block[1]), op(62), PushCompilable(op, block);
 }
 
 /**
@@ -597,7 +553,7 @@ function PushYieldableBlock(op, block) {
  * @param block a Compilable block
  */
 function InvokeStaticBlock(op, block) {
-  op(MachineOp.PushFrame), PushCompilable(op, block), op(Op.CompileBlock), op(MachineOp.InvokeVirtual), op(MachineOp.PopFrame);
+  op(0), PushCompilable(op, block), op(61), op(2), op(1);
 }
 
 /**
@@ -612,19 +568,142 @@ function InvokeStaticBlockWithStack(op, block, callerCount) {
     calleeCount = parameters.length,
     count = Math.min(callerCount, calleeCount);
   if (0 !== count) {
-    if (op(MachineOp.PushFrame), count) {
-      op(Op.ChildScope);
-      for (let i = 0; i < count; i++) op(Op.Dup, $fp, callerCount - i), op(Op.SetVariable, parameters[i]);
+    if (op(0), count) {
+      op(39);
+      for (let i = 0; i < count; i++) op(33, $fp, callerCount - i), op(19, parameters[i]);
     }
-    PushCompilable(op, block), op(Op.CompileBlock), op(MachineOp.InvokeVirtual), count && op(Op.PopScope), op(MachineOp.PopFrame);
+    PushCompilable(op, block), op(61), op(2), count && op(40), op(1);
   } else InvokeStaticBlock(op, block);
 }
 function PushCompilable(op, _block) {
-  var value;
-  null === _block ? PushPrimitive(op, null) : op(Op.Constant, (value = _block, {
-    type: HighLevelOperands.Block,
-    value: value
-  }));
+  null === _block ? PushPrimitive(op, null) : op(28, {
+    type: 4,
+    value: _block
+  });
+}
+
+/**
+ * Compile arguments, pushing an Arguments object onto the stack.
+ *
+ * @param args.params
+ * @param args.hash
+ * @param args.blocks
+ * @param args.atNames
+ */
+function SimpleArgs(op, positional, named, atNames) {
+  if (null === positional && null === named) return void op(83);
+  let flags = CompilePositional(op, positional) << 4;
+  atNames && (flags |= 8);
+  let names = EMPTY_STRING_ARRAY;
+  if (named) {
+    names = named[0];
+    let val = named[1];
+    for (let i = 0; i < val.length; i++) expr(op, val[i]);
+  }
+  op(82, names, EMPTY_STRING_ARRAY, flags);
+}
+
+/**
+ * Compile an optional list of positional arguments, which pushes each argument
+ * onto the stack and returns the number of parameters compiled
+ *
+ * @param positional an optional list of positional arguments
+ */
+function CompilePositional(op, positional) {
+  if (null === positional) return 0;
+  for (let i = 0; i < positional.length; i++) expr(op, positional[i]);
+  return positional.length;
+}
+function meta(layout) {
+  let [, locals, upvars, lexicalSymbols] = layout.block;
+  return {
+    symbols: {
+      locals: locals,
+      upvars: upvars,
+      lexical: lexicalSymbols
+    },
+    scopeValues: layout.scope?.() ?? null,
+    isStrictMode: layout.isStrictMode,
+    moduleName: layout.moduleName,
+    owner: layout.owner,
+    size: locals.length
+  };
+}
+EXPRESSIONS.add(opcodes.Concat, (op, [, parts]) => {
+  for (let part of parts) expr(op, part);
+  op(27, parts.length);
+}), EXPRESSIONS.add(opcodes.Call, (op, [, expression, positional, named]) => {
+  isGetFreeHelper(expression) ? op(1005, expression, handle => {
+    Call(op, handle, positional, named);
+  }) : (expr(op, expression), CallDynamic(op, positional, named));
+}), EXPRESSIONS.add(opcodes.Curry, (op, [, expr, type, positional, named]) => {
+  Curry(op, type, expr, positional, named);
+}), EXPRESSIONS.add(opcodes.GetSymbol, (op, [, sym, path]) => {
+  op(21, sym), withPath(op, path);
+}), EXPRESSIONS.add(opcodes.GetLexicalSymbol, (op, [, sym, path]) => {
+  op(1011, sym, handle => {
+    op(29, handle), withPath(op, path);
+  });
+}), EXPRESSIONS.add(opcodes.GetStrictKeyword, (op, expr) => {
+  op(1010, expr[1], () => {
+    op(1005, expr, handle => {
+      Call(op, handle, null, null);
+    });
+  });
+}), EXPRESSIONS.add(opcodes.GetFreeAsHelperHead, (op, expr) => {
+  op(1010, expr[1], () => {
+    op(1005, expr, handle => {
+      Call(op, handle, null, null);
+    });
+  });
+}), EXPRESSIONS.add(opcodes.Undefined, op => PushPrimitiveReference(op, void 0)), EXPRESSIONS.add(opcodes.HasBlock, (op, [, block]) => {
+  expr(op, block), op(25);
+}), EXPRESSIONS.add(opcodes.HasBlockParams, (op, [, block]) => {
+  expr(op, block), op(24), op(61), op(26);
+}), EXPRESSIONS.add(opcodes.IfInline, (op, [, condition, truthy, falsy]) => {
+  // Push in reverse order
+  expr(op, falsy), expr(op, truthy), expr(op, condition), op(109);
+}), EXPRESSIONS.add(opcodes.Not, (op, [, value]) => {
+  expr(op, value), op(110);
+}), EXPRESSIONS.add(opcodes.GetDynamicVar, (op, [, expression]) => {
+  expr(op, expression), op(111);
+}), EXPRESSIONS.add(opcodes.Log, (op, [, positional]) => {
+  op(0), SimpleArgs(op, positional, null, false), op(112), op(1), op(36, $v0);
+});
+class NamedBlocksImpl {
+  constructor(blocks) {
+    this.blocks = blocks, this.names = blocks ? Object.keys(blocks) : [];
+  }
+  get(name) {
+    return this.blocks && this.blocks[name] || null;
+  }
+  has(name) {
+    let {
+      blocks: blocks
+    } = this;
+    return null !== blocks && name in blocks;
+  }
+  with(name, block) {
+    let {
+      blocks: blocks
+    } = this;
+    return new NamedBlocksImpl(blocks ? assign({}, blocks, {
+      [name]: block
+    }) : {
+      [name]: block
+    });
+  }
+  get hasAny() {
+    return null !== this.blocks;
+  }
+}
+const EMPTY_BLOCKS = new NamedBlocksImpl(null);
+function namedBlocks(blocks) {
+  if (null === blocks) return EMPTY_BLOCKS;
+  let out = dict(),
+    [keys, values] = blocks;
+  for (const [i, key] of enumerate(keys)) out[key] = values[i];
+  return new NamedBlocksImpl(out);
 }
 function SwitchCases(op, bootstrap, matcher) {
   // Setup the switch DSL
@@ -639,20 +718,20 @@ function SwitchCases(op, bootstrap, matcher) {
     });
   }),
   // Emit the opcodes for the switch
-  op(Op.Enter, 1), bootstrap(), op(HighLevelBuilderOpcodes.StartLabels);
+  op(69, 1), bootstrap(), op(1001);
   // First, emit the jump opcodes. We don't need a jump for the last
   // opcode, since it bleeds directly into its clause.
-  for (let clause of clauses.slice(0, -1)) op(Op.JumpEq, labelOperand(clause.label), clause.match);
+  for (let clause of clauses.slice(0, -1)) op(67, labelOperand(clause.label), clause.match);
   // Enumerate the clauses in reverse order. Earlier matches will
   // require fewer checks.
   for (let i = clauses.length - 1; i >= 0; i--) {
-    let clause = unwrap(clauses[i]);
-    op(HighLevelBuilderOpcodes.Label, clause.label), op(Op.Pop, 1), clause.callback(),
+    let clause = clauses[i];
+    op(1e3, clause.label), op(34, 1), clause.callback(),
     // The first match is special: it is placed directly before the END
     // label, so no additional jump is needed at the end of it.
-    0 !== i && op(MachineOp.Jump, labelOperand("END"));
+    0 !== i && op(4, labelOperand("END"));
   }
-  op(HighLevelBuilderOpcodes.Label, "END"), op(HighLevelBuilderOpcodes.StopLabels), op(Op.Exit);
+  op(1e3, "END"), op(1002), op(70);
 }
 
 /**
@@ -719,25 +798,20 @@ function SwitchCases(op, bootstrap, matcher) {
 function Replayable(op, args, body) {
   // Start a new label frame, to give END and RETURN
   // a unique meaning.
-  op(HighLevelBuilderOpcodes.StartLabels), op(MachineOp.PushFrame),
+  op(1001), op(0),
   // If the body invokes a block, its return will return to
   // END. Otherwise, the return in RETURN will return to END.
-  op(MachineOp.ReturnTo, labelOperand("ENDINITIAL"));
-  // Push the arguments onto the stack. The args() function
-  // tells us how many stack elements to retain for re-execution
-  // when updating.
-  let count = args();
+  op(6, labelOperand("ENDINITIAL")),
   // Start a new updating closure, remembering `count` elements
   // from the stack. Everything after this point, and before END,
   // will execute both initially and to update the block.
-
   // The enter and exit opcodes also track the area of the DOM
   // associated with this block. If an assertion inside the block
   // fails (for example, the test value changes from true to false
   // in an #if), the DOM is cleared and the program is re-executed,
   // restoring `count` elements to the stack and executing the
   // instructions between the enter and exit.
-  op(Op.Enter, count),
+  op(69, args()),
   // Evaluate the body of the block. The body of the block may
   // return, which will jump execution to END during initial
   // execution, and exit the updating routine.
@@ -745,16 +819,16 @@ function Replayable(op, args, body) {
   // All execution paths in the body should run the FINALLY once
   // they are done. It is executed both during initial execution
   // and during updating execution.
-  op(HighLevelBuilderOpcodes.Label, "FINALLY"),
+  op(1e3, "FINALLY"),
   // Finalize the DOM.
-  op(Op.Exit),
+  op(70),
   // In initial execution, this is a noop: it returns to the
   // immediately following opcode. In updating execution, this
   // exits the updating routine.
-  op(MachineOp.Return),
+  op(5),
   // Cleanup code for the block. Runs on initial execution
   // but not on updating.
-  op(HighLevelBuilderOpcodes.Label, "ENDINITIAL"), op(MachineOp.PopFrame), op(HighLevelBuilderOpcodes.StopLabels);
+  op(1e3, "ENDINITIAL"), op(1), op(1002);
 }
 
 /**
@@ -775,13 +849,13 @@ function Replayable(op, args, body) {
 function ReplayableIf(op, args, ifTrue, ifFalse) {
   return Replayable(op, args, () => {
     // If the conditional is false, jump to the ELSE label.
-    op(Op.JumpUnless, labelOperand("ELSE")),
+    op(66, labelOperand("ELSE")),
     // Otherwise, execute the code associated with the true branch.
     ifTrue(),
     // We're done, so return. In the initial execution, this runs
     // the cleanup code. In the updating VM, it exits the updating
     // routine.
-    op(MachineOp.Jump, labelOperand("FINALLY")), op(HighLevelBuilderOpcodes.Label, "ELSE"),
+    op(4, labelOperand("FINALLY")), op(1e3, "ELSE"),
     // If the conditional is false, and code associatied ith the
     // false branch was provided, execute it. If there was no code
     // associated with the false branch, jumping to the else statement
@@ -789,10 +863,6 @@ function ReplayableIf(op, args, ifTrue, ifFalse) {
     void 0 !== ifFalse && ifFalse();
   });
 }
-
-// {{component}}
-// <Component>
-// chokepoint
 function InvokeComponent(op, component, _elementBlock, positional, named, _blocks) {
   let {
       compilable: compilable,
@@ -800,8 +870,8 @@ function InvokeComponent(op, component, _elementBlock, positional, named, _block
       handle: handle
     } = component,
     elementBlock = _elementBlock ? [_elementBlock, []] : null,
-    blocks = Array.isArray(_blocks) || null === _blocks ? namedBlocks(_blocks) : _blocks;
-  compilable ? (op(Op.PushComponentDefinition, handle), function (op, {
+    blocks = namedBlocks(_blocks);
+  compilable ? (op(78, handle), function (op, {
     capabilities: capabilities,
     layout: layout,
     elementBlock: elementBlock,
@@ -812,16 +882,16 @@ function InvokeComponent(op, component, _elementBlock, positional, named, _block
     let {
       symbolTable: symbolTable
     } = layout;
-    if (symbolTable.hasEval || hasCapability(capabilities, InternalComponentCapabilities.prepareArgs)) return void InvokeNonStaticComponent(op, {
+    if (hasCapability(capabilities, InternalComponentCapabilities.prepareArgs)) return void InvokeNonStaticComponent(op, {
       capabilities: capabilities,
       elementBlock: elementBlock,
       positional: positional,
       named: named,
-      atNames: !0,
+      atNames: true,
       blocks: blocks,
       layout: layout
     });
-    op(Op.Fetch, $s0), op(Op.Dup, $sp, 1), op(Op.Load, $s0), op(MachineOp.PushFrame);
+    op(36, $s0), op(33, $sp, 1), op(35, $s0), op(0);
     // Setup arguments
     let {
         symbols: symbols
@@ -861,14 +931,14 @@ function InvokeComponent(op, component, _elementBlock, positional, named, _block
         names = named[0];
         let val = named[1];
         for (let i = 0; i < val.length; i++) {
-          let symbol = symbols.indexOf(unwrap(names[i]));
+          let symbol = symbols.indexOf(names[i]);
           expr(op, val[i]), argSymbols.push(symbol);
         }
       }
       // Finally, push the VM arguments themselves. These args won't need access
       // to blocks (they aren't accessible from userland anyways), so we push an
       // empty array instead of the actual block names.
-      op(Op.PushArgs, names, EMPTY_STRING_ARRAY, flags),
+      op(82, names, EMPTY_STRING_ARRAY, flags),
       // And push an extra pop operation to remove the args before we begin setting
       // variables on the local context
       argSymbols.push(-1);
@@ -879,17 +949,19 @@ function InvokeComponent(op, component, _elementBlock, positional, named, _block
       let names = named[0],
         val = named[1];
       for (let i = 0; i < val.length; i++) {
-        let name = unwrap(names[i]),
+        let name = names[i],
           symbol = symbols.indexOf(name);
         -1 !== symbol && (expr(op, val[i]), argSymbols.push(symbol), argNames.push(name));
       }
     }
-    op(Op.BeginComponentTransaction, $s0), hasCapability(capabilities, InternalComponentCapabilities.dynamicScope) && op(Op.PushDynamicScope), hasCapability(capabilities, InternalComponentCapabilities.createInstance) && op(Op.CreateComponent, 0 | blocks.has("default"), $s0), op(Op.RegisterComponentDestructor, $s0), hasCapability(capabilities, InternalComponentCapabilities.createArgs) ? op(Op.GetComponentSelf, $s0) : op(Op.GetComponentSelf, $s0, argNames),
+    op(97, $s0), hasCapability(capabilities, InternalComponentCapabilities.dynamicScope) && op(59), hasCapability(capabilities, InternalComponentCapabilities.createInstance) &&
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    op(87, 0 | blocks.has("default")), op(88, $s0), hasCapability(capabilities, InternalComponentCapabilities.createArgs) ? op(90, $s0) : op(90, $s0, argNames),
     // Setup the new root scope for the component
-    op(Op.RootScope, symbols.length + 1, Object.keys(blocks).length > 0 ? 1 : 0),
+    op(37, symbols.length + 1, Object.keys(blocks).length > 0 ? 1 : 0),
     // Pop the self reference off the stack and set it to the symbol for `this`
     // in the new scope. This is why all subsequent symbols are increased by one.
-    op(Op.SetVariable, 0);
+    op(19, 0);
     // Going in reverse, now we pop the args/blocks off the stack, starting with
     // arguments, and assign them to their symbols in the new scope.
     for (const symbol of reverse(argSymbols))
@@ -898,12 +970,12 @@ function InvokeComponent(op, component, _elementBlock, positional, named, _block
     -1 === symbol ?
     // The expression was not bound to a local symbol, it was only pushed to be
     // used with VM args in the javascript side
-    op(Op.Pop, 1) : op(Op.SetVariable, symbol + 1);
+    op(34, 1) : op(19, symbol + 1);
     // if any positional params exist, pop them off the stack as well
-    null !== positional && op(Op.Pop, positional.length);
+    null !== positional && op(34, positional.length);
     // Finish up by popping off and assigning blocks
-    for (const symbol of reverse(blockSymbols)) op(Op.SetBlock, symbol + 1);
-    op(Op.Constant, layoutOperand(layout)), op(Op.CompileBlock), op(MachineOp.InvokeVirtual), op(Op.DidRenderLayout, $s0), op(MachineOp.PopFrame), op(Op.PopScope), hasCapability(capabilities, InternalComponentCapabilities.dynamicScope) && op(Op.PopDynamicScope), op(Op.CommitComponentTransaction), op(Op.Load, $s0);
+    for (const symbol of reverse(blockSymbols)) op(20, symbol + 1);
+    op(28, layoutOperand(layout)), op(61), op(2), op(100, $s0), op(1), op(40), hasCapability(capabilities, InternalComponentCapabilities.dynamicScope) && op(60), op(98), op(35, $s0);
   }(op, {
     capabilities: capabilities,
     layout: compilable,
@@ -911,27 +983,30 @@ function InvokeComponent(op, component, _elementBlock, positional, named, _block
     positional: positional,
     named: named,
     blocks: blocks
-  })) : (op(Op.PushComponentDefinition, handle), InvokeNonStaticComponent(op, {
+  })) : (op(78, handle), InvokeNonStaticComponent(op, {
     capabilities: capabilities,
     elementBlock: elementBlock,
     positional: positional,
     named: named,
-    atNames: !0,
+    atNames: true,
     blocks: blocks
   }));
 }
 function InvokeDynamicComponent(op, definition, _elementBlock, positional, named, _blocks, atNames, curried) {
   let elementBlock = _elementBlock ? [_elementBlock, []] : null,
-    blocks = Array.isArray(_blocks) || null === _blocks ? namedBlocks(_blocks) : _blocks;
-  Replayable(op, () => (expr(op, definition), op(Op.Dup, $sp, 0), 2), () => {
-    op(Op.JumpUnless, labelOperand("ELSE")), curried ? op(Op.ResolveCurriedComponent) : op(Op.ResolveDynamicComponent, isStrictMode()), op(Op.PushDynamicComponentInstance), InvokeNonStaticComponent(op, {
-      capabilities: !0,
+    blocks = namedBlocks(_blocks);
+  Replayable(op, () => (expr(op, definition), op(33, $sp, 0), 2), () => {
+    op(66, labelOperand("ELSE")), curried ? op(81) : op(80, {
+      type: 2,
+      value: void 0
+    }), op(79), InvokeNonStaticComponent(op, {
+      capabilities: true,
       elementBlock: elementBlock,
       positional: positional,
       named: named,
       atNames: atNames,
       blocks: blocks
-    }), op(HighLevelBuilderOpcodes.Label, "ELSE");
+    }), op(1e3, "ELSE");
   });
 }
 function InvokeNonStaticComponent(op, {
@@ -944,168 +1019,33 @@ function InvokeNonStaticComponent(op, {
   layout: layout
 }) {
   let bindableBlocks = !!namedBlocks,
-    bindableAtNames = !0 === capabilities || hasCapability(capabilities, InternalComponentCapabilities.prepareArgs) || !(!named || 0 === named[0].length),
+    bindableAtNames = true === capabilities || hasCapability(capabilities, InternalComponentCapabilities.prepareArgs) || !(!named || 0 === named[0].length),
     blocks = namedBlocks.with("attrs", elementBlock);
-  op(Op.Fetch, $s0), op(Op.Dup, $sp, 1), op(Op.Load, $s0), op(MachineOp.PushFrame), function (op, positional, named, blocks, atNames) {
+  op(36, $s0), op(33, $sp, 1), op(35, $s0), op(0), function (op, positional, named, blocks, atNames) {
     let blockNames = blocks.names;
     for (const name of blockNames) PushYieldableBlock(op, blocks.get(name));
     let flags = CompilePositional(op, positional) << 4;
-    atNames && (flags |= 8), blocks && (flags |= 7);
+    atNames && (flags |= 8), blocks.hasAny && (flags |= 7);
     let names = EMPTY_ARRAY;
     if (named) {
       names = named[0];
       let val = named[1];
       for (let i = 0; i < val.length; i++) expr(op, val[i]);
     }
-    op(Op.PushArgs, names, blockNames, flags);
-  }(op, positional, named, blocks, atNames), op(Op.PrepareArgs, $s0), invokePreparedComponent(op, blocks.has("default"), bindableBlocks, bindableAtNames, () => {
-    layout ? (op(Op.PushSymbolTable, symbolTableOperand(layout.symbolTable)), op(Op.Constant, layoutOperand(layout)), op(Op.CompileBlock)) : op(Op.GetComponentLayout, $s0), op(Op.PopulateLayout, $s0);
-  }), op(Op.Load, $s0);
+    op(82, names, blockNames, flags);
+  }(op, positional, named, blocks, atNames), op(85, $s0), invokePreparedComponent(op, blocks.has("default"), bindableBlocks, bindableAtNames, () => {
+    layout ? (op(63, symbolTableOperand(layout.symbolTable)), op(28, layoutOperand(layout)), op(61)) : op(92, $s0), op(95, $s0);
+  }), op(35, $s0);
 }
 function invokePreparedComponent(op, hasBlock, bindableBlocks, bindableAtNames, populateLayout = null) {
-  op(Op.BeginComponentTransaction, $s0), op(Op.PushDynamicScope), op(Op.CreateComponent, 0 | hasBlock, $s0),
+  op(97, $s0), op(59),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  op(87, 0 | hasBlock),
   // this has to run after createComponent to allow
   // for late-bound layouts, but a caller is free
   // to populate the layout earlier if it wants to
   // and do nothing here.
-  populateLayout && populateLayout(), op(Op.RegisterComponentDestructor, $s0), op(Op.GetComponentSelf, $s0), op(Op.VirtualRootScope, $s0), op(Op.SetVariable, 0), op(Op.SetupForEval, $s0), bindableAtNames && op(Op.SetNamedVariables, $s0), bindableBlocks && op(Op.SetBlocks, $s0), op(Op.Pop, 1), op(Op.InvokeComponentLayout, $s0), op(Op.DidRenderLayout, $s0), op(MachineOp.PopFrame), op(Op.PopScope), op(Op.PopDynamicScope), op(Op.CommitComponentTransaction);
-}
-
-/**
- * Append content to the DOM. This standard function triages content and does the
- * right thing based upon whether it's a string, safe string, component, fragment
- * or node.
- *
- * @param trusting whether to interpolate a string as raw HTML (corresponds to
- * triple curlies)
- */
-function StdAppend(op, trusting, nonDynamicAppend) {
-  SwitchCases(op, () => op(Op.ContentType), when => {
-    when(ContentType.String, () => {
-      trusting ? (op(Op.AssertSame), op(Op.AppendHTML)) : op(Op.AppendText);
-    }), "number" == typeof nonDynamicAppend ? (when(ContentType.Component, () => {
-      op(Op.ResolveCurriedComponent), op(Op.PushDynamicComponentInstance), function (op) {
-        op(Op.Fetch, $s0), op(Op.Dup, $sp, 1), op(Op.Load, $s0), op(MachineOp.PushFrame), op(Op.PushEmptyArgs), op(Op.PrepareArgs, $s0), invokePreparedComponent(op, !1, !1, !0, () => {
-          op(Op.GetComponentLayout, $s0), op(Op.PopulateLayout, $s0);
-        }), op(Op.Load, $s0);
-      }(op);
-    }), when(ContentType.Helper, () => {
-      CallDynamic(op, null, null, () => {
-        op(MachineOp.InvokeStatic, nonDynamicAppend);
-      });
-    })) : (
-    // when non-dynamic, we can no longer call the value (potentially because we've already called it)
-    // this prevents infinite loops. We instead coerce the value, whatever it is, into the DOM.
-    when(ContentType.Component, () => {
-      op(Op.AppendText);
-    }), when(ContentType.Helper, () => {
-      op(Op.AppendText);
-    })), when(ContentType.SafeString, () => {
-      op(Op.AssertSame), op(Op.AppendSafeHTML);
-    }), when(ContentType.Fragment, () => {
-      op(Op.AssertSame), op(Op.AppendDocumentFragment);
-    }), when(ContentType.Node, () => {
-      op(Op.AssertSame), op(Op.AppendNode);
-    });
-  });
-}
-function compileStd(context) {
-  let mainHandle = build(context, op => function (op) {
-      op(Op.Main, $s0), invokePreparedComponent(op, !1, !1, !0);
-    }(op)),
-    trustingGuardedNonDynamicAppend = build(context, op => StdAppend(op, !0, null)),
-    cautiousGuardedNonDynamicAppend = build(context, op => StdAppend(op, !1, null)),
-    trustingGuardedDynamicAppend = build(context, op => StdAppend(op, !0, trustingGuardedNonDynamicAppend)),
-    cautiousGuardedDynamicAppend = build(context, op => StdAppend(op, !1, cautiousGuardedNonDynamicAppend));
-  return new StdLib(mainHandle, trustingGuardedDynamicAppend, cautiousGuardedDynamicAppend, trustingGuardedNonDynamicAppend, cautiousGuardedNonDynamicAppend);
-}
-EXPRESSIONS.add(opcodes.Concat, (op, [, parts]) => {
-  for (let part of parts) expr(op, part);
-  op(Op.Concat, parts.length);
-}), EXPRESSIONS.add(opcodes.Call, (op, [, expression, positional, named]) => {
-  isGetFreeHelper(expression) ? op(HighLevelResolutionOpcodes.Helper, expression, handle => {
-    Call(op, handle, positional, named);
-  }) : (expr(op, expression), CallDynamic(op, positional, named));
-}), EXPRESSIONS.add(opcodes.Curry, (op, [, expr, type, positional, named]) => {
-  Curry(op, type, expr, positional, named);
-}), EXPRESSIONS.add(opcodes.GetSymbol, (op, [, sym, path]) => {
-  op(Op.GetVariable, sym), withPath(op, path);
-}), EXPRESSIONS.add(opcodes.GetLexicalSymbol, (op, [, sym, path]) => {
-  op(HighLevelResolutionOpcodes.TemplateLocal, sym, handle => {
-    op(Op.ConstantReference, handle), withPath(op, path);
-  });
-}), EXPRESSIONS.add(opcodes.GetStrictKeyword, (op, expr) => {
-  op(HighLevelResolutionOpcodes.Local, expr[1], _name => {
-    op(HighLevelResolutionOpcodes.Helper, expr, handle => {
-      Call(op, handle, null, null);
-    });
-  });
-}), EXPRESSIONS.add(opcodes.GetFreeAsHelperHead, (op, expr) => {
-  op(HighLevelResolutionOpcodes.Local, expr[1], _name => {
-    op(HighLevelResolutionOpcodes.Helper, expr, handle => {
-      Call(op, handle, null, null);
-    });
-  });
-}), EXPRESSIONS.add(opcodes.Undefined, op => PushPrimitiveReference(op, void 0)), EXPRESSIONS.add(opcodes.HasBlock, (op, [, block]) => {
-  expr(op, block), op(Op.HasBlock);
-}), EXPRESSIONS.add(opcodes.HasBlockParams, (op, [, block]) => {
-  expr(op, block), op(Op.SpreadBlock), op(Op.CompileBlock), op(Op.HasBlockParams);
-}), EXPRESSIONS.add(opcodes.IfInline, (op, [, condition, truthy, falsy]) => {
-  // Push in reverse order
-  expr(op, falsy), expr(op, truthy), expr(op, condition), op(Op.IfInline);
-}), EXPRESSIONS.add(opcodes.Not, (op, [, value]) => {
-  expr(op, value), op(Op.Not);
-}), EXPRESSIONS.add(opcodes.GetDynamicVar, (op, [, expression]) => {
-  expr(op, expression), op(Op.GetDynamicVar);
-}), EXPRESSIONS.add(opcodes.Log, (op, [, positional]) => {
-  op(MachineOp.PushFrame), SimpleArgs(op, positional, null, !1), op(Op.Log), op(MachineOp.PopFrame), op(Op.Fetch, $v0);
-});
-const STDLIB_META = {
-  evalSymbols: null,
-  upvars: null,
-  moduleName: "stdlib",
-  // TODO: ??
-  scopeValues: null,
-  isStrictMode: !0,
-  owner: null,
-  size: 0
-};
-function build(program, builder) {
-  let {
-      constants: constants,
-      heap: heap,
-      resolver: resolver
-    } = program,
-    encoder = new EncoderImpl(heap, STDLIB_META);
-  builder(function (...op) {
-    encodeOp(encoder, constants, resolver, STDLIB_META, op);
-  });
-  let result = encoder.commit(0);
-  if ("number" != typeof result)
-    // This shouldn't be possible
-    throw new Error("Unexpected errors compiling std");
-  return result;
-}
-class CompileTimeCompilationContextImpl {
-  constants;
-  heap;
-  stdlib;
-  constructor({
-    constants: constants,
-    heap: heap
-  }, resolver, createOp) {
-    this.resolver = resolver, this.createOp = createOp, this.constants = constants, this.heap = heap, this.stdlib = compileStd(this);
-  }
-}
-function programCompilationContext(artifacts, resolver, createOp) {
-  return new CompileTimeCompilationContextImpl(artifacts, resolver, createOp);
-}
-function templateCompilationContext(program, meta) {
-  return {
-    program: program,
-    encoder: new EncoderImpl(program.heap, meta, program.stdlib),
-    meta: meta
-  };
+  populateLayout && populateLayout(), op(88, $s0), op(90, $s0), op(38, $s0), op(19, 0), bindableAtNames && op(17, $s0), bindableBlocks && op(18, $s0), op(34, 1), op(96, $s0), op(100, $s0), op(1), op(40), op(60), op(98);
 }
 const STATEMENTS = new Compilers(),
   INFLATE_ATTR_TABLE = ["class", "id", "value", "name", "type", "style", "href"],
@@ -1119,118 +1059,125 @@ function inflateAttrName(attrName) {
 function hashToArgs(hash) {
   return null === hash ? null : [hash[0].map(key => `@${key}`), hash[1]];
 }
-STATEMENTS.add(opcodes.Comment, (op, sexp) => op(Op.Comment, sexp[1])), STATEMENTS.add(opcodes.CloseElement, op => op(Op.CloseElement)), STATEMENTS.add(opcodes.FlushElement, op => op(Op.FlushElement)), STATEMENTS.add(opcodes.Modifier, (op, [, expression, positional, named]) => {
-  isGetFreeModifier(expression) ? op(HighLevelResolutionOpcodes.Modifier, expression, handle => {
-    op(MachineOp.PushFrame), SimpleArgs(op, positional, named, !1), op(Op.Modifier, handle), op(MachineOp.PopFrame);
-  }) : (expr(op, expression), op(MachineOp.PushFrame), SimpleArgs(op, positional, named, !1), op(Op.Dup, $fp, 1), op(Op.DynamicModifier), op(MachineOp.PopFrame));
+STATEMENTS.add(opcodes.Comment, (op, sexp) => op(42, sexp[1])), STATEMENTS.add(opcodes.CloseElement, op => op(55)), STATEMENTS.add(opcodes.FlushElement, op => op(54)), STATEMENTS.add(opcodes.Modifier, (op, [, expression, positional, named]) => {
+  isGetFreeModifier(expression) ? op(1003, expression, handle => {
+    op(0), SimpleArgs(op, positional, named, false), op(57, handle), op(1);
+  }) : (expr(op, expression), op(0), SimpleArgs(op, positional, named, false), op(33, $fp, 1), op(108), op(1));
 }), STATEMENTS.add(opcodes.StaticAttr, (op, [, name, value, namespace]) => {
-  op(Op.StaticAttr, inflateAttrName(name), value, namespace ?? null);
+  op(51, inflateAttrName(name), value, namespace ?? null);
 }), STATEMENTS.add(opcodes.StaticComponentAttr, (op, [, name, value, namespace]) => {
-  op(Op.StaticComponentAttr, inflateAttrName(name), value, namespace ?? null);
+  op(105, inflateAttrName(name), value, namespace ?? null);
 }), STATEMENTS.add(opcodes.DynamicAttr, (op, [, name, value, namespace]) => {
-  expr(op, value), op(Op.DynamicAttr, inflateAttrName(name), !1, namespace ?? null);
+  expr(op, value), op(52, inflateAttrName(name), false, namespace ?? null);
 }), STATEMENTS.add(opcodes.TrustingDynamicAttr, (op, [, name, value, namespace]) => {
-  expr(op, value), op(Op.DynamicAttr, inflateAttrName(name), !0, namespace ?? null);
+  expr(op, value), op(52, inflateAttrName(name), true, namespace ?? null);
 }), STATEMENTS.add(opcodes.ComponentAttr, (op, [, name, value, namespace]) => {
-  expr(op, value), op(Op.ComponentAttr, inflateAttrName(name), !1, namespace ?? null);
+  expr(op, value), op(53, inflateAttrName(name), false, namespace ?? null);
 }), STATEMENTS.add(opcodes.TrustingComponentAttr, (op, [, name, value, namespace]) => {
-  expr(op, value), op(Op.ComponentAttr, inflateAttrName(name), !0, namespace ?? null);
+  expr(op, value), op(53, inflateAttrName(name), true, namespace ?? null);
 }), STATEMENTS.add(opcodes.OpenElement, (op, [, tag]) => {
-  op(Op.OpenElement, inflateTagName(tag));
+  op(48, inflateTagName(tag));
 }), STATEMENTS.add(opcodes.OpenElementWithSplat, (op, [, tag]) => {
-  op(Op.PutComponentOperations), op(Op.OpenElement, inflateTagName(tag));
+  op(89), op(48, inflateTagName(tag));
 }), STATEMENTS.add(opcodes.Component, (op, [, expr, elementBlock, named, blocks]) => {
-  isGetFreeComponent(expr) ? op(HighLevelResolutionOpcodes.Component, expr, component => {
+  isGetFreeComponent(expr) ? op(1004, expr, component => {
     InvokeComponent(op, component, elementBlock, null, named, blocks);
   }) :
   // otherwise, the component name was an expression, so resolve the expression
   // and invoke it as a dynamic component
-  InvokeDynamicComponent(op, expr, elementBlock, null, named, blocks, !0, !0);
-}), STATEMENTS.add(opcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, params)), STATEMENTS.add(opcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null)), STATEMENTS.add(opcodes.Debugger, (op, [, debugInfo]) => op(Op.Debugger, {
-  type: HighLevelOperands.DebugSymbols,
-  value: void 0
-}, debugInfo)), STATEMENTS.add(opcodes.Append, (op, [, value]) => {
+  InvokeDynamicComponent(op, expr, elementBlock, null, named, blocks, true, true);
+}), STATEMENTS.add(opcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, params)), STATEMENTS.add(opcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null)), STATEMENTS.add(opcodes.Debugger, (op, [, locals, upvars, lexical]) => {
+  op(103, function (locals, upvars, lexical) {
+    return {
+      type: 3,
+      value: {
+        locals: locals,
+        upvars: upvars,
+        lexical: lexical
+      }
+    };
+  }(locals, upvars, lexical));
+}), STATEMENTS.add(opcodes.Append, (op, [, value]) => {
   // Special case for static values
   if (Array.isArray(value)) {
-    if (isGetFreeComponentOrHelper(value)) op(HighLevelResolutionOpcodes.OptionalComponentOrHelper, value, {
+    if (isGetFreeComponentOrHelper(value)) op(1008, value, {
       ifComponent(component) {
         InvokeComponent(op, component, null, null, null, null);
       },
       ifHelper(handle) {
-        op(MachineOp.PushFrame), Call(op, handle, null, null), op(MachineOp.InvokeStatic, stdlibOperand("cautious-non-dynamic-append")), op(MachineOp.PopFrame);
+        op(0), Call(op, handle, null, null), op(3, stdlibOperand("cautious-non-dynamic-append")), op(1);
       },
       ifValue(handle) {
-        op(MachineOp.PushFrame), op(Op.ConstantReference, handle), op(MachineOp.InvokeStatic, stdlibOperand("cautious-non-dynamic-append")), op(MachineOp.PopFrame);
+        op(0), op(29, handle), op(3, stdlibOperand("cautious-non-dynamic-append")), op(1);
       }
     });else if (value[0] === opcodes.Call) {
       let [, expression, positional, named] = value;
-      isGetFreeComponentOrHelper(expression) ? op(HighLevelResolutionOpcodes.ComponentOrHelper, expression, {
+      isGetFreeComponentOrHelper(expression) ? op(1007, expression, {
         ifComponent(component) {
           InvokeComponent(op, component, null, positional, hashToArgs(named), null);
         },
         ifHelper(handle) {
-          op(MachineOp.PushFrame), Call(op, handle, positional, named), op(MachineOp.InvokeStatic, stdlibOperand("cautious-non-dynamic-append")), op(MachineOp.PopFrame);
+          op(0), Call(op, handle, positional, named), op(3, stdlibOperand("cautious-non-dynamic-append")), op(1);
         }
       }) : SwitchCases(op, () => {
-        expr(op, expression), op(Op.DynamicContentType);
+        expr(op, expression), op(106);
       }, when => {
         when(ContentType.Component, () => {
-          op(Op.ResolveCurriedComponent), op(Op.PushDynamicComponentInstance), InvokeNonStaticComponent(op, {
-            capabilities: !0,
+          op(81), op(79), InvokeNonStaticComponent(op, {
+            capabilities: true,
             elementBlock: null,
             positional: positional,
             named: named,
-            atNames: !1,
+            atNames: false,
             blocks: namedBlocks(null)
           });
         }), when(ContentType.Helper, () => {
           CallDynamic(op, positional, named, () => {
-            op(MachineOp.InvokeStatic, stdlibOperand("cautious-non-dynamic-append"));
+            op(3, stdlibOperand("cautious-non-dynamic-append"));
           });
         });
       });
-    } else op(MachineOp.PushFrame), expr(op, value), op(MachineOp.InvokeStatic, stdlibOperand("cautious-append")), op(MachineOp.PopFrame);
-  } else op(Op.Text, null == value ? "" : String(value));
+    } else op(0), expr(op, value), op(3, stdlibOperand("cautious-append")), op(1);
+  } else op(41, null == value ? "" : String(value));
 }), STATEMENTS.add(opcodes.TrustingAppend, (op, [, value]) => {
-  Array.isArray(value) ? (op(MachineOp.PushFrame), expr(op, value), op(MachineOp.InvokeStatic, stdlibOperand("trusting-append")), op(MachineOp.PopFrame)) : op(Op.Text, null == value ? "" : String(value));
+  Array.isArray(value) ? (op(0), expr(op, value), op(3, stdlibOperand("trusting-append")), op(1)) : op(41, null == value ? "" : String(value));
 }), STATEMENTS.add(opcodes.Block, (op, [, expr, positional, named, blocks]) => {
-  isGetFreeComponent(expr) ? op(HighLevelResolutionOpcodes.Component, expr, component => {
+  isGetFreeComponent(expr) ? op(1004, expr, component => {
     InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
-  }) : InvokeDynamicComponent(op, expr, null, positional, named, blocks, !1, !1);
+  }) : InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
 }), STATEMENTS.add(opcodes.InElement, (op, [, block, guid, destination, insertBefore]) => {
-  ReplayableIf(op, () => (expr(op, guid), void 0 === insertBefore ? PushPrimitiveReference(op, void 0) : expr(op, insertBefore), expr(op, destination), op(Op.Dup, $sp, 0), 4), () => {
-    op(Op.PushRemoteElement), InvokeStaticBlock(op, block), op(Op.PopRemoteElement);
+  ReplayableIf(op, () => (expr(op, guid), void 0 === insertBefore ? PushPrimitiveReference(op, void 0) : expr(op, insertBefore), expr(op, destination), op(33, $sp, 0), 4), () => {
+    op(50), InvokeStaticBlock(op, block), op(56);
   });
-}), STATEMENTS.add(opcodes.If, (op, [, condition, block, inverse]) => ReplayableIf(op, () => (expr(op, condition), op(Op.ToBoolean), 1), () => {
+}), STATEMENTS.add(opcodes.If, (op, [, condition, block, inverse]) => ReplayableIf(op, () => (expr(op, condition), op(71), 1), () => {
   InvokeStaticBlock(op, block);
 }, inverse ? () => {
   InvokeStaticBlock(op, inverse);
 } : void 0)), STATEMENTS.add(opcodes.Each, (op, [, value, key, block, inverse]) => Replayable(op, () => (key ? expr(op, key) : PushPrimitiveReference(op, null), expr(op, value), 2), () => {
-  op(Op.EnterList, labelOperand("BODY"), labelOperand("ELSE")), op(MachineOp.PushFrame), op(Op.Dup, $fp, 1), op(MachineOp.ReturnTo, labelOperand("ITER")), op(HighLevelBuilderOpcodes.Label, "ITER"), op(Op.Iterate, labelOperand("BREAK")), op(HighLevelBuilderOpcodes.Label, "BODY"), InvokeStaticBlockWithStack(op, block, 2), op(Op.Pop, 2), op(MachineOp.Jump, labelOperand("FINALLY")), op(HighLevelBuilderOpcodes.Label, "BREAK"), op(MachineOp.PopFrame), op(Op.ExitList), op(MachineOp.Jump, labelOperand("FINALLY")), op(HighLevelBuilderOpcodes.Label, "ELSE"), inverse && InvokeStaticBlock(op, inverse);
+  op(72, labelOperand("BODY"), labelOperand("ELSE")), op(0), op(33, $fp, 1), op(6, labelOperand("ITER")), op(1e3, "ITER"), op(74, labelOperand("BREAK")), op(1e3, "BODY"), InvokeStaticBlockWithStack(op, block, 2), op(34, 2), op(4, labelOperand("FINALLY")), op(1e3, "BREAK"), op(1), op(73), op(4, labelOperand("FINALLY")), op(1e3, "ELSE"), inverse && InvokeStaticBlock(op, inverse);
 })), STATEMENTS.add(opcodes.Let, (op, [, positional, block]) => {
   InvokeStaticBlockWithStack(op, block, CompilePositional(op, positional));
 }), STATEMENTS.add(opcodes.WithDynamicVars, (op, [, named, block]) => {
   if (named) {
     let [names, expressions] = named;
     CompilePositional(op, expressions), function (op, names, block) {
-      op(Op.PushDynamicScope), op(Op.BindDynamicScope, names), block(), op(Op.PopDynamicScope);
+      op(59), op(58, names), block(), op(60);
     }(op, names, () => {
       InvokeStaticBlock(op, block);
     });
   } else InvokeStaticBlock(op, block);
 }), STATEMENTS.add(opcodes.InvokeComponent, (op, [, expr, positional, named, blocks]) => {
-  isGetFreeComponent(expr) ? op(HighLevelResolutionOpcodes.Component, expr, component => {
+  isGetFreeComponent(expr) ? op(1004, expr, component => {
     InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
-  }) : InvokeDynamicComponent(op, expr, null, positional, named, blocks, !1, !1);
+  }) : InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
 });
 class CompilableTemplateImpl {
-  compiled = null;
   constructor(statements, meta,
   // Part of CompilableTemplate
   symbolTable,
   // Used for debugging
   moduleName = "plain block") {
-    this.statements = statements, this.meta = meta, this.symbolTable = symbolTable, this.moduleName = moduleName;
+    this.statements = statements, this.meta = meta, this.symbolTable = symbolTable, this.moduleName = moduleName, this.compiled = null;
   }
   // Part of CompilableTemplate
   compile(context) {
@@ -1247,10 +1194,9 @@ class CompilableTemplateImpl {
   }
 }
 function compilable(layout, moduleName) {
-  let [statements, symbols, hasEval] = layout.block;
+  let [statements, symbols] = layout.block;
   return new CompilableTemplateImpl(statements, meta(layout), {
-    symbols: symbols,
-    hasEval: hasEval
+    symbols: symbols
   }, moduleName);
 }
 function compileStatements(statements, meta, syntaxContext) {
@@ -1258,64 +1204,157 @@ function compileStatements(statements, meta, syntaxContext) {
     context = templateCompilationContext(syntaxContext, meta),
     {
       encoder: encoder,
-      program: {
-        constants: constants,
-        resolver: resolver
-      }
+      evaluation: evaluation
     } = context;
   function pushOp(...op) {
-    encodeOp(encoder, constants, resolver, meta, op);
+    encodeOp(encoder, evaluation, meta, op);
   }
   for (const statement of statements) sCompiler.compile(pushOp, statement);
   return context.encoder.commit(meta.size);
 }
 const DEFAULT_CAPABILITIES = {
-    dynamicLayout: !0,
-    dynamicTag: !0,
-    prepareArgs: !0,
-    createArgs: !0,
-    attributeHook: !1,
-    elementHook: !1,
-    dynamicScope: !0,
-    createCaller: !1,
-    updateHook: !0,
-    createInstance: !0,
-    wrapped: !1,
-    willDestroy: !1,
-    hasSubOwner: !1
+    dynamicLayout: true,
+    dynamicTag: true,
+    prepareArgs: true,
+    createArgs: true,
+    attributeHook: false,
+    elementHook: false,
+    dynamicScope: true,
+    createCaller: false,
+    updateHook: true,
+    createInstance: true,
+    wrapped: false,
+    willDestroy: false,
+    hasSubOwner: false
   },
   MINIMAL_CAPABILITIES = {
-    dynamicLayout: !1,
-    dynamicTag: !1,
-    prepareArgs: !1,
-    createArgs: !1,
-    attributeHook: !1,
-    elementHook: !1,
-    dynamicScope: !1,
-    createCaller: !1,
-    updateHook: !1,
-    createInstance: !1,
-    wrapped: !1,
-    willDestroy: !1,
-    hasSubOwner: !1
+    dynamicLayout: false,
+    dynamicTag: false,
+    prepareArgs: false,
+    createArgs: false,
+    attributeHook: false,
+    elementHook: false,
+    dynamicScope: false,
+    createCaller: false,
+    updateHook: false,
+    createInstance: false,
+    wrapped: false,
+    willDestroy: false,
+    hasSubOwner: false
   };
+class StdLib {
+  constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {
+    this.main = main, this.trustingGuardedAppend = trustingGuardedAppend, this.cautiousGuardedAppend = cautiousGuardedAppend, this.trustingNonDynamicAppend = trustingNonDynamicAppend, this.cautiousNonDynamicAppend = cautiousNonDynamicAppend;
+  }
+  get "trusting-append"() {
+    return this.trustingGuardedAppend;
+  }
+  get "cautious-append"() {
+    return this.cautiousGuardedAppend;
+  }
+  get "trusting-non-dynamic-append"() {
+    return this.trustingNonDynamicAppend;
+  }
+  get "cautious-non-dynamic-append"() {
+    return this.cautiousNonDynamicAppend;
+  }
+  getAppend(trusting) {
+    return trusting ? this.trustingGuardedAppend : this.cautiousGuardedAppend;
+  }
+}
+
+/**
+ * Append content to the DOM. This standard function triages content and does the
+ * right thing based upon whether it's a string, safe string, component, fragment
+ * or node.
+ *
+ * @param trusting whether to interpolate a string as raw HTML (corresponds to
+ * triple curlies)
+ */
+function StdAppend(op, trusting, nonDynamicAppend) {
+  SwitchCases(op, () => op(76), when => {
+    when(ContentType.String, () => {
+      trusting ? (op(68), op(43)) : op(47);
+    }), "number" == typeof nonDynamicAppend ? (when(ContentType.Component, () => {
+      op(81), op(79), function (op) {
+        op(36, $s0), op(33, $sp, 1), op(35, $s0), op(0), op(83), op(85, $s0), invokePreparedComponent(op, false, false, true, () => {
+          op(92, $s0), op(95, $s0);
+        }), op(35, $s0);
+      }(op);
+    }), when(ContentType.Helper, () => {
+      CallDynamic(op, null, null, () => {
+        op(3, nonDynamicAppend);
+      });
+    })) : (
+    // when non-dynamic, we can no longer call the value (potentially because we've already called it)
+    // this prevents infinite loops. We instead coerce the value, whatever it is, into the DOM.
+    when(ContentType.Component, () => {
+      op(47);
+    }), when(ContentType.Helper, () => {
+      op(47);
+    })), when(ContentType.SafeString, () => {
+      op(68), op(44);
+    }), when(ContentType.Fragment, () => {
+      op(68), op(45);
+    }), when(ContentType.Node, () => {
+      op(68), op(46);
+    });
+  });
+}
+function compileStd(context) {
+  let mainHandle = build(context, op => function (op) {
+      op(75, $s0), invokePreparedComponent(op, false, false, true);
+    }(op)),
+    trustingGuardedNonDynamicAppend = build(context, op => StdAppend(op, true, null)),
+    cautiousGuardedNonDynamicAppend = build(context, op => StdAppend(op, false, null)),
+    trustingGuardedDynamicAppend = build(context, op => StdAppend(op, true, trustingGuardedNonDynamicAppend)),
+    cautiousGuardedDynamicAppend = build(context, op => StdAppend(op, false, cautiousGuardedNonDynamicAppend));
+  return new StdLib(mainHandle, trustingGuardedDynamicAppend, cautiousGuardedDynamicAppend, trustingGuardedNonDynamicAppend, cautiousGuardedNonDynamicAppend);
+}
+const STDLIB_META = {
+  symbols: {
+    locals: null,
+    upvars: null
+  },
+  moduleName: "stdlib",
+  // TODO: ??
+  scopeValues: null,
+  isStrictMode: true,
+  owner: null,
+  size: 0
+};
+function build(evaluation, builder) {
+  let encoder = new EncoderImpl(evaluation.program.heap, STDLIB_META);
+  builder(function (...op) {
+    encodeOp(encoder, evaluation, STDLIB_META, op);
+  });
+  let result = encoder.commit(0);
+  if ("number" != typeof result)
+    // This shouldn't be possible
+    throw new Error("Unexpected errors compiling std");
+  return result;
+}
+class EvaluationContextImpl {
+  constructor({
+    constants: constants,
+    heap: heap
+  }, createOp, runtime) {
+    this.constants = constants, this.heap = heap, this.resolver = runtime.resolver, this.createOp = createOp, this.env = runtime.env, this.program = runtime.program, this.stdlib = compileStd(this);
+  }
+}
 class WrappedBuilder {
-  symbolTable;
-  compiled = null;
-  attrsBlockNumber;
   constructor(layout, moduleName) {
-    this.layout = layout, this.moduleName = moduleName;
+    this.layout = layout, this.moduleName = moduleName, this.compiled = null;
     let {
         block: block
       } = layout,
-      [, symbols, hasEval] = block;
+      [, symbols] = block;
     symbols = symbols.slice();
     // ensure ATTRS_BLOCK is always included (only once) in the list of symbols
     let attrsBlockIndex = symbols.indexOf("&attrs");
     this.attrsBlockNumber = -1 === attrsBlockIndex ? symbols.push("&attrs") : attrsBlockIndex + 1, this.symbolTable = {
-      hasEval: hasEval,
       symbols: symbols
-    };
+    }, this.meta = meta(layout);
   }
   compile(syntax) {
     if (null !== this.compiled) return this.compiled;
@@ -1323,19 +1362,16 @@ class WrappedBuilder {
       context = templateCompilationContext(syntax, m),
       {
         encoder: encoder,
-        program: {
-          constants: constants,
-          resolver: resolver
-        }
+        evaluation: evaluation
       } = context;
     var op, layout, attrsBlockNumber;
     op = function (...op) {
-      encodeOp(encoder, constants, resolver, m, op);
-    }, layout = this.layout, attrsBlockNumber = this.attrsBlockNumber, op(HighLevelBuilderOpcodes.StartLabels), function (op, register, block) {
-      op(Op.Fetch, register), block(), op(Op.Load, register);
+      encodeOp(encoder, evaluation, m, op);
+    }, layout = this.layout, attrsBlockNumber = this.attrsBlockNumber, op(1001), function (op, register, block) {
+      op(36, register), block(), op(35, register);
     }(op, $s1, () => {
-      op(Op.GetComponentTagName, $s0), op(Op.PrimitiveReference), op(Op.Dup, $sp, 0);
-    }), op(Op.JumpUnless, labelOperand("BODY")), op(Op.Fetch, $s1), op(Op.PutComponentOperations), op(Op.OpenDynamicElement), op(Op.DidCreateElement, $s0), YieldBlock(op, attrsBlockNumber, null), op(Op.FlushElement), op(HighLevelBuilderOpcodes.Label, "BODY"), InvokeStaticBlock(op, [layout.block[0], []]), op(Op.Fetch, $s1), op(Op.JumpUnless, labelOperand("END")), op(Op.CloseElement), op(HighLevelBuilderOpcodes.Label, "END"), op(Op.Load, $s1), op(HighLevelBuilderOpcodes.StopLabels);
+      op(91, $s0), op(31), op(33, $sp, 0);
+    }), op(66, labelOperand("BODY")), op(36, $s1), op(89), op(49), op(99, $s0), YieldBlock(op, attrsBlockNumber, null), op(54), op(1e3, "BODY"), InvokeStaticBlock(op, [layout.block[0], []]), op(36, $s1), op(66, labelOperand("END")), op(55), op(1e3, "END"), op(35, $s1), op(1002);
     let handle = context.encoder.commit(m.size);
     return "number" != typeof handle || (this.compiled = handle), handle;
   }
@@ -1346,7 +1382,6 @@ let clientId = 0,
     cacheMiss: 0
   };
 
-// These interfaces are for backwards compatibility, some addons use these intimate APIs
 /**
  * Wraps a template js in a template module to change it into a factory
  * that handles lazy parsing the template and to create per env singletons
@@ -1392,11 +1427,8 @@ function templateFactory({
   }, factory;
 }
 class TemplateImpl {
-  result = "ok";
-  layout = null;
-  wrappedLayout = null;
   constructor(parsedLayout) {
-    this.parsedLayout = parsedLayout;
+    this.parsedLayout = parsedLayout, this.result = "ok", this.layout = null, this.wrappedLayout = null;
   }
   get moduleName() {
     return this.parsedLayout.moduleName;
@@ -1420,4 +1452,4 @@ class TemplateImpl {
   }
 }
 
-export { CompileTimeCompilationContextImpl, DEFAULT_CAPABILITIES, EMPTY_BLOCKS, MINIMAL_CAPABILITIES, StdLib, WrappedBuilder, compilable, compileStatements, compileStd, debugCompiler, InvokeStaticBlock as invokeStaticBlock, InvokeStaticBlockWithStack as invokeStaticBlockWithStack, meta, programCompilationContext, templateCacheCounters, templateCompilationContext, templateFactory };
+export { DEFAULT_CAPABILITIES, EMPTY_BLOCKS, EvaluationContextImpl, MINIMAL_CAPABILITIES, StdLib, WrappedBuilder, compilable, compileStatements, compileStd, debugCompiler, InvokeStaticBlock as invokeStaticBlock, InvokeStaticBlockWithStack as invokeStaticBlockWithStack, meta, templateCacheCounters, templateCompilationContext, templateFactory };