diff --git a/.editorconfig b/.editorconfig
index 44ffe996f1..28ea59ea5c 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -6,6 +6,7 @@ root = true
 
 
 [*]
+max_line_length = 100
 end_of_line = lf
 charset = utf-8
 trim_trailing_whitespace = true
@@ -21,3 +22,4 @@ insert_final_newline = false
 
 [*.{diff,md}]
 trim_trailing_whitespace = false
+max_line_length = 80
diff --git a/.eslintrc.cjs b/.eslintrc.cjs
index a6cde334c0..152a06e108 100644
--- a/.eslintrc.cjs
+++ b/.eslintrc.cjs
@@ -19,32 +19,32 @@ module.exports = {
     '**/fixtures',
     '!**/.eslintrc.cjs',
   ],
-  parser: '@typescript-eslint/parser',
-  parserOptions: {
-    ecmaVersion: 'latest',
-    project: [],
-  },
-  settings: {
-    'import/parsers': {
-      '@typescript-eslint/parser': ['.js', '.cjs', '.mjs', '.mts', '.ts', '.d.ts'],
-    },
-    'import/resolver': {
-      typescript: {},
-    },
-    node: {
-      allowModules: ['@glimmer/debug', '@glimmer/local-debug-flags'],
-      tryExtensions: ['.js', '.ts', '.d.ts', '.json'],
-    },
-  },
-  plugins: [
-    '@typescript-eslint',
-    'prettier',
-    'qunit',
-    'simple-import-sort',
-    'unused-imports',
-    'prettier',
-    'n',
-  ],
+  // parser: '@typescript-eslint/parser',
+  // parserOptions: {
+  //   ecmaVersion: 'latest',
+  //   project: [],
+  // },
+  // settings: {
+  //   'import/parsers': {
+  //     '@typescript-eslint/parser': ['.js', '.cjs', '.mjs', '.mts', '.ts', '.d.ts'],
+  //   },
+  //   'import/resolver': {
+  //     typescript: {},
+  //   },
+  //   node: {
+  //     allowModules: ['@glimmer/debug', '@glimmer/local-debug-flags'],
+  //     tryExtensions: ['.js', '.ts', '.d.ts', '.json'],
+  //   },
+  // },
+  // plugins: [
+  //   '@typescript-eslint',
+  //   'prettier',
+  //   'qunit',
+  //   'simple-import-sort',
+  //   'unused-imports',
+  //   'prettier',
+  //   'n',
+  // ],
 
   rules: {},
   overrides: [
diff --git a/.prettierrc.json b/.prettierrc.json
index d440171380..5626bc6e0d 100644
--- a/.prettierrc.json
+++ b/.prettierrc.json
@@ -1,5 +1,6 @@
 {
   "singleQuote": true,
   "trailingComma": "es5",
-  "printWidth": 100
+  "printWidth": 100,
+  "plugins": []
 }
diff --git a/.vscode/extensions.json b/.vscode/extensions.json
new file mode 100644
index 0000000000..8c164afb17
--- /dev/null
+++ b/.vscode/extensions.json
@@ -0,0 +1,3 @@
+{
+  "recommendations": ["foxundermoon.shell-format"]
+}
diff --git a/.vscode/settings.json b/.vscode/settings.json
index fc8e324a56..b56a38d2db 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -9,11 +9,14 @@
   "[javascript][typescript]": {
     "editor.formatOnSave": false,
     "editor.defaultFormatter": "esbenp.prettier-vscode",
-    "editor.codeActionsOnSave": ["source.formatDocument", "source.fixAll.eslint"]
+    "editor.codeActionsOnSave": {
+      "source.unusedImports": "explicit",
+      "source.fixAll": "explicit",
+      "source.formatDocument": "always"
+    }
   },
   "editor.formatOnSave": true,
   "eslint.enable": true,
-  "eslint.packageManager": "npm",
   "eslint.codeAction.showDocumentation": {
     "enable": true
   },
@@ -25,7 +28,7 @@
       "mode": "auto"
     }
   ],
-  "explorer.excludeGitIgnore": false,
+  "explorer.excludeGitIgnore": true,
   "files.exclude": {
     "**/.DS_Store": true,
     "**/.git": true,
@@ -41,15 +44,190 @@
   "javascript.updateImportsOnFileMove.enabled": "always",
   "typescript.updateImportsOnFileMove.enabled": "always",
 
-  "typescript.preferences.importModuleSpecifier": "project-relative",
   "javascript.preferences.importModuleSpecifier": "project-relative",
+  "typescript.preferences.importModuleSpecifier": "project-relative",
 
-  "typescript.preferences.importModuleSpecifierEnding": "minimal",
+  "typescript.preferences.importModuleSpecifierEnding": "index",
   "typescript.preferences.useAliasesForRenames": false,
 
-  "typescript.tsc.autoDetect": "on",
   "typescript.tsdk": "node_modules/typescript/lib",
-  "typescript.tsserver.experimental.enableProjectDiagnostics": false,
+  "typescript.tsserver.experimental.enableProjectDiagnostics": true,
   "typescript.workspaceSymbols.scope": "currentProject",
-  "eslint.problems.shortenToSingleLine": true
+  "eslint.problems.shortenToSingleLine": true,
+  "inline-bookmarks.expert.custom.words.mapping": {
+    "warn": ["@premerge(\\s|$)"],
+    "active": ["@active(\\s|$)"],
+    "fixme": ["@fixme(\\s|$)"]
+  },
+  "inline-bookmarks.expert.custom.styles": {
+    "active": {
+      // teal
+      "gutterIconColor": "#009999",
+      "overviewRulerColor": "rgba(0, 150, 150, 0.7)",
+      "light": {
+        "fontWeight": "bold",
+        "color": "#009999"
+      },
+      "dark": {
+        "fontWeight": "bold",
+        "color": "#00ffff"
+      }
+    },
+    "fixme": {
+      // yellow
+      "gutterIconColor": "#990000",
+      "overviewRulerColor": "rgba(150, 0, 0, 0.7)",
+      "light": {
+        "fontWeight": "bold",
+        "color": "#990000"
+      },
+      "dark": {
+        "fontWeight": "bold",
+        "color": "#ff0000"
+      }
+    },
+    "warn": {
+      // yellow
+      "gutterIconColor": "#999900",
+      "overviewRulerColor": "rgba(150, 150, 0, 0.7)",
+      "light": {
+        "fontWeight": "bold",
+        "color": "#999900"
+      },
+      "dark": {
+        "fontWeight": "bold",
+        "color": "#ffff00"
+      }
+    }
+  },
+  "inline-bookmarks.view.showVisibleFilesOnly": true,
+  "commit-message-editor.staticTemplate": [
+    "feat: Short description",
+    "",
+    "Message body",
+    "",
+    "Message footer"
+  ],
+  "commit-message-editor.dynamicTemplate": [
+    "{type}{scope}: {description}",
+    "",
+    "{body}",
+    "",
+    "{breaking_change}{footer}"
+  ],
+  "commit-message-editor.tokens": [
+    {
+      "label": "Type",
+      "name": "type",
+      "type": "enum",
+      "options": [
+        {
+          "label": "---",
+          "value": ""
+        },
+        {
+          "label": "build",
+          "description": "Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)"
+        },
+        {
+          "label": "chore",
+          "description": "Updating grunt tasks etc; no production code change"
+        },
+        {
+          "label": "ci",
+          "description": "Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)"
+        },
+        {
+          "label": "docs",
+          "description": "Documentation only changes"
+        },
+        {
+          "label": "feat",
+          "description": "A new feature"
+        },
+        {
+          "label": "fix",
+          "description": "A bug fix"
+        },
+        {
+          "label": "editor",
+          "description": "A change to editor/IDE support"
+        },
+        {
+          "label": "infra",
+          "description": "A change to the build, test or CI infrastructure"
+        },
+        {
+          "label": "perf",
+          "description": "A code change that improves performance"
+        },
+        {
+          "label": "refactor",
+          "description": "A code change that neither fixes a bug nor adds a feature"
+        },
+        {
+          "label": "revert"
+        },
+        {
+          "label": "style",
+          "description": "Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)"
+        },
+        {
+          "label": "test",
+          "description": "Adding missing tests or correcting existing tests"
+        }
+      ],
+      "description": "Type of changes"
+    },
+    {
+      "label": "Scope",
+      "name": "scope",
+      "description": "A scope may be provided to a commit’s type, to provide additional contextual information and is contained within parenthesis, e.g., \"feat(parser): add ability to parse arrays\".",
+      "type": "text",
+      "multiline": false,
+      "prefix": "(",
+      "suffix": ")"
+    },
+    {
+      "label": "Short description",
+      "name": "description",
+      "description": "Short description in the subject line.",
+      "type": "text",
+      "multiline": false
+    },
+    {
+      "label": "Body",
+      "name": "body",
+      "description": "Optional body",
+      "type": "text",
+      "multiline": true,
+      "lines": 5,
+      "maxLines": 10
+    },
+    {
+      "label": "Breaking change",
+      "name": "breaking_change",
+      "type": "boolean",
+      "value": "BREAKING CHANGE: ",
+      "default": false
+    },
+    {
+      "label": "Footer",
+      "name": "footer",
+      "description": "Optional footer",
+      "type": "text",
+      "multiline": true
+    }
+  ],
+  "surround.custom": {
+    "register": {
+      "label": "register helper",
+      "snippet": "{ ${1:helper}: $TM_SELECTED_TEXT }"
+    }
+  },
+  "rewrap.wrappingColumn": 100,
+  "rewrap.onSave": false,
+  "rewrap.autoWrap.enabled": true,
+  "rewrap.reformat": true,
+  "rewrap.wholeComment": false
 }
diff --git a/TODO.md b/TODO.md
new file mode 100644
index 0000000000..29d05d11e7
--- /dev/null
+++ b/TODO.md
@@ -0,0 +1,13 @@
+- [ ] Implement `#try` that takes handler
+  - [ ] internal `{{#if isClear}}{{!-- actual code --}}{{/if}}`
+  - [ ] if an error is encountered, unwind as-if isClear was false
+        during the render pass
+    - [ ] when you encounter the enter of the try, insert a marker in
+          every VM stack.
+    - [ ] every stack in the VM needs "unwind to nearest marker"
+    - [ ] when a render error is encountered, unwind all the stacks
+    - [ ] call the handler with the error
+  - [ ] no catch
+  - [ ] the handler has a way to clear the error
+  - [ ] deal with user destructors that should run even during render errors
+    - [ ] maintain the invariant that constructors and destructors are paired
diff --git a/bin/.eslintrc.cjs b/bin/.eslintrc.cjs
index ff785c7aa5..358453f1d1 100644
--- a/bin/.eslintrc.cjs
+++ b/bin/.eslintrc.cjs
@@ -7,7 +7,6 @@ module.exports = {
   root: false,
   env: {
     es6: true,
-    node: true,
   },
   overrides: [
     {
diff --git a/bin/codemods/devmode.toml b/bin/codemods/devmode.toml
new file mode 100644
index 0000000000..6a55621c2c
--- /dev/null
+++ b/bin/codemods/devmode.toml
@@ -0,0 +1,7 @@
+[devmode]
+match = "devmode({ :[block] })"
+rewrite = "devmode(() => ({ :[block] }))"
+
+[devmode2]
+match = "if (import.meta.env.DEV) { :[[name]].description = :[description]; }"
+rewrite = "setDescription(:[name], devmode(() => :[description]));"
diff --git a/bin/codemods/new-spec-suite.toml b/bin/codemods/new-spec-suite.toml
new file mode 100644
index 0000000000..ef577e8b8d
--- /dev/null
+++ b/bin/codemods/new-spec-suite.toml
@@ -0,0 +1,21 @@
+[test]
+match = """
+export class :[class] extends :[extends] {
+  static suiteName = :[suite];
+  :[block]
+}
+"""
+rewrite = """
+import { matrix } from "@glimmer-workspace/integration-tests";
+matrix(:[suite], (spec) => { :[block] }).client();
+"""
+rule = """
+where
+rewrite :[block] { "this" -> "ctx" },
+rewrite :[block] {
+  "@render(:[type]) :[string]() { :[body] }" -> "spec({ type: :[type] }, :[string], (ctx) => { :[body] })"
+},
+rewrite :[block] {
+  "@render :[string]() { :[body] }" -> "spec(:[string], (ctx) => { :[body] })"
+}
+"""
diff --git a/bin/opcodes.json b/bin/opcodes.json
new file mode 100644
index 0000000000..66dd0efa4a
--- /dev/null
+++ b/bin/opcodes.json
@@ -0,0 +1,112 @@
+{
+  "$schema": "./opcodes/opcodes.schema.json",
+  "outputs": {
+    "interface": "@glimmer/interfaces/lib/generated/vm-opcodes.d.ts",
+    "code": "@glimmer/vm/lib/generated/opcodes.ts",
+    "debug": "@glimmer/debug/lib/generated/op-list.ts"
+  },
+  "machine": ["PushFrame", "PopFrame", "Jump", "ReturnTo", "UnwindTypeFrame"],
+  "syscall": [
+    "PushBegin",
+    "Begin",
+    "Catch",
+    "Finally",
+    "InvokeVirtual",
+    "InvokeStatic",
+    "Start",
+    "Return",
+    "Helper",
+    "SetNamedVariables",
+    "SetBlocks",
+    "SetVariable",
+    "SetBlock",
+    "GetVariable",
+    "GetProperty",
+    "GetBlock",
+    "SpreadBlock",
+    "HasBlock",
+    "HasBlockParams",
+    "Concat",
+    "Constant",
+    "ConstantReference",
+    "Primitive",
+    "PrimitiveReference",
+    "ReifyU32",
+    "Dup",
+    "Pop",
+    "Load",
+    "Fetch",
+    "RootScope",
+    "VirtualRootScope",
+    "ChildScope",
+    "PopScope",
+    "Text",
+    "Comment",
+    "AppendHTML",
+    "AppendSafeHTML",
+    "AppendDocumentFragment",
+    "AppendNode",
+    "AppendText",
+    "OpenElement",
+    "OpenDynamicElement",
+    "PushRemoteElement",
+    "StaticAttr",
+    "DynamicAttr",
+    "ComponentAttr",
+    "FlushElement",
+    "CloseElement",
+    "PopRemoteElement",
+    "Modifier",
+    "BindDynamicScope",
+    "PushDynamicScope",
+    "PopDynamicScope",
+    "CompileBlock",
+    "PushBlockScope",
+    "PushSymbolTable",
+    "InvokeYield",
+    "JumpIf",
+    "JumpUnless",
+    "JumpEq",
+    "AssertSame",
+    "Enter",
+    "Exit",
+    "ToBoolean",
+    "EnterList",
+    "ExitList",
+    "Iterate",
+    "Main",
+    "ContentType",
+    "Curry",
+    "PushComponentDefinition",
+    "PushDynamicComponentInstance",
+    "ResolveDynamicComponent",
+    "ResolveCurriedComponent",
+    "PushArgs",
+    "PushEmptyArgs",
+    "PrepareArgs",
+    "CaptureArgs",
+    "CreateComponent",
+    "RegisterComponentDestructor",
+    "PutComponentOperations",
+    "GetComponentSelf",
+    "GetComponentTagName",
+    "GetComponentLayout",
+    "SetupForEval",
+    "PopulateLayout",
+    "InvokeComponentLayout",
+    "BeginComponentTransaction",
+    "CommitComponentTransaction",
+    "DidCreateElement",
+    "DidRenderLayout",
+    "Debugger",
+    "StaticComponentAttr",
+    "DynamicContentType",
+    "DynamicHelper",
+    "DynamicModifier",
+    "IfInline",
+    "Not",
+    "GetDynamicVar",
+    "Log",
+    "PushUnwindTarget"
+  ]
+}
diff --git a/bin/opcodes.mts b/bin/opcodes.mts
new file mode 100644
index 0000000000..47813386a0
--- /dev/null
+++ b/bin/opcodes.mts
@@ -0,0 +1,133 @@
+import { dirname, resolve } from 'node:path';
+import chalk from 'chalk';
+import { execSync, spawnSync } from 'node:child_process';
+import { Emitter } from './opcodes/utils.mjs';
+
+const emitter = Emitter.argv('opcodes.json', import.meta);
+
+const { machine, system } = emitter.opcodes;
+
+const ALL: (string | null)[] = [
+  ...machine,
+  ...new Array(16 - machine.length).fill(null),
+  ...system,
+];
+
+const TYPES = ['interface', 'code', 'debug', 'all'] as const;
+
+if (emitter.options.help) {
+  throw usage();
+}
+
+if (emitter.type === undefined) {
+  throw usage('Missing type');
+}
+
+compute(emitter.type);
+
+function compute(type: string) {
+  switch (type) {
+    case 'interface': {
+      const members = Object.fromEntries(
+        ALL.flatMap((name, i) => {
+          if (name === null) return [];
+          return [[name, i]];
+        })
+      );
+
+      const INTERFACE_MEMBERS = ALL.flatMap((name, i) => {
+        if (name === null) return [];
+        return [`  ${name}: ${i};`];
+      }).join('\n');
+
+      emitter.writeTarget('interface')([
+        `export interface VmOpMap {\n${INTERFACE_MEMBERS}\n}`,
+        '',
+        `export type VmMachineOp =`,
+        ...machine.flatMap((m) => [`// ${m}`, `| ${members[m]}`]),
+        '',
+        `export type VmSyscallOp =`,
+        ...system.flatMap((m) => [`// ${m}`, `| ${members[m]}`]),
+        '',
+        `export type OpSize = ${ALL.length};`,
+      ]);
+      break;
+    }
+
+    case 'code': {
+      const OP_TYPE = `OpType`;
+
+      const CODE_MEMBERS = ALL.flatMap((name, i) => {
+        if (name === null) return [];
+        return [`  ${name}: ${i},`];
+      }).join('\n');
+
+      emitter.writeTarget('code')([
+        `export interface Op {\n${CODE_MEMBERS}\n}`,
+        '',
+        `export const Op: Op = {\n${CODE_MEMBERS}\n};`,
+        '',
+        `export const OpSize = ${ALL.length} as const;`,
+      ]);
+      break;
+    }
+
+    case 'debug': {
+      emitter.writeTarget('debug')([
+        `import type { VmOpMap } from "${emitter.imports.interface}";`,
+        '',
+        `export const DebugOpList = ${JSON.stringify(
+          ALL
+        )} as const satisfies { [P in keyof VmOpMap as VmOpMap[P]]: P };`,
+        '',
+        `export type DebugOpList = ${JSON.stringify(ALL)}`,
+      ]);
+      break;
+    }
+
+    case 'all':
+      compute('code');
+      compute('interface');
+      compute('debug');
+      break;
+
+    default:
+      usage(`Invalid type ${chalk.cyan(type)}`);
+  }
+}
+
+function usage(error?: string): never {
+  emitter.human(chalk.cyan.inverse('Usage:'), chalk.cyan('node opcodes.mts <type> [target]'));
+  emitter.newline();
+  emitter.human(
+    chalk.yellow(`<type>    `),
+    chalk.grey.inverse('one of'),
+    chalk.cyanBright(TYPES.join(', '))
+  );
+  emitter.human(
+    chalk.yellow(`[target]  `),
+    chalk.grey(`Output path or '-' (defaults to target in opcodes.json).`)
+  );
+  emitter.newline();
+  emitter.human(chalk.yellowBright.inverse('NOTE'));
+  emitter.human(
+    chalk.yellow(
+      `targets in ${chalk.cyan(`opcodes.json`)} are ${chalk.magentaBright(
+        'relative to the packages directory'
+      )}.`
+    )
+  );
+  emitter.human(
+    chalk.yellow(
+      `targets ${chalk.cyan('specified on the command-line')} are ${chalk.magentaBright(
+        'relative to the workspace root'
+      )}.`
+    )
+  );
+
+  if (error) {
+    emitter.newline();
+    emitter.human(chalk.red.inverse('ERROR'), chalk.red(error));
+  }
+  process.exit(error ? 1 : 0);
+}
diff --git a/bin/opcodes/opcodes.schema.json b/bin/opcodes/opcodes.schema.json
new file mode 100644
index 0000000000..c9a8a78bdf
--- /dev/null
+++ b/bin/opcodes/opcodes.schema.json
@@ -0,0 +1,30 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "required": ["outputs", "machine", "syscall"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string",
+      "format": "path"
+    },
+    "outputs": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "interface": { "type": "string" },
+        "code": { "type": "string" },
+        "debug": { "type": "string" }
+      },
+      "required": ["interface", "code", "debug"]
+    },
+    "machine": {
+      "type": "array",
+      "items": { "type": "string" }
+    },
+    "syscall": {
+      "type": "array",
+      "items": { "type": "string" }
+    }
+  }
+}
diff --git a/bin/opcodes/utils.mts b/bin/opcodes/utils.mts
new file mode 100644
index 0000000000..d272929f1d
--- /dev/null
+++ b/bin/opcodes/utils.mts
@@ -0,0 +1,225 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, resolve } from 'node:path';
+import chalk from 'chalk';
+import { spawnSync } from 'node:child_process';
+
+const MISSING_INDEX = -1;
+const REMOVE = 1;
+
+interface OpcodesJson {
+  outputs: {
+    code: string;
+    interface: string;
+    debug: string;
+  };
+  machine: string[];
+  syscall: string[];
+}
+
+interface Paths {
+  config: string;
+  root: string;
+  packages: string;
+}
+
+interface Options {
+  verbose: boolean;
+  dryRun: boolean;
+  help: boolean;
+}
+
+type Target = keyof OpcodesJson['outputs'];
+
+export class Emitter {
+  static argv(config: string, here: ImportMeta) {
+    const __dirname = new URL('.', here.url).pathname;
+    const configPath = resolve(__dirname, config);
+    const json = JSON.parse(readFileSync(configPath, 'utf-8'));
+
+    const root = dirname(__dirname);
+    const packages = resolve(root, 'packages');
+    const ARGV = [...process.argv.slice(2)];
+
+    const verbose = extractFlag(ARGV, '--verbose') || extractFlag(ARGV, '-v');
+    const dryRun = extractFlag(ARGV, '--dry-run') || extractFlag(ARGV, '-d');
+    const help = extractFlag(ARGV, '--help') || extractFlag(ARGV, '-h');
+
+    return new Emitter(json, { root, packages, config: configPath }, ARGV, {
+      verbose,
+      dryRun,
+      help,
+    });
+  }
+
+  readonly #json: OpcodesJson;
+  readonly #paths: Paths;
+  readonly #args: string[];
+  readonly #options: Options;
+
+  constructor(json: OpcodesJson, paths: Paths, args: string[], options: Options) {
+    this.#json = json;
+    this.#paths = paths;
+    this.#args = args;
+    this.#options = options;
+  }
+
+  get type(): string | undefined {
+    return this.#args[0];
+  }
+
+  get target(): string | undefined {
+    return this.#args[1];
+  }
+
+  get options(): Options {
+    return this.#options;
+  }
+
+  get opcodes(): { machine: string[]; system: string[] } {
+    return {
+      machine: this.#json.machine,
+      system: this.#json.syscall,
+    };
+  }
+
+  writeTarget(name: Target): (code: string[]) => void {
+    return (code) => {
+      this.write(code, this.#resolvePath(name));
+    };
+  }
+
+  newline(): void {
+    this.human('');
+  }
+
+  #resolvePath(name: Target) {
+    switch (this.target) {
+      case '-':
+        return '-';
+      case undefined:
+        return resolve(this.#paths.packages, this.#json.outputs[name]);
+      default:
+        return resolve(this.#paths.root, this.target);
+    }
+  }
+
+  write(code: string[], path: string) {
+    const outputString = [
+      `// This code was generated by $root/bin/opcodes.mts.`,
+      `// Do not change it manually.`,
+      '',
+      ...code,
+    ].join('\n');
+
+    const dir = dirname(path);
+
+    if (!existsSync(dir)) {
+      this.human(`Directory ${chalk.cyan(dir)} does not exist.`);
+      process.exit(1);
+    }
+
+    const result = spawnSync(`pnpm`, ['prettier', '--parser', 'typescript'], {
+      cwd: this.#paths.root,
+      input: outputString,
+      stdio: ['pipe', 'pipe', 'inherit'],
+      encoding: 'utf-8',
+    });
+
+    const { stdout: formatted } = result;
+
+    if (formatted === null) {
+      this.human(
+        chalk.red.inverse('ERROR'),
+        'running',
+        `pnpm prettier --parser typescript`,
+        'at',
+        chalk.cyan(this.#paths.root)
+      );
+      this.newline();
+      this.human(chalk.yellow.inverse('STDIN'));
+      this.logOutput(outputString);
+      this.newline();
+      process.exit(1);
+    }
+
+    if (this.#options.dryRun) {
+      this.human(
+        chalk.cyan.inverse('[DRY RUN]'),
+        chalk.grey(`Writing ${chalk.cyan(relative(this.#paths.root, path))}...`)
+      );
+    }
+
+    if (path === '-') {
+      this.emit(formatted);
+      return;
+    } else if (this.#options.dryRun) {
+      this.logOutput(formatted);
+      this.newline();
+      return;
+    }
+
+    this.human(chalk.grey(`Writing ${chalk.cyan(path)}...`));
+    writeFileSync(path, formatted);
+
+    if (this.#options.verbose) {
+      const written = readFileSync(path, 'utf-8');
+      this.human('');
+      this.human(chalk.bgGrey('Output:'));
+      this.logOutput(written);
+      this.newline();
+    }
+  }
+
+  logOutput(output: string) {
+    this.human('');
+    for (const line of output.split('\n')) {
+      this.human(`${chalk.grey('|')}  ${chalk.green.dim(line)}`);
+    }
+  }
+
+  get imports(): { code: string; interface: string; debug: string } {
+    return {
+      code: this.#extractImport('code'),
+      interface: this.#extractImport('interface'),
+      debug: this.#extractImport('debug'),
+    };
+  }
+
+  #extractImport(type: Target): string {
+    const match = /^@glimmer\/[^/]*/.exec(this.#json.outputs[type])?.[0];
+
+    if (!match) {
+      this.human(`Invalid output.${type} in opcodes.json: ${chalk.cyan(this.#paths.config)}`);
+      this.human(chalk.yellow(`Output files must be nested in '@glimmer/*' packages`));
+      process.exit(1);
+    }
+
+    return match;
+  }
+
+  /**
+   * Anything intended to be piped should be sent to `stdout`.
+   */
+  emit(...args: unknown[]) {
+    console.log(...args);
+  }
+
+  /**
+   * Anything that isn't intended to be piped should be sent to `stderr` (really
+   * should be called `stdlog` imo).
+   */
+  human(...args: unknown[]) {
+    console.error(...args);
+  }
+}
+
+function extractFlag(argv: string[], name: string): boolean {
+  const index = argv.indexOf(name);
+
+  if (index === MISSING_INDEX) {
+    return false;
+  }
+
+  argv.splice(index, REMOVE);
+  return true;
+}
diff --git a/bin/tsconfig.json b/bin/tsconfig.json
index cba49b2922..bb4f82cb03 100644
--- a/bin/tsconfig.json
+++ b/bin/tsconfig.json
@@ -22,5 +22,5 @@
     "noPropertyAccessFromIndexSignature": true,
     "noUncheckedIndexedAccess": true
   },
-  "include": ["*.mjs", "*.mts", "*.ts"]
+  "include": ["*.mjs", "*.mts", "*.ts", "*/*.mjs", "*/*.mts", "*/*.ts"]
 }
diff --git a/glimmer-vm.code-workspace b/glimmer-vm.code-workspace
new file mode 100644
index 0000000000..cf76460b62
--- /dev/null
+++ b/glimmer-vm.code-workspace
@@ -0,0 +1,189 @@
+{
+  "folders": [
+    {
+      "name": "✨ glimmer-engine",
+      "path": "."
+    },
+    {
+      "name": "glimmer-benchmark",
+      "path": "benchmark"
+    },
+    {
+      "name": "@glimmer-workspace/krausest",
+      "path": "benchmark/benchmarks/krausest"
+    },
+    {
+      "name": "@glimmer-workspace/bin",
+      "path": "bin"
+    },
+    {
+      "name": "📦 local-linker",
+      "path": "lib/local-linker"
+    },
+    {
+      "name": "📦 /home/wycats/Code/Ember/glimmer-vm/packages",
+      "path": "packages"
+    },
+    {
+      "name": "📦 @glimmer-workspace/benchmark-env",
+      "path": "packages/@glimmer-workspace/benchmark-env"
+    },
+    {
+      "name": "📦 @glimmer-workspace/build-support",
+      "path": "packages/@glimmer-workspace/build"
+    },
+    {
+      "name": "📦 @glimmer-workspace/eslint-plugin",
+      "path": "packages/@glimmer-workspace/eslint-plugin"
+    },
+    {
+      "name": "📦 @glimmer-workspace/integration-tests",
+      "path": "packages/@glimmer-workspace/integration-tests"
+    },
+    {
+      "name": "📦 @glimmer-workspace/test-utils",
+      "path": "packages/@glimmer-workspace/test-utils"
+    },
+    {
+      "name": "📦 @glimmer/compiler",
+      "path": "packages/@glimmer/compiler"
+    },
+    {
+      "name": "📦 @glimmer-test/compiler",
+      "path": "packages/@glimmer/compiler/test"
+    },
+    {
+      "name": "📦 @glimmer/debug",
+      "path": "packages/@glimmer/debug"
+    },
+    {
+      "name": "📦 @glimmer/destroyable",
+      "path": "packages/@glimmer/destroyable"
+    },
+    {
+      "name": "📦 @glimmer-test/destroyable",
+      "path": "packages/@glimmer/destroyable/test"
+    },
+    {
+      "name": "📦 @glimmer/dom-change-list",
+      "path": "packages/@glimmer/dom-change-list"
+    },
+    {
+      "name": "📦 @glimmer-test/dom-change-list",
+      "path": "packages/@glimmer/dom-change-list/test"
+    },
+    {
+      "name": "📦 @glimmer/encoder",
+      "path": "packages/@glimmer/encoder"
+    },
+    {
+      "name": "📦 @glimmer/global-context",
+      "path": "packages/@glimmer/global-context"
+    },
+    {
+      "name": "📦 @glimmer/interfaces",
+      "path": "packages/@glimmer/interfaces"
+    },
+    {
+      "name": "📦 @glimmer/local-debug-flags",
+      "path": "packages/@glimmer/local-debug-flags"
+    },
+    {
+      "name": "📦 @glimmer/manager",
+      "path": "packages/@glimmer/manager"
+    },
+    {
+      "name": "📦 @glimmer-test/manager",
+      "path": "packages/@glimmer/manager/test"
+    },
+    {
+      "name": "📦 @glimmer/node",
+      "path": "packages/@glimmer/node"
+    },
+    {
+      "name": "📦 @glimmer/opcode-compiler",
+      "path": "packages/@glimmer/opcode-compiler"
+    },
+    {
+      "name": "📦 @glimmer/owner",
+      "path": "packages/@glimmer/owner"
+    },
+    {
+      "name": "📦 @glimmer-test/owner",
+      "path": "packages/@glimmer/owner/test"
+    },
+    {
+      "name": "📦 @glimmer/program",
+      "path": "packages/@glimmer/program"
+    },
+    {
+      "name": "📦 @glimmer-test/program",
+      "path": "packages/@glimmer/program/test"
+    },
+    {
+      "name": "📦 @glimmer/reference",
+      "path": "packages/@glimmer/reference"
+    },
+    {
+      "name": "📦 @glimmer-test/reference",
+      "path": "packages/@glimmer/reference/test"
+    },
+    {
+      "name": "📦 @glimmer/runtime",
+      "path": "packages/@glimmer/runtime"
+    },
+    {
+      "name": "📦 @glimmer/syntax",
+      "path": "packages/@glimmer/syntax"
+    },
+    {
+      "name": "📦 @glimmer-test/syntax",
+      "path": "packages/@glimmer/syntax/test"
+    },
+    {
+      "name": "📦 @glimmer/util",
+      "path": "packages/@glimmer/util"
+    },
+    {
+      "name": "📦 @glimmer-test/util",
+      "path": "packages/@glimmer/util/test"
+    },
+    {
+      "name": "📦 @glimmer/validator",
+      "path": "packages/@glimmer/validator"
+    },
+    {
+      "name": "📦 @glimmer-test/validator",
+      "path": "packages/@glimmer/validator/test"
+    },
+    {
+      "name": "📦 @glimmer/vm",
+      "path": "packages/@glimmer/vm"
+    },
+    {
+      "name": "📦 @glimmer/vm-babel-plugins",
+      "path": "packages/@glimmer/vm-babel-plugins"
+    },
+    {
+      "name": "📦 @glimmer/wire-format",
+      "path": "packages/@glimmer/wire-format"
+    },
+    {
+      "name": "📦 @types/js-reporters",
+      "path": "packages/@types/js-reporters"
+    },
+    {
+      "name": "📦 @types/puppeteer-chromium-resolver",
+      "path": "packages/@types/puppeteer-chromium-resolver"
+    },
+    {
+      "name": "📦 @types/qunit",
+      "path": "packages/@types/qunit"
+    }
+  ],
+  "settings": {
+    "typescript.tsc.autoDetect": "on",
+    "typescript.tsdk": "node_modules/typescript/lib",
+    "typescript.tsserver.experimental.enableProjectDiagnostics": true
+  }
+}
diff --git a/guides/building-glimmer/01-introduction.md b/guides/building-glimmer/01-introduction.md
new file mode 100644
index 0000000000..4eabb85084
--- /dev/null
+++ b/guides/building-glimmer/01-introduction.md
@@ -0,0 +1,5 @@
+### Table of Contents
+
+1. [Introduction](./01-introduction.md)
+2. [Minification Assumptions](./02-minification.md)
+3. [Dev Mode Patterns](./03-devmode-patterns.md)
diff --git a/guides/building-glimmer/02-minification.md b/guides/building-glimmer/02-minification.md
new file mode 100644
index 0000000000..f2b979b13f
--- /dev/null
+++ b/guides/building-glimmer/02-minification.md
@@ -0,0 +1,14 @@
+# Minification Assumptions
+
+> 🚧 https://terser.org/docs/options/
+
+- `import.meta.env.DEV`
+- `keep_fargs: false`
+
+## Issues
+
+### Works better in terser than swc
+
+- https://tiny.katz.zone/OfydPB
+- https://tiny.katz.zone/XlJrqp
+- https://tiny.katz.zone/6R5VdC (weird behavior involving new)
diff --git a/guides/building-glimmer/03-devmode-patterns.md b/guides/building-glimmer/03-devmode-patterns.md
new file mode 100644
index 0000000000..e93df9a578
--- /dev/null
+++ b/guides/building-glimmer/03-devmode-patterns.md
@@ -0,0 +1,3 @@
+# Dev Mode Patterns
+
+## Case Study: `DevMode<Description>`
diff --git a/guides/compiler-internals/01-introduction.md b/guides/internals/01-introduction.md
similarity index 60%
rename from guides/compiler-internals/01-introduction.md
rename to guides/internals/01-introduction.md
index 9f676e0528..bcc4f17662 100644
--- a/guides/compiler-internals/01-introduction.md
+++ b/guides/internals/01-introduction.md
@@ -6,3 +6,7 @@
 4. [Resolver Delegate](./04-compile-time-resolver-delegate.md)
 5. [Handles](./05-handles.md)
 6. [Template Compilation](./06-templates.md)
+7. [Frames and Blocks](./07-frames-and-blocks.md)
+8. [References](./08-references.md)
+9. [Error Recovery](./09-error-recovery/index.md)
+10. [Trace Logging](./10-trace-logging.md)
diff --git a/guides/compiler-internals/02-program-compilation-context.md b/guides/internals/02-program-compilation-context.md
similarity index 100%
rename from guides/compiler-internals/02-program-compilation-context.md
rename to guides/internals/02-program-compilation-context.md
diff --git a/guides/internals/07-frames-and-blocks.md b/guides/internals/07-frames-and-blocks.md
new file mode 100644
index 0000000000..4b5330150a
--- /dev/null
+++ b/guides/internals/07-frames-and-blocks.md
@@ -0,0 +1,55 @@
+# Frames and Blocks
+
+Initial:
+
+```clj
+[
+  (PushFrame)
+  [
+    (ReturnTo END)
+    (Push ...Args)
+    (Enter)
+    [
+      (Assertion) ; (JumpUnless) | (AssertSame)
+      ...body
+    ]
+    (Exit)
+    (Return)
+    ; END
+  ]
+  (PopFrame)
+]
+```
+
+Update:
+
+```clj
+[
+  ; restore state
+  (ReturnTo -1)
+  (PushArgs ...Captured)
+  (ReEnter)
+  ; start evaluation here
+  [
+    (Assertion)
+    ; (JumpUnless) | (AssertSame)
+    ...body
+  ]
+  (Exit)
+  (Return)
+]
+```
+
+1. Initial
+   1. PushFrame
+   2. ReturnTo
+   3. Push captured args
+   4. Enter (optionally try frame)
+   5. Assertion
+      a. `JumpUnless` -> target
+      b. `AssertSame`
+   6. (body)
+   7. Exit
+   8. Return
+   9. PopFrame
+2. Update (from 1.5)
diff --git a/guides/internals/07-references.md b/guides/internals/07-references.md
new file mode 100644
index 0000000000..ae6cc34dab
--- /dev/null
+++ b/guides/internals/07-references.md
@@ -0,0 +1,139 @@
+# Reactivity APIs
+
+## Generic APIs
+
+## `readReactive`
+
+| Takes              | Returns                       |
+| ------------------ | ----------------------------- |
+| 🟢🟡 Fallible Read | 🟡 Result _(throws ⚪ Never)_ |
+
+The `readReactive` function takes a reactive value and returns a `ReactiveResult`.
+
+## `unwrapReactive`
+
+The `unwrapReactive` function takes a `ReactiveResult` and returns its value, throwing an exception
+if the reactive produces an error (or was previously an error).
+
+| Takes              | Returns                              |
+| ------------------ | ------------------------------------ |
+| 🟢🟡 Fallible Read | 🟢 Value _(throws 🔴 UserException)_ |
+
+## `updateReactive`
+
+The `updateReactive` function takes a _mutable_ reactive and a new value and updates it. You cannot
+pass an immutable reactive to this function.
+
+| Takes      | Updates                  |
+| ---------- | ------------------------ |
+| 📝 Mutable | 🟢 Value _(or 🔴 Error)_ |
+
+## Cell APIs
+
+### Constructors
+
+```ts
+function Cell(value: T): MutableCell<T>;
+function ReadonlyCell(value: T): ReadonlyCell<T>;
+
+type Cell<T> = MutableCell<T> | ReadonlyCell<T>;
+```
+
+| Type              | Read     | Write        |
+| ----------------- | -------- | ------------ |
+| `Cell<T>`         | 🟢 Value | 📝 Mutable   |
+| `ReadonlyCell<T>` | 🟢 Value | 🚫 Immutable |
+
+### `readCell`
+
+```ts
+export function readCell<T>(cell: Cell<T>): T;
+```
+
+The `readCell` function takes a cell and returns its value. Since cells are infallible, you can use
+this function to read from a cell without risking an exception (as with `unwrapReactive`).
+
+### `writeCell`
+
+```ts
+export function writeCell<T>(cell: MutableCell<T>, value: T): void;
+```
+
+| Takes            | Updates  |
+| ---------------- | -------- |
+| 📝 Mutable Write | 🟢 Value |
+
+The `writeCell` function writes a new value to a mutable cell. You can't write to a readonly cell.
+
+## Formula APIs
+
+| Type          | Read      | Write        |
+| ------------- | --------- | ------------ |
+| `Accessor<T>` | 🟡 Result | 📝 Mutable   |
+| `Formula<T>`  | 🟡 Result | 🚫 Immutable |
+
+### Constructors
+
+```ts
+export function Formula<T>(compute: () => T): Formula<T>;
+export function Accessor<T>(options: { get: () => T; set: (value: T) => void }): Accessor<T>;
+```
+
+If an accessor's `set` throws an error, the reactive value will become an error.
+
+## External Markers
+
+External markers are not reactive values themselves. Instead, they _stand in_ for external storage.
+
+Here's an example using a `SimpleMap` class that uses a `Map` as its backing storage:
+
+```ts
+class SimpleMap<K, V> {
+  #markers = new Map<K, ExternalMarker>();
+  #values = new Map<K, V>();
+
+  get(key: K): V {
+    this.#initialized(key).consumed();
+    return this.#values.get(key);
+  }
+
+  has(key: K) {
+    this.#initialized(key).consumed();
+    return this.#values.has(key);
+  }
+
+  set(key: K, value: V) {
+    this.#initialized(key).updated();
+    this.#values.set(key, value);
+  }
+
+  #initialized(key: K) {
+    let marker = this.#markers.get(key);
+
+    if (!marker) {
+      marker = ExternalMarker();
+      this.#markers.set(key, marker);
+    }
+
+    return marker;
+  }
+}
+```
+
+Now, reads from `has(key)` or `get(key)` will be invalidated whenever `set(key, value)` is called on
+the same key.
+
+The crux of the situation is that we don't want to store every value in a Cell and turn every
+computation into a `Formula`. Instead, we want to store our data in normal JavaScript data
+structures and notify the reactivity system whenever the data is accessed or modified.
+
+## Internal Reactives
+
+### `ComputedCell`
+
+A `ComputedCell` behaves like a cell, but it uses a `compute` function to compute a new value. The
+`compute` function must be infallible, and there is no error recovery if it fails.
+
+| Type              | Read     | Write        |
+| ----------------- | -------- | ------------ |
+| `ComputedCell<T>` | 🟢 Value | 🚫 Immutable |
diff --git a/guides/internals/09-error-recovery/A-error-recovery-references.md b/guides/internals/09-error-recovery/A-error-recovery-references.md
new file mode 100644
index 0000000000..39e6caddf1
--- /dev/null
+++ b/guides/internals/09-error-recovery/A-error-recovery-references.md
@@ -0,0 +1,55 @@
+# Error Recovery: Reactive Values
+
+Reactive values are _fallible_: they can be in an error state.
+
+## `ReactiveResult<T>`
+
+A `ReactiveResult` can be in one of two states:
+
+```ts
+interface Ok<T> {
+  type: 'ok';
+  value: T;
+}
+```
+
+```ts
+interface Error {
+  type: 'error';
+  value: UserException;
+}
+```
+
+## General Reactive APIs
+
+### `readReactive`
+
+The `readReactive` function takes a reactive value and returns a `ReactiveResult`.
+
+### `unwrapReactive`
+
+The `unwrapReactive` function takes a `ReactiveResult` and returns its value, throwing an exception
+if the reactive produces an error (or was previously an error).
+
+## Cell APIs
+
+### `readCell`
+
+### `writeCell`
+
+## Error Recovery
+
+Once a formula has entered the error state, it can be recovered in one of two ways:
+
+- The formula invalidates
+- The `clearError` function is called
+
+Examples:
+
+```ts
+class isError = createCell(false);
+
+const formula = FallibleFormula(() => {
+  if ()
+});
+```
diff --git a/guides/internals/09-error-recovery/B-error-recovery-stack.md b/guides/internals/09-error-recovery/B-error-recovery-stack.md
new file mode 100644
index 0000000000..c9dbe92a59
--- /dev/null
+++ b/guides/internals/09-error-recovery/B-error-recovery-stack.md
@@ -0,0 +1,76 @@
+# Error Recovery
+
+Error recovery is a feature of the Glimmer VM that allows the VM to recover from errors in user code.
+
+## Table of Contents
+
+1. [Conceptually](#conceptually)
+1. [Internal VM Pattern](#internal-vm-pattern)
+1. [The Unwind Pointer](#the-unwind-pointer)
+1. [The ErrorBoundary Internal Construct](#the-errorboundary-internal-construct)
+1. [Modelled as a Conditional](#modelled-as-a-conditional)
+
+## Conceptually
+
+Conceptually, this feature makes it possible to create an unwind boundary in the VM. When an error occurs inside of an unwind boundary, the VM will clear its internal stack back to the unwind pointer.
+
+## Internal VM Pattern
+
+Internally, all objects that represent aspects of the runtime stack have the following methods:
+
+```ts
+interface VmStackAspect {
+  begin(): this;
+  catch(): this;
+  finally(): this;
+
+  onCatch?(callback: () => void): void;
+  onFinally?(callback: () => void): void;
+
+  readonly debug?: { frames: Array<DebugStackAspectFrame> };
+}
+
+type DebugStackAspectFrame =
+  | { aspects: Record<string, DebugStackAspectFrame> }
+  | { values: unknown[] };
+```
+
+Each of these methods returns a _snapshot_ of the current state of the stack. We call these
+snapshots "transactions".
+
+### Begin
+
+When entering a block of code with error recovery, call `begin()` on each stack aspect and replace
+the current instance of that aspect with the result of calling `begin()`.
+
+### Catch
+
+When an error occurs inside of a block of code with error recovery, call `catch()` on each stack aspect
+and replace the current instance of that aspect with the result of calling `catch()`.
+
+You can call `catch()` without balancing pops with pushes (that's the entire point). When you call
+`catch()`, the stack aspect will return the state at the last `begin()` point.
+
+### Finally
+
+When you reach the end of a block of code with error recovery, call `finally()` on the stack aspect.
+You must only call `finally()` after balancing pushes and pops.
+
+### `onCatch` (optional)
+
+Some stack aspects also implement `onCatch`. Any functions registered with `onCatch` will
+automatically be invoked when `catch` occurs.
+
+### `onFinally` (optional)
+
+Some stack aspects also implement `onFinally`. Any functions registered with `onFinally` will
+automatically be invoked when either `catch` or `finally` occurs.
+
+### `debug` (in dev mode)
+
+The `debug` property is a list of conceptual "frames". Each frame is a record of all of the stack aspects contained within the current stack
+aspect. It is always present in dev mode (`import.meta.env.DEV`), and generally not present in prod.
+
+The "leaf" aspects are stacks, and each frame in a stack is a list of the values for that stack.
+The "parent" aspects are collections of aspects, and the frames _zip together_ the frames of
+the children.
diff --git a/guides/internals/09-error-recovery/index.md b/guides/internals/09-error-recovery/index.md
new file mode 100644
index 0000000000..295b208352
--- /dev/null
+++ b/guides/internals/09-error-recovery/index.md
@@ -0,0 +1,4 @@
+# Error Recovery
+
+1. [References](./error-recovery/A-error-recovery-references.md)
+2. [Stack](./error-recovery/B-error-recovery-stack.md)
diff --git a/guides/internals/10-trace-logging.md b/guides/internals/10-trace-logging.md
new file mode 100644
index 0000000000..b8af58fb37
--- /dev/null
+++ b/guides/internals/10-trace-logging.md
@@ -0,0 +1,11 @@
+# Trace Logging
+
+This section describes the trace logging used in the Glimmer compiler.
+
+## Enabling Trace Logging
+
+### Enabling Trace Logging Via the Test Harness
+
+### Advanced Trace Options
+
+## Trace Options
diff --git a/package.json b/package.json
index 0611fd0391..2fd4f68e3c 100644
--- a/package.json
+++ b/package.json
@@ -10,6 +10,7 @@
   "license": "MIT",
   "author": "Tilde, Inc.",
   "scripts": {
+    "generate:opcodes": "esyes bin/opcodes.mts all",
     "benchmark:build": "node benchmark/bin/build.js",
     "benchmark:control": "node benchmark/bin/control.js",
     "benchmark:experiment": "node benchmark/bin/experiment.js",
@@ -23,7 +24,7 @@
     "lint:files": "dotenv -- turbo lint",
     "force:lint:files": "eslint .",
     "lint:types": "tsc -b",
-    "start": "ember serve --port=7357",
+    "start": "vite",
     "test": "node bin/run-tests.mjs",
     "test:browserstack": "ember test --test-port=7774 --host 127.0.0.1 --config-file=testem-browserstack.js",
     "test:node": "node bin/run-node-tests.mjs",
@@ -50,71 +51,74 @@
     }
   },
   "devDependencies": {
+    "@babel/plugin-proposal-decorators": "^7.23.2",
     "@babel/plugin-syntax-dynamic-import": "^7.8.3",
-    "@babel/plugin-transform-modules-commonjs": "^7.21.5",
-    "@babel/plugin-transform-runtime": "^7.21.4",
-    "@babel/preset-env": "^7.21.5",
-    "@babel/preset-typescript": "^7.21.5",
-    "@babel/runtime": "^7.21.5",
-    "@babel/traverse": "^7.21.5",
-    "@babel/types": "^7.21.5",
+    "@babel/plugin-transform-modules-commonjs": "^7.23.0",
+    "@babel/plugin-transform-runtime": "^7.23.2",
+    "@babel/preset-env": "^7.23.2",
+    "@babel/preset-typescript": "^7.23.2",
+    "@babel/runtime": "^7.23.2",
+    "@babel/traverse": "^7.23.2",
+    "@babel/types": "^7.23.0",
     "@glimmer-workspace/build-support": "workspace:^",
     "@glimmer-workspace/eslint-plugin": "workspace:^",
     "@glimmer-workspace/integration-tests": "workspace:^",
     "@glimmer/env": "0.1.7",
     "@release-it-plugins/lerna-changelog": "^6.0.0",
     "@release-it-plugins/workspaces": "^4.0.0",
-    "@rollup/plugin-terser": "^0.4.1",
-    "@types/babel-plugin-macros": "^3.1.0",
-    "@types/babel__core": "^7.20.0",
-    "@types/babel__traverse": "^7.18.5",
-    "@types/eslint": "^8.37.0",
-    "@types/node": "^18.16.6",
-    "@types/preval.macro": "^3.0.0",
-    "@types/qunit": "^2.19.7",
-    "@typescript-eslint/eslint-plugin": "^5.59.5",
-    "@typescript-eslint/parser": "^5.59.5",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@types/babel-plugin-macros": "^3.1.2",
+    "@types/babel__core": "^7.20.3",
+    "@types/babel__traverse": "^7.20.3",
+    "@types/eslint": "^8.44.6",
+    "@types/node": "^20.8.10",
+    "@types/qunit": "workspace:^",
+    "@typescript-eslint/eslint-plugin": "^6.9.1",
+    "@typescript-eslint/parser": "^6.9.1",
+    "@vitejs/plugin-react": "^4.1.1",
+    "@vitejs/plugin-react-swc": "^3.4.1",
     "amd-name-resolver": "^1.3.1",
     "auto-dist-tag": "^2.1.1",
     "babel-plugin-macros": "^3.1.0",
     "babel-plugin-strip-glimmer-utils": "^0.1.1",
-    "chalk": "^5.2.0",
+    "chalk": "^5.3.0",
     "dag-map": "^2.0.2",
-    "dotenv-cli": "^7.2.1",
-    "ember-cli": "~4.12.1",
+    "dotenv-cli": "^7.3.0",
     "ember-cli-browserstack": "^2.0.1",
     "ensure-posix-path": "^1.1.1",
-    "eslint": "^8.40.0",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-import-resolver-typescript": "^3.5.5",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.7.0",
-    "eslint-plugin-qunit": "^7.3.4",
+    "eslint": "^8.53.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "npm:eslint-plugin-i@^2.28.1",
+    "eslint-plugin-n": "^16.2.0",
+    "eslint-plugin-qunit": "^8.0.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
-    "eslint-plugin-unused-imports": "^2.0.0",
-    "execa": "^7.1.1",
-    "fast-glob": "^3.2.12",
-    "glob": "^10.2.3",
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "esyes": "^1.0.1",
+    "execa": "^8.0.1",
+    "fast-glob": "^3.3.1",
+    "glob": "^10.3.10",
     "js-yaml": "^4.1.0",
     "loader.js": "^4.7.0",
     "mkdirp": "^3.0.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.8.8",
-    "preval.macro": "^5.0.0",
-    "puppeteer": "^20.1.2",
-    "puppeteer-chromium-resolver": "^20.0.0",
-    "qunit": "^2.19.4",
+    "prettier": "^3.0.3",
+    "prettier-plugin-organize-imports": "^3.2.3",
+    "puppeteer": "^21.5.0",
+    "puppeteer-chromium-resolver": "^21.0.0",
+    "qunit": "^2.20.0",
     "release-it": "^16.2.1",
-    "rimraf": "^5.0.0",
-    "rollup": "^3.21.6",
-    "semver": "^7.5.2",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.3.0",
+    "semver": "^7.5.4",
     "testem-failure-only-reporter": "^1.0.0",
     "toml": "^3.0.0",
     "ts-node": "^10.9.1",
-    "turbo": "^1.9.3",
-    "typescript": "^5.0.4",
-    "vite": "^4.3.9",
-    "xo": "^0.54.2"
+    "turbo": "^1.10.16",
+    "typescript": "^5.2.2",
+    "vite": "^4.5.0",
+    "vite-plugin-babel": "^1.1.3",
+    "xo": "^0.56.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org"
@@ -156,7 +160,7 @@
     "node": ">=16.0.0"
   },
   "volta": {
-    "node": "20.1.0",
-    "pnpm": "8.5.0"
+    "node": "21.1.0",
+    "pnpm": "8.6.12"
   }
 }
diff --git a/packages/@glimmer-workspace/.eslintrc.cjs b/packages/@glimmer-workspace/.eslintrc.cjs
index 77b2a142fd..9ec3e64b29 100644
--- a/packages/@glimmer-workspace/.eslintrc.cjs
+++ b/packages/@glimmer-workspace/.eslintrc.cjs
@@ -1,30 +1,141 @@
-const { resolve } = require('path');
+const { existsSync, readFileSync } = require('fs');
+const { resolve, relative, dirname } = require('path');
 
-const tsconfig = resolve(__dirname, 'tsconfig.json');
+const glob = require('fast-glob');
+
+const libs = glob.sync(['tsconfig.json', '*/tsconfig.json'], {
+  cwd: __dirname,
+  absolute: true,
+});
+
+const tests = glob.sync(['tsconfig.json', '*/test/tsconfig.json'], {
+  cwd: __dirname,
+  absolute: true,
+});
+
+const testDirs = glob.sync(['*/test'], {
+  cwd: __dirname,
+  absolute: true,
+  onlyDirectories: true,
+  ignore: ['**/node_modules/**'],
+});
+
+/**
+ * @type {Record<string, Record<string, string[] | undefined>>}
+ */
+const RESTRICTIONS = {};
+
+for (const dir of testDirs) {
+  const pkgRoot = dirname(dir);
+
+  if (!existsSync(resolve(dir, 'package.json'))) {
+    // don't create rules if the tests dir doesn't have a package.json
+    continue;
+  }
+
+  const packageName = JSON.parse(readFileSync(resolve(pkgRoot, 'package.json'), 'utf8')).name;
+
+  const files = glob.sync(['**/*.{js,ts,d.ts}'], {
+    cwd: dir,
+    absolute: true,
+    onlyFiles: true,
+    ignore: ['**/node_modules/**'],
+  });
+
+  for (const file of files) {
+    const relativeFile = `./${relative(__dirname, file)}`;
+    const relativeToLib = relative(dirname(file), resolve(dirname(dir), 'lib'));
+
+    const pkg = (RESTRICTIONS[packageName] ??= {});
+
+    if (pkg[relativeToLib]) {
+      pkg[relativeToLib].push(relativeFile);
+    } else {
+      pkg[relativeToLib] = [relativeFile];
+    }
+  }
+}
+
+/**
+ * @type {import("eslint").Linter.Config["overrides"]}
+ */
+const overrides = Object.entries(RESTRICTIONS).flatMap(([pkgName, overrides]) =>
+  Object.entries(overrides).map(([lib, files]) => ({
+    files,
+    rules: {
+      '@typescript-eslint/no-restricted-imports': [
+        'error',
+        {
+          paths: [
+            {
+              name: lib,
+              message: `Import from ${pkgName} instead`,
+            },
+          ],
+        },
+      ],
+    },
+  }))
+);
+
+// console.dir({ overrides }, { depth: null });
 
 /** @type {import("eslint").Linter.Config} */
 module.exports = {
   root: false,
   overrides: [
     {
-      files: ['*/index.{js,ts,d.ts}', '*/lib/**/*.{js,ts,d.ts}', '*/test/**/*.{js,ts,d.ts}'],
+      files: ['*/lib/**/*.{js,cjs,mjs,ts,d.ts}'],
+      excludedFiles: ['node_modules', '*/node_modules'],
+      parserOptions: {
+        project: libs,
+      },
+      plugins: ['@glimmer-workspace'],
+      extends: ['plugin:@glimmer-workspace/recommended'],
+    },
+    {
+      files: ['*/lib/**/*.cjs'],
+      env: {
+        node: true,
+      },
       excludedFiles: ['node_modules', '*/node_modules'],
       parserOptions: {
-        ecmaVersion: 'latest',
-        project: [tsconfig],
+        project: libs,
       },
       plugins: ['@glimmer-workspace'],
       extends: ['plugin:@glimmer-workspace/recommended'],
+      rules: {
+        '@typescript-eslint/no-require-imports': 'off',
+        '@typescript-eslint/no-var-requires': 'off',
+        'no-undef': 'off',
+      },
+    },
+    {
+      files: ['./integration-tests/{lib,test}/**/*.ts'],
+      rules: {
+        // off for now
+        '@typescript-eslint/no-explicit-any': 'off',
+      },
     },
     // QUnit is a weird package, and there are some issues open about fixing it
     // - https://github.com/qunitjs/qunit/issues/1729
     // - https://github.com/qunitjs/qunit/issues/1727
     // - https://github.com/qunitjs/qunit/issues/1724
     {
-      files: ['**/*-test.ts', '**/{test,integration-tests}/**/*.ts'],
+      files: ['*/test/**/*.{js,ts,d.ts}'],
+      parserOptions: {
+        project: tests,
+      },
+      plugins: ['@glimmer-workspace'],
+      extends: ['plugin:@glimmer-workspace/recommended'],
       rules: {
         '@typescript-eslint/unbound-method': 'off',
+        // off for now
+        '@typescript-eslint/no-explicit-any': 'off',
+        'import/no-relative-packages': 'error',
+        'no-restricted-paths': 'off',
       },
     },
+    ...overrides,
   ],
 };
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/args-proxy.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/args-proxy.ts
index d8183833fe..fb338e2a6c 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/args-proxy.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/args-proxy.ts
@@ -1,5 +1,5 @@
-import type { CapturedArguments, CapturedNamedArguments, Reference } from '@glimmer/interfaces';
-import { valueForRef } from '@glimmer/reference';
+import type { CapturedArguments, CapturedNamedArguments, Reactive } from '@glimmer/interfaces';
+import { unwrapReactive } from '@glimmer/reference';
 
 import type { ComponentArgs } from '../interfaces';
 
@@ -18,7 +18,7 @@ class ArgsProxy implements ProxyHandler<CapturedNamedArguments> {
   ): PropertyDescriptor | undefined {
     let desc: PropertyDescriptor | undefined;
     if (typeof p === 'string' && p in target) {
-      const value = valueForRef(target[p] as Reference);
+      const value = unwrapReactive(target[p] as Reactive);
       desc = {
         enumerable: true,
         configurable: false,
@@ -35,7 +35,7 @@ class ArgsProxy implements ProxyHandler<CapturedNamedArguments> {
 
   get(target: CapturedNamedArguments, p: PropertyKey): unknown {
     if (typeof p === 'string' && p in target) {
-      return valueForRef(target[p] as Reference);
+      return unwrapReactive(target[p] as Reactive);
     }
   }
 
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/basic-component-manager.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/basic-component-manager.ts
index 2e3e4d2612..3609ae1a8f 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/basic-component-manager.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/basic-component-manager.ts
@@ -1,15 +1,11 @@
-import type {
-  Dict,
-  Owner,
-  Template,
-  VMArguments,
-  WithCreateInstance,
-} from "@glimmer/interfaces";
+import type { Dict, Owner, Template, VMArguments, WithCreateInstance } from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
 import { getComponentTemplate } from '@glimmer/manager';
-import { createConstRef, type Reference } from '@glimmer/reference';
+import { ReadonlyCell  } from '@glimmer/reference';
 import { EMPTY_ARGS } from '@glimmer/runtime';
 
 import type { ComponentArgs } from '../interfaces';
+
 import argsProxy from './args-proxy';
 
 const BASIC_COMPONENT_CAPABILITIES = {
@@ -29,7 +25,7 @@ const BASIC_COMPONENT_CAPABILITIES = {
 };
 
 interface BasicState {
-  self: Reference<unknown>;
+  self: Reactive<unknown>;
   instance: object;
 }
 
@@ -42,7 +38,7 @@ class BasicComponentManager
     args: VMArguments | null
   ) {
     const instance = new Component(argsProxy(args === null ? EMPTY_ARGS : args.capture()));
-    const self = createConstRef(instance, 'this');
+    const self = ReadonlyCell(instance, 'this');
     return { instance, self };
   }
 
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-env-delegate.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-env-delegate.ts
index 6f53f90c2a..9c3ed731f8 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-env-delegate.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-env-delegate.ts
@@ -1,11 +1,13 @@
 /* eslint-disable no-console */
 
-import setGlobalContext from '@glimmer/global-context';
 import type { Destroyable, Destructor, RenderResult } from '@glimmer/interfaces';
 import type { EnvironmentDelegate } from '@glimmer/runtime';
+import setGlobalContext from '@glimmer/global-context';
 
 type Queue = (() => void)[];
 
+type Dict<T = unknown> = object & Record<string, T>;
+
 const scheduledDestructors: Queue = [];
 const scheduledFinalizers: Queue = [];
 
@@ -51,6 +53,14 @@ setGlobalContext({
     (obj as Record<string, unknown>)[prop] = value;
   },
 
+  setProperty<T extends Dict, K extends keyof T>(parent: T, key: K, value: T[K]) {
+    Reflect.set(parent, key, value);
+  },
+
+  getProperty<T extends Dict, K extends keyof T>(parent: T, key: K) {
+    return Reflect.get(parent, key);
+  },
+
   getPath(obj: unknown, path: string) {
     let parts = path.split('.');
 
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-registry.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-registry.ts
index 4429f376fd..f4d86c52fa 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-registry.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/create-registry.ts
@@ -17,6 +17,7 @@ import { programCompilationContext } from '@glimmer/opcode-compiler';
 import { artifacts, RuntimeOpImpl } from '@glimmer/program';
 
 import type { UpdateBenchmark } from '../interfaces';
+
 import renderBenchmark from './render-benchmark';
 
 export interface Registry {
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/on-modifier.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/on-modifier.ts
index 33597adf88..a95c7877e2 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/on-modifier.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/on-modifier.ts
@@ -1,30 +1,45 @@
 import type {
   CapturedArguments,
+  DevMode,
   InternalModifierManager,
   Owner,
   SimpleElement,
-} from "@glimmer/interfaces";
-import { type Reference, valueForRef } from '@glimmer/reference';
-import { castToBrowser } from '@glimmer/util';
+  TagDescription,
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import { unwrapReactive } from '@glimmer/reference';
+import { castToBrowser, devmode, getDescription, setDescription } from '@glimmer/util';
 import { createUpdatableTag } from '@glimmer/validator';
 
 interface OnModifierState {
   element: SimpleElement;
-  nameRef: Reference<string>;
-  listenerRef: Reference<EventListener>;
+  nameRef: Reactive<string>;
+  listenerRef: Reactive<EventListener>;
   name: string | null;
   listener: EventListener | null;
+  description: DevMode<TagDescription>;
 }
 
 class OnModifierManager implements InternalModifierManager<OnModifierState, object> {
   create(_owner: Owner, element: SimpleElement, _: {}, args: CapturedArguments) {
-    return {
+    const state = {
       element,
-      nameRef: args.positional[0] as Reference<string>,
-      listenerRef: args.positional[1] as Reference<EventListener>,
+      nameRef: args.positional[0] as Reactive<string>,
+      listenerRef: args.positional[1] as Reactive<EventListener>,
       name: null,
       listener: null,
     };
+    setDescription(
+      state,
+      devmode(
+        () =>
+          ({
+            reason: 'modifier',
+            label: ['on'],
+          }) satisfies TagDescription
+      )
+    );
+    return state;
   }
 
   getDebugName() {
@@ -32,8 +47,8 @@ class OnModifierManager implements InternalModifierManager<OnModifierState, obje
   }
 
   install(state: OnModifierState) {
-    const name = valueForRef(state.nameRef);
-    const listener = valueForRef(state.listenerRef);
+    const name = unwrapReactive(state.nameRef);
+    const listener = unwrapReactive(state.listenerRef);
     castToBrowser(state.element, 'ELEMENT').addEventListener(name, listener);
     state.listener = listener;
     state.name = name;
@@ -41,8 +56,8 @@ class OnModifierManager implements InternalModifierManager<OnModifierState, obje
 
   update(state: OnModifierState) {
     const element = castToBrowser(state.element, 'ELEMENT');
-    const name = valueForRef(state.nameRef);
-    const listener = valueForRef(state.listenerRef);
+    const name = unwrapReactive(state.nameRef);
+    const listener = unwrapReactive(state.listenerRef);
     if (name !== state.name || listener !== state.listener) {
       element.removeEventListener(state.name!, state.listener!);
       element.addEventListener(name, listener);
@@ -55,8 +70,8 @@ class OnModifierManager implements InternalModifierManager<OnModifierState, obje
     return state;
   }
 
-  getTag() {
-    return createUpdatableTag();
+  getTag(state: OnModifierState) {
+    return createUpdatableTag(getDescription(state));
   }
 }
 
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/render-benchmark.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/render-benchmark.ts
index d68e878215..ef9d13e7aa 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/render-benchmark.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/render-benchmark.ts
@@ -1,6 +1,6 @@
 import type {
-  CompileTimeCompilationContext,
   Dict,
+  JitContext,
   ResolvedComponentDefinition,
   RuntimeArtifacts,
   RuntimeResolver,
@@ -9,12 +9,13 @@ import type {
 import { NewElementBuilder, renderComponent, renderSync, runtimeContext } from '@glimmer/runtime';
 
 import type { UpdateBenchmark } from '../interfaces';
+
 import createEnvDelegate, { registerResult } from './create-env-delegate';
 import { measureRender } from './util';
 
 export default async function renderBenchmark(
   artifacts: RuntimeArtifacts,
-  context: CompileTimeCompilationContext,
+  context: JitContext,
   runtimeResolver: RuntimeResolver,
   component: ResolvedComponentDefinition,
   args: Dict,
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/util.ts b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/util.ts
index 7d9d8256f8..c75aec5cae 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/benchmark/util.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/benchmark/util.ts
@@ -1,10 +1,10 @@
 import type {
-  CompileTimeCompilationContext,
   CompileTimeComponent,
+  JitContext,
 } from "@glimmer/interfaces";
 import { unwrapHandle } from '@glimmer/util';
 
-export function compileEntry(entry: CompileTimeComponent, context: CompileTimeCompilationContext) {
+export function compileEntry(entry: CompileTimeComponent, context: JitContext) {
   return unwrapHandle(entry.compilable!.compile(context));
 }
 
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/create-benchmark.ts b/packages/@glimmer-workspace/benchmark-env/lib/create-benchmark.ts
index cf53503a2d..412f7397c7 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/create-benchmark.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/create-benchmark.ts
@@ -2,10 +2,11 @@ import { setComponentTemplate, setInternalComponentManager } from '@glimmer/mana
 import { templateFactory } from '@glimmer/opcode-compiler';
 import { templateOnlyComponent } from '@glimmer/runtime';
 
+import type { Benchmark } from './interfaces';
+
 import basicComponentManager from './benchmark/basic-component-manager';
 import createRegistry from './benchmark/create-registry';
 import onModifier from './benchmark/on-modifier';
-import type { Benchmark } from './interfaces';
 
 export default function createBenchmark(): Benchmark {
   const registry = createRegistry();
diff --git a/packages/@glimmer-workspace/benchmark-env/lib/create-cell.ts b/packages/@glimmer-workspace/benchmark-env/lib/create-cell.ts
index 400bf9d357..cde57c0a02 100644
--- a/packages/@glimmer-workspace/benchmark-env/lib/create-cell.ts
+++ b/packages/@glimmer-workspace/benchmark-env/lib/create-cell.ts
@@ -1,11 +1,5 @@
-import {
-  consumeTag,
-  dirtyTagFor,
-  tagFor,
-  type TagMeta,
-  tagMetaFor,
-  type UpdatableTag,
-} from '@glimmer/validator';
+import type { TagMeta, UpdatableTag } from '@glimmer/validator';
+import { consumeTag, dirtyTagFor, tagFor, tagMetaFor } from '@glimmer/validator';
 
 import type { Cell } from './interfaces';
 
diff --git a/packages/@glimmer-workspace/build/index.js b/packages/@glimmer-workspace/build/index.js
deleted file mode 100644
index 480f7fba41..0000000000
--- a/packages/@glimmer-workspace/build/index.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export { Package } from './lib/config.js';
-export { default as importMeta } from './lib/import-meta.js';
-export { default as inline } from './lib/inline.js';
diff --git a/packages/@glimmer-workspace/build/lib/config.js b/packages/@glimmer-workspace/build/lib/config.js
index 2cb782079b..7d7bbfd6cb 100644
--- a/packages/@glimmer-workspace/build/lib/config.js
+++ b/packages/@glimmer-workspace/build/lib/config.js
@@ -63,7 +63,6 @@ export function tsconfig(updates) {
     verbatimModuleSyntax: true,
     module: ModuleKind.NodeNext,
     moduleResolution: ModuleResolutionKind.NodeNext,
-    experimentalDecorators: true,
     ...updates,
   };
 }
@@ -310,7 +309,7 @@ export class Package {
         typescript(this.#package, {
           target: ScriptTarget.ES2021,
           module: ModuleKind.CommonJS,
-          moduleResolution: ModuleResolutionKind.NodeJs,
+          moduleResolution: ModuleResolutionKind.Bundler,
         }),
       ],
     }));
diff --git a/packages/@glimmer-workspace/build/index.d.ts b/packages/@glimmer-workspace/build/lib/index.d.ts
similarity index 51%
rename from packages/@glimmer-workspace/build/index.d.ts
rename to packages/@glimmer-workspace/build/lib/index.d.ts
index 8442f97f0b..c1b44b2f7f 100644
--- a/packages/@glimmer-workspace/build/index.d.ts
+++ b/packages/@glimmer-workspace/build/lib/index.d.ts
@@ -3,5 +3,5 @@ export {
   type PackageInfo,
   type PackageJSON,
   type ViteConfig as ViteExport,
-} from './lib/config.js';
-export { default as importMeta } from './lib/import-meta.js';
+} from './config.js';
+export { default as importMeta } from './import-meta.js';
diff --git a/packages/@glimmer-workspace/build/lib/index.js b/packages/@glimmer-workspace/build/lib/index.js
new file mode 100644
index 0000000000..8a1c001b0b
--- /dev/null
+++ b/packages/@glimmer-workspace/build/lib/index.js
@@ -0,0 +1,3 @@
+export { Package } from './config.js';
+export { default as importMeta } from './import-meta.js';
+export { default as inline } from './inline.js';
diff --git a/packages/@glimmer-workspace/build/package.json b/packages/@glimmer-workspace/build/package.json
index 1e61db1f0f..cbdef48f39 100644
--- a/packages/@glimmer-workspace/build/package.json
+++ b/packages/@glimmer-workspace/build/package.json
@@ -3,13 +3,13 @@
   "name": "@glimmer-workspace/build-support",
   "type": "module",
   "version": "1.0.0",
-  "main": "index.mjs",
-  "types": "index.d.mts",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
   "engines": {
     "node": ">=16"
   },
   "exports": {
-    "default": "./index.js"
+    "default": "./lib/index.js"
   },
   "starbeam": {
     "source": "js:typed",
@@ -20,25 +20,25 @@
     "test:types": "tsc --noEmit -p ../tsconfig.json"
   },
   "dependencies": {
-    "@rollup/plugin-commonjs": "^24.1.0",
-    "@rollup/plugin-node-resolve": "^15.0.2",
     "eslint": "^8.40.0",
     "eslint-plugin-import": "^2.27.5",
     "eslint-plugin-json": "^3.1.0",
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-simple-import-sort": "^10.0.0",
-    "eslint-plugin-unused-imports": "^2.0.0",
-    "magic-string": "^0.30.0",
+    "eslint-plugin-unused-imports": "^3.0.0",
     "postcss": "^8.4.31",
-    "rollup": "^3.21.6",
+    "@rollup/plugin-commonjs": "^25.0.4",
+    "@rollup/plugin-node-resolve": "^15.2.0",
+    "magic-string": "^0.30.3",
+    "rollup": "^3.28.0",
     "rollup-plugin-polyfill-node": "^0.12.0",
     "rollup-plugin-postcss": "^4.0.2",
-    "rollup-plugin-ts": "^3.2.0",
+    "rollup-plugin-ts": "^3.4.4",
     "unplugin-fonts": "^1.0.3",
-    "vite": "4.3.9"
+    "vite": "4.4.9"
   },
   "devDependencies": {
-    "@types/node": "^18.16.6",
+    "@types/node": "*",
     "typescript": "*"
   }
 }
diff --git a/packages/@glimmer-workspace/build/tsconfig.json b/packages/@glimmer-workspace/build/tsconfig.json
new file mode 100644
index 0000000000..0cea37921d
--- /dev/null
+++ b/packages/@glimmer-workspace/build/tsconfig.json
@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "outDir": "dist",
+
+    "allowJs": true,
+    "checkJs": true,
+
+    "target": "esnext",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "verbatimModuleSyntax": true,
+
+    "strict": true,
+    "suppressImplicitAnyIndexErrors": false,
+    "useDefineForClassFields": false,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUncheckedIndexedAccess": true,
+    "skipLibCheck": true,
+    "types": ["qunit", "node", "vite/client"]
+  },
+  "include": ["./lib/**/*.*"]
+}
diff --git a/packages/@glimmer-workspace/eslint-plugin/index.js b/packages/@glimmer-workspace/eslint-plugin/lib/index.cjs
similarity index 57%
rename from packages/@glimmer-workspace/eslint-plugin/index.js
rename to packages/@glimmer-workspace/eslint-plugin/lib/index.cjs
index e0a5f52cf0..f95197c168 100644
--- a/packages/@glimmer-workspace/eslint-plugin/index.js
+++ b/packages/@glimmer-workspace/eslint-plugin/lib/index.cjs
@@ -8,12 +8,30 @@ module.exports = {
   },
   configs: {
     recommended: {
+      settings: {
+        'import/parsers': {
+          '@typescript-eslint/parser': ['.js', '.cjs', '.mjs', '.mts', '.ts', '.d.ts'],
+        },
+        'import/resolver': {
+          typescript: {
+            alwaysTryTypes: true,
+          },
+        },
+        node: {
+          allowModules: ['@glimmer/debug', '@glimmer/local-debug-flags'],
+          tryExtensions: ['.cjs', '.js', '.ts', '.d.ts', '.json'],
+        },
+      },
+      env: {
+        es6: true,
+      },
       plugins: [
         '@typescript-eslint',
         'prettier',
         'qunit',
         'simple-import-sort',
         'unused-imports',
+        'import',
         'prettier',
         'n',
       ],
@@ -21,20 +39,36 @@ module.exports = {
         'eslint:recommended',
         'plugin:@typescript-eslint/recommended',
         'plugin:@typescript-eslint/recommended-requiring-type-checking',
-        'plugin:n/recommended',
+        'plugin:n/recommended-module',
         'plugin:import/recommended',
         'plugin:qunit/recommended',
         'plugin:regexp/recommended',
+        'plugin:deprecation/recommended',
         'prettier',
       ],
       rules: {
+        'prefer-arrow-callback': 'error',
+        'no-restricted-imports': 'off',
+        'no-inner-declarations': 'off',
+        '@typescript-eslint/no-restricted-imports': [
+          'error',
+          {
+            patterns: [
+              { group: ['**/generated/**'], message: "Don't import directly from generated files" },
+              {
+                group: ['console', 'node:console'],
+                message: "Don't import directly from 'console'",
+              },
+            ],
+          },
+        ],
+        '@typescript-eslint/no-redundant-type-constituents': 'off',
         'no-console': 'error',
         'no-debugger': 'error',
         'no-loop-func': 'error',
         'prefer-const': 'off',
         'no-fallthrough': 'off',
-        'import/no-relative-packages': 'error',
-        'import/default': 'off',
+
         'qunit/require-expect': ['error', 'never-except-zero'],
         // we're using assert.step instead of this sort of thing
         'qunit/no-conditional-assertions': 'off',
@@ -50,27 +84,11 @@ module.exports = {
         'regexp/prefer-regexp-exec': 'error',
         'regexp/prefer-quantifier': 'error',
         'require-unicode-regexp': 'off',
-        'unused-imports/no-unused-imports': 'error',
-        'unused-imports/no-unused-vars': [
-          'warn',
-          { vars: 'all', varsIgnorePattern: '^_', args: 'after-used', argsIgnorePattern: '^_' },
-        ],
-        'n/no-unpublished-require': 'off',
-        '@typescript-eslint/no-explicit-any': 'off',
+        '@typescript-eslint/no-explicit-any': 'warn',
         '@typescript-eslint/ban-types': 'off',
         '@typescript-eslint/no-non-null-assertion': 'off',
-        '@typescript-eslint/consistent-type-imports': [
-          'error',
-          {
-            fixStyle: 'separate-type-imports',
-          },
-        ],
-        '@typescript-eslint/consistent-type-exports': [
-          'error',
-          {
-            fixMixedExportsWithInlineTypeSpecifier: true,
-          },
-        ],
+        '@typescript-eslint/consistent-type-imports': 'error',
+        '@typescript-eslint/consistent-type-exports': 'error',
         '@typescript-eslint/no-import-type-side-effects': 'error',
         '@typescript-eslint/naming-convention': [
           'error',
@@ -105,7 +123,66 @@ module.exports = {
         '@typescript-eslint/no-unsafe-member-access': 'off',
         '@typescript-eslint/no-unsafe-call': 'off',
         '@typescript-eslint/restrict-template-expressions': 'off',
+
         'n/no-missing-import': 'off',
+        'unused-imports/no-unused-imports': 'error',
+        'unused-imports/no-unused-vars': [
+          'error',
+          { vars: 'all', varsIgnorePattern: '^_', args: 'after-used', argsIgnorePattern: '^_' },
+        ],
+        'n/no-unpublished-require': 'off',
+        'import/consistent-type-specifier-style': 'error',
+        'import/no-relative-packages': 'error',
+        'import/default': 'off',
+        'import/no-unresolved': 'error',
+        'import/no-extraneous-dependencies': 'error',
+        'sort-imports': 'off',
+        'simple-import-sort/imports': [
+          'error',
+          {
+            groups: [
+              // == Side effect imports. ==
+              ['^\\u0000'],
+
+              // == from node:* ==
+              [
+                //
+                '^node:.+\\u0000$',
+                '^node:',
+              ],
+
+              // == From (optionally scoped) packages
+              [
+                // import type
+                '^@?\\w.+\\u0000$',
+                '^@?\\w',
+              ],
+
+              // == from absolute imports ==
+              //
+              // (Absolute imports and other imports such as Vue-style `@/foo`. Anything not matched
+              // in another group.)
+              [
+                // import type
+                '^.+\\u0000$',
+                '^',
+              ],
+
+              // == Relative imports ==.
+              [
+                // import type
+                '^\\..+\\u0000$',
+                '^\\.',
+              ],
+            ],
+          },
+        ],
+        'simple-import-sort/exports': 'error',
+        'no-unused-private-class-members': 'error',
+        'import/first': 'error',
+        'import/newline-after-import': 'error',
+        'import/no-duplicates': 'error',
+
         'n/no-unsupported-features/es-syntax': 'off',
         'n/no-unsupported-features/node-builtins': 'off',
       },
diff --git a/packages/@glimmer-workspace/eslint-plugin/package.json b/packages/@glimmer-workspace/eslint-plugin/package.json
index 24ec828dd4..671ab3ccdc 100644
--- a/packages/@glimmer-workspace/eslint-plugin/package.json
+++ b/packages/@glimmer-workspace/eslint-plugin/package.json
@@ -1,24 +1,30 @@
 {
   "name": "@glimmer-workspace/eslint-plugin",
   "private": true,
-  "main": "index.js",
+  "type": "commonjs",
+  "main": "lib/index.cjs",
   "dependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.59.5",
-    "@typescript-eslint/parser": "^5.59.5",
-    "eslint-config-prettier": "^8.8.0",
-    "eslint-import-resolver-typescript": "^3.5.5",
-    "eslint-plugin-import": "^2.27.5",
-    "eslint-plugin-n": "^15.7.0",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "@typescript-eslint/parser": "^6.4.0",
+    "eslint-config-prettier": "^9.0.0",
+    "eslint-import-resolver-typescript": "^3.6.0",
+    "eslint-plugin-import": "^2.28.0",
+    "eslint-plugin-n": "^16.0.1",
     "eslint-plugin-regexp": "^1.15.0",
-    "eslint-plugin-qunit": "^7.3.4",
+    "eslint-plugin-qunit": "^8.0.0",
     "eslint-plugin-simple-import-sort": "^10.0.0",
-    "eslint-plugin-unused-imports": "^2.0.0"
+    "eslint-plugin-unused-imports": "^3.0.0",
+    "eslint-plugin-deprecation": "^1.5.0",
+    "eslint-utils": "^3.0.0",
+    "ignore": "^5.2.4"
   },
   "peerDependencies": {
-    "eslint": "^8.40.0"
+    "eslint": "^8.47.0"
   },
   "devDependencies": {
-    "eslint": "^8.40.0",
-    "@types/eslint": "^8.37.0"
+    "eslint": "^8.47.0",
+    "@types/eslint": "^8.44.2",
+    "@types/eslint-utils": "^3.0.4",
+    "@types/node": "^20.8.10"
   }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/index.ts b/packages/@glimmer-workspace/integration-tests/index.ts
deleted file mode 100644
index 83c13f6c91..0000000000
--- a/packages/@glimmer-workspace/integration-tests/index.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import './lib/setup';
-
-export * from './lib/base-env';
-export * from './lib/compile';
-export * from './lib/components';
-export * from './lib/dom/assertions';
-export * from './lib/dom/blocks';
-export * from './lib/dom/simple-utils';
-export * from './lib/markers';
-export * from './lib/modes/env';
-export * from './lib/modes/jit/delegate';
-export * from './lib/modes/jit/register';
-export * from './lib/modes/jit/resolver';
-export * from './lib/modes/node/env';
-export * from './lib/modes/rehydration/delegate';
-export * from './lib/modes/rehydration/partial-rehydration-delegate';
-export type { RenderDelegateOptions } from './lib/render-delegate';
-export * from './lib/render-test';
-export * from './lib/setup-harness';
-export * from './lib/snapshot';
-export * from './lib/suites';
-export * from './lib/test-helpers/define';
-export * from './lib/test-helpers/module';
-export * from './lib/test-helpers/strings';
-export * from './lib/test-helpers/test';
-export * from './lib/test-helpers/tracked';
-export * from './lib/test-helpers/tracked-object';
-export { syntaxErrorFor } from '@glimmer-workspace/test-utils';
diff --git a/packages/@glimmer-workspace/integration-tests/lib/assertions.ts b/packages/@glimmer-workspace/integration-tests/lib/assertions.ts
new file mode 100644
index 0000000000..922fb30054
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/assertions.ts
@@ -0,0 +1,24 @@
+export function notThrows(callback: () => void, message?: string): void;
+export function notThrows(callback: () => Promise<void>, message?: string): Promise<void>;
+export function notThrows(
+  callback: () => void | Promise<void>,
+  message = 'expected callback to not throw'
+): void | Promise<void> {
+  try {
+    const result = callback();
+
+    if (result) {
+      return result
+        .then(() => {
+          QUnit.assert.ok(true, message);
+        })
+        .catch((e) => {
+          QUnit.assert.notOk(e, message);
+        });
+    } else {
+      QUnit.assert.ok(true, message);
+    }
+  } catch (e) {
+    QUnit.assert.ok(false, message);
+  }
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/compile.ts b/packages/@glimmer-workspace/integration-tests/lib/compile.ts
index 9238ada29d..169dba10d2 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/compile.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/compile.ts
@@ -1,12 +1,12 @@
-import { precompileJSON } from '@glimmer/compiler';
 import type {
   Nullable,
   SerializedTemplateWithLazyBlock,
   Template,
   TemplateFactory,
 } from '@glimmer/interfaces';
-import { templateFactory } from '@glimmer/opcode-compiler';
 import type { PrecompileOptions } from '@glimmer/syntax';
+import { precompileJSON } from '@glimmer/compiler';
+import { templateFactory } from '@glimmer/opcode-compiler';
 
 // TODO: This fundamentally has little to do with testing and
 // most tests should just use a more generic preprocess, extracted
diff --git a/packages/@glimmer-workspace/integration-tests/lib/components/build.ts b/packages/@glimmer-workspace/integration-tests/lib/components/build.ts
new file mode 100644
index 0000000000..1b014c6ebc
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/components/build.ts
@@ -0,0 +1,70 @@
+import type { Dict, Maybe } from '@glimmer/interfaces';
+
+import type { BuildStyle } from './delegate';
+
+export class InvocationBuilder {
+  static ANGLE = new InvocationBuilder('angle');
+  static CURLIES = new InvocationBuilder('curlies');
+
+  readonly #style: BuildStyle;
+
+  constructor(style: BuildStyle) {
+    this.#style = style;
+  }
+
+  args(args: Dict): string {
+    return buildArgs(ARGS[this.#style])(args);
+  }
+
+  attributes(attrs: Dict = {}) {
+    return buildArgs(ATTRS[this.#style])(attrs);
+  }
+
+  blockParams(blockParams: string[]): string {
+    return `${blockParams.length > 0 ? ` as |${blockParams.join(' ')}|` : ''}`;
+  }
+
+  else(elseBlock: string | undefined): string {
+    return `${elseBlock ? `{{else}}${elseBlock}` : ''}`;
+  }
+}
+
+const ARGS = {
+  angle: { sigil: '@', curlies: true },
+  curlies: { sigil: '', curlies: false },
+} as const;
+
+const ATTRS = {
+  angle: { sigil: '', curlies: true },
+  curlies: { sigil: '', curlies: false },
+} as const;
+
+export function buildArgs({
+  sigil,
+  curlies,
+}: {
+  sigil: string;
+  curlies: boolean;
+}): (args: Dict) => string {
+  return (args) => {
+    return `${Object.keys(args)
+      .map((arg) => {
+        let rightSide: string;
+
+        let value = args[arg] as Maybe<string[]>;
+        if (curlies) {
+          let isString = value && (value[0] === "'" || value[0] === '"');
+          if (isString) {
+            rightSide = `${value}`;
+          } else {
+            rightSide = `{{${value}}}`;
+          }
+        } else {
+          rightSide = `${value}`;
+        }
+
+        return `${sigil}${arg}=${rightSide}`;
+      })
+      .join(' ')}`;
+  };
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/components/delegate.ts b/packages/@glimmer-workspace/integration-tests/lib/components/delegate.ts
new file mode 100644
index 0000000000..b0812e1435
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/components/delegate.ts
@@ -0,0 +1,143 @@
+import type { Dict, Nullable, SimpleElement } from '@glimmer/interfaces';
+
+import type { TestJitRegistry } from '../modes/jit/registry';
+import type { DeclaredComponentType } from '../test-helpers/constants';
+import type { BuildInvocation, BuildTemplate } from './styles';
+import type { ComponentBlueprint, ComponentTypes } from './types';
+
+import { assertElementShape, assertEmberishElement } from '../dom/assertions';
+import {
+  registerEmberishCurlyComponent,
+  registerGlimmerishComponent,
+  registerTemplateOnlyComponent,
+} from '../modes/jit/register';
+import {
+  BuildCurlyInvoke,
+  BuildCurlyTemplate,
+  BuildDynamicInvoke,
+  BuildDynamicTemplate,
+  BuildGlimmerInvoke,
+  BuildGlimmerTemplate,
+} from './styles';
+
+export function buildTemplate<K extends DeclaredComponentType>(
+  delegate: ComponentDelegate<K>,
+  component: ComponentBlueprint
+): string {
+  const build = delegate.build;
+
+  const template = build.template(component);
+  QUnit.assert.ok(true, `generated ${delegate.type} layout as ${template}`);
+
+  return template;
+}
+
+export function buildInvoke<K extends DeclaredComponentType>(
+  delegate: ComponentDelegate<K>,
+  component: ComponentBlueprint
+): { name: string; invocation: string } {
+  const build = delegate.build;
+
+  const invocation = build.invoke(component);
+  QUnit.assert.ok(
+    true,
+    `generated ${delegate.type} invocation as ${invocation.invocation} (name=${invocation.name})`
+  );
+
+  return invocation;
+}
+
+export interface BuildDelegate {
+  style: BuildStyle;
+  template: BuildTemplate;
+  invoke: BuildInvocation;
+}
+
+export interface ComponentDelegate<K extends DeclaredComponentType = DeclaredComponentType> {
+  readonly type: K;
+
+  register: (
+    registry: TestJitRegistry,
+    name: string,
+    layout: Nullable<string>,
+    Class?: ComponentTypes[K]
+  ) => void;
+
+  assert: (element: SimpleElement, tagName: string, attrs?: Dict, contents?: string) => void;
+
+  build: BuildDelegate;
+}
+
+export type BuildStyle = 'angle' | 'curlies';
+
+export const GlimmerDelegate: ComponentDelegate<'glimmer'> = {
+  type: 'glimmer',
+  register: (registry, name, layout, Class) => {
+    registerGlimmerishComponent(registry, name, Class ?? null, layout);
+  },
+
+  assert: assertElementShape,
+
+  build: {
+    style: 'angle',
+    template: BuildGlimmerTemplate,
+    invoke: BuildGlimmerInvoke,
+  },
+};
+
+export const CurlyDelegate: ComponentDelegate<'curly'> = {
+  type: 'curly',
+  register: (registry, name, layout, Class) => {
+    registerEmberishCurlyComponent(registry, name, Class ?? null, layout);
+  },
+
+  assert: assertEmberishElement,
+
+  build: {
+    style: 'curlies',
+    template: BuildCurlyTemplate,
+    invoke: BuildCurlyInvoke,
+  },
+};
+
+export const DynamicDelegate: ComponentDelegate<'dynamic'> = {
+  type: 'dynamic',
+  register: (registry, name, layout, Class) => {
+    registerEmberishCurlyComponent(registry, name, Class ?? null, layout);
+  },
+
+  assert: assertEmberishElement,
+
+  build: {
+    style: 'curlies',
+    invoke: BuildDynamicInvoke,
+    template: BuildDynamicTemplate,
+  },
+};
+
+export const TemplateOnlyDelegate: ComponentDelegate<'templateOnly'> = {
+  type: 'templateOnly',
+  register: (registry, name, layout) => {
+    registerTemplateOnlyComponent(registry, name, layout ?? '');
+  },
+
+  assert: assertElementShape,
+
+  build: {
+    style: 'angle',
+    template: BuildGlimmerTemplate,
+    invoke: BuildGlimmerInvoke,
+  },
+};
+
+const DELEGATES = {
+  glimmer: GlimmerDelegate,
+  curly: CurlyDelegate,
+  dynamic: DynamicDelegate,
+  templateOnly: TemplateOnlyDelegate,
+} as const satisfies { [K in DeclaredComponentType]: ComponentDelegate<K> };
+type DELEGATES = typeof DELEGATES;
+
+export const getDelegate = <K extends DeclaredComponentType>(type: K): ComponentDelegate<K> => {
+  return DELEGATES[type] as ComponentDelegate<K>;
+};
diff --git a/packages/@glimmer-workspace/integration-tests/lib/components/emberish-curly.ts b/packages/@glimmer-workspace/integration-tests/lib/components/emberish-curly.ts
index 0dd63560f0..f31987858f 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/components/emberish-curly.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/components/emberish-curly.ts
@@ -1,6 +1,5 @@
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
-  Bounds,
+  BlockBounds,
   CapturedNamedArguments,
   CompilableProgram,
   Destroyable,
@@ -12,30 +11,27 @@ import type {
   Nullable,
   Owner,
   PreparedArguments,
-  Reference,
+  Reactive,
+  TagDescription,
   Template,
   VMArguments,
   WithCreateInstance,
   WithDynamicLayout,
   WithDynamicTagName,
 } from '@glimmer/interfaces';
+import type { DirtyableTag } from '@glimmer/validator';
+import { registerDestructor } from '@glimmer/destroyable';
 import { setInternalComponentManager } from '@glimmer/manager';
 import {
-  childRefFor,
-  createComputeRef,
-  createConstRef,
-  createPrimitiveRef,
-  valueForRef,
+  createPrimitiveCell,
+  Formula,
+  getReactiveProperty,
+  ReadonlyCell,
+  unwrapReactive,
 } from '@glimmer/reference';
 import { reifyNamed, reifyPositional } from '@glimmer/runtime';
-import { assign, EMPTY_ARRAY, keys, unwrapTemplate } from '@glimmer/util';
-import {
-  consumeTag,
-  createTag,
-  type DirtyableTag,
-  dirtyTag,
-  dirtyTagFor,
-} from '@glimmer/validator';
+import { assign, devmode, EMPTY_ARRAY, keys, unwrapTemplate } from '@glimmer/util';
+import { consumeTag, createTag, dirtyTag, dirtyTagFor } from '@glimmer/validator';
 
 import type { TestJitRuntimeResolver } from '../modes/jit/resolver';
 import type { TestComponentConstructor } from './types';
@@ -56,14 +52,22 @@ let GUID = 1;
 export class EmberishCurlyComponent {
   public static positionalParams: string[] | string = [];
 
-  public dirtinessTag: DirtyableTag = createTag();
+  public dirtinessTag: DirtyableTag = createTag(
+    devmode(
+      () =>
+        ({
+          reason: 'component',
+          label: ['(emberish)'],
+        }) satisfies TagDescription
+    )
+  );
   public declare layout: Template;
   public declare name: string;
   public tagName: Nullable<string> = null;
   public attributeBindings: Nullable<string[]> = null;
   public declare attrs: Attrs;
   public declare element: Element;
-  public declare bounds: Bounds;
+  public declare bounds: BlockBounds;
   public parentView: Nullable<EmberishCurlyComponent> = null;
   public declare args: CapturedNamedArguments;
 
@@ -119,7 +123,7 @@ export class EmberishCurlyComponent {
 
 export interface EmberishCurlyComponentState {
   component: EmberishCurlyComponent;
-  selfRef: Reference;
+  selfRef: Reactive;
 }
 
 const EMBERISH_CURLY_CAPABILITIES: InternalComponentCapabilities = {
@@ -180,7 +184,7 @@ export class EmberishCurlyComponentManager
 
       let named = args.named.capture();
       let positional = args.positional.capture();
-      named[positionalParams] = createComputeRef(() => reifyPositional(positional));
+      named[positionalParams] = Formula(() => reifyPositional(positional));
 
       return { positional: EMPTY_ARRAY, named } as PreparedArguments;
     } else if (Array.isArray(positionalParams)) {
@@ -211,11 +215,11 @@ export class EmberishCurlyComponentManager
     _args: VMArguments,
     _env: Environment,
     dynamicScope: DynamicScope,
-    callerSelf: Reference,
+    callerSelf: Reactive,
     hasDefaultBlock: boolean
   ): EmberishCurlyComponentState {
     let klass = definition || EmberishCurlyComponent;
-    let self = valueForRef(callerSelf);
+    let self = unwrapReactive(callerSelf);
     let args = _args.named.capture();
     let attrs = reifyNamed(args);
     let merged = assign(
@@ -235,7 +239,7 @@ export class EmberishCurlyComponentManager
     if (dyn) {
       for (let i = 0; i < dyn.length; i++) {
         let name = dyn[i] as string;
-        component.set(name, valueForRef(dynamicScope.get(name)));
+        component.set(name, unwrapReactive(dynamicScope.get(name)));
       }
     }
 
@@ -248,12 +252,12 @@ export class EmberishCurlyComponentManager
 
     registerDestructor(component, () => component.destroy());
 
-    const selfRef = createConstRef(component, 'this');
+    const selfRef = ReadonlyCell(component, 'this');
 
     return { component, selfRef };
   }
 
-  getSelf({ selfRef }: EmberishCurlyComponentState): Reference<unknown> {
+  getSelf({ selfRef }: EmberishCurlyComponentState): Reactive<unknown> {
     return selfRef;
   }
 
@@ -274,21 +278,21 @@ export class EmberishCurlyComponentManager
   ): void {
     component.element = element;
 
-    operations.setAttribute('id', createPrimitiveRef(`ember${component._guid}`), false, null);
-    operations.setAttribute('class', createPrimitiveRef('ember-view'), false, null);
+    operations.setAttribute('id', createPrimitiveCell(`ember${component._guid}`), false, null);
+    operations.setAttribute('class', createPrimitiveCell('ember-view'), false, null);
 
     let bindings = component.attributeBindings;
 
     if (bindings) {
       for (const attribute of bindings) {
-        let reference = childRefFor(selfRef, attribute);
+        let reference = getReactiveProperty(selfRef, attribute);
 
         operations.setAttribute(attribute, reference, false, null);
       }
     }
   }
 
-  didRenderLayout({ component }: EmberishCurlyComponentState, bounds: Bounds): void {
+  didRenderLayout({ component }: EmberishCurlyComponentState, bounds: BlockBounds): void {
     component.bounds = bounds;
   }
 
diff --git a/packages/@glimmer-workspace/integration-tests/lib/components/emberish-glimmer.ts b/packages/@glimmer-workspace/integration-tests/lib/components/emberish-glimmer.ts
index 93dc23453f..4113a9161a 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/components/emberish-glimmer.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/components/emberish-glimmer.ts
@@ -1,5 +1,5 @@
-import { destroy, isDestroyed, isDestroying, registerDestructor } from '@glimmer/destroyable';
 import type { Arguments, ComponentManager, Dict, Owner } from '@glimmer/interfaces';
+import { destroy, isDestroyed, isDestroying, registerDestructor } from '@glimmer/destroyable';
 import { componentCapabilities, setComponentManager } from '@glimmer/manager';
 import { setOwner } from '@glimmer/owner';
 
diff --git a/packages/@glimmer-workspace/integration-tests/lib/components/styles.ts b/packages/@glimmer-workspace/integration-tests/lib/components/styles.ts
new file mode 100644
index 0000000000..51d87dbf37
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/components/styles.ts
@@ -0,0 +1,252 @@
+import type {ComponentBlueprint} from './types';
+
+import { InvocationBuilder } from './build';
+import {  CURLY_TEST_COMPONENT, GLIMMER_TEST_COMPONENT } from './types';
+
+export type ComponentStyle = (blueprint: ComponentBlueprint) => {
+  // the name of the template
+  name: string;
+  template: string;
+  invocation: string;
+};
+
+export type BuildTemplate = (blueprint: ComponentBlueprint) => string;
+
+export type BuildInvocation = (blueprint: ComponentBlueprint) => {
+  invocation: string;
+  name: string;
+};
+
+const AngleBracketStyle = ((blueprint: ComponentBlueprint) => {
+  let {
+    args = {},
+    attributes = {},
+    template,
+    name = GLIMMER_TEST_COMPONENT,
+    else: elseBlock,
+    blockParams = [],
+  } = blueprint;
+
+  const builder = InvocationBuilder.ANGLE;
+
+  let invocation: string | string[] = [];
+
+  invocation.push(`<${name}`);
+
+  let componentArgs = builder.args(args);
+
+  if (componentArgs !== '') {
+    invocation.push(componentArgs);
+  }
+
+  let attrs = builder.attributes(attributes);
+  if (attrs !== '') {
+    invocation.push(attrs);
+  }
+
+  let open = invocation.join(' ');
+  invocation = [open];
+
+  if (template) {
+    let block: string | string[] = [];
+    let params = builder.blockParams(blockParams);
+
+    if (elseBlock) {
+      block.push(`><:default${params}>${template}</:default><:else>${elseBlock}</:else>`);
+    } else {
+      block.push(`${params}>${template}`);
+    }
+
+    block.push(`</${name}>`);
+    invocation.push(block.join(''));
+  } else {
+    invocation.push(' ');
+    invocation.push(`/>`);
+  }
+
+  return { name, invocation: invocation.join('') };
+}) satisfies BuildInvocation;
+
+export const BuildGlimmerInvoke = (blueprint: ComponentBlueprint) => {
+  return AngleBracketStyle(blueprint);
+};
+
+export const BuildGlimmerTemplate = (blueprint: ComponentBlueprint) => {
+  let { tag = 'div', layout } = blueprint;
+  const builder = InvocationBuilder.ANGLE;
+
+  let layoutAttrs = builder.attributes(blueprint.layoutAttributes);
+
+  return layout.includes(`...attributes`)
+    ? `<${tag} ${layoutAttrs}>${layout}</${tag}>`
+    : `<${tag} ${layoutAttrs} ...attributes>${layout}</${tag}>`;
+};
+
+export const BuildGlimmerComponent = (blueprint: ComponentBlueprint) => {
+  let { tag = 'div', layout, name = GLIMMER_TEST_COMPONENT } = blueprint;
+  const builder = InvocationBuilder.ANGLE;
+
+  let invocation = AngleBracketStyle(blueprint);
+  let layoutAttrs = builder.attributes(blueprint.layoutAttributes);
+
+  return {
+    name,
+    invocation,
+    template: layout.includes(`...attributes`)
+      ? `<${tag} ${layoutAttrs}>${layout}</${tag}>`
+      : `<${tag} ${layoutAttrs} ...attributes>${layout}</${tag}>`,
+  };
+};
+
+const CurlyTemplate = (
+  builder: InvocationBuilder,
+  {
+    name,
+    template,
+    blockParams,
+    else: elseBlock,
+  }: { name: string; template: string; blockParams: string[]; else?: string | undefined }
+) => {
+  let block: string[] = [];
+  block.push(builder.blockParams(blockParams));
+  block.push('}}');
+  block.push(template);
+  block.push(builder.else(elseBlock));
+  block.push(`{{/${name}}}`);
+  return block.join('');
+};
+
+export const BuildCurlyInvoke = ((blueprint: ComponentBlueprint) => {
+  const builder = InvocationBuilder.CURLIES;
+
+  let {
+    args = {},
+    template,
+    attributes,
+    else: elseBlock,
+    name = CURLY_TEST_COMPONENT,
+    blockParams = [],
+  } = blueprint;
+
+  if (attributes) {
+    throw new Error('Cannot pass attributes to curly components');
+  }
+
+  let invocation: string[] | string = [];
+
+  if (template) {
+    invocation.push(`{{#${name}`);
+  } else {
+    invocation.push(`{{${name}`);
+  }
+
+  let componentArgs = builder.args(args);
+
+  if (componentArgs !== '') {
+    invocation.push(' ');
+    invocation.push(componentArgs);
+  }
+
+  if (template) {
+    invocation.push(CurlyTemplate(builder, { name, template, blockParams, else: elseBlock }));
+  } else {
+    invocation.push('}}');
+  }
+
+  return { name, invocation: invocation.join('') };
+}) satisfies BuildInvocation;
+
+export const BuildCurlyTemplate = (blueprint: ComponentBlueprint) => {
+  return blueprint.layout;
+};
+
+export const BuildDynamicInvoke = ((blueprint: ComponentBlueprint) => {
+  const builder = InvocationBuilder.CURLIES;
+
+  let {
+    args = {},
+    name = GLIMMER_TEST_COMPONENT,
+    template,
+    attributes,
+    else: elseBlock,
+    blockParams = [],
+  } = blueprint;
+
+  if (attributes) {
+    throw new Error('Cannot pass attributes to curly components');
+  }
+
+  let invocation: string | string[] = [];
+  if (template) {
+    invocation.push('{{#component this.componentName');
+  } else {
+    invocation.push('{{component this.componentName');
+  }
+
+  let componentArgs = builder.args(args);
+
+  if (componentArgs !== '') {
+    invocation.push(' ');
+    invocation.push(componentArgs);
+  }
+
+  if (template) {
+    invocation.push(
+      CurlyTemplate(builder, { name: 'component', template, blockParams, else: elseBlock })
+    );
+  } else {
+    invocation.push('}}');
+  }
+
+  return { name, invocation: invocation.join('') };
+}) satisfies BuildInvocation;
+
+export const BuildDynamicTemplate = (blueprint: ComponentBlueprint) => {
+  return blueprint.layout;
+};
+
+export const BuildDynamicComponent = ((blueprint: ComponentBlueprint) => {
+  const builder = InvocationBuilder.CURLIES;
+
+  let {
+    args = {},
+    layout,
+    template,
+    attributes,
+    else: elseBlock,
+    name = GLIMMER_TEST_COMPONENT,
+    blockParams = [],
+  } = blueprint;
+
+  if (attributes) {
+    throw new Error('Cannot pass attributes to curly components');
+  }
+
+  let invocation: string | string[] = [];
+  if (template) {
+    invocation.push('{{#component this.componentName');
+  } else {
+    invocation.push('{{component this.componentName');
+  }
+
+  let componentArgs = builder.args(args);
+
+  if (componentArgs !== '') {
+    invocation.push(' ');
+    invocation.push(componentArgs);
+  }
+
+  if (template) {
+    invocation.push(
+      CurlyTemplate(builder, { name: 'component', template, blockParams, else: elseBlock })
+    );
+  } else {
+    invocation.push('}}');
+  }
+
+  return {
+    name,
+    template: layout,
+    invocation: invocation.join(''),
+  };
+}) satisfies ComponentStyle;
diff --git a/packages/@glimmer-workspace/integration-tests/lib/components/types.ts b/packages/@glimmer-workspace/integration-tests/lib/components/types.ts
index 15a1d61a28..c46056edc7 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/components/types.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/components/types.ts
@@ -4,18 +4,19 @@ import type { TemplateOnlyComponent } from '@glimmer/runtime';
 import type { EmberishCurlyComponent } from './emberish-curly';
 import type { GlimmerishComponent } from './emberish-glimmer';
 
-export type ComponentKind = 'Glimmer' | 'Curly' | 'Dynamic' | 'TemplateOnly' | 'Custom' | 'unknown';
+export type EveryComponentKind = ComponentKind | 'Custom';
+export type ComponentKind = 'Glimmer' | 'Curly' | 'Dynamic' | 'TemplateOnly';
 
 export interface TestComponentConstructor<T> {
   new (): T;
 }
 
 export interface ComponentTypes {
-  Glimmer: typeof GlimmerishComponent;
-  Curly: TestComponentConstructor<EmberishCurlyComponent>;
-  Dynamic: TestComponentConstructor<EmberishCurlyComponent>;
-  TemplateOnly: TemplateOnlyComponent;
-  Custom: unknown;
+  glimmer: typeof GlimmerishComponent;
+  curly: TestComponentConstructor<EmberishCurlyComponent>;
+  dynamic: TestComponentConstructor<EmberishCurlyComponent>;
+  templateOnly: TemplateOnlyComponent;
+  custom: unknown;
   unknown: unknown;
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/lib/dom/assertions.ts b/packages/@glimmer-workspace/integration-tests/lib/dom/assertions.ts
index 98c581b07d..372d190814 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/dom/assertions.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/dom/assertions.ts
@@ -1,5 +1,5 @@
 import type { Dict, SimpleElement, SimpleNode } from '@glimmer/interfaces';
-import { assign, dict, isSimpleElement } from '@glimmer/util';
+import { dict, ELEMENT_NODE, isSimpleElement } from '@glimmer/util';
 
 export interface DebugElement {
   element: SimpleElement | null | undefined;
@@ -102,25 +102,25 @@ export function equalsElement(
 }
 
 // TODO: Consider removing this
-interface CompatibleTagNameMap extends ElementTagNameMap {
-  foreignobject: SVGForeignObjectElement;
-}
 
 export function assertIsElement(node: SimpleNode | null): node is SimpleElement {
   let nodeType = node === null ? null : node.nodeType;
   QUnit.assert.pushResult({
-    result: nodeType === 1,
+    result: nodeType === ELEMENT_NODE,
     expected: 1,
     actual: nodeType,
     message: 'expected node to be an element',
   });
-  return nodeType === 1;
+  return nodeType === ELEMENT_NODE;
 }
 
-export function assertNodeTagName<
-  T extends keyof CompatibleTagNameMap,
-  U extends CompatibleTagNameMap[T]
->(node: SimpleNode | null, tagName: T): node is SimpleNode & U {
+type AllTagNameMap = HTMLElementTagNameMap &
+  Omit<SVGElementTagNameMap, keyof HTMLElementTagNameMap>;
+
+export function assertNodeTagName<T extends keyof AllTagNameMap, U extends AllTagNameMap[T]>(
+  node: SimpleNode | null,
+  tagName: T
+): node is SimpleNode & U {
   if (assertIsElement(node)) {
     const lowerTagName = node.tagName.toLowerCase();
     const nodeTagName = node.tagName;
@@ -156,22 +156,12 @@ export function equalsAttr(expected: any): Matcher {
 export function assertEmberishElement(
   element: SimpleElement,
   tagName: string,
-  attrs: Object,
-  contents: string
-): void;
-export function assertEmberishElement(element: SimpleElement, tagName: string, attrs: Object): void;
-export function assertEmberishElement(
-  element: SimpleElement,
-  tagName: string,
-  contents: string
-): void;
-export function assertEmberishElement(element: SimpleElement, tagName: string): void;
-export function assertEmberishElement(...args: any[]): void {
-  let [element, tagName, attrs, contents] = processAssertComponentArgs(args);
-
-  let fullAttrs = assign({ class: classes('ember-view'), id: regex(/^ember\d*$/u) }, attrs);
+  attrs?: Dict,
+  contents?: string
+): void {
+  let fullAttrs = { class: classes('ember-view'), id: regex(/^ember\d*$/u), ...attrs };
 
-  equalsElement(element, tagName, fullAttrs, contents);
+  equalsElement(element, tagName, fullAttrs, contents ?? null);
 }
 
 export function assertSerializedInElement(result: string, expected: string, message?: string) {
diff --git a/packages/@glimmer-workspace/integration-tests/lib/dom/simple-utils.ts b/packages/@glimmer-workspace/integration-tests/lib/dom/simple-utils.ts
index b445cf4c54..ba7f1ddd14 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/dom/simple-utils.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/dom/simple-utils.ts
@@ -10,15 +10,8 @@ import type {
   SimpleNode,
   SimpleText,
 } from '@glimmer/interfaces';
-import {
-  clearElement,
-  type COMMENT_NODE,
-  type DOCUMENT_FRAGMENT_NODE,
-  type DOCUMENT_NODE,
-  ELEMENT_NODE,
-  INSERT_AFTER_BEGIN,
-  type TEXT_NODE,
-} from '@glimmer/util';
+import type { COMMENT_NODE, DOCUMENT_FRAGMENT_NODE, DOCUMENT_NODE, TEXT_NODE } from '@glimmer/util';
+import { clearElement, ELEMENT_NODE, INSERT_AFTER_BEGIN } from '@glimmer/util';
 import Serializer from '@simple-dom/serializer';
 import voidMap from '@simple-dom/void-map';
 
diff --git a/packages/@glimmer-workspace/integration-tests/lib/helpers.ts b/packages/@glimmer-workspace/integration-tests/lib/helpers.ts
index 2805b08564..dc4139a5d3 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/helpers.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/helpers.ts
@@ -1,9 +1,10 @@
 import type { CapturedArguments, Dict } from '@glimmer/interfaces';
-import { createComputeRef, type Reference } from '@glimmer/reference';
+import type {Reactive} from '@glimmer/reference';
+import { Formula  } from '@glimmer/reference';
 import { reifyNamed, reifyPositional } from '@glimmer/runtime';
 
 export type UserHelper = (args: ReadonlyArray<unknown>, named: Dict<unknown>) => unknown;
 
-export function createHelperRef(helper: UserHelper, args: CapturedArguments): Reference {
-  return createComputeRef(() => helper(reifyPositional(args.positional), reifyNamed(args.named)));
+export function createHelperRef(helper: UserHelper, args: CapturedArguments): Reactive {
+  return Formula(() => helper(reifyPositional(args.positional), reifyNamed(args.named)));
 }
diff --git a/packages/@glimmer-workspace/integration-tests/lib/index.ts b/packages/@glimmer-workspace/integration-tests/lib/index.ts
new file mode 100644
index 0000000000..6c7e415c9a
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/index.ts
@@ -0,0 +1,32 @@
+import './setup';
+
+export * from './base-env';
+export * from './compile';
+export * from './components';
+export * from './dom/assertions';
+export * from './dom/blocks';
+export * from './dom/simple-utils';
+export * from './markers';
+export * from './matrix';
+export * from './modes/env';
+export * from './modes/jit/delegate';
+export * from './modes/jit/register';
+export * from './modes/jit/resolver';
+export * from './modes/node/env';
+export * from './modes/rehydration/delegate';
+export * from './modes/rehydration/partial-rehydration-delegate';
+export * from './render-delegate';
+export * from './render-test';
+export * from './setup-harness';
+export * from './snapshot';
+export * from './suites';
+export * from './test-decorator';
+export * from './test-helpers/constants';
+export * from './test-helpers/define';
+export * from './test-helpers/module';
+export * from './test-helpers/recorded';
+export * from './test-helpers/strings';
+export * from './test-helpers/test';
+export * from './test-helpers/tracked';
+export * from './test-helpers/tracked-object';
+export { syntaxErrorFor } from '@glimmer-workspace/test-utils';
diff --git a/packages/@glimmer-workspace/integration-tests/lib/matrix.ts b/packages/@glimmer-workspace/integration-tests/lib/matrix.ts
new file mode 100644
index 0000000000..1a0ffbb1fd
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/matrix.ts
@@ -0,0 +1,228 @@
+import type {
+  DeclaredComponentType,
+  RenderDelegate,
+  RenderDelegateOptions,
+} from '@glimmer-workspace/integration-tests';
+import {
+  ClientSideRenderDelegate,
+  ErrorRecoveryRenderDelegate,
+  RenderTestContext,
+  RenderTestState,
+} from '@glimmer-workspace/integration-tests';
+
+const { module, test } = QUnit;
+
+interface RenderDelegateClass {
+  readonly style: string;
+  new (options?: RenderDelegateOptions): RenderDelegate;
+}
+
+export interface CoreMatrixOptions {
+  template: DeclaredComponentType | 'all' | undefined;
+  invokeAs?: DeclaredComponentType | 'all' | undefined;
+}
+
+export type MatrixOptions = CoreMatrixOptions &
+  (
+    | {
+        delegate: RenderDelegateClass;
+      }
+    | {
+        delegates: RenderDelegateClass[];
+      }
+  );
+
+const EXPANSIONS = {
+  curly: ['curly', 'dynamic'],
+  glimmer: ['glimmer', 'templateOnly'],
+  dynamic: ['dynamic'],
+  templateOnly: ['templateOnly'],
+  all: ['curly', 'glimmer', 'dynamic', 'templateOnly'],
+} as const;
+type EXPANSIONS = typeof EXPANSIONS;
+
+function expand(
+  test: Partial<CoreMatrixOptions> | undefined,
+  suite: Partial<CoreMatrixOptions>
+): {
+  template: DeclaredComponentType;
+  invokeAs: DeclaredComponentType;
+}[] {
+  const template = EXPANSIONS[test?.template ?? suite.template ?? 'all'];
+  // const invokeAs= EXPANSIONS[test.invokeAs ?? suite.invokeAs ];
+
+  return template.flatMap((t) => {
+    return [{ template: t, invokeAs: t }];
+    // return invokeAs.map((i) => {
+    //   return { template: t, invokeAs: i };
+    // });
+  });
+}
+
+interface TestsFn<T> {
+  (
+    ...args:
+      | [description: string, body: (context: T) => void | Promise<void>]
+      | [
+          options: {
+            type: DeclaredComponentType;
+          },
+          description: string,
+          body: (context: T) => void | Promise<void>,
+        ]
+  ): void;
+}
+
+type ErrorsFn = (
+  description: string,
+  spec: {
+    /**
+     * A template. The error handler is wrapped in `{{#-try}}...{{-/try}}`.
+     * The value is included as `{{value}}`.
+     */
+    template: string;
+    /**
+     * The error that should be rendered in `{{value}}` when present.
+     */
+    value: string;
+    /**
+     * The error that should be rendered in `{{value}}` when empty. Defaults to `""`.
+     */
+    empty?: string;
+  }
+) => void;
+
+interface CustomOptions<T extends RenderTestContext> {
+  context: new (delegate: RenderDelegate, context: RenderTestState) => T;
+  extends?: Matrix | Matrix[];
+}
+
+type MatrixFn = (options: MatrixOptions) => void;
+
+export class Matrix {
+  readonly #fn: MatrixFn;
+
+  constructor(fn: MatrixFn) {
+    this.#fn = fn;
+  }
+
+  client() {
+    this.#fn({
+      delegates: [ClientSideRenderDelegate, ErrorRecoveryRenderDelegate],
+      template: 'all',
+      invokeAs: 'all',
+    });
+  }
+
+  test(delegate: RenderDelegateClass) {
+    this.#fn({
+      delegate,
+      template: 'all',
+      invokeAs: 'all',
+    });
+  }
+
+  apply(options: MatrixOptions) {
+    this.#fn(options);
+  }
+}
+
+export function matrix(
+  description: string,
+  define: (define: TestsFn<RenderTestContext>, errors: ErrorsFn) => void
+): Matrix;
+export function matrix<const T extends RenderTestContext>(
+  custom: CustomOptions<T>,
+  description: string,
+  define: (define: TestsFn<T>, errors: ErrorsFn) => void
+): Matrix;
+export function matrix<const T extends RenderTestContext>(
+  ...args:
+    | [description: string, define: (define: TestsFn<T>, errors: ErrorsFn) => void]
+    | [
+        custom: CustomOptions<T>,
+        description: string,
+        define: (define: TestsFn<T>, errors: ErrorsFn) => void,
+      ]
+): Matrix {
+  const [{ context: Context, extends: extendsMatrix }, description, define] =
+    args.length === 2
+      ? [{ context: RenderTestContext } satisfies CustomOptions<RenderTestContext>, ...args]
+      : args;
+
+  const extendsMatrixes = extendsMatrix
+    ? Array.isArray(extendsMatrix)
+      ? extendsMatrix
+      : [extendsMatrix]
+    : [];
+
+  return new Matrix((options: MatrixOptions) => {
+    const delegates = 'delegate' in options ? [options.delegate] : options.delegates;
+
+    for (const delegate of delegates) {
+      for (const matrix of extendsMatrixes) {
+        matrix.apply({
+          delegate: delegate,
+          template: options.template,
+          invokeAs: options.invokeAs,
+        });
+      }
+    }
+
+    module(description, () => {
+      for (const delegate of delegates) {
+        const TESTS: Record<
+          /* DeclaredComponentType */ string,
+          [description: string, test: (assert: Assert) => void | Promise<void>][]
+        > = {};
+
+        const tests: TestsFn<T> = (...args) => {
+          const [testOptions, description, fn] =
+            args.length === 2 ? ([undefined, ...args] as const) : args;
+
+          const fullMatrix = expand({ template: testOptions?.type }, options);
+
+          for (const row of fullMatrix) {
+            TESTS[row.template] ??= [];
+
+            TESTS[row.template]?.push([
+              description,
+              (assert) => {
+                const context = new Context(
+                  new delegate(),
+                  RenderTestState(assert, row.template)
+                ) as T;
+                return fn(context);
+              },
+            ]);
+          }
+        };
+
+        define(tests, errors(tests));
+
+        module(`[${delegate.style} style]`, () => {
+          for (const [type, tests] of Object.entries(TESTS)) {
+            module(type, () => {
+              for (const [description, testFn] of tests) {
+                test(description, testFn);
+              }
+            });
+          }
+        });
+      }
+    });
+  });
+}
+
+const errors = <T extends RenderTestContext>(spec: TestsFn<T>) =>
+  function errors(
+    description: string,
+    actual: { template: string; value: string; empty?: string; attribute?: boolean }
+  ) {
+    spec(`${description} (errors: initial)`, (ctx) => {
+      ctx.assertError(actual);
+    });
+    spec(`${description} (errors: update)`, (ctx) => {
+      ctx.assertOk(actual);
+    });
+  };
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/delegate.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/delegate.ts
index 9fbb4d3155..29caa0bb6f 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/delegate.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/delegate.ts
@@ -1,71 +1,44 @@
 import type {
   CapturedRenderNode,
-  CompileTimeCompilationContext,
   Cursor,
-  Dict,
-  DynamicScope,
   ElementBuilder,
-  ElementNamespace,
   Environment,
   HandleResult,
-  Helper,
+  JitContext,
   Nullable,
   RenderResult,
   RuntimeContext,
   SimpleDocument,
-  SimpleDocumentFragment,
   SimpleElement,
-  SimpleText,
 } from '@glimmer/interfaces';
+import type { CurriedValue, EnvironmentDelegate } from '@glimmer/runtime';
+import type { ASTPluginBuilder } from '@glimmer/syntax';
 import { programCompilationContext } from '@glimmer/opcode-compiler';
 import { artifacts, RuntimeOpImpl } from '@glimmer/program';
-import { createConstRef, type Reference } from '@glimmer/reference';
-import {
-  array,
-  clientBuilder,
-  concat,
-  type CurriedValue,
-  type EnvironmentDelegate,
-  fn,
-  get,
-  hash,
-  on,
-  renderComponent,
-  renderSync,
-  runtimeContext,
-} from '@glimmer/runtime';
-import type { ASTPluginBuilder, PrecompileOptions } from '@glimmer/syntax';
-import { assign, castToBrowser, castToSimple, expect, unwrapTemplate } from '@glimmer/util';
+import { array, clientBuilder, concat, fn, get, hash, on, runtimeContext } from '@glimmer/runtime';
+import { assign, castToSimple, expect, unwrapTemplate } from '@glimmer/util';
+
+import type { RenderDelegate, RenderDelegateOptions, WrappedTemplate } from '../../render-delegate';
+import type { Self } from '../../render-test';
 
 import { BaseEnv } from '../../base-env';
 import { preprocess } from '../../compile';
-import type { ComponentKind, ComponentTypes } from '../../components';
-import type { UserHelper } from '../../helpers';
-import type { TestModifierConstructor } from '../../modifiers';
-import type RenderDelegate from '../../render-delegate';
-import type { RenderDelegateOptions } from '../../render-delegate';
 import JitCompileTimeLookup from './compilation-context';
-import {
-  componentHelper,
-  registerComponent,
-  registerHelper,
-  registerInternalHelper,
-  registerModifier,
-} from './register';
+import { componentHelper } from './register';
 import { TestJitRegistry } from './registry';
 import { renderTemplate } from './render';
 import { TestJitRuntimeResolver } from './resolver';
 
-export interface JitTestDelegateContext {
+export interface TestJitContext {
   runtime: RuntimeContext;
-  program: CompileTimeCompilationContext;
+  program: JitContext;
 }
 
 export function JitDelegateContext(
   doc: SimpleDocument,
   resolver: TestJitRuntimeResolver,
   env: EnvironmentDelegate
-): JitTestDelegateContext {
+): TestJitContext {
   let sharedArtifacts = artifacts();
   let context = programCompilationContext(
     sharedArtifacts,
@@ -76,27 +49,38 @@ export function JitDelegateContext(
   return { runtime, program: context };
 }
 
-export class JitRenderDelegate implements RenderDelegate {
+export class ClientSideRenderDelegate implements RenderDelegate {
   static readonly isEager = false;
-  static style = 'jit';
+  static style = 'client-side';
 
   protected registry: TestJitRegistry;
   protected resolver: TestJitRuntimeResolver;
 
-  private plugins: ASTPluginBuilder[] = [];
-  private _context: JitTestDelegateContext | null = null;
-  private self: Nullable<Reference> = null;
   private doc: SimpleDocument;
   private env: EnvironmentDelegate;
 
+  readonly registries: TestJitRegistry[];
+  readonly context: TestJitContext;
+
   constructor({
-    doc,
+    doc: specifiedDoc,
     env,
     resolver = (registry) => new TestJitRuntimeResolver(registry),
   }: RenderDelegateOptions = {}) {
+    const doc = specifiedDoc ?? document;
+
     this.registry = new TestJitRegistry();
     this.resolver = resolver(this.registry);
-    this.doc = castToSimple(doc ?? document);
+    this.doc = castToSimple(doc);
+    this.dom = {
+      document: this.doc,
+      getInitialElement: (doc) =>
+        isBrowserTestDocument(doc)
+          ? castToSimple(
+              expect(doc.querySelector('#qunit-fixture'), 'expected #qunit-fixture to exist')
+            )
+          : doc.createElement('div'),
+    } satisfies RenderDelegate['dom'];
     this.env = assign({}, env ?? BaseEnv);
     this.registry.register('modifier', 'on', on);
     this.registry.register('helper', 'fn', fn);
@@ -104,15 +88,15 @@ export class JitRenderDelegate implements RenderDelegate {
     this.registry.register('helper', 'array', array);
     this.registry.register('helper', 'get', get);
     this.registry.register('helper', 'concat', concat);
-  }
 
-  get context(): JitTestDelegateContext {
-    if (this._context === null) {
-      this._context = JitDelegateContext(this.doc, this.resolver, this.env);
-    }
+    this.registries = [this.registry];
 
-    return this._context;
+    this.context = JitDelegateContext(this.doc, this.resolver, this.env);
   }
+  dom: {
+    document: SimpleDocument | Document;
+    getInitialElement: (doc: SimpleDocument | Document) => SimpleElement;
+  };
 
   getCapturedRenderTree(): CapturedRenderNode[] {
     return expect(
@@ -121,125 +105,58 @@ export class JitRenderDelegate implements RenderDelegate {
     ).capture();
   }
 
-  getInitialElement(): SimpleElement {
-    if (isBrowserTestDocument(this.doc)) {
-      return castToSimple(castToBrowser(this.doc).getElementById('qunit-fixture')!);
-    } else {
-      return this.createElement('div');
-    }
-  }
-
-  createElement(tagName: string): SimpleElement {
-    return this.doc.createElement(tagName);
-  }
-
-  createTextNode(content: string): SimpleText {
-    return this.doc.createTextNode(content);
-  }
-
-  createElementNS(namespace: ElementNamespace, tagName: string): SimpleElement {
-    return this.doc.createElementNS(namespace, tagName);
-  }
-
-  createDocumentFragment(): SimpleDocumentFragment {
-    return this.doc.createDocumentFragment();
-  }
-
-  createCurriedComponent(name: string): CurriedValue | null {
+  createCurriedComponent(name: string): Nullable<CurriedValue> {
     return componentHelper(this.registry, name, this.context.program.constants);
   }
 
-  registerPlugin(plugin: ASTPluginBuilder): void {
-    this.plugins.push(plugin);
-  }
-
-  registerComponent<K extends 'TemplateOnly' | 'Glimmer', L extends ComponentKind>(
-    type: K,
-    _testType: L,
-    name: string,
-    layout: string,
-    Class?: ComponentTypes[K]
-  ): void;
-  registerComponent<K extends 'Curly' | 'Dynamic', L extends ComponentKind>(
-    type: K,
-    _testType: L,
-    name: string,
-    layout: Nullable<string>,
-    Class?: ComponentTypes[K]
-  ): void;
-  registerComponent<K extends ComponentKind, L extends ComponentKind>(
-    type: K,
-    _testType: L,
-    name: string,
-    layout: Nullable<string>,
-    Class?: ComponentTypes[K]
-  ) {
-    registerComponent(this.registry, type, name, layout, Class);
-  }
-
-  registerModifier(name: string, ModifierClass: TestModifierConstructor): void {
-    registerModifier(this.registry, name, ModifierClass);
-  }
-
-  registerHelper(name: string, helper: UserHelper): void {
-    registerHelper(this.registry, name, helper);
-  }
-
-  registerInternalHelper(name: string, helper: Helper) {
-    registerInternalHelper(this.registry, name, helper);
-  }
-
   getElementBuilder(env: Environment, cursor: Cursor): ElementBuilder {
     return clientBuilder(env, cursor);
   }
 
-  getSelf(_env: Environment, context: unknown): Reference {
-    if (!this.self) {
-      this.self = createConstRef(context, 'this');
-    }
-
-    return this.self;
+  wrap(template: string): WrappedTemplate {
+    return { template };
   }
 
-  compileTemplate(template: string): HandleResult {
-    let compiled = preprocess(template, this.precompileOptions);
+  compileTemplate(template: string, plugins: ASTPluginBuilder[]): HandleResult {
+    let compiled = preprocess(this.wrap(template).template, {
+      plugins: {
+        ast: plugins,
+      },
+    });
 
     return unwrapTemplate(compiled).asLayout().compile(this.context.program);
   }
 
-  renderTemplate(template: string, context: Dict<unknown>, element: SimpleElement): RenderResult {
+  renderTemplate(
+    rawTemplate: string,
+    self: Self,
+    element: SimpleElement,
+    _: () => void,
+    plugins: ASTPluginBuilder[]
+  ): RenderResult {
     let cursor = { element, nextSibling: null };
 
     let { env } = this.context.runtime;
 
-    return renderTemplate(
-      template,
-      this.context,
-      this.getSelf(env, context),
-      this.getElementBuilder(env, cursor),
-      this.precompileOptions
-    );
-  }
+    const { template, properties } = this.wrap(rawTemplate);
 
-  renderComponent(
-    component: object,
-    args: Record<string, unknown>,
-    element: SimpleElement,
-    dynamicScope?: DynamicScope
-  ): RenderResult {
-    let cursor = { element, nextSibling: null };
-    let { program, runtime } = this.context;
-    let builder = this.getElementBuilder(runtime.env, cursor);
-    let iterator = renderComponent(runtime, builder, program, {}, component, args, dynamicScope);
+    if (properties) self.update(properties);
 
-    return renderSync(runtime.env, iterator);
+    return renderTemplate(template, this.context, self.ref, this.getElementBuilder(env, cursor), {
+      plugins: {
+        ast: plugins,
+      },
+    });
   }
+}
+
+export class ErrorRecoveryRenderDelegate extends ClientSideRenderDelegate {
+  static override style = 'in a no-op error recovery';
 
-  private get precompileOptions(): PrecompileOptions {
+  override wrap(template: string): WrappedTemplate {
     return {
-      plugins: {
-        ast: this.plugins,
-      },
+      template: `{{#-try this.errorRecoveryHandle}}${template}{{/-try}}`,
+      properties: { errorRecoveryHandle: () => {} },
     };
   }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/dom.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/dom.ts
new file mode 100644
index 0000000000..23204f1260
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/dom.ts
@@ -0,0 +1,45 @@
+import type {
+  ElementNamespace,
+  SimpleDocument,
+  SimpleDocumentFragment,
+  SimpleElement,
+  SimpleText,
+} from '@glimmer/interfaces';
+import { castToSimple } from '@glimmer/util';
+
+import type { DomDelegate } from '../../render-delegate';
+import type RenderDelegate from '../../render-delegate';
+
+export class BuildDomDelegate implements DomDelegate {
+  readonly #document: SimpleDocument | Document;
+  readonly #getInitial: (doc: SimpleDocument | Document) => SimpleElement;
+
+  constructor({ document: doc, getInitialElement: getInitial }: RenderDelegate['dom']) {
+    this.#document = doc;
+    this.#getInitial = getInitial;
+  }
+
+  getInitialElement(): SimpleElement {
+    return this.#getInitial(this.#document);
+  }
+
+  get doc() {
+    return castToSimple(this.#document);
+  }
+
+  createElement(tagName: string): SimpleElement {
+    return this.doc.createElement(tagName);
+  }
+
+  createTextNode(content: string): SimpleText {
+    return this.doc.createTextNode(content);
+  }
+
+  createElementNS(namespace: ElementNamespace, tagName: string): SimpleElement {
+    return this.doc.createElementNS(namespace, tagName);
+  }
+
+  createDocumentFragment(): SimpleDocumentFragment {
+    return this.doc.createDocumentFragment();
+  }
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/register.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/register.ts
index 41ff4ab4ad..7469dc9c84 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/register.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/register.ts
@@ -5,26 +5,30 @@ import type {
   ResolutionTimeConstants,
   TemplateFactory,
 } from '@glimmer/interfaces';
+import type {CurriedValue} from '@glimmer/runtime';
 import {
   getInternalComponentManager,
   setComponentTemplate,
   setInternalHelperManager,
   setInternalModifierManager,
 } from '@glimmer/manager';
-import { type CurriedValue, curry, templateOnlyComponent } from '@glimmer/runtime';
+import {  curry, templateOnlyComponent } from '@glimmer/runtime';
 import { CurriedTypes } from '@glimmer/vm';
 
+import type { ComponentTypes } from '../../components';
+import type {UserHelper} from '../../helpers';
+import type {TestModifierConstructor} from '../../modifiers';
+import type { DeclaredComponentType } from '../../test-helpers/constants';
+import type { TestJitRegistry } from './registry';
+
 import { createTemplate } from '../../compile';
-import type { ComponentKind, ComponentTypes } from '../../components';
 import { EmberishCurlyComponent } from '../../components/emberish-curly';
 import { GlimmerishComponent } from '../../components/emberish-glimmer';
-import { createHelperRef, type UserHelper } from '../../helpers';
+import { createHelperRef  } from '../../helpers';
 import {
-  type TestModifierConstructor,
   TestModifierDefinitionState,
-  TestModifierManager,
+  TestModifierManager
 } from '../../modifiers';
-import type { TestJitRegistry } from './registry';
 
 export function registerTemplateOnlyComponent(
   registry: TestJitRegistry,
@@ -42,7 +46,7 @@ export function registerTemplateOnlyComponent(
 export function registerEmberishCurlyComponent(
   registry: TestJitRegistry,
   name: string,
-  Component: Nullable<ComponentTypes['Curly']>,
+  Component: Nullable<ComponentTypes['curly']>,
   layoutSource: Nullable<string>
 ): void {
   let ComponentClass = Component || class extends EmberishCurlyComponent {};
@@ -58,7 +62,7 @@ export function registerEmberishCurlyComponent(
 export function registerGlimmerishComponent(
   registry: TestJitRegistry,
   name: string,
-  Component: Nullable<ComponentTypes['Glimmer']>,
+  Component: Nullable<ComponentTypes['glimmer']>,
   layoutSource: Nullable<string>
 ): void {
   if (name.indexOf('-') !== -1) {
@@ -107,7 +111,7 @@ export function registerModifier(
   registry.register('modifier', name, state);
 }
 
-export function registerComponent<K extends ComponentKind>(
+export function registerComponent<K extends DeclaredComponentType>(
   registry: TestJitRegistry,
   type: K,
   name: string,
@@ -115,22 +119,17 @@ export function registerComponent<K extends ComponentKind>(
   Class?: ComponentTypes[K]
 ): void {
   switch (type) {
-    case 'Glimmer':
-      registerGlimmerishComponent(registry, name, Class as ComponentTypes['Glimmer'], layout);
+    case 'glimmer':
+      registerGlimmerishComponent(registry, name, Class as ComponentTypes['glimmer'], layout);
       break;
-    case 'Curly':
-      registerEmberishCurlyComponent(registry, name, Class as ComponentTypes['Curly'], layout);
+    case 'curly':
+      registerEmberishCurlyComponent(registry, name, Class as ComponentTypes['curly'], layout);
       break;
 
-    case 'Dynamic':
-      registerEmberishCurlyComponent(
-        registry,
-        name,
-        Class as any as typeof EmberishCurlyComponent,
-        layout
-      );
+    case 'dynamic':
+      registerEmberishCurlyComponent(registry, name, Class as ComponentTypes['dynamic'], layout);
       break;
-    case 'TemplateOnly':
+    case 'templateOnly':
       registerTemplateOnlyComponent(registry, name, layout ?? '');
       break;
   }
@@ -163,7 +162,7 @@ export function componentHelper(
   registry: TestJitRegistry,
   name: string,
   constants: ResolutionTimeConstants
-): CurriedValue | null {
+): Nullable<CurriedValue> {
   let definition = registry.lookupComponent(name);
 
   if (definition === null) return null;
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/render.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/render.ts
index 5e6a13bd1a..3442af93dc 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modes/jit/render.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/jit/render.ts
@@ -1,16 +1,17 @@
 import type { ElementBuilder, RenderResult } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { renderMain, renderSync } from '@glimmer/runtime';
+import type { Reactive } from '@glimmer/reference';
 import type { PrecompileOptions } from '@glimmer/syntax';
+import { renderMain, renderSync } from '@glimmer/runtime';
 import { unwrapTemplate } from '@glimmer/util';
 
+import type { TestJitContext } from './delegate';
+
 import { preprocess } from '../../compile';
-import type { JitTestDelegateContext } from './delegate';
 
 export function renderTemplate(
   src: string,
-  { runtime, program }: JitTestDelegateContext,
-  self: Reference,
+  { runtime, program }: TestJitContext,
+  self: Reactive,
   builder: ElementBuilder,
   options?: PrecompileOptions
 ): RenderResult {
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/node/env.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/node/env.ts
index f182e82058..b12aabddf3 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modes/node/env.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/node/env.ts
@@ -5,11 +5,11 @@ import type {
 } from '@glimmer/interfaces';
 import createHTMLDocument from '@simple-dom/document';
 
-import { assertingElement, toInnerHTML } from '../../dom/simple-utils';
-import type RenderDelegate from '../../render-delegate';
 import type { RenderDelegateOptions } from '../../render-delegate';
-import { RenderTest } from '../../render-test';
-import { JitRenderDelegate } from '../jit/delegate';
+
+import { toInnerHTML } from '../../dom/simple-utils';
+import { RenderTestContext } from '../../render-test';
+import { ClientSideRenderDelegate } from '../jit/delegate';
 
 export interface NodeEnvironmentOptions {
   document: SimpleDocument;
@@ -17,7 +17,7 @@ export interface NodeEnvironmentOptions {
   updateOperations?: GlimmerTreeChanges;
 }
 
-export class NodeJitRenderDelegate extends JitRenderDelegate {
+export class NodeJitRenderDelegate extends ClientSideRenderDelegate {
   static override style = 'node jit';
 
   constructor(options: RenderDelegateOptions = {}) {
@@ -26,26 +26,21 @@ export class NodeJitRenderDelegate extends JitRenderDelegate {
   }
 }
 
-export class AbstractNodeTest extends RenderTest {
-  constructor(delegate: RenderDelegate) {
-    super(delegate);
-  }
-
+export abstract class NodeRenderTest extends RenderTestContext {
   override assertHTML(html: string) {
     let serialized = toInnerHTML(this.element);
     this.assert.strictEqual(serialized, html);
   }
 
   override assertComponent(html: string) {
-    let el = assertingElement(this.element.firstChild);
+    let el = this.assertingElement;
 
-    if (this.testType !== 'Glimmer') {
+    if (this.testType !== 'Glimmer' && this.testType !== 'TemplateOnly') {
       this.assert.strictEqual(el.getAttribute('class'), 'ember-view');
       this.assert.ok(el.getAttribute('id'));
       this.assert.ok(el.getAttribute('id')!.indexOf('ember') > -1);
     }
 
-    let serialized = toInnerHTML(el);
-    this.assert.strictEqual(serialized, html);
+    this.assert.strictEqual(toInnerHTML(el), html);
   }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/delegate.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/delegate.ts
index c998624378..e715ef56a0 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/delegate.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/delegate.ts
@@ -1,42 +1,31 @@
 import type {
   Cursor,
-  Dict,
   ElementBuilder,
-  ElementNamespace,
   Environment,
-  Helper,
-  Nullable,
   RenderResult,
   SimpleDocument,
-  SimpleDocumentFragment,
   SimpleElement,
   SimpleNode,
-  SimpleText,
 } from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import type { ASTPluginBuilder } from '@glimmer/syntax';
 import { serializeBuilder } from '@glimmer/node';
-import { createConstRef, type Reference } from '@glimmer/reference';
-import type { ASTPluginBuilder, PrecompileOptions } from '@glimmer/syntax';
 import { assign, castToSimple } from '@glimmer/util';
 import createHTMLDocument from '@simple-dom/document';
 
+import type RenderDelegate from '../../render-delegate';
+import type { RenderDelegateOptions, WrappedTemplate } from '../../render-delegate';
+import type { Self } from '../../render-test';
+import type {TestJitContext} from '../jit/delegate';
+import type {DebugRehydrationBuilder} from './builder';
+
 import { BaseEnv } from '../../base-env';
-import type { ComponentKind } from '../../components';
 import { replaceHTML, toInnerHTML } from '../../dom/simple-utils';
-import type { UserHelper } from '../../helpers';
-import type { TestModifierConstructor } from '../../modifiers';
-import type RenderDelegate from '../../render-delegate';
-import type { RenderDelegateOptions } from '../../render-delegate';
-import { JitDelegateContext, type JitTestDelegateContext } from '../jit/delegate';
-import {
-  registerComponent,
-  registerHelper,
-  registerInternalHelper,
-  registerModifier,
-} from '../jit/register';
+import { JitDelegateContext } from '../jit/delegate';
 import { TestJitRegistry } from '../jit/registry';
 import { renderTemplate } from '../jit/render';
 import { TestJitRuntimeResolver } from '../jit/resolver';
-import { debugRehydration, type DebugRehydrationBuilder } from './builder';
+import { debugRehydration  } from './builder';
 
 export interface RehydrationStats {
   clearedNodes: SimpleNode[];
@@ -46,10 +35,10 @@ export class RehydrationDelegate implements RenderDelegate {
   static readonly isEager = false;
   static readonly style = 'rehydration';
 
-  private plugins: ASTPluginBuilder[] = [];
+  readonly style: string = 'rehydration';
 
-  public clientEnv: JitTestDelegateContext;
-  public serverEnv: JitTestDelegateContext;
+  public clientEnv: TestJitContext;
+  public serverEnv: TestJitContext;
 
   private clientResolver: TestJitRuntimeResolver;
   private serverResolver: TestJitRuntimeResolver;
@@ -60,42 +49,31 @@ export class RehydrationDelegate implements RenderDelegate {
   public clientDoc: SimpleDocument;
   public serverDoc: SimpleDocument;
 
-  public declare rehydrationStats: RehydrationStats;
+  readonly context: TestJitContext;
+  readonly dom: RenderDelegate['dom'];
 
-  private self: Nullable<Reference> = null;
+  public declare rehydrationStats: RehydrationStats;
 
   constructor(options?: RenderDelegateOptions) {
-    let delegate = assign(options?.env ?? {}, BaseEnv);
+    let envDelegate = assign(options?.env ?? {}, BaseEnv);
+
+    const clientDoc = castToSimple(document);
 
-    this.clientDoc = castToSimple(document);
+    this.clientDoc = clientDoc;
     this.clientRegistry = new TestJitRegistry();
     this.clientResolver = new TestJitRuntimeResolver(this.clientRegistry);
-    this.clientEnv = JitDelegateContext(this.clientDoc, this.clientResolver, delegate);
+    this.clientEnv = JitDelegateContext(this.clientDoc, this.clientResolver, envDelegate);
+
+    this.dom = {
+      document: this.clientDoc,
+      getInitialElement: () => this.clientDoc.createElement('div'),
+    };
+    this.context = JitDelegateContext(clientDoc, this.clientResolver, envDelegate);
 
     this.serverDoc = createHTMLDocument();
     this.serverRegistry = new TestJitRegistry();
     this.serverResolver = new TestJitRuntimeResolver(this.serverRegistry);
-    this.serverEnv = JitDelegateContext(this.serverDoc, this.serverResolver, delegate);
-  }
-
-  getInitialElement(): SimpleElement {
-    return this.clientDoc.createElement('div');
-  }
-
-  createElement(tagName: string): SimpleElement {
-    return this.clientDoc.createElement(tagName);
-  }
-
-  createTextNode(content: string): SimpleText {
-    return this.clientDoc.createTextNode(content);
-  }
-
-  createElementNS(namespace: ElementNamespace, tagName: string): SimpleElement {
-    return this.clientDoc.createElementNS(namespace, tagName);
-  }
-
-  createDocumentFragment(): SimpleDocumentFragment {
-    return this.clientDoc.createDocumentFragment();
+    this.serverEnv = JitDelegateContext(this.serverDoc, this.serverResolver, envDelegate);
   }
 
   getElementBuilder(env: Environment, cursor: Cursor): ElementBuilder {
@@ -106,55 +84,52 @@ export class RehydrationDelegate implements RenderDelegate {
     return serializeBuilder(env, cursor);
   }
 
+  wrap(template: string): WrappedTemplate {
+    return { template };
+  }
+
   renderServerSide(
     template: string,
-    context: Dict<unknown>,
+    self: Reactive,
     takeSnapshot: () => void,
-    element: SimpleElement | undefined = undefined
+    element: SimpleElement | undefined = undefined,
+    plugins: ASTPluginBuilder[]
   ): string {
     element = element || this.serverDoc.createElement('div');
     let cursor = { element, nextSibling: null };
     let { env } = this.serverEnv.runtime;
 
     // Emulate server-side render
-    renderTemplate(
-      template,
-      this.serverEnv,
-      this.getSelf(env, context),
-      this.getElementBuilder(env, cursor),
-      this.precompileOptions
-    );
+    renderTemplate(template, this.serverEnv, self, this.getElementBuilder(env, cursor), {
+      plugins: {
+        ast: plugins,
+      },
+    });
 
     takeSnapshot();
     return this.serialize(element);
   }
 
-  getSelf(_env: Environment, context: unknown): Reference {
-    if (!this.self) {
-      this.self = createConstRef(context, 'this');
-    }
-
-    return this.self;
-  }
-
   serialize(element: SimpleElement): string {
     return toInnerHTML(element);
   }
 
-  renderClientSide(template: string, context: Dict<unknown>, element: SimpleElement): RenderResult {
+  renderClientSide(
+    template: string,
+    self: Reactive,
+    element: SimpleElement,
+    plugins: ASTPluginBuilder[]
+  ): RenderResult {
     let env = this.clientEnv.runtime.env;
-    this.self = null;
 
     // Client-side rehydration
     let cursor = { element, nextSibling: null };
     let builder = this.getElementBuilder(env, cursor) as DebugRehydrationBuilder;
-    let result = renderTemplate(
-      template,
-      this.clientEnv,
-      this.getSelf(env, context),
-      builder,
-      this.precompileOptions
-    );
+    let result = renderTemplate(template, this.clientEnv, self, builder, {
+      plugins: {
+        ast: plugins,
+      },
+    });
 
     this.rehydrationStats = {
       clearedNodes: builder['clearedNodes'],
@@ -165,47 +140,20 @@ export class RehydrationDelegate implements RenderDelegate {
 
   renderTemplate(
     template: string,
-    context: Dict<unknown>,
+    self: Self,
     element: SimpleElement,
-    snapshot: () => void
+    snapshot: () => void,
+    plugins: ASTPluginBuilder[]
   ): RenderResult {
-    let serialized = this.renderServerSide(template, context, snapshot);
+    let serialized = this.renderServerSide(template, self.ref, snapshot, undefined, plugins);
     replaceHTML(element, serialized);
     qunitFixture().appendChild(element);
 
-    return this.renderClientSide(template, context, element);
-  }
-
-  registerPlugin(plugin: ASTPluginBuilder): void {
-    this.plugins.push(plugin);
+    return this.renderClientSide(template, self.ref, element, plugins);
   }
 
-  registerComponent(type: ComponentKind, _testType: string, name: string, layout: string): void {
-    registerComponent(this.clientRegistry, type, name, layout);
-    registerComponent(this.serverRegistry, type, name, layout);
-  }
-
-  registerHelper(name: string, helper: UserHelper): void {
-    registerHelper(this.clientRegistry, name, helper);
-    registerHelper(this.serverRegistry, name, helper);
-  }
-
-  registerInternalHelper(name: string, helper: Helper) {
-    registerInternalHelper(this.clientRegistry, name, helper);
-    registerInternalHelper(this.serverRegistry, name, helper);
-  }
-
-  registerModifier(name: string, ModifierClass: TestModifierConstructor): void {
-    registerModifier(this.clientRegistry, name, ModifierClass);
-    registerModifier(this.serverRegistry, name, ModifierClass);
-  }
-
-  private get precompileOptions(): PrecompileOptions {
-    return {
-      plugins: {
-        ast: this.plugins,
-      },
-    };
+  get registries() {
+    return [this.clientRegistry, this.serverRegistry];
   }
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/partial-rehydration-delegate.ts b/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/partial-rehydration-delegate.ts
index 1daa7cec3c..85ee35de85 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/partial-rehydration-delegate.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modes/rehydration/partial-rehydration-delegate.ts
@@ -2,12 +2,11 @@ import type { Dict, RenderResult, SimpleElement } from '@glimmer/interfaces';
 import { renderComponent, renderSync } from '@glimmer/runtime';
 
 import type { DebugRehydrationBuilder } from './builder';
+
 import { RehydrationDelegate } from './delegate';
 
 export class PartialRehydrationDelegate extends RehydrationDelegate {
-  registerTemplateOnlyComponent(name: string, layout: string) {
-    this.registerComponent('TemplateOnly', 'TemplateOnly', name, layout);
-  }
+  override readonly style = 'partial rehydration';
 
   renderComponentClientSide(
     name: string,
diff --git a/packages/@glimmer-workspace/integration-tests/lib/modifiers.ts b/packages/@glimmer-workspace/integration-tests/lib/modifiers.ts
index 9289429ee8..5e9afd1e37 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/modifiers.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/modifiers.ts
@@ -1,4 +1,3 @@
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
   CapturedArguments,
   Destroyable,
@@ -8,8 +7,11 @@ import type {
   Owner,
   SimpleElement,
 } from '@glimmer/interfaces';
+import type {UpdatableTag} from '@glimmer/validator';
+import { registerDestructor } from '@glimmer/destroyable';
 import { reifyNamed, reifyPositional } from '@glimmer/runtime';
-import { createUpdatableTag, type UpdatableTag } from '@glimmer/validator';
+import { devmode } from '@glimmer/util';
+import { createUpdatableTag  } from '@glimmer/validator';
 
 export interface TestModifierConstructor {
   new (): TestModifierInstance;
@@ -78,7 +80,14 @@ export class TestModifierManager
 }
 
 export class TestModifier {
-  public tag = createUpdatableTag();
+  public tag = createUpdatableTag(
+    devmode(() => ({
+      kind: 'modifier',
+      label: ['test'],
+      readonly: true,
+      fallible: true,
+    }))
+  );
 
   constructor(
     public element: SimpleElement,
diff --git a/packages/@glimmer-workspace/integration-tests/lib/render-delegate.ts b/packages/@glimmer-workspace/integration-tests/lib/render-delegate.ts
index a2fdd35750..6ae6160043 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/render-delegate.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/render-delegate.ts
@@ -1,61 +1,87 @@
 import type {
   Cursor,
   Dict,
-  DynamicScope,
   ElementBuilder,
   ElementNamespace,
   Environment,
-  Helper,
+  Optional,
   RenderResult,
   SimpleDocument,
   SimpleDocumentFragment,
   SimpleElement,
   SimpleText,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
 import type { EnvironmentDelegate } from '@glimmer/runtime';
 import type { ASTPluginBuilder } from '@glimmer/syntax';
 
-import type { ComponentKind, ComponentTypes } from './components';
-import type { UserHelper } from './helpers';
+import type { TestJitContext } from './modes/jit/delegate';
 import type { TestJitRegistry } from './modes/jit/registry';
 import type { TestJitRuntimeResolver } from './modes/jit/resolver';
+import type { Self } from './render-test';
 
 export interface RenderDelegateOptions {
   doc?: SimpleDocument | Document | undefined;
-  env?: EnvironmentDelegate | undefined;
+  env?: Optional<EnvironmentDelegate>;
   resolver?: (registry: TestJitRegistry) => TestJitRuntimeResolver;
 }
 
-export default interface RenderDelegate {
+export interface DomDelegate {
   getInitialElement(): SimpleElement;
+
   createElement(tagName: string): SimpleElement;
   createTextNode(content: string): SimpleText;
   createElementNS(namespace: ElementNamespace, tagName: string): SimpleElement;
   createDocumentFragment(): SimpleDocumentFragment;
-  registerComponent<K extends ComponentKind, L extends ComponentKind>(
-    type: K,
-    testType: L,
-    name: string,
-    layout: string,
-    Class?: ComponentTypes[K]
-  ): void;
-  registerPlugin(plugin: ASTPluginBuilder): void;
-  registerHelper(name: string, helper: UserHelper): void;
-  registerInternalHelper(name: string, helper: Helper): void;
-  registerModifier(name: string, klass: unknown): void;
+}
+
+/**
+ * A WrappedTemplate is used to wrap tests in no-op handling (such as `{{#-try}}` error recovery).
+ *
+ * It has the wrapped template itself, as well as any properties (`this` values) needed to make the template work.
+ */
+export interface WrappedTemplate {
+  template: string;
+  properties?: Dict;
+}
+
+export interface LogRender {
+  template: string;
+  self: Self;
+  element: SimpleElement;
+}
+
+export default interface RenderDelegate {
+  // Each registered value (using the `test.register.XXX` APIs) will be registered in each of these
+  // registries. In rehydration tests, this causes values to be registered on both the emulated
+  // server and client.
+  readonly registries: TestJitRegistry[];
+
+  // The compilation and runtime contexts for the current testing environment.
+  readonly context: TestJitContext;
+
+  readonly dom: {
+    document: SimpleDocument | Document;
+    getInitialElement: (doc: SimpleDocument | Document) => SimpleElement;
+  };
+
+  /**
+   * Optionally wrap the template in some additional code. This is used to wrap tests in no-op handling (such as
+   * `{{#-try}}` error recovery).
+   */
+  wrap(template: string): WrappedTemplate;
+
+  // Render the template into the given element. Rehydration delegates will emulate
+  // rendering on the server and having the contents already present in the DOM.
   renderTemplate(
     template: string,
-    context: Dict<unknown>,
+    self: Self,
     element: SimpleElement,
-    snapshot: () => void
-  ): RenderResult;
-  renderComponent?(
-    component: object,
-    args: Record<string, unknown>,
-    element: SimpleElement,
-    dynamicScope?: DynamicScope
+    snapshot: () => void,
+    plugins: ASTPluginBuilder[]
   ): RenderResult;
+
+  // Get the appropriate element builder for the current environment.
   getElementBuilder(env: Environment, cursor: Cursor): ElementBuilder;
-  getSelf(env: Environment, context: unknown): Reference;
 }
+
+export type { RenderDelegate };
diff --git a/packages/@glimmer-workspace/integration-tests/lib/render-test.ts b/packages/@glimmer-workspace/integration-tests/lib/render-test.ts
index 5feba341b2..471eecd922 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/render-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/render-test.ts
@@ -1,48 +1,72 @@
-import { destroy } from '@glimmer/destroyable';
 import type {
-  ComponentDefinitionState,
   Dict,
   DynamicScope,
   Helper,
   Maybe,
   Nullable,
+  Reactive,
   RenderResult,
   SimpleElement,
   SimpleNode,
 } from '@glimmer/interfaces';
-import { inTransaction } from '@glimmer/runtime';
 import type { ASTPluginBuilder } from '@glimmer/syntax';
-import { assert, clearElement, dict, expect, isPresent, unwrap } from '@glimmer/util';
-import { dirtyTagFor } from '@glimmer/validator';
 import type { NTuple } from '@glimmer-workspace/test-utils';
+import { destroy } from '@glimmer/destroyable';
+import { hasFlagWith } from '@glimmer/local-debug-flags';
+import { ReadonlyCell } from '@glimmer/reference';
+import { inTransaction, renderComponent, renderSync } from '@glimmer/runtime';
+import { clearElement, dict, expect, isPresent, LOCAL_LOGGER, unwrap } from '@glimmer/util';
+import { dirtyTagFor } from '@glimmer/validator';
 
-import {
-  type ComponentBlueprint,
-  type ComponentKind,
-  type ComponentTypes,
-  CURLY_TEST_COMPONENT,
-  GLIMMER_TEST_COMPONENT,
-} from './components';
-import { assertElementShape, assertEmberishElement } from './dom/assertions';
-import { assertingElement, toInnerHTML } from './dom/simple-utils';
+import type { ComponentBlueprint, ComponentKind, ComponentTypes } from './components';
+import type { ComponentDelegate } from './components/delegate';
 import type { UserHelper } from './helpers';
 import type { TestModifierConstructor } from './modifiers';
-import type RenderDelegate from './render-delegate';
-import { equalTokens, isServerMarker, type NodesSnapshot, normalizeSnapshot } from './snapshot';
+import type { DomDelegate, LogRender, RenderDelegate } from './render-delegate';
+import type { NodesSnapshot } from './snapshot';
+import type { DeclaredComponentType, TypeFor } from './test-helpers/constants';
+import type { RenderTestState } from './test-helpers/module';
+
+import { GLIMMER_TEST_COMPONENT } from './components';
+import {
+  buildInvoke,
+  buildTemplate,
+  CurlyDelegate,
+  DynamicDelegate,
+  getDelegate,
+  GlimmerDelegate,
+} from './components/delegate';
+import { assertingElement, toInnerHTML } from './dom/simple-utils';
+import { BuildDomDelegate } from './modes/jit/dom';
+import {
+  registerComponent,
+  registerHelper,
+  registerInternalHelper,
+  registerModifier,
+} from './modes/jit/register';
+import { equalTokens, isServerMarker, normalizeSnapshot } from './snapshot';
+import { KIND_FOR, TYPE_FOR } from './test-helpers/constants';
+import { Woops } from './test-helpers/error';
+import { RecordedEvents } from './test-helpers/recorded';
 
 type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
 type Present<T> = Exclude<T, null | undefined>;
 
 export interface IRenderTest {
-  readonly count: Count;
-  testType: ComponentKind;
-  beforeEach?(): void;
-  afterEach?(): void;
+  readonly testType: ComponentKind;
+  readonly context: RenderTestState;
+  readonly beforeEach?: () => void;
+  readonly afterEach?: () => void;
 }
 
 export class Count {
   private expected: Record<string, number> = {};
   private actual: Record<string, number> = {};
+  readonly #events: RecordedEvents;
+
+  constructor(events: RecordedEvents) {
+    this.#events = events;
+  }
 
   expect(name: string, count = 1) {
     this.expected[name] = count;
@@ -51,304 +75,242 @@ export class Count {
   }
 
   assert() {
-    QUnit.assert.deepEqual(this.actual, this.expected, 'TODO');
+    this.#events.finalize();
+
+    // don't print anything if the counts match
+    if (QUnit.equiv(this.expected, this.actual)) return;
+
+    QUnit.assert.deepEqual(this.actual, this.expected, "Expected and actual counts don't match");
   }
 }
 
-export class RenderTest implements IRenderTest {
-  testType: ComponentKind = 'unknown';
-
-  protected element: SimpleElement;
-  protected assert = QUnit.assert;
-  protected context: Dict = dict();
-  protected renderResult: Nullable<RenderResult> = null;
-  protected helpers = dict<UserHelper>();
-  protected snapshot: NodesSnapshot = [];
-  readonly count = new Count();
+export class Self {
+  #properties: Dict;
+  readonly ref: Reactive<Dict>;
 
-  constructor(protected delegate: RenderDelegate) {
-    this.element = delegate.getInitialElement();
+  constructor(properties: Dict) {
+    this.#properties = properties;
+    this.ref = ReadonlyCell(this.#properties, 'this');
   }
 
-  capture<T>() {
-    let instance: T;
-    return {
-      capture: (value: T) => (instance = value),
-      get captured(): T {
-        return unwrap(instance);
-      },
-    };
+  get inner(): Dict {
+    return this.#properties;
   }
 
-  registerPlugin(plugin: ASTPluginBuilder): void {
-    this.delegate.registerPlugin(plugin);
+  set(key: string, value: unknown): void {
+    this.#properties[key] = value;
+    dirtyTagFor(this.#properties, key);
   }
 
-  registerHelper(name: string, helper: UserHelper): void {
-    this.delegate.registerHelper(name, helper);
+  delete(key: string): void {
+    delete this.#properties[key];
+    dirtyTagFor(this.#properties, key);
   }
 
-  registerInternalHelper(name: string, helper: Helper): void {
-    this.delegate.registerInternalHelper(name, helper);
-  }
+  initialize(properties: Dict): void {
+    for (const [key, value] of Object.entries(properties)) {
+      this.set(key, value);
+    }
 
-  registerModifier(name: string, ModifierClass: TestModifierConstructor): void {
-    this.delegate.registerModifier(name, ModifierClass);
+    for (const key of Object.keys(this.#properties)) {
+      if (!(key in properties)) {
+        this.delete(key);
+      }
+    }
   }
 
-  registerComponent<K extends ComponentKind>(
-    type: K,
-    name: string,
-    layout: string,
-    Class?: ComponentTypes[K]
-  ): void {
-    this.delegate.registerComponent(type, this.testType, name, layout, Class);
+  update(properties: Dict): void {
+    for (const [key, value] of Object.entries(properties)) {
+      this.set(key, value);
+    }
   }
+}
 
-  buildComponent(blueprint: ComponentBlueprint): string {
-    let invocation = '';
-    switch (this.testType) {
-      case 'Glimmer':
-        invocation = this.buildGlimmerComponent(blueprint);
-        break;
-      case 'Curly':
-        invocation = this.buildCurlyComponent(blueprint);
-        break;
-      case 'Dynamic':
-        invocation = this.buildDynamicComponent(blueprint);
-        break;
-      case 'TemplateOnly':
-        invocation = this.buildTemplateOnlyComponent(blueprint);
-        break;
+export class RenderTestContext implements IRenderTest {
+  readonly events = new RecordedEvents();
+  readonly name?: string;
 
-      default:
-        throw new Error(`Invalid test type ${this.testType}`);
-    }
+  readonly self = new Self({});
+  #element: SimpleElement;
+  readonly assert = QUnit.assert;
+  protected renderResult: Nullable<RenderResult> = null;
+  protected helpers = dict<UserHelper>();
+  protected snapshot: NodesSnapshot = [];
+  readonly dom: DomDelegate;
+  readonly context: RenderTestState;
 
-    return invocation;
+  readonly plugins: ASTPluginBuilder[] = [];
+  readonly #delegate: ComponentDelegate<DeclaredComponentType>;
+
+  constructor(
+    protected delegate: RenderDelegate,
+    context: RenderTestState
+  ) {
+    this.#element = delegate.dom.getInitialElement(delegate.dom.document);
+    this.context = context;
+    this.dom = new BuildDomDelegate(delegate.dom);
+
+    this.#delegate = getDelegate(context.types.template);
   }
 
-  private buildArgs(args: Dict): string {
-    let { testType } = this;
-    let sigil = '';
-    let needsCurlies = false;
+  get element() {
+    return this.#element;
+  }
 
-    if (testType === 'Glimmer' || testType === 'TemplateOnly') {
-      sigil = '@';
-      needsCurlies = true;
-    }
+  set element(element: SimpleElement) {
+    this.#element = element;
+  }
 
-    return `${Object.keys(args)
-      .map((arg) => {
-        let rightSide: string;
-
-        let value = args[arg] as Maybe<string[]>;
-        if (needsCurlies) {
-          let isString = value && (value[0] === "'" || value[0] === '"');
-          if (isString) {
-            rightSide = `${value}`;
-          } else {
-            rightSide = `{{${value}}}`;
-          }
-        } else {
-          rightSide = `${value}`;
-        }
+  declare readonly beforeEach?: () => void;
+  declare readonly afterEach?: () => void;
 
-        return `${sigil}${arg}=${rightSide}`;
-      })
-      .join(' ')}`;
+  get testType(): ComponentKind {
+    return KIND_FOR[this.context.types.template];
   }
 
-  private buildBlockParams(blockParams: string[]): string {
-    return `${blockParams.length > 0 ? ` as |${blockParams.join(' ')}|` : ''}`;
+  get invoker(): ComponentDelegate {
+    return getDelegate(this.context.types.invoker);
   }
 
-  private buildElse(elseBlock: string | undefined): string {
-    return `${elseBlock ? `{{else}}${elseBlock}` : ''}`;
+  get invokeAs(): DeclaredComponentType {
+    return this.context.types.invoker;
   }
 
-  private buildAttributes(attrs: Dict = {}): string {
-    return Object.keys(attrs)
-      .map((attr) => `${attr}=${attrs[attr]}`)
-      .join(' ');
+  getInitialElement(): SimpleElement {
+    return this.element;
   }
 
-  private buildAngleBracketComponent(blueprint: ComponentBlueprint): string {
-    let {
-      args = {},
-      attributes = {},
-      template,
-      name = GLIMMER_TEST_COMPONENT,
-      blockParams = [],
-    } = blueprint;
+  getClearedElement(): SimpleElement {
+    (this.element as unknown as HTMLElement).innerHTML = '';
+    return this.element;
+  }
 
-    let invocation: string | string[] = [];
+  clearElement() {
+    (this.element as unknown as HTMLElement).innerHTML = '';
+  }
 
-    invocation.push(`<${name}`);
+  get assertingElement() {
+    return assertingElement(this.element.firstChild);
+  }
 
-    let componentArgs = this.buildArgs(args);
+  escape(text: string): string {
+    const textNode = this.dom.createTextNode(text);
+    const div = this.dom.createElement('div');
+    div.appendChild(textNode);
 
-    if (componentArgs !== '') {
-      invocation.push(componentArgs);
-    }
+    return toInnerHTML(div);
+  }
 
-    let attrs = this.buildAttributes(attributes);
-    if (attrs !== '') {
-      invocation.push(attrs);
-    }
+  capture<T>() {
+    let instance: T;
+    return {
+      capture: (value: T) => (instance = value),
+      get captured(): T {
+        return unwrap(instance);
+      },
+    };
+  }
 
-    let open = invocation.join(' ');
-    invocation = [open];
+  readonly register = {
+    plugin: (plugin: ASTPluginBuilder) => {
+      this.plugins.push(plugin);
+    },
 
-    if (template) {
-      let block: string | string[] = [];
-      let params = this.buildBlockParams(blockParams);
-      if (params !== '') {
-        block.push(params);
+    helper: (name: string, helper: UserHelper) => {
+      for (const registry of this.delegate.registries) {
+        registerHelper(registry, name, helper);
       }
-      block.push(`>`);
-      block.push(template);
-      block.push(`</${name}>`);
-      invocation.push(block.join(''));
-    } else {
-      invocation.push(' ');
-      invocation.push(`/>`);
-    }
+    },
 
-    return invocation.join('');
-  }
+    internalHelper: (name: string, helper: Helper) => {
+      for (const registry of this.delegate.registries) {
+        registerInternalHelper(registry, name, helper);
+      }
+    },
 
-  private buildGlimmerComponent(blueprint: ComponentBlueprint): string {
-    let { tag = 'div', layout, name = GLIMMER_TEST_COMPONENT } = blueprint;
-    let invocation = this.buildAngleBracketComponent(blueprint);
-    let layoutAttrs = this.buildAttributes(blueprint.layoutAttributes);
-    this.assert.ok(
-      true,
-      `generated glimmer layout as ${`<${tag} ${layoutAttrs} ...attributes>${layout}</${tag}>`}`
-    );
-    this.delegate.registerComponent(
-      'Glimmer',
-      this.testType,
-      name,
-      `<${tag} ${layoutAttrs} ...attributes>${layout}</${tag}>`
-    );
-    this.assert.ok(true, `generated glimmer invocation as ${invocation}`);
-    return invocation;
-  }
+    modifier: (name: string, ModifierClass: TestModifierConstructor) => {
+      for (const registry of this.delegate.registries) {
+        registerModifier(registry, name, ModifierClass);
+      }
+    },
 
-  private buildCurlyBlockTemplate(
-    name: string,
-    template: string,
-    blockParams: string[],
-    elseBlock?: string
-  ): string {
-    let block: string[] = [];
-    block.push(this.buildBlockParams(blockParams));
-    block.push('}}');
-    block.push(template);
-    block.push(this.buildElse(elseBlock));
-    block.push(`{{/${name}}}`);
-    return block.join('');
-  }
+    component: <K extends ComponentKind>(
+      kind: K,
+      name: string,
+      layout: Nullable<string>,
+      Class?: ComponentTypes[TypeFor<K>]
+    ): void => {
+      for (const registry of this.delegate.registries) {
+        registerComponent(registry, TYPE_FOR[kind], name, layout, Class);
+      }
+    },
+  };
 
-  private buildCurlyComponent(blueprint: ComponentBlueprint): string {
-    let {
-      args = {},
-      layout,
-      template,
-      attributes,
-      else: elseBlock,
-      name = CURLY_TEST_COMPONENT,
-      blockParams = [],
-    } = blueprint;
-
-    if (attributes) {
-      throw new Error('Cannot pass attributes to curly components');
-    }
+  readonly build = {
+    glimmer: (blueprint: ComponentBlueprint) => this.buildGlimmerComponent(blueprint),
+    curly: (blueprint: ComponentBlueprint) => this.buildCurlyComponent(blueprint),
+    dynamic: (blueprint: ComponentBlueprint) => this.buildDynamicComponent(blueprint),
+    templateOnly: (blueprint: ComponentBlueprint) => this.buildTemplateOnlyComponent(blueprint),
+  };
 
-    let invocation: string[] | string = [];
+  buildComponent(blueprint: ComponentBlueprint): string {
+    switch (this.testType) {
+      case 'Glimmer':
+        return this.buildGlimmerComponent(blueprint);
+      case 'Curly':
+        return this.buildCurlyComponent(blueprint);
+      case 'Dynamic':
+        return this.buildDynamicComponent(blueprint);
+      case 'TemplateOnly':
+        return this.buildTemplateOnlyComponent(blueprint);
 
-    if (template) {
-      invocation.push(`{{#${name}`);
-    } else {
-      invocation.push(`{{${name}`);
+      default:
+        throw new Error(`Invalid test type ${this.testType}`);
     }
+  }
 
-    let componentArgs = this.buildArgs(args);
+  #buildInvoke(blueprint: ComponentBlueprint): { name: string; invocation: string } {
+    return buildInvoke(getDelegate(this.context.types.invoker), blueprint);
+  }
 
-    if (componentArgs !== '') {
-      invocation.push(' ');
-      invocation.push(componentArgs);
-    }
+  #buildComponent(templateDelegate: ComponentDelegate<any>, blueprint: ComponentBlueprint): string {
+    const template = buildTemplate(templateDelegate, blueprint);
+    const { name, invocation } = this.#buildInvoke(blueprint);
 
-    if (template) {
-      invocation.push(this.buildCurlyBlockTemplate(name, template, blockParams, elseBlock));
-    } else {
-      invocation.push('}}');
-    }
-    this.assert.ok(true, `generated curly layout as ${layout}`);
-    this.delegate.registerComponent('Curly', this.testType, name, layout);
-    invocation = invocation.join('');
-    this.assert.ok(true, `generated curly invocation as ${invocation}`);
+    this.register.component(this.testType, name, template);
     return invocation;
   }
 
-  private buildTemplateOnlyComponent(blueprint: ComponentBlueprint): string {
-    let { layout, name = GLIMMER_TEST_COMPONENT } = blueprint;
-    let invocation = this.buildAngleBracketComponent(blueprint);
-    this.assert.ok(true, `generated fragment layout as ${layout}`);
-    this.delegate.registerComponent('TemplateOnly', this.testType, name, `${layout}`);
-    this.assert.ok(true, `generated fragment invocation as ${invocation}`);
-    return invocation;
+  private buildGlimmerComponent(blueprint: ComponentBlueprint): string {
+    return this.#buildComponent(GlimmerDelegate, blueprint);
   }
 
-  private buildDynamicComponent(blueprint: ComponentBlueprint): string {
-    let {
-      args = {},
-      layout,
-      template,
-      attributes,
-      else: elseBlock,
-      name = GLIMMER_TEST_COMPONENT,
-      blockParams = [],
-    } = blueprint;
-
-    if (attributes) {
-      throw new Error('Cannot pass attributes to curly components');
-    }
-
-    let invocation: string | string[] = [];
-    if (template) {
-      invocation.push('{{#component this.componentName');
-    } else {
-      invocation.push('{{component this.componentName');
-    }
-
-    let componentArgs = this.buildArgs(args);
-
-    if (componentArgs !== '') {
-      invocation.push(' ');
-      invocation.push(componentArgs);
-    }
-
-    if (template) {
-      invocation.push(this.buildCurlyBlockTemplate('component', template, blockParams, elseBlock));
-    } else {
-      invocation.push('}}');
-    }
+  private buildCurlyComponent(blueprint: ComponentBlueprint): string {
+    return this.#buildComponent(CurlyDelegate, blueprint);
+  }
 
-    this.assert.ok(true, `generated dynamic layout as ${layout}`);
-    this.delegate.registerComponent('Curly', this.testType, name, layout);
-    invocation = invocation.join('');
-    this.assert.ok(true, `generated dynamic invocation as ${invocation}`);
+  private buildTemplateOnlyComponent(blueprint: ComponentBlueprint): string {
+    return this.buildGlimmerComponent(blueprint);
+    // let { layout, name = GLIMMER_TEST_COMPONENT } = blueprint; let invocation =
+    // this.buildAngleBracketComponent(blueprint); this.assert.ok(true, `generated fragment layout
+    // as ${layout}`); this.register.component('TemplateOnly', name, `${layout}`);
+    // this.assert.ok(true, `generated fragment invocation as ${invocation}`); return invocation;
+  }
 
-    return invocation;
+  private buildDynamicComponent(blueprint: ComponentBlueprint): string {
+    return this.#buildComponent(DynamicDelegate, blueprint);
   }
 
   shouldBeVoid(tagName: string) {
     clearElement(this.element);
     let html = '<' + tagName + " data-foo='bar'><p>hello</p>";
-    this.delegate.renderTemplate(html, this.context, this.element, () => this.takeSnapshot());
+    this.delegate.renderTemplate(
+      html,
+      this.self,
+      this.element,
+      () => this.takeSnapshot(),
+      this.plugins
+    );
 
     let tag = '<' + tagName + ' data-foo="bar">';
     let closing = '</' + tagName + '>';
@@ -363,13 +325,29 @@ export class RenderTest implements IRenderTest {
     });
   }
 
-  render(template: string | ComponentBlueprint, properties: Dict<unknown> = {}): void {
-    try {
-      QUnit.assert.ok(true, `Rendering ${template} with ${JSON.stringify(properties)}`);
-    } catch {
-      // couldn't stringify, possibly has a circular dependency
-    }
+  readonly render = {
+    template: (template: string | ComponentBlueprint, properties: Dict<unknown> = {}) =>
+      this.#renderTemplate(template, properties),
+
+    component: (
+      component: object,
+      args: Record<string, unknown> = {},
+      {
+        into: element = this.element,
+        dynamicScope,
+      }: { into?: SimpleElement; dynamicScope?: DynamicScope } = {}
+    ): void => {
+      let cursor = { element, nextSibling: null };
+
+      let { program, runtime } = this.delegate.context;
+      let builder = this.delegate.getElementBuilder(runtime.env, cursor);
+      let iterator = renderComponent(runtime, builder, program, {}, component, args, dynamicScope);
+
+      this.renderResult = renderSync(runtime.env, iterator);
+    },
+  };
 
+  #renderTemplate(template: string | ComponentBlueprint, properties: Dict<unknown> = {}): void {
     if (typeof template === 'object') {
       let blueprint = template;
       template = this.buildComponent(blueprint);
@@ -379,66 +357,70 @@ export class RenderTest implements IRenderTest {
       }
     }
 
-    this.setProperties(properties);
-
-    this.renderResult = this.delegate.renderTemplate(template, this.context, this.element, () =>
-      this.takeSnapshot()
-    );
-  }
+    this.self.initialize(properties);
 
-  renderComponent(
-    component: ComponentDefinitionState,
-    args: Dict<unknown> = {},
-    dynamicScope?: DynamicScope
-  ): void {
-    try {
-      QUnit.assert.ok(true, `Rendering ${String(component)} with ${JSON.stringify(args)}`);
-    } catch {
-      // couldn't stringify, possibly has a circular dependency
-    }
+    this.#log({
+      template,
+      self: this.self,
+      element: this.element,
+    });
 
-    assert(
-      !!this.delegate.renderComponent,
-      'Attempted to render a component, but the delegate did not implement renderComponent'
+    this.renderResult = this.delegate.renderTemplate(
+      template,
+      this.self,
+      this.element,
+      () => this.takeSnapshot(),
+      this.plugins
     );
-
-    this.renderResult = this.delegate.renderComponent(component, args, this.element, dynamicScope);
   }
 
-  rerender(properties: Dict<unknown> = {}): void {
+  rerender(updates?: Dict<unknown> | string): void {
+    const properties = typeof updates === 'string' ? {} : updates ?? {};
+    const message =
+      typeof updates === 'string'
+        ? updates
+        : updates === undefined
+        ? ''
+        : ` ${JSON.stringify(updates)}`;
+
     try {
-      QUnit.assert.ok(true, `rerender ${JSON.stringify(properties)}`);
+      QUnit.assert.ok(true, `rerender ${message}`);
     } catch {
       // couldn't stringify, possibly has a circular dependency
     }
 
-    this.setProperties(properties);
+    this.self.update(properties);
 
     let result = expect(this.renderResult, 'the test should call render() before rerender()');
 
     try {
+      this.events.record('env:begin');
       result.env.begin();
       result.rerender();
     } finally {
       result.env.commit();
+      this.events.record('env:commit');
     }
   }
 
-  destroy(): void {
-    let result = expect(this.renderResult, 'the test should call render() before destroy()');
+  #log(render: LogRender) {
+    const { template, properties: addedProperties } = this.delegate.wrap(render.template);
 
-    inTransaction(result.env, () => destroy(result));
-  }
+    QUnit.assert.ok(true, `Rendering ${String(template)}`);
 
-  protected set(key: string, value: unknown): void {
-    this.context[key] = value;
-    dirtyTagFor(this.context, key);
+    if (hasFlagWith('enable_internals_logging', 'render')) {
+      const properties = { ...render.self.inner, ...addedProperties };
+      LOCAL_LOGGER.groupCollapsed(`%c[render] Rendering ${template}`, 'font-weight: normal');
+      LOCAL_LOGGER.debug('element   ', render.element);
+      LOCAL_LOGGER.debug('properties', { ...render.self.inner, ...properties });
+      LOCAL_LOGGER.groupEnd();
+    }
   }
 
-  protected setProperties(properties: Dict<unknown>): void {
-    for (let key in properties) {
-      this.set(key, properties[key]);
-    }
+  destroy(): void {
+    let result = expect(this.renderResult, 'the test should call render() before destroy()');
+
+    inTransaction(result.env, () => destroy(result));
   }
 
   protected takeSnapshot(): NodesSnapshot {
@@ -475,7 +457,70 @@ export class RenderTest implements IRenderTest {
     return snapshot;
   }
 
-  protected assertStableRerender() {
+  assertError<This extends RenderTestContext>(
+    this: This,
+    spec: {
+      template: string;
+      value: string;
+      empty?: string;
+      attribute?: boolean;
+    }
+  ) {
+    const { template, expected, error } = distill(spec);
+
+    QUnit.assert.ok(true, `> template: ${template} <`);
+    QUnit.assert.ok(true, `> expected: ${expected(`contents`, this)} <`);
+    QUnit.assert.ok(true, `> error   : ${error} <`);
+
+    const woops = Woops.error(spec.value);
+
+    this.render.template(template, { result: woops, handleError: woops.handleError });
+
+    this.assertStableHTML(error);
+
+    this.assertUpdate('after recovering', () => woops.recover(), expected(spec.value, this));
+    this.assertUpdate(
+      'after emptying',
+      () => (woops.value = spec.empty ?? ''),
+      expected(spec.empty ?? '', this)
+    );
+    this.assertUpdate('after erroring', () => (woops.isError = true), error);
+    this.assertUpdate(
+      'after recovering directly to empty',
+      () => {
+        woops.recover();
+        woops.value = spec.empty ?? '';
+      },
+      expected(spec.empty ?? '', this)
+    );
+  }
+
+  assertOk<This extends RenderTestContext>(
+    this: This,
+    spec: {
+      template: string;
+      value: string;
+      empty?: string;
+      attribute?: boolean;
+    }
+  ) {
+    const { template, expected, error } = distill(spec);
+
+    const woops = Woops.noop(spec.value);
+    this.render.template(template, { result: woops, handleError: woops.handleError });
+
+    this.assertStableHTML(expected(spec.value, this));
+
+    this.assertUpdate('after erroring', () => (woops.isError = true), error);
+    this.assertUpdate('after recovering', () => woops.recover(), expected(spec.value, this));
+    this.assertUpdate(
+      'after emptying',
+      () => (woops.value = spec.empty ?? ''),
+      expected(spec.empty ?? '', this)
+    );
+  }
+
+  assertStableRerender() {
     this.takeSnapshot();
     this.runTask(() => this.rerender());
     this.assertStableNodes();
@@ -522,30 +567,30 @@ export class RenderTest implements IRenderTest {
     return value as Present<T>;
   }
 
-  protected guardArray<T extends Maybe<unknown>[], K extends string>(desc: { [P in K]: T }): {
+  guardArray<T extends Maybe<unknown>[], K extends string>(desc: { [P in K]: T }): {
     [K in keyof T]: Present<T[K]>;
   };
-  protected guardArray<T, K extends string, N extends number>(
+  guardArray<T, K extends string, N extends number>(
     desc: { [P in K]: Iterable<T> | ArrayLike<T> },
     options: { min: N }
   ): Expand<NTuple<N, Present<T>>>;
-  protected guardArray<T, U extends T, K extends string, N extends number>(
+  guardArray<T, U extends T, K extends string, N extends number>(
     desc: { [P in K]: Iterable<T> | ArrayLike<T> },
     options: { min: N; condition: (value: T) => value is U }
   ): Expand<NTuple<N, U>>;
-  protected guardArray<T, K extends string, A extends ArrayLike<T>>(desc: { [P in K]: A }): Expand<
+  guardArray<T, K extends string, A extends ArrayLike<T>>(desc: { [P in K]: A }): Expand<
     NTuple<A['length'], Present<T>>
   >;
-  protected guardArray<T, K extends string>(desc: {
+  guardArray<T, K extends string>(desc: {
     [P in K]: Iterable<T> | ArrayLike<T>;
   }): Present<T>[];
-  protected guardArray<T, K extends string, U extends T>(
+  guardArray<T, K extends string, U extends T>(
     desc: {
       [P in K]: Iterable<T> | ArrayLike<T>;
     },
     options: { condition: (value: T) => value is U; min?: number }
   ): U[];
-  protected guardArray(
+  guardArray(
     desc: Record<string, Iterable<unknown> | ArrayLike<unknown>>,
     options?: {
       min?: Maybe<number>;
@@ -585,7 +630,7 @@ export class RenderTest implements IRenderTest {
     return array;
   }
 
-  protected assertHTML(html: string, elementOrMessage?: SimpleElement | string, message?: string) {
+  assertHTML(html: string, elementOrMessage?: SimpleElement | string, message?: string) {
     if (typeof elementOrMessage === 'object') {
       equalTokens(elementOrMessage || this.element, html, message ? `${html} (${message})` : html);
     } else {
@@ -594,16 +639,19 @@ export class RenderTest implements IRenderTest {
     this.takeSnapshot();
   }
 
-  protected assertComponent(content: string, attrs: Object = {}) {
-    let element = assertingElement(this.element.firstChild);
+  assertStableHTML(html: string, message?: string) {
+    equalTokens(this.element, { expected: html, ignore: 'comments' }, message);
+    this.assertStableRerender();
+  }
 
-    switch (this.testType) {
-      case 'Glimmer':
-        assertElementShape(element, 'div', attrs, content);
-        break;
-      default:
-        assertEmberishElement(element, 'div', attrs, content);
-    }
+  assertUpdate(explanation: string, update: () => void, html: string, message?: string) {
+    update();
+    this.rerender(explanation);
+    this.assertStableHTML(html, message);
+  }
+
+  assertComponent(content: string, attrs: Dict = {}) {
+    this.#delegate.assert(this.assertingElement, 'div', attrs, content);
 
     this.takeSnapshot();
   }
@@ -612,7 +660,7 @@ export class RenderTest implements IRenderTest {
     return callback();
   }
 
-  protected assertStableNodes(
+  assertStableNodes(
     { except: _except }: { except: SimpleNode | SimpleNode[] } = {
       except: [],
     }
@@ -641,3 +689,42 @@ function uniq(arr: any[]) {
     return accum;
   }, []);
 }
+
+export function distill({ template }: { template: string; attribute?: boolean }) {
+  return {
+    template: createTemplate(template),
+    expected: createExpected(template),
+    error: createError(template),
+  };
+}
+
+/**
+ * "<p>{{#-try}}before<img src='{{value}}'>after{{/-try}}</p>"
+ *
+ * ->
+ *
+ * "<p>{{#-try this.handleError}}before<img src='{{this.result.value}}'>after{{/-try}}</p>"
+ */
+function createTemplate(template: string): string {
+  return template
+    .replaceAll('{{#-try}}', '{{#-try this.handleError}}')
+    .replaceAll('{{/-try}}', '{{/-try}}')
+    .replaceAll('{{{value}}}', '{{{this.result.value}}}')
+    .replaceAll('{{value}}', '{{this.result.value}}');
+}
+
+function createExpected(template: string): (value: string, ctx: RenderTestContext) => string {
+  return (value: string, ctx: RenderTestContext) => {
+    const result = template
+      .replaceAll('{{#-try}}', '')
+      .replaceAll('{{/-try}}', '')
+      .replaceAll('{{{value}}}', value)
+      .replaceAll('{{value}}', ctx.escape(value));
+
+    return result;
+  };
+}
+
+function createError(template: string): string {
+  return template.replaceAll(/\{\{#-try\}\}.*?\{\{\/-try\}\}/gu, '');
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/setup-harness.ts b/packages/@glimmer-workspace/integration-tests/lib/setup-harness.ts
index b05c2a7fd3..c532f19c04 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/setup-harness.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/setup-harness.ts
@@ -1,26 +1,58 @@
 /* eslint-disable no-console */
+import type { Expand } from '@glimmer/interfaces';
 import { debug } from '@glimmer/validator';
 import { autoRegister } from 'js-reporters';
+import { default as QUnit } from 'qunit';
 
 export async function setupQunit() {
-  const qunit = await import('qunit');
+  const qunitLib: QUnit = await import('qunit');
   await import('qunit/qunit/qunit.css');
 
+  const testing = Testing.withConfig(
+    {
+      id: 'smoke_tests',
+      label: 'Smoke Tests',
+      tooltip: 'Enable Smoke Tests',
+    },
+    {
+      id: 'ci',
+      label: 'CI Mode',
+      tooltip:
+        'CI mode emits tap output and makes tests run faster by sacrificing UI responsiveness',
+    },
+    {
+      id: 'enable_internals_logging',
+      label: 'Log Deep Internals',
+      tooltip: 'Logs internals that are used in the development of the trace logs',
+    },
+
+    {
+      id: 'enable_trace_logging',
+      label: 'Trace Logs',
+      tooltip: 'Trace logs emit information about the internal VM state',
+    },
+
+    {
+      id: 'enable_subtle_logging',
+      label: '+ Subtle',
+      tooltip:
+        'Subtle logs include unchanged information and other details not necessary for normal debugging',
+    },
+
+    {
+      id: 'enable_trace_explanations',
+      label: '+ Explanations',
+      tooltip: 'Also explain the trace logs',
+    }
+  );
+
   const runner = autoRegister();
-  // @ts-expect-error qunit types don't expose "reporters"
-  const tap = qunit.reporters.tap;
-  tap.init(runner, { log: console.info });
-
-  QUnit.config.urlConfig.push({
-    id: 'smoke_tests',
-    label: 'Enable Smoke Tests',
-    tooltip: 'Enable Smoke Tests',
-  });
 
-  QUnit.config.urlConfig.push({
-    id: 'ci',
-    label: 'Enable CI Mode',
-    tooltip: 'CI mode makes tests run faster by sacrificing UI responsiveness',
+  testing.begin(() => {
+    if (testing.config.ci) {
+      const tap = qunitLib.reporters.tap;
+      tap.init(runner, { log: console.info });
+    }
   });
 
   await Promise.resolve();
@@ -34,7 +66,7 @@ export async function setupQunit() {
 
   console.log(`[HARNESS] ci=${hasFlag('ci')}`);
 
-  QUnit.testStart(() => {
+  testing.testStart(() => {
     debug.resetTrackingTransaction?.();
   });
 
@@ -52,7 +84,7 @@ export async function setupQunit() {
       });
 
     let start = performance.now();
-    qunit.testDone(async () => {
+    qunitLib.testDone(async () => {
       let gap = performance.now() - start;
       if (gap > 200) {
         await pause();
@@ -60,10 +92,10 @@ export async function setupQunit() {
       }
     });
 
-    qunit.moduleDone(pause);
+    qunitLib.moduleDone(pause);
   }
 
-  qunit.done(() => {
+  qunitLib.done(() => {
     console.log('[HARNESS] done');
   });
 
@@ -72,7 +104,74 @@ export async function setupQunit() {
   };
 }
 
+class Testing<Q extends typeof QUnit> {
+  static withConfig<const C extends readonly UrlConfig[]>(...configs: C): Testing<WithConfig<C>> {
+    return new Testing(withConfig(...configs));
+  }
+
+  readonly #qunit: Q;
+
+  constructor(qunit: Q) {
+    this.#qunit = qunit;
+  }
+
+  get config(): Q['config'] {
+    return this.#qunit.config;
+  }
+
+  readonly begin = (begin: (details: QUnit.BeginDetails) => void | Promise<void>): void => {
+    this.#qunit.begin(begin);
+  };
+
+  readonly testStart = (
+    callback: (details: QUnit.TestStartDetails) => void | Promise<void>
+  ): void => {
+    this.#qunit.testStart(callback);
+  };
+}
+
 function hasFlag(flag: string): boolean {
+  return hasSpecificFlag(flag);
+}
+
+function hasSpecificFlag(flag: string): boolean {
   let location = typeof window !== 'undefined' && window.location;
   return location && new RegExp(`[?&]${flag}`).test(location.search);
 }
+
+// eslint-disable-next-line unused-imports/no-unused-vars
+function getSpecificFlag(flag: string): string | undefined {
+  let location = typeof window !== 'undefined' && window.location;
+  if (!location) {
+    return undefined;
+  }
+
+  const matches = new RegExp(`[?&]${flag}=([^&]*)`).exec(location.search);
+  return matches ? matches[1] : undefined;
+}
+
+interface UrlConfig {
+  id: string;
+  label?: string | undefined;
+  tooltip?: string | undefined;
+  value?: string | string[] | { [key: string]: string } | undefined;
+}
+
+type WithConfig<C extends readonly UrlConfig[]> = typeof QUnit & {
+  config: QUnit['config'] & {
+    [P in C[number]['id']]: string | undefined;
+  };
+};
+
+function withConfig<const C extends readonly UrlConfig[]>(...configs: C): Expand<WithConfig<C>> {
+  for (let config of configs) {
+    QUnit.config.urlConfig.push(config);
+  }
+
+  const index = QUnit.config.urlConfig.findIndex((c) => c.id === 'noglobals');
+  if (index !== -1) {
+    QUnit.config.urlConfig.splice(index, 1);
+  }
+
+  return QUnit as any;
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/setup.ts b/packages/@glimmer-workspace/integration-tests/lib/setup.ts
index d4cbad411b..25f41bcaf7 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/setup.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/setup.ts
@@ -1,11 +1,11 @@
-import setGlobalContext from '@glimmer/global-context';
 import type { Destroyable, Destructor, Dict, Nullable } from '@glimmer/interfaces';
 import type { IteratorDelegate } from '@glimmer/reference';
+import type { TestBase } from 'qunit';
+import setGlobalContext from '@glimmer/global-context';
 import { consumeTag, dirtyTagFor, tagFor } from '@glimmer/validator';
 
 import { scheduleDidDestroy, scheduleWillDestroy } from './base-env';
 import { NativeIteratorDelegate } from './modes/env';
-import type { TestBase } from 'qunit';
 
 let actualDeprecations: string[] = [];
 
@@ -91,7 +91,7 @@ setGlobalContext({
 
   getProp(obj: unknown, key: string): unknown {
     if (typeof obj === 'object' && obj !== null) {
-      consumeTag(tagFor(obj, key));
+      consumeTag(tagFor(obj, key, undefined));
     }
 
     return (obj as Dict)[key];
diff --git a/packages/@glimmer-workspace/integration-tests/lib/snapshot.ts b/packages/@glimmer-workspace/integration-tests/lib/snapshot.ts
index 4b1e9323a7..474d71fae6 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/snapshot.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/snapshot.ts
@@ -1,44 +1,58 @@
 import type { Nullable, SimpleElement, SimpleNode } from '@glimmer/interfaces';
+import type { EndTag, Token, TokenType } from 'simple-html-tokenizer';
 import { castToSimple, COMMENT_NODE, TEXT_NODE, unwrap } from '@glimmer/util';
-import { type EndTag, type Token, tokenize } from 'simple-html-tokenizer';
+import { tokenize } from 'simple-html-tokenizer';
 
 import { replaceHTML, toInnerHTML } from './dom/simple-utils';
 
 export type IndividualSnapshot = 'up' | 'down' | SimpleNode;
 export type NodesSnapshot = IndividualSnapshot[];
 
+export const DOCTYPE_TOKEN = 'Doctype' as TokenType.Doctype;
+export const START_TAG_TOKEN = 'StartTag' as TokenType.StartTag;
+export const END_TAG_TOKEN = 'EndTag' as TokenType.EndTag;
+export const CHARS_TOKEN = 'Chars' as TokenType.Chars;
+export const COMMENT_TOKEN = 'Comment' as TokenType.Comment;
+
 export function snapshotIsNode(snapshot: IndividualSnapshot): snapshot is SimpleNode {
   return snapshot !== 'up' && snapshot !== 'down';
 }
 
 export function equalTokens(
-  testFragment: SimpleElement | string | null,
-  testHTML: SimpleElement | string,
+  actual: SimpleElement | string | null,
+  expected:
+    | SimpleElement
+    | string
+    | {
+        expected: string | SimpleElement;
+        ignore: 'comments';
+      },
   message: Nullable<string> = null
 ) {
-  if (testFragment === null) {
+  if (actual === null) {
     throw new Error(`Unexpectedly passed null to equalTokens`);
   }
 
-  const fragTokens = generateTokens(testFragment);
-  const htmlTokens = generateTokens(testHTML);
+  const { element: expectedElement, ignoreComments } = extract(expected);
+  const expectedTokens = generateTokens(expectedElement, ignoreComments);
+  const fragTokens = generateTokens(extract(actual).element, ignoreComments);
 
   cleanEmberIds(fragTokens.tokens);
-  cleanEmberIds(htmlTokens.tokens);
+  cleanEmberIds(expectedTokens.tokens);
 
-  const equiv = QUnit.equiv(fragTokens.tokens, htmlTokens.tokens);
+  const equiv = QUnit.equiv(fragTokens.tokens, expectedTokens.tokens);
 
-  if (equiv && fragTokens.html !== htmlTokens.html) {
+  if (equiv && fragTokens.html !== expectedTokens.html) {
     QUnit.assert.deepEqual(
       fragTokens.tokens,
-      htmlTokens.tokens,
+      expectedTokens.tokens,
       message || 'expected tokens to match'
     );
   } else {
     QUnit.assert.pushResult({
-      result: QUnit.equiv(fragTokens.tokens, htmlTokens.tokens),
+      result: QUnit.equiv(fragTokens.tokens, expectedTokens.tokens),
       actual: fragTokens.html,
-      expected: htmlTokens.html,
+      expected: expectedTokens.html,
       message: message || 'expected tokens to match',
     });
   }
@@ -84,19 +98,43 @@ export function generateSnapshot(element: SimpleElement): SimpleNode[] {
   return snapshot;
 }
 
-function generateTokens(divOrHTML: SimpleElement | string): { tokens: Token[]; html: string } {
-  let div: SimpleElement;
-  if (typeof divOrHTML === 'string') {
-    div = castToSimple(document.createElement('div'));
-    replaceHTML(div, divOrHTML);
+function extract(
+  expected: SimpleElement | string | { expected: string | SimpleElement; ignore: 'comments' }
+): {
+  ignoreComments: boolean;
+  element: SimpleElement;
+} {
+  if (typeof expected === 'string') {
+    const div = castToSimple(document.createElement('div'));
+    replaceHTML(div, expected);
+    return {
+      ignoreComments: false,
+      element: div,
+    };
+  } else if ('nodeType' in expected) {
+    return {
+      ignoreComments: false,
+      element: expected,
+    };
   } else {
-    div = divOrHTML;
+    return {
+      ignoreComments: true,
+      element: extract(expected.expected).element,
+    };
   }
+}
 
-  let tokens = tokenize(toInnerHTML(div), {});
+function generateTokens(
+  element: SimpleElement,
+  ignoreComments: boolean
+): {
+  tokens: Token[];
+  html: string;
+} {
+  let tokens = tokenize(toInnerHTML(element), {});
 
   tokens = tokens.reduce((tokens, token) => {
-    if (token.type === 'StartTag') {
+    if (token.type === START_TAG_TOKEN) {
       if (token.attributes) {
         token.attributes.sort((a, b) => {
           if (a[0] > b[0]) {
@@ -116,14 +154,14 @@ function generateTokens(divOrHTML: SimpleElement | string): { tokens: Token[]; h
       } else {
         tokens.push(token);
       }
-    } else {
+    } else if (!ignoreComments || token.type !== COMMENT_TOKEN) {
       tokens.push(token);
     }
 
     return tokens;
   }, new Array<Token>());
 
-  return { tokens, html: toInnerHTML(div) };
+  return { tokens, html: toInnerHTML(element) };
 }
 
 export function equalSnapshots(a: SimpleNode[], b: SimpleNode[]) {
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites.ts b/packages/@glimmer-workspace/integration-tests/lib/suites.ts
index a3ecce2e83..26ca47d43f 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites.ts
@@ -1,13 +1,14 @@
+import './suites/has-block';
+import './suites/has-block-params';
+
 export * from './suites/components';
 export * from './suites/custom-dom-helper';
 export * from './suites/debugger';
 export * from './suites/each';
 export * from './suites/emberish-components';
 export * from './suites/entry-point';
-export * from './suites/has-block';
-export * from './suites/has-block-params';
 export * from './suites/in-element';
-export * from './suites/initial-render';
+export * from './suites/initial-render/index';
 export * from './suites/scope';
 export * from './suites/shadowing';
 export * from './suites/ssr';
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/components.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/components.ts
index 56e989173c..b6728ba6f0 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/components.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/components.ts
@@ -3,19 +3,16 @@ import type { Dict, Owner } from '@glimmer/interfaces';
 import { GlimmerishComponent } from '../components';
 import { assertElementShape } from '../dom/assertions';
 import { assertingElement } from '../dom/simple-utils';
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render, suite } from '../test-decorator';
 import { strip, stripTight } from '../test-helpers/strings';
 import { tracked } from '../test-helpers/tracked';
 
-export class TemplateOnlyComponents extends RenderTest {
-  static suiteName = 'TemplateOnly';
-
-  @test({
-    kind: 'templateOnly',
-  })
+@suite('TemplateOnly', { kind: 'templateOnly' })
+export class TemplateOnlyComponents extends RenderTestContext {
+  @render
   'creating a new component'() {
-    this.render(
+    this.render.template(
       {
         name: 'MyComponent',
         layout: '{{yield}} - {{@color}}',
@@ -25,29 +22,27 @@ export class TemplateOnlyComponents extends RenderTest {
       { color: 'red' }
     );
 
-    this.assertHTML(`hello! - red`);
+    this.assertHTML(`<div>hello! - red</div>`);
     this.assertStableRerender();
 
     this.rerender({ color: 'green' });
-    this.assertHTML(`hello! - green`);
+    this.assertHTML(`<div>hello! - green</div>`);
     this.assertStableNodes();
 
     this.rerender({ color: 'red' });
-    this.assertHTML(`hello! - red`);
+    this.assertHTML(`<div>hello! - red</div>`);
     this.assertStableNodes();
   }
 
-  @test({
-    kind: 'templateOnly',
-  })
+  @render
   'inner ...attributes'() {
-    this.render(
+    this.render.template(
       {
         name: 'MyComponent',
-        layout: '<div><span ...attributes>{{yield}} - {{@color}}</span></div>',
+        layout: '<span ...attributes>{{yield}} - {{@color}}</span>',
         template: 'hello!',
         args: { color: 'this.color' },
-        attributes: { color: '{{this.color}}' },
+        attributes: { color: 'this.color' },
       },
       { color: 'red' }
     );
@@ -65,15 +60,12 @@ export class TemplateOnlyComponents extends RenderTest {
   }
 }
 
-export class GlimmerishComponents extends RenderTest {
-  static suiteName = 'Glimmerish';
-
-  @test({
-    kind: 'glimmer',
-  })
+@suite('Glimmerish', { kind: 'glimmer' })
+export class GlimmerishComponents extends RenderTestContext {
+  @render
   'invoking dynamic component (named arg) via angle brackets'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
-    this.render({
+    this.register.component('Glimmer', 'Foo', 'hello world!');
+    this.render.template({
       layout: '<@foo />',
       args: {
         foo: 'component "Foo"',
@@ -84,13 +76,11 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (named arg path) via angle brackets'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
-    this.render({
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Glimmer', 'Foo', 'hello world!');
+    this.render.template({
       layout: '<@stuff.Foo />',
       args: {
         stuff: 'hash Foo=(component "Foo")',
@@ -101,17 +91,15 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking curried component with attributes via angle brackets (invocation attributes clobber)'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent(
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component(
       'Glimmer',
       'Foo',
       '<p data-foo="default" ...attributes>hello world!</p>'
     );
-    this.render({
+    this.render.template({
       layout: '<@stuff.Foo data-foo="invocation" />',
       args: {
         stuff: 'hash Foo=(component "Foo")',
@@ -122,13 +110,11 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking curried component with attributes via angle brackets (invocation classes merge)'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Glimmer', 'Foo', '<p class="default" ...attributes>hello world!</p>');
-    this.render({
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Glimmer', 'Foo', '<p class="default" ...attributes>hello world!</p>');
+    this.render.template({
       layout: '<@stuff.Foo class="invocation" />',
       args: {
         stuff: 'hash Foo=(component "Foo")',
@@ -139,16 +125,14 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (named arg) via angle brackets supports attributes (invocation attributes clobber)'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       '<div data-test="default" ...attributes>hello world!</div>'
     );
-    this.render({
+    this.render.template({
       layout: '<@foo data-test="foo"/>',
       args: {
         foo: 'component "Foo"',
@@ -159,12 +143,10 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (named arg) via angle brackets supports attributes'() {
-    this.registerComponent('Glimmer', 'Foo', '<div ...attributes>hello world!</div>');
-    this.render({
+    this.register.component('Glimmer', 'Foo', '<div ...attributes>hello world!</div>');
+    this.render.template({
       layout: '<@foo data-test="foo"/>',
       args: {
         foo: 'component "Foo"',
@@ -175,12 +157,10 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (named arg) via angle brackets supports args'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello {{@name}}!');
-    this.render({
+    this.register.component('Glimmer', 'Foo', 'hello {{@name}}!');
+    this.render.template({
       layout: '<@foo @name="world" />',
       args: {
         foo: 'component "Foo"',
@@ -191,12 +171,10 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (named arg) via angle brackets supports passing a block'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello {{yield}}!');
-    this.render({
+    this.register.component('Glimmer', 'Foo', 'hello {{yield}}!');
+    this.render.template({
       layout: '<@foo>world</@foo>',
       args: {
         foo: 'component "Foo"',
@@ -207,9 +185,7 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (named arg) via angle brackets supports args and attributes'() {
     let instance = this.capture<Foo>();
 
@@ -222,14 +198,14 @@ export class GlimmerishComponents extends RenderTest {
         this.localProperty = 'local';
       }
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       '<div ...attributes>[{{this.localProperty}} {{@staticNamedArg}} {{@dynamicNamedArg}}]</div>',
       Foo
     );
 
-    this.render(
+    this.render.template(
       {
         layout: stripTight`<@foo @staticNamedArg="static" data-test1={{@outerArg}} data-test2="static" @dynamicNamedArg={{@outerArg}} />`,
         args: {
@@ -263,76 +239,64 @@ export class GlimmerishComponents extends RenderTest {
     );
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local) via angle brackets'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
-    this.render(`{{#with (component 'Foo') as |Other|}}<Other />{{/with}}`);
+    this.register.component('Glimmer', 'Foo', 'hello world!');
+    this.render.template(`{{#with (component 'Foo') as |Other|}}<Other />{{/with}}`);
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local path) via angle brackets'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
-    this.render(`{{#with (hash Foo=(component 'Foo')) as |Other|}}<Other.Foo />{{/with}}`);
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Glimmer', 'Foo', 'hello world!');
+    this.render.template(`{{#with (hash Foo=(component 'Foo')) as |Other|}}<Other.Foo />{{/with}}`);
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local) via angle brackets (ill-advised "htmlish element name" but supported)'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
-    this.render(`{{#with (component 'Foo') as |div|}}<div />{{/with}}`);
+    this.register.component('Glimmer', 'Foo', 'hello world!');
+    this.render.template(`{{#with (component 'Foo') as |div|}}<div />{{/with}}`);
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local) via angle brackets supports attributes'() {
-    this.registerComponent('Glimmer', 'Foo', '<div ...attributes>hello world!</div>');
-    this.render(`{{#with (component 'Foo') as |Other|}}<Other data-test="foo" />{{/with}}`);
+    this.register.component('Glimmer', 'Foo', '<div ...attributes>hello world!</div>');
+    this.render.template(
+      `{{#with (component 'Foo') as |Other|}}<Other data-test="foo" />{{/with}}`
+    );
 
     this.assertHTML(`<div data-test="foo">hello world!</div>`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local) via angle brackets supports args'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello {{@name}}!');
-    this.render(`{{#with (component 'Foo') as |Other|}}<Other @name="world" />{{/with}}`);
+    this.register.component('Glimmer', 'Foo', 'hello {{@name}}!');
+    this.render.template(`{{#with (component 'Foo') as |Other|}}<Other @name="world" />{{/with}}`);
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local) via angle brackets supports passing a block'() {
-    this.registerComponent('Glimmer', 'Foo', 'hello {{yield}}!');
-    this.render(`{{#with (component 'Foo') as |Other|}}<Other>world</Other>{{/with}}`);
+    this.register.component('Glimmer', 'Foo', 'hello {{yield}}!');
+    this.render.template(`{{#with (component 'Foo') as |Other|}}<Other>world</Other>{{/with}}`);
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (local) via angle brackets supports args, attributes, and blocks'() {
     let instance = this.capture<Foo>();
     class Foo extends GlimmerishComponent {
@@ -344,13 +308,13 @@ export class GlimmerishComponents extends RenderTest {
         this.localProperty = 'local';
       }
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       '<div ...attributes>[{{this.localProperty}} {{@staticNamedArg}} {{@dynamicNamedArg}}] - {{yield}}</div>',
       Foo
     );
-    this.render(
+    this.render.template(
       `{{#with (component 'Foo') as |Other|}}<Other @staticNamedArg="static" data-test1={{this.outer}} data-test2="static" @dynamicNamedArg={{this.outer}}>template</Other>{{/with}}`,
       { outer: 'outer' }
     );
@@ -378,60 +342,50 @@ export class GlimmerishComponents extends RenderTest {
     );
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets'() {
-    this.registerComponent('Glimmer', 'TestHarness', '<this.args.Foo />');
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
+    this.register.component('Glimmer', 'TestHarness', '<this.args.Foo />');
+    this.register.component('Glimmer', 'Foo', 'hello world!');
 
-    this.render('<TestHarness @Foo={{component "Foo"}} />');
+    this.render.template('<TestHarness @Foo={{component "Foo"}} />');
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets does not work for string'() {
-    this.registerComponent('Glimmer', 'TestHarness', '<this.args.Foo />');
-    this.registerComponent('Glimmer', 'Foo', 'hello world!');
+    this.register.component('Glimmer', 'TestHarness', '<this.args.Foo />');
+    this.register.component('Glimmer', 'Foo', 'hello world!');
 
     this.assert.throws(() => {
-      this.render('<TestHarness @Foo="Foo" />');
+      this.render.template('<TestHarness @Foo="Foo" />');
     }, /Expected a component definition, but received Foo. You may have accidentally done <this.args.Foo>, where "this.args.Foo" was a string instead of a curried component definition. You must either use the component definition directly, or use the \{\{component\}\} helper to create a curried component definition when invoking dynamically/u);
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets with named block'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'TestHarness',
       '<this.args.Foo><:bar>Stuff!</:bar></this.args.Foo>'
     );
-    this.registerComponent('Glimmer', 'Foo', '{{yield to="bar"}}');
+    this.register.component('Glimmer', 'Foo', '{{yield to="bar"}}');
 
-    this.render('<TestHarness @Foo={{component "Foo"}} />');
+    this.render.template('<TestHarness @Foo={{component "Foo"}} />');
 
     this.assertHTML(`Stuff!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets does not support implicit `this` fallback'() {
     this.assert.throws(() => {
-      this.registerComponent('TemplateOnly', 'Test', '<stuff.Foo />');
+      this.register.component('TemplateOnly', 'Test', '<stuff.Foo />');
     }, /stuff is not in scope/u);
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets supports attributes'() {
     class TestHarness extends GlimmerishComponent {
       public Foo: any;
@@ -441,17 +395,15 @@ export class GlimmerishComponents extends RenderTest {
         this.Foo = args['Foo'];
       }
     }
-    this.registerComponent('Glimmer', 'TestHarness', '<this.Foo data-test="foo"/>', TestHarness);
-    this.registerComponent('Glimmer', 'Foo', '<div ...attributes>hello world!</div>');
-    this.render('<TestHarness @Foo={{component "Foo"}} />');
+    this.register.component('Glimmer', 'TestHarness', '<this.Foo data-test="foo"/>', TestHarness);
+    this.register.component('Glimmer', 'Foo', '<div ...attributes>hello world!</div>');
+    this.render.template('<TestHarness @Foo={{component "Foo"}} />');
 
     this.assertHTML(`<div data-test="foo">hello world!</div>`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets supports args'() {
     class TestHarness extends GlimmerishComponent {
       public Foo: any;
@@ -461,17 +413,15 @@ export class GlimmerishComponents extends RenderTest {
         this.Foo = args['Foo'];
       }
     }
-    this.registerComponent('Glimmer', 'TestHarness', '<this.Foo @name="world"/>', TestHarness);
-    this.registerComponent('Glimmer', 'Foo', 'hello {{@name}}!');
-    this.render('<TestHarness @Foo={{component "Foo"}} />');
+    this.register.component('Glimmer', 'TestHarness', '<this.Foo @name="world"/>', TestHarness);
+    this.register.component('Glimmer', 'Foo', 'hello {{@name}}!');
+    this.render.template('<TestHarness @Foo={{component "Foo"}} />');
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets supports passing a block'() {
     class TestHarness extends GlimmerishComponent {
       public Foo: any;
@@ -481,17 +431,15 @@ export class GlimmerishComponents extends RenderTest {
         this.Foo = args['Foo'];
       }
     }
-    this.registerComponent('Glimmer', 'TestHarness', '<this.Foo>world</this.Foo>', TestHarness);
-    this.registerComponent('Glimmer', 'Foo', 'hello {{yield}}!');
-    this.render('<TestHarness @Foo={{component "Foo"}} />');
+    this.register.component('Glimmer', 'TestHarness', '<this.Foo>world</this.Foo>', TestHarness);
+    this.register.component('Glimmer', 'Foo', 'hello {{yield}}!');
+    this.render.template('<TestHarness @Foo={{component "Foo"}} />');
 
     this.assertHTML(`hello world!`);
     this.assertStableRerender();
   }
 
-  @test({
-    kind: 'glimmer',
-  })
+  @render
   'invoking dynamic component (path) via angle brackets supports args, attributes, and blocks'() {
     let instance = this.capture<Foo>();
 
@@ -513,19 +461,19 @@ export class GlimmerishComponents extends RenderTest {
         this.localProperty = 'local';
       }
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'TestHarness',
       '<this.Foo @staticNamedArg="static" data-test1={{@outer}} data-test2="static" @dynamicNamedArg={{@outer}}>template</this.Foo>',
       TestHarness
     );
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       '<div ...attributes>[{{this.localProperty}} {{@staticNamedArg}} {{@dynamicNamedArg}}] - {{yield}}</div>',
       Foo
     );
-    this.render('<TestHarness @outer={{this.outer}} @Foo={{component "Foo"}} />', {
+    this.render.template('<TestHarness @outer={{this.outer}} @Foo={{component "Foo"}} />', {
       outer: 'outer',
     });
 
@@ -552,126 +500,126 @@ export class GlimmerishComponents extends RenderTest {
     );
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can pass forward ...attributes to a nested component'() {
-    this.registerComponent('Glimmer', 'Qux', '<div data-from-qux ...attributes></div>');
-    this.registerComponent('Glimmer', 'Bar', '<Qux data-from-bar ...attributes />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar data-from-foo ...attributes />');
+    this.register.component('Glimmer', 'Qux', '<div data-from-qux ...attributes></div>');
+    this.register.component('Glimmer', 'Bar', '<Qux data-from-bar ...attributes />');
+    this.register.component('Glimmer', 'Foo', '<Bar data-from-foo ...attributes />');
 
-    this.render('<Foo data-from-top />');
+    this.render.template('<Foo data-from-top />');
     this.assertHTML('<div data-from-qux data-from-bar data-from-foo data-from-top></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can allow invocation side to override attributes with ...attributes'() {
-    this.registerComponent('Glimmer', 'Qux', '<div id="qux" ...attributes />');
-    this.registerComponent('Glimmer', 'Bar', '<Qux id="bar" ...attributes />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar id="foo" ...attributes />');
+    this.register.component('Glimmer', 'Qux', '<div id="qux" ...attributes />');
+    this.register.component('Glimmer', 'Bar', '<Qux id="bar" ...attributes />');
+    this.register.component('Glimmer', 'Foo', '<Bar id="foo" ...attributes />');
 
-    this.render('<Foo id="top" />');
+    this.render.template('<Foo id="top" />');
     this.assertHTML('<div id="top"></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can allow invocation side to override the type attribute with ...attributes'() {
-    this.registerComponent('Glimmer', 'Qux', '<div type="qux" ...attributes />');
-    this.registerComponent('Glimmer', 'Bar', '<Qux type="bar" ...attributes />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar type="foo" ...attributes />');
+    this.register.component('Glimmer', 'Qux', '<div type="qux" ...attributes />');
+    this.register.component('Glimmer', 'Bar', '<Qux type="bar" ...attributes />');
+    this.register.component('Glimmer', 'Foo', '<Bar type="foo" ...attributes />');
 
-    this.render('<Foo type="top" />');
+    this.render.template('<Foo type="top" />');
     this.assertHTML('<div type="top"></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can override invocation side attributes with ...attributes'() {
-    this.registerComponent('Glimmer', 'Qux', '<div ...attributes id="qux" />');
-    this.registerComponent('Glimmer', 'Bar', '<Qux ...attributes id="bar" />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar ...attributes id="foo" />');
+    this.register.component('Glimmer', 'Qux', '<div ...attributes id="qux" />');
+    this.register.component('Glimmer', 'Bar', '<Qux ...attributes id="bar" />');
+    this.register.component('Glimmer', 'Foo', '<Bar ...attributes id="foo" />');
 
-    this.render('<Foo id="top" />');
+    this.render.template('<Foo id="top" />');
     this.assertHTML('<div id="qux"></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can override invocation side type attribute with ...attributes'() {
-    this.registerComponent('Glimmer', 'Qux', '<div ...attributes type="qux" />');
-    this.registerComponent('Glimmer', 'Bar', '<Qux ...attributes type="bar" />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar ...attributes type="foo" />');
+    this.register.component('Glimmer', 'Qux', '<div ...attributes type="qux" />');
+    this.register.component('Glimmer', 'Bar', '<Qux ...attributes type="bar" />');
+    this.register.component('Glimmer', 'Foo', '<Bar ...attributes type="foo" />');
 
-    this.render('<Foo type="top" />');
+    this.render.template('<Foo type="top" />');
     this.assertHTML('<div type="qux"></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can forward classes before ...attributes to a nested component'() {
-    this.registerComponent('Glimmer', 'Qux', '<div class="qux" ...attributes />');
-    this.registerComponent('Glimmer', 'Bar', '<Qux class="bar" ...attributes />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar class="foo" ...attributes />');
+    this.register.component('Glimmer', 'Qux', '<div class="qux" ...attributes />');
+    this.register.component('Glimmer', 'Bar', '<Qux class="bar" ...attributes />');
+    this.register.component('Glimmer', 'Foo', '<Bar class="foo" ...attributes />');
 
-    this.render('<Foo class="top" />');
+    this.render.template('<Foo class="top" />');
     this.assertHTML('<div class="qux bar foo top"></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'angle bracket invocation can forward classes after ...attributes to a nested component'() {
-    this.registerComponent('Glimmer', 'Qux', '<div ...attributes class="qux" />');
-    this.registerComponent('Glimmer', 'Bar', '<Qux ...attributes class="bar" />');
-    this.registerComponent('Glimmer', 'Foo', '<Bar ...attributes class="foo" />');
+    this.register.component('Glimmer', 'Qux', '<div ...attributes class="qux" />');
+    this.register.component('Glimmer', 'Bar', '<Qux ...attributes class="bar" />');
+    this.register.component('Glimmer', 'Foo', '<Bar ...attributes class="foo" />');
 
-    this.render('<Foo class="top" />');
+    this.render.template('<Foo class="top" />');
     this.assertHTML('<div class="top foo bar qux"></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   '[BUG: #644 popping args should be balanced]'() {
     class MainComponent extends GlimmerishComponent {
       salutation = 'Glimmer';
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Main',
       '<div><HelloWorld @name={{this.salutation}} /></div>',
       MainComponent
     );
-    this.registerComponent('Glimmer', 'HelloWorld', '<h1>Hello {{@name}}!</h1>');
-    this.render('<Main />');
+    this.register.component('Glimmer', 'HelloWorld', '<h1>Hello {{@name}}!</h1>');
+    this.render.template('<Main />');
     this.assertHTML('<div><h1>Hello Glimmer!</h1></div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'Only one arg reference is created per argument'() {
     let count = 0;
 
-    this.registerHelper('count', () => count++);
+    this.register.helper('count', () => count++);
 
     class MainComponent extends GlimmerishComponent {
       salutation = 'Glimmer';
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Main',
       '<div><Child @value={{(count)}} /></div>',
       MainComponent
     );
-    this.registerComponent('Glimmer', 'Child', '{{@value}} {{this.args.value}}');
-    this.render('<Main />');
+    this.register.component('Glimmer', 'Child', '{{@value}} {{this.args.value}}');
+    this.render.template('<Main />');
     this.assertHTML('<div>0 0</div>');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   '[BUG] Gracefully handles application of curried args when invoke starts with 0 args'() {
     class MainComponent extends GlimmerishComponent {
       salutation = 'Glimmer';
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Main',
       '<div><HelloWorld @a={{@a}} as |wat|>{{wat}}</HelloWorld></div>',
       MainComponent
     );
-    this.registerComponent('Glimmer', 'HelloWorld', '{{yield (component "A" a=@a)}}');
-    this.registerComponent('Glimmer', 'A', 'A {{@a}}');
-    this.render('<Main @a={{this.a}} />', { a: 'a' });
+    this.register.component('Glimmer', 'HelloWorld', '{{yield (component "A" a=@a)}}');
+    this.register.component('Glimmer', 'A', 'A {{@a}}');
+    this.render.template('<Main @a={{this.a}} />', { a: 'a' });
     this.assertHTML('<div>A a</div>');
     this.assertStableRerender();
     this.rerender({ a: 'A' });
@@ -679,15 +627,15 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'Static block component helper'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'A',
       'A {{#component "B" arg1=@one arg2=@two arg3=@three}}{{/component}}'
     );
-    this.registerComponent('Glimmer', 'B', 'B {{@arg1}} {{@arg2}} {{@arg3}}');
-    this.render('<A @one={{this.first}} @two={{this.second}} @three={{this.third}} />', {
+    this.register.component('Glimmer', 'B', 'B {{@arg1}} {{@arg2}} {{@arg3}}');
+    this.render.template('<A @one={{this.first}} @two={{this.second}} @three={{this.third}} />', {
       first: 1,
       second: 2,
       third: 3,
@@ -699,11 +647,11 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'Static inline component helper'() {
-    this.registerComponent('Glimmer', 'A', 'A {{component "B" arg1=@one arg2=@two arg3=@three}}');
-    this.registerComponent('Glimmer', 'B', 'B {{@arg1}} {{@arg2}} {{@arg3}}');
-    this.render('<A @one={{this.first}} @two={{this.second}} @three={{this.third}} />', {
+    this.register.component('Glimmer', 'A', 'A {{component "B" arg1=@one arg2=@two arg3=@three}}');
+    this.register.component('Glimmer', 'B', 'B {{@arg1}} {{@arg2}} {{@arg3}}');
+    this.render.template('<A @one={{this.first}} @two={{this.second}} @three={{this.third}} />', {
       first: 1,
       second: 2,
       third: 3,
@@ -715,14 +663,14 @@ export class GlimmerishComponents extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'top level in-element'() {
-    this.registerComponent('Glimmer', 'Foo', '<Bar data-bar={{@childName}} @data={{@data}} />');
-    this.registerComponent('Glimmer', 'Bar', '<div ...attributes>Hello World</div>');
+    this.register.component('Glimmer', 'Foo', '<Bar data-bar={{@childName}} @data={{@data}} />');
+    this.register.component('Glimmer', 'Bar', '<div ...attributes>Hello World</div>');
 
-    let el = this.delegate.getInitialElement();
+    let el = this.getInitialElement();
 
-    this.render(
+    this.render.template(
       strip`
     {{#each this.components key="id" as |c|}}
       {{#in-element c.mount}}
@@ -740,7 +688,7 @@ export class GlimmerishComponents extends RenderTest {
     assertElementShape(first, 'div', { 'data-bar': 'Bar' }, 'Hello World');
   }
 
-  @test({ kind: 'glimmer' })
+  @render
   'recursive component invocation'() {
     let counter = 0;
 
@@ -757,20 +705,20 @@ export class GlimmerishComponents extends RenderTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'RecursiveInvoker',
       '{{this.id}}{{#if this.showChildren}}<RecursiveInvoker />{{/if}}',
       RecursiveInvoker
     );
 
-    this.render('<RecursiveInvoker />');
+    this.render.template('<RecursiveInvoker />');
     this.assertHTML('123<!---->');
   }
 
-  @test({ kind: 'templateOnly' })
+  @render('templateOnly')
   'throwing an error during component construction does not put result into a bad state'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       'Hello',
@@ -782,7 +730,7 @@ export class GlimmerishComponents extends RenderTest {
       }
     );
 
-    this.render('{{#if this.showing}}<Foo/>{{/if}}', {
+    this.render.template('{{#if this.showing}}<Foo/>{{/if}}', {
       showing: false,
     });
 
@@ -796,9 +744,9 @@ export class GlimmerishComponents extends RenderTest {
     this.assertHTML('', 'destroys correctly');
   }
 
-  @test({ kind: 'templateOnly' })
+  @render('templateOnly')
   'throwing an error during component construction does not put result into a bad state with multiple prior nodes'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       'Hello',
@@ -810,7 +758,7 @@ export class GlimmerishComponents extends RenderTest {
       }
     );
 
-    this.render(
+    this.render.template(
       '{{#if this.showing}}<div class="first"></div><div class="second"></div><Foo/>{{/if}}',
       {
         showing: false,
@@ -830,9 +778,9 @@ export class GlimmerishComponents extends RenderTest {
     this.assertHTML('', 'destroys correctly');
   }
 
-  @test({ kind: 'templateOnly' })
+  @render('templateOnly')
   'throwing an error during component construction does not put result into a bad state with nested components'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Foo',
       'Hello',
@@ -844,9 +792,9 @@ export class GlimmerishComponents extends RenderTest {
       }
     );
 
-    this.registerComponent('TemplateOnly', 'Bar', '<div class="second"></div><Foo/>');
+    this.register.component('TemplateOnly', 'Bar', '<div class="second"></div><Foo/>');
 
-    this.render('{{#if this.showing}}<div class="first"></div><Bar/>{{/if}}', {
+    this.render.template('{{#if this.showing}}<div class="first"></div><Bar/>{{/if}}', {
       showing: false,
     });
 
@@ -863,7 +811,7 @@ export class GlimmerishComponents extends RenderTest {
     this.assertHTML('', 'destroys correctly');
   }
 
-  @test({ kind: 'templateOnly' })
+  @render('templateOnly')
   'throwing an error during rendering gives a readable error stack'(assert: Assert) {
     // eslint-disable-next-line no-console
     let originalConsoleError = console.error;
@@ -879,7 +827,7 @@ export class GlimmerishComponents extends RenderTest {
     try {
       assert.expect(7);
 
-      this.registerComponent(
+      this.register.component(
         'Glimmer',
         'Foo',
         'Hello',
@@ -891,9 +839,9 @@ export class GlimmerishComponents extends RenderTest {
         }
       );
 
-      this.registerComponent('TemplateOnly', 'Bar', '<div class="second"></div><Foo/>');
+      this.register.component('TemplateOnly', 'Bar', '<div class="second"></div><Foo/>');
 
-      this.render('{{#if this.showing}}<div class="first"></div><Bar/>{{/if}}', {
+      this.render.template('{{#if this.showing}}<div class="first"></div><Bar/>{{/if}}', {
         showing: false,
       });
 
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/custom-dom-helper.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/custom-dom-helper.ts
index abf2623dfc..1a31f88c9c 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/custom-dom-helper.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/custom-dom-helper.ts
@@ -1,18 +1,18 @@
-import { precompile } from '@glimmer/compiler';
 import type { Cursor, ElementBuilder, Environment } from '@glimmer/interfaces';
+import { precompile } from '@glimmer/compiler';
 import { NodeDOMTreeConstruction, serializeBuilder } from '@glimmer/node';
+import { RenderTestContext } from '@glimmer-workspace/integration-tests';
 
 import { blockStack } from '../dom/blocks';
 import { toInnerHTML } from '../dom/simple-utils';
-import { AbstractNodeTest, NodeJitRenderDelegate } from '../modes/node/env';
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { NodeJitRenderDelegate, NodeRenderTest } from '../modes/node/env';
+import { render } from '../test-decorator';
 import { strip } from '../test-helpers/strings';
 
-export class DOMHelperTests extends AbstractNodeTest {
+export class DOMHelperTests extends NodeRenderTest {
   static suiteName = 'Server-side rendering in Node.js (normal)';
 
-  @test
+  @render
   'can instantiate NodeDOMTreeConstruction without a document'() {
     // this emulates what happens in Ember when using `App.visit('/', { shouldRender: false });`
 
@@ -22,10 +22,10 @@ export class DOMHelperTests extends AbstractNodeTest {
   }
 }
 
-export class CompilationTests extends RenderTest {
+export class CompilationTests extends RenderTestContext {
   static suiteName = 'Id generation';
 
-  @test
+  @render
   'generates id in node'() {
     let template = precompile('hello');
     let obj = JSON.parse(template);
@@ -47,9 +47,9 @@ export class JitSerializationDelegate extends NodeJitRenderDelegate {
 export class SerializedDOMHelperTests extends DOMHelperTests {
   static override suiteName = 'Server-side rendering in Node.js (serialize)';
 
-  @test
+  @render
   'The compiler can handle unescaped HTML'() {
-    this.render('<div>{{{this.title}}}</div>', { title: '<strong>hello</strong>' });
+    this.render.template('<div>{{{this.title}}}</div>', { title: '<strong>hello</strong>' });
     let b = blockStack();
     this.assertHTML(strip`
       <div>
@@ -62,10 +62,10 @@ export class SerializedDOMHelperTests extends DOMHelperTests {
     `);
   }
 
-  @test
+  @render
   'Unescaped helpers render correctly'() {
-    this.registerHelper('testing-unescaped', (params) => params[0]);
-    this.render('{{{testing-unescaped "<span>hi</span>"}}}');
+    this.register.helper('testing-unescaped', (params) => params[0]);
+    this.render.template('{{{testing-unescaped "<span>hi</span>"}}}');
     let b = blockStack();
     this.assertHTML(strip`
       ${b(1)}
@@ -76,15 +76,15 @@ export class SerializedDOMHelperTests extends DOMHelperTests {
     `);
   }
 
-  @test
+  @render
   'Null literals do not have representation in DOM'() {
-    this.render('{{null}}');
+    this.render.template('{{null}}');
     this.assertHTML(strip`<!--% %-->`);
   }
 
-  @test
+  @render
   'Elements inside a yielded block'() {
-    this.render('{{#if true}}<div id="test">123</div>{{/if}}');
+    this.render.template('{{#if true}}<div id="test">123</div>{{/if}}');
     let b = blockStack();
     this.assertHTML(strip`
       ${b(1)}
@@ -93,9 +93,9 @@ export class SerializedDOMHelperTests extends DOMHelperTests {
     `);
   }
 
-  @test
+  @render
   'A simple block helper can return text'() {
-    this.render('{{#if true}}test{{else}}not shown{{/if}}');
+    this.render.template('{{#if true}}test{{else}}not shown{{/if}}');
     let b = blockStack();
     this.assertHTML(strip`
       ${b(1)}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/debugger.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/debugger.ts
index 1b3e22cb37..6f24d03f1b 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/debugger.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/debugger.ts
@@ -1,16 +1,16 @@
 import { resetDebuggerCallback, setDebuggerCallback } from '@glimmer/runtime';
 
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render } from '../test-decorator';
 
-export class DebuggerSuite extends RenderTest {
+export class DebuggerSuite extends RenderTestContext {
   static suiteName = 'Debugger';
 
-  afterEach() {
+  override readonly afterEach = () => {
     resetDebuggerCallback();
-  }
+  };
 
-  @test
+  @render
   'basic debugger statement'() {
     let expectedContext = {
       foo: 'bar',
@@ -26,7 +26,7 @@ export class DebuggerSuite extends RenderTest {
       this.assert.strictEqual(get('foo'), expectedContext.foo);
     });
 
-    this.render(
+    this.render.template(
       '{{#if this.a.b}}true{{debugger}}{{else}}false{{debugger}}{{/if}}',
       expectedContext
     );
@@ -57,7 +57,7 @@ export class DebuggerSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'can get locals'() {
     let expectedContext = {
       foo: 'bar',
@@ -74,7 +74,7 @@ export class DebuggerSuite extends RenderTest {
       this.assert.deepEqual(get('this'), context);
     });
 
-    this.render(
+    this.render.template(
       '{{#with this.foo as |bar|}}{{#if this.a.b}}true{{debugger}}{{else}}false{{debugger}}{{/if}}{{/with}}',
       expectedContext
     );
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/each.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/each.ts
index 8726ccb9a4..3c65b0cf4d 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/each.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/each.ts
@@ -1,32 +1,36 @@
+import type { TagDescription } from '@glimmer/interfaces/index';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { beginTestSteps, endTestSteps, verifySteps } from '@glimmer/util';
+import { beginTestSteps, devmode, endTestSteps, verifySteps } from '@glimmer/util';
 import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
 
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render } from '../test-decorator';
 import { tracked } from '../test-helpers/tracked';
 
-export class EachSuite extends RenderTest {
+export class EachSuite extends RenderTestContext {
   static suiteName = '#each';
 
-  beforeEach() {
+  override readonly beforeEach = () => {
     if (LOCAL_DEBUG) {
       beginTestSteps?.();
     }
-  }
+  };
 
-  afterEach() {
+  override readonly afterEach = () => {
     if (LOCAL_DEBUG) {
       endTestSteps?.();
     }
-  }
+  };
 
-  @test
+  @render
   'basic #each'() {
     let list = [1, 2, 3, 4];
-    this.render('{{#each this.list key="@index" as |item|}}{{item}}{{else}}Empty{{/each}}', {
-      list,
-    });
+    this.render.template(
+      '{{#each this.list key="@index" as |item|}}{{item}}{{else}}Empty{{/each}}',
+      {
+        list,
+      }
+    );
     this.assertHTML('1234');
     this.assertStableRerender();
 
@@ -46,7 +50,7 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'autotracked custom iterable'() {
     if (typeof Symbol !== 'function') {
       QUnit.assert.ok(true, 'skipping platform without iterable');
@@ -55,7 +59,15 @@ export class EachSuite extends RenderTest {
 
     let list = {
       arr: [1, 2, 3, 4],
-      tag: createTag(),
+      tag: createTag(
+        devmode(
+          () =>
+            ({
+              reason: 'cell',
+              label: ['list'],
+            }) satisfies TagDescription
+        )
+      ),
 
       [Symbol.iterator]() {
         consumeTag(this.tag);
@@ -72,9 +84,12 @@ export class EachSuite extends RenderTest {
         this.arr.splice(0, this.arr.length);
       },
     };
-    this.render('{{#each this.list key="@index" as |item|}}{{item}}{{else}}Empty{{/each}}', {
-      list,
-    });
+    this.render.template(
+      '{{#each this.list key="@index" as |item|}}{{item}}{{else}}Empty{{/each}}',
+      {
+        list,
+      }
+    );
     this.assertHTML('1234');
     this.assertStableRerender();
 
@@ -94,12 +109,15 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'keyed #each'() {
     let list = [{ text: 'hello' }];
-    this.render('{{#each this.list key="text" as |item|}}{{item.text}}{{else}}Empty{{/each}}', {
-      list,
-    });
+    this.render.template(
+      '{{#each this.list key="text" as |item|}}{{item.text}}{{else}}Empty{{/each}}',
+      {
+        list,
+      }
+    );
     this.assertHTML('hello');
     this.assertStableRerender();
 
@@ -120,10 +138,21 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
+  'an empty list'() {
+    let list: number[] = [];
+    this.render.template(
+      '{{#each this.list key="@index" as |item|}}{{item}}{{else}}Empty{{/each}}',
+      { list }
+    );
+    this.assertHTML('Empty');
+    this.assertStableRerender();
+  }
+
+  @render
   'receives the index as the second parameter'() {
     let list = [1, 2, 3, 4];
-    this.render(
+    this.render.template(
       '{{#each this.list key="@index" as |item i|}}{{item}}-{{i}}:{{else}}Empty{{/each}}',
       {
         list,
@@ -148,7 +177,7 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'receives the index as the second parameter (when key=@identity)'() {
     let v1 = val(1);
     let v2 = val(2);
@@ -158,7 +187,7 @@ export class EachSuite extends RenderTest {
     let v6 = val(6);
 
     let list = [v1, v2, v3, v4];
-    this.render(
+    this.render.template(
       '{{#each this.list key="@identity" as |item i|}}{{item.val}}-{{i}}{{else}}Empty{{/each}}',
       {
         list,
@@ -188,10 +217,10 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'it can render duplicate primitive items'() {
     let list = ['a', 'a', 'a'];
-    this.render('{{#each this.list key="@index" as |item|}}{{item}}{{/each}}', {
+    this.render.template('{{#each this.list key="@index" as |item|}}{{item}}{{/each}}', {
       list,
     });
     this.assertHTML('aaa');
@@ -208,11 +237,11 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'it can render duplicate objects'() {
     let dup = { text: 'dup' };
     let list = [dup, dup, { text: 'uniq' }];
-    this.render('{{#each this.list key="@index" as |item|}}{{item.text}}{{/each}}', {
+    this.render.template('{{#each this.list key="@index" as |item|}}{{item.text}}{{/each}}', {
       list,
     });
     this.assertHTML('dupdupuniq');
@@ -229,7 +258,7 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'it renders all items with duplicate key values'() {
     class Item {
       @tracked text: string;
@@ -241,7 +270,7 @@ export class EachSuite extends RenderTest {
 
     let list = [new Item('Hello'), new Item('Hello'), new Item('Hello')];
 
-    this.render(`{{#each this.list key="text" as |item|}}{{item.text}}{{/each}}`, {
+    this.render.template(`{{#each this.list key="text" as |item|}}{{item.text}}{{/each}}`, {
       list,
     });
 
@@ -261,7 +290,7 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'it updates items if their key has not changed, and the items are tracked'() {
     class Item {
       @tracked public text: string;
@@ -273,7 +302,7 @@ export class EachSuite extends RenderTest {
 
     let list = [new Item('Hello'), new Item('Hello'), new Item('Hello')];
 
-    this.render(`{{#each this.list key="@identity" as |item|}}{{item.text}}{{/each}}`, {
+    this.render.template(`{{#each this.list key="@identity" as |item|}}{{item.text}}{{/each}}`, {
       list,
     });
 
@@ -293,11 +322,11 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'it does not update items if their key has not changed, and the items are not tracked'() {
     let list = [{ text: 'Hello' }, { text: 'Hello' }, { text: 'Hello' }];
 
-    this.render(`{{#each this.list key="@identity" as |item|}}{{item.text}}{{/each}}`, {
+    this.render.template(`{{#each this.list key="@identity" as |item|}}{{item.text}}{{/each}}`, {
       list,
     });
 
@@ -311,11 +340,11 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'scoped variable not available outside list'() {
     let list = ['Wycats'];
 
-    this.render(
+    this.render.template(
       `{{this.name}}-{{#each this.list key="@index" as |name|}}{{name}}{{/each}}-{{this.name}}`,
       {
         list,
@@ -342,11 +371,11 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'else template is displayed with context'() {
     let list: string[] = [];
 
-    this.render(
+    this.render.template(
       `{{#each this.list key="@index" as |name|}}Has thing{{else}}No thing {{this.otherThing}}{{/each}}`,
       {
         list,
@@ -371,12 +400,12 @@ export class EachSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'When re-iterated via swap #1, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = numbers();
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let a = arr[1];
     let b = arr[7];
@@ -401,12 +430,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #2, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = numbers();
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let a = arr[0];
     let b = arr[7];
@@ -431,12 +460,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #3, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = numbers();
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let a = arr[0];
     let b = arr[6];
@@ -461,12 +490,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #4, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = numbers();
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let a = arr[1];
     let b = arr[3];
@@ -495,12 +524,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #5, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = numbers();
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let a = arr[1];
     let b = arr[3];
@@ -527,12 +556,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #6, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = numbers();
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let a = arr[1];
     let b = arr[6];
@@ -560,12 +589,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #7, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = [1, 2, 3, 4, 5, 6, 7, 8];
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     arr.shift();
     arr.splice(2, 0, 9);
@@ -589,12 +618,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #8, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = [1, 2, 3, 4, 5, 6, 7, 8];
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let shifted = [8, 1, 2, 3, 4, 5, 6, 7];
 
@@ -616,12 +645,12 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #9, the original references are updated'() {
     if (!LOCAL_DEBUG) return;
 
     let arr = [1, 2, 3, 4, 5, 6, 7, 8];
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     let shifted = [2, 3, 4, 5, 6, 7, 8, 1];
 
@@ -643,18 +672,17 @@ export class EachSuite extends RenderTest {
     );
   }
 
-  @test
+  @render
   'When re-iterated via swap #10, the original references are updated'(assert: Assert) {
     if (!LOCAL_DEBUG) return;
 
     let arr = [1, 2, 3, 4, 5, 6, 7, 8];
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     for (let i = 0; i < 100; i++) {
       shuffleArray(arr);
       this.rerender({ arr });
 
-       
       verifySteps?.('list-updates', (steps) => {
         let stats = getStepStats(steps as ListStep[]);
 
@@ -668,12 +696,12 @@ export class EachSuite extends RenderTest {
     }
   }
 
-  @test
+  @render
   'When re-iterated via swap #11, the original references are updated'(assert: Assert) {
     if (!LOCAL_DEBUG) return;
 
     let arr = [1, 2, 3, 4, 5, 6, 7, 8];
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     for (let i = 0; i < 100; i++) {
       let newArr = arr.slice();
@@ -681,7 +709,6 @@ export class EachSuite extends RenderTest {
       let semiArr = newArr.slice(0, 5);
       this.rerender({ arr: semiArr });
 
-       
       verifySteps?.('list-updates', (steps) => {
         let stats = getStepStats(steps as ListStep[]);
 
@@ -695,12 +722,12 @@ export class EachSuite extends RenderTest {
     }
   }
 
-  @test
+  @render
   'When re-iterated via swap #12, the original references are updated'(assert: Assert) {
     if (!LOCAL_DEBUG) return;
 
     let arr = [1, 2, 3, 4, 5, 6, 7, 8];
-    this.render(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
+    this.render.template(`{{#each this.arr as |item|}}{{item}}{{/each}}`, { arr });
 
     for (let i = 0; i < 100; i++) {
       let newArr = arr.slice();
@@ -708,7 +735,6 @@ export class EachSuite extends RenderTest {
       let semiArr = newArr.slice(0, 5).concat([11, 12]);
       this.rerender({ arr: semiArr });
 
-       
       verifySteps?.('list-updates', (steps) => {
         let stats = getStepStats(steps as ListStep[]);
 
@@ -722,16 +748,19 @@ export class EachSuite extends RenderTest {
     }
   }
 
-  @test
+  @render
   're-iterating nested arrays works'() {
     let arr = [
       [1, 2, 3, 4, 5],
       [4, 5, 6, 7, 8],
       [5, 6, 7, 8, 9],
     ];
-    this.render(`{{#each this.arr as |sub|}}{{#each sub as |item|}}{{item}}{{/each}}{{/each}}`, {
-      arr,
-    });
+    this.render.template(
+      `{{#each this.arr as |sub|}}{{#each sub as |item|}}{{item}}{{/each}}{{/each}}`,
+      {
+        arr,
+      }
+    );
 
     for (let i = 0; i < 100; i++) {
       for (let sub of arr) {
@@ -791,6 +820,6 @@ function numbers() {
     number,
     number,
     number,
-    number
+    number,
   ];
 }
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/emberish-components.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/emberish-components.ts
index 1a57c8c142..aeef622ed3 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/emberish-components.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/emberish-components.ts
@@ -1,24 +1,28 @@
 import type { SimpleElement } from '@glimmer/interfaces';
+import { unwrap } from '@glimmer/util';
+
+import type { RenderTestState } from '../test-helpers/module';
 
 import { EmberishCurlyComponent } from '../components';
 import { assertEmberishElement, classes } from '../dom/assertions';
 import { assertingElement, toInnerHTML } from '../dom/simple-utils';
-import { type Count, RenderTest } from '../render-test';
+import { RenderTestContext } from '../render-test';
 import { equalTokens } from '../snapshot';
-import { test } from '../test-decorator';
-import { unwrap } from '@glimmer/util';
+import { render, suite } from '../test-decorator';
+import { defineComponent } from '../test-helpers/define';
 
-export class EmberishComponentTests extends RenderTest {
-  static suiteName = 'Emberish';
+@suite('Emberish', 'curly')
+export class EmberishComponentTests extends RenderTestContext {
+  @render
+  'Element modifier with hooks'(assert: RenderTestState) {
+    const { events } = assert;
 
-  @test
-  'Element modifier with hooks'(assert: Assert, count: Count) {
-    this.registerModifier(
+    this.register.modifier(
       'foo',
       class {
         element?: SimpleElement;
         didInsertElement() {
-          count.expect('didInsertElement');
+          events.record('didInsertElement');
           assert.ok(this.element, 'didInsertElement');
           assert.strictEqual(
             unwrap(this.element).getAttribute('data-ok'),
@@ -28,29 +32,34 @@ export class EmberishComponentTests extends RenderTest {
         }
 
         didUpdate() {
-          count.expect('didUpdate');
+          events.record('didUpdate');
           assert.ok(true, 'didUpdate');
         }
 
         willDestroyElement() {
-          count.expect('willDestroyElement');
+          events.record('willDestroyElement');
           assert.ok(true, 'willDestroyElement');
         }
       }
     );
 
-    this.render('{{#if this.ok}}<div data-ok=true {{foo this.bar}}></div>{{/if}}', {
+    this.render.template('{{#if this.ok}}<div data-ok=true {{foo this.bar}}></div>{{/if}}', {
       bar: 'bar',
       ok: true,
     });
 
+    events.expect(['didInsertElement']);
+
     this.rerender({ bar: 'foo' });
+    events.expect(['didUpdate']);
+
     this.rerender({ ok: false });
+    events.expect(['willDestroyElement']);
   }
 
-  @test
+  @render
   'non-block without properties'() {
-    this.render({
+    this.render.template({
       layout: 'In layout',
     });
 
@@ -58,9 +67,9 @@ export class EmberishComponentTests extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'block without properties'() {
-    this.render({
+    this.render.template({
       layout: 'In layout -- {{yield}}',
       template: 'In template',
     });
@@ -69,9 +78,9 @@ export class EmberishComponentTests extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yield inside a conditional on the component'() {
-    this.render(
+    this.render.template(
       {
         layout: 'In layout -- {{#if @predicate}}{{yield}}{{/if}}',
         template: 'In template',
@@ -92,9 +101,9 @@ export class EmberishComponentTests extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'non-block with properties on attrs'() {
-    this.render({
+    this.render.template({
       layout: 'In layout - someProp: {{@someProp}}',
       args: { someProp: '"something here"' },
     });
@@ -103,9 +112,9 @@ export class EmberishComponentTests extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'block with properties on attrs'() {
-    this.render({
+    this.render.template({
       layout: 'In layout - someProp: {{@someProp}} - {{yield}}',
       template: 'In template',
       args: { someProp: '"something here"' },
@@ -115,75 +124,87 @@ export class EmberishComponentTests extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({ skip: true, kind: 'curly' })
+  @render({ invokeAs: 'glimmer' })
   'with ariaRole specified'() {
-    this.render({
+    this.render.template({
       layout: 'Here!',
-      attributes: { id: '"aria-test"', ariaRole: '"main"' },
+      attributes: { id: '"aria-test"', role: '"main"' },
     });
 
-    this.assertComponent('Here!', { id: '"aria-test"', role: '"main"' });
+    this.assertComponent('Here!', { id: 'aria-test', role: 'main' });
     this.assertStableRerender();
   }
 
-  @test({ skip: true, kind: 'curly' })
+  @render({ invokeAs: 'glimmer' })
   'with ariaRole and class specified'() {
-    this.render({
-      layout: 'Here!',
-      attributes: { id: '"aria-test"', class: '"foo"', ariaRole: '"main"' },
-    });
+    this.render.template(
+      {
+        layout: 'Here!',
+        attributes: { id: '"aria-test"', class: '"foo"', role: 'this.ariaRole' },
+      },
+      { ariaRole: 'main' }
+    );
 
     this.assertComponent('Here!', {
-      id: '"aria-test"',
+      id: 'aria-test',
       class: classes('ember-view foo'),
-      role: '"main"',
+      role: 'main',
     });
     this.assertStableRerender();
   }
 
-  @test({ skip: true, kind: 'curly' })
+  @render({ invokeAs: 'glimmer' })
   'with ariaRole specified as an outer binding'() {
-    this.render(
+    this.render.template(
       {
         layout: 'Here!',
-        attributes: { id: '"aria-test"', class: '"foo"', ariaRole: 'ariaRole' },
+        attributes: { id: '"aria-test"', class: '"foo"', role: 'this.ariaRole' },
       },
       { ariaRole: 'main' }
     );
 
     this.assertComponent('Here!', {
-      id: '"aria-test"',
+      id: 'aria-test',
       class: classes('ember-view foo'),
-      role: '"main"',
+      role: 'main',
     });
     this.assertStableRerender();
   }
 
-  @test({ skip: true, kind: 'glimmer' })
+  @render('glimmer')
   'glimmer component with role specified as an outer binding and copied'() {
-    this.render(
-      {
-        layout: 'Here!',
-        attributes: { id: '"aria-test"', role: 'myRole' },
-      },
-      { myRole: 'main' }
+    const TestComponent = defineComponent({}, `<div ...attributes>Here!</div>`);
+
+    const component = defineComponent(
+      { myRole: 'main', TestComponent },
+      `<TestComponent id="aria-test" role={{myRole}}></TestComponent>`
     );
 
-    this.assertComponent('Here!', { id: '"aria-test"', role: '"main"' });
+    this.render.component(component);
+
+    // this.render.template(
+    //   {
+    //     layout: 'Here!',
+    //     attributes: { id: '"aria-test"', role: 'this.myRole' },
+    //   },
+    //   { myRole: 'main' }
+    // );
+
+    this.assertComponent('Here!', { id: 'aria-test', role: 'main' });
     this.assertStableRerender();
   }
 
-  @test({ kind: 'curly' })
+  @render('curly')
   'invoking wrapped layout via angle brackets applies ...attributes'() {
-    this.registerComponent('Curly', 'FooBar', 'Hello world!');
+    this.register.component('Curly', 'FooBar', 'Hello world!');
 
-    this.render(`<FooBar data-foo="bar" />`);
+    this.render.template(`<FooBar data-foo="bar" />`);
 
     this.assertComponent('Hello world!', { 'data-foo': 'bar' });
     this.assertStableRerender();
   }
 
-  @test({ kind: 'curly' })
+  @render('curly')
   'invoking wrapped layout via angle brackets - invocation attributes clobber internal attributes'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -194,16 +215,16 @@ export class EmberishComponentTests extends RenderTest {
         this['data-foo'] = 'inner';
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello world!', FooBar);
 
-    this.render(`<FooBar data-foo="outer" />`);
+    this.render.template(`<FooBar data-foo="outer" />`);
 
     this.assertComponent('Hello world!', { 'data-foo': 'outer' });
     this.assertStableRerender();
   }
 
   // LOCKS
-  @test({ kind: 'curly' })
+  @render('curly')
   'yields named block'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -212,16 +233,16 @@ export class EmberishComponentTests extends RenderTest {
         super();
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello{{yield to="baz"}}world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello{{yield to="baz"}}world!', FooBar);
 
-    this.render(`<FooBar><:baz> my </:baz></FooBar>`);
+    this.render.template(`<FooBar><:baz> my </:baz></FooBar>`);
 
     this.assertComponent('Hello my world!');
     this.assertStableRerender();
   }
 
   // LOCKS
-  @test({ kind: 'curly' })
+  @render('curly')
   'implicit default named block'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -230,16 +251,16 @@ export class EmberishComponentTests extends RenderTest {
         super();
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello{{yield}}world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello{{yield}}world!', FooBar);
 
-    this.render(`<FooBar> my </FooBar>`);
+    this.render.template(`<FooBar> my </FooBar>`);
 
     this.assertComponent('Hello my world!');
     this.assertStableRerender();
   }
 
   // LOCKS
-  @test({ kind: 'curly' })
+  @render('curly')
   'explicit default named block'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -248,16 +269,16 @@ export class EmberishComponentTests extends RenderTest {
         super();
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello{{yield to="default"}}world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello{{yield to="default"}}world!', FooBar);
 
-    this.render(`<FooBar><:default> my </:default></FooBar>`);
+    this.render.template(`<FooBar><:default> my </:default></FooBar>`);
 
     this.assertComponent('Hello my world!');
     this.assertStableRerender();
   }
 
   // LOCKS
-  @test({ kind: 'curly' })
+  @render('curly')
   'else named block'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -266,15 +287,15 @@ export class EmberishComponentTests extends RenderTest {
         super();
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello{{yield "my" to="inverse"}}world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello{{yield "my" to="inverse"}}world!', FooBar);
 
-    this.render(`<FooBar><:else as |value|> {{value}} </:else></FooBar>`);
+    this.render.template(`<FooBar><:else as |value|> {{value}} </:else></FooBar>`);
 
     this.assertComponent('Hello my world!');
     this.assertStableRerender();
   }
 
-  @test({ kind: 'curly' })
+  @render('curly')
   'inverse named block'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -283,15 +304,15 @@ export class EmberishComponentTests extends RenderTest {
         super();
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello{{yield "my" to="inverse"}}world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello{{yield "my" to="inverse"}}world!', FooBar);
 
-    this.render(`<FooBar><:inverse as |value|> {{value}} </:inverse></FooBar>`);
+    this.render.template(`<FooBar><:inverse as |value|> {{value}} </:inverse></FooBar>`);
 
     this.assertComponent('Hello my world!');
     this.assertStableRerender();
   }
 
-  @test({ kind: 'curly' })
+  @render('curly')
   'invoking wrapped layout via angle brackets - invocation attributes merges classes'() {
     class FooBar extends EmberishCurlyComponent {
       [index: string]: unknown;
@@ -302,19 +323,19 @@ export class EmberishComponentTests extends RenderTest {
         this['class'] = 'inner';
       }
     }
-    this.registerComponent('Curly', 'FooBar', 'Hello world!', FooBar);
+    this.register.component('Curly', 'FooBar', 'Hello world!', FooBar);
 
-    this.render(`<FooBar class="outer" />`);
+    this.render.template(`<FooBar class="outer" />`);
 
     this.assertComponent('Hello world!', { class: classes('ember-view inner outer') });
     this.assertStableRerender();
   }
 
-  @test({ kind: 'curly' })
+  @render('curly')
   'invoking wrapped layout via angle brackets also applies explicit ...attributes'() {
-    this.registerComponent('Curly', 'FooBar', '<h1 ...attributes>Hello world!</h1>');
+    this.register.component('Curly', 'FooBar', '<h1 ...attributes>Hello world!</h1>');
 
-    this.render(`<FooBar data-foo="bar" />`);
+    this.render.template(`<FooBar data-foo="bar" />`);
 
     let wrapperElement = assertingElement(this.element.firstChild);
     assertEmberishElement(wrapperElement, 'div', { 'data-foo': 'bar' });
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/entry-point.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/entry-point.ts
index c0c388ce4d..c70d20b07e 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/entry-point.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/entry-point.ts
@@ -1,85 +1,61 @@
-import { createPrimitiveRef } from '@glimmer/reference';
+import { createPrimitiveCell } from '@glimmer/reference';
 import { DynamicScopeImpl } from '@glimmer/runtime';
 import { castToBrowser } from '@glimmer/util';
+import { ClientSideRenderDelegate, matrix } from '@glimmer-workspace/integration-tests';
 
-import type { ComponentKind } from '../components/types';
-import { JitRenderDelegate } from '../modes/jit/delegate';
-import { Count, RenderTest } from '../render-test';
-import { test } from '../test-decorator';
 import { defineComponent } from '../test-helpers/define';
 
-export class EntryPointTest extends RenderTest {
-  static suiteName = 'entry points';
-
-  declare readonly testType: ComponentKind;
-
-  override readonly count = new Count();
-
-  @test
-  'an entry point'() {
-    let delegate = new JitRenderDelegate();
+matrix('entry points', (spec) => {
+  spec('an entry point', (ctx) => {
     let Title = defineComponent({}, `<h1>hello {{@title}}</h1>`);
 
-    let element = delegate.getInitialElement();
-    let title = createPrimitiveRef('renderComponent');
-    delegate.renderComponent(Title, { title }, element);
+    ctx.render.component(Title, { title: 'renderComponent' }, { into: ctx.element });
 
     QUnit.assert.strictEqual(
-      castToBrowser(element, 'HTML').innerHTML,
+      castToBrowser(ctx.element, 'HTML').innerHTML,
       '<h1>hello renderComponent</h1>'
     );
-  }
+  });
 
-  @test
-  'does not leak args between invocations'() {
-    let delegate = new JitRenderDelegate();
+  spec('does not leak args between invocations', (ctx) => {
+    let delegate = new ClientSideRenderDelegate();
     let Title = defineComponent({}, `<h1>hello {{@title}}</h1>`);
 
-    let element = delegate.getInitialElement();
-    let title = createPrimitiveRef('renderComponent');
-    delegate.renderComponent(Title, { title }, element);
+    let element = delegate.dom.getInitialElement(delegate.dom.document);
+    ctx.render.component(Title, { title: 'renderComponent' }, { into: element });
     QUnit.assert.strictEqual(
       castToBrowser(element, 'HTML').innerHTML,
       '<h1>hello renderComponent</h1>'
     );
 
-    element = delegate.getInitialElement();
-    let newTitle = createPrimitiveRef('new title');
-    delegate.renderComponent(Title, { title: newTitle }, element);
+    element = ctx.getClearedElement();
+    ctx.render.component(Title, { title: 'new title' }, { into: element });
     QUnit.assert.strictEqual(castToBrowser(element, 'HTML').innerHTML, '<h1>hello new title</h1>');
-  }
+  });
 
-  @test
-  'can render different components per call'() {
-    let delegate = new JitRenderDelegate();
+  spec('can render different components per call', (ctx) => {
     let Title = defineComponent({}, `<h1>hello {{@title}}</h1>`);
     let Body = defineComponent({}, `<p>body {{@body}}</p>`);
 
-    let element = delegate.getInitialElement();
-    let title = createPrimitiveRef('renderComponent');
-    delegate.renderComponent(Title, { title }, element);
+    ctx.render.component(Title, { title: 'renderComponent' });
     QUnit.assert.strictEqual(
-      castToBrowser(element, 'HTML').innerHTML,
+      castToBrowser(ctx.element, 'HTML').innerHTML,
       '<h1>hello renderComponent</h1>'
     );
 
-    element = delegate.getInitialElement();
-    let body = createPrimitiveRef('text');
-    delegate.renderComponent(Body, { body }, element);
+    const element = ctx.getClearedElement();
+    ctx.render.component(Body, { body: 'text' }, { into: element });
     QUnit.assert.strictEqual(castToBrowser(element, 'HTML').innerHTML, '<p>body text</p>');
-  }
+  });
 
-  @test
-  'supports passing in an initial dynamic context'() {
-    let delegate = new JitRenderDelegate();
+  spec('supports passing in an initial dynamic context', (ctx) => {
     let Locale = defineComponent({}, `{{-get-dynamic-var "locale"}}`);
 
-    let element = delegate.getInitialElement();
     let dynamicScope = new DynamicScopeImpl({
-      locale: createPrimitiveRef('en_US'),
+      locale: createPrimitiveCell('en_US'),
     });
-    delegate.renderComponent(Locale, {}, element, dynamicScope);
+    ctx.render.component(Locale, {}, { dynamicScope });
 
-    QUnit.assert.strictEqual(castToBrowser(element, 'HTML').innerHTML, 'en_US');
-  }
-}
+    QUnit.assert.strictEqual(castToBrowser(ctx.element, 'HTML').innerHTML, 'en_US');
+  });
+}).client();
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/error-recovery.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/error-recovery.ts
new file mode 100644
index 0000000000..c4c396e78c
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/error-recovery.ts
@@ -0,0 +1,209 @@
+import { render, RenderTestContext, stripTight } from '@glimmer-workspace/integration-tests';
+
+export class ErrorRecoverySuite extends RenderTestContext {
+  static suiteName = 'ErrorRecovery';
+
+  @render
+  'if no error is thrown, everything works as expected'() {
+    const actions = new Actions();
+
+    this.render.template('{{#-try}}message: {{this.message}}{{/-try}}', {
+      message: 'hello',
+    });
+
+    actions.expect([]);
+  }
+
+  @render('templateOnly')
+  'if no error is thrown and a component is rendered, everything works as expected'() {
+    this.register.component('TemplateOnly', 'Message', '{{yield}}');
+
+    this.render.template('{{#-try}}message: <Message />>{{/-try}}', {});
+  }
+
+  @render
+  'if the error is handled, the DOM is cleaned up'() {
+    const actions = new Actions();
+
+    class Woops {
+      get woops() {
+        actions.record('get woops');
+        throw Error('woops');
+      }
+    }
+
+    this.render.template('{{#-try this.handler}}message: [{{this.woops.woops}}]{{/-try}}', {
+      woops: new Woops(),
+      handler: (_err: unknown, _retry: () => void) => {
+        // it only runs once
+        actions.record('error handled');
+      },
+    });
+
+    actions.expect(['get woops', 'error handled']);
+    this.assertHTML('<!---->');
+  }
+
+  @render
+  'if the error is unhandled, the DOM is cleaned up'(assert: Assert) {
+    const actions = new Actions();
+
+    class Woops {
+      get woops() {
+        actions.record('get woops');
+        throw Error('woops');
+      }
+    }
+
+    assert.throws(() => {
+      this.render.template('{{#-try}}message: [{{this.woops.woops}}]{{/-try}}', {
+        woops: new Woops(),
+      });
+    });
+
+    actions.expect(['get woops']);
+    this.assertHTML('<!---->');
+  }
+
+  @render
+  'error boundaries can happen in nested context'() {
+    const actions = new Actions();
+
+    class Woops {
+      get woops() {
+        actions.record('get woops');
+        throw Error('woops');
+      }
+    }
+
+    this.render.template(
+      stripTight`
+        <p>
+          {{this.outer.before}}|
+          {{#-try this.handler}}
+            {{this.inner.before}}|message: [{{this.woops.woops}}]|{{this.inner.after}}
+          {{/-try}}
+          |{{this.outer.after}}
+        </p>
+      `,
+      {
+        woops: new Woops(),
+        outer: {
+          before: 'outer:before',
+          after: 'outer:after',
+        },
+        inner: {
+          before: 'inner:before',
+          after: 'inner:after',
+        },
+        handler: (_err: unknown, _retry: () => void) => {
+          actions.record('error handled');
+        },
+      }
+    );
+
+    actions.expect(['get woops', 'error handled']);
+    this.assertHTML('<p>outer:before|<!---->|outer:after</p>');
+  }
+
+  // @test
+  // 'errors are rethrown during initial render and DOM is cleaned up'() {
+  //   const actions = new Actions();
+
+  //   class Counter {
+  //     @tracked count = 0;
+
+  //     get message() {
+  //       actions.record(`get message`);
+  //       if (this.count === 0) {
+  //         throw Error('woops');
+  //       } else {
+  //         return String(this.count);
+  //       }
+  //     }
+  //   }
+
+  //   let counter = new Counter();
+
+  //   this.render('message: [{{this.counter.message}}]', {
+  //     counter,
+  //   });
+  //   this.#assertRenderError('woops');
+
+  //   actions.expect(['get message']);
+
+  //   // counter.count++;
+
+  //   // this.rerender();
+
+  //   // this.assertHTML('message: [1]');
+  //   // actions.expect(['get message']);
+  // }
+
+  // @test
+  // 'errors are rethrown during rerender and DOM is cleaned up'() {
+  //   const actions = new Actions();
+
+  //   class Counter {
+  //     @tracked count = 0;
+
+  //     get message() {
+  //       actions.record(`get message`);
+  //       if (this.count === 1) {
+  //         throw Error('woops');
+  //       } else {
+  //         return String(this.count);
+  //       }
+  //     }
+  //   }
+
+  //   let counter = new Counter();
+
+  //   this.render('message: [{{this.counter.message}}]', {
+  //     counter,
+  //   });
+
+  //   this.assertHTML('message: [0]');
+  //   actions.expect(['get message']);
+
+  //   // counter.count++;
+
+  //   // this.rerender();
+
+  //   // this.#assertRenderError('woops');
+
+  //   // actions.expect(['get message']);
+
+  //   // counter.count++;
+
+  //   // this.rerender();
+
+  //   // this.assertHTML('message: [2]');
+  //   // actions.expect(['get message']);
+  // }
+
+  // @test
+  // 'helper destructors run on rollback'(assert: Assert) {
+  //   assert.false(true, 'TODO');
+  // }
+
+  // @test
+  // 'the tracking frame is cleared when an error was thrown'(assert: Assert) {
+  //   assert.false(true, 'TODO');
+  // }
+}
+
+class Actions {
+  #actions: string[] = [];
+
+  record(action: string) {
+    this.#actions.push(action);
+  }
+
+  expect(expected: string[]) {
+    let actual = this.#actions;
+    this.#actions = [];
+
+    QUnit.assert.deepEqual(actual, expected);
+  }
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/has-block-params.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/has-block-params.ts
index ab408a1a6b..1c554b2b22 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/has-block-params.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/has-block-params.ts
@@ -1,304 +1,380 @@
+import { matrix } from '@glimmer-workspace/integration-tests';
+
 import { GlimmerishComponent } from '../components';
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
-
-export class HasBlockParamsHelperSuite extends RenderTest {
-  static suiteName = 'has-block-params';
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (subexpr, else) when else supplied without block params'() {
-    this.render({
-      layout: '{{#if (has-block-params "inverse")}}Yes{{else}}No{{/if}}',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'has-block-params from within a yielded + invoked curried component'() {
-    class TestHarness extends GlimmerishComponent {
-      public Foo: any;
+
+matrix('has-block-params', (spec) => {
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (subexpr, else) when else supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{#if (has-block-params "inverse")}}Yes{{else}}No{{/if}}',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('No');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'has-block-params from within a yielded + invoked curried component',
+    (ctx) => {
+      class TestHarness extends GlimmerishComponent {
+        public Foo: any;
+      }
+      ctx.register.component('Glimmer', 'TestHarness', '{{yield (component "Foo")}}', TestHarness);
+      ctx.register.component('Glimmer', 'Foo', '{{#if (has-block-params)}}Yes{{else}}No{{/if}}');
+
+      ctx.render.template('<TestHarness as |Foo|>{{Foo}}</TestHarness>');
+
+      ctx.assertHTML('No');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (subexpr, else) when else not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{#if (has-block-params "inverse")}}Yes{{else}}No{{/if}}',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('No');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (subexpr, default) when block supplied with block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{#if (has-block-params)}}Yes{{else}}No{{/if}}',
+        blockParams: ['param'],
+        template: 'block here',
+      });
+
+      ctx.assertComponent('Yes');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (subexpr, default) when block supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{#if (has-block-params)}}Yes{{else}}No{{/if}}',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('No');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (subexpr, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{#if (has-block-params)}}Yes{{else}}No{{/if}}',
+      });
+
+      ctx.assertComponent('No');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (content, else) when else supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{has-block-params "inverse"}}',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('false');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (content, else) when else not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{has-block-params "inverse"}}',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('false');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (content, default) when block supplied with block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{has-block-params}}',
+        blockParams: ['param'],
+        template: 'block here',
+      });
+
+      ctx.assertComponent('true');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (content, default) when block supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{has-block-params}}',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('false');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (content, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{has-block-params}}',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('false');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (prop, else) when else supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button name={{has-block-params "inverse"}}></button>',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('<button name="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (prop, else) when else not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button name={{has-block-params "inverse"}}></button>',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button name="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (prop, default) when block supplied with block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button name={{has-block-params}}></button>',
+        blockParams: ['param'],
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button name="true"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (prop, default) when block supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button name={{has-block-params}}></button>',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button name="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (prop, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button name={{has-block-params}}></button>',
+      });
+
+      ctx.assertComponent('<button name="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (attr, else) when else supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="{{has-block-params "inverse"}}"></button>',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (attr, else) when else not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="{{has-block-params "inverse"}}"></button>',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (attr, default) when block supplied with block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="{{has-block-params}}"></button>',
+        blockParams: ['param'],
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="true"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (attr, default) when block supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="{{has-block-params}}"></button>',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (attr, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="{{has-block-params}}"></button>',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (concatted attr, else) when else supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="is-{{has-block-params "inverse"}}"></button>',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="is-false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (concatted attr, else) when else not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="is-{{has-block-params "inverse"}}"></button>',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="is-false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (concatted attr, default) when block supplied with block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="is-{{has-block-params}}"></button>',
+        template: 'block here',
+        blockParams: ['param'],
+      });
+
+      ctx.assertComponent('<button data-has-block-params="is-true"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (concatted attr, default) when block supplied without block params',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="is-{{has-block-params}}"></button>',
+        template: 'block here',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="is-false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block-params (concatted attr, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block-params="is-{{has-block-params}}"></button>',
+      });
+
+      ctx.assertComponent('<button data-has-block-params="is-false"></button>');
+      ctx.assertStableRerender();
     }
-    this.registerComponent('Glimmer', 'TestHarness', '{{yield (component "Foo")}}', TestHarness);
-    this.registerComponent('Glimmer', 'Foo', '{{#if (has-block-params)}}Yes{{else}}No{{/if}}');
-
-    this.render('<TestHarness as |Foo|>{{Foo}}</TestHarness>');
-
-    this.assertHTML('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (subexpr, else) when else not supplied'() {
-    this.render({
-      layout: '{{#if (has-block-params "inverse")}}Yes{{else}}No{{/if}}',
-      template: 'block here',
-    });
-
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (subexpr, default) when block supplied with block params'() {
-    this.render({
-      layout: '{{#if (has-block-params)}}Yes{{else}}No{{/if}}',
-      blockParams: ['param'],
-      template: 'block here',
-    });
-
-    this.assertComponent('Yes');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (subexpr, default) when block supplied without block params'() {
-    this.render({
-      layout: '{{#if (has-block-params)}}Yes{{else}}No{{/if}}',
-      template: 'block here',
-    });
-
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (subexpr, default) when block not supplied'() {
-    this.render({
-      layout: '{{#if (has-block-params)}}Yes{{else}}No{{/if}}',
-    });
-
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (content, else) when else supplied without block params'() {
-    this.render({
-      layout: '{{has-block-params "inverse"}}',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (content, else) when else not supplied'() {
-    this.render({
-      layout: '{{has-block-params "inverse"}}',
-      template: 'block here',
-    });
-
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (content, default) when block supplied with block params'() {
-    this.render({
-      layout: '{{has-block-params}}',
-      blockParams: ['param'],
-      template: 'block here',
-    });
-
-    this.assertComponent('true');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (content, default) when block supplied without block params'() {
-    this.render({
-      layout: '{{has-block-params}}',
-      template: 'block here',
-    });
-
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (content, default) when block not supplied'() {
-    this.render({
-      layout: '{{has-block-params}}',
-      template: 'block here',
-    });
-
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (prop, else) when else supplied without block params'() {
-    this.render({
-      layout: '<button name={{has-block-params "inverse"}}></button>',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('<button name="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (prop, else) when else not supplied'() {
-    this.render({
-      layout: '<button name={{has-block-params "inverse"}}></button>',
-      template: 'block here',
-    });
-
-    this.assertComponent('<button name="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (prop, default) when block supplied with block params'() {
-    this.render({
-      layout: '<button name={{has-block-params}}></button>',
-      blockParams: ['param'],
-      template: 'block here',
-    });
-
-    this.assertComponent('<button name="true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (prop, default) when block supplied without block params'() {
-    this.render({
-      layout: '<button name={{has-block-params}}></button>',
-      template: 'block here',
-    });
-
-    this.assertComponent('<button name="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (prop, default) when block not supplied'() {
-    this.render({
-      layout: '<button name={{has-block-params}}></button>',
-    });
-
-    this.assertComponent('<button name="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (attr, else) when else supplied without block params'() {
-    this.render({
-      layout: '<button data-has-block-params="{{has-block-params "inverse"}}"></button>',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('<button data-has-block-params="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (attr, else) when else not supplied'() {
-    this.render({
-      layout: '<button data-has-block-params="{{has-block-params "inverse"}}"></button>',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('<button data-has-block-params="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (attr, default) when block supplied with block params'() {
-    this.render({
-      layout: '<button data-has-block-params="{{has-block-params}}"></button>',
-      blockParams: ['param'],
-      template: 'block here',
-    });
-
-    this.assertComponent('<button data-has-block-params="true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (attr, default) when block supplied without block params'() {
-    this.render({
-      layout: '<button data-has-block-params="{{has-block-params}}"></button>',
-      template: 'block here',
-    });
-
-    this.assertComponent('<button data-has-block-params="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (attr, default) when block not supplied'() {
-    this.render({
-      layout: '<button data-has-block-params="{{has-block-params}}"></button>',
-      template: 'block here',
-    });
-
-    this.assertComponent('<button data-has-block-params="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (concatted attr, else) when else supplied without block params'() {
-    this.render({
-      layout: '<button data-has-block-params="is-{{has-block-params "inverse"}}"></button>',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('<button data-has-block-params="is-false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (concatted attr, else) when else not supplied'() {
-    this.render({
-      layout: '<button data-has-block-params="is-{{has-block-params "inverse"}}"></button>',
-      template: 'block here',
-    });
-
-    this.assertComponent('<button data-has-block-params="is-false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (concatted attr, default) when block supplied with block params'() {
-    this.render({
-      layout: '<button data-has-block-params="is-{{has-block-params}}"></button>',
-      template: 'block here',
-      blockParams: ['param'],
-    });
-
-    this.assertComponent('<button data-has-block-params="is-true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (concatted attr, default) when block supplied without block params'() {
-    this.render({
-      layout: '<button data-has-block-params="is-{{has-block-params}}"></button>',
-      template: 'block here',
-    });
-
-    this.assertComponent('<button data-has-block-params="is-false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block-params (concatted attr, default) when block not supplied'() {
-    this.render({
-      layout: '<button data-has-block-params="is-{{has-block-params}}"></button>',
-    });
-
-    this.assertComponent('<button data-has-block-params="is-false"></button>');
-    this.assertStableRerender();
-  }
-}
+  );
+}).client();
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/has-block.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/has-block.ts
index a47503b303..0739e63568 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/has-block.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/has-block.ts
@@ -1,343 +1,357 @@
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { matrix } from '@glimmer-workspace/integration-tests';
 
-export class HasBlockSuite extends RenderTest {
-  static suiteName = 'has-block';
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (subexpr, else) when else supplied'() {
-    this.render({
+matrix('has-block', (spec) => {
+  spec({ type: 'curly' }, 'parameterized has-block (subexpr, else) when else supplied', (ctx) => {
+    ctx.render.template({
       layout: '{{#if (has-block "inverse")}}Yes{{else}}No{{/if}}',
       template: 'block here',
       else: 'else here',
     });
 
-    this.assertComponent('Yes');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('Yes');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (subexpr, else) when else not supplied'() {
-    this.render({
+  spec('parameterized has-block (subexpr, else) when else not supplied', (ctx) => {
+    ctx.render.template({
       layout: '{{#if (has-block "inverse")}}Yes{{else}}No{{/if}}',
       template: 'block here',
     });
 
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('No');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (subexpr, default) when block supplied'() {
-    this.render({
+  spec('parameterized has-block (subexpr, default) when block supplied', (ctx) => {
+    ctx.render.template({
       layout: '{{#if (has-block)}}Yes{{else}}No{{/if}}',
       template: 'block here',
     });
 
-    this.assertComponent('Yes');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (subexpr, default) when block not supplied'() {
-    this.render({
-      layout: '{{#if (has-block)}}Yes{{else}}No{{/if}}',
-    });
-
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (content, else) when else supplied'() {
-    this.render({
+    ctx.assertComponent('Yes');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block (subexpr, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{#if (has-block)}}Yes{{else}}No{{/if}}',
+      });
+
+      ctx.assertComponent('No');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec({ type: 'curly' }, 'parameterized has-block (content, else) when else supplied', (ctx) => {
+    ctx.render.template({
       layout: '{{has-block "inverse"}}',
       template: 'block here',
       else: 'else here',
     });
 
-    this.assertComponent('true');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('true');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (content, else) when else not supplied'() {
-    this.render({
+  spec('parameterized has-block (content, else) when else not supplied', (ctx) => {
+    ctx.render.template({
       layout: '{{has-block "inverse"}}',
       template: 'block here',
     });
 
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('false');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (content, default) when block supplied'() {
-    this.render({
+  spec('parameterized has-block (content, default) when block supplied', (ctx) => {
+    ctx.render.template({
       layout: '{{has-block}}',
       template: 'block here',
     });
 
-    this.assertComponent('true');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (content, default) when block not supplied'() {
-    this.render({
-      layout: '{{has-block}}',
-    });
-
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (prop, else) when else supplied'() {
-    this.render({
+    ctx.assertComponent('true');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block (content, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '{{has-block}}',
+      });
+
+      ctx.assertComponent('false');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec({ type: 'curly' }, 'parameterized has-block (prop, else) when else supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button name={{has-block "inverse"}}></button>',
       template: 'block here',
       else: 'else here',
     });
 
-    this.assertComponent('<button name="true"></button>');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('<button name="true"></button>');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (prop, else) when else not supplied'() {
-    this.render({
+  spec('parameterized has-block (prop, else) when else not supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button name={{has-block "inverse"}}></button>',
       template: 'block here',
     });
 
-    this.assertComponent('<button name="false"></button>');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('<button name="false"></button>');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (prop, default) when block supplied'() {
-    this.render({
+  spec('parameterized has-block (prop, default) when block supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button name={{has-block}}></button>',
       template: 'block here',
     });
 
-    this.assertComponent('<button name="true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (prop, default) when block not supplied'() {
-    this.render({
-      layout: '<button name={{has-block}}></button>',
-    });
-
-    this.assertComponent('<button name="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'has-block works when used directly as an argument without extra parens (prop, default)'() {
-    this.registerComponent('TemplateOnly', 'Foo', '{{@hasBlock}}');
-
-    this.render({
-      layout: '<Foo @hasBlock={{has-block}}></Foo>',
-    });
-
-    this.assertComponent('false');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (attr, else) when else supplied'() {
-    this.render({
+    ctx.assertComponent('<button name="true"></button>');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block (prop, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button name={{has-block}}></button>',
+      });
+
+      ctx.assertComponent('<button name="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'has-block works when used directly as an argument without extra parens (prop, default)',
+    (ctx) => {
+      ctx.register.component('TemplateOnly', 'Foo', '{{@hasBlock}}');
+
+      ctx.render.template({
+        layout: '<Foo @hasBlock={{has-block}}></Foo>',
+      });
+
+      ctx.assertComponent('false');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec({ type: 'curly' }, 'parameterized has-block (attr, else) when else supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button data-has-block="{{has-block "inverse"}}"></button>',
       template: 'block here',
       else: 'else here',
     });
 
-    this.assertComponent('<button data-has-block="true"></button>');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('<button data-has-block="true"></button>');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (attr, else) when else not supplied'() {
-    this.render({
+  spec('parameterized has-block (attr, else) when else not supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button data-has-block="{{has-block "inverse"}}"></button>',
       template: 'block here',
     });
 
-    this.assertComponent('<button data-has-block="false"></button>');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('<button data-has-block="false"></button>');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (attr, default) when block supplied'() {
-    this.render({
+  spec('parameterized has-block (attr, default) when block supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button data-has-block="{{has-block}}"></button>',
       template: 'block here',
     });
 
-    this.assertComponent('<button data-has-block="true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (attr, default) when block not supplied'() {
-    this.render({
-      layout: '<button data-has-block="{{has-block}}"></button>',
-    });
-
-    this.assertComponent('<button data-has-block="false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (concatted attr, else) when else supplied'() {
-    this.render({
-      layout: '<button data-has-block="is-{{has-block "inverse"}}"></button>',
-      template: 'block here',
-      else: 'else here',
-    });
-
-    this.assertComponent('<button data-has-block="is-true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'parameterized has-block (concatted attr, else) when else not supplied'() {
-    this.render({
+    ctx.assertComponent('<button data-has-block="true"></button>');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block (attr, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block="{{has-block}}"></button>',
+      });
+
+      ctx.assertComponent('<button data-has-block="false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block (concatted attr, else) when else supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block="is-{{has-block "inverse"}}"></button>',
+        template: 'block here',
+        else: 'else here',
+      });
+
+      ctx.assertComponent('<button data-has-block="is-true"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec('parameterized has-block (concatted attr, else) when else not supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button data-has-block="is-{{has-block "inverse"}}"></button>',
       template: 'block here',
     });
 
-    this.assertComponent('<button data-has-block="is-false"></button>');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('<button data-has-block="is-false"></button>');
+    ctx.assertStableRerender();
+  });
 
-  @test
-  'parameterized has-block (concatted attr, default) when block supplied'() {
-    this.render({
+  spec('parameterized has-block (concatted attr, default) when block supplied', (ctx) => {
+    ctx.render.template({
       layout: '<button data-has-block="is-{{has-block}}"></button>',
       template: 'block here',
     });
 
-    this.assertComponent('<button data-has-block="is-true"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'curly' })
-  'parameterized has-block (concatted attr, default) when block not supplied'() {
-    this.render({
-      layout: '<button data-has-block="is-{{has-block}}"></button>',
-    });
-
-    this.assertComponent('<button data-has-block="is-false"></button>');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'glimmer' })
-  'self closing angle bracket invocation (subexpr, default)'() {
-    this.registerComponent(
+    ctx.assertComponent('<button data-has-block="is-true"></button>');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    { type: 'curly' },
+    'parameterized has-block (concatted attr, default) when block not supplied',
+    (ctx) => {
+      ctx.render.template({
+        layout: '<button data-has-block="is-{{has-block}}"></button>',
+      });
+
+      ctx.assertComponent('<button data-has-block="is-false"></button>');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec({ type: 'glimmer' }, 'self closing angle bracket invocation (subexpr, default)', (ctx) => {
+    ctx.register.component(
       'Glimmer',
       'TestComponent',
       `<div ...attributes>{{#if (has-block)}}Yes{{else}}No{{/if}}</div>`
     );
-    this.render(`<TestComponent />`);
+    ctx.render.template(`<TestComponent />`);
 
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
+    ctx.assertComponent('No');
+    ctx.assertStableRerender();
+  });
 
-  @test({ kind: 'glimmer' })
-  'self closing angle bracket invocation (subexpr, else)'() {
-    this.registerComponent(
+  spec({ type: 'glimmer' }, 'self closing angle bracket invocation (subexpr, else)', (ctx) => {
+    ctx.register.component(
       'Glimmer',
       'TestComponent',
       `<div ...attributes>{{#if (has-block 'inverse')}}Yes{{else}}No{{/if}}</div>`
     );
-    this.render(`<TestComponent />`);
-
-    this.assertComponent('No');
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'glimmer' })
-  'self closing angle bracket invocation (concatted attr, default)'() {
-    this.registerComponent(
-      'Glimmer',
-      'TestComponent',
-      `<div data-has-block="{{has-block}}" ...attributes></div>`
-    );
-    this.render(`<TestComponent />`);
-
-    this.assertComponent('', { 'data-has-block': 'false' });
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'glimmer' })
-  'has-block works within a yielded curried component invoked within mustaches'() {
-    this.registerComponent(
-      'Glimmer',
-      'ComponentWithHasBlock',
-      `<div data-has-block="{{has-block}}" ...attributes></div>`
-    );
-
-    this.registerComponent('Glimmer', 'Yielder', `{{yield (component 'ComponentWithHasBlock')}}`);
-
-    this.registerComponent(
-      'Glimmer',
-      'TestComponent',
-      `<Yielder as |componentWithHasBlock|>{{componentWithHasBlock}}</Yielder>`
-    );
-
-    this.render(`<TestComponent />`);
-
-    this.assertComponent('', { 'data-has-block': 'false' });
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'glimmer' })
-  'has-block works within a yielded curried component invoked with angle bracket invocation (falsy)'() {
-    this.registerComponent(
-      'Glimmer',
-      'ComponentWithHasBlock',
-      `<div data-has-block="{{has-block}}" ...attributes></div>`
-    );
-
-    this.registerComponent('Glimmer', 'Yielder', `{{yield (component 'ComponentWithHasBlock')}}`);
-
-    this.registerComponent(
-      'Glimmer',
-      'TestComponent',
-      `<Yielder as |componentWithHasBlock|><componentWithHasBlock/></Yielder>`
-    );
-
-    this.render(`<TestComponent />`);
-
-    this.assertComponent('', { 'data-has-block': 'false' });
-    this.assertStableRerender();
-  }
-
-  @test({ kind: 'glimmer' })
-  'has-block works within a yielded curried component invoked with angle bracket invocation (truthy)'() {
-    this.registerComponent(
-      'Glimmer',
-      'ComponentWithHasBlock',
-      `<div data-has-block="{{has-block}}" ...attributes></div>`
-    );
-
-    this.registerComponent('Glimmer', 'Yielder', `{{yield (component 'ComponentWithHasBlock')}}`);
-
-    this.registerComponent(
-      'Glimmer',
-      'TestComponent',
-      `<Yielder as |componentWithHasBlock|><componentWithHasBlock></componentWithHasBlock></Yielder>`
-    );
-
-    this.render(`<TestComponent />`);
-
-    this.assertComponent('', { 'data-has-block': 'true' });
-    this.assertStableRerender();
-  }
-}
+    ctx.render.template(`<TestComponent />`);
+
+    ctx.assertComponent('No');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    { type: 'glimmer' },
+    'self closing angle bracket invocation (concatted attr, default)',
+    (ctx) => {
+      ctx.register.component(
+        'Glimmer',
+        'TestComponent',
+        `<div data-has-block="{{has-block}}" ...attributes></div>`
+      );
+      ctx.render.template(`<TestComponent />`);
+
+      ctx.assertComponent('', { 'data-has-block': 'false' });
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'glimmer' },
+    'has-block works within a yielded curried component invoked within mustaches',
+    (ctx) => {
+      ctx.register.component(
+        'Glimmer',
+        'ComponentWithHasBlock',
+        `<div data-has-block="{{has-block}}" ...attributes></div>`
+      );
+
+      ctx.register.component('Glimmer', 'Yielder', `{{yield (component 'ComponentWithHasBlock')}}`);
+
+      ctx.register.component(
+        'Glimmer',
+        'TestComponent',
+        `<Yielder as |componentWithHasBlock|>{{componentWithHasBlock}}</Yielder>`
+      );
+
+      ctx.render.template(`<TestComponent />`);
+
+      ctx.assertComponent('', { 'data-has-block': 'false' });
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'glimmer' },
+    'has-block works within a yielded curried component invoked with angle bracket invocation (falsy)',
+    (ctx) => {
+      ctx.register.component(
+        'Glimmer',
+        'ComponentWithHasBlock',
+        `<div data-has-block="{{has-block}}" ...attributes></div>`
+      );
+
+      ctx.register.component('Glimmer', 'Yielder', `{{yield (component 'ComponentWithHasBlock')}}`);
+
+      ctx.register.component(
+        'Glimmer',
+        'TestComponent',
+        `<Yielder as |componentWithHasBlock|><componentWithHasBlock/></Yielder>`
+      );
+
+      ctx.render.template(`<TestComponent />`);
+
+      ctx.assertComponent('', { 'data-has-block': 'false' });
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec(
+    { type: 'glimmer' },
+    'has-block works within a yielded curried component invoked with angle bracket invocation (truthy)',
+    (ctx) => {
+      ctx.register.component(
+        'Glimmer',
+        'ComponentWithHasBlock',
+        `<div data-has-block="{{has-block}}" ...attributes></div>`
+      );
+
+      ctx.register.component('Glimmer', 'Yielder', `{{yield (component 'ComponentWithHasBlock')}}`);
+
+      ctx.register.component(
+        'Glimmer',
+        'TestComponent',
+        `<Yielder as |componentWithHasBlock|><componentWithHasBlock></componentWithHasBlock></Yielder>`
+      );
+
+      ctx.render.template(`<TestComponent />`);
+
+      ctx.assertComponent('', { 'data-has-block': 'true' });
+      ctx.assertStableRerender();
+    }
+  );
+}).client();
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/in-element.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/in-element.ts
index 0064029e30..64756a9b36 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/in-element.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/in-element.ts
@@ -1,21 +1,21 @@
-import { destroy } from '@glimmer/destroyable';
 import type { AST } from '@glimmer/syntax';
+import { destroy } from '@glimmer/destroyable';
 import { assign, unwrap } from '@glimmer/util';
 
 import { GlimmerishComponent } from '../components/emberish-glimmer';
 import { equalsElement } from '../dom/assertions';
 import { replaceHTML } from '../dom/simple-utils';
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render } from '../test-decorator';
 import { stripTight } from '../test-helpers/strings';
 import { tracked } from '../test-helpers/tracked';
 
-export class InElementSuite extends RenderTest {
+export class InElementSuite extends RenderTestContext {
   static suiteName = '#in-element';
 
-  @test
+  @render
   'It works with AST transforms'() {
-    this.registerPlugin((env) => ({
+    this.register.plugin((env) => ({
       name: 'maybe-in-element',
       visitor: {
         BlockStatement(node: AST.BlockStatement) {
@@ -30,11 +30,14 @@ export class InElementSuite extends RenderTest {
       },
     }));
 
-    let externalElement = this.delegate.createElement('div');
-    this.render('{{#maybe-in-element this.externalElement}}[{{this.foo}}]{{/maybe-in-element}}', {
-      externalElement,
-      foo: 'Yippie!',
-    });
+    let externalElement = this.dom.createElement('div');
+    this.render.template(
+      '{{#maybe-in-element this.externalElement}}[{{this.foo}}]{{/maybe-in-element}}',
+      {
+        externalElement,
+        foo: 'Yippie!',
+      }
+    );
 
     equalsElement(externalElement, 'div', {}, '[Yippie!]');
     this.assertStableRerender();
@@ -48,10 +51,10 @@ export class InElementSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'Renders curlies into external element'() {
-    let externalElement = this.delegate.createElement('div');
-    this.render('{{#in-element this.externalElement}}[{{this.foo}}]{{/in-element}}', {
+    let externalElement = this.dom.createElement('div');
+    this.render.template('{{#in-element this.externalElement}}[{{this.foo}}]{{/in-element}}', {
       externalElement,
       foo: 'Yippie!',
     });
@@ -68,13 +71,13 @@ export class InElementSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'clears existing content'() {
-    let externalElement = this.delegate.createElement('div');
+    let externalElement = this.dom.createElement('div');
     let initialContent = '<p>Hello there!</p>';
     replaceHTML(externalElement, initialContent);
 
-    this.render('{{#in-element this.externalElement}}[{{this.foo}}]{{/in-element}}', {
+    this.render.template('{{#in-element this.externalElement}}[{{this.foo}}]{{/in-element}}', {
       externalElement,
       foo: 'Yippie!',
     });
@@ -91,12 +94,12 @@ export class InElementSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'Changing to falsey'() {
-    let first = this.delegate.createElement('div');
-    let second = this.delegate.createElement('div');
+    let first = this.dom.createElement('div');
+    let second = this.dom.createElement('div');
 
-    this.render(
+    this.render.template(
       stripTight`
         |{{this.foo}}|
         {{#in-element this.first}}[1{{this.foo}}]{{/in-element}}
@@ -135,13 +138,13 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'With pre-existing content'() {
-    let externalElement = this.delegate.createElement('div');
+    let externalElement = this.dom.createElement('div');
     let initialContent = '<p>Hello there!</p>';
     replaceHTML(externalElement, initialContent);
 
-    this.render(
+    this.render.template(
       stripTight`{{#in-element this.externalElement insertBefore=null}}[{{this.foo}}]{{/in-element}}`,
       {
         externalElement,
@@ -169,12 +172,12 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'With insertBefore'() {
-    let externalElement = this.delegate.createElement('div');
+    let externalElement = this.dom.createElement('div');
     replaceHTML(externalElement, '<b>Hello</b><em>there!</em>');
 
-    this.render(
+    this.render.template(
       stripTight`{{#in-element this.externalElement insertBefore=this.insertBefore}}[{{this.foo}}]{{/in-element}}`,
       { externalElement, insertBefore: externalElement.lastChild, foo: 'Yippie!' }
     );
@@ -204,15 +207,18 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Updating remote element'() {
-    let first = this.delegate.createElement('div');
-    let second = this.delegate.createElement('div');
+    let first = this.dom.createElement('div');
+    let second = this.dom.createElement('div');
 
-    this.render(stripTight`{{#in-element this.externalElement}}[{{this.foo}}]{{/in-element}}`, {
-      externalElement: first,
-      foo: 'Yippie!',
-    });
+    this.render.template(
+      stripTight`{{#in-element this.externalElement}}[{{this.foo}}]{{/in-element}}`,
+      {
+        externalElement: first,
+        foo: 'Yippie!',
+      }
+    );
 
     equalsElement(first, 'div', {}, '[Yippie!]');
     equalsElement(second, 'div', {}, '');
@@ -256,12 +262,12 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   "Inside an '{{if}}'"() {
-    let first = { element: this.delegate.createElement('div'), description: 'first' };
-    let second = { element: this.delegate.createElement('div'), description: 'second' };
+    let first = { element: this.dom.createElement('div'), description: 'first' };
+    let second = { element: this.dom.createElement('div'), description: 'second' };
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#if this.showFirst}}
           {{#in-element this.first}}[{{this.foo}}]{{/in-element}}
@@ -321,9 +327,9 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Inside the current constructing element'() {
-    this.render(
+    this.render.template(
       stripTight`
         Before
         {{#in-element this.element insertBefore=null}}
@@ -343,12 +349,12 @@ export class InElementSuite extends RenderTest {
     destroy(unwrap(this.renderResult));
   }
 
-  @test
+  @render
   Multiple() {
-    let firstElement = this.delegate.createElement('div');
-    let secondElement = this.delegate.createElement('div');
+    let firstElement = this.dom.createElement('div');
+    let secondElement = this.dom.createElement('div');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#in-element this.firstElement}}
           [{{this.foo}}]
@@ -389,12 +395,12 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Inside a loop'() {
-    let { delegate } = this;
+    let { dom } = this;
 
     class Item {
-      element = delegate.createElement('div');
+      element = dom.createElement('div');
 
       @tracked value: string;
 
@@ -403,14 +409,13 @@ export class InElementSuite extends RenderTest {
       }
     }
 
-    this.testType = 'Dynamic';
-    this.registerComponent('TemplateOnly', 'FooBar', '<p>{{@value}}</p>');
+    this.register.component('TemplateOnly', 'FooBar', '<p>{{@value}}</p>');
 
-    this.registerHelper('log', () => {});
+    this.register.helper('log', () => {});
 
     let roots = [new Item('foo'), new Item('bar'), new Item('baz')];
 
-    this.render(
+    this.render.template(
       stripTight`
         {{~#each this.roots as |root|~}}
           {{~log root~}}
@@ -458,15 +463,14 @@ export class InElementSuite extends RenderTest {
     equalsElement(third.element, 'div', {}, '<p>baz</p>');
     this.assertHTML('<!----><!----><!--->');
     this.assertStableRerender();
-    this.testType = 'TemplateOnly';
   }
 
-  @test
+  @render
   Nesting() {
-    let firstElement = this.delegate.createElement('div');
-    let secondElement = this.delegate.createElement('div');
+    let firstElement = this.dom.createElement('div');
+    let secondElement = this.dom.createElement('div');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#in-element this.firstElement}}
           [{{this.foo}}]
@@ -513,7 +517,7 @@ export class InElementSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Components are destroyed'() {
     let destroyed = 0;
 
@@ -524,10 +528,10 @@ export class InElementSuite extends RenderTest {
       }
     }
 
-    this.registerComponent('Glimmer', 'DestroyMe', 'destroy me!', DestroyMeComponent as any);
-    let externalElement = this.delegate.createElement('div');
+    this.register.component('Glimmer', 'DestroyMe', 'destroy me!', DestroyMeComponent as any);
+    let externalElement = this.dom.createElement('div');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#if this.showExternal}}
           {{#in-element this.externalElement}}[<DestroyMe />]{{/in-element}}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render.ts
deleted file mode 100644
index 994386d4f5..0000000000
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render.ts
+++ /dev/null
@@ -1,1318 +0,0 @@
-import type { SimpleElement } from '@glimmer/interfaces';
-import { castToBrowser, checkNode, NS_SVG, strip, unwrap } from '@glimmer/util';
-
-import { assertNodeTagName } from '../dom/assertions';
-import { firstElementChild, getElementsByTagName } from '../dom/simple-utils';
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
-
-export class InitialRenderSuite extends RenderTest {
-  static suiteName = 'initial render';
-
-  name = 'BASE';
-  @test
-  'HTML text content'() {
-    this.render('content');
-    this.assertHTML('content');
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML tags'() {
-    this.render('<h1>hello!</h1><div>content</div>');
-    this.assertHTML('<h1>hello!</h1><div>content</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML attributes'() {
-    this.render("<div class='foo' id='bar'>content</div>");
-    this.assertHTML("<div class='foo' id='bar'>content</div>");
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML data attributes'() {
-    this.render("<div data-some-data='foo'>content</div>");
-    this.assertHTML("<div data-some-data='foo'>content</div>");
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML checked attributes'() {
-    this.render("<input checked='checked'>");
-    this.assertHTML(`<input checked='checked'>`);
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML selected options'() {
-    this.render(strip`
-      <select>
-        <option>1</option>
-        <option selected>2</option>
-        <option>3</option>
-      </select>
-    `);
-    this.assertHTML(strip`
-      <select>
-        <option>1</option>
-        <option selected>2</option>
-        <option>3</option>
-      </select>
-    `);
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML multi-select options'() {
-    this.render(strip`
-      <select multiple>
-        <option>1</option>
-        <option selected>2</option>
-        <option selected>3</option>
-      </select>
-    `);
-    this.assertHTML(strip`
-      <select multiple>
-        <option>1</option>
-        <option selected>2</option>
-        <option selected>3</option>
-      </select>
-    `);
-    this.assertStableRerender();
-  }
-
-  @test
-  'Void Elements'() {
-    const voidElements = 'area base br embed hr img input keygen link meta param source track wbr';
-    voidElements.split(' ').forEach((tagName) => this.shouldBeVoid(tagName));
-  }
-
-  @test
-  'Nested HTML'() {
-    this.render(
-      "<div class='foo'><p><span id='bar' data-foo='bar'>hi!</span></p></div>&nbsp;More content"
-    );
-    this.assertHTML(
-      "<div class='foo'><p><span id='bar' data-foo='bar'>hi!</span></p></div>&nbsp;More content"
-    );
-    this.assertStableRerender();
-  }
-
-  @test
-  'Custom Elements'() {
-    this.render('<use-the-platform></use-the-platform>');
-    this.assertHTML('<use-the-platform></use-the-platform>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Nested Custom Elements'() {
-    this.render(
-      "<use-the-platform><seriously-please data-foo='1'>Stuff <div>Here</div></seriously-please></use-the-platform>"
-    );
-    this.assertHTML(
-      "<use-the-platform><seriously-please data-foo='1'>Stuff <div>Here</div></seriously-please></use-the-platform>"
-    );
-    this.assertStableRerender();
-  }
-
-  @test
-  'Moar nested Custom Elements'() {
-    this.render(
-      "<use-the-platform><seriously-please data-foo='1'><wheres-the-platform>Here</wheres-the-platform></seriously-please></use-the-platform>"
-    );
-    this.assertHTML(
-      "<use-the-platform><seriously-please data-foo='1'><wheres-the-platform>Here</wheres-the-platform></seriously-please></use-the-platform>"
-    );
-    this.assertStableRerender();
-  }
-
-  @test
-  'Custom Elements with dynamic attributes'() {
-    this.render(
-      "<fake-thing><other-fake-thing data-src='extra-{{this.someDynamicBits}}-here' /></fake-thing>",
-      { someDynamicBits: 'things' }
-    );
-    this.assertHTML("<fake-thing><other-fake-thing data-src='extra-things-here' /></fake-thing>");
-    this.assertStableRerender();
-  }
-
-  @test
-  'Custom Elements with dynamic content'() {
-    this.render('<x-foo><x-bar>{{this.derp}}</x-bar></x-foo>', { derp: 'stuff' });
-    this.assertHTML('<x-foo><x-bar>stuff</x-bar></x-foo>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Dynamic content within single custom element'() {
-    this.render('<x-foo>{{#if this.derp}}Content Here{{/if}}</x-foo>', { derp: 'stuff' });
-    this.assertHTML('<x-foo>Content Here</x-foo>');
-    this.assertStableRerender();
-
-    this.rerender({ derp: false });
-    this.assertHTML('<x-foo><!----></x-foo>');
-    this.assertStableRerender();
-
-    this.rerender({ derp: true });
-    this.assertHTML('<x-foo>Content Here</x-foo>');
-    this.assertStableRerender();
-
-    this.rerender({ derp: 'stuff' });
-    this.assertHTML('<x-foo>Content Here</x-foo>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Supports quotes'() {
-    this.render('<div>"This is a title," we\'re on a boat</div>');
-    this.assertHTML('<div>"This is a title," we\'re on a boat</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Supports backslashes'() {
-    this.render('<div>This is a backslash: \\</div>');
-    this.assertHTML('<div>This is a backslash: \\</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Supports new lines'() {
-    this.render('<div>common\n\nbro</div>');
-    this.assertHTML('<div>common\n\nbro</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'HTML tag with empty attribute'() {
-    this.render("<div class=''>content</div>");
-    this.assertHTML("<div class=''>content</div>");
-    this.assertStableRerender();
-  }
-
-  @test
-  'Attributes containing a helper are treated like a block'() {
-    this.registerHelper('testing', (params) => {
-      this.assert.deepEqual(params, [123]);
-      return 'example.com';
-    });
-
-    this.render('<a href="http://{{testing 123}}/index.html">linky</a>');
-    this.assertHTML('<a href="http://example.com/index.html">linky</a>');
-    this.assertStableRerender();
-  }
-
-  @test
-  "HTML boolean attribute 'disabled'"() {
-    this.render('<input disabled>');
-    this.assertHTML('<input disabled>');
-
-    // TODO: What is the point of this test? (Note that it wouldn't work with SimpleDOM)
-    // assertNodeProperty(root.firstChild, 'input', 'disabled', true);
-
-    this.assertStableRerender();
-  }
-
-  @test
-  'Quoted attribute null values do not disable'() {
-    this.render('<input disabled="{{this.isDisabled}}">', { isDisabled: null });
-    this.assertHTML('<input>');
-    this.assertStableRerender();
-
-    // TODO: What is the point of this test? (Note that it wouldn't work with SimpleDOM)
-    // assertNodeProperty(root.firstChild, 'input', 'disabled', false);
-
-    this.rerender({ isDisabled: true });
-    this.assertHTML('<input disabled>');
-    this.assertStableNodes();
-
-    // TODO: ??????????
-    this.rerender({ isDisabled: false });
-    this.assertHTML('<input disabled>');
-    this.assertStableNodes();
-
-    this.rerender({ isDisabled: null });
-    this.assertHTML('<input>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Unquoted attribute null values do not disable'() {
-    this.render('<input disabled={{this.isDisabled}}>', { isDisabled: null });
-    this.assertHTML('<input>');
-    this.assertStableRerender();
-
-    // TODO: What is the point of this test? (Note that it wouldn't work with SimpleDOM)
-    // assertNodeProperty(root.firstChild, 'input', 'disabled', false);
-
-    this.rerender({ isDisabled: true });
-    this.assertHTML('<input disabled>');
-    this.assertStableRerender();
-
-    this.rerender({ isDisabled: false });
-    this.assertHTML('<input>');
-    this.assertStableRerender();
-
-    this.rerender({ isDisabled: null });
-    this.assertHTML('<input>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Quoted attribute string values'() {
-    this.render("<img src='{{this.src}}'>", { src: 'image.png' });
-    this.assertHTML("<img src='image.png'>");
-    this.assertStableRerender();
-
-    this.rerender({ src: 'newimage.png' });
-    this.assertHTML("<img src='newimage.png'>");
-    this.assertStableNodes();
-
-    this.rerender({ src: '' });
-    this.assertHTML("<img src=''>");
-    this.assertStableNodes();
-
-    this.rerender({ src: 'image.png' });
-    this.assertHTML("<img src='image.png'>");
-    this.assertStableNodes();
-  }
-
-  @test
-  'Unquoted attribute string values'() {
-    this.render('<img src={{this.src}}>', { src: 'image.png' });
-    this.assertHTML("<img src='image.png'>");
-    this.assertStableRerender();
-
-    this.rerender({ src: 'newimage.png' });
-    this.assertHTML("<img src='newimage.png'>");
-    this.assertStableNodes();
-
-    this.rerender({ src: '' });
-    this.assertHTML("<img src=''>");
-    this.assertStableNodes();
-
-    this.rerender({ src: 'image.png' });
-    this.assertHTML("<img src='image.png'>");
-    this.assertStableNodes();
-  }
-
-  @test
-  'Unquoted img src attribute is not rendered when set to `null`'() {
-    this.render("<img src='{{this.src}}'>", { src: null });
-    this.assertHTML('<img>');
-    this.assertStableRerender();
-
-    this.rerender({ src: 'newimage.png' });
-    this.assertHTML("<img src='newimage.png'>");
-    this.assertStableNodes();
-
-    this.rerender({ src: '' });
-    this.assertHTML("<img src=''>");
-    this.assertStableNodes();
-
-    this.rerender({ src: null });
-    this.assertHTML('<img>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Unquoted img src attribute is not rendered when set to `undefined`'() {
-    this.render("<img src='{{this.src}}'>", { src: undefined });
-    this.assertHTML('<img>');
-    this.assertStableRerender();
-
-    this.rerender({ src: 'newimage.png' });
-    this.assertHTML("<img src='newimage.png'>");
-    this.assertStableNodes();
-
-    this.rerender({ src: '' });
-    this.assertHTML("<img src=''>");
-    this.assertStableNodes();
-
-    this.rerender({ src: undefined });
-    this.assertHTML('<img>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Unquoted a href attribute is not rendered when set to `null`'() {
-    this.render('<a href={{this.href}}></a>', { href: null });
-    this.assertHTML('<a></a>');
-    this.assertStableRerender();
-
-    this.rerender({ href: 'http://example.com' });
-    this.assertHTML("<a href='http://example.com'></a>");
-    this.assertStableNodes();
-
-    this.rerender({ href: '' });
-    this.assertHTML("<a href=''></a>");
-    this.assertStableNodes();
-
-    this.rerender({ href: null });
-    this.assertHTML('<a></a>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Unquoted a href attribute is not rendered when set to `undefined`'() {
-    this.render('<a href={{this.href}}></a>', { href: undefined });
-    this.assertHTML('<a></a>');
-    this.assertStableRerender();
-
-    this.rerender({ href: 'http://example.com' });
-    this.assertHTML("<a href='http://example.com'></a>");
-    this.assertStableNodes();
-
-    this.rerender({ href: '' });
-    this.assertHTML("<a href=''></a>");
-    this.assertStableNodes();
-
-    this.rerender({ href: undefined });
-    this.assertHTML('<a></a>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Attribute expression can be followed by another attribute'() {
-    this.render("<div foo='{{this.funstuff}}' name='Alice'></div>", { funstuff: 'oh my' });
-    this.assertHTML("<div name='Alice' foo='oh my'></div>");
-    this.assertStableRerender();
-
-    this.rerender({ funstuff: 'oh boy' });
-    this.assertHTML("<div name='Alice' foo='oh boy'></div>");
-    this.assertStableNodes();
-
-    this.rerender({ funstuff: '' });
-    this.assertHTML("<div name='Alice' foo=''></div>");
-    this.assertStableNodes();
-
-    this.rerender({ funstuff: 'oh my' });
-    this.assertHTML("<div name='Alice' foo='oh my'></div>");
-    this.assertStableNodes();
-  }
-
-  @test
-  'Dynamic selected options'() {
-    this.render(
-      strip`
-      <select>
-        <option>1</option>
-        <option selected={{this.selected}}>2</option>
-        <option>3</option>
-      </select>
-    `,
-      { selected: true }
-    );
-
-    this.assertHTML(strip`
-      <select>
-        <option>1</option>
-        <option ${this.name === 'rehydration' ? ' selected=true' : ''}>2</option>
-        <option>3</option>
-      </select>
-    `);
-
-    let selectNode = checkNode(castToBrowser(this.element, 'HTML').firstElementChild, 'select');
-    this.assert.strictEqual(selectNode.selectedIndex, 1);
-    this.assertStableRerender();
-
-    this.rerender({ selected: false });
-    this.assertHTML(strip`
-      <select>
-        <option>1</option>
-        <option ${this.name === 'rehydration' ? ' selected=true' : ''}>2</option>
-        <option>3</option>
-      </select>
-    `);
-
-    selectNode = checkNode(castToBrowser(this.element, 'HTML').firstElementChild, 'select');
-
-    this.assert.strictEqual(selectNode.selectedIndex, 0);
-
-    this.assertStableNodes();
-
-    this.rerender({ selected: '' });
-
-    this.assertHTML(strip`
-      <select>
-        <option>1</option>
-        <option ${this.name === 'rehydration' ? ' selected=true' : ''}>2</option>
-        <option>3</option>
-      </select>
-    `);
-
-    selectNode = checkNode(castToBrowser(this.element, 'HTML').firstElementChild, 'select');
-
-    this.assert.strictEqual(selectNode.selectedIndex, 0);
-
-    this.assertStableNodes();
-
-    this.rerender({ selected: true });
-    this.assertHTML(strip`
-      <select>
-        <option>1</option>
-        <option ${this.name === 'rehydration' ? ' selected=true' : ''}>2</option>
-        <option>3</option>
-      </select>
-    `);
-
-    selectNode = checkNode(castToBrowser(this.element, 'HTML').firstElementChild, 'select');
-    this.assert.strictEqual(selectNode.selectedIndex, 1);
-    this.assertStableNodes();
-  }
-
-  @test
-  'Dynamic multi-select'() {
-    this.render(
-      strip`
-      <select multiple>
-        <option>0</option>
-        <option selected={{this.somethingTrue}}>1</option>
-        <option selected={{this.somethingTruthy}}>2</option>
-        <option selected={{this.somethingUndefined}}>3</option>
-        <option selected={{this.somethingNull}}>4</option>
-        <option selected={{this.somethingFalse}}>5</option>
-      </select>`,
-      {
-        somethingTrue: true,
-        somethingTruthy: 'is-true',
-        somethingUndefined: undefined,
-        somethingNull: null,
-        somethingFalse: false,
-      }
-    );
-
-    const selectNode = firstElementChild(this.element);
-    this.assert.ok(selectNode, 'rendered select');
-    if (selectNode === null) {
-      return;
-    }
-    const options = getElementsByTagName(selectNode, 'option');
-    const selected: SimpleElement[] = [];
-
-    for (const option of options) {
-      // TODO: This is a real discrepancy with SimpleDOM
-      if ((option as any).selected) {
-        selected.push(option);
-      }
-    }
-
-    const [first, second] = this.guardArray({ selected }, { min: 2 });
-
-    this.assertHTML(strip`
-      <select multiple="">
-        <option>0</option>
-        <option ${this.name === 'rehydration' ? ' selected=true' : ''}>1</option>
-        <option ${this.name === 'rehydration' ? ' selected=true' : ''}>2</option>
-        <option>3</option>
-        <option>4</option>
-        <option>5</option>
-      </select>`);
-
-    this.assert.strictEqual(selected.length, 2, 'two options are selected');
-    this.assert.strictEqual(
-      castToBrowser(first, 'option').value,
-      '1',
-      'first selected item is "1"'
-    );
-    this.assert.strictEqual(
-      castToBrowser(second, 'option').value,
-      '2',
-      'second selected item is "2"'
-    );
-  }
-
-  @test
-  'HTML comments'() {
-    this.render('<div><!-- Just passing through --></div>');
-    this.assertHTML('<div><!-- Just passing through --></div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Curlies in HTML comments'() {
-    this.render('<div><!-- {{this.foo}} --></div>', { foo: 'foo' });
-    this.assertHTML('<div><!-- {{this.foo}} --></div>');
-    this.assertStableRerender();
-
-    this.rerender({ foo: 'bar' });
-    this.assertHTML('<div><!-- {{this.foo}} --></div>');
-    this.assertStableNodes();
-
-    this.rerender({ foo: '' });
-    this.assertHTML('<div><!-- {{this.foo}} --></div>');
-    this.assertStableNodes();
-
-    this.rerender({ foo: 'foo' });
-    this.assertHTML('<div><!-- {{this.foo}} --></div>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Complex Curlies in HTML comments'() {
-    this.render('<div><!-- {{this.foo bar baz}} --></div>', { foo: 'foo' });
-    this.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
-    this.assertStableRerender();
-
-    this.rerender({ foo: 'bar' });
-    this.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
-    this.assertStableNodes();
-
-    this.rerender({ foo: '' });
-    this.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
-    this.assertStableNodes();
-
-    this.rerender({ foo: 'foo' });
-    this.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'HTML comments with multi-line mustaches'() {
-    this.render('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>');
-    this.assertHTML('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Top level comments'() {
-    this.render('<!-- {{this.foo}} -->');
-    this.assertHTML('<!-- {{this.foo}} -->');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Handlebars comments'() {
-    this.render('<div>{{! Better not break! }}content</div>');
-    this.assertHTML('<div>content</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Namespaced attribute'() {
-    this.render("<svg xlink:title='svg-title'>content</svg>");
-    this.assertHTML("<svg xlink:title='svg-title'>content</svg>");
-    this.assertStableRerender();
-  }
-
-  @test
-  'svg href attribute with quotation marks'() {
-    this.render(
-      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="{{this.iconLink}}"></use></svg>`,
-      { iconLink: 'home' }
-    );
-    this.assertHTML(
-      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="home"></use></svg>`
-    );
-    const svg = this.element.firstChild;
-    if (assertNodeTagName(svg, 'svg')) {
-      const use = svg.firstChild;
-      if (assertNodeTagName(use, 'use')) {
-        this.assert.strictEqual(use.href.baseVal, 'home');
-      }
-    }
-  }
-
-  @test
-  'svg href attribute without quotation marks'() {
-    this.render(
-      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href={{this.iconLink}}></use></svg>`,
-      { iconLink: 'home' }
-    );
-    this.assertHTML(
-      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="home"></use></svg>`
-    );
-    const svg = this.element.firstChild;
-    if (assertNodeTagName(svg, 'svg')) {
-      const use = svg.firstChild;
-      if (assertNodeTagName(use, 'use')) {
-        this.assert.strictEqual(use.href.baseVal, 'home');
-      }
-    }
-  }
-
-  @test
-  '<svg> tag with case-sensitive attribute'() {
-    this.render('<svg viewBox="0 0 0 0"></svg>');
-    this.assertHTML('<svg viewBox="0 0 0 0"></svg>');
-    const svg = this.element.firstChild;
-    if (assertNodeTagName(svg, 'svg')) {
-      this.assert.strictEqual(svg.namespaceURI, NS_SVG);
-      this.assert.strictEqual(svg.getAttribute('viewBox'), '0 0 0 0');
-    }
-    this.assertStableRerender();
-  }
-
-  @test
-  'nested element in the SVG namespace'() {
-    const d = 'M 0 0 L 100 100';
-    this.render(`<svg><path d="${d}"></path></svg>`);
-    this.assertHTML(`<svg><path d="${d}"></path></svg>`);
-
-    const svg = this.element.firstChild;
-
-    if (assertNodeTagName(svg, 'svg')) {
-      this.assert.strictEqual(svg.namespaceURI, NS_SVG);
-
-      const path = svg.firstChild;
-      if (assertNodeTagName(path, 'path')) {
-        this.assert.strictEqual(
-          path.namespaceURI,
-          NS_SVG,
-          'creates the path element with a namespace'
-        );
-        this.assert.strictEqual(path.getAttribute('d'), d);
-      }
-    }
-
-    this.assertStableRerender();
-  }
-
-  @test
-  '<foreignObject> tag has an SVG namespace'() {
-    this.render('<svg><foreignObject>Hi</foreignObject></svg>');
-    this.assertHTML('<svg><foreignObject>Hi</foreignObject></svg>');
-
-    const svg = this.element.firstChild;
-
-    if (assertNodeTagName(svg, 'svg')) {
-      this.assert.strictEqual(svg.namespaceURI, NS_SVG);
-
-      const foreignObject = svg.firstChild;
-
-      if (assertNodeTagName(foreignObject, 'foreignObject')) {
-        this.assert.strictEqual(
-          foreignObject.namespaceURI,
-          NS_SVG,
-          'creates the foreignObject element with a namespace'
-        );
-      }
-    }
-
-    this.assertStableRerender();
-  }
-
-  @test
-  'Namespaced and non-namespaced elements as siblings'() {
-    this.render('<svg></svg><svg></svg><div></div>');
-    this.assertHTML('<svg></svg><svg></svg><div></div>');
-
-    const [firstChild, secondChild, thirdChild] = this.guardArray(
-      { childNodes: this.element.childNodes },
-      { min: 3 }
-    );
-
-    this.assert.strictEqual(
-      castToBrowser(unwrap(firstChild), 'SVG').namespaceURI,
-      NS_SVG,
-      'creates the first svg element with a namespace'
-    );
-
-    this.assert.strictEqual(
-      castToBrowser(secondChild, 'SVG').namespaceURI,
-      NS_SVG,
-      'creates the second svg element with a namespace'
-    );
-
-    this.assert.strictEqual(
-      castToBrowser(thirdChild, 'HTML').namespaceURI,
-      XHTML_NAMESPACE,
-      'creates the div element without a namespace'
-    );
-
-    this.assertStableRerender();
-  }
-
-  @test
-  'Namespaced and non-namespaced elements with nesting'() {
-    this.render('<div><svg></svg></div><div></div>');
-
-    const firstDiv = this.element.firstChild;
-    const secondDiv = this.element.lastChild;
-    const svg = firstDiv && firstDiv.firstChild;
-
-    this.assertHTML('<div><svg></svg></div><div></div>');
-
-    if (assertNodeTagName(firstDiv, 'div')) {
-      this.assert.strictEqual(
-        firstDiv.namespaceURI,
-        XHTML_NAMESPACE,
-        "first div's namespace is xhtmlNamespace"
-      );
-    }
-
-    if (assertNodeTagName(svg, 'svg')) {
-      this.assert.strictEqual(svg.namespaceURI, NS_SVG, "svg's namespace is svgNamespace");
-    }
-
-    if (assertNodeTagName(secondDiv, 'div')) {
-      this.assert.strictEqual(
-        secondDiv.namespaceURI,
-        XHTML_NAMESPACE,
-        "last div's namespace is xhtmlNamespace"
-      );
-    }
-
-    this.assertStableRerender();
-  }
-
-  @test
-  'Case-sensitive tag has capitalization preserved'() {
-    this.render('<svg><linearGradient id="gradient"></linearGradient></svg>');
-    this.assertHTML('<svg><linearGradient id="gradient"></linearGradient></svg>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Text curlies'() {
-    this.render('<div>{{this.title}}<span>{{this.title}}</span></div>', { title: 'hello' });
-    this.assertHTML('<div>hello<span>hello</span></div>');
-    this.assertStableRerender();
-
-    this.rerender({ title: 'goodbye' });
-    this.assertHTML('<div>goodbye<span>goodbye</span></div>');
-    this.assertStableNodes();
-
-    this.rerender({ title: '' });
-    this.assertHTML('<div><span></span></div>');
-    this.assertStableNodes();
-
-    this.rerender({ title: 'hello' });
-    this.assertHTML('<div>hello<span>hello</span></div>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Repaired text nodes are ensured in the right place Part 1'() {
-    this.render('{{this.a}} {{this.b}}', { a: 'A', b: 'B', c: 'C', d: 'D' });
-    this.assertHTML('A B');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Repaired text nodes are ensured in the right place Part 2'() {
-    this.render('<div>{{this.a}}{{this.b}}{{this.c}}wat{{this.d}}</div>', {
-      a: 'A',
-      b: 'B',
-      c: 'C',
-      d: 'D',
-    });
-    this.assertHTML('<div>ABCwatD</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Repaired text nodes are ensured in the right place Part 3'() {
-    this.render('{{this.a}}{{this.b}}<img><img><img><img>', { a: 'A', b: 'B', c: 'C', d: 'D' });
-    this.assertHTML('AB<img><img><img><img>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Path expressions'() {
-    this.render('<div>{{this.model.foo.bar}}<span>{{this.model.foo.bar}}</span></div>', {
-      model: { foo: { bar: 'hello' } },
-    });
-    this.assertHTML('<div>hello<span>hello</span></div>');
-    this.assertStableRerender();
-
-    this.rerender({ model: { foo: { bar: 'goodbye' } } });
-    this.assertHTML('<div>goodbye<span>goodbye</span></div>');
-    this.assertStableNodes();
-
-    this.rerender({ model: { foo: { bar: '' } } });
-    this.assertHTML('<div><span></span></div>');
-    this.assertStableNodes();
-
-    this.rerender({ model: { foo: { bar: 'hello' } } });
-    this.assertHTML('<div>hello<span>hello</span></div>');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Text curlies perform escaping'() {
-    this.render('<div>{{this.title}}<span>{{this.title}}</span></div>', {
-      title: '<strong>hello</strong>',
-    });
-    this.assertHTML(
-      '<div>&lt;strong&gt;hello&lt;/strong&gt;<span>&lt;strong>hello&lt;/strong&gt;</span></div>'
-    );
-    this.assertStableRerender();
-
-    this.rerender({ title: '<i>goodbye</i>' });
-    this.assertHTML('<div>&lt;i&gt;goodbye&lt;/i&gt;<span>&lt;i&gt;goodbye&lt;/i&gt;</span></div>');
-    this.assertStableNodes();
-
-    this.rerender({ title: '' });
-    this.assertHTML('<div><span></span></div>');
-    this.assertStableNodes();
-
-    this.rerender({ title: '<strong>hello</strong>' });
-    this.assertHTML(
-      '<div>&lt;strong&gt;hello&lt;/strong&gt;<span>&lt;strong>hello&lt;/strong&gt;</span></div>'
-    );
-    this.assertStableNodes();
-  }
-
-  @test
-  'Rerender respects whitespace'() {
-    this.render('Hello {{ this.foo }} ', { foo: 'bar' });
-    this.assertHTML('Hello bar ');
-    this.assertStableRerender();
-
-    this.rerender({ foo: 'baz' });
-    this.assertHTML('Hello baz ');
-    this.assertStableNodes();
-
-    this.rerender({ foo: '' });
-    this.assertHTML('Hello  ');
-    this.assertStableNodes();
-
-    this.rerender({ foo: 'bar' });
-    this.assertHTML('Hello bar ');
-    this.assertStableNodes();
-  }
-
-  @test
-  'Safe HTML curlies'() {
-    const title = {
-      toHTML() {
-        return '<span>hello</span> <em>world</em>';
-      },
-    };
-    this.render('<div>{{this.title}}</div>', { title });
-    this.assertHTML('<div><span>hello</span> <em>world</em></div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Triple curlies'() {
-    const title = '<span>hello</span> <em>world</em>';
-    this.render('<div>{{{this.title}}}</div>', { title });
-    this.assertHTML('<div><span>hello</span> <em>world</em></div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Triple curlie helpers'() {
-    this.registerHelper('unescaped', ([param]) => param);
-    this.registerHelper('escaped', ([param]) => param);
-    this.render('{{{unescaped "<strong>Yolo</strong>"}}} {{escaped "<strong>Yolo</strong>"}}');
-    this.assertHTML('<strong>Yolo</strong> &lt;strong&gt;Yolo&lt;/strong&gt;');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Top level triple curlies'() {
-    const title = '<span>hello</span> <em>world</em>';
-    this.render('{{{this.title}}}', { title });
-    this.assertHTML('<span>hello</span> <em>world</em>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Top level unescaped tr'() {
-    const title = '<tr><td>Yo</td></tr>';
-    this.render('<table>{{{this.title}}}</table>', { title });
-    this.assertHTML('<table><tbody><tr><td>Yo</td></tr></tbody></table>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'The compiler can handle top-level unescaped td inside tr contextualElement'() {
-    this.render('{{{this.html}}}', { html: '<td>Yo</td>' });
-    this.assertHTML('<tr><td>Yo</td></tr>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Extreme nesting'() {
-    this.render(
-      '{{this.foo}}<span>{{this.bar}}<a>{{this.baz}}<em>{{this.boo}}{{this.brew}}</em>{{this.bat}}</a></span><span><span>{{this.flute}}</span></span>{{this.argh}}',
-      {
-        foo: 'FOO',
-        bar: 'BAR',
-        baz: 'BAZ',
-        boo: 'BOO',
-        brew: 'BREW',
-        bat: 'BAT',
-        flute: 'FLUTE',
-        argh: 'ARGH',
-      }
-    );
-    this.assertHTML(
-      'FOO<span>BAR<a>BAZ<em>BOOBREW</em>BAT</a></span><span><span>FLUTE</span></span>ARGH'
-    );
-    this.assertStableRerender();
-  }
-
-  @test
-  'Simple blocks'() {
-    this.render('<div>{{#if this.admin}}<p>{{this.user}}</p>{{/if}}!</div>', {
-      admin: true,
-      user: 'chancancode',
-    });
-    this.assertHTML('<div><p>chancancode</p>!</div>');
-    this.assertStableRerender();
-
-    const p = this.element.firstChild!.firstChild!;
-
-    this.rerender({ admin: false });
-    this.assertHTML('<div><!---->!</div>');
-    this.assertStableNodes({ except: p });
-
-    const comment = this.element.firstChild!.firstChild!;
-
-    this.rerender({ admin: true });
-    this.assertHTML('<div><p>chancancode</p>!</div>');
-    this.assertStableNodes({ except: comment });
-  }
-
-  @test
-  'Nested blocks'() {
-    this.render(
-      '<div>{{#if this.admin}}{{#if this.access}}<p>{{this.user}}</p>{{/if}}{{/if}}!</div>',
-      {
-        admin: true,
-        access: true,
-        user: 'chancancode',
-      }
-    );
-    this.assertHTML('<div><p>chancancode</p>!</div>');
-    this.assertStableRerender();
-
-    let p = this.element.firstChild!.firstChild!;
-
-    this.rerender({ admin: false });
-    this.assertHTML('<div><!---->!</div>');
-    this.assertStableNodes({ except: p });
-
-    const comment = this.element.firstChild!.firstChild!;
-
-    this.rerender({ admin: true });
-    this.assertHTML('<div><p>chancancode</p>!</div>');
-    this.assertStableNodes({ except: comment });
-
-    p = this.element.firstChild!.firstChild!;
-
-    this.rerender({ access: false });
-    this.assertHTML('<div><!---->!</div>');
-    this.assertStableNodes({ except: p });
-  }
-
-  @test
-  Loops() {
-    this.render(
-      '<div>{{#each this.people key="handle" as |p|}}<span>{{p.handle}}</span> - {{p.name}}{{/each}}</div>',
-      {
-        people: [
-          { handle: 'tomdale', name: 'Tom Dale' },
-          { handle: 'chancancode', name: 'Godfrey Chan' },
-          { handle: 'wycats', name: 'Yehuda Katz' },
-        ],
-      }
-    );
-
-    this.assertHTML(
-      '<div><span>tomdale</span> - Tom Dale<span>chancancode</span> - Godfrey Chan<span>wycats</span> - Yehuda Katz</div>'
-    );
-    this.assertStableRerender();
-
-    this.rerender({
-      people: [
-        { handle: 'tomdale', name: 'Thomas Dale' },
-        { handle: 'wycats', name: 'Yehuda Katz' },
-      ],
-    });
-
-    this.assertHTML(
-      '<div><span>tomdale</span> - Thomas Dale<span>wycats</span> - Yehuda Katz</div>'
-    );
-  }
-
-  @test
-  'Simple helpers'() {
-    this.registerHelper('testing', ([id]) => id);
-    this.render('<div>{{testing this.title}}</div>', { title: 'hello' });
-    this.assertHTML('<div>hello</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Constant negative numbers can render'() {
-    this.registerHelper('testing', ([id]) => id);
-    this.render('<div>{{testing -123321}}</div>');
-    this.assertHTML('<div>-123321</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Large numeric literals (Number.MAX_SAFE_INTEGER)'() {
-    this.registerHelper('testing', ([id]) => id);
-    this.render('<div>{{testing 9007199254740991}}</div>');
-    this.assertHTML('<div>9007199254740991</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Integer powers of 2'() {
-    const ints = [];
-    let i = 9007199254740991; // Number.MAX_SAFE_INTEGER isn't available on IE11
-    while (i > 1) {
-      ints.push(i);
-      i = Math.round(i / 2);
-    }
-    i = -9007199254740991; // Number.MIN_SAFE_INTEGER isn't available on IE11
-    while (i < -1) {
-      ints.push(i);
-      i = Math.round(i / 2);
-    }
-    this.registerHelper('testing', ([id]) => id);
-    this.render(ints.map((i) => `{{${i}}}`).join('-'));
-    this.assertHTML(ints.map((i) => `${i}`).join('-'));
-    this.assertStableRerender();
-  }
-
-  @test
-  'odd integers'() {
-    this.render(
-      '{{4294967296}} {{4294967295}} {{4294967294}} {{536870913}} {{536870912}} {{536870911}} {{268435455}}'
-    );
-    this.assertHTML('4294967296 4294967295 4294967294 536870913 536870912 536870911 268435455');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Constant float numbers can render'() {
-    this.registerHelper('testing', ([id]) => id);
-    this.render('<div>{{testing 0.123}}</div>');
-    this.assertHTML('<div>0.123</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle simple helpers with inline null parameter'() {
-    let value;
-    this.registerHelper('say-hello', function (params) {
-      value = params[0];
-      return 'hello';
-    });
-    this.render('<div>{{say-hello null}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(value, null, 'is null');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle simple helpers with inline string literal null parameter'() {
-    let value;
-    this.registerHelper('say-hello', function (params) {
-      value = params[0];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello "null"}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(value, 'null', 'is null string literal');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle simple helpers with inline undefined parameter'() {
-    let value: unknown = 'PLACEHOLDER';
-    let length;
-    this.registerHelper('say-hello', function (params) {
-      length = params.length;
-      value = params[0];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello undefined}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(length, 1);
-    this.assert.strictEqual(value, undefined, 'is undefined');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle simple helpers with positional parameter undefined string literal'() {
-    let value: unknown = 'PLACEHOLDER';
-    let length;
-    this.registerHelper('say-hello', function (params) {
-      length = params.length;
-      value = params[0];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello "undefined"}} undefined</div>');
-    this.assertHTML('<div>hello undefined</div>');
-    this.assert.strictEqual(length, 1);
-    this.assert.strictEqual(value, 'undefined', 'is undefined string literal');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle components with undefined named arguments'() {
-    let value: unknown = 'PLACEHOLDER';
-    this.registerHelper('say-hello', function (_, hash) {
-      value = hash['foo'];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello foo=undefined}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(value, undefined, 'is undefined');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle components with undefined string literal named arguments'() {
-    let value: unknown = 'PLACEHOLDER';
-    this.registerHelper('say-hello', function (_, hash) {
-      value = hash['foo'];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello foo="undefined"}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(value, 'undefined', 'is undefined string literal');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle components with null named arguments'() {
-    let value;
-    this.registerHelper('say-hello', function (_, hash) {
-      value = hash['foo'];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello foo=null}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(value, null, 'is null');
-    this.assertStableRerender();
-  }
-
-  @test
-  'GH#13999 The compiler can handle components with null string literal named arguments'() {
-    let value;
-    this.registerHelper('say-hello', function (_, hash) {
-      value = hash['foo'];
-      return 'hello';
-    });
-
-    this.render('<div>{{say-hello foo="null"}}</div>');
-    this.assertHTML('<div>hello</div>');
-    this.assert.strictEqual(value, 'null', 'is null string literal');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Null curly in attributes'() {
-    this.render('<div class="foo {{null}}">hello</div>');
-    this.assertHTML('<div class="foo ">hello</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Null in primitive syntax'() {
-    this.render('{{#if null}}NOPE{{else}}YUP{{/if}}');
-    this.assertHTML('YUP');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Sexpr helpers'() {
-    this.registerHelper('testing', function (params) {
-      return `${params[0]}!`;
-    });
-
-    this.render('<div>{{testing (testing "hello")}}</div>');
-    this.assertHTML('<div>hello!!</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'The compiler can handle multiple invocations of sexprs'() {
-    this.registerHelper('testing', function (params) {
-      return `${params[0]}${params[1]}`;
-    });
-
-    this.render(
-      '<div>{{testing (testing "hello" this.foo) (testing (testing this.bar "lol") this.baz)}}</div>',
-      {
-        foo: 'FOO',
-        bar: 'BAR',
-        baz: 'BAZ',
-      }
-    );
-    this.assertHTML('<div>helloFOOBARlolBAZ</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'The compiler passes along the hash arguments'() {
-    this.registerHelper('testing', function (_, hash) {
-      return `${hash['first']}-${hash['second']}`;
-    });
-
-    this.render('<div>{{testing first="one" second="two"}}</div>');
-    this.assertHTML('<div>one-two</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Attributes can be populated with helpers that generate a string'() {
-    this.registerHelper('testing', function (params) {
-      return params[0];
-    });
-
-    this.render('<a href="{{testing this.url}}">linky</a>', { url: 'linky.html' });
-    this.assertHTML('<a href="linky.html">linky</a>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Attribute helpers take a hash'() {
-    this.registerHelper('testing', function (_, hash) {
-      return hash['path'];
-    });
-
-    this.render('<a href="{{testing path=this.url}}">linky</a>', { url: 'linky.html' });
-    this.assertHTML('<a href="linky.html">linky</a>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Attributes containing multiple helpers are treated like a block'() {
-    this.registerHelper('testing', function (params) {
-      return params[0];
-    });
-
-    this.render('<a href="http://{{this.foo}}/{{testing this.bar}}/{{testing "baz"}}">linky</a>', {
-      foo: 'foo.com',
-      bar: 'bar',
-    });
-    this.assertHTML('<a href="http://foo.com/bar/baz">linky</a>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'Elements inside a yielded block'() {
-    this.render('{{#if true}}<div id="test">123</div>{{/if}}');
-    this.assertHTML('<div id="test">123</div>');
-    this.assertStableRerender();
-  }
-
-  @test
-  'A simple block helper can return text'() {
-    this.render('{{#if true}}test{{else}}not shown{{/if}}');
-    this.assertHTML('test');
-    this.assertStableRerender();
-  }
-}
-
-const XHTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/dynamic.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/dynamic.ts
new file mode 100644
index 0000000000..cb583d3363
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/dynamic.ts
@@ -0,0 +1,1139 @@
+import type { SimpleElement } from '@glimmer/interfaces';
+import { castToBrowser, checkNode, NS_SVG, strip, unwrap } from '@glimmer/util';
+import {
+  assertNodeTagName,
+  firstElementChild,
+  getElementsByTagName,
+  matrix,
+} from '@glimmer-workspace/integration-tests';
+
+import { Woops } from '../../test-helpers/error';
+
+export const DynamicInitialRenderSuite = matrix('initial render (dynamic)', (spec, errors) => {
+  // @render
+  // 'HTML text content'() {
+  //   this.render.template('content');
+  //   this.assertHTML('content');
+  //   this.assertStableRerender();
+  // }
+
+  spec('Quoted attribute null values do not disable', (ctx) => {
+    ctx.render.template('<input disabled="{{this.isDisabled}}">', { isDisabled: null });
+    ctx.assertHTML('<input>');
+    ctx.assertStableRerender();
+
+    // TODO: What is the point of this test? (Note that it wouldn't work with SimpleDOM)
+    // assertNodeProperty(root.firstChild, 'input', 'disabled', false);
+
+    ctx.rerender({ isDisabled: true });
+    ctx.assertHTML('<input disabled>');
+    ctx.assertStableNodes();
+
+    // TODO: ??????????
+    ctx.rerender({ isDisabled: false });
+    ctx.assertHTML('<input disabled>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ isDisabled: null });
+    ctx.assertHTML('<input>');
+    ctx.assertStableNodes();
+  });
+
+  spec('Unquoted attribute null values do not disable', (ctx) => {
+    ctx.render.template('<input disabled={{this.isDisabled}}>', { isDisabled: null });
+    ctx.assertHTML('<input>');
+    ctx.assertStableRerender();
+
+    // TODO: What is the point of this test? (Note that it wouldn't work with SimpleDOM)
+    // assertNodeProperty(root.firstChild, 'input', 'disabled', false);
+
+    ctx.rerender({ isDisabled: true });
+    ctx.assertHTML('<input disabled>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ isDisabled: false });
+    ctx.assertHTML('<input>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ isDisabled: null });
+    ctx.assertHTML('<input>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Quoted attribute string values', (ctx) => {
+    ctx.render.template("<img src='{{this.src}}'>", { src: 'image.png' });
+    ctx.assertHTML("<img src='image.png'>");
+    ctx.assertStableRerender();
+
+    ctx.rerender({ src: 'newimage.png' });
+    ctx.assertHTML("<img src='newimage.png'>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: '' });
+    ctx.assertHTML("<img src=''>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: 'image.png' });
+    ctx.assertHTML("<img src='image.png'>");
+    ctx.assertStableNodes();
+  });
+
+  errors('Quoted attribute string values', {
+    template: "<p>{{#-try}}before<img src='{{value}}'>after{{/-try}}</p>",
+    value: 'image.png',
+  });
+
+  spec('Unquoted attribute string values', (ctx) => {
+    ctx.render.template('<img src={{this.src}}>', { src: 'image.png' });
+    ctx.assertHTML("<img src='image.png'>");
+    ctx.assertStableRerender();
+
+    ctx.rerender({ src: 'newimage.png' });
+    ctx.assertHTML("<img src='newimage.png'>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: '' });
+    ctx.assertHTML("<img src=''>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: 'image.png' });
+    ctx.assertHTML("<img src='image.png'>");
+    ctx.assertStableNodes();
+  });
+
+  errors('Unquoted attribute string values', {
+    template: '<p>{{#-try}}before<img src={{value}}>after{{/-try}}</p>',
+    value: 'image.png',
+  });
+
+  spec('Unquoted img src attribute is not rendered when set to `null`', (ctx) => {
+    ctx.render.template("<img src='{{this.src}}'>", { src: null });
+    ctx.assertHTML('<img>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ src: 'newimage.png' });
+    ctx.assertHTML("<img src='newimage.png'>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: '' });
+    ctx.assertHTML("<img src=''>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: null });
+    ctx.assertHTML('<img>');
+    ctx.assertStableNodes();
+  });
+
+  spec('Unquoted img src attribute is not rendered when set to `undefined`', (ctx) => {
+    ctx.render.template("<img src='{{this.src}}'>", { src: undefined });
+    ctx.assertHTML('<img>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ src: 'newimage.png' });
+    ctx.assertHTML("<img src='newimage.png'>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: '' });
+    ctx.assertHTML("<img src=''>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ src: undefined });
+    ctx.assertHTML('<img>');
+    ctx.assertStableNodes();
+  });
+
+  spec('Unquoted a href attribute is not rendered when set to `null`', (ctx) => {
+    ctx.render.template('<a href={{this.href}}></a>', { href: null });
+    ctx.assertHTML('<a></a>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ href: 'http://example.com' });
+    ctx.assertHTML("<a href='http://example.com'></a>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ href: '' });
+    ctx.assertHTML("<a href=''></a>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ href: null });
+    ctx.assertHTML('<a></a>');
+    ctx.assertStableNodes();
+  });
+
+  spec('Unquoted a href attribute is not rendered when set to `undefined`', (ctx) => {
+    ctx.render.template('<a href={{this.href}}></a>', { href: undefined });
+    ctx.assertHTML('<a></a>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ href: 'http://example.com' });
+    ctx.assertHTML("<a href='http://example.com'></a>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ href: '' });
+    ctx.assertHTML("<a href=''></a>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ href: undefined });
+    ctx.assertHTML('<a></a>');
+    ctx.assertStableNodes();
+  });
+
+  errors('Attribute expression can be followed by another attribute', {
+    template: "<div>{{#-try}}before<p foo='{{value}}' name='Alice'></p>after{{/-try}}</div>",
+    value: 'oh my',
+  });
+
+  spec('Attribute expression can be followed by another attribute', (ctx) => {
+    ctx.render.template("<div foo='{{this.funstuff}}' name='Alice'></div>", { funstuff: 'oh my' });
+    ctx.assertHTML("<div name='Alice' foo='oh my'></div>");
+    ctx.assertStableRerender();
+
+    ctx.rerender({ funstuff: 'oh boy' });
+    ctx.assertHTML("<div name='Alice' foo='oh boy'></div>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ funstuff: '' });
+    ctx.assertHTML("<div name='Alice' foo=''></div>");
+    ctx.assertStableNodes();
+
+    ctx.rerender({ funstuff: 'oh my' });
+    ctx.assertHTML("<div name='Alice' foo='oh my'></div>");
+    ctx.assertStableNodes();
+  });
+
+  spec('Dynamic selected options', (ctx) => {
+    ctx.render.template(
+      strip`
+      <select>
+        <option>1</option>
+        <option selected={{this.selected}}>2</option>
+        <option>3</option>
+      </select>
+    `,
+      { selected: true }
+    );
+
+    ctx.assertHTML(strip`
+      <select>
+        <option>1</option>
+        <option ${ctx.name === 'rehydration' ? ' selected=true' : ''}>2</option>
+        <option>3</option>
+      </select>
+    `);
+
+    let selectNode = checkNode(castToBrowser(ctx.element, 'HTML').firstElementChild, 'select');
+    ctx.assert.strictEqual(selectNode.selectedIndex, 1);
+    ctx.assertStableRerender();
+
+    ctx.rerender({ selected: false });
+    ctx.assertHTML(strip`
+      <select>
+        <option>1</option>
+        <option ${ctx.name === 'rehydration' ? ' selected=true' : ''}>2</option>
+        <option>3</option>
+      </select>
+    `);
+
+    selectNode = checkNode(castToBrowser(ctx.element, 'HTML').firstElementChild, 'select');
+
+    ctx.assert.strictEqual(selectNode.selectedIndex, 0);
+
+    ctx.assertStableNodes();
+
+    ctx.rerender({ selected: '' });
+
+    ctx.assertHTML(strip`
+      <select>
+        <option>1</option>
+        <option ${ctx.name === 'rehydration' ? ' selected=true' : ''}>2</option>
+        <option>3</option>
+      </select>
+    `);
+
+    selectNode = checkNode(castToBrowser(ctx.element, 'HTML').firstElementChild, 'select');
+
+    ctx.assert.strictEqual(selectNode.selectedIndex, 0);
+
+    ctx.assertStableNodes();
+
+    ctx.rerender({ selected: true });
+    ctx.assertHTML(strip`
+      <select>
+        <option>1</option>
+        <option ${ctx.name === 'rehydration' ? ' selected=true' : ''}>2</option>
+        <option>3</option>
+      </select>
+    `);
+
+    selectNode = checkNode(castToBrowser(ctx.element, 'HTML').firstElementChild, 'select');
+    ctx.assert.strictEqual(selectNode.selectedIndex, 1);
+    ctx.assertStableNodes();
+  });
+
+  spec('Dynamic multi-select', (ctx) => {
+    ctx.render.template(
+      strip`
+      <select multiple>
+        <option>0</option>
+        <option selected={{this.somethingTrue}}>1</option>
+        <option selected={{this.somethingTruthy}}>2</option>
+        <option selected={{this.somethingUndefined}}>3</option>
+        <option selected={{this.somethingNull}}>4</option>
+        <option selected={{this.somethingFalse}}>5</option>
+      </select>`,
+      {
+        somethingTrue: true,
+        somethingTruthy: 'is-true',
+        somethingUndefined: undefined,
+        somethingNull: null,
+        somethingFalse: false,
+      }
+    );
+
+    const selectNode = firstElementChild(ctx.element);
+    ctx.assert.ok(selectNode, 'rendered select');
+    if (selectNode === null) {
+      return;
+    }
+    const options = getElementsByTagName(selectNode, 'option');
+    const selected: SimpleElement[] = [];
+
+    for (const option of options) {
+      // TODO: This is a real discrepancy with SimpleDOM
+      if ((option as any).selected) {
+        selected.push(option);
+      }
+    }
+
+    const [first, second] = ctx.guardArray({ selected }, { min: 2 });
+
+    ctx.assertHTML(strip`
+      <select multiple="">
+        <option>0</option>
+        <option ${ctx.name === 'rehydration' ? ' selected=true' : ''}>1</option>
+        <option ${ctx.name === 'rehydration' ? ' selected=true' : ''}>2</option>
+        <option>3</option>
+        <option>4</option>
+        <option>5</option>
+      </select>`);
+
+    ctx.assert.strictEqual(selected.length, 2, 'two options are selected');
+    ctx.assert.strictEqual(castToBrowser(first, 'option').value, '1', 'first selected item is "1"');
+    ctx.assert.strictEqual(
+      castToBrowser(second, 'option').value,
+      '2',
+      'second selected item is "2"'
+    );
+  });
+
+  spec('HTML comments', (ctx) => {
+    ctx.render.template('<div><!-- Just passing through --></div>');
+    ctx.assertHTML('<div><!-- Just passing through --></div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Curlies in HTML comments', (ctx) => {
+    ctx.render.template('<div><!-- {{this.foo}} --></div>', { foo: 'foo' });
+    ctx.assertHTML('<div><!-- {{this.foo}} --></div>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ foo: 'bar' });
+    ctx.assertHTML('<div><!-- {{this.foo}} --></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ foo: '' });
+    ctx.assertHTML('<div><!-- {{this.foo}} --></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ foo: 'foo' });
+    ctx.assertHTML('<div><!-- {{this.foo}} --></div>');
+    ctx.assertStableNodes();
+  });
+
+  spec('Complex Curlies in HTML comments', (ctx) => {
+    ctx.render.template('<div><!-- {{this.foo bar baz}} --></div>', { foo: 'foo' });
+    ctx.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ foo: 'bar' });
+    ctx.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ foo: '' });
+    ctx.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ foo: 'foo' });
+    ctx.assertHTML('<div><!-- {{this.foo bar baz}} --></div>');
+    ctx.assertStableNodes();
+  });
+
+  spec('HTML comments with multi-line mustaches', (ctx) => {
+    ctx.render.template('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>');
+    ctx.assertHTML('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Top level comments', (ctx) => {
+    ctx.render.template('<!-- {{this.foo}} -->');
+    ctx.assertHTML('<!-- {{this.foo}} -->');
+    ctx.assertStableRerender();
+  });
+
+  spec('Handlebars comments', (ctx) => {
+    ctx.render.template('<div>{{! Better not break! }}content</div>');
+    ctx.assertHTML('<div>content</div>');
+    ctx.assertStableRerender();
+  });
+
+  errors('Namespaced attribute', {
+    template: `<svg xmlns:xlink="http://www.w3.org/1999/xlink">{{#-try}}<use xlink:href="{{value}}"></use>{{/-try}}</svg>`,
+    value: 'home',
+  });
+
+  spec('Namespaced attribute', (ctx) => {
+    ctx.render.template("<svg xlink:title='svg-title'>content</svg>");
+    ctx.assertHTML("<svg xlink:title='svg-title'>content</svg>");
+    ctx.assertStableRerender();
+  });
+
+  spec('svg href attribute with quotation marks', (ctx) => {
+    ctx.render.template(
+      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="{{this.iconLink}}"></use></svg>`,
+      { iconLink: 'home' }
+    );
+    ctx.assertHTML(
+      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="home"></use></svg>`
+    );
+    const svg = ctx.element.firstChild;
+    if (assertNodeTagName(svg, 'svg')) {
+      const use = svg.firstChild;
+      if (assertNodeTagName(use, 'use')) {
+        ctx.assert.strictEqual(use.href.baseVal, 'home');
+      }
+    }
+  });
+
+  spec('svg href attribute without quotation marks', (ctx) => {
+    ctx.render.template(
+      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href={{this.iconLink}}></use></svg>`,
+      { iconLink: 'home' }
+    );
+    ctx.assertHTML(
+      `<svg xmlns:xlink="http://www.w3.org/1999/xlink"><use xlink:href="home"></use></svg>`
+    );
+    const svg = ctx.element.firstChild;
+    if (assertNodeTagName(svg, 'svg')) {
+      const use = svg.firstChild;
+      if (assertNodeTagName(use, 'use')) {
+        ctx.assert.strictEqual(use.href.baseVal, 'home');
+      }
+    }
+  });
+
+  spec('<svg> tag with case-sensitive attribute', (ctx) => {
+    ctx.render.template('<svg viewBox="0 0 0 0"></svg>');
+    ctx.assertHTML('<svg viewBox="0 0 0 0"></svg>');
+    const svg = ctx.element.firstChild;
+    if (assertNodeTagName(svg, 'svg')) {
+      ctx.assert.strictEqual(svg.namespaceURI, NS_SVG);
+      ctx.assert.strictEqual(svg.getAttribute('viewBox'), '0 0 0 0');
+    }
+    ctx.assertStableRerender();
+  });
+
+  spec('nested element in the SVG namespace', (ctx) => {
+    const d = 'M 0 0 L 100 100';
+    ctx.render.template(`<svg><path d="${d}"></path></svg>`);
+    ctx.assertHTML(`<svg><path d="${d}"></path></svg>`);
+
+    const svg = ctx.element.firstChild;
+
+    if (assertNodeTagName(svg, 'svg')) {
+      ctx.assert.strictEqual(svg.namespaceURI, NS_SVG);
+
+      const path = svg.firstChild;
+      if (assertNodeTagName(path, 'path')) {
+        ctx.assert.strictEqual(
+          path.namespaceURI,
+          NS_SVG,
+          'creates the path element with a namespace'
+        );
+        ctx.assert.strictEqual(path.getAttribute('d'), d);
+      }
+    }
+
+    ctx.assertStableRerender();
+  });
+
+  spec('<foreignObject> tag has an SVG namespace', (ctx) => {
+    ctx.render.template('<svg><foreignObject>Hi</foreignObject></svg>');
+    ctx.assertHTML('<svg><foreignObject>Hi</foreignObject></svg>');
+
+    const svg = ctx.element.firstChild;
+
+    if (assertNodeTagName(svg, 'svg')) {
+      ctx.assert.strictEqual(svg.namespaceURI, NS_SVG);
+
+      const foreignObject = svg.firstChild;
+
+      if (assertNodeTagName(foreignObject, 'foreignObject')) {
+        ctx.assert.strictEqual(
+          foreignObject.namespaceURI,
+          NS_SVG,
+          'creates the foreignObject element with a namespace'
+        );
+      }
+    }
+
+    ctx.assertStableRerender();
+  });
+
+  spec('Namespaced and non-namespaced elements as siblings', (ctx) => {
+    ctx.render.template('<svg></svg><svg></svg><div></div>');
+    ctx.assertHTML('<svg></svg><svg></svg><div></div>');
+
+    const [firstChild, secondChild, thirdChild] = ctx.guardArray(
+      { childNodes: ctx.element.childNodes },
+      { min: 3 }
+    );
+
+    ctx.assert.strictEqual(
+      castToBrowser(unwrap(firstChild), 'SVG').namespaceURI,
+      NS_SVG,
+      'creates the first svg element with a namespace'
+    );
+
+    ctx.assert.strictEqual(
+      castToBrowser(secondChild, 'SVG').namespaceURI,
+      NS_SVG,
+      'creates the second svg element with a namespace'
+    );
+
+    ctx.assert.strictEqual(
+      castToBrowser(thirdChild, 'HTML').namespaceURI,
+      XHTML_NAMESPACE,
+      'creates the div element without a namespace'
+    );
+
+    ctx.assertStableRerender();
+  });
+
+  spec('Namespaced and non-namespaced elements with nesting', (ctx) => {
+    ctx.render.template('<div><svg></svg></div><div></div>');
+
+    const firstDiv = ctx.element.firstChild;
+    const secondDiv = ctx.element.lastChild;
+    const svg = firstDiv && firstDiv.firstChild;
+
+    ctx.assertHTML('<div><svg></svg></div><div></div>');
+
+    if (assertNodeTagName(firstDiv, 'div')) {
+      ctx.assert.strictEqual(
+        firstDiv.namespaceURI,
+        XHTML_NAMESPACE,
+        "first div's namespace is xhtmlNamespace"
+      );
+    }
+
+    if (assertNodeTagName(svg, 'svg')) {
+      ctx.assert.strictEqual(svg.namespaceURI, NS_SVG, "svg's namespace is svgNamespace");
+    }
+
+    if (assertNodeTagName(secondDiv, 'div')) {
+      ctx.assert.strictEqual(
+        secondDiv.namespaceURI,
+        XHTML_NAMESPACE,
+        "last div's namespace is xhtmlNamespace"
+      );
+    }
+
+    ctx.assertStableRerender();
+  });
+
+  spec('Case-sensitive tag has capitalization preserved', (ctx) => {
+    ctx.render.template('<svg><linearGradient id="gradient"></linearGradient></svg>');
+    ctx.assertHTML('<svg><linearGradient id="gradient"></linearGradient></svg>');
+    ctx.assertStableRerender();
+  });
+
+  errors('Text curlies', {
+    template: '<div>{{#-try}}{{value}}<span>{{value}}</span>{{/-try}}</div>',
+    value: 'hello',
+  });
+
+  spec('Text curlies', (ctx) => {
+    ctx.render.template('<div>{{this.title}}<span>{{this.title}}</span></div>', {
+      title: 'hello',
+    });
+    ctx.assertHTML('<div>hello<span>hello</span></div>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ title: 'goodbye' });
+    ctx.assertHTML('<div>goodbye<span>goodbye</span></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ title: '' });
+    ctx.assertHTML('<div><span></span></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ title: 'hello' });
+    ctx.assertHTML('<div>hello<span>hello</span></div>');
+    ctx.assertStableNodes();
+  });
+
+  spec('Text curlies (error handling)', (ctx) => {
+    const woops = Woops.noop();
+
+    ctx.render.template(
+      '<div>{{#-try this.woops.handleError}}<span>{{this.woops.value}}</span>{{/-try}}<span>{{this.title}}</span></div>',
+      { woops, title: 'hello' }
+    );
+
+    ctx.assertHTML('<div><span>no woops</span><span>hello</span></div>');
+    woops.isError = true;
+
+    // ctx.rerender();
+    // ctx.assertHTML('<div><span>hello</span></div>');
+  });
+
+  spec('Repaired text nodes are ensured in the right place Part 1', (ctx) => {
+    ctx.render.template('{{this.a}} {{this.b}}', { a: 'A', b: 'B', c: 'C', d: 'D' });
+    ctx.assertHTML('A B');
+    ctx.assertStableRerender();
+  });
+
+  spec('Repaired text nodes are ensured in the right place Part 2', (ctx) => {
+    ctx.render.template('<div>{{this.a}}{{this.b}}{{this.c}}wat{{this.d}}</div>', {
+      a: 'A',
+      b: 'B',
+      c: 'C',
+      d: 'D',
+    });
+    ctx.assertHTML('<div>ABCwatD</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Repaired text nodes are ensured in the right place Part 3', (ctx) => {
+    ctx.render.template('{{this.a}}{{this.b}}<img><img><img><img>', {
+      a: 'A',
+      b: 'B',
+      c: 'C',
+      d: 'D',
+    });
+    ctx.assertHTML('AB<img><img><img><img>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Path expressions', (ctx) => {
+    ctx.render.template('<div>{{this.model.foo.bar}}<span>{{this.model.foo.bar}}</span></div>', {
+      model: { foo: { bar: 'hello' } },
+    });
+    ctx.assertHTML('<div>hello<span>hello</span></div>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ model: { foo: { bar: 'goodbye' } } });
+    ctx.assertHTML('<div>goodbye<span>goodbye</span></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ model: { foo: { bar: '' } } });
+    ctx.assertHTML('<div><span></span></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ model: { foo: { bar: 'hello' } } });
+    ctx.assertHTML('<div>hello<span>hello</span></div>');
+    ctx.assertStableNodes();
+  });
+
+  errors(`Text curlies produce text nodes (not HTML)`, {
+    template: `<div>{{#-try}}{{value}}<span>{{value}}</span>{{/-try}}</div>`,
+    value: `<strong>hello</strong>`,
+  });
+
+  spec('Text curlies produce text nodes (not HTML)', (ctx) => {
+    ctx.render.template('<div>{{this.title}}<span>{{this.title}}</span></div>', {
+      title: '<strong>hello</strong>',
+    });
+    ctx.assertHTML(
+      '<div>&lt;strong&gt;hello&lt;/strong&gt;<span>&lt;strong>hello&lt;/strong&gt;</span></div>'
+    );
+    ctx.assertStableRerender();
+
+    ctx.rerender({ title: '<i>goodbye</i>' });
+    ctx.assertHTML('<div>&lt;i&gt;goodbye&lt;/i&gt;<span>&lt;i&gt;goodbye&lt;/i&gt;</span></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ title: '' });
+    ctx.assertHTML('<div><span></span></div>');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ title: '<strong>hello</strong>' });
+    ctx.assertHTML(
+      '<div>&lt;strong&gt;hello&lt;/strong&gt;<span>&lt;strong>hello&lt;/strong&gt;</span></div>'
+    );
+    ctx.assertStableNodes();
+  });
+
+  errors(`whitespace`, {
+    template: `<div>{{#-try}}Hello {{value}}{{/-try}}</div>`,
+    value: `world`,
+  });
+
+  spec('Rerender respects whitespace', (ctx) => {
+    ctx.render.template('Hello {{ this.foo }} ', { foo: 'bar' });
+    ctx.assertHTML('Hello bar ');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ foo: 'baz' });
+    ctx.assertHTML('Hello baz ');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ foo: '' });
+    ctx.assertHTML('Hello  ');
+    ctx.assertStableNodes();
+
+    ctx.rerender({ foo: 'bar' });
+    ctx.assertHTML('Hello bar ');
+    ctx.assertStableNodes();
+  });
+
+  spec('Safe HTML curlies', (ctx) => {
+    const title = {
+      toHTML() {
+        return '<span>hello</span> <em>world</em>';
+      },
+    };
+    ctx.render.template('<div>{{this.title}}</div>', { title });
+    ctx.assertHTML('<div><span>hello</span> <em>world</em></div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Triple curlies', (ctx) => {
+    const title = '<span>hello</span> <em>world</em>';
+    ctx.render.template('<div>{{{this.title}}}</div>', { title });
+    ctx.assertHTML('<div><span>hello</span> <em>world</em></div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Triple curlie helpers', (ctx) => {
+    ctx.register.helper('unescaped', ([param]) => param);
+    ctx.register.helper('escaped', ([param]) => param);
+    ctx.render.template(
+      '{{{unescaped "<strong>Yolo</strong>"}}} {{escaped "<strong>Yolo</strong>"}}'
+    );
+    ctx.assertHTML('<strong>Yolo</strong> &lt;strong&gt;Yolo&lt;/strong&gt;');
+    ctx.assertStableRerender();
+  });
+
+  spec('Top level triple curlies', (ctx) => {
+    const title = '<span>hello</span> <em>world</em>';
+    ctx.render.template('{{{this.title}}}', { title });
+    ctx.assertHTML('<span>hello</span> <em>world</em>');
+    ctx.assertStableRerender();
+  });
+
+  errors(`Top level triple curlies`, {
+    template: `{{#-try}}{{{value}}}{{/-try}}`,
+    value: `<span>hello</span> <em>world</em>`,
+  });
+
+  spec('Top level unescaped tr', (ctx) => {
+    const title = '<tr><td>Yo</td></tr>';
+    ctx.render.template('<table>{{{this.title}}}</table>', { title });
+    ctx.assertHTML('<table><tbody><tr><td>Yo</td></tr></tbody></table>');
+    ctx.assertStableRerender();
+  });
+
+  errors(`Top level unescaped tr`, {
+    template: `<table>{{#-try}}{{{value}}}{{/-try}}</table>`,
+    value: `<tr><td>Yo</td></tr>`,
+  });
+
+  spec('The compiler can handle top-level unescaped td inside tr contextualElement', (ctx) => {
+    ctx.render.template('{{{this.html}}}', { html: '<td>Yo</td>' });
+    ctx.assertHTML('<tr><td>Yo</td></tr>');
+    ctx.assertStableRerender();
+  });
+
+  errors(`unescaped td inside tr`, {
+    template: `{{#-try}}{{{value}}}{{/-try}}`,
+    value: `<td>Yo</td>`,
+  });
+
+  spec('Extreme nesting', (ctx) => {
+    ctx.render.template(
+      '{{this.foo}}<span>{{this.bar}}<a>{{this.baz}}<em>{{this.boo}}{{this.brew}}</em>{{this.bat}}</a></span><span><span>{{this.flute}}</span></span>{{this.argh}}',
+      {
+        foo: 'FOO',
+        bar: 'BAR',
+        baz: 'BAZ',
+        boo: 'BOO',
+        brew: 'BREW',
+        bat: 'BAT',
+        flute: 'FLUTE',
+        argh: 'ARGH',
+      }
+    );
+    ctx.assertHTML(
+      'FOO<span>BAR<a>BAZ<em>BOOBREW</em>BAT</a></span><span><span>FLUTE</span></span>ARGH'
+    );
+    ctx.assertStableRerender();
+  });
+
+  spec('Simple blocks', (ctx) => {
+    ctx.render.template('<div>{{#if this.admin}}<p>{{this.user}}</p>{{/if}}!</div>', {
+      admin: true,
+      user: 'chancancode',
+    });
+    ctx.assertHTML('<div><p>chancancode</p>!</div>');
+    ctx.assertStableRerender();
+
+    const p = ctx.element.firstChild!.firstChild!;
+
+    ctx.rerender({ admin: false });
+    ctx.assertHTML('<div><!---->!</div>');
+    ctx.assertStableNodes({ except: p });
+
+    const comment = ctx.element.firstChild!.firstChild!;
+
+    ctx.rerender({ admin: true });
+    ctx.assertHTML('<div><p>chancancode</p>!</div>');
+    ctx.assertStableNodes({ except: comment });
+  });
+
+  spec('Nested blocks', (ctx) => {
+    ctx.render.template(
+      '<div>{{#if this.admin}}{{#if this.access}}<p>{{this.user}}</p>{{/if}}{{/if}}!</div>',
+      {
+        admin: true,
+        access: true,
+        user: 'chancancode',
+      }
+    );
+    ctx.assertHTML('<div><p>chancancode</p>!</div>');
+    ctx.assertStableRerender();
+
+    let p = ctx.element.firstChild!.firstChild!;
+
+    ctx.rerender({ admin: false });
+    ctx.assertHTML('<div><!---->!</div>');
+    ctx.assertStableNodes({ except: p });
+
+    const comment = ctx.element.firstChild!.firstChild!;
+
+    ctx.rerender({ admin: true });
+    ctx.assertHTML('<div><p>chancancode</p>!</div>');
+    ctx.assertStableNodes({ except: comment });
+
+    p = ctx.element.firstChild!.firstChild!;
+
+    ctx.rerender({ access: false });
+    ctx.assertHTML('<div><!---->!</div>');
+    ctx.assertStableNodes({ except: p });
+  });
+
+  spec('Loops', (ctx) => {
+    ctx.render.template(
+      '<div>{{#each this.people key="handle" as |p|}}<span>{{p.handle}}</span> - {{p.name}}{{/each}}</div>',
+      {
+        people: [
+          { handle: 'tomdale', name: 'Tom Dale' },
+          { handle: 'chancancode', name: 'Godfrey Chan' },
+          { handle: 'wycats', name: 'Yehuda Katz' },
+        ],
+      }
+    );
+
+    ctx.assertHTML(
+      '<div><span>tomdale</span> - Tom Dale<span>chancancode</span> - Godfrey Chan<span>wycats</span> - Yehuda Katz</div>'
+    );
+    ctx.assertStableRerender();
+
+    ctx.rerender({
+      people: [
+        { handle: 'tomdale', name: 'Thomas Dale' },
+        { handle: 'wycats', name: 'Yehuda Katz' },
+      ],
+    });
+
+    ctx.assertHTML(
+      '<div><span>tomdale</span> - Thomas Dale<span>wycats</span> - Yehuda Katz</div>'
+    );
+  });
+
+  spec('Simple helpers', (ctx) => {
+    ctx.register.helper('testing', ([id]) => id);
+    ctx.render.template('<div>{{testing this.title}}</div>', { title: 'hello' });
+    ctx.assertHTML('<div>hello</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Constant negative numbers can render', (ctx) => {
+    ctx.register.helper('testing', ([id]) => id);
+    ctx.render.template('<div>{{testing -123321}}</div>');
+    ctx.assertHTML('<div>-123321</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Large numeric literals (Number.MAX_SAFE_INTEGER)', (ctx) => {
+    ctx.register.helper('testing', ([id]) => id);
+    ctx.render.template('<div>{{testing 9007199254740991}}</div>');
+    ctx.assertHTML('<div>9007199254740991</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Integer powers of 2', (ctx) => {
+    const ints = [];
+    let i = 9007199254740991; // Number.MAX_SAFE_INTEGER isn't available on IE11
+    while (i > 1) {
+      ints.push(i);
+      i = Math.round(i / 2);
+    }
+    i = -9007199254740991; // Number.MIN_SAFE_INTEGER isn't available on IE11
+    while (i < -1) {
+      ints.push(i);
+      i = Math.round(i / 2);
+    }
+    ctx.register.helper('testing', ([id]) => id);
+    ctx.render.template(ints.map((i) => `{{${i}}}`).join('-'));
+    ctx.assertHTML(ints.map((i) => `${i}`).join('-'));
+    ctx.assertStableRerender();
+  });
+
+  spec('odd integers', (ctx) => {
+    ctx.render.template(
+      '{{4294967296}} {{4294967295}} {{4294967294}} {{536870913}} {{536870912}} {{536870911}} {{268435455}}'
+    );
+    ctx.assertHTML('4294967296 4294967295 4294967294 536870913 536870912 536870911 268435455');
+    ctx.assertStableRerender();
+  });
+
+  spec('Constant float numbers can render', (ctx) => {
+    ctx.register.helper('testing', ([id]) => id);
+    ctx.render.template('<div>{{testing 0.123}}</div>');
+    ctx.assertHTML('<div>0.123</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('GH#13999 The compiler can handle simple helpers with inline null parameter', (ctx) => {
+    let value;
+    ctx.register.helper('say-hello', (params) => {
+      value = params[0];
+      return 'hello';
+    });
+    ctx.render.template('<div>{{say-hello null}}</div>');
+    ctx.assertHTML('<div>hello</div>');
+    ctx.assert.strictEqual(value, null, 'is null');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    'GH#13999 The compiler can handle simple helpers with inline string literal null parameter',
+    (ctx) => {
+      let value;
+      ctx.register.helper('say-hello', (params) => {
+        value = params[0];
+        return 'hello';
+      });
+
+      ctx.render.template('<div>{{say-hello "null"}}</div>');
+      ctx.assertHTML('<div>hello</div>');
+      ctx.assert.strictEqual(value, 'null', 'is null string literal');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec('GH#13999 The compiler can handle simple helpers with inline undefined parameter', (ctx) => {
+    let value: unknown = 'PLACEHOLDER';
+    let length;
+    ctx.register.helper('say-hello', (params) => {
+      length = params.length;
+      value = params[0];
+      return 'hello';
+    });
+
+    ctx.render.template('<div>{{say-hello undefined}}</div>');
+    ctx.assertHTML('<div>hello</div>');
+    ctx.assert.strictEqual(length, 1);
+    ctx.assert.strictEqual(value, undefined, 'is undefined');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    'GH#13999 The compiler can handle simple helpers with positional parameter undefined string literal',
+    (ctx) => {
+      let value: unknown = 'PLACEHOLDER';
+      let length;
+      ctx.register.helper('say-hello', (params) => {
+        length = params.length;
+        value = params[0];
+        return 'hello';
+      });
+
+      ctx.render.template('<div>{{say-hello "undefined"}} undefined</div>');
+      ctx.assertHTML('<div>hello undefined</div>');
+      ctx.assert.strictEqual(length, 1);
+      ctx.assert.strictEqual(value, 'undefined', 'is undefined string literal');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec('GH#13999 The compiler can handle components with undefined named arguments', (ctx) => {
+    let value: unknown = 'PLACEHOLDER';
+    ctx.register.helper('say-hello', (_, hash) => {
+      value = hash['foo'];
+      return 'hello';
+    });
+
+    ctx.render.template('<div>{{say-hello foo=undefined}}</div>');
+    ctx.assertHTML('<div>hello</div>');
+    ctx.assert.strictEqual(value, undefined, 'is undefined');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    'GH#13999 The compiler can handle components with undefined string literal named arguments',
+    (ctx) => {
+      let value: unknown = 'PLACEHOLDER';
+      ctx.register.helper('say-hello', (_, hash) => {
+        value = hash['foo'];
+        return 'hello';
+      });
+
+      ctx.render.template('<div>{{say-hello foo="undefined"}}</div>');
+      ctx.assertHTML('<div>hello</div>');
+      ctx.assert.strictEqual(value, 'undefined', 'is undefined string literal');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec('GH#13999 The compiler can handle components with null named arguments', (ctx) => {
+    let value;
+    ctx.register.helper('say-hello', (_, hash) => {
+      value = hash['foo'];
+      return 'hello';
+    });
+
+    ctx.render.template('<div>{{say-hello foo=null}}</div>');
+    ctx.assertHTML('<div>hello</div>');
+    ctx.assert.strictEqual(value, null, 'is null');
+    ctx.assertStableRerender();
+  });
+
+  spec(
+    'GH#13999 The compiler can handle components with null string literal named arguments',
+    (ctx) => {
+      let value;
+      ctx.register.helper('say-hello', (_, hash) => {
+        value = hash['foo'];
+        return 'hello';
+      });
+
+      ctx.render.template('<div>{{say-hello foo="null"}}</div>');
+      ctx.assertHTML('<div>hello</div>');
+      ctx.assert.strictEqual(value, 'null', 'is null string literal');
+      ctx.assertStableRerender();
+    }
+  );
+
+  spec('Null curly in attributes', (ctx) => {
+    ctx.render.template('<div class="foo {{null}}">hello</div>');
+    ctx.assertHTML('<div class="foo ">hello</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Null in primitive syntax', (ctx) => {
+    ctx.render.template('{{#if null}}NOPE{{else}}YUP{{/if}}');
+    ctx.assertHTML('YUP');
+    ctx.assertStableRerender();
+  });
+
+  spec('Sexpr helpers', (ctx) => {
+    ctx.register.helper('testing', (params) => {
+      return `${params[0]}!`;
+    });
+
+    ctx.render.template('<div>{{testing (testing "hello")}}</div>');
+    ctx.assertHTML('<div>hello!!</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('The compiler can handle multiple invocations of sexprs', (ctx) => {
+    ctx.register.helper('testing', (params) => {
+      return `${params[0]}${params[1]}`;
+    });
+
+    ctx.render.template(
+      '<div>{{testing (testing "hello" this.foo) (testing (testing this.bar "lol") this.baz)}}</div>',
+      {
+        foo: 'FOO',
+        bar: 'BAR',
+        baz: 'BAZ',
+      }
+    );
+    ctx.assertHTML('<div>helloFOOBARlolBAZ</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('The compiler passes along the hash arguments', (ctx) => {
+    ctx.register.helper('testing', (_, hash) => {
+      return `${hash['first']}-${hash['second']}`;
+    });
+
+    ctx.render.template('<div>{{testing first="one" second="two"}}</div>');
+    ctx.assertHTML('<div>one-two</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Attributes can be populated with helpers that generate a string', (ctx) => {
+    ctx.register.helper('testing', (params) => {
+      return params[0];
+    });
+
+    ctx.render.template('<a href="{{testing this.url}}">linky</a>', { url: 'linky.html' });
+    ctx.assertHTML('<a href="linky.html">linky</a>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Attribute helpers take a hash', (ctx) => {
+    ctx.register.helper('testing', (_, hash) => {
+      return hash['path'];
+    });
+
+    ctx.render.template('<a href="{{testing path=this.url}}">linky</a>', { url: 'linky.html' });
+    ctx.assertHTML('<a href="linky.html">linky</a>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Attributes containing multiple helpers are treated like a block', (ctx) => {
+    ctx.register.helper('testing', (params) => {
+      return params[0];
+    });
+
+    ctx.render.template(
+      '<a href="http://{{this.foo}}/{{testing this.bar}}/{{testing "baz"}}">linky</a>',
+      {
+        foo: 'foo.com',
+        bar: 'bar',
+      }
+    );
+    ctx.assertHTML('<a href="http://foo.com/bar/baz">linky</a>');
+    ctx.assertStableRerender();
+  });
+
+  spec('Elements inside a yielded block', (ctx) => {
+    ctx.render.template('{{#if true}}<div id="test">123</div>{{/if}}');
+    ctx.assertHTML('<div id="test">123</div>');
+    ctx.assertStableRerender();
+  });
+
+  spec('A simple block helper can return text', (ctx) => {
+    ctx.render.template('{{#if true}}test{{else}}not shown{{/if}}');
+    ctx.assertHTML('test');
+    ctx.assertStableRerender();
+  });
+});
+
+DynamicInitialRenderSuite.client();
+
+const XHTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/index.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/index.ts
new file mode 100644
index 0000000000..93db0e1555
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/index.ts
@@ -0,0 +1,6 @@
+import { DynamicInitialRenderSuite } from './dynamic';
+import { InitialRenderTests } from './static';
+
+InitialRenderTests.client();
+
+export { DynamicInitialRenderSuite, InitialRenderTests };
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/static.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/static.ts
new file mode 100644
index 0000000000..b744c90e77
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/initial-render/static.ts
@@ -0,0 +1,192 @@
+import { strip } from '@glimmer/util';
+
+import { matrix } from '../../matrix';
+
+export const InitialRenderTests = matrix('initial render (static)', (test) => {
+  test('HTML text content', (ctx) => {
+    ctx.render.template('content');
+    ctx.assertHTML('content');
+    ctx.assertStableRerender();
+  });
+
+  test('HTML tags', (ctx) => {
+    ctx.render.template('<h1>hello!</h1><div>content</div>');
+    ctx.assertHTML('<h1>hello!</h1><div>content</div>');
+    ctx.assertStableRerender();
+  });
+
+  test('HTML attributes', (ctx) => {
+    ctx.render.template("<div class='foo' id='bar'>content</div>");
+    ctx.assertHTML("<div class='foo' id='bar'>content</div>");
+    ctx.assertStableRerender();
+  });
+
+  test('HTML data attributes', (ctx) => {
+    ctx.render.template("<div data-some-data='foo'>content</div>");
+    ctx.assertHTML("<div data-some-data='foo'>content</div>");
+    ctx.assertStableRerender();
+  });
+
+  test('HTML checked attributes', (ctx) => {
+    ctx.render.template("<input checked='checked'>");
+    ctx.assertHTML(`<input checked='checked'>`);
+    ctx.assertStableRerender();
+  });
+
+  test('HTML selected options', (ctx) => {
+    ctx.render.template(strip`
+      <select>
+        <option>1</option>
+        <option selected>2</option>
+        <option>3</option>
+      </select>
+    `);
+    ctx.assertHTML(strip`
+      <select>
+        <option>1</option>
+        <option selected>2</option>
+        <option>3</option>
+      </select>
+    `);
+    ctx.assertStableRerender();
+  });
+
+  test('HTML multi-select options', (ctx) => {
+    ctx.render.template(strip`
+      <select multiple>
+        <option>1</option>
+        <option selected>2</option>
+        <option selected>3</option>
+      </select>
+    `);
+    ctx.assertHTML(strip`
+      <select multiple>
+        <option>1</option>
+        <option selected>2</option>
+        <option selected>3</option>
+      </select>
+    `);
+    ctx.assertStableRerender();
+  });
+
+  test('Void Elements', (ctx) => {
+    const voidElements = 'area base br embed hr img input keygen link meta param source track wbr';
+    voidElements.split(' ').forEach((tagName) => ctx.shouldBeVoid(tagName));
+  });
+
+  test('Nested HTML', (ctx) => {
+    ctx.render.template(
+      "<div class='foo'><p><span id='bar' data-foo='bar'>hi!</span></p></div>&nbsp;More content"
+    );
+    ctx.assertHTML(
+      "<div class='foo'><p><span id='bar' data-foo='bar'>hi!</span></p></div>&nbsp;More content"
+    );
+    ctx.assertStableRerender();
+  });
+
+  test('Custom Elements', (ctx) => {
+    ctx.render.template('<use-the-platform></use-the-platform>');
+    ctx.assertHTML('<use-the-platform></use-the-platform>');
+    ctx.assertStableRerender();
+  });
+
+  test('Nested Custom Elements', (ctx) => {
+    ctx.render.template(
+      "<use-the-platform><seriously-please data-foo='1'>Stuff <div>Here</div></seriously-please></use-the-platform>"
+    );
+    ctx.assertHTML(
+      "<use-the-platform><seriously-please data-foo='1'>Stuff <div>Here</div></seriously-please></use-the-platform>"
+    );
+    ctx.assertStableRerender();
+  });
+
+  test('Moar nested Custom Elements', (ctx) => {
+    ctx.render.template(
+      "<use-the-platform><seriously-please data-foo='1'><wheres-the-platform>Here</wheres-the-platform></seriously-please></use-the-platform>"
+    );
+    ctx.assertHTML(
+      "<use-the-platform><seriously-please data-foo='1'><wheres-the-platform>Here</wheres-the-platform></seriously-please></use-the-platform>"
+    );
+    ctx.assertStableRerender();
+  });
+
+  test('Custom Elements with dynamic attributes', (ctx) => {
+    ctx.render.template(
+      "<fake-thing><other-fake-thing data-src='extra-{{this.someDynamicBits}}-here' /></fake-thing>",
+      { someDynamicBits: 'things' }
+    );
+    ctx.assertHTML("<fake-thing><other-fake-thing data-src='extra-things-here' /></fake-thing>");
+    ctx.assertStableRerender();
+  });
+
+  test('Custom Elements with dynamic content', (ctx) => {
+    ctx.render.template('<x-foo><x-bar>{{this.derp}}</x-bar></x-foo>', { derp: 'stuff' });
+    ctx.assertHTML('<x-foo><x-bar>stuff</x-bar></x-foo>');
+    ctx.assertStableRerender();
+  });
+
+  test('Dynamic content within single custom element', (ctx) => {
+    ctx.render.template('<x-foo>{{#if this.derp}}Content Here{{/if}}</x-foo>', { derp: 'stuff' });
+    ctx.assertHTML('<x-foo>Content Here</x-foo>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ derp: false });
+    ctx.assertHTML('<x-foo><!----></x-foo>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ derp: true });
+    ctx.assertHTML('<x-foo>Content Here</x-foo>');
+    ctx.assertStableRerender();
+
+    ctx.rerender({ derp: 'stuff' });
+    ctx.assertHTML('<x-foo>Content Here</x-foo>');
+    ctx.assertStableRerender();
+  });
+
+  test('Supports quotes', (ctx) => {
+    ctx.render.template('<div>"This is a title," we\'re on a boat</div>');
+    ctx.assertHTML('<div>"This is a title," we\'re on a boat</div>');
+    ctx.assertStableRerender();
+  });
+
+  test('Supports backslashes', (ctx) => {
+    ctx.render.template('<div>This is a backslash: \\</div>');
+    ctx.assertHTML('<div>This is a backslash: \\</div>');
+    ctx.assertStableRerender();
+  });
+
+  test('Supports new lines', (ctx) => {
+    ctx.render.template('<div>common\n\nbro</div>');
+    ctx.assertHTML('<div>common\n\nbro</div>');
+    ctx.assertStableRerender();
+  });
+
+  test('HTML tag with empty attribute', (ctx) => {
+    ctx.render.template("<div class=''>content</div>");
+    ctx.assertHTML("<div class=''>content</div>");
+    ctx.assertStableRerender();
+  });
+
+  test('Attributes containing a helper are treated like a block', (ctx) => {
+    ctx.register.helper('testing', (params) => {
+      ctx.assert.deepEqual(params, [123]);
+      return 'example.com';
+    });
+
+    ctx.render.template('<a href="http://{{testing 123}}/index.html">linky</a>');
+    ctx.assertHTML('<a href="http://example.com/index.html">linky</a>');
+    ctx.assertStableRerender();
+  });
+
+  test("HTML boolean attribute 'disabled'", (ctx) => {
+    ctx.render.template('<input disabled>');
+    ctx.assertHTML('<input disabled>');
+
+    // TODO: What is the point of this test? (Note that it wouldn't work with SimpleDOM)
+    // assertNodeProperty(root.firstChild, 'input', 'disabled', true);
+
+    ctx.assertStableRerender();
+  });
+});
+
+InitialRenderTests.client();
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/scope.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/scope.ts
index 87f8764d13..ffa7259fc9 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/scope.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/scope.ts
@@ -1,13 +1,13 @@
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render } from '../test-decorator';
 import { stripTight } from '../test-helpers/strings';
 
-export class ScopeSuite extends RenderTest {
+export class ScopeSuite extends RenderTestContext {
   static suiteName = 'Scope';
 
-  @test
+  @render
   'correct scope - conflicting local names'() {
-    this.render({
+    this.render.template({
       layout: stripTight`
         {{#with @a as |item|}}{{@a}}: {{item}},
           {{#with @b as |item|}} {{@b}}: {{item}},
@@ -21,9 +21,9 @@ export class ScopeSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'correct scope - conflicting block param and attr names'() {
-    this.render({
+    this.render.template({
       layout:
         'Outer: {{@conflict}} {{#with @item as |conflict|}}Inner: {{@conflict}} Block: {{conflict}}{{/with}}',
       args: { item: '"from block"', conflict: '"from attr"' },
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/shadowing.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/shadowing.ts
index ba15fc771a..402ca3ecfc 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/shadowing.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/shadowing.ts
@@ -1,12 +1,12 @@
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render } from '../test-decorator';
 
-export class ShadowingSuite extends RenderTest {
+export class ShadowingSuite extends RenderTestContext {
   static suiteName = 'Shadowing';
 
-  @test({ kind: 'glimmer' })
+  @render('glimmer')
   'normal outer attributes are reflected'() {
-    this.render({
+    this.render.template({
       layout: 'In layout - someProp: {{@someProp}}',
       args: { someProp: '"something here"' },
     });
@@ -15,9 +15,9 @@ export class ShadowingSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({ kind: 'glimmer' })
+  @render('glimmer')
   'shadowing - normal outer attributes clobber inner attributes'() {
-    this.render({
+    this.render.template({
       layout: 'Hello!',
       layoutAttributes: { 'data-name': '"Godfrey"', 'data-foo': '"foo"' },
       attributes: { 'data-name': '"Godfrey"', 'data-foo': '"bar"' },
@@ -28,9 +28,9 @@ export class ShadowingSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({ kind: 'glimmer' })
+  @render('glimmer')
   'outer attributes with concat are reflected'() {
-    this.render(
+    this.render.template(
       {
         layout: 'In layout - someProp: {{@someProp}}',
         args: { someProp: 'this.someProp' },
@@ -54,11 +54,11 @@ export class ShadowingSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test({ kind: 'glimmer' })
+  @render('glimmer')
   'outer attributes with concat clobber inner attributes'() {
-    this.render(
+    this.render.template(
       {
-        layoutAttributes: { 'data-name': 'Godfrey', 'data-foo': 'foo' },
+        layoutAttributes: { 'data-name': '"Godfrey"', 'data-foo': '"foo"' },
         layout: 'Hello!',
         attributes: { 'data-name': '"{{this.name}}"', 'data-foo': '"{{this.foo}}-bar"' },
       },
@@ -81,11 +81,11 @@ export class ShadowingSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test({ kind: 'glimmer' })
+  @render('glimmer')
   'outer attributes clobber inner attributes with concat'() {
-    this.render(
+    this.render.template(
       {
-        layoutAttributes: { 'data-name': '{{@name}}', 'data-foo': '"{{@foo}}-bar"' },
+        layoutAttributes: { 'data-name': '@name', 'data-foo': '"{{@foo}}-bar"' },
         layout: 'Hello!',
         args: { name: 'this.name', foo: 'this.foo' },
         attributes: { 'data-name': '"Godhuda"', 'data-foo': '"foo-bar"' },
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/ssr.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/ssr.ts
index 5912f77607..c1b9f3176a 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/ssr.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/ssr.ts
@@ -1,74 +1,74 @@
-import { AbstractNodeTest } from '../modes/node/env';
-import { test } from '../test-decorator';
+import { NodeRenderTest } from '../modes/node/env';
+import { render } from '../test-decorator';
 
-export class ServerSideSuite extends AbstractNodeTest {
+export class ServerSideSuite extends NodeRenderTest {
   static suiteName = 'Server Side Rendering';
 
-  @test
+  @render
   'HTML text content'() {
-    this.render('content');
+    this.render.template('content');
     this.assertHTML('content');
   }
 
-  @test
+  @render
   'HTML tags'() {
-    this.render('<h1>hello!</h1><div>content</div>');
+    this.render.template('<h1>hello!</h1><div>content</div>');
     this.assertHTML('<h1>hello!</h1><div>content</div>');
   }
 
-  @test
+  @render
   'HTML tags re-rendered'() {
-    this.render('<h1>hello!</h1><div>content</div>');
+    this.render.template('<h1>hello!</h1><div>content</div>');
     this.assertHTML('<h1>hello!</h1><div>content</div>');
     this.rerender();
     this.assertHTML('<h1>hello!</h1><div>content</div>');
   }
 
-  @test
+  @render
   'HTML attributes'() {
-    this.render("<div id='bar' class='foo'>content</div>");
+    this.render.template("<div id='bar' class='foo'>content</div>");
     this.assertHTML('<div id="bar" class="foo">content</div>');
   }
 
-  @test
+  @render
   'HTML tag with empty attribute'() {
-    this.render("<div class=''>content</div>");
+    this.render.template("<div class=''>content</div>");
     this.assertHTML('<div class>content</div>');
   }
 
-  @test
+  @render
   "HTML boolean attribute 'disabled'"() {
-    this.render('<input disabled>');
+    this.render.template('<input disabled>');
     this.assertHTML('<input disabled>');
   }
 
-  @test
+  @render
   'Quoted attribute expression is removed when null'() {
-    this.render('<input disabled="{{this.isDisabled}}">', { isDisabled: null });
+    this.render.template('<input disabled="{{this.isDisabled}}">', { isDisabled: null });
     this.assertHTML('<input>');
   }
 
-  @test
+  @render
   'Unquoted attribute expression with null value is not coerced'() {
-    this.render('<input disabled={{this.isDisabled}}>', { isDisabled: null });
+    this.render.template('<input disabled={{this.isDisabled}}>', { isDisabled: null });
     this.assertHTML('<input>');
   }
 
-  @test
+  @render
   'Attribute expression can be followed by another attribute'() {
-    this.render('<div foo="{{this.funstuff}}" name="Alice"></div>', { funstuff: 'oh my' });
+    this.render.template('<div foo="{{this.funstuff}}" name="Alice"></div>', { funstuff: 'oh my' });
     this.assertHTML('<div foo="oh my" name="Alice"></div>');
   }
 
-  @test
+  @render
   'HTML tag with data- attribute'() {
-    this.render("<div data-some-data='foo'>content</div>");
+    this.render.template("<div data-some-data='foo'>content</div>");
     this.assertHTML('<div data-some-data="foo">content</div>');
   }
 
-  @test
+  @render
   'The compiler can handle nesting'() {
-    this.render(
+    this.render.template(
       '<div class="foo"><p><span id="bar" data-foo="bar">hi!</span></p></div>&nbsp;More content'
     );
 
@@ -78,102 +78,103 @@ export class ServerSideSuite extends AbstractNodeTest {
     );
   }
 
-  @test
+  @render
   'The compiler can handle comments'() {
-    this.render('<div><!-- Just passing through --></div>');
+    this.render.template('<div><!-- Just passing through --></div>');
     this.assertHTML('<div><!-- Just passing through --></div>');
   }
 
-  @test
+  @render
   'The compiler can handle HTML comments with mustaches in them'() {
-    this.render('<div><!-- {{foo}} --></div>', { foo: 'bar' });
+    this.render.template('<div><!-- {{foo}} --></div>', { foo: 'bar' });
     this.assertHTML('<div><!-- {{foo}} --></div>');
   }
 
-  @test
+  @render
   'The compiler can handle HTML comments with complex mustaches in them'() {
-    this.render('<div><!-- {{foo bar baz}} --></div>', { foo: 'bar' });
+    this.render.template('<div><!-- {{foo bar baz}} --></div>', { foo: 'bar' });
     this.assertHTML('<div><!-- {{foo bar baz}} --></div>');
   }
 
-  @test
+  @render
   'The compiler can handle HTML comments with multi-line mustaches in them'() {
-    this.render('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>', { foo: 'bar' });
+    this.render.template('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>', { foo: 'bar' });
 
     this.assertHTML('<div><!-- {{#each foo as |bar|}}\n{{bar}}\n\n{{/each}} --></div>');
   }
 
-  @test
+  @render
   'The compiler can handle comments with no parent element'() {
-    this.render('<!-- {{foo}} -->', { foo: 'bar' });
+    this.render.template('<!-- {{foo}} -->', { foo: 'bar' });
     this.assertHTML('<!-- {{foo}} -->');
   }
 
-  @test
+  @render
   'The compiler can handle simple handlebars'() {
-    this.render('<div>{{this.title}}</div>', { title: 'hello' });
+    this.render.template('<div>{{this.title}}</div>', { title: 'hello' });
     this.assertHTML('<div>hello</div>');
   }
 
-  @test
+  @render
   'The compiler can handle escaping HTML'() {
-    this.render('<div>{{this.title}}</div>', { title: '<strong>hello</strong>' });
+    this.render.template('<div>{{this.title}}</div>', { title: '<strong>hello</strong>' });
     this.assertHTML('<div>&lt;strong&gt;hello&lt;/strong&gt;</div>');
   }
 
-  @test
+  @render
   'The compiler can handle unescaped HTML'() {
-    this.render('<div>{{{this.title}}}</div>', { title: '<strong>hello</strong>' });
+    this.render.template('<div>{{{this.title}}}</div>', { title: '<strong>hello</strong>' });
     this.assertHTML('<div><strong>hello</strong></div>');
   }
 
-  @test
+  @render
   'Unescaped helpers render correctly'() {
-    this.registerHelper('testing-unescaped', (params) => params[0]);
-    this.render('{{{testing-unescaped "<span>hi</span>"}}}');
+    this.register.helper('testing-unescaped', (params) => params[0] );
+    this.render.template('{{{testing-unescaped "<span>hi</span>"}}}');
     this.assertHTML('<span>hi</span>');
   }
 
-  @test
+  @render
   'Null literals do not have representation in DOM'() {
-    this.render('{{null}}');
+    this.render.template('{{null}}');
     this.assertHTML('');
   }
 
-  @test
+  @render
   'Attributes can be populated with helpers that generate a string'() {
-    this.registerHelper('testing', (params) => {
-      return params[0];
-    });
+    this.register.helper('testing', (params) => {
+        return params[0];
+      },
+    );
 
-    this.render('<a href="{{testing this.url}}">linky</a>', { url: 'linky.html' });
+    this.render.template('<a href="{{testing this.url}}">linky</a>', { url: 'linky.html' });
     this.assertHTML('<a href="linky.html">linky</a>');
   }
 
-  @test
+  @render
   'Elements inside a yielded block'() {
-    this.render('{{#if true}}<div id="test">123</div>{{/if}}');
+    this.render.template('{{#if true}}<div id="test">123</div>{{/if}}');
     this.assertHTML('<div id="test">123</div>');
   }
 
-  @test
+  @render
   'A simple block helper can return text'() {
-    this.render('{{#if true}}test{{else}}not shown{{/if}}');
+    this.render.template('{{#if true}}test{{else}}not shown{{/if}}');
     this.assertHTML('test');
   }
 
-  @test
+  @render
   'SVG: basic element'() {
     let template = `
       <svg xmlns="http://www.w3.org/2000/svg">
         <rect x="10" y="10" height="100" width="100" style="stroke:#ff0000; fill: #0000ff"></rect>
       </svg>
     `;
-    this.render(template);
+    this.render.template(template);
     this.assertHTML(template);
   }
 
-  @test
+  @render
   'SVG: element with xlink:href'() {
     let template = `
       <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
@@ -183,35 +184,35 @@ export class ServerSideSuite extends AbstractNodeTest {
         </a>
       </svg>
     `;
-    this.render(template);
+    this.render.template(template);
 
     this.assertHTML(template);
   }
 }
 
-export class ServerSideComponentSuite extends AbstractNodeTest {
+export class ServerSideComponentSuite extends NodeRenderTest {
   static suiteName = 'Server Side Components';
 
-  @test
+  @render
   'can render components'() {
-    this.render({
+    this.render.template({
       layout: '<h1>Hello World!</h1>',
     });
     this.assertComponent('<h1>Hello World!</h1>');
   }
 
-  @test
+  @render
   'can render components with yield'() {
-    this.render({
+    this.render.template({
       layout: '<h1>Hello {{yield}}!</h1>',
       template: 'World',
     });
     this.assertComponent('<h1>Hello World!</h1>');
   }
 
-  @test
+  @render
   'can render components with args'() {
-    this.render(
+    this.render.template(
       {
         layout: '<h1>Hello {{@place}}!</h1>',
         template: 'World',
@@ -222,9 +223,9 @@ export class ServerSideComponentSuite extends AbstractNodeTest {
     this.assertComponent('<h1>Hello World!</h1>');
   }
 
-  @test
+  @render
   'can render components with block params'() {
-    this.render(
+    this.render.template(
       {
         layout: '<h1>Hello {{yield @place}}!</h1>',
         template: '{{place}}',
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/with-dynamic-vars.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/with-dynamic-vars.ts
index 7608fcddf8..f7c2eab62a 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/with-dynamic-vars.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/with-dynamic-vars.ts
@@ -1,11 +1,11 @@
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render } from '../test-decorator';
 
-export class WithDynamicVarsSuite extends RenderTest {
+export class WithDynamicVarsSuite extends RenderTestContext {
   static suiteName = '-with-dynamic-vars and -get-dynamic-var';
-  @test
+  @render
   'Can get and set dynamic variable'() {
-    this.render(
+    this.render.template(
       {
         layout: '{{#-with-dynamic-vars myKeyword=@value}}{{yield}}{{/-with-dynamic-vars}}',
         template: '{{-get-dynamic-var "myKeyword"}}',
@@ -26,9 +26,9 @@ export class WithDynamicVarsSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'Can get and set dynamic variable with bound names'() {
-    this.render(
+    this.render.template(
       {
         layout:
           '{{#-with-dynamic-vars myKeyword=@value1 secondKeyword=@value2}}{{yield}}{{/-with-dynamic-vars}}',
@@ -54,9 +54,9 @@ export class WithDynamicVarsSuite extends RenderTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'Can shadow existing dynamic variable'() {
-    this.render(
+    this.render.template(
       {
         layout:
           '{{#-with-dynamic-vars myKeyword=@outer}}<div>{{-get-dynamic-var "myKeyword"}}</div>{{#-with-dynamic-vars myKeyword=@inner}}{{yield}}{{/-with-dynamic-vars}}<div>{{-get-dynamic-var "myKeyword"}}</div>{{/-with-dynamic-vars}}',
diff --git a/packages/@glimmer-workspace/integration-tests/lib/suites/yield.ts b/packages/@glimmer-workspace/integration-tests/lib/suites/yield.ts
index 3f6f99ebeb..ebbf008aa6 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/suites/yield.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/suites/yield.ts
@@ -1,12 +1,11 @@
-import { RenderTest } from '../render-test';
-import { test } from '../test-decorator';
+import { RenderTestContext } from '../render-test';
+import { render, suite } from '../test-decorator';
 
-export class YieldSuite extends RenderTest {
-  static suiteName = 'yield';
-
-  @test
+@suite('yield')
+export class YieldSuite extends RenderTestContext {
+  @render
   yield() {
-    this.render(
+    this.render.template(
       {
         layout:
           '{{#if @predicate}}Yes:{{yield @someValue}}{{else}}No:{{yield to="inverse"}}{{/if}}',
@@ -22,11 +21,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    skip: 'glimmer',
-  })
+  @render
   'yield to "inverse"'() {
-    this.render(
+    this.render.template(
       {
         layout:
           '{{#if @predicate}}Yes:{{yield @someValue}}{{else}}No:{{yield to="inverse"}}{{/if}}',
@@ -42,11 +39,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    skip: 'glimmer',
-  })
+  @render
   'yield to "else"'() {
-    this.render(
+    this.render.template(
       {
         layout: '{{#if @predicate}}Yes:{{yield @someValue}}{{else}}No:{{yield to="else"}}{{/if}}',
         args: { predicate: 'this.activated', someValue: '42' },
@@ -61,9 +56,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding to an non-existent block'() {
-    this.render({
+    this.render.template({
       layout: 'Before-{{yield}}-After',
     });
 
@@ -71,9 +66,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding a string and rendering its length'() {
-    this.render({
+    this.render.template({
       layout: `{{yield "foo"}}-{{yield ""}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.length}}',
@@ -83,12 +78,10 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test({
-    skip: 'glimmer',
-  })
+  @render
   'use a non-existent block param'() {
-    this.render({
-      layout: '{{yield this.someValue}}',
+    this.render.template({
+      layout: '{{yield @someValue}}',
       args: { someValue: '42' },
       blockParams: ['val1', 'val2'],
       template: '{{val1}} - {{val2}}',
@@ -98,9 +91,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'block without properties'() {
-    this.render({
+    this.render.template({
       layout: 'In layout -- {{yield}}',
       template: 'In template',
     });
@@ -109,9 +102,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding true'() {
-    this.render({
+    this.render.template({
       layout: `{{yield true}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -121,9 +114,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding false'() {
-    this.render({
+    this.render.template({
       layout: `{{yield false}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -133,9 +126,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding null'() {
-    this.render({
+    this.render.template({
       layout: `{{yield null}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -145,9 +138,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding undefined'() {
-    this.render({
+    this.render.template({
       layout: `{{yield undefined}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -157,9 +150,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding integers'() {
-    this.render({
+    this.render.template({
       layout: `{{yield 123}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -169,9 +162,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding floats'() {
-    this.render({
+    this.render.template({
       layout: `{{yield 123.45}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -181,9 +174,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yielding strings'() {
-    this.render({
+    this.render.template({
       layout: `{{yield "hello"}}`,
       blockParams: ['yielded'],
       template: '{{yielded}}-{{yielded.foo.bar}}',
@@ -193,9 +186,9 @@ export class YieldSuite extends RenderTest {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'yield inside a conditional on the component'() {
-    this.render(
+    this.render.template(
       {
         layout: 'In layout -- {{#if @predicate}}{{yield}}{{/if}}',
         template: 'In template',
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-decorator.ts b/packages/@glimmer-workspace/integration-tests/lib/test-decorator.ts
index a610fa243b..6e012674d4 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/test-decorator.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-decorator.ts
@@ -1,35 +1,170 @@
-import { keys } from '@glimmer/util';
+import { LOCAL_LOGGER } from '@glimmer/util';
 
-export type DeclaredComponentKind = 'glimmer' | 'curly' | 'dynamic' | 'templateOnly';
+import type { IRenderTest } from './render-test';
+import type { DeclaredComponentType, EveryComponentType } from './test-helpers/constants';
+import type { RenderTestConstructor, RenderTestState } from './test-helpers/module';
+
+import { isTest, TEST_META } from './test-helpers/test';
+
+type ComponentTestOptions =
+  | Partial<Pick<ComponentTestMeta, 'skip' | 'kind' | 'invokeAs'>>
+  | ComponentTestMeta['kind'];
+
+type NormalizedComponentTestOptions = Pick<ComponentTestMeta, 'skip' | 'kind' | 'invokeAs'>;
 
 export interface ComponentTestMeta {
-  kind?: DeclaredComponentKind;
-  skip?: boolean | DeclaredComponentKind;
+  type: 'component';
+  kind: EveryComponentType | undefined;
+  // Normally, any invoking code is built using the same style as the target template. But sometimes
+  // you need to invoke a component with a different style for full coverage (in particular, you
+  // need a Glimmer invoker to pass attributes, but curly components can accept attributes).
+  invokeAs: DeclaredComponentType | undefined;
+  skip: boolean | DeclaredComponentType | undefined;
 }
 
-export function test(meta: ComponentTestMeta): MethodDecorator;
-export function test<T>(
-  _target: Object | ComponentTestMeta,
-  _name?: string,
-  descriptor?: TypedPropertyDescriptor<T>
-): TypedPropertyDescriptor<T> | void;
-export function test(...args: any[]) {
+export interface ComponentTestFunction {
+  (this: IRenderTest, assert: RenderTestState): void | Promise<void>;
+
+  readonly [TEST_META]: ComponentTestMeta;
+}
+
+export function isComponentTest(value: unknown): value is ComponentTestFunction {
+  return isTest(value) && value[TEST_META].type === 'component';
+}
+
+export function getComponentTestMeta(value: ComponentTestFunction) {
+  return value[TEST_META];
+}
+
+export function render(
+  kind: DeclaredComponentType,
+  options: Omit<ComponentTestOptions, 'type' | 'kind'>
+): MethodDecorator;
+export function render(meta: Omit<ComponentTestOptions, 'type'>): MethodDecorator;
+export function render(
+  target: object,
+  name: string,
+  descriptor: TypedPropertyDescriptor<() => void | Promise<void>>
+): void;
+export function render<C extends Assert>(
+  target: object,
+  name: string,
+  descriptor: TypedPropertyDescriptor<(context: C) => void | Promise<void>>
+): void;
+export function render(
+  ...args:
+    | [meta: Omit<ComponentTestOptions, 'type'>]
+    | [kind: DeclaredComponentType, options: Omit<ComponentTestOptions, 'type' | 'kind'>]
+    | [target: object, name: string, descriptor: PropertyDescriptor]
+): MethodDecorator | PropertyDescriptor {
   if (args.length === 1) {
-    let meta: ComponentTestMeta = args[0];
-    return (_target: Object, _name: string, descriptor: PropertyDescriptor) => {
-      let testFunction = descriptor.value;
-      keys(meta).forEach((key) => (testFunction[key] = meta[key]));
-      setTestingDescriptor(descriptor);
-    };
-  }
+    const [options] = args;
+    return (<T>(
+      _target: object,
+      _name: string | symbol,
+      descriptor: TypedPropertyDescriptor<T>
+    ) => {
+      setTestingDescriptor(descriptor, normalizeOptions(options));
+      return descriptor;
+    }) satisfies MethodDecorator;
+  } else if (args.length === 2) {
+    const [kind, options] = args;
+    return (<T>(
+      _target: object,
+      _name: string | symbol,
+      descriptor: TypedPropertyDescriptor<T>
+    ) => {
+      setTestingDescriptor(descriptor, normalizeOptions({ kind, ...options }));
+      return descriptor;
+    }) satisfies MethodDecorator;
+  } else {
+    let [, , descriptor] = args;
 
-  let descriptor = args[2];
-  setTestingDescriptor(descriptor);
-  return descriptor;
+    setTestingDescriptor(descriptor);
+    return descriptor;
+  }
 }
 
-function setTestingDescriptor(descriptor: PropertyDescriptor): void {
+function setTestingDescriptor(
+  descriptor: PropertyDescriptor,
+  meta: NormalizedComponentTestOptions = normalizeOptions(undefined)
+): void {
   let testFunction = descriptor.value;
   descriptor.enumerable = true;
-  testFunction['isTest'] = true;
+  setComponentTest(testFunction, meta);
+}
+
+export function setComponentTest(
+  testFunction: Partial<ComponentTestFunction>,
+  meta: NormalizedComponentTestOptions
+) {
+  Object.defineProperty(testFunction, TEST_META, {
+    configurable: true,
+    value: {
+      type: 'component',
+      ...meta,
+    } satisfies ComponentTestMeta,
+  });
+}
+
+function normalizeOptions(
+  options: ComponentTestOptions | undefined
+): NormalizedComponentTestOptions {
+  if (typeof options === 'string') {
+    return { kind: options, invokeAs: options === 'all' ? undefined : options, skip: false };
+  } else {
+    return {
+      kind: options?.kind,
+      invokeAs: options?.invokeAs,
+      skip: false,
+    };
+  }
+}
+
+const RENDER_SUITE_META = Symbol('SUITE_META');
+
+export interface RenderSuiteMeta {
+  readonly description: string;
+  readonly kind?: ComponentTestMeta['kind'] | undefined;
+}
+
+export interface RenderSuite {
+  [RENDER_SUITE_META]: RenderSuiteMeta;
+}
+
+export function isSuite(value: object): value is RenderSuite {
+  return RENDER_SUITE_META in value;
+}
+
+export function getSuiteMetadata(suite: RenderSuite): RenderSuiteMeta {
+  return suite[RENDER_SUITE_META];
+}
+
+export function suite(
+  description: string,
+  options?: Partial<RenderSuiteMeta> | EveryComponentType
+): <Class extends RenderTestConstructor<any, any>>(Class: Class) => Class {
+  return (Class) => {
+    Object.defineProperty(Class, RENDER_SUITE_META, {
+      configurable: true,
+      value: {
+        description,
+        kind: typeof options === 'string' ? options : options?.kind,
+      } satisfies RenderSuiteMeta,
+    });
+
+    if ('suiteName' in Class) {
+      LOCAL_LOGGER.warn(
+        `Don't use 'static suiteName =' and @suite together. Please remove the static property and migrate to @suite.`,
+        { Class }
+      );
+    }
+
+    Object.defineProperty(Class, 'suiteName', {
+      configurable: true,
+      value: description,
+    });
+
+    return Class;
+  };
 }
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/constants.ts b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/constants.ts
new file mode 100644
index 0000000000..533633ce7a
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/constants.ts
@@ -0,0 +1,21 @@
+import type { ComponentKind } from '../components';
+
+export const KIND_FOR = {
+  glimmer: 'Glimmer',
+  curly: 'Curly',
+  dynamic: 'Dynamic',
+  templateOnly: 'TemplateOnly',
+} as const;
+
+export type KindFor<K extends DeclaredComponentType> = (typeof KIND_FOR)[K];
+export type DeclaredComponentType = 'glimmer' | 'curly' | 'dynamic' | 'templateOnly';
+export type EveryComponentType = DeclaredComponentType | 'all';
+
+export const TYPE_FOR = {
+  Glimmer: 'glimmer',
+  Curly: 'curly',
+  Dynamic: 'dynamic',
+  TemplateOnly: 'templateOnly',
+} as const;
+
+export type TypeFor<K extends ComponentKind> = (typeof TYPE_FOR)[K];
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/define.ts b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/define.ts
index 2a004ebe51..0db43e0127 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/define.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/define.ts
@@ -1,4 +1,3 @@
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
   Arguments,
   HelperCapabilities,
@@ -6,6 +5,7 @@ import type {
   ModifierManager,
   Owner,
 } from '@glimmer/interfaces';
+import { registerDestructor } from '@glimmer/destroyable';
 import {
   helperCapabilities,
   modifierCapabilities,
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/error.ts b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/error.ts
new file mode 100644
index 0000000000..2f249521ae
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/error.ts
@@ -0,0 +1,51 @@
+import type { UserException } from '@glimmer/interfaces';
+
+import { tracked } from './tracked';
+
+type Handler = (error: UserException, retry: () => void) => void;
+
+export class Woops {
+  static noop(value = `no woops`): Woops {
+    return new Woops(false, value);
+  }
+
+  static error(value = `no woops`): Woops {
+    return new Woops(true, value);
+  }
+
+  @tracked _value: string;
+  @tracked isError = false;
+  readonly handleError: Handler;
+  #retry: undefined | (() => void);
+
+  private constructor(isError = false, value: string) {
+    this.isError = isError;
+    this.handleError = (error, retry) => {
+      this.#retry = retry;
+    };
+    this._value = value;
+  }
+
+  get value() {
+    if (this.isError) {
+      throw Error(`woops`);
+    } else {
+      return this._value;
+    }
+  }
+
+  set value(value: string) {
+    if (this.isError) {
+      throw Error(`woops`);
+    } else {
+      this._value = value;
+    }
+  }
+
+  recover() {
+    this.isError = false;
+    if (this.#retry) {
+      this.#retry();
+    }
+  }
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/module.ts b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/module.ts
index 8fb0b8241c..f464c513f1 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/module.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/module.ts
@@ -1,55 +1,65 @@
 import type { EnvironmentDelegate } from '@glimmer/runtime';
-import { keys } from '@glimmer/util';
 
-import type { ComponentKind } from '../components';
-import { JitRenderDelegate } from '../modes/jit/delegate';
+import type { RenderDelegate, RenderDelegateOptions } from '../render-delegate';
+import type { IRenderTest, RenderTestContext } from '../render-test';
+import type {ComponentTestFunction, ComponentTestMeta, RenderSuiteMeta} from '../test-decorator';
+import type { DeclaredComponentType } from './constants';
+
+import { ClientSideRenderDelegate,ErrorRecoveryRenderDelegate } from '../modes/jit/delegate';
 import { NodeJitRenderDelegate } from '../modes/node/env';
-import type RenderDelegate from '../render-delegate';
-import type { RenderDelegateOptions } from '../render-delegate';
-import type { Count, IRenderTest, RenderTest } from '../render-test';
+import { Count } from '../render-test';
 import { JitSerializationDelegate } from '../suites/custom-dom-helper';
-import type { DeclaredComponentKind } from '../test-decorator';
+import {
+  getComponentTestMeta,
+  getSuiteMetadata,
+  isComponentTest,
+  isSuite
+} from '../test-decorator';
+import { RecordedEvents } from './recorded';
 
 export interface RenderTestConstructor<D extends RenderDelegate, T extends IRenderTest> {
-  suiteName: string;
-  new (delegate: D): T;
+  suiteName?: string;
+  new (delegate: D, context: RenderTestState): T;
 }
 
 export function jitSuite<T extends IRenderTest>(
   klass: RenderTestConstructor<RenderDelegate, T>,
-  options?: { componentModule?: boolean; env?: EnvironmentDelegate }
+  options?: { componentModule?: boolean; test?: ['error-recovery']; env?: EnvironmentDelegate }
 ): void {
-  return suite(klass, JitRenderDelegate, options);
+  testSuite(klass, ClientSideRenderDelegate, options);
+
+  if (options?.test?.includes('error-recovery')) {
+    testSuite(klass, ErrorRecoveryRenderDelegate);
+  }
 }
 
 export function nodeSuite<T extends IRenderTest>(
   klass: RenderTestConstructor<RenderDelegate, T>,
   options = { componentModule: false }
 ): void {
-  return suite(klass, NodeJitRenderDelegate, options);
+  return testSuite(klass, NodeJitRenderDelegate, options);
 }
 
 export function nodeComponentSuite<T extends IRenderTest>(
   klass: RenderTestConstructor<RenderDelegate, T>
 ): void {
-  return suite(klass, NodeJitRenderDelegate, { componentModule: true });
+  return testSuite(klass, NodeJitRenderDelegate, { componentModule: true });
 }
 
 export function jitComponentSuite<T extends IRenderTest>(
   klass: RenderTestConstructor<RenderDelegate, T>
 ): void {
-  return suite(klass, JitRenderDelegate, { componentModule: true });
+  return testSuite(klass, ClientSideRenderDelegate, { componentModule: true });
 }
 
 export function jitSerializeSuite<T extends IRenderTest>(
   klass: RenderTestConstructor<RenderDelegate, T>,
   options = { componentModule: false }
 ): void {
-  return suite(klass, JitSerializationDelegate, options);
+  return testSuite(klass, JitSerializationDelegate, options);
 }
 
 export interface RenderDelegateConstructor<Delegate extends RenderDelegate> {
-  readonly isEager: boolean;
   readonly style: string;
   new (options?: RenderDelegateOptions): Delegate;
 }
@@ -58,215 +68,269 @@ export function componentSuite<D extends RenderDelegate>(
   klass: RenderTestConstructor<D, IRenderTest>,
   Delegate: RenderDelegateConstructor<D>
 ): void {
-  return suite(klass, Delegate, { componentModule: true });
+  return testSuite(klass, Delegate, { componentModule: true });
 }
 
-export function suite<D extends RenderDelegate>(
-  klass: RenderTestConstructor<D, IRenderTest>,
+export function testSuite<D extends RenderDelegate>(
+  Class: RenderTestConstructor<D, IRenderTest>,
   Delegate: RenderDelegateConstructor<D>,
   options: { componentModule?: boolean; env?: EnvironmentDelegate } = {}
 ): void {
-  let suiteName = klass.suiteName;
-
   if (options.componentModule) {
-    if (shouldRunTest<D>(Delegate)) {
-      componentModule(
-        `${Delegate.style} :: Components :: ${suiteName}`,
-        klass as any as RenderTestConstructor<D, RenderTest>,
-        Delegate
-      );
-    }
+    componentModule(
+      `${Delegate.style} :: Components :: ${TestBlueprint.suiteName(Class)}`,
+      Class as any as RenderTestConstructor<D, RenderTestContext>,
+      Delegate
+    );
   } else {
-    let instance: IRenderTest | null = null;
-    QUnit.module(`[integration] ${Delegate.style} :: ${suiteName}`, {
-      beforeEach() {
-        instance = new klass(new Delegate({ env: options.env }));
-        if (instance.beforeEach) instance.beforeEach();
-      },
+    QUnit.module(`[integration] ${Delegate.style} :: ${TestBlueprint.suiteName(Class)}`);
 
-      afterEach() {
-        if (instance!.afterEach) instance!.afterEach();
-        instance = null;
-      },
-    });
+    for (let prop in Class.prototype) {
+      const test = Class.prototype[prop];
+      const blueprint = TestBlueprint.for(Class, Delegate);
 
-    for (let prop in klass.prototype) {
-      const test = klass.prototype[prop];
+      if (isComponentTest(test)) {
+        const meta = getComponentTestMeta(test);
 
-      if (isTestFunction(test) && shouldRunTest<D>(Delegate)) {
-        if (isSkippedTest(test)) {
-          // eslint-disable-next-line no-loop-func
-          QUnit.skip(prop, (assert) => {
-            test.call(instance!, assert, instance!.count);
-            instance!.count.assert();
-          });
-        } else {
-          // eslint-disable-next-line no-loop-func
-          QUnit.test(prop, (assert) => {
-            let result = test.call(instance!, assert, instance!.count);
-            instance!.count.assert();
-            return result;
-          });
+        const CASES = blueprint.filtered(meta).map((types) => {
+          return {
+            types,
+            test: blueprint.createTestFn(test, types),
+          };
+        });
+
+        for (const { types, test: testCase } of CASES) {
+          if (meta.skip) {
+            QUnit.skip(`${formatTypes(types)}: ${prop}`, testCase);
+          } else {
+            QUnit.test(`${formatTypes(types)}: ${prop}`, testCase);
+          }
         }
       }
     }
   }
 }
 
-function componentModule<D extends RenderDelegate, T extends IRenderTest>(
-  name: string,
-  klass: RenderTestConstructor<D, T>,
-  Delegate: RenderDelegateConstructor<D>
-) {
-  let tests: ComponentTests = {
-    glimmer: [],
-    curly: [],
-    dynamic: [],
-    templateOnly: [],
-  };
+function formatTypes(types: RenderTestTypes): string {
+  if (types.invoker === types.template) {
+    return types.invoker;
+  } else {
+    return `${types.template} (invoked by ${types.invoker})`;
+  }
+}
 
-  function createTest(prop: string, test: any, skip?: boolean) {
-    let shouldSkip: boolean;
-    if (skip === true || test.skip === true) {
-      shouldSkip = true;
-    }
+export interface RenderTestState<
+  Template extends DeclaredComponentType = DeclaredComponentType,
+  Invoker extends DeclaredComponentType = Template,
+> extends Assert {
+  readonly count: Count;
+  readonly events: RecordedEvents;
+  readonly types: {
+    readonly template: Template;
+    readonly invoker: Invoker;
+  };
+}
 
-    return (type: ComponentKind, klass: RenderTestConstructor<D, T>) => {
-      if (!shouldSkip) {
-         
-        QUnit.test(prop, (assert) => {
-          let instance = new klass(new Delegate());
-          instance.testType = type;
-          return test.call(instance, assert, instance.count);
-        });
-      }
-    };
-  }
+export interface RenderTestTypes {
+  readonly template: DeclaredComponentType;
+  readonly invoker: DeclaredComponentType;
+}
 
-  for (let prop in klass.prototype) {
-    const test = klass.prototype[prop];
-    if (isTestFunction(test)) {
-      if (test['kind'] === undefined) {
-        let skip = test['skip'];
-        switch (skip) {
-          case 'glimmer':
-            tests.curly.push(createTest(prop, test));
-            tests.dynamic.push(createTest(prop, test));
-            tests.glimmer.push(createTest(prop, test, true));
-            break;
-          case 'curly':
-            tests.glimmer.push(createTest(prop, test));
-            tests.dynamic.push(createTest(prop, test));
-            tests.curly.push(createTest(prop, test, true));
-            break;
-          case 'dynamic':
-            tests.glimmer.push(createTest(prop, test));
-            tests.curly.push(createTest(prop, test));
-            tests.dynamic.push(createTest(prop, test, true));
-            break;
-          case true:
-            if (test['kind'] === 'templateOnly') {
-              tests.templateOnly.push(createTest(prop, test, true));
-            } else {
-              ['glimmer', 'curly', 'dynamic'].forEach((kind) => {
-                tests[kind as DeclaredComponentKind].push(createTest(prop, test, true));
-              });
-            }
+export function RenderTestState(
+  assert: Assert,
+  specifiedTypes: RenderTestTypes | DeclaredComponentType
+): RenderTestState {
+  const events = new RecordedEvents();
+
+  const types =
+    typeof specifiedTypes === 'string'
+      ? { template: specifiedTypes, invoker: specifiedTypes }
+      : specifiedTypes;
+
+  return new Proxy(
+    { assert, count: new Count(events), events, types },
+    {
+      get({ assert, count, types }, prop, receiver) {
+        switch (prop) {
+          case 'count':
+            return count;
+          case 'events':
+            return events;
+          case 'types':
+            return types;
           default:
-            tests.glimmer.push(createTest(prop, test));
-            tests.curly.push(createTest(prop, test));
-            tests.dynamic.push(createTest(prop, test));
+            return Reflect.get(assert, prop, receiver);
         }
-        continue;
-      }
+      },
+    }
+  ) as unknown as RenderTestState;
+}
 
-      let kind = test['kind'];
+type TestFn = () => void;
 
-      if (kind === 'curly') {
-        tests.curly.push(createTest(prop, test));
-        tests.dynamic.push(createTest(prop, test));
-      }
+export class TestBlueprint<D extends RenderDelegate, T extends IRenderTest> {
+  static for<D extends RenderDelegate, T extends IRenderTest>(
+    Class: RenderTestConstructor<D, T>,
+    Delegate: RenderDelegateConstructor<D>
+  ) {
+    return new TestBlueprint(Class, Delegate);
+  }
 
-      if (kind === 'glimmer') {
-        tests.glimmer.push(createTest(prop, test));
-      }
+  static suiteName<D extends RenderDelegate, T extends IRenderTest>(
+    Class: RenderTestConstructor<D, T>
+  ) {
+    if (isSuite(Class)) {
+      return getSuiteMetadata(Class).description;
+    } else if (Class.suiteName) {
+      return Class.suiteName;
+    } else {
+      throw Error(`Could not find suite name for ${Class.name}`);
+    }
+  }
 
-      if (kind === 'dynamic') {
-        tests.curly.push(createTest(prop, test));
-        tests.dynamic.push(createTest(prop, test));
-      }
+  #Class: RenderTestConstructor<D, T>;
+  #Delegate: RenderDelegateConstructor<D>;
+  #suite: RenderSuiteMeta;
 
-      if (kind === 'templateOnly') {
-        tests.templateOnly.push(createTest(prop, test));
-      }
+  private constructor(Class: RenderTestConstructor<D, T>, Delegate: RenderDelegateConstructor<D>) {
+    this.#Class = Class;
+    this.#Delegate = Delegate;
+
+    if (isSuite(Class)) {
+      this.#suite = getSuiteMetadata(Class);
+    } else {
+      this.#suite = { description: Class.suiteName ?? Class.name };
     }
   }
-  QUnit.module(`[integration] ${name}`, () => {
-    nestedComponentModules(klass, tests);
-  });
-}
 
-interface ComponentTests {
-  glimmer: Function[];
-  curly: Function[];
-  dynamic: Function[];
-  templateOnly: Function[];
-}
+  get suiteName() {
+    return this.#suite.description;
+  }
 
-function nestedComponentModules<D extends RenderDelegate, T extends IRenderTest>(
-  klass: RenderTestConstructor<D, T>,
-  tests: ComponentTests
-): void {
-  keys(tests).forEach((type) => {
-    let formattedType = upperFirst(type);
+  filtered(meta: ComponentTestMeta): readonly RenderTestTypes[] {
+    const included = EXPANSIONS[meta.kind ?? this.#suite.kind ?? 'all'];
+    const excluded = new Set(expandSkip(meta.skip));
 
-    QUnit.module(`[integration] ${formattedType}`, () => {
-      const allTests = [...tests[type]].reverse();
+    return included
+      .filter((kind) => !excluded.has(kind))
+      .map((kind) => ({ invoker: meta.invokeAs ?? kind, template: kind }));
+  }
 
-      for (const t of allTests) {
-        t(formattedType, klass);
-      }
+  createTestFn(
+    test: ComponentTestFunction,
+    types: RenderTestTypes
+  ): (assert: Assert) => void | Promise<void> {
+    return (assert) => {
+      const instance = new this.#Class(new this.#Delegate(), RenderTestState(assert, types));
+      instance.beforeEach?.();
 
-      tests[type] = [];
-    });
-  });
-}
+      try {
+        const result = test.call(instance, instance.context);
 
-function upperFirst<T extends string>(
-  str: T extends '' ? `upperFirst only takes (statically) non-empty strings` : T
-): string {
-  let first = str[0] as string;
-  let rest = str.slice(1);
+        if (result === undefined) {
+          instance.context.count.assert();
+        } else {
+          return result.then(() => {
+            instance.context.count.assert();
+          });
+        }
+      } finally {
+        instance.afterEach?.();
+      }
+    };
+  }
 
-  return `${first.toUpperCase()}${rest}`;
-}
+  createTest(types: RenderTestTypes, description: string, test: unknown): TestFn | undefined {
+    if (!isComponentTest(test)) return;
 
-const HAS_TYPED_ARRAYS = typeof Uint16Array !== 'undefined';
+    return () => {
+      QUnit.test(
+        `${types.invoker !== types.template ? formatTypes(types) : ''} ${description}`,
+        this.createTestFn(test, types)
+      );
+    };
+  }
+}
 
-function shouldRunTest<T extends RenderDelegate>(Delegate: RenderDelegateConstructor<T>) {
-  let isEagerDelegate = Delegate['isEager'];
+class ComponentTests<D extends RenderDelegate, T extends IRenderTest> {
+  readonly #blueprint: TestBlueprint<D, T>;
+  readonly #tests: { types: RenderTestTypes; test: TestFn }[] = [];
 
-  if (HAS_TYPED_ARRAYS) {
-    return true;
+  constructor(blueprint: TestBlueprint<D, T>) {
+    this.#blueprint = blueprint;
   }
 
-  if (!HAS_TYPED_ARRAYS && !isEagerDelegate) {
-    return true;
+  *[Symbol.iterator](): IterableIterator<readonly [DeclaredComponentType, TestFn[]]> {
+    for (const type of ['curly', 'glimmer', 'dynamic', 'templateOnly'] as const) {
+      yield [
+        type,
+        this.#tests.filter((t) => t.types.template === type).map((t) => t.test),
+      ] as const;
+    }
   }
 
-  return false;
+  add(kinds: readonly RenderTestTypes[], { prop, test }: { prop: string; test: unknown }) {
+    for (const types of kinds) {
+      const testFn = this.#blueprint.createTest(types, prop, test);
+      if (testFn) {
+        this.#tests.push({ types, test: testFn });
+      }
+    }
+  }
 }
 
-interface TestFunction {
-  (this: IRenderTest, assert: typeof QUnit.assert, count?: Count): void;
-  kind?: DeclaredComponentKind;
-  skip?: boolean | DeclaredComponentKind;
+export type ExpandType<K extends DeclaredComponentType | 'all'> = EXPANSIONS[K][number];
+
+const EXPANSIONS = {
+  curly: ['curly', 'dynamic'],
+  glimmer: ['glimmer', 'templateOnly'],
+  dynamic: ['dynamic'],
+  templateOnly: ['templateOnly'],
+  all: ['curly', 'glimmer', 'dynamic', 'templateOnly'],
+} as const;
+type EXPANSIONS = typeof EXPANSIONS;
+
+function expandSkip(
+  kind: DeclaredComponentType | boolean | undefined
+): readonly DeclaredComponentType[] {
+  if (kind === false || kind === undefined) {
+    return [];
+  } else if (kind === true) {
+    return ['glimmer', 'curly', 'dynamic'];
+  } else {
+    return EXPANSIONS[kind];
+  }
 }
 
-function isTestFunction(value: any): value is TestFunction {
-  return typeof value === 'function' && value.isTest;
+function componentModule<D extends RenderDelegate, T extends IRenderTest>(
+  name: string,
+  Class: RenderTestConstructor<D, T>,
+  Delegate: RenderDelegateConstructor<D>
+) {
+  const blueprint = TestBlueprint.for(Class, Delegate);
+  const tests = new ComponentTests(blueprint);
+
+  for (let prop in Class.prototype) {
+    const test = Class.prototype[prop];
+    if (isComponentTest(test)) {
+      const meta = getComponentTestMeta(test);
+      const filtered = blueprint.filtered(meta);
+      tests.add(filtered, { prop, test });
+    }
+  }
+  QUnit.module(`[integration] ${name}`, () => {
+    nestedComponentModules(tests);
+  });
 }
 
-function isSkippedTest(value: any): boolean {
-  return typeof value === 'function' && value.skip;
+function nestedComponentModules<D extends RenderDelegate, T extends IRenderTest>(
+  modules: ComponentTests<D, T>
+): void {
+  for (const [type, tests] of modules) {
+    QUnit.module(`[integration] ${type}`, () => {
+      for (const test of tests) {
+        test();
+      }
+    });
+  }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/recorded.ts b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/recorded.ts
new file mode 100644
index 0000000000..b7db759df0
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/recorded.ts
@@ -0,0 +1,79 @@
+export class RecordedEvents {
+  #events: string[] = [];
+
+  record(event: string) {
+    this.#events.push(event);
+  }
+
+  finalize() {
+    const filtered = this.#events.filter((e) => !e.includes(':'));
+
+    if (filtered.length !== 0) {
+      QUnit.assert.deepEqual(
+        this.#events.filter((e) => !e.includes(':')),
+        [],
+        'Expected all unprefixed events to be verified during the test.\nFull event log:\n' +
+          this.#events.join('\n')
+      );
+    }
+  }
+
+  get unprefixed(): { expect: (expectedEvents: string[]) => void } {
+    return {
+      expect: (expectedEvents) => {
+        const filteredEvents = this.#events.filter((e) => !e.includes(':'));
+        this.#events = [];
+
+        if (QUnit.equiv(filteredEvents, expectedEvents)) {
+          QUnit.assert.deepEqual(filteredEvents, expectedEvents);
+        } else {
+          QUnit.assert.deepEqual(
+            filteredEvents,
+            expectedEvents,
+            `Full event log:\n${this.#events.map((e) => `  - ${e}`).join('\n')}`
+          );
+        }
+      },
+    };
+  }
+
+  prefixed(
+    prefixes: string[],
+    options?: { exclude: 'unprefixed' }
+  ): { expect: (expectedEvents: string[]) => void } {
+    const prefixSet = new Set<string | undefined>(prefixes);
+    return {
+      expect: (expectedEvents) => {
+        const filteredEvents = this.#events.filter((e) => {
+          if (prefixSet.has(e.split(':')[0])) return true;
+          if (options?.exclude === 'unprefixed') return false;
+          return !e.includes(':');
+        });
+        this.#events = [];
+
+        if (QUnit.equiv(filteredEvents, expectedEvents)) {
+          QUnit.assert.deepEqual(filteredEvents, expectedEvents);
+        } else {
+          QUnit.assert.deepEqual(
+            filteredEvents,
+            expectedEvents,
+            `Full event log:\n${this.#events.map((e) => `  - ${e}`).join('\n')}`
+          );
+        }
+      },
+    };
+  }
+
+  readonly all = {
+    expect: (expectedEvents: string[]) => {
+      const actualEvents = this.#events;
+      this.#events = [];
+
+      QUnit.assert.deepEqual(actualEvents, expectedEvents);
+    },
+  };
+
+  expect(expectedEvents: string[]) {
+    this.unprefixed.expect(expectedEvents);
+  }
+}
diff --git a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/test.ts b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/test.ts
index 29ee8a1d0f..00a4b88706 100644
--- a/packages/@glimmer-workspace/integration-tests/lib/test-helpers/test.ts
+++ b/packages/@glimmer-workspace/integration-tests/lib/test-helpers/test.ts
@@ -1,30 +1,70 @@
-import { keys } from '@glimmer/util';
+export interface TestMeta {
+  type: string;
+  skip?: boolean | undefined;
+}
+
+export interface SimpleTestMeta extends TestMeta {
+  type: 'simple';
+}
 
-import type { ComponentTestMeta } from '../test-decorator';
+export type SimpleTestOptions = Partial<Omit<TestMeta, 'type'>>;
 
-export function test(meta: ComponentTestMeta): MethodDecorator;
+export function test(meta: SimpleTestOptions): MethodDecorator;
 export function test<T>(
-  _target: Object | ComponentTestMeta,
-  _name?: string,
-  descriptor?: TypedPropertyDescriptor<T>
-): TypedPropertyDescriptor<T> | void;
-export function test(...args: any[]) {
+  _target: object,
+  _name: string | symbol,
+  descriptor: TypedPropertyDescriptor<T>
+): TypedPropertyDescriptor<T>;
+export function test(
+  ...args: [meta: SimpleTestOptions] | Parameters<MethodDecorator>
+): MethodDecorator | PropertyDescriptor {
   if (args.length === 1) {
-    let meta: ComponentTestMeta = args[0];
-    return (_target: Object, _name: string, descriptor: PropertyDescriptor) => {
-      let testFunction = descriptor.value;
-      keys(meta).forEach((key) => (testFunction[key] = meta[key]));
-      setTestingDescriptor(descriptor);
-    };
+    let meta = args[0];
+    return ((_target, _name, descriptor: PropertyDescriptor) => {
+      setTestingDescriptor(descriptor, meta);
+    }) satisfies MethodDecorator;
+  } else {
+    const [, , descriptor] = args;
+    setTestingDescriptor(descriptor);
+    return descriptor;
   }
-
-  let descriptor = args[2];
-  setTestingDescriptor(descriptor);
-  return descriptor;
 }
 
-function setTestingDescriptor(descriptor: PropertyDescriptor): void {
+export const TEST_META = Symbol('TEST_META');
+function setTestingDescriptor(
+  descriptor: PropertyDescriptor,
+  options?: SimpleTestOptions | undefined
+): void {
   let testFunction = descriptor.value;
   descriptor.enumerable = true;
-  testFunction['isTest'] = true;
+  testFunction[TEST_META] = {
+    type: 'simple',
+    skip: options?.skip,
+  };
+}
+
+export interface TestFunction<Instance = object> {
+  (this: Instance, assert: Assert): void;
+  readonly [TEST_META]: {
+    type: string;
+  };
+}
+
+export interface SimpleTestFunction extends TestFunction {
+  readonly [TEST_META]: {
+    type: 'simple';
+    skip?: boolean | undefined;
+  };
+}
+
+export function isTest(value: unknown): value is TestFunction {
+  return typeof value === 'function' && TEST_META in value;
+}
+
+export function getTestMeta(value: TestFunction): TestMeta {
+  return value[TEST_META];
+}
+
+export function isSimpleTest(value: unknown): value is SimpleTestFunction {
+  return isTest(value) && value[TEST_META].type === 'simple';
 }
diff --git a/packages/@glimmer-workspace/integration-tests/package.json b/packages/@glimmer-workspace/integration-tests/package.json
index d488f53e7a..8667623423 100644
--- a/packages/@glimmer-workspace/integration-tests/package.json
+++ b/packages/@glimmer-workspace/integration-tests/package.json
@@ -2,7 +2,17 @@
   "name": "@glimmer-workspace/integration-tests",
   "version": "0.84.3",
   "private": true,
-  "main": "index.ts",
+  "main": "lib/index.ts",
+  "types": "lib/index.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.ts",
+      "default": "./lib/index.ts"
+    }
+  },
+  "files": [
+    "lib"
+  ],
   "repository": "https://github.com/glimmerjs/glimmer-vm/tree/master/packages/@glimmer-workspace/integration-tests",
   "dependencies": {
     "@glimmer/destroyable": "workspace:^",
@@ -31,7 +41,7 @@
   },
   "devDependencies": {
     "@glimmer/local-debug-flags": "workspace:^",
-    "@types/qunit": "^2.19.7",
+    "@types/qunit": "workspace:^",
     "@types/js-reporters": "workspace:^"
   },
   "scripts": {
diff --git a/packages/@glimmer-workspace/integration-tests/test/attributes-test.ts b/packages/@glimmer-workspace/integration-tests/test/attributes-test.ts
index cd686d0af8..d93afa1a4e 100644
--- a/packages/@glimmer-workspace/integration-tests/test/attributes-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/attributes-test.ts
@@ -1,10 +1,16 @@
 import type { SimpleElement } from '@glimmer/interfaces';
 import { normalizeProperty } from '@glimmer/runtime';
 import { castToBrowser, expect, NS_SVG } from '@glimmer/util';
-
-import { assertingElement, hasAttribute, jitSuite, RenderTest, test, tracked } from '..';
-
-export class AttributesTests extends RenderTest {
+import {
+  assertingElement,
+  hasAttribute,
+  jitSuite,
+  RenderTestContext,
+  test,
+  tracked,
+} from '@glimmer-workspace/integration-tests';
+
+export class AttributesTests extends RenderTestContext {
   static suiteName = 'Attributes';
 
   protected readDOMAttr(attr: string, element = this.element.firstChild as SimpleElement) {
@@ -24,7 +30,7 @@ export class AttributesTests extends RenderTest {
 
   protected nativeValueForElementProperty<
     T extends keyof HTMLElementTagNameMap,
-    P extends keyof HTMLElementTagNameMap[T]
+    P extends keyof HTMLElementTagNameMap[T],
   >(tagName: T, property: P, value: HTMLElementTagNameMap[T][P]) {
     const element = document.createElement<T>(tagName);
     element[property] = value;
@@ -33,11 +39,11 @@ export class AttributesTests extends RenderTest {
 
   @test
   'helpers shadow self'() {
-    this.registerHelper('foo', function () {
+    this.register.helper('foo', () => {
       return 'hello';
     });
 
-    this.render('<div data-test="{{foo}}"></div>', { foo: 'bye' });
+    this.render.template('<div data-test="{{foo}}"></div>', { foo: 'bye' });
     this.assertHTML('<div data-test="hello"></div>');
     this.assertStableRerender();
 
@@ -52,7 +58,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'disable updates properly'() {
-    this.render('<input disabled={{this.enabled}} />', { enabled: true });
+    this.render.template('<input disabled={{this.enabled}} />', { enabled: true });
     this.assertHTML('<input disabled />');
     this.assertStableRerender();
 
@@ -83,7 +89,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'Quoted disabled is always disabled if a not-null, not-undefined value is given'() {
-    this.render('<input disabled="{{this.enabled}}" />', { enabled: true });
+    this.render.template('<input disabled="{{this.enabled}}" />', { enabled: true });
     this.assertHTML('<input disabled />');
     this.assertStableRerender();
 
@@ -114,7 +120,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'disabled without an explicit value is truthy'() {
-    this.render('<input disabled />');
+    this.render.template('<input disabled />');
     this.assertHTML('<input disabled />');
     this.assert.ok(this.readDOMAttr('disabled'));
 
@@ -124,7 +130,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'div[href] is not marked as unsafe'() {
-    this.render('<div href="{{this.foo}}"></div>', { foo: 'javascript:foo()' });
+    this.render.template('<div href="{{this.foo}}"></div>', { foo: 'javascript:foo()' });
     this.assertHTML('<div href="javascript:foo()"></div>');
     this.assertStableRerender();
 
@@ -139,7 +145,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'triple curlies in attribute position'() {
-    this.render('<div data-bar="bar" data-foo={{{this.rawString}}}>Hello</div>', {
+    this.render.template('<div data-bar="bar" data-foo={{{this.rawString}}}>Hello</div>', {
       rawString: 'TRIPLE',
     });
     this.assertHTML('<div data-foo="TRIPLE" data-bar="bar">Hello</div>');
@@ -156,35 +162,37 @@ export class AttributesTests extends RenderTest {
 
   @test
   'can read attributes'() {
-    this.render('<div data-bar="bar"></div>');
+    this.render.template('<div data-bar="bar"></div>');
     this.assert.strictEqual(this.readDOMAttr('data-bar'), 'bar');
     this.assertStableRerender();
   }
 
   @test
   'can read attributes from namespace elements'() {
-    this.render('<svg viewBox="0 0 0 0"></svg>');
+    this.render.template('<svg viewBox="0 0 0 0"></svg>');
     this.assert.strictEqual(this.readDOMAttr('viewBox'), '0 0 0 0');
     this.assertStableRerender();
   }
 
   @test
   'can read properties'() {
-    this.render('<input value="gnargnar" />');
+    this.render.template('<input value="gnargnar" />');
     this.assert.strictEqual(this.readDOMAttr('value'), 'gnargnar');
     this.assertStableRerender();
   }
 
   @test
   'can read the form attribute'() {
-    this.render('<button form="gnargnar" />');
+    this.render.template('<button form="gnargnar" />');
     this.assert.strictEqual(this.readDOMAttr('form'), 'gnargnar');
     this.assertStableRerender();
   }
 
   @test
   'can set attributes on form properties'() {
-    this.render('<form id={{this.foo}}></form><output form={{this.foo}}></output>', { foo: 'bar' });
+    this.render.template('<form id={{this.foo}}></form><output form={{this.foo}}></output>', {
+      foo: 'bar',
+    });
 
     const outputElement = assertingElement(this.element.lastChild);
 
@@ -197,7 +205,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'handles null input values'() {
-    this.render('<input value={{this.isNull}} />', { isNull: null });
+    this.render.template('<input value={{this.isNull}} />', { isNull: null });
     this.assert.strictEqual(this.readDOMAttr('value'), '');
     this.assertStableRerender();
 
@@ -212,7 +220,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'handles undefined input values'() {
-    this.render('<input value={{this.isUndefined}} />', { isUndefined: null });
+    this.render.template('<input value={{this.isUndefined}} />', { isUndefined: null });
     this.assert.strictEqual(this.readDOMAttr('value'), '');
     this.assertStableRerender();
 
@@ -228,7 +236,7 @@ export class AttributesTests extends RenderTest {
   @test
   'handles undefined `toString` input values'() {
     const obj = Object.create(null);
-    this.render('<input value={{this.obj}} />', { obj });
+    this.render.template('<input value={{this.obj}} />', { obj });
     this.assert.strictEqual(this.readDOMAttr('value'), '');
     this.assertStableRerender();
 
@@ -249,7 +257,7 @@ export class AttributesTests extends RenderTest {
 
     const model = new Model();
 
-    this.render('<input value={{this.model.value}} />', { model });
+    this.render.template('<input value={{this.model.value}} />', { model });
     this.assert.strictEqual(this.readDOMAttr('value'), '');
     this.assertStableRerender();
 
@@ -277,7 +285,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'input[checked] prop updates when set to undefined'() {
-    this.registerHelper('if', (params) => {
+    this.register.helper('if', (params) => {
       if (params[0]) {
         return params[1];
       } else {
@@ -285,7 +293,7 @@ export class AttributesTests extends RenderTest {
       }
     });
 
-    this.render('<input checked={{if this.foo true undefined}} />', { foo: true });
+    this.render.template('<input checked={{if this.foo true undefined}} />', { foo: true });
     this.assert.strictEqual(this.readDOMAttr('checked'), true);
     this.assertStableRerender();
 
@@ -300,7 +308,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'input[checked] prop updates when set to null'() {
-    this.render('<input checked={{this.foo}} />', { foo: true });
+    this.render.template('<input checked={{this.foo}} />', { foo: true });
     this.assert.strictEqual(this.readDOMAttr('checked'), true);
     this.assertStableRerender();
 
@@ -316,7 +324,7 @@ export class AttributesTests extends RenderTest {
   @test
   'select[value] prop updates when set to undefined'() {
     // setting `select[value]` only works after initial render, just use
-    this.render(
+    this.render.template(
       '<select value={{this.foo}}><option></option><option value="us" selected>us</option></select>',
       { foo: undefined }
     );
@@ -335,7 +343,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'handles empty string textarea values'() {
-    this.render('<textarea value={{this.name}} />', { name: '' });
+    this.render.template('<textarea value={{this.name}} />', { name: '' });
     this.assert.strictEqual(this.readDOMAttr('value'), '');
     this.assertStableRerender();
 
@@ -350,7 +358,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'handles empty string input placeholders'() {
-    this.render('<input type="text" placeholder={{this.name}} />', { name: '' });
+    this.render.template('<input type="text" placeholder={{this.name}} />', { name: '' });
     this.assert.strictEqual(this.readDOMAttr('placeholder'), '');
     this.assertStableRerender();
 
@@ -364,7 +372,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'type attribute can be set to non-valid type'() {
-    this.render('<input type="yolo" />');
+    this.render.template('<input type="yolo" />');
     this.assert.strictEqual(this.readDOMAttr('type'), 'text');
     this.assertStableRerender();
 
@@ -374,10 +382,13 @@ export class AttributesTests extends RenderTest {
 
   @test
   'does not set undefined attributes'() {
-    this.render('<div data-foo={{this.isUndefined}} /><div data-foo={{this.isNotUndefined}} />', {
-      isUndefined: undefined,
-      isNotUndefined: 'hello',
-    });
+    this.render.template(
+      '<div data-foo={{this.isUndefined}} /><div data-foo={{this.isNotUndefined}} />',
+      {
+        isUndefined: undefined,
+        isNotUndefined: 'hello',
+      }
+    );
 
     const firstElement = assertingElement(this.element.firstChild);
     const secondElement = assertingElement(this.element.lastChild);
@@ -410,7 +421,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'does not set null attributes'() {
-    this.render('<div data-foo={{this.isNull}} /><div data-foo={{this.isNotNull}} />', {
+    this.render.template('<div data-foo={{this.isNull}} /><div data-foo={{this.isNotNull}} />', {
       isNull: null,
       isNotNull: 'hello',
     });
@@ -450,10 +461,13 @@ export class AttributesTests extends RenderTest {
 
   @test
   'does not set undefined properties initially'() {
-    this.render('<div title={{this.isUndefined}} /><div title={{this.isNotUndefined}} />', {
-      isUndefined: undefined,
-      isNotUndefined: 'hello',
-    });
+    this.render.template(
+      '<div title={{this.isUndefined}} /><div title={{this.isNotUndefined}} />',
+      {
+        isUndefined: undefined,
+        isNotUndefined: 'hello',
+      }
+    );
 
     const firstElement = assertingElement(this.element.firstChild);
     const secondElement = assertingElement(this.element.lastChild);
@@ -487,7 +501,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'does not set null properties initially'() {
-    this.render('<div title={{this.isNull}} /><div title={{this.isNotNull}} />', {
+    this.render.template('<div title={{this.isNull}} /><div title={{this.isNotNull}} />', {
       isNull: undefined,
       isNotNull: 'hello',
     });
@@ -524,7 +538,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'input list attribute updates properly'() {
-    this.render('<input list="{{this.foo}}" />', { foo: 'bar' });
+    this.render.template('<input list="{{this.foo}}" />', { foo: 'bar' });
     this.assertHTML('<input list="bar" />');
     this.assertStableRerender();
 
@@ -539,7 +553,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'normalizes lowercase dynamic properties correctly'() {
-    this.render('<div tiTle={{this.foo}} />', { foo: 'bar' });
+    this.render.template('<div tiTle={{this.foo}} />', { foo: 'bar' });
     this.assertHTML('<div title="bar" />');
     this.assertStableRerender();
 
@@ -554,7 +568,7 @@ export class AttributesTests extends RenderTest {
 
   @test
   'normalizes mix-case dynamic properties correctly'() {
-    this.render('<svg viewBox={{this.foo}} />', { foo: '0 0 100 100' });
+    this.render.template('<svg viewBox={{this.foo}} />', { foo: '0 0 100 100' });
     this.assertHTML('<svg viewBox="0 0 100 100" />');
     this.assertStableRerender();
 
@@ -570,7 +584,7 @@ export class AttributesTests extends RenderTest {
 
 jitSuite(AttributesTests);
 
-abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
+abstract class BoundValuesToSpecialAttributeTests extends RenderTestContext {
   protected abstract tag: string;
   protected abstract attr: string;
   protected isEmptyElement = false;
@@ -578,7 +592,7 @@ abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
 
   @test
   'marks javascript: protocol as unsafe'() {
-    this.render(this.tmplt('{{this.foo}}'), {
+    this.render.template(this.tmplt('{{this.foo}}'), {
       foo: 'javascript:foo()',
     });
     this.assertHTML(this.tmplt('unsafe:javascript:foo()'));
@@ -595,7 +609,7 @@ abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
 
   @test
   'marks javascript: protocol as unsafe, http as safe'() {
-    this.render(this.tmplt('{{this.foo}}'), { foo: 'javascript:foo()' });
+    this.render.template(this.tmplt('{{this.foo}}'), { foo: 'javascript:foo()' });
     this.assertHTML(this.tmplt('unsafe:javascript:foo()'));
     this.assertStableRerender();
 
@@ -610,7 +624,7 @@ abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
 
   @test
   'marks javascript: protocol as unsafe on updates'() {
-    this.render(this.tmplt('{{this.foo}}'), { foo: 'http://foo.bar' });
+    this.render.template(this.tmplt('{{this.foo}}'), { foo: 'http://foo.bar' });
     this.assertHTML(this.tmplt('http://foo.bar', true));
     this.assertStableRerender();
 
@@ -625,7 +639,7 @@ abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
 
   @test
   'marks vbscript: protocol as unsafe'() {
-    this.render(this.tmplt('{{this.foo}}'), { foo: 'vbscript:foo()' });
+    this.render.template(this.tmplt('{{this.foo}}'), { foo: 'vbscript:foo()' });
     this.assertHTML(this.tmplt('unsafe:vbscript:foo()', true));
     this.assertStableRerender();
 
@@ -640,7 +654,7 @@ abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
 
   @test
   'can be removed by setting to `null`'() {
-    this.render(this.tmplt('{{this.foo}}', false), { foo: 'http://foo.bar/derp.jpg' });
+    this.render.template(this.tmplt('{{this.foo}}', false), { foo: 'http://foo.bar/derp.jpg' });
     this.assertHTML(this.tmplt('http://foo.bar/derp.jpg'));
     this.assertStableRerender();
 
@@ -655,7 +669,7 @@ abstract class BoundValuesToSpecialAttributeTests extends RenderTest {
 
   @test
   'can be removed by setting to `undefined`'() {
-    this.render(this.tmplt('{{this.foo}}', false), { foo: 'http://foo.bar/derp.jpg' });
+    this.render.template(this.tmplt('{{this.foo}}', false), { foo: 'http://foo.bar/derp.jpg' });
     this.assertHTML(this.tmplt('http://foo.bar/derp.jpg'));
     this.assertStableRerender();
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/chaos-rehydration-test.ts b/packages/@glimmer-workspace/integration-tests/test/chaos-rehydration-test.ts
index bc3de96641..6a210f805c 100644
--- a/packages/@glimmer-workspace/integration-tests/test/chaos-rehydration-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/chaos-rehydration-test.ts
@@ -1,4 +1,7 @@
-import type { Dict, Nullable, SimpleElement } from '@glimmer/interfaces';
+/* eslint-disable qunit/no-identical-names */
+import type { Dict, Nullable, Reactive,SimpleElement } from '@glimmer/interfaces';
+import type {ComponentBlueprint, Content} from '@glimmer-workspace/integration-tests';
+import { ReadonlyCell, unwrapReactive } from '@glimmer/reference';
 import {
   castToBrowser,
   castToSimple,
@@ -8,31 +11,26 @@ import {
   isObject,
   LOCAL_LOGGER,
 } from '@glimmer/util';
-
 import {
   blockStack,
   CLOSE,
-  type ComponentBlueprint,
-  type Content,
   content,
   equalTokens,
+  matrix,
   OPEN,
   PartialRehydrationDelegate,
   qunitFixture,
   RehydrationDelegate,
-  RenderTest,
-  replaceHTML,
-  suite,
-  test,
-} from '..';
-
-// `window.ActiveXObject` is "falsey" in IE11 (but not `undefined` or `false`)
-// `"ActiveXObject" in window` returns `true` in all IE versions
-// only IE11 will pass _both_ of these conditions
+  RenderTestContext,
+  replaceHTML
+} from '@glimmer-workspace/integration-tests';
+
+// `window.ActiveXObject` is "falsey" in IE11 (but not `undefined` or `false`) `"ActiveXObject" in
+// window` returns `true` in all IE versions only IE11 will pass _both_ of these conditions
 const isIE11 = !(window as any).ActiveXObject && 'ActiveXObject' in window;
 
-abstract class AbstractChaosMonkeyTest extends RenderTest {
-  abstract renderClientSide(template: string | ComponentBlueprint, context: Dict<unknown>): void;
+abstract class ChaosMonkeyContext extends RenderTestContext {
+  abstract renderClientSide(template: string | ComponentBlueprint, self: Reactive): void;
 
   getRandomForIteration(iteration: number) {
     const { seed } = QUnit.config;
@@ -87,7 +85,8 @@ abstract class AbstractChaosMonkeyTest extends RenderTest {
     // gather all the nodes recursively
     let nodes: Node[] = collectChildNodes([], element);
 
-    // cannot remove the first opening block node and last closing block node, that is what makes it rehydrateable
+    // cannot remove the first opening block node and last closing block node, that is what makes it
+    // rehydrateable
     nodes = nodes.slice(1, -1);
 
     // select a random node to remove
@@ -112,7 +111,7 @@ abstract class AbstractChaosMonkeyTest extends RenderTest {
     }
 
     if (shouldLog) {
-      LOCAL_LOGGER.log(
+      LOCAL_LOGGER.debug(
         `${removedNodeDisplay} was removed;\noriginal: ${original}\nupdated:  ${element.innerHTML}`
       );
     }
@@ -124,7 +123,7 @@ abstract class AbstractChaosMonkeyTest extends RenderTest {
     );
   }
 
-  runIterations(template: string, context: Dict<unknown>, expectedHTML: string, count: number) {
+  runIterations(template: string, self: Reactive<Dict>, expectedHTML: string, count: number) {
     const element = castToBrowser(this.element, 'HTML');
     const elementResetValue = element.innerHTML;
 
@@ -134,7 +133,7 @@ abstract class AbstractChaosMonkeyTest extends RenderTest {
       const iteration = parseInt(urlParams['iteration'], 10);
       this.wreakHavoc(iteration, true);
 
-      this.renderClientSide(template, context);
+      this.renderClientSide(template, self);
 
       const element = castToBrowser(this.element, 'HTML');
       this.assert.strictEqual(element.innerHTML, expectedHTML);
@@ -146,7 +145,7 @@ abstract class AbstractChaosMonkeyTest extends RenderTest {
         try {
           this.wreakHavoc(i);
 
-          this.renderClientSide(template, context);
+          this.renderClientSide(template, self);
 
           const element = castToBrowser(this.element, 'HTML');
           this.assert.strictEqual(
@@ -186,7 +185,7 @@ function getErrorMessage(assert: Assert, error: unknown): string {
   }
 }
 
-class ChaosMonkeyRehydration extends AbstractChaosMonkeyTest {
+class ChaosMonkeyRehydration extends ChaosMonkeyContext {
   static suiteName = 'chaos-rehydration';
 
   protected declare delegate: RehydrationDelegate;
@@ -194,21 +193,26 @@ class ChaosMonkeyRehydration extends AbstractChaosMonkeyTest {
 
   renderServerSide(
     template: string | ComponentBlueprint,
-    context: Dict<unknown>,
+    self: Reactive,
     element: SimpleElement | undefined = undefined
   ): void {
     this.serverOutput = this.delegate.renderServerSide(
       template as string,
-      context,
+      self,
       () => this.takeSnapshot(),
-      element
+      element,
+      this.plugins
     );
     replaceHTML(this.element, this.serverOutput);
   }
 
-  renderClientSide(template: string | ComponentBlueprint, context: Dict<unknown>): void {
-    this.context = context;
-    this.renderResult = this.delegate.renderClientSide(template as string, context, this.element);
+  renderClientSide(template: string | ComponentBlueprint, self: Reactive): void {
+    this.renderResult = this.delegate.renderClientSide(
+      template as string,
+      self,
+      this.element,
+      this.plugins
+    );
   }
 
   assertExactServerOutput(_expected: string) {
@@ -222,128 +226,148 @@ class ChaosMonkeyRehydration extends AbstractChaosMonkeyTest {
   assertServerOutput(..._expected: Content[]) {
     this.assertExactServerOutput(content([OPEN, ..._expected, CLOSE]));
   }
+}
 
-  @test
-  'adjacent text nodes'() {
-    const template = '<div>a {{this.b}}{{this.c}}{{this.d}}</div>';
-    const context = { b: '', c: '', d: '' };
+export const ChaosMonkeyTests = matrix(
+  { context: ChaosMonkeyRehydration },
+  'chaos rehydration',
+  (test) => {
+    test('adjacent text nodes', (ctx) => {
+      const template = '<div>a {{this.b}}{{this.c}}{{this.d}}</div>';
 
-    this.renderServerSide(template, context);
+      ctx.self.initialize({ b: '', c: '', d: '' });
+      ctx.renderServerSide(template, ctx.self.ref);
 
-    const b = blockStack();
-    this.assertServerOutput(
-      `<div>a ${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}</div>`
-    );
+      const b = blockStack();
+      ctx.assertServerOutput(
+        `<div>a ${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}</div>`
+      );
 
-    this.runIterations(template, context, '<div>a </div>', 100);
-  }
+      ctx.runIterations(template, ctx.self.ref, '<div>a </div>', 100);
+    });
 
-  @test
-  '<p> invoking a block which emits a <div>'() {
-    const template = '<p>hello {{#if this.show}}<div>world!</div>{{/if}}</p>';
-    const context = { show: true };
+    test('<p> invoking a block which emits a <div>', (ctx) => {
+      const template = '<p>hello {{#if this.show}}<div>world!</div>{{/if}}</p>';
 
-    this.renderServerSide(template, context);
-    const b = blockStack();
+      ctx.self.update({ show: true });
+      ctx.renderServerSide(template, ctx.self.ref);
+      const b = blockStack();
 
-    // assert that we are in a "browser corrected" state (note the `</p>` before the `<div>world!</div>`)
-    if (isIE11) {
-      // IE11 doesn't behave the same as modern browsers
-      this.assertServerOutput(`<p>hello ${b(1)}<div>world!</div>${b(1)}<p></p>`);
-    } else {
-      this.assertServerOutput(`<p>hello ${b(1)}</p><div>world!</div>${b(1)}<p></p>`);
-    }
+      // assert that we are in a "browser corrected" state (note the `</p>` before the
+      // `<div>world!</div>`)
+      if (isIE11) {
+        // IE11 doesn't behave the same as modern browsers
+        ctx.assertServerOutput(`<p>hello ${b(1)}<div>world!</div>${b(1)}<p></p>`);
+      } else {
+        ctx.assertServerOutput(`<p>hello ${b(1)}</p><div>world!</div>${b(1)}<p></p>`);
+      }
 
-    this.runIterations(template, context, '<p>hello <div>world!</div></p>', 100);
+      ctx.runIterations(template, ctx.self.ref, '<p>hello <div>world!</div></p>', 100);
+    });
   }
-}
+).test(RehydrationDelegate);
 
-class ChaosMonkeyPartialRehydration extends AbstractChaosMonkeyTest {
+class ChaosMonkeyPartialRehydrationContext extends ChaosMonkeyContext {
   static suiteName = 'chaos-partial-rehydration';
-  protected declare delegate: PartialRehydrationDelegate;
-
-  renderClientSide(componentName: string, args: Dict<unknown>): void {
-    this.renderResult = this.delegate.renderComponentClientSide(componentName, args, this.element);
-  }
-
-  @test
-  'adjacent text nodes'() {
-    const args = { b: 'b', c: 'c', d: 'd' };
+  declare delegate: PartialRehydrationDelegate;
 
-    this.delegate.registerTemplateOnlyComponent('RehydratingComponent', 'a {{@b}}{{@c}}{{@d}}');
-    this.delegate.registerTemplateOnlyComponent(
-      'Root',
-      '<div><RehydratingComponent @b={{@b}} @c={{@c}} @d={{@d}}/></div>'
+  renderClientSide(componentName: string, args: Reactive<Dict>): void {
+    this.renderResult = this.delegate.renderComponentClientSide(
+      componentName,
+      unwrapReactive(args),
+      this.element
     );
-    const html = this.delegate.renderComponentServerSide('Root', args);
-
-    this.assert.strictEqual(
-      html,
-      content([
-        OPEN,
-        OPEN,
-        '<div>',
-        OPEN,
-        'a ',
-        OPEN,
-        'b',
-        CLOSE,
-        OPEN,
-        'c',
-        CLOSE,
-        OPEN,
-        'd',
-        CLOSE,
-        CLOSE,
-        '</div>',
-        CLOSE,
-        CLOSE,
-      ]),
-      'server html is correct'
-    );
-    replaceHTML(qunitFixture(), html);
-    this.element = castToSimple(castToBrowser(qunitFixture(), 'HTML').querySelector('div')!);
-    this.runIterations('RehydratingComponent', args, 'a bcd', 100);
   }
+}
 
-  @test
-  '<p> invoking a block which emits a <div>'() {
-    const args = { show: true };
+matrix(
+  {
+    context: ChaosMonkeyPartialRehydrationContext,
+  },
+  'chaos partial rehydration',
+  (test) => {
+    test('adjacent text nodes', (ctx) => {
+      const args = { b: 'b', c: 'c', d: 'd' };
+
+      ctx.register.component('TemplateOnly', 'RehydratingComponent', 'a {{@b}}{{@c}}{{@d}}');
+      ctx.register.component(
+        'TemplateOnly',
+        'Root',
+        '<div><RehydratingComponent @b={{@b}} @c={{@c}} @d={{@d}}/></div>'
+      );
+      const html = ctx.delegate.renderComponentServerSide('Root', args);
+
+      ctx.assert.strictEqual(
+        html,
+        content([
+          OPEN,
+          OPEN,
+          '<div>',
+          OPEN,
+          'a ',
+          OPEN,
+          'b',
+          CLOSE,
+          OPEN,
+          'c',
+          CLOSE,
+          OPEN,
+          'd',
+          CLOSE,
+          CLOSE,
+          '</div>',
+          CLOSE,
+          CLOSE,
+        ]),
+        'server html is correct'
+      );
+      replaceHTML(qunitFixture(), html);
+      ctx.element = castToSimple(castToBrowser(qunitFixture(), 'HTML').querySelector('div')!);
+      ctx.runIterations('RehydratingComponent', ReadonlyCell(args, 'args'), 'a bcd', 100);
+    });
 
-    this.delegate.registerTemplateOnlyComponent(
-      'RehydratingComponent',
-      '<p>hello {{#if @show}}<div>world!</div>{{/if}}</p>'
-    );
+    test('<p> invoking a block which emits a <div>', (ctx) => {
+      const args = { show: true };
 
-    this.delegate.registerTemplateOnlyComponent(
-      'Root',
-      '<div><RehydratingComponent @show={{@show}}/></div>'
-    );
-    const html = this.delegate.renderComponentServerSide('Root', args);
-    this.assert.strictEqual(
-      html,
-      content([
-        OPEN,
-        OPEN,
-        '<div>',
-        OPEN,
-        '<p>hello ',
-        OPEN,
-        '<div>world!</div>',
-        CLOSE,
-        '</p>',
-        CLOSE,
-        '</div>',
-        CLOSE,
-        CLOSE,
-      ])
-    );
+      ctx.register.component(
+        'TemplateOnly',
+        'RehydratingComponent',
+        '<p>hello {{#if @show}}<div>world!</div>{{/if}}</p>'
+      );
 
-    replaceHTML(qunitFixture(), html);
-    this.element = castToSimple(castToBrowser(qunitFixture(), 'HTML').querySelector('div')!);
-    this.runIterations('RehydratingComponent', args, '<p>hello <div>world!</div></p>', 100);
-  }
-}
+      ctx.register.component(
+        'TemplateOnly',
+        'Root',
+        '<div><RehydratingComponent @show={{@show}}/></div>'
+      );
+      const html = ctx.delegate.renderComponentServerSide('Root', args);
+      ctx.assert.strictEqual(
+        html,
+        content([
+          OPEN,
+          OPEN,
+          '<div>',
+          OPEN,
+          '<p>hello ',
+          OPEN,
+          '<div>world!</div>',
+          CLOSE,
+          '</p>',
+          CLOSE,
+          '</div>',
+          CLOSE,
+          CLOSE,
+        ])
+      );
 
-suite(ChaosMonkeyRehydration, RehydrationDelegate);
-suite(ChaosMonkeyPartialRehydration, PartialRehydrationDelegate);
+      replaceHTML(qunitFixture(), html);
+      ctx.element = castToSimple(castToBrowser(qunitFixture(), 'HTML').querySelector('div')!);
+      ctx.runIterations(
+        'RehydratingComponent',
+        ReadonlyCell(args, 'args'),
+        '<p>hello <div>world!</div></p>',
+        100
+      );
+    });
+  }
+).test(PartialRehydrationDelegate);
diff --git a/packages/@glimmer-workspace/integration-tests/test/compiler/compile-options-test.ts b/packages/@glimmer-workspace/integration-tests/test/compiler/compile-options-test.ts
index 8ec0339b25..2d584e68ae 100644
--- a/packages/@glimmer-workspace/integration-tests/test/compiler/compile-options-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/compiler/compile-options-test.ts
@@ -1,10 +1,10 @@
-import { precompile } from '@glimmer/compiler';
 import type { WireFormat } from '@glimmer/interfaces';
 import type { TemplateWithIdAndReferrer } from '@glimmer/opcode-compiler';
+import { precompile } from '@glimmer/compiler';
 import { assert as glimmerAssert, unwrapTemplate } from '@glimmer/util';
 import { SexpOpcodes } from '@glimmer/wire-format';
 
-import { preprocess } from '../..';
+import { preprocess } from '../../lib';
 import { module } from '../support';
 
 module('[glimmer-compiler] Compile options', ({ test }) => {
@@ -46,17 +46,15 @@ module('[glimmer-compiler] precompile', ({ test }) => {
   }
 
   test('lexicalScope is used if present', (assert) => {
-     
     let wire = compile(`<hello /><div />`, ['hello'], (source) => eval(source));
 
     const hello = { varname: 'hello' };
     assert.ok(hello, 'avoid unused variable lint');
 
-     
     let [statements] = wire.block;
     let [[, componentNameExpr], ...divExpr] = statements as [
       WireFormat.Statements.Component,
-      ...WireFormat.Statement[]
+      ...WireFormat.Statement[],
     ];
 
     assert.deepEqual(wire.scope?.(), [hello]);
@@ -75,17 +73,15 @@ module('[glimmer-compiler] precompile', ({ test }) => {
   });
 
   test('lexicalScope works if the component name is a path', (assert) => {
-     
     let wire = compile(`<f.hello /><div />`, ['f'], (source) => eval(source));
 
     const f = {};
     assert.ok(f, 'avoid unused variable lint');
 
-     
     let [statements] = wire.block;
     let [[, componentNameExpr], ...divExpr] = statements as [
       WireFormat.Statements.Component,
-      ...WireFormat.Statement[]
+      ...WireFormat.Statement[],
     ];
 
     assert.deepEqual(wire.scope?.(), [f]);
@@ -102,7 +98,7 @@ module('[glimmer-compiler] precompile', ({ test }) => {
     ]);
   });
 
-  test('customizeComponentName is used if present', function (assert) {
+  test('customizeComponentName is used if present', (assert) => {
     let wire = JSON.parse(
       precompile('<XFoo />', {
         customizeComponentName(input: string) {
@@ -124,7 +120,7 @@ module('[glimmer-compiler] precompile', ({ test }) => {
     assert.strictEqual(componentName, 'ooFX', 'customized component name was used');
   });
 
-  test('customizeComponentName does not cause components to conflict with existing symbols', function (assert) {
+  test('customizeComponentName does not cause components to conflict with existing symbols', (assert) => {
     let wire = JSON.parse(
       precompile('{{#let @model as |rental|}}<Rental @renter={{rental}} />{{/let}}', {
         customizeComponentName(input: string) {
@@ -148,7 +144,7 @@ module('[glimmer-compiler] precompile', ({ test }) => {
     assert.strictEqual(componentName, 'rental', 'customized component name was used');
   });
 
-  test('customizeComponentName is not invoked on curly components', function (assert) {
+  test('customizeComponentName is not invoked on curly components', (assert) => {
     let wire = JSON.parse(
       precompile('{{#my-component}}hello{{/my-component}}', {
         customizeComponentName(input: string) {
@@ -171,7 +167,7 @@ module('[glimmer-compiler] precompile', ({ test }) => {
     assert.strictEqual(componentName, 'my-component', 'original component name was used');
   });
 
-  test('customizeComponentName is not invoked on angle-bracket-like name invoked with curlies', function (assert) {
+  test('customizeComponentName is not invoked on angle-bracket-like name invoked with curlies', (assert) => {
     let wire = JSON.parse(
       precompile('{{#MyComponent}}hello{{/MyComponent}}', {
         customizeComponentName(input: string) {
diff --git a/packages/@glimmer-workspace/integration-tests/test/debug-render-tree-test.ts b/packages/@glimmer-workspace/integration-tests/test/debug-render-tree-test.ts
index ad78b676ef..a1e962e228 100644
--- a/packages/@glimmer-workspace/integration-tests/test/debug-render-tree-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/debug-render-tree-test.ts
@@ -8,25 +8,24 @@ import type {
   SimpleElement,
   SimpleNode,
 } from '@glimmer/interfaces';
+import type {TemplateOnlyComponent} from '@glimmer/runtime';
+import type {EmberishCurlyComponent} from '@glimmer-workspace/integration-tests';
 import { setComponentTemplate } from '@glimmer/manager';
 import {
   EMPTY_ARGS,
-  type TemplateOnlyComponent,
   templateOnlyComponent,
-  TemplateOnlyComponentManager,
+  TemplateOnlyComponentManager
 } from '@glimmer/runtime';
 import { assign, expect } from '@glimmer/util';
-
 import {
   BaseEnv,
+  ClientSideRenderDelegate,
   createTemplate,
-  type EmberishCurlyComponent,
   GlimmerishComponent,
-  JitRenderDelegate,
-  RenderTest,
-  suite,
+  RenderTestContext,
   test,
-} from '..';
+  testSuite
+} from '@glimmer-workspace/integration-tests';
 
 interface CapturedBounds {
   parentElement: SimpleElement;
@@ -50,7 +49,7 @@ interface ExpectedRenderNode {
   children: Expected<CapturedRenderNode['children']> | ExpectedRenderNode[];
 }
 
-class DebugRenderTreeDelegate extends JitRenderDelegate {
+class DebugRenderTreeDelegate extends ClientSideRenderDelegate {
   registerCustomComponent(
     name: string,
     template: string,
@@ -71,15 +70,15 @@ class DebugRenderTreeDelegate extends JitRenderDelegate {
   }
 }
 
-class DebugRenderTreeTest extends RenderTest {
+class DebugRenderTreeTest extends RenderTestContext {
   static suiteName = 'Application test: debug render tree';
 
   declare delegate: DebugRenderTreeDelegate;
 
   @test 'template-only components'() {
-    this.registerComponent('TemplateOnly', 'HelloWorld', '{{@arg}}');
+    this.register.component('TemplateOnly', 'HelloWorld', '{{@arg}}');
 
-    this.render(
+    this.render.template(
       `<HelloWorld @arg="first"/>{{#if this.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
       {
         showSecond: false,
@@ -93,7 +92,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: null,
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
     ]);
@@ -107,7 +106,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: null,
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
       {
@@ -116,7 +115,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'second' } },
         instance: null,
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().lastChild),
+        bounds: this.nodeBounds(this.getInitialElement().lastChild),
         children: [],
       },
     ]);
@@ -130,16 +129,16 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: null,
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
     ]);
   }
 
   @test 'emberish curly components'() {
-    this.registerComponent('Curly', 'HelloWorld', 'Hello World');
+    this.register.component('Curly', 'HelloWorld', 'Hello World');
 
-    this.render(
+    this.render.template(
       `<HelloWorld @arg="first"/>{{#if this.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
       {
         showSecond: false,
@@ -153,7 +152,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: (instance: EmberishCurlyComponent) => (instance as any).arg === 'first',
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
     ]);
@@ -197,9 +196,9 @@ class DebugRenderTreeTest extends RenderTest {
   }
 
   @test 'glimmerish components'() {
-    this.registerComponent('Glimmer', 'HelloWorld', 'Hello World');
+    this.register.component('Glimmer', 'HelloWorld', 'Hello World');
 
-    this.render(
+    this.render.template(
       `<HelloWorld @arg="first"/>{{#if this.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
       {
         showSecond: false,
@@ -213,7 +212,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: (instance: GlimmerishComponent) => instance.args['arg'] === 'first',
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
     ]);
@@ -294,9 +293,9 @@ class DebugRenderTreeTest extends RenderTest {
       }
     );
 
-    this.registerComponent('TemplateOnly', 'HelloWorld2', '{{@arg}}');
+    this.register.component('TemplateOnly', 'HelloWorld2', '{{@arg}}');
 
-    this.render(
+    this.render.template(
       `<HelloWorld2 @arg="first"/>{{#if this.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
       {
         showSecond: false,
@@ -310,7 +309,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: null,
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
     ]);
@@ -374,9 +373,9 @@ class DebugRenderTreeTest extends RenderTest {
       }
     );
 
-    this.registerComponent('TemplateOnly', 'HelloWorld2', '{{@arg}}');
+    this.register.component('TemplateOnly', 'HelloWorld2', '{{@arg}}');
 
-    this.render(
+    this.render.template(
       `<HelloWorld2 @arg="first"/>{{#if this.showSecond}}<HelloWorld @arg="second"/>{{/if}}`,
       {
         showSecond: false,
@@ -390,7 +389,7 @@ class DebugRenderTreeTest extends RenderTest {
         args: { positional: [], named: { arg: 'first' } },
         instance: null,
         template: '(unknown template module)',
-        bounds: this.nodeBounds(this.delegate.getInitialElement().firstChild),
+        bounds: this.nodeBounds(this.getInitialElement().firstChild),
         children: [],
       },
     ]);
@@ -425,7 +424,7 @@ class DebugRenderTreeTest extends RenderTest {
   }
 
   @test 'cleans up correctly after errors'(assert: Assert) {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'HelloWorld',
       'Hello World',
@@ -438,7 +437,7 @@ class DebugRenderTreeTest extends RenderTest {
     );
 
     assert.throws(() => {
-      this.render('<HelloWorld @arg="first"/>');
+      this.render.template('<HelloWorld @arg="first"/>');
     }, /oops!/u);
 
     assert.deepEqual(this.delegate.getCapturedRenderTree(), [], 'there was no output');
@@ -535,7 +534,7 @@ class DebugRenderTreeTest extends RenderTest {
   }
 }
 
-suite(DebugRenderTreeTest, DebugRenderTreeDelegate, {
+testSuite(DebugRenderTreeTest, DebugRenderTreeDelegate, {
   env: assign({}, BaseEnv, {
     enableDebugTooling: true,
   }),
diff --git a/packages/@glimmer-workspace/integration-tests/test/ember-component-test.ts b/packages/@glimmer-workspace/integration-tests/test/ember-component-test.ts
index b21f1cd81f..213e9183d7 100644
--- a/packages/@glimmer-workspace/integration-tests/test/ember-component-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/ember-component-test.ts
@@ -1,25 +1,24 @@
 import type { SimpleElement, SimpleNode } from '@glimmer/interfaces';
+import type {Attrs, AttrsDiff, ClientSideRenderDelegate, EmberishCurlyComponentFactory} from '@glimmer-workspace/integration-tests';
 import { assign, castToSimple, unwrap } from '@glimmer/util';
 import {
   classes,
   createTemplate,
   elementId,
   EmberishCurlyComponent,
-  type EmberishCurlyComponentFactory,
   equalsElement,
   firstElementChild,
   GlimmerishComponent,
   isSimpleElement,
-  type JitRenderDelegate,
   jitSuite,
   regex,
-  RenderTest,
+  render,
+  RenderTestContext,
   stripTight,
-  test,
-  type AttrsDiff,
-  type Attrs,
+  suite
 } from '@glimmer-workspace/integration-tests';
 
+import { ErrorRecoverySuite } from '../lib/suites/error-recovery';
 import { assert } from './support';
 
 interface ComponentHooks {
@@ -107,7 +106,7 @@ function assertFired(component: HookedComponent, name: string, count = 1) {
   let hooks = component.hooks;
 
   if (!hooks) {
-    throw new TypeError(`Not hooked: ${component}`);
+    throw new TypeError(`Not hooked: ${component.constructor.name}`);
   }
 
   if (name in hooks) {
@@ -164,7 +163,7 @@ export function assertElementIsEmberishElement(
 //   view.rerender();
 // }
 
-class CurlyTest extends RenderTest {
+class CurlyTest extends RenderTestContext {
   assertEmberishElement(tagName: string, attrs: Object, contents: string): void;
   assertEmberishElement(tagName: string, attrs: Object): void;
   assertEmberishElement(tagName: string, contents: string): void;
@@ -188,45 +187,68 @@ class CurlyTest extends RenderTest {
 class CurlyCreateTest extends CurlyTest {
   static suiteName = '[curly components] Manager#create - hasBlock';
 
-  @test
+  @render
   'when no block present'() {
     class FooBar extends EmberishCurlyComponent {
       override tagName = 'div';
     }
 
-    this.registerComponent('Curly', 'foo-bar', `{{this.HAS_BLOCK}}`, FooBar);
+    this.register.component('Curly', 'foo-bar', `{{this.HAS_BLOCK}}`, FooBar);
 
-    this.render(`{{foo-bar}}`);
+    this.render.template(`{{foo-bar}}`);
 
     this.assertEmberishElement('div', {}, `false`);
   }
 
-  @test
+  @render
   'when block present'() {
     class FooBar extends EmberishCurlyComponent {
       override tagName = 'div';
     }
 
-    this.registerComponent('Curly', 'foo-bar', `{{this.HAS_BLOCK}}`, FooBar);
+    this.register.component('Curly', 'foo-bar', `{{this.HAS_BLOCK}}`, FooBar);
 
-    this.render(`{{#foo-bar}}{{/foo-bar}}`);
+    this.render.template(`{{#foo-bar}}{{/foo-bar}}`);
 
     this.assertEmberishElement('div', {}, `true`);
   }
 }
 
+class Context {
+  readonly handler = () => {};
+
+  get arg1() {
+    throw Error('woops');
+  }
+}
+
+@suite('(component dynamic)')
 class CurlyDynamicComponentTest extends CurlyTest {
-  static suiteName = '[curly components] dynamic components';
+  override beforeEach = () => {
+    this.register.component('TemplateOnly', 'Target', `<p>{{@arg1}}</p>`);
+  };
+
+  @render
+  'error recovery'() {
+    this.render.template(
+      stripTight`
+        <div>{{#-try this.context.handler}}{{component this.context.component arg1="hello"}}{{/-try}}</div>
+      `,
+      { context: new Context() }
+    );
+
+    this.assertHTML('<div><!----></div>');
+  }
 
-  @test
+  @render
   'initially missing, then present, then missing'() {
-    this.registerComponent('Curly', 'FooBar', `<p>{{@arg1}}</p>`);
+    this.register.component('Curly', 'FooBar', `<p>{{@arg1}}</p>`);
 
-    this.render(
+    this.render.template(
       stripTight`
-        <div>
-          {{component this.something arg1="hello"}}
-        </div>
+      <div>
+      {{component this.something arg1="hello"}}
+      </div>
       `,
       {
         something: undefined,
@@ -241,11 +263,11 @@ class CurlyDynamicComponentTest extends CurlyTest {
     this.assertHTML('<div><!----></div>');
   }
 
-  @test
+  @render
   'initially present, then missing, then present'() {
-    this.registerComponent('Curly', 'FooBar', `<p>foo bar baz</p>`);
+    this.register.component('Curly', 'FooBar', `<p>foo bar baz</p>`);
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           {{component this.something}}
@@ -267,33 +289,33 @@ class CurlyDynamicComponentTest extends CurlyTest {
 class CurlyDynamicCustomizationTest extends CurlyTest {
   static suiteName = '[curly components] dynamic customizations';
 
-  @test
+  @render
   'dynamic tagName'() {
     class FooBar extends EmberishCurlyComponent {
       override tagName = 'aside';
     }
 
-    this.registerComponent('Curly', 'foo-bar', `Hello. It's me.`, FooBar);
+    this.register.component('Curly', 'foo-bar', `Hello. It's me.`, FooBar);
 
-    this.render(`{{foo-bar}}`);
+    this.render.template(`{{foo-bar}}`);
     this.assertEmberishElement('aside', {}, `Hello. It's me.`);
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'dynamic tagless component'() {
     class FooBar extends EmberishCurlyComponent {
       override tagName = '';
     }
 
-    this.registerComponent('Curly', 'foo-bar', `Michael Jordan says "Go Tagless"`, FooBar);
+    this.register.component('Curly', 'foo-bar', `Michael Jordan says "Go Tagless"`, FooBar);
 
-    this.render(`{{foo-bar}}`);
+    this.render.template(`{{foo-bar}}`);
     this.assertHTML('Michael Jordan says "Go Tagless"');
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'dynamic attribute bindings'() {
     let fooBarInstance: FooBar | undefined;
 
@@ -310,9 +332,9 @@ class CurlyDynamicCustomizationTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'foo-bar', `Hello. It's me.`, FooBar);
+    this.register.component('Curly', 'foo-bar', `Hello. It's me.`, FooBar);
 
-    this.render(`{{foo-bar}}`);
+    this.render.template(`{{foo-bar}}`);
     this.assertEmberishElement('div', { style: 'color: red;' }, `Hello. It's me.`);
 
     this.rerender();
@@ -340,16 +362,16 @@ class CurlyDynamicCustomizationTest extends CurlyTest {
 class CurlyArgsTest extends CurlyTest {
   static suiteName = '[curly components] args';
 
-  @test
+  @render
   'using @value from emberish curly component'() {
     class FooBar extends EmberishCurlyComponent {
       static override positionalParams = ['foo'];
       override tagName = 'div';
     }
 
-    this.registerComponent('Curly', 'foo-bar', `{{@blah}}`, FooBar);
+    this.register.component('Curly', 'foo-bar', `{{@blah}}`, FooBar);
 
-    this.render(`{{foo-bar this.first blah="derp"}}`);
+    this.render.template(`{{foo-bar this.first blah="derp"}}`);
 
     this.assertEmberishElement('div', {}, `derp`);
   }
@@ -358,15 +380,15 @@ class CurlyArgsTest extends CurlyTest {
 class CurlyScopeTest extends CurlyTest {
   static suiteName = '[curly components] scope';
 
-  @test
+  @render
   'correct scope - accessing local variable in yielded block (glimmer component)'() {
-    this.registerComponent(
+    this.register.component(
       'TemplateOnly',
       'FooBar',
       `<div>[Layout: {{this.zomg}}][Layout: {{this.lol}}][Layout: {{@foo}}]{{yield}}</div>`
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           [Outside: {{this.zomg}}]
@@ -400,20 +422,20 @@ class CurlyScopeTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'correct scope - accessing local variable in yielded block (curly component)'() {
     class FooBar extends EmberishCurlyComponent {
       public override tagName = '';
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'foo-bar',
       `[Layout: {{this.zomg}}][Layout: {{this.lol}}][Layout: {{this.foo}}]{{yield}}`,
       FooBar
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           [Outside: {{this.zomg}}]
@@ -445,7 +467,7 @@ class CurlyScopeTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'correct scope - caller self can be threaded through (curly component)'() {
     // demonstrates ability for Ember to know the target object of curly component actions
     class Base extends EmberishCurlyComponent {
@@ -459,7 +481,7 @@ class CurlyScopeTest extends CurlyTest {
       public override name = 'qux-derp';
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'foo-bar',
       stripTight`
@@ -472,14 +494,14 @@ class CurlyScopeTest extends CurlyTest {
       FooBar
     );
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'qux-derp',
       `[Name: {{this.name}} | Target: {{this.targetObject.name}}]{{yield}}`,
       QuxDerp
     );
 
-    this.render(`<div>{{foo-bar}}</div>`, {
+    this.render.template(`<div>{{foo-bar}}</div>`, {
       name: 'outer-scope',
     });
 
@@ -495,45 +517,47 @@ class CurlyScopeTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   '`false` class name do not render'() {
-    this.render('<div class={{this.isFalse}}>FALSE</div>', { isFalse: false });
+    this.render.template('<div class={{this.isFalse}}>FALSE</div>', { isFalse: false });
     this.assertHTML('<div>FALSE</div>');
   }
 
-  @test
+  @render
   '`null` class name do not render'() {
-    this.render('<div class={{this.isNull}}>NULL</div>', { isNull: null });
+    this.render.template('<div class={{this.isNull}}>NULL</div>', { isNull: null });
     this.assertHTML('<div>NULL</div>');
   }
 
-  @test
+  @render
   '`undefined` class name do not render'() {
-    this.render('<div class={{this.isUndefined}}>UNDEFINED</div>', { isUndefined: undefined });
+    this.render.template('<div class={{this.isUndefined}}>UNDEFINED</div>', {
+      isUndefined: undefined,
+    });
     this.assertHTML('<div>UNDEFINED</div>');
   }
 
-  @test
+  @render
   '`0` class names do render'() {
-    this.render('<div class={{this.isZero}}>ZERO</div>', { isZero: 0 });
+    this.render.template('<div class={{this.isZero}}>ZERO</div>', { isZero: 0 });
     this.assertHTML('<div class="0">ZERO</div>');
   }
 
-  @test
+  @render
   'component with slashed name'() {
-    this.registerComponent('Curly', 'fizz-bar/baz-bar', '{{@hey}}');
-    this.render('{{fizz-bar/baz-bar hey="hello"}}');
+    this.register.component('Curly', 'fizz-bar/baz-bar', '{{@hey}}');
+    this.render.template('{{fizz-bar/baz-bar hey="hello"}}');
 
     this.assertHTML('<div id="ember*" class="ember-view">hello</div>');
   }
 
-  @test
+  @render
   'correct scope - simple'() {
-    this.registerComponent('TemplateOnly', 'SubItem', `<p>{{@name}}</p>`);
+    this.register.component('TemplateOnly', 'SubItem', `<p>{{@name}}</p>`);
 
     let subitems = [{ id: 0 }, { id: 1 }, { id: 42 }];
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           {{#each this.items key="id" as |item|}}
@@ -546,13 +570,13 @@ class CurlyScopeTest extends CurlyTest {
     this.assertHTML('<div><p>0</p><p>1</p><p>42</p></div>');
   }
 
-  @test
+  @render
   'correct scope - self lookup inside #each'() {
-    this.registerComponent('TemplateOnly', 'SubItem', `<p>{{@name}}</p>`);
+    this.register.component('TemplateOnly', 'SubItem', `<p>{{@name}}</p>`);
 
     let subitems = [{ id: 0 }, { id: 1 }, { id: 42 }];
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           {{#each this.items key="id" as |item|}}
@@ -575,11 +599,11 @@ class CurlyScopeTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'correct scope - complex'() {
-    this.registerComponent('TemplateOnly', 'SubItem', `<p>{{@name}}</p>`);
+    this.register.component('TemplateOnly', 'SubItem', `<p>{{@name}}</p>`);
 
-    this.registerComponent(
+    this.register.component(
       'TemplateOnly',
       'MyItem',
       stripTight`
@@ -614,7 +638,7 @@ class CurlyScopeTest extends CurlyTest {
       });
     }
 
-    this.render(
+    this.render.template(
       stripTight`
         <article>{{#each this.items key="id" as |item|}}
           <MyItem @item={{item}} />
@@ -634,9 +658,9 @@ class CurlyScopeTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'correct scope - complex yield'() {
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'item-list',
       stripTight`
@@ -654,7 +678,7 @@ class CurlyScopeTest extends CurlyTest {
       { id: '3', name: 'Baz', description: 'Baz!' },
     ];
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#item-list items=this.items as |item|}}
           {{item.name}}{{#if this.showDescription}} - {{item.description}}{{/if}}
@@ -687,21 +711,21 @@ class CurlyScopeTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'correct scope - self'() {
     class FooBar extends GlimmerishComponent {
       public foo = 'foo';
       public bar = 'bar';
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       `<p>{{this.foo}} {{this.bar}} {{@baz}}</p>`,
       FooBar
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           <FooBar />
@@ -724,15 +748,17 @@ class CurlyScopeTest extends CurlyTest {
 class CurlyDynamicScopeSmokeTest extends CurlyTest {
   static suiteName = '[curly components] dynamicScope access smoke test';
 
-  @test
+  @render
   'component has access to dynamic scope'() {
     class SampleComponent extends EmberishCurlyComponent {
       static fromDynamicScope = ['theme'];
     }
 
-    this.registerComponent('Curly', 'sample-component', '{{this.theme}}', SampleComponent);
+    this.register.component('Curly', 'sample-component', '{{this.theme}}', SampleComponent);
 
-    this.render('{{#-with-dynamic-vars theme="light"}}{{sample-component}}{{/-with-dynamic-vars}}');
+    this.render.template(
+      '{{#-with-dynamic-vars theme="light"}}{{sample-component}}{{/-with-dynamic-vars}}'
+    );
 
     this.assertEmberishElement('div', 'light');
   }
@@ -741,38 +767,38 @@ class CurlyDynamicScopeSmokeTest extends CurlyTest {
 class CurlyPositionalArgsTest extends CurlyTest {
   static suiteName = '[curly components] positional arguments';
 
-  @test
+  @render
   'static named positional parameters'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['person', 'age'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{this.person}}{{this.age}}',
       SampleComponent
     );
 
-    this.render('{{sample-component "Quint" 4}}');
+    this.render.template('{{sample-component "Quint" 4}}');
 
     this.assertEmberishElement('div', 'Quint4');
   }
 
-  @test
+  @render
   'dynamic named positional parameters'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['person', 'age'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{this.person}}{{this.age}}',
       SampleComponent
     );
 
-    this.render('{{sample-component this.myName this.myAge}}', {
+    this.render.template('{{sample-component this.myName this.myAge}}', {
       myName: 'Quint',
       myAge: 4,
     });
@@ -787,36 +813,36 @@ class CurlyPositionalArgsTest extends CurlyTest {
     this.assertEmberishElement('div', 'Edward5');
   }
 
-  @test
+  @render
   'if a value is passed as a non-positional parameter, it takes precedence over the named one'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['name'];
     }
 
-    this.registerComponent('Curly', 'sample-component', '{{this.name}}', SampleComponent);
+    this.register.component('Curly', 'sample-component', '{{this.name}}', SampleComponent);
 
     assert.throws(() => {
-      this.render('{{sample-component this.notMyName name=this.myName}}', {
+      this.render.template('{{sample-component this.notMyName name=this.myName}}', {
         myName: 'Quint',
         notMyName: 'Sergio',
       });
     }, 'You cannot specify both a positional param (at position 0) and the hash argument `name`.');
   }
 
-  @test
+  @render
   'static arbitrary number of positional parameters'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = 'names';
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{#each this.names key="@index" as |name|}}{{name}}{{/each}}',
       SampleComponent
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         {{sample-component "Foo" 4 "Bar"}}
         {{sample-component "Foo" 4 "Bar" 5 "Baz"}}
@@ -836,13 +862,13 @@ class CurlyPositionalArgsTest extends CurlyTest {
     assertElementIsEmberishElement(second, 'div', 'Foo4Bar5Baz');
   }
 
-  @test
+  @render
   'arbitrary positional parameter conflict with hash parameter is reported'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['names'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{#each this.attrs.names key="@index" as |name|}}{{name}}{{/each}}',
@@ -850,46 +876,46 @@ class CurlyPositionalArgsTest extends CurlyTest {
     );
 
     assert.throws(() => {
-      this.render('{{sample-component "Foo" 4 "Bar" names=this.numbers id="args-3"}}', {
+      this.render.template('{{sample-component "Foo" 4 "Bar" names=this.numbers id="args-3"}}', {
         numbers: [1, 2, 3],
       });
     }, `You cannot specify positional parameters and the hash argument \`names\`.`);
   }
 
-  @test
+  @render
   'can use hash parameter instead of arbitrary positional param [GH #12444]'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['names'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{#each this.names key="@index" as |name|}}{{name}}{{/each}}',
       SampleComponent
     );
 
-    this.render('{{sample-component names=this.things}}', {
+    this.render.template('{{sample-component names=this.things}}', {
       things: ['Foo', 4, 'Bar'],
     });
 
     this.assertEmberishElement('div', 'Foo4Bar');
   }
 
-  @test
+  @render
   'can use hash parameter instead of positional param'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['first', 'second'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{this.first}} - {{this.second}}',
       SampleComponent
     );
 
-    this.render(
+    this.render.template(
       stripTight`
           {{sample-component "one" "two"}}
           {{sample-component "one" second="two"}}
@@ -909,20 +935,20 @@ class CurlyPositionalArgsTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'dynamic arbitrary number of positional parameters'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = 'n';
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       '{{#each this.attrs.n key="@index" as |name|}}{{name}}{{/each}}',
       SampleComponent
     );
 
-    this.render('{{sample-component this.user1 this.user2}}', {
+    this.render.template('{{sample-component this.user1 this.user2}}', {
       user1: 'Foo',
       user2: 4,
     });
@@ -943,20 +969,20 @@ class CurlyPositionalArgsTest extends CurlyTest {
     this.assertEmberishElement('div', 'Bar6');
   }
 
-  @test
+  @render
   '{{component}} helper works with positional params'() {
     class SampleComponent extends EmberishCurlyComponent {
       static override positionalParams = ['name', 'age'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'sample-component',
       `{{this.attrs.name}}{{this.attrs.age}}`,
       SampleComponent
     );
 
-    this.render(`{{component "sample-component" this.myName this.myAge}}`, {
+    this.render.template(`{{component "sample-component" this.myName this.myAge}}`, {
       myName: 'Quint',
       myAge: 4,
     });
@@ -982,12 +1008,12 @@ class CurlyPositionalArgsTest extends CurlyTest {
 class CurlyClosureComponentsTest extends CurlyTest {
   static suiteName = '[curly components] closure components';
 
-  @test
+  @render
   'component helper can handle aliased block components with args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', 'Hello {{this.arg1}} {{yield}}');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', 'Hello {{this.arg1}} {{yield}}');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#with (hash comp=(component 'foo-bar')) as |my|}}
           {{#component my.comp arg1="World!"}}Test1{{/component}} Test2
@@ -998,12 +1024,12 @@ class CurlyClosureComponentsTest extends CurlyTest {
     this.assertHTML('<div id="ember1" class="ember-view">Hello World! Test1</div> Test2');
   }
 
-  @test
+  @render
   'component helper can handle aliased block components without args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', 'Hello {{yield}}');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', 'Hello {{yield}}');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#with (hash comp=(component 'foo-bar')) as |my|}}
           {{#component my.comp}}World!{{/component}} Test
@@ -1014,12 +1040,12 @@ class CurlyClosureComponentsTest extends CurlyTest {
     this.assertHTML('<div id="ember1" class="ember-view">Hello World!</div> Test');
   }
 
-  @test
+  @render
   'component helper can handle aliased inline components with args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', 'Hello {{this.arg1}}');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', 'Hello {{this.arg1}}');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#with (hash comp=(component 'foo-bar')) as |my|}}
           {{component my.comp arg1="World!"}} Test
@@ -1030,12 +1056,12 @@ class CurlyClosureComponentsTest extends CurlyTest {
     this.assertHTML('<div id="ember1" class="ember-view">Hello World!</div> Test');
   }
 
-  @test
+  @render
   'component helper can handle aliased inline components without args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', 'Hello');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', 'Hello');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#with (hash comp=(component 'foo-bar')) as |my|}}
           {{component my.comp}} World!
@@ -1046,13 +1072,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     this.assertHTML('<div id="ember2" class="ember-view">Hello</div> World!');
   }
 
-  @test
+  @render
   'component helper can handle higher order inline components with args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
-    this.registerComponent('Curly', 'baz-bar', 'Hello {{this.arg1}}');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
+    this.register.component('Curly', 'baz-bar', 'Hello {{this.arg1}}');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#foo-bar as |my|}}
           {{component my.comp arg1="World!"}} Test
@@ -1065,13 +1091,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'component helper can handle higher order inline components without args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
-    this.registerComponent('Curly', 'baz-bar', 'Hello');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
+    this.register.component('Curly', 'baz-bar', 'Hello');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#foo-bar as |my|}}
           {{component my.comp}} World!
@@ -1084,13 +1110,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'component helper can handle higher order block components with args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
-    this.registerComponent('Curly', 'baz-bar', 'Hello {{this.arg1}} {{yield}}');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
+    this.register.component('Curly', 'baz-bar', 'Hello {{this.arg1}} {{yield}}');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#foo-bar as |my|}}
           {{#component my.comp arg1="World!"}}Test1{{/component}} Test2
@@ -1103,13 +1129,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'component helper can handle higher order block components without args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
-    this.registerComponent('Curly', 'baz-bar', 'Hello {{this.arg1}} {{yield}}');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
+    this.register.component('Curly', 'baz-bar', 'Hello {{this.arg1}} {{yield}}');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#foo-bar as |my|}}
           {{#component my.comp}}World!{{/component}} Test
@@ -1122,12 +1148,12 @@ class CurlyClosureComponentsTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'component deopt can handle aliased inline components without args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', 'Hello');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', 'Hello');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#with (hash comp=(component 'foo-bar')) as |my|}}
           {{my.comp}} World!
@@ -1138,13 +1164,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     this.assertHTML('<div id="ember1" class="ember-view">Hello</div> World!');
   }
 
-  @test
+  @render
   'component deopt can handle higher order inline components without args'() {
-    this.registerHelper('hash', (_positional, named) => named);
-    this.registerComponent('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
-    this.registerComponent('Curly', 'baz-bar', 'Hello');
+    this.register.helper('hash', (_positional, named) => named);
+    this.register.component('Curly', 'foo-bar', '{{yield (hash comp=(component "baz-bar"))}}');
+    this.register.component('Curly', 'baz-bar', 'Hello');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#foo-bar as |my|}}
           {{my.comp}} World!
@@ -1157,13 +1183,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'component helper can curry arguments'() {
     class FooBarComponent extends EmberishCurlyComponent {
       static override positionalParams = ['one', 'two', 'three', 'four', 'five', 'six'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'foo-bar',
       stripTight`
@@ -1186,7 +1212,7 @@ class CurlyClosureComponentsTest extends CurlyTest {
       FooBarComponent
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#with (component "foo-bar" "outer 1" "outer 2" a="outer a" b="outer b" c="outer c" e="outer e") as |outer|}}
           {{#with (component outer "inner 1" a="inner a" d="inner d" e="inner e") as |inner|}}
@@ -1217,13 +1243,13 @@ class CurlyClosureComponentsTest extends CurlyTest {
     `);
   }
 
-  @test
+  @render
   'component helper: currying works inline'() {
     class FooBarComponent extends EmberishCurlyComponent {
       static override positionalParams = ['one', 'two', 'three', 'four', 'five', 'six'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'foo-bar',
       stripTight`
@@ -1237,7 +1263,7 @@ class CurlyClosureComponentsTest extends CurlyTest {
       FooBarComponent
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         {{component (component (component 'foo-bar' this.foo.first this.foo.second) 'inner 1') 'invocation 1' 'invocation 2'}}
       `,
@@ -1265,11 +1291,11 @@ class CurlyClosureComponentsTest extends CurlyTest {
 class CurlyIdsTest extends CurlyTest {
   static suiteName = '[curly components] ids';
 
-  @test
+  @render
   'emberish curly component should have unique IDs'() {
-    this.registerComponent('Curly', 'x-curly', '');
+    this.register.component('Curly', 'x-curly', '');
 
-    this.render(
+    this.render.template(
       stripTight`
         {{x-curly}}
         {{x-curly}}
@@ -1335,24 +1361,24 @@ class CurlyIdsTest extends CurlyTest {
 class CurlyGlimmerComponentTest extends CurlyTest {
   static suiteName = '[curly components] glimmer components';
 
-  @test
+  @render
   'NonBlock without attributes replaced with a div'() {
-    this.registerComponent('Glimmer', 'NonBlock', '<div ...attributes>In layout</div>');
+    this.register.component('Glimmer', 'NonBlock', '<div ...attributes>In layout</div>');
 
-    this.render('<NonBlock />');
+    this.render.template('<NonBlock />');
     this.assertHTML('<div>In layout</div>');
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'NonBlock with attributes replaced with a div'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'NonBlock',
       '<div such="{{@stability}}" ...attributes>In layout</div>'
     );
 
-    this.render('<NonBlock @stability={{this.stability}} />', { stability: 'stability' });
+    this.render.template('<NonBlock @stability={{this.stability}} />', { stability: 'stability' });
     this.assertHTML('<div such="stability">In layout</div>');
 
     this.rerender({
@@ -1363,29 +1389,29 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'NonBlock without attributes replaced with a web component'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'NonBlock',
       '<not-an-ember-component ...attributes>In layout</not-an-ember-component>'
     );
 
-    this.render('<NonBlock />');
+    this.render.template('<NonBlock />');
 
     this.assertHTML('<not-an-ember-component>In layout</not-an-ember-component>');
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'NonBlock with attributes replaced with a web component'() {
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'NonBlock',
       '<not-an-ember-component such="{{@stability}}" ...attributes>In layout</not-an-ember-component>'
     );
 
-    this.render('<NonBlock @stability={{this.stability}} />', { stability: 'stability' });
+    this.render.template('<NonBlock @stability={{this.stability}} />', { stability: 'stability' });
     this.assertHTML('<not-an-ember-component such="stability">In layout</not-an-ember-component>');
 
     this.rerender({
@@ -1396,24 +1422,24 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'Ensure components can be invoked'() {
-    this.registerComponent('Glimmer', 'Outer', `<Inner></Inner>`);
-    this.registerComponent('Glimmer', 'Inner', `<div ...attributes>hi!</div>`);
+    this.register.component('Glimmer', 'Outer', `<Inner></Inner>`);
+    this.register.component('Glimmer', 'Inner', `<div ...attributes>hi!</div>`);
 
-    this.render('<Outer />');
+    this.render.template('<Outer />');
     this.assertHTML('<div>hi!</div>');
   }
 
-  @test
+  @render
   'Custom element with element modifier'() {
-    this.registerModifier('foo', class {});
+    this.register.modifier('foo', class {});
 
-    this.render('<some-custom-element {{foo "foo"}}></some-custom-element>');
+    this.render.template('<some-custom-element {{foo "foo"}}></some-custom-element>');
     this.assertHTML('<some-custom-element></some-custom-element>');
   }
 
-  @test
+  @render
   'Curly component hooks (with attrs)'() {
     let instance: (NonBlock & HookedComponent) | undefined;
 
@@ -1423,14 +1449,14 @@ class CurlyGlimmerComponentTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'non-block',
       'In layout - someProp: {{@someProp}}',
       inspectHooks(NonBlock as unknown as EmberishCurlyComponentFactory)
     );
 
-    this.render('{{non-block someProp=this.someProp}}', { someProp: 'wycats' });
+    this.render.template('{{non-block someProp=this.someProp}}', { someProp: 'wycats' });
 
     assert.ok(instance, 'instance is created');
 
@@ -1466,7 +1492,7 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     assertFired(instance, 'didRender', 3);
   }
 
-  @test
+  @render
   'Curly component hooks (attrs as self props)'() {
     let instance: (NonBlock & HookedComponent) | undefined;
 
@@ -1476,14 +1502,14 @@ class CurlyGlimmerComponentTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'non-block',
       'In layout - someProp: {{this.someProp}}',
       inspectHooks(NonBlock as any)
     );
 
-    this.render('{{non-block someProp=this.someProp}}', { someProp: 'wycats' });
+    this.render.template('{{non-block someProp=this.someProp}}', { someProp: 'wycats' });
 
     assert.ok(instance, 'instance is created');
 
@@ -1519,7 +1545,7 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     assertFired(instance, 'didRender', 3);
   }
 
-  @test
+  @render
   'Setting value attributeBinding to null results in empty string value'() {
     let instance: InputComponent | undefined;
 
@@ -1533,14 +1559,14 @@ class CurlyGlimmerComponentTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'input-component',
       'input component',
       inspectHooks(InputComponent as any)
     );
 
-    this.render('{{input-component value=this.someProp}}', { someProp: null });
+    this.render.template('{{input-component value=this.someProp}}', { someProp: null });
 
     assert.ok(instance, 'instance is created');
 
@@ -1565,7 +1591,7 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     assert.strictEqual(element.value, '');
   }
 
-  @test
+  @render
   'Setting class attributeBinding does not clobber ember-view'() {
     let instance: FooBarComponent | undefined;
 
@@ -1578,9 +1604,9 @@ class CurlyGlimmerComponentTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'foo-bar', 'FOO BAR', FooBarComponent);
+    this.register.component('Curly', 'foo-bar', 'FOO BAR', FooBarComponent);
 
-    this.render('{{foo-bar class=this.classes}}', { classes: 'foo bar' });
+    this.render.template('{{foo-bar class=this.classes}}', { classes: 'foo bar' });
 
     assert.ok(instance, 'instance is created');
 
@@ -1607,7 +1633,7 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     this.assertEmberishElement('div', { class: classes('ember-view foo bar') }, 'FOO BAR');
   }
 
-  @test
+  @render
   'Curly component hooks (force recompute)'() {
     let instance: (NonBlock & HookedComponent) | undefined;
 
@@ -1617,14 +1643,14 @@ class CurlyGlimmerComponentTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'non-block',
       'In layout - someProp: {{@someProp}}',
       inspectHooks(NonBlock as any)
     );
 
-    this.render('{{non-block someProp="wycats"}}');
+    this.render.template('{{non-block someProp="wycats"}}');
 
     assert.ok(instance, 'instance is created');
 
@@ -1659,11 +1685,11 @@ class CurlyGlimmerComponentTest extends CurlyTest {
     assertFired(instance, 'didRender', 2);
   }
 
-  @test
+  @render
   'Can use named argument @component (e.g. `{{@component.name}}`) emberjs/ember.js#19313'() {
-    this.registerComponent('Glimmer', 'Outer', '{{@component.name}}');
+    this.register.component('Glimmer', 'Outer', '{{@component.name}}');
 
-    this.render('<Outer @component={{hash name="Foo"}} />');
+    this.render.template('<Outer @component={{hash name="Foo"}} />');
     this.assertHTML('Foo');
 
     this.rerender();
@@ -1676,7 +1702,7 @@ class CurlyGlimmerComponentTest extends CurlyTest {
 class CurlyTeardownTest extends CurlyTest {
   static suiteName = '[curly components] teardown';
 
-  @test
+  @render
   'curly components are destroyed'() {
     let willDestroy = 0;
     let destroyed = 0;
@@ -1693,9 +1719,9 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'destroy-me', 'destroy me!', DestroyMeComponent);
+    this.register.component('Curly', 'destroy-me', 'destroy me!', DestroyMeComponent);
 
-    this.render(`{{#if this.cond}}{{destroy-me}}{{/if}}`, { cond: true });
+    this.render.template(`{{#if this.cond}}{{destroy-me}}{{/if}}`, { cond: true });
 
     assert.strictEqual(willDestroy, 0, 'destroy should not be called');
     assert.strictEqual(destroyed, 0, 'destroy should not be called');
@@ -1706,7 +1732,7 @@ class CurlyTeardownTest extends CurlyTest {
     assert.strictEqual(destroyed, 1, 'destroy should be called exactly one');
   }
 
-  @test
+  @render
   'glimmer components are destroyed'() {
     let destroyed = 0;
 
@@ -1717,14 +1743,14 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'DestroyMe',
       '<div ...attributes>destroy me!</div>',
       DestroyMeComponent
     );
 
-    this.render(`{{#if this.cond}}<DestroyMe />{{/if}}`, { cond: true });
+    this.render.template(`{{#if this.cond}}<DestroyMe />{{/if}}`, { cond: true });
 
     assert.strictEqual(destroyed, 0, 'destroy should not be called');
 
@@ -1733,7 +1759,7 @@ class CurlyTeardownTest extends CurlyTest {
     assert.strictEqual(destroyed, 1, 'destroy should be called exactly one');
   }
 
-  @test
+  @render
   'component helpers component are destroyed'() {
     let destroyed = 0;
 
@@ -1744,13 +1770,13 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'destroy-me', 'destroy me!', DestroyMeComponent);
+    this.register.component('Curly', 'destroy-me', 'destroy me!', DestroyMeComponent);
 
     class AnotherComponent extends EmberishCurlyComponent {}
 
-    this.registerComponent('Curly', 'another-component', 'another thing!', AnotherComponent);
+    this.register.component('Curly', 'another-component', 'another thing!', AnotherComponent);
 
-    this.render(`{{component this.componentName}}`, { componentName: 'destroy-me' });
+    this.render.template(`{{component this.componentName}}`, { componentName: 'destroy-me' });
 
     assert.strictEqual(destroyed, 0, 'destroy should not be called');
 
@@ -1759,7 +1785,7 @@ class CurlyTeardownTest extends CurlyTest {
     assert.strictEqual(destroyed, 1, 'destroy should be called exactly one');
   }
 
-  @test
+  @render
   'components inside a list are destroyed'() {
     let destroyed: unknown[] = [];
 
@@ -1770,9 +1796,9 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'DestroyMe', '<div>destroy me!</div>', DestroyMeComponent);
+    this.register.component('Curly', 'DestroyMe', '<div>destroy me!</div>', DestroyMeComponent);
 
-    this.render(`{{#each this.list as |item|}}<DestroyMe @item={{item}} />{{/each}}`, {
+    this.render.template(`{{#each this.list as |item|}}<DestroyMe @item={{item}} />{{/each}}`, {
       list: [1, 2, 3, 4, 5],
     });
 
@@ -1791,7 +1817,7 @@ class CurlyTeardownTest extends CurlyTest {
     assert.deepEqual(destroyed, [4, 5, 1, 2, 3], 'destroy should be called for each item');
   }
 
-  @test
+  @render
   'components inside a list are destroyed (when key is @identity)'() {
     let destroyed: unknown[] = [];
 
@@ -1802,7 +1828,7 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'DestroyMe', '<div>destroy me!</div>', DestroyMeComponent);
+    this.register.component('Curly', 'DestroyMe', '<div>destroy me!</div>', DestroyMeComponent);
 
     let val1 = { val: 1 };
     let val2 = { val: 2 };
@@ -1810,7 +1836,7 @@ class CurlyTeardownTest extends CurlyTest {
     let val4 = { val: 4 };
     let val5 = { val: 5 };
 
-    this.render(
+    this.render.template(
       `{{#each this.list key='@identity' as |item|}}<DestroyMe @item={{item}} />{{/each}}`,
       {
         list: [val1, val2, val3, val4, val5],
@@ -1836,7 +1862,7 @@ class CurlyTeardownTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'components that are "destroyed twice" are destroyed once'() {
     let destroyed: string[] = [];
 
@@ -1854,18 +1880,21 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'destroy-me',
       '{{#if @cond}}{{destroy-me-inner from="inner"}}{{/if}}',
       DestroyMeComponent
     );
-    this.registerComponent('Curly', 'destroy-me-inner', 'inner', DestroyMe2Component);
+    this.register.component('Curly', 'destroy-me-inner', 'inner', DestroyMe2Component);
 
-    this.render(`{{#if this.cond}}{{destroy-me from="root" cond=this.child.cond}}{{/if}}`, {
-      cond: true,
-      child: { cond: true },
-    });
+    this.render.template(
+      `{{#if this.cond}}{{destroy-me from="root" cond=this.child.cond}}{{/if}}`,
+      {
+        cond: true,
+        child: { cond: true },
+      }
+    );
 
     assert.deepEqual(destroyed, [], 'destroy should not be called');
 
@@ -1878,7 +1907,7 @@ class CurlyTeardownTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'deeply nested destructions'() {
     let destroyed: string[] = [];
 
@@ -1896,15 +1925,15 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'DestroyMe1',
       '<div>{{#destroy-me2 item=@item from="destroy-me1"}}{{yield}}{{/destroy-me2}}</div>',
       DestroyMe1Component
     );
-    this.registerComponent('Curly', 'destroy-me2', 'Destroy me! {{yield}}', DestroyMe2Component);
+    this.register.component('Curly', 'destroy-me2', 'Destroy me! {{yield}}', DestroyMe2Component);
 
-    this.render(
+    this.render.template(
       `{{#each this.list key='@identity' as |item|}}<DestroyMe1 @item={{item}}>{{#destroy-me2 from="root" item=item}}{{/destroy-me2}}</DestroyMe1>{{/each}}`,
       { list: [1, 2, 3, 4, 5] }
     );
@@ -1951,7 +1980,7 @@ class CurlyTeardownTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'components inside the root are destroyed when the render result is destroyed'() {
     let glimmerDestroyed = false;
     let curlyDestroyed = false;
@@ -1970,10 +1999,10 @@ class CurlyTeardownTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Glimmer', 'DestroyMe1', '<div>Destry me!</div>', DestroyMe1Component);
-    this.registerComponent('Curly', 'destroy-me2', 'Destroy me too!', DestroyMe2Component);
+    this.register.component('Glimmer', 'DestroyMe1', '<div>Destry me!</div>', DestroyMe1Component);
+    this.register.component('Curly', 'destroy-me2', 'Destroy me too!', DestroyMe2Component);
 
-    this.render(`<DestroyMe1 id="destroy-me1"/>{{destroy-me2 id="destroy-me2"}}`);
+    this.render.template(`<DestroyMe1 id="destroy-me1"/>{{destroy-me2 id="destroy-me2"}}`);
 
     assert.strictEqual(glimmerDestroyed, false, 'the glimmer component should not be destroyed');
     assert.strictEqual(curlyDestroyed, false, 'the curly component should not be destroyed');
@@ -2001,11 +2030,11 @@ class CurlyTeardownTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'tagless components render properly'() {
-    this.registerComponent('TemplateOnly', 'foo-bar', `Michael Jordan says "Go Tagless"`);
+    this.register.component('TemplateOnly', 'foo-bar', `Michael Jordan says "Go Tagless"`);
 
-    this.render(`{{foo-bar}}`);
+    this.render.template(`{{foo-bar}}`);
     this.assertHTML('Michael Jordan says "Go Tagless"');
     this.assertStableRerender();
   }
@@ -2014,17 +2043,17 @@ class CurlyTeardownTest extends CurlyTest {
 class CurlyLateLayoutTest extends CurlyTest {
   static suiteName = '[curly component] late bound layout';
 
-  declare delegate: JitRenderDelegate;
+  declare delegate: ClientSideRenderDelegate;
 
-  @test
+  @render
   'can bind the layout late'() {
     class FooBar extends EmberishCurlyComponent {
       override layout = createTemplate('Swap - {{yield}}')(undefined);
     }
 
-    this.delegate.registerComponent('Curly', 'Curly', 'foo-bar', null, FooBar);
+    this.register.component('Curly', 'foo-bar', null, FooBar);
 
-    this.render('{{#foo-bar}}YIELD{{/foo-bar}}');
+    this.render.template('{{#foo-bar}}YIELD{{/foo-bar}}');
 
     equalsElement(
       this.element.firstChild,
@@ -2042,15 +2071,15 @@ class CurlyLateLayoutTest extends CurlyTest {
 class CurlyAppendableTest extends CurlyTest {
   static suiteName = '[curly component] appendable components';
 
-  declare delegate: JitRenderDelegate;
+  declare delegate: ClientSideRenderDelegate;
 
-  @test
+  @render
   'it does not work on optimized appends'() {
-    this.registerComponent('Curly', 'foo-bar', 'foo bar');
+    this.register.component('Curly', 'foo-bar', 'foo bar');
 
     let definition = this.delegate.createCurriedComponent('foo-bar');
 
-    this.render('{{this.foo}}', { foo: definition });
+    this.render.template('{{this.foo}}', { foo: definition });
     this.assertEmberishElement('div', {}, 'foo bar');
     this.assertStableRerender();
 
@@ -2061,13 +2090,13 @@ class CurlyAppendableTest extends CurlyTest {
     this.assertEmberishElement('div', {}, 'foo bar');
   }
 
-  @test
+  @render
   'it works on unoptimized appends (dot paths)'() {
-    this.registerComponent('Curly', 'foo-bar', 'foo bar');
+    this.register.component('Curly', 'foo-bar', 'foo bar');
 
     let definition = this.delegate.createCurriedComponent('foo-bar');
 
-    this.render('{{this.foo.bar}}', { foo: { bar: definition } });
+    this.render.template('{{this.foo.bar}}', { foo: { bar: definition } });
     this.assertEmberishElement('div', {}, 'foo bar');
     this.assertStableRerender();
 
@@ -2082,13 +2111,13 @@ class CurlyAppendableTest extends CurlyTest {
     this.assertEmberishElement('div', {}, 'foo bar');
   }
 
-  @test
+  @render
   'it works on unoptimized appends (this paths)'() {
-    this.registerComponent('Curly', 'foo-bar', 'foo bar');
+    this.register.component('Curly', 'foo-bar', 'foo bar');
 
     let definition = this.delegate.createCurriedComponent('foo-bar');
 
-    this.render('{{this.foo}}', { foo: definition });
+    this.render.template('{{this.foo}}', { foo: definition });
     this.assertEmberishElement('div', {}, 'foo bar');
     this.assertStableRerender();
 
@@ -2103,13 +2132,13 @@ class CurlyAppendableTest extends CurlyTest {
     this.assertEmberishElement('div', {}, 'foo bar');
   }
 
-  @test
+  @render
   'it works on unoptimized appends when initially not a component (dot paths)'() {
-    this.registerComponent('Curly', 'foo-bar', 'foo bar');
+    this.register.component('Curly', 'foo-bar', 'foo bar');
 
     let definition = this.delegate.createCurriedComponent('foo-bar');
 
-    this.render('{{this.foo.bar}}', { foo: { bar: 'lol' } });
+    this.render.template('{{this.foo.bar}}', { foo: { bar: 'lol' } });
     this.assertHTML('lol');
     this.assertStableRerender();
 
@@ -2121,13 +2150,13 @@ class CurlyAppendableTest extends CurlyTest {
     this.assertHTML('lol');
   }
 
-  @test
+  @render
   'it works on unoptimized appends when initially not a component (this paths)'() {
-    this.registerComponent('Curly', 'foo-bar', 'foo bar');
+    this.register.component('Curly', 'foo-bar', 'foo bar');
 
     let definition = this.delegate.createCurriedComponent('foo-bar');
 
-    this.render('{{this.foo}}', { foo: 'lol' });
+    this.render.template('{{this.foo}}', { foo: 'lol' });
     this.assertHTML('lol');
     this.assertStableRerender();
 
@@ -2143,7 +2172,7 @@ class CurlyAppendableTest extends CurlyTest {
 class CurlyBoundsTrackingTest extends CurlyTest {
   static suiteName = '[curly components] bounds tracking';
 
-  @test
+  @render
   'it works for wrapped (curly) components'() {
     let instance = this.capture<FooBar>();
 
@@ -2156,9 +2185,9 @@ class CurlyBoundsTrackingTest extends CurlyTest {
       }
     }
 
-    this.registerComponent('Curly', 'foo-bar', 'foo bar', FooBar);
+    this.register.component('Curly', 'foo-bar', 'foo bar', FooBar);
 
-    this.render('zomg {{foo-bar}} wow');
+    this.render.template('zomg {{foo-bar}} wow');
 
     assert.ok(instance, 'instance is created');
 
@@ -2178,7 +2207,7 @@ class CurlyBoundsTrackingTest extends CurlyTest {
     assert.strictEqual(bounds.lastNode(), castToSimple(element));
   }
 
-  @test
+  @render
   'it works for tagless components'() {
     let instance = this.capture<FooBar>();
 
@@ -2191,14 +2220,14 @@ class CurlyBoundsTrackingTest extends CurlyTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Curly',
       'foo-bar',
       '<span id="first-node">foo</span> <span id="before-last-node">bar</span>!',
       FooBar
     );
 
-    this.render('zomg {{foo-bar}} wow');
+    this.render.template('zomg {{foo-bar}} wow');
 
     this.assertHTML(
       'zomg <span id="first-node">foo</span> <span id="before-last-node">bar</span>! wow'
@@ -2220,16 +2249,17 @@ class CurlyBoundsTrackingTest extends CurlyTest {
     );
   }
 
-  @test
+  @render
   'A curly component can have an else block'() {
-    this.registerComponent('Curly', 'render-else', `{{yield to="inverse"}}`);
+    this.register.component('Curly', 'render-else', `{{yield to="inverse"}}`);
 
-    this.render('{{#render-else}}Nope{{else}}<div id="test">123</div>{{/render-else}}');
+    this.render.template('{{#render-else}}Nope{{else}}<div id="test">123</div>{{/render-else}}');
     this.assertHTML('<div id="ember1" class="ember-view"><div id="test">123</div></div>');
     this.assertStableRerender();
   }
 }
 
+jitSuite(ErrorRecoverySuite);
 jitSuite(CurlyCreateTest);
 jitSuite(CurlyDynamicComponentTest);
 jitSuite(CurlyDynamicCustomizationTest);
diff --git a/packages/@glimmer-workspace/integration-tests/test/helpers/array-test.ts b/packages/@glimmer-workspace/integration-tests/test/helpers/array-test.ts
index e78c73bd07..099bf95461 100644
--- a/packages/@glimmer-workspace/integration-tests/test/helpers/array-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/helpers/array-test.ts
@@ -1,11 +1,18 @@
-import { GlimmerishComponent, jitSuite, RenderTest, strip, test, tracked } from '../..';
-
-class ArrayTest extends RenderTest {
+import {
+  GlimmerishComponent,
+  jitSuite,
+  RenderTestContext,
+  strip,
+  test,
+  tracked,
+} from '@glimmer-workspace/integration-tests';
+
+class ArrayTest extends RenderTestContext {
   static suiteName = 'Helpers test: {{array}}';
 
   @test
   'returns an array'() {
-    this.render(strip`
+    this.render.template(strip`
     {{#with (array "Sergio") as |people|}}
       {{#each people as |personName|}}
         {{personName}}
@@ -19,7 +26,7 @@ class ArrayTest extends RenderTest {
 
   @test
   'can have more than one value'() {
-    this.render(strip`
+    this.render.template(strip`
     {{#with (array "Sergio" "Robert") as |people|}}
       {{#each people as |personName|}}
         {{personName}},
@@ -33,7 +40,7 @@ class ArrayTest extends RenderTest {
 
   @test
   'binds values when variables are used'() {
-    this.render(
+    this.render.template(
       strip`{{#with (array this.personOne) as |people|}}
             {{#each people as |personName|}}
               {{personName}}
@@ -57,7 +64,7 @@ class ArrayTest extends RenderTest {
 
   @test
   'binds multiple values when variables are used'() {
-    this.render(
+    this.render.template(
       strip`{{#with (array this.personOne this.personTwo) as |people|}}
             {{#each people as |personName|}}
               {{personName}},
@@ -87,7 +94,7 @@ class ArrayTest extends RenderTest {
 
   @test
   'array helpers can be nested'() {
-    this.render(
+    this.render.template(
       strip`
         {{#let (array (array this.personOne this.personTwo)) as |listOfPeople|}}
           {{#each listOfPeople as |people|}}
@@ -137,14 +144,14 @@ class ArrayTest extends RenderTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       '{{yield (hash people=(array this.personOne))}}',
       FooBar
     );
 
-    this.render(
+    this.render.template(
       strip`
         <FooBar as |values|>
           {{#each values.people as |personName|}}
@@ -184,14 +191,14 @@ class ArrayTest extends RenderTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       `{{yield (hash people=(array this.personOne @personTwo))}}`,
       FooBar
     );
 
-    this.render(
+    this.render.template(
       strip`
         <FooBar @personTwo={{this.model.personTwo}} as |values|>
           {{#each values.people as |personName|}}
@@ -221,7 +228,7 @@ class ArrayTest extends RenderTest {
 
   @test
   'should render when passing as argument to a component invocation'() {
-    this.registerComponent(
+    this.register.component(
       'TemplateOnly',
       'FooBar',
       strip`
@@ -231,7 +238,9 @@ class ArrayTest extends RenderTest {
       `
     );
 
-    this.render(strip`<FooBar @people={{array "Tom" this.personTwo}}/>`, { personTwo: 'Chad' });
+    this.render.template(strip`<FooBar @people={{array "Tom" this.personTwo}}/>`, {
+      personTwo: 'Chad',
+    });
 
     this.assertHTML('Tom,Chad,');
 
@@ -261,7 +270,7 @@ class ArrayTest extends RenderTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       strip`
@@ -272,7 +281,9 @@ class ArrayTest extends RenderTest {
       FooBar
     );
 
-    this.render(strip`<FooBar @people={{array "Tom" this.personTwo}}/>`, { personTwo: 'Chad' });
+    this.render.template(strip`<FooBar @people={{array "Tom" this.personTwo}}/>`, {
+      personTwo: 'Chad',
+    });
 
     let firstArray = fooBarInstance!.args['people'];
 
@@ -288,12 +299,12 @@ class ArrayTest extends RenderTest {
   'capture array values in JS to assert deep equal'() {
     let captured;
 
-    this.registerHelper('capture', function ([array]) {
+    this.register.helper('capture', ([array]) => {
       captured = array;
       return 'captured';
     });
 
-    this.render(`{{capture (array 'Tom' this.personTwo)}}`, { personTwo: 'Godfrey' });
+    this.render.template(`{{capture (array 'Tom' this.personTwo)}}`, { personTwo: 'Godfrey' });
 
     this.assert.deepEqual(captured, ['Tom', 'Godfrey']);
 
@@ -308,7 +319,7 @@ class ArrayTest extends RenderTest {
 
   @test
   'GH18693 properties in hash can be accessed from the array'() {
-    this.render(strip`
+    this.render.template(strip`
       {{#each (array (hash some="thing")) as |item|}}
         {{item.some}}
       {{/each}}
diff --git a/packages/@glimmer-workspace/integration-tests/test/helpers/concat-test.ts b/packages/@glimmer-workspace/integration-tests/test/helpers/concat-test.ts
index 7019c7a299..1e6d590e4d 100644
--- a/packages/@glimmer-workspace/integration-tests/test/helpers/concat-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/helpers/concat-test.ts
@@ -1,17 +1,17 @@
-import { jitSuite, RenderTest, test } from '../..';
+import { jitSuite, RenderTestContext, test } from '@glimmer-workspace/integration-tests';
 
-class ConcatTest extends RenderTest {
+class ConcatTest extends RenderTestContext {
   static suiteName = 'Helpers test: {{concat}}';
 
   @test
   'it concats static arguments'() {
-    this.render(`{{concat "foo" " " "bar" " " "baz"}}`);
+    this.render.template(`{{concat "foo" " " "bar" " " "baz"}}`);
     this.assertHTML('foo bar baz');
   }
 
   @test
   'it updates for bound arguments'() {
-    this.render(`{{concat this.model.first this.model.second}}`, {
+    this.render.template(`{{concat this.model.first this.model.second}}`, {
       model: { first: 'one', second: 'two' },
     });
 
@@ -30,7 +30,7 @@ class ConcatTest extends RenderTest {
 
   @test
   'it can be used as a sub-expression'() {
-    this.render(
+    this.render.template(
       `{{concat (concat this.model.first this.model.second) (concat this.model.third this.model.fourth)}}`,
       {
         model: {
@@ -78,9 +78,9 @@ class ConcatTest extends RenderTest {
 
   @test
   'it can be used as input for other helpers'() {
-    this.registerHelper('x-eq', ([actual, expected]) => actual === expected);
+    this.register.helper('x-eq', ([actual, expected]) => actual === expected);
 
-    this.render(
+    this.render.template(
       `{{#if (x-eq (concat this.model.first this.model.second) "onetwo")}}Truthy!{{else}}False{{/if}}`,
       {
         model: {
diff --git a/packages/@glimmer-workspace/integration-tests/test/helpers/dynamic-helpers-test.ts b/packages/@glimmer-workspace/integration-tests/test/helpers/dynamic-helpers-test.ts
index f38b0797a2..b5be0d3641 100644
--- a/packages/@glimmer-workspace/integration-tests/test/helpers/dynamic-helpers-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/helpers/dynamic-helpers-test.ts
@@ -3,19 +3,19 @@ import {
   defineSimpleHelper,
   GlimmerishComponent,
   jitSuite,
-  RenderTest,
+  RenderTestContext,
   test,
-} from '../..';
+} from '@glimmer-workspace/integration-tests';
 
-class DynamicHelpersResolutionModeTest extends RenderTest {
+class DynamicHelpersResolutionModeTest extends RenderTestContext {
   static suiteName = 'dynamic helpers in resolution mode';
 
   @test
   'Can invoke a yielded nested helper in resolution mode'() {
     const foo = defineSimpleHelper(() => 'Hello, world!');
-    this.registerComponent('TemplateOnly', 'Bar', '{{#let @x as |x|}}{{x.foo}}{{/let}}');
+    this.register.component('TemplateOnly', 'Bar', '{{#let @x as |x|}}{{x.foo}}{{/let}}');
 
-    this.render('<Bar @x={{this.x}} />', { x: { foo } });
+    this.render.template('<Bar @x={{this.x}} />', { x: { foo } });
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -30,7 +30,7 @@ class DynamicHelpersResolutionModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -46,7 +46,7 @@ class DynamicHelpersResolutionModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
diff --git a/packages/@glimmer-workspace/integration-tests/test/helpers/fn-test.ts b/packages/@glimmer-workspace/integration-tests/test/helpers/fn-test.ts
index c652acfd10..ee1a2ca63e 100644
--- a/packages/@glimmer-workspace/integration-tests/test/helpers/fn-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/helpers/fn-test.ts
@@ -1,21 +1,25 @@
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createInvokableRef } from '@glimmer/reference';
-
-import { GlimmerishComponent, jitSuite, RenderTest, test } from '../..';
-
-class FnTest extends RenderTest {
+import { toMut } from '@glimmer/reference';
+import {
+  GlimmerishComponent,
+  jitSuite,
+  RenderTestContext,
+  test,
+} from '@glimmer-workspace/integration-tests';
+
+class FnTest extends RenderTestContext {
   static suiteName = 'Helpers test: {{fn}}';
 
   stashedFn?: () => unknown;
 
-  beforeEach() {
-    this.registerHelper('invoke', ([fn]) => {
+  override readonly beforeEach = () => {
+    this.register.helper('invoke', ([fn]) => {
       return (fn as () => unknown)();
     });
 
     const setStashedFn = (value: unknown) => (this.stashedFn = value as () => unknown);
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Stash',
       '',
@@ -26,11 +30,11 @@ class FnTest extends RenderTest {
         }
       }
     );
-  }
+  };
 
   @test
   'updates when arguments change'() {
-    this.render(`{{invoke (fn this.myFunc this.arg1 this.arg2)}}`, {
+    this.render.template(`{{invoke (fn this.myFunc this.arg1 this.arg2)}}`, {
       myFunc(arg1: string, arg2: string) {
         return `arg1: ${arg1}, arg2: ${arg2}`;
       },
@@ -58,7 +62,7 @@ class FnTest extends RenderTest {
     let func1 = (arg1: string, arg2: string) => `arg1: ${arg1}, arg2: ${arg2}`;
     let func2 = (arg1: string, arg2: string) => `arg2: ${arg2}, arg1: ${arg1}`;
 
-    this.render(`{{invoke (fn this.myFunc this.arg1 this.arg2)}}`, {
+    this.render.template(`{{invoke (fn this.myFunc this.arg1 this.arg2)}}`, {
       myFunc: func1,
 
       arg1: 'foo',
@@ -77,7 +81,7 @@ class FnTest extends RenderTest {
 
   @test
   'a stashed fn result update arguments when invoked'(assert: Assert) {
-    this.render(`<Stash @stashedFn={{fn this.myFunc this.arg1 this.arg2}}/>`, {
+    this.render.template(`<Stash @stashedFn={{fn this.myFunc this.arg1 this.arg2}}/>`, {
       myFunc(arg1: string, arg2: string) {
         return `arg1: ${arg1}, arg2: ${arg2}`;
       },
@@ -105,7 +109,7 @@ class FnTest extends RenderTest {
     let func1 = (arg1: string, arg2: string) => `arg1: ${arg1}, arg2: ${arg2}`;
     let func2 = (arg1: string, arg2: string) => `arg2: ${arg2}, arg1: ${arg1}`;
 
-    this.render(`<Stash @stashedFn={{fn this.myFunc this.arg1 this.arg2}}/>`, {
+    this.render.template(`<Stash @stashedFn={{fn this.myFunc this.arg1 this.arg2}}/>`, {
       myFunc: func1,
 
       arg1: 'foo',
@@ -124,7 +128,7 @@ class FnTest extends RenderTest {
   @test
   'asserts if no argument given'(assert: Assert) {
     assert.throws(() => {
-      this.render(`{{fn}}`, {
+      this.render.template(`{{fn}}`, {
         myFunc: null,
         arg1: 'foo',
         arg2: 'bar',
@@ -135,7 +139,7 @@ class FnTest extends RenderTest {
   @test
   'asserts if the first argument is undefined'(assert: Assert) {
     assert.throws(() => {
-      this.render(`{{fn this.myFunc this.arg1 this.arg2}}`, {
+      this.render.template(`{{fn this.myFunc this.arg1 this.arg2}}`, {
         myFunc: undefined,
         arg1: 'foo',
         arg2: 'bar',
@@ -146,7 +150,7 @@ class FnTest extends RenderTest {
   @test
   'asserts if the first argument is null'(assert: Assert) {
     assert.throws(() => {
-      this.render(`{{fn this.myFunc this.arg1 this.arg2}}`, {
+      this.render.template(`{{fn this.myFunc this.arg1 this.arg2}}`, {
         myFunc: null,
         arg1: 'foo',
         arg2: 'bar',
@@ -158,7 +162,7 @@ class FnTest extends RenderTest {
   'asserts if the provided function accesses `this` without being bound prior to passing to fn'(
     assert: Assert
   ) {
-    this.render(`<Stash @stashedFn={{fn this.myFunc this.arg1}}/>`, {
+    this.render.template(`<Stash @stashedFn={{fn this.myFunc this.arg1}}/>`, {
       myFunc(arg1: string) {
         return `arg1: ${arg1}, arg2: ${this['arg2']}`;
       },
@@ -174,7 +178,7 @@ class FnTest extends RenderTest {
 
   @test
   'there is no `this` context within the callback'(assert: Assert) {
-    this.render(`<Stash @stashedFn={{fn this.myFunc this.arg1}}/>`, {
+    this.render.template(`<Stash @stashedFn={{fn this.myFunc this.arg1}}/>`, {
       myFunc() {
         assert.step('calling stashed function');
         assert.throws(() => String(this), /not bound to a valid `this` context/u);
@@ -199,14 +203,14 @@ class FnTest extends RenderTest {
 
     context.myFunc = context.myFunc.bind(context);
 
-    this.render(`<Stash @stashedFn={{fn this.myFunc this.arg1}}/>`, context);
+    this.render.template(`<Stash @stashedFn={{fn this.myFunc this.arg1}}/>`, context);
 
     assert.strictEqual(this.stashedFn?.(), 'arg1: foo, arg2: bar');
   }
 
   @test
   'partially applies each layer when nested [GH#17959]'() {
-    this.render(`{{invoke (fn (fn (fn this.myFunc this.arg1) this.arg2) this.arg3)}}`, {
+    this.render.template(`{{invoke (fn (fn (fn this.myFunc this.arg1) this.arg2) this.arg3)}}`, {
       myFunc(arg1: string, arg2: string, arg3: string) {
         return `arg1: ${arg1}, arg2: ${arg2}, arg3: ${arg3}`;
       },
@@ -234,12 +238,12 @@ class FnTest extends RenderTest {
 
   @test
   'can be used on the result of `mut`'() {
-    this.registerInternalHelper('mut', (args: CapturedArguments) => {
+    this.register.internalHelper('mut', (args: CapturedArguments) => {
       let [first] = this.guardArray({ positional: args.positional }, { min: 1 });
-      return createInvokableRef(first);
+      return toMut(first);
     });
 
-    this.render(`{{this.arg1}}<Stash @stashedFn={{fn (mut this.arg1) this.arg2}}/>`, {
+    this.render.template(`{{this.arg1}}<Stash @stashedFn={{fn (mut this.arg1) this.arg2}}/>`, {
       arg1: 'foo',
       arg2: 'bar',
     });
@@ -254,12 +258,12 @@ class FnTest extends RenderTest {
 
   @test
   'can be used on the result of `mut` with a falsy value'() {
-    this.registerInternalHelper('mut', (args: CapturedArguments) => {
+    this.register.internalHelper('mut', (args: CapturedArguments) => {
       let [first] = this.guardArray({ positional: args.positional }, { min: 1 });
-      return createInvokableRef(first);
+      return toMut(first);
     });
 
-    this.render(`{{this.arg1}}<Stash @stashedFn={{fn (mut this.arg1) this.arg2}}/>`, {
+    this.render.template(`{{this.arg1}}<Stash @stashedFn={{fn (mut this.arg1) this.arg2}}/>`, {
       arg1: 'foo',
       arg2: false,
     });
diff --git a/packages/@glimmer-workspace/integration-tests/test/helpers/get-test.ts b/packages/@glimmer-workspace/integration-tests/test/helpers/get-test.ts
index 50391bde2f..03181e7254 100644
--- a/packages/@glimmer-workspace/integration-tests/test/helpers/get-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/helpers/get-test.ts
@@ -1,10 +1,16 @@
-import { GlimmerishComponent, jitSuite, RenderTest, test, tracked } from '../..';
-
-class GetTest extends RenderTest {
+import {
+  GlimmerishComponent,
+  jitSuite,
+  RenderTestContext,
+  test,
+  tracked,
+} from '@glimmer-workspace/integration-tests';
+
+class GetTest extends RenderTestContext {
   static suiteName = 'Helpers test: {{get}}';
   @test
   'should be able to get an object value with a static key'() {
-    this.render(`[{{get this.colors 'apple'}}] [{{if true (get this.colors 'apple')}}]`, {
+    this.render.template(`[{{get this.colors 'apple'}}] [{{if true (get this.colors 'apple')}}]`, {
       colors: { apple: 'red' },
     });
 
@@ -20,13 +26,16 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with nested static key'() {
-    this.render(`[{{get this.colors "apple.gala"}}] [{{if true (get this.colors "apple.gala")}}]`, {
-      colors: {
-        apple: {
-          gala: 'red and yellow',
+    this.render.template(
+      `[{{get this.colors "apple.gala"}}] [{{if true (get this.colors "apple.gala")}}]`,
+      {
+        colors: {
+          apple: {
+            gala: 'red and yellow',
+          },
         },
-      },
-    });
+      }
+    );
 
     this.assertHTML('[red and yellow] [red and yellow]');
     this.assertStableRerender();
@@ -52,7 +61,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with a number'() {
-    this.render(`[{{get this.items 1}}][{{get this.items 2}}][{{get this.items 3}}]`, {
+    this.render.template(`[{{get this.items 1}}][{{get this.items 2}}][{{get this.items 3}}]`, {
       items: {
         1: 'First',
         2: 'Second',
@@ -72,9 +81,12 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an array value with a number'() {
-    this.render(`[{{get this.numbers 0}}][{{get this.numbers 1}}][{{get this.numbers 2}}]`, {
-      numbers: [1, 2, 3],
-    });
+    this.render.template(
+      `[{{get this.numbers 0}}][{{get this.numbers 1}}][{{get this.numbers 2}}]`,
+      {
+        numbers: [1, 2, 3],
+      }
+    );
 
     this.assertHTML('[1][2][3]');
     this.assertStableRerender();
@@ -88,7 +100,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with a path evaluating to a number'() {
-    this.render(`{{#each this.indexes as |index|}}[{{get this.items index}}]{{/each}}`, {
+    this.render.template(`{{#each this.indexes as |index|}}[{{get this.items index}}]{{/each}}`, {
       indexes: [1, 2, 3],
       items: {
         1: 'First',
@@ -109,9 +121,12 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an array value with a path evaluating to a number'() {
-    this.render(`{{#each this.numbers as |num index|}}[{{get this.numbers index}}]{{/each}}`, {
-      numbers: [1, 2, 3],
-    });
+    this.render.template(
+      `{{#each this.numbers as |num index|}}[{{get this.numbers index}}]{{/each}}`,
+      {
+        numbers: [1, 2, 3],
+      }
+    );
 
     this.assertHTML('[1][2][3]');
     this.assertStableRerender();
@@ -122,10 +137,13 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with a bound/dynamic key'() {
-    this.render(`[{{get this.colors this.key}}] [{{if true (get this.colors this.key)}}]`, {
-      colors: { apple: 'red', banana: 'yellow' },
-      key: 'apple',
-    });
+    this.render.template(
+      `[{{get this.colors this.key}}] [{{if true (get this.colors this.key)}}]`,
+      {
+        colors: { apple: 'red', banana: 'yellow' },
+        key: 'apple',
+      }
+    );
 
     this.assertHTML('[red] [red]');
     this.assertStableRerender();
@@ -142,16 +160,19 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with nested dynamic key'() {
-    this.render(`[{{get this.colors this.key}}] [{{if true (get this.colors this.key)}}]`, {
-      colors: {
-        apple: {
-          gala: 'red and yellow',
-          mcintosh: 'red',
+    this.render.template(
+      `[{{get this.colors this.key}}] [{{if true (get this.colors this.key)}}]`,
+      {
+        colors: {
+          apple: {
+            gala: 'red and yellow',
+            mcintosh: 'red',
+          },
+          banana: 'yellow',
         },
-        banana: 'yellow',
-      },
-      key: 'apple.gala',
-    });
+        key: 'apple.gala',
+      }
+    );
 
     this.assertHTML('[red and yellow] [red and yellow]');
     this.assertStableRerender();
@@ -168,7 +189,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with subexpression returning nested key'() {
-    this.render(
+    this.render.template(
       `[{{get this.colors (concat 'apple' '.' 'gala')}}] [{{if true (get this.colors (concat 'apple' '.' 'gala'))}}]`,
       {
         colors: {
@@ -205,7 +226,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with a get helper as the key'() {
-    this.render(
+    this.render.template(
       `[{{get this.colors (get this.possibleKeys this.key)}}] [{{if true (get this.colors (get this.possibleKeys this.key))}}]`,
       {
         colors: { apple: 'red', banana: 'yellow' },
@@ -232,7 +253,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with a get helper value as a bound/dynamic key'() {
-    this.render(
+    this.render.template(
       `[{{get (get this.possibleValues this.objectKey) this.key}}] [{{if true (get (get this.possibleValues this.objectKey) this.key)}}]`,
       {
         possibleValues: {
@@ -265,7 +286,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get an object value with a get helper as the value and a get helper as the key'() {
-    this.render(
+    this.render.template(
       `[{{get (get this.possibleValues this.objectKey) (get this.possibleKeys this.key)}}] [{{if true (get (get this.possibleValues this.objectKey) (get this.possibleKeys this.key))}}]`,
       {
         possibleValues: {
@@ -315,9 +336,9 @@ class GetTest extends RenderTest {
       }
     }
 
-    this.registerComponent('Glimmer', 'FooBar', '{{yield (get @colors this.mcintosh)}}', FooBar);
+    this.register.component('Glimmer', 'FooBar', '{{yield (get @colors this.mcintosh)}}', FooBar);
 
-    this.render(`<FooBar @colors={{this.colors}} as |value|>{{value}}</FooBar>`, {
+    this.render.template(`<FooBar @colors={{this.colors}} as |value|>{{value}}</FooBar>`, {
       colors: {
         red: 'banana',
       },
@@ -337,7 +358,7 @@ class GetTest extends RenderTest {
 
   @test
   'should handle object values as nulls'() {
-    this.render(`[{{get this.colors 'apple'}}] [{{if true (get this.colors 'apple')}}]`, {
+    this.render.template(`[{{get this.colors 'apple'}}] [{{if true (get this.colors 'apple')}}]`, {
       colors: null,
     });
 
@@ -356,13 +377,16 @@ class GetTest extends RenderTest {
 
   @test
   'should handle object keys as nulls'() {
-    this.render(`[{{get this.colors this.key}}] [{{if true (get this.colors this.key)}}]`, {
-      colors: {
-        apple: 'red',
-        banana: 'yellow',
-      },
-      key: null,
-    });
+    this.render.template(
+      `[{{get this.colors this.key}}] [{{if true (get this.colors this.key)}}]`,
+      {
+        colors: {
+          apple: 'red',
+          banana: 'yellow',
+        },
+        key: null,
+      }
+    );
 
     this.assertHTML('[] []');
     this.assertStableRerender();
@@ -376,7 +400,7 @@ class GetTest extends RenderTest {
 
   @test
   'should handle object values and keys as nulls'() {
-    this.render(`[{{get this.colors 'apple'}}] [{{if true (get this.colors this.key)}}]`, {
+    this.render.template(`[{{get this.colors 'apple'}}] [{{if true (get this.colors this.key)}}]`, {
       colors: null,
       key: null,
     });
@@ -390,17 +414,20 @@ class GetTest extends RenderTest {
       options = ['first', 'last', 'age'];
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'PersonWrapper',
       '{{#each this.options as |option|}}{{get this.args option}}{{/each}}',
       PersonComponent
     );
 
-    this.render('<PersonWrapper @first={{this.first}} @last={{this.last}} @age={{this.age}}/>', {
-      first: 'miguel',
-      last: 'andrade',
-    });
+    this.render.template(
+      '<PersonWrapper @first={{this.first}} @last={{this.last}} @age={{this.age}}/>',
+      {
+        first: 'miguel',
+        last: 'andrade',
+      }
+    );
 
     this.assertHTML('miguelandrade');
     this.assertStableRerender();
@@ -411,7 +438,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get string length with a static key'() {
-    this.render(`[{{get this.name 'length'}}] [{{if true (get this.name 'length')}}]`, {
+    this.render.template(`[{{get this.name 'length'}}] [{{if true (get this.name 'length')}}]`, {
       name: 'Tomster',
     });
 
@@ -427,7 +454,7 @@ class GetTest extends RenderTest {
 
   @test
   'should be able to get string length with a bound/dynamic key'() {
-    this.render(`[{{get this.name this.key}}] [{{if true (get this.name this.key)}}]`, {
+    this.render.template(`[{{get this.name this.key}}] [{{if true (get this.name this.key)}}]`, {
       name: 'Tomster',
       key: 'length',
     });
diff --git a/packages/@glimmer-workspace/integration-tests/test/helpers/hash-test.ts b/packages/@glimmer-workspace/integration-tests/test/helpers/hash-test.ts
index 1113ac3203..7dc973ca94 100644
--- a/packages/@glimmer-workspace/integration-tests/test/helpers/hash-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/helpers/hash-test.ts
@@ -1,11 +1,18 @@
-import { GlimmerishComponent, jitSuite, RenderTest, test, tracked } from '../..';
-
-class HashTest extends RenderTest {
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
+import {
+  GlimmerishComponent,
+  jitSuite,
+  RenderTestContext,
+  test,
+  tracked,
+} from '@glimmer-workspace/integration-tests';
+
+class HashTest extends RenderTestContext {
   static suiteName = 'Helpers test: {{hash}}';
 
   @test
   'returns a hash with the right key-value'() {
-    this.render(`{{#let (hash name="Sergio") as |person|}}{{person.name}}{{/let}}`);
+    this.render.template(`{{#let (hash name="Sergio") as |person|}}{{person.name}}{{/let}}`);
 
     this.assertHTML('Sergio');
     this.assertStableRerender();
@@ -13,7 +20,7 @@ class HashTest extends RenderTest {
 
   @test
   'can have more than one key-value'() {
-    this.render(
+    this.render.template(
       `{{#let (hash name="Sergio" lastName="Arbeo") as |person|}}{{person.name}} {{person.lastName}}{{/let}}`
     );
 
@@ -23,7 +30,7 @@ class HashTest extends RenderTest {
 
   @test
   'binds values when variables are used'() {
-    this.render(
+    this.render.template(
       `{{#let (hash name=this.firstName lastName="Arbeo") as |person|}}{{person.name}} {{person.lastName}}{{/let}}`,
       {
         firstName: 'Marisa',
@@ -42,7 +49,7 @@ class HashTest extends RenderTest {
 
   @test
   'binds multiple values when variables are used'() {
-    this.render(
+    this.render.template(
       `{{#let (hash name=this.firstName lastName=this.lastName) as |person|}}{{person.name}} {{person.lastName}}{{/let}}`,
       {
         firstName: 'Marisa',
@@ -65,7 +72,7 @@ class HashTest extends RenderTest {
 
   @test
   'hash helpers can be nested'() {
-    this.render(
+    this.render.template(
       `{{#let (hash person=(hash name=this.firstName)) as |ctx|}}{{ctx.person.name}}{{/let}}`,
       {
         firstName: 'Balint',
@@ -97,14 +104,14 @@ class HashTest extends RenderTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       `{{yield (hash firstName=this.firstName)}}`,
       FooBar
     );
 
-    this.render(`<FooBar as |values|>{{values.firstName}}</FooBar>`);
+    this.render.template(`<FooBar as |values|>{{values.firstName}}</FooBar>`);
 
     this.assertHTML('Chad');
     this.assertStableRerender();
@@ -133,14 +140,14 @@ class HashTest extends RenderTest {
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       `{{yield (hash firstName=this.firstName lastName=@lastName)}}`,
       FooBar
     );
 
-    this.render(
+    this.render.template(
       `<FooBar @lastName={{this.lastName}} as |values|>{{values.firstName}} {{values.lastName}}</FooBar>`,
       {
         lastName: 'Hietala',
@@ -167,20 +174,25 @@ class HashTest extends RenderTest {
       firstName = 'Godfrey';
 
       get lastName() {
-        assert.ok(false, 'lastName was accessed');
+        // trace logging eagerly evaluates the arguments in order to print
+        // them, so we can't verify that they are accessed lazily while trace
+        // logging is on.
+        if (!LOCAL_TRACE_LOGGING) {
+          assert.ok(false, 'lastName was unexpectedly accessed');
+        }
 
         return;
       }
     }
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'FooBar',
       `{{yield (hash firstName=@firstName lastName=this.lastName)}}`,
       FooBar
     );
 
-    this.render(`<FooBar @firstName="Godfrey" as |values|>{{values.firstName}}</FooBar>`);
+    this.render.template(`<FooBar @firstName="Godfrey" as |values|>{{values.firstName}}</FooBar>`);
 
     this.assertHTML('Godfrey');
     this.assertStableRerender();
@@ -197,9 +209,9 @@ class HashTest extends RenderTest {
       }
     }
 
-    this.registerComponent('Glimmer', 'FooBar', `{{yield @hash}}`, FooBar);
+    this.register.component('Glimmer', 'FooBar', `{{yield @hash}}`, FooBar);
 
-    this.render(
+    this.render.template(
       `<FooBar @hash={{hash firstName="Godfrey" lastName="Hietala"}} as |values|>{{values.firstName}} {{values.lastName}}</FooBar>`
     );
 
@@ -226,9 +238,9 @@ class HashTest extends RenderTest {
       }
     }
 
-    this.registerComponent('Glimmer', 'FooBar', `{{yield @hash this.alias}}`, FooBar);
+    this.register.component('Glimmer', 'FooBar', `{{yield @hash this.alias}}`, FooBar);
 
-    this.render(
+    this.render.template(
       `<FooBar @hash={{hash name=this.name}} as |values alias|>{{values.name}} {{alias}}</FooBar>`,
       {
         name: 'Godfrey',
@@ -259,9 +271,9 @@ class HashTest extends RenderTest {
       }
     }
 
-    this.registerComponent('Glimmer', 'FooBar', `{{yield @hash}}`, FooBar);
+    this.register.component('Glimmer', 'FooBar', `{{yield @hash}}`, FooBar);
 
-    this.render(
+    this.render.template(
       `<FooBar @hash={{hash firstName="Godfrey"}} as |values|>{{values.firstName}} {{values.lastName}}</FooBar>`
     );
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/i-n-u-r-test.ts b/packages/@glimmer-workspace/integration-tests/test/i-n-u-r-test.ts
index f5eea322db..cc1e93d588 100644
--- a/packages/@glimmer-workspace/integration-tests/test/i-n-u-r-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/i-n-u-r-test.ts
@@ -1,6 +1,10 @@
 import { castToSimple } from '@glimmer/util';
+import {
+  ClientSideRenderDelegate,
+  RenderTestContext,
+  RenderTestState,
+} from '@glimmer-workspace/integration-tests';
 
-import { JitRenderDelegate, RenderTest } from '..';
 import { module } from './support';
 
 // "I-N-U-R" cycle
@@ -8,34 +12,21 @@ import { module } from './support';
 module('Render Tests: I-N-U-R', ({ test }) => {
   let doc = castToSimple(document);
 
-   
-  test('Can set properties', (assert) => {
-    new (class extends RenderTest {
-      constructor(delegate: JitRenderDelegate) {
-        super(delegate);
-        this.setProperties({ foo: 'bar' });
-        assert.strictEqual(this.context['foo'], 'bar');
-      }
-    })(new JitRenderDelegate());
-  });
-
-   
   test('Can take basic snapshots', (assert) => {
     let div = doc.createElement('div');
     let text = doc.createTextNode('Foo');
     div.appendChild(text);
 
-    new (class extends RenderTest {
-      override element = div;
-      constructor(delegate: JitRenderDelegate) {
-        super(delegate);
+    new (class extends RenderTestContext {
+      constructor(...args: ConstructorParameters<typeof RenderTestContext>) {
+        super(...args);
+        this.element = div;
         let snapShot = this.takeSnapshot();
         assert.deepEqual(snapShot, [text, 'up']);
       }
-    })(new JitRenderDelegate());
+    })(new ClientSideRenderDelegate(), RenderTestState(assert, 'glimmer'));
   });
 
-   
   test('Can take nested snapshots', (assert) => {
     let div = doc.createElement('div');
     let p = doc.createElement('p');
@@ -43,17 +34,16 @@ module('Render Tests: I-N-U-R', ({ test }) => {
     p.appendChild(text);
     div.appendChild(p);
 
-    new (class extends RenderTest {
-      override element = div;
-      constructor(delegate: JitRenderDelegate) {
-        super(delegate);
+    new (class extends RenderTestContext {
+      constructor(...args: ConstructorParameters<typeof RenderTestContext>) {
+        super(...args);
+        this.element = div;
         let snapShot = this.takeSnapshot();
         assert.deepEqual(snapShot, [p, 'down', text, 'up', 'up']);
       }
-    })(new JitRenderDelegate());
+    })(new ClientSideRenderDelegate(), RenderTestState(assert, 'glimmer'));
   });
 
-   
   test('Can take nested snapshots of serialized blocks', (assert) => {
     let div = doc.createElement('div');
     let open = doc.createComment('<!--%+b:0%-->');
@@ -63,13 +53,13 @@ module('Render Tests: I-N-U-R', ({ test }) => {
     div.appendChild(text);
     div.appendChild(close);
 
-    new (class extends RenderTest {
-      override element = div;
-      constructor(delegate: JitRenderDelegate) {
-        super(delegate);
+    new (class extends RenderTestContext {
+      constructor(...args: ConstructorParameters<typeof RenderTestContext>) {
+        super(...args);
+        this.element = div;
         let snapShot = this.takeSnapshot();
         assert.deepEqual(snapShot, [open, text, close, 'up']);
       }
-    })(new JitRenderDelegate());
+    })(new ClientSideRenderDelegate(), RenderTestState(assert, 'glimmer'));
   });
 });
diff --git a/packages/@glimmer-workspace/integration-tests/test/initial-render-test.ts b/packages/@glimmer-workspace/integration-tests/test/initial-render-test.ts
index 85ebe0d9d0..7f18215378 100644
--- a/packages/@glimmer-workspace/integration-tests/test/initial-render-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/initial-render-test.ts
@@ -1,7 +1,7 @@
 import type { Dict, Nullable, SimpleElement } from '@glimmer/interfaces';
 import type { SafeString } from '@glimmer/runtime';
+import type {ComponentBlueprint, Content} from '@glimmer-workspace/integration-tests';
 import { castToBrowser, expect } from '@glimmer/util';
-
 import {
   assertElementShape,
   assertEmberishElement,
@@ -9,58 +9,57 @@ import {
   assertSerializedInElement,
   blockStack,
   CLOSE,
-  type ComponentBlueprint,
   componentSuite,
-  type Content,
   content,
   EMPTY,
   equalTokens,
   firstElementChild,
   GLIMMER_TEST_COMPONENT,
-  InitialRenderSuite,
-  jitSuite,
-  OPEN,
+  InitialRenderTests,
+matrix,  OPEN,
   RehydrationDelegate,
+  render,
+  RenderTestContext,
   replaceHTML,
   strip,
   suite,
-  test,
   toInnerHTML,
-  toTextContent,
-} from '..';
+  toTextContent
+ } from '@glimmer-workspace/integration-tests';
 
 // `window.ActiveXObject` is "falsey" in IE11 (but not `undefined` or `false`)
 // `"ActiveXObject" in window` returns `true` in all IE versions
 // only IE11 will pass _both_ of these conditions
 const isIE11 = !(window as any).ActiveXObject && 'ActiveXObject' in window;
 
-class RenderTests extends InitialRenderSuite {
-  static override suiteName = 'initial render (client)';
-  override name = 'client';
-}
-
-class AbstractRehydrationTests extends InitialRenderSuite {
-  override name = 'rehydration';
-  protected declare delegate: RehydrationDelegate;
+class RehydrationContext extends RenderTestContext {
+  declare delegate: RehydrationDelegate;
   protected declare serverOutput: Nullable<string>;
 
   renderServerSide(
     template: string | ComponentBlueprint,
-    context: Dict<unknown>,
+    self: Dict,
     element: SimpleElement | undefined = undefined
   ): void {
+    this.self.initialize(self);
     this.serverOutput = this.delegate.renderServerSide(
       template as string,
-      context,
+      this.self.ref,
       () => this.takeSnapshot(),
-      element
+      element,
+      this.plugins
     );
     replaceHTML(this.element, this.serverOutput);
   }
 
-  renderClientSide(template: string | ComponentBlueprint, context: Dict<unknown>): void {
-    this.context = context;
-    this.renderResult = this.delegate.renderClientSide(template as string, context, this.element);
+  renderClientSide(template: string | ComponentBlueprint, self: Dict): void {
+    this.self.initialize(self);
+    this.renderResult = this.delegate.renderClientSide(
+      template as string,
+      this.self.ref,
+      this.element,
+      this.plugins
+    );
   }
 
   assertRehydrationStats({ nodesRemoved: nodes }: { nodesRemoved: number }) {
@@ -81,151 +80,141 @@ class AbstractRehydrationTests extends InitialRenderSuite {
   }
 }
 
-class Rehydration extends AbstractRehydrationTests {
-  static override suiteName = 'rehydration';
-
-  @test
-  'rehydrates into element with pre-existing content'() {
-    let rootElement = this.delegate.serverDoc.createElement('div');
-    let extraContent = this.delegate.serverDoc.createElement('noscript');
-    rootElement.appendChild(extraContent);
-
-    let noScriptString = '<noscript></noscript>';
-    let template = '<div>Hi!</div>';
-    this.renderServerSide(template, {}, rootElement);
-    this.assertExactServerOutput(content([noScriptString, OPEN, ...template, CLOSE]));
-    this.renderClientSide(template, {});
-    this.assertHTML('<noscript></noscript><div>Hi!</div>');
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertStableNodes();
-  }
+const RehydrationTests = matrix(
+  { context: RehydrationContext, extends: InitialRenderTests },
+  'rehydration',
+  (test) => {
+    test('rehydrates into element with pre-existing content', (ctx) => {
+      let rootElement = ctx.delegate.serverDoc.createElement('div');
+      let extraContent = ctx.delegate.serverDoc.createElement('noscript');
+      rootElement.appendChild(extraContent);
+
+      let noScriptString = '<noscript></noscript>';
+      let template = '<div>Hi!</div>';
+      ctx.renderServerSide(template, {}, rootElement);
+      ctx.assertExactServerOutput(content([noScriptString, OPEN, ...template, CLOSE]));
+      ctx.renderClientSide(template, {});
+      ctx.assertHTML('<noscript></noscript><div>Hi!</div>');
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertStableNodes();
+    });
 
-  @test
-  'handles non-empty trusted content (triple-curlies)'() {
-    let template = '<div>{{{this.value}}}</div>';
-    let obj: { value: string } = { value: 'foo' };
-    this.renderServerSide(template, obj);
-    this.renderClientSide(template, obj);
-    this.assertHTML('<div>foo</div>');
-  }
+    test('handles non-empty trusted content (triple-curlies)', (ctx) => {
+      let template = '<div>{{{this.value}}}</div>';
+      let obj: { value: string } = { value: 'foo' };
+      ctx.renderServerSide(template, obj);
+      ctx.renderClientSide(template, obj);
+      ctx.assertHTML('<div>foo</div>');
+    });
 
-  @test
-  'handles empty trusted content (triple-curlies)'() {
-    let template = '<div>{{{this.value}}}</div>';
-    let obj: { value: string } = { value: '' };
-    this.renderServerSide(template, obj);
-    this.renderClientSide(template, obj);
-    this.assertHTML('<div></div>');
-  }
+    test('handles empty trusted content (triple-curlies)', (ctx) => {
+      let template = '<div>{{{this.value}}}</div>';
+      let obj: { value: string } = { value: '' };
+      ctx.renderServerSide(template, obj);
+      ctx.renderClientSide(template, obj);
+      ctx.assertHTML('<div></div>');
+    });
 
-  @test
-  'handles empty trusted content (html safe string)'() {
-    let template = '<div>{{this.value}}</div>';
+    test('handles empty trusted content (html safe string)', (ctx) => {
+      let template = '<div>{{this.value}}</div>';
 
-    let safeString: SafeString = {
-      toHTML() {
-        return '';
-      },
-    };
-    let obj = { value: safeString };
+      let safeString: SafeString = {
+        toHTML() {
+          return '';
+        },
+      };
+      let obj = { value: safeString };
 
-    this.renderServerSide(template, obj);
-    this.renderClientSide(template, obj);
-    this.assertHTML('<div></div>');
-  }
+      ctx.renderServerSide(template, obj);
+      ctx.renderClientSide(template, obj);
+      ctx.assertHTML('<div></div>');
+    });
 
-  @test
-  'table with omitted tbody'() {
-    let template = '<table><tr><td>standards</td></tr></table>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<table><tbody><tr><td>standards</td></tr></tbody></table>');
-    this.renderClientSide(template, {});
-    this.assertHTML('<table><tbody><tr><td>standards</td></tr></tbody></table>');
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertStableNodes();
-  }
+    test('table with omitted tbody', (ctx) => {
+      let template = '<table><tr><td>standards</td></tr></table>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<table><tbody><tr><td>standards</td></tr></tbody></table>');
+      ctx.renderClientSide(template, {});
+      ctx.assertHTML('<table><tbody><tr><td>standards</td></tr></tbody></table>');
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertStableNodes();
+    });
 
-  @test
-  'table with thead'() {
-    let template = '<table><thead><tr><th>standards</th></tr></thead></table>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<table><thead><tr><th>standards</th></tr></thead></table>');
-    this.renderClientSide(template, {});
-    this.assertHTML('<table><thead><tr><th>standards</th></tr></thead></table>');
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertStableNodes();
-  }
+    test('table with thead', (ctx) => {
+      let template = '<table><thead><tr><th>standards</th></tr></thead></table>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<table><thead><tr><th>standards</th></tr></thead></table>');
+      ctx.renderClientSide(template, {});
+      ctx.assertHTML('<table><thead><tr><th>standards</th></tr></thead></table>');
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertStableNodes();
+    });
 
-  @test
-  'table with tfoot'() {
-    let template = '<table><tfoot><tr><th>standards</th></tr></tfoot></table>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<table><tfoot><tr><th>standards</th></tr></tfoot></table>');
-    this.renderClientSide(template, {});
-    this.assertHTML('<table><tfoot><tr><th>standards</th></tr></tfoot></table>');
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertStableNodes();
-  }
+    test('table with tfoot', (ctx) => {
+      let template = '<table><tfoot><tr><th>standards</th></tr></tfoot></table>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<table><tfoot><tr><th>standards</th></tr></tfoot></table>');
+      ctx.renderClientSide(template, {});
+      ctx.assertHTML('<table><tfoot><tr><th>standards</th></tr></tfoot></table>');
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertStableNodes();
+    });
 
-  @test
-  'mismatched text nodes'() {
-    let template = '{{this.content}}';
-    this.renderServerSide(template, { content: 'hello' });
-    this.assertServerOutput(OPEN, 'hello', CLOSE);
+    test('mismatched text nodes', (ctx) => {
+      let template = '{{this.content}}';
+      ctx.renderServerSide(template, { content: 'hello' });
+      ctx.assertServerOutput(OPEN, 'hello', CLOSE);
 
-    this.renderClientSide(template, { content: 'goodbye' });
-    this.assertHTML('goodbye');
-    // Just repairs the value of the text node
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertStableRerender();
-  }
+      ctx.renderClientSide(template, { content: 'goodbye' });
+      ctx.assertHTML('goodbye');
+      // Just repairs the value of the text node
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'mismatched text nodes (server-render empty)'() {
-    let template = '{{this.content}} world';
-    this.renderServerSide(template, { content: '' });
-    this.assertServerOutput(OPEN, EMPTY, CLOSE, ' world');
+    test('mismatched text nodes (server-render empty)', (ctx) => {
+      let template = '{{this.content}} world';
+      ctx.renderServerSide(template, { content: '' });
+      ctx.assertServerOutput(OPEN, EMPTY, CLOSE, ' world');
 
-    this.renderClientSide(template, { content: 'hello' });
-    this.assertHTML('hello world');
-    // Just repairs the value of the text node
-    this.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.renderClientSide(template, { content: 'hello' });
+      ctx.assertHTML('hello world');
+      // Just repairs the value of the text node
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
 
-    // TODO handle % % in the testing DSL
-    // this.assertStableNodes();
-    this.assertStableRerender();
-  }
+      // TODO handle % % in the testing DSL
+      // this.assertStableNodes();
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'missing closing block within multiple text nodes'() {
-    let template = '<div>a {{this.b}}{{this.c}}{{this.d}}</div>';
-    let context = { b: '', c: '', d: '' };
+    test('missing closing block within multiple text nodes', (ctx) => {
+      let template = '<div>a {{this.b}}{{this.c}}{{this.d}}</div>';
+      let context = { b: '', c: '', d: '' };
 
-    this.renderServerSide(template, context);
+      ctx.renderServerSide(template, context);
 
-    let b = blockStack();
-    this.assertServerOutput(
-      `<div>a ${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}</div>`
-    );
+      let b = blockStack();
+      ctx.assertServerOutput(
+        `<div>a ${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}${b(1)}<!--% %-->${b(1)}</div>`
+      );
 
-    // remove the first `<!--%-b:1%-->`
-    let element = castToBrowser(this.element, 'HTML');
-    let [div] = this.guardArray({ children: element.children }, { min: 1 });
-    let commentToRemove = this.guardArray({ children: div.childNodes }, { min: 4 })[3];
-    div.removeChild(commentToRemove);
+      // remove the first `<!--%-b:1%-->`
+      let element = castToBrowser(ctx.element, 'HTML');
+      let [div] = ctx.guardArray({ children: element.children }, { min: 1 });
+      let commentToRemove = ctx.guardArray({ children: div.childNodes }, { min: 4 })[3];
+      div.removeChild(commentToRemove);
 
-    this.renderClientSide(template, context);
-    this.assertHTML('<div>a </div>');
-    this.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.renderClientSide(template, context);
+      ctx.assertHTML('<div>a </div>');
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
 
-    // TODO: handle % % in the testing DSL
-    // this.assertStableNodes();
-    this.assertStableRerender();
-  }
+      // TODO: handle % % in the testing DSL
+      // this.assertStableNodes();
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'resumes correct block after reenabling rehydration'() {
-    let template = strip`
+    test('resumes correct block after reenabling rehydration', (ctx) => {
+      let template = strip`
       <div>
         {{#if this.a}}
           {{#if this.b}}
@@ -239,469 +228,450 @@ class Rehydration extends AbstractRehydrationTests {
         <after-a></after-a>
       </div>
     `;
-    let context = { a: false, b: false, c: false };
-
-    this.renderServerSide(template, context);
+      let context = { a: false, b: false, c: false };
 
-    let b = blockStack();
-    this.assertServerOutput(`<div>${b(1)}<!---->${b(1)}<after-a></after-a></div>`);
+      ctx.renderServerSide(template, context);
 
-    this.renderClientSide(template, { a: true, b: true, c: true });
-    this.assertHTML(
-      '<div><inside-c></inside-c><after-c></after-c><after-b></after-b><after-a></after-a></div>'
-    );
-    this.assertRehydrationStats({ nodesRemoved: 0 });
+      let b = blockStack();
+      ctx.assertServerOutput(`<div>${b(1)}<!---->${b(1)}<after-a></after-a></div>`);
 
-    // TODO: handle % % in the testing DSL
-    // this.assertStableNodes();
-    this.assertStableRerender();
-  }
+      ctx.renderClientSide(template, { a: true, b: true, c: true });
+      ctx.assertHTML(
+        '<div><inside-c></inside-c><after-c></after-c><after-b></after-b><after-a></after-a></div>'
+      );
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
 
-  @test
-  'mismatched elements'() {
-    let template = '{{#if this.admin}}<div>hi admin</div>{{else}}<p>HAXOR</p>{{/if}}';
-    this.renderServerSide(template, { admin: true });
-    this.assertServerOutput(OPEN, '<div>hi admin</div>', CLOSE);
+      // TODO: handle % % in the testing DSL
+      // this.assertStableNodes();
+      ctx.assertStableRerender();
+    });
 
-    this.renderClientSide(template, { admin: false });
-    this.assertRehydrationStats({ nodesRemoved: 1 });
-    this.assertHTML('<p>HAXOR</p>');
-    this.assertStableRerender();
-  }
+    test('mismatched elements', (ctx) => {
+      let template = '{{#if this.admin}}<div>hi admin</div>{{else}}<p>HAXOR</p>{{/if}}';
+      ctx.renderServerSide(template, { admin: true });
+      ctx.assertServerOutput(OPEN, '<div>hi admin</div>', CLOSE);
 
-  @test
-  'text nodes surrounding single line handlebars comments'() {
-    let template = 'hello{{! hmm, why is this here?! }} world';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('hello', '<!--%|%-->', ' world');
+      ctx.renderClientSide(template, { admin: false });
+      ctx.assertRehydrationStats({ nodesRemoved: 1 });
+      ctx.assertHTML('<p>HAXOR</p>');
+      ctx.assertStableRerender();
+    });
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('hello world');
-    this.assertStableRerender();
-  }
+    test('text nodes surrounding single line handlebars comments', (ctx) => {
+      let template = 'hello{{! hmm, why is this here?! }} world';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('hello', '<!--%|%-->', ' world');
 
-  @test
-  'text nodes surrounding multi line handlebars comments'() {
-    let template = 'hello{{!-- hmm, why is this here?! --}} world';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('hello', '<!--%|%-->', ' world');
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('hello world');
+      ctx.assertStableRerender();
+    });
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('hello world');
-    this.assertStableRerender();
-  }
+    test('text nodes surrounding multi line handlebars comments', (ctx) => {
+      let template = 'hello{{!-- hmm, why is this here?! --}} world';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('hello', '<!--%|%-->', ' world');
 
-  @test
-  'text nodes surrounding "stand alone" handlebars comment'() {
-    let template = '<div></div>\n{{! hmm, why is this here?! }}\n<div></div>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<div></div>', '\n', '<div></div>');
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('hello world');
+      ctx.assertStableRerender();
+    });
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('<div></div>\n<div></div>');
-    this.assertStableRerender();
-  }
+    test('text nodes surrounding "stand alone" handlebars comment', (ctx) => {
+      let template = '<div></div>\n{{! hmm, why is this here?! }}\n<div></div>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<div></div>', '\n', '<div></div>');
 
-  @test
-  'extra nodes at the end'() {
-    let template =
-      '{{#if this.admin}}<div>hi admin</div>{{else}}<div>HAXOR{{this.stopHaxing}}</div>{{/if}}';
-    this.renderServerSide(template, { admin: false, stopHaxing: 'stahp' });
-    this.assertServerOutput(OPEN, '<div>HAXOR', OPEN, 'stahp', CLOSE, '</div>', CLOSE);
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('<div></div>\n<div></div>');
+      ctx.assertStableRerender();
+    });
 
-    this.renderClientSide(template, { admin: true });
-    this.assertRehydrationStats({ nodesRemoved: 1 });
-    this.assertHTML('<div>hi admin</div>');
-    this.assertStableRerender();
-  }
+    test('extra nodes at the end', (ctx) => {
+      let template =
+        '{{#if this.admin}}<div>hi admin</div>{{else}}<div>HAXOR{{this.stopHaxing}}</div>{{/if}}';
+      ctx.renderServerSide(template, { admin: false, stopHaxing: 'stahp' });
+      ctx.assertServerOutput(OPEN, '<div>HAXOR', OPEN, 'stahp', CLOSE, '</div>', CLOSE);
 
-  @test
-  'missing attributes'() {
-    let template = '<div data-foo="true"></div>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<div data-foo="true"></div>');
+      ctx.renderClientSide(template, { admin: true });
+      ctx.assertRehydrationStats({ nodesRemoved: 1 });
+      ctx.assertHTML('<div>hi admin</div>');
+      ctx.assertStableRerender();
+    });
 
-    // remove the attribute
-    let element = castToBrowser(this.element, 'HTML');
-    let [div] = this.guardArray({ children: element.children }, { min: 1 });
-    div.removeAttribute('data-foo');
+    test('missing attributes', (ctx) => {
+      let template = '<div data-foo="true"></div>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<div data-foo="true"></div>');
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('<div data-foo="true"></div>');
-    this.assertStableRerender();
-  }
+      // remove the attribute
+      let element = castToBrowser(ctx.element, 'HTML');
+      let [div] = ctx.guardArray({ children: element.children }, { min: 1 });
+      div.removeAttribute('data-foo');
 
-  @test
-  'remove extra attributes'() {
-    let template = '<div data-foo="true"></div>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<div data-foo="true"></div>');
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('<div data-foo="true"></div>');
+      ctx.assertStableRerender();
+    });
 
-    // add an extra attribute
-    let element = castToBrowser(this.element, 'HTML');
-    let [div] = this.guardArray({ children: element.children }, { min: 1 });
-    div.setAttribute('data-bar', 'oops');
+    test('remove extra attributes', (ctx) => {
+      let template = '<div data-foo="true"></div>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<div data-foo="true"></div>');
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('<div data-foo="true"></div>');
-    this.assertStableRerender();
-  }
+      // add an extra attribute
+      let element = castToBrowser(ctx.element, 'HTML');
+      let [div] = ctx.guardArray({ children: element.children }, { min: 1 });
+      div.setAttribute('data-bar', 'oops');
 
-  @test
-  'updates attribute to current value'() {
-    let template = '<div class="always-present show-me"></div>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<div class="always-present show-me"></div>');
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('<div data-foo="true"></div>');
+      ctx.assertStableRerender();
+    });
 
-    // mutate the attribute
-    let element = castToBrowser(this.element, 'HTML');
-    let [div] = this.guardArray({ children: element.children }, { min: 1 });
-    div.setAttribute('class', 'zomg');
+    test('updates attribute to current value', (ctx) => {
+      let template = '<div class="always-present show-me"></div>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<div class="always-present show-me"></div>');
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('<div class="always-present show-me"></div>');
-    this.assertStableRerender();
-  }
+      // mutate the attribute
+      let element = castToBrowser(ctx.element, 'HTML');
+      let [div] = ctx.guardArray({ children: element.children }, { min: 1 });
+      div.setAttribute('class', 'zomg');
 
-  @test
-  'does not mutate attributes that already match'() {
-    let observer = new MutationObserver((mutationList) => {
-      mutationList.forEach((mutation) => {
-        let target = castToBrowser(mutation.target, 'HTML');
-        this.assert.ok(
-          false,
-          `should not have updated ${mutation.attributeName} on ${target.outerHTML}`
-        );
-      });
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('<div class="always-present show-me"></div>');
+      ctx.assertStableRerender();
     });
 
-    let template = '<div data-foo="whatever"></div>';
-    this.renderServerSide(template, {});
-    this.assertServerOutput('<div data-foo="whatever"></div>');
-
-    observer.observe(castToBrowser(this.element, 'HTML'), { attributes: true, subtree: true });
+    test('does not mutate attributes that already match', (ctx) => {
+      let observer = new MutationObserver((mutationList) => {
+        mutationList.forEach((mutation) => {
+          let target = castToBrowser(mutation.target, 'HTML');
+          ctx.assert.ok(
+            false,
+            `should not have updated ${mutation.attributeName} on ${target.outerHTML}`
+          );
+        });
+      });
 
-    this.renderClientSide(template, {});
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML('<div data-foo="whatever"></div>');
-    this.assertStableRerender();
-  }
+      let template = '<div data-foo="whatever"></div>';
+      ctx.renderServerSide(template, {});
+      ctx.assertServerOutput('<div data-foo="whatever"></div>');
 
-  @test
-  'Node curlies'() {
-    let template = '<div>{{this.node}}</div>';
-
-    let doc = this.delegate.serverDoc;
-    let node = doc.createTextNode('hello');
-    this.renderServerSide(template, { node });
-    this.assertServerOutput('<div>', OPEN, 'hello', CLOSE, '</div>');
-    doc = this.delegate.clientDoc;
-    let clientNode = doc.createTextNode('hello');
-    this.context = { node: clientNode };
-    this.renderClientSide(template, { node: clientNode });
-    this.assertHTML('<div>hello</div>', 'first clean rerender');
-    // Just repairs the value of the text node
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertStableRerender();
+      observer.observe(castToBrowser(ctx.element, 'HTML'), { attributes: true, subtree: true });
 
-    let clientNode2 = doc.createTextNode('goodbye');
-    this.rerender({ node: clientNode2 });
-    this.assertHTML('<div>goodbye</div>', 'rerender after node update');
-    this.assertStableNodes({ except: clientNode });
+      ctx.renderClientSide(template, {});
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML('<div data-foo="whatever"></div>');
+      ctx.assertStableRerender();
+    });
 
-    this.rerender({ node: clientNode });
-    this.assertHTML('<div>hello</div>', 'back to the beginning');
-    this.assertStableNodes({ except: clientNode2 });
-  }
+    test('Node curlies', (ctx) => {
+      let template = '<div>{{this.node}}</div>';
+
+      let doc = ctx.delegate.serverDoc;
+      let node = doc.createTextNode('hello');
+      ctx.renderServerSide(template, { node });
+      ctx.assertServerOutput('<div>', OPEN, 'hello', CLOSE, '</div>');
+      doc = ctx.delegate.clientDoc;
+      let clientNode = doc.createTextNode('hello');
+      ctx.renderClientSide(template, { node: clientNode });
+      ctx.assertHTML('<div>hello</div>', 'first clean rerender');
+      // Just repairs the value of the text node
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertStableRerender();
+
+      let clientNode2 = doc.createTextNode('goodbye');
+      ctx.rerender({ node: clientNode2 });
+      ctx.assertHTML('<div>goodbye</div>', 'rerender after node update');
+      ctx.assertStableNodes({ except: clientNode });
+
+      ctx.rerender({ node: clientNode });
+      ctx.assertHTML('<div>hello</div>', 'back to the beginning');
+      ctx.assertStableNodes({ except: clientNode2 });
+    });
 
-  @test
-  'in-element can rehydrate'() {
-    let template = strip`
+    test('in-element can rehydrate', (ctx) => {
+      let template = strip`
       <outer><prefix></prefix>
       {{#in-element this.remote}}<inner>Wat Wat</inner>{{/in-element}}
       <suffix></suffix></outer>
       `;
-    let doc = this.delegate.serverDoc;
-    let remote = doc.createElement('remote');
-    let prefix = doc.createElement('prefix');
-    let suffix = doc.createElement('suffix');
-    remote.appendChild(prefix);
-    remote.appendChild(suffix);
-
-    this.renderServerSide(template, { remote });
-    let serializedRemote = this.delegate.serialize(remote);
-    let b = blockStack();
-    assertSerializedInElement(
-      serializedRemote,
-      strip`
+      let doc = ctx.delegate.serverDoc;
+      let remote = doc.createElement('remote');
+      let prefix = doc.createElement('prefix');
+      let suffix = doc.createElement('suffix');
+      remote.appendChild(prefix);
+      remote.appendChild(suffix);
+
+      ctx.renderServerSide(template, { remote });
+      let serializedRemote = ctx.delegate.serialize(remote);
+      let b = blockStack();
+      assertSerializedInElement(
+        serializedRemote,
+        strip`
       ${b(2)}
       <inner>Wat Wat</inner>
       ${b(2)}
     `
-    );
-
-    doc = this.delegate.clientDoc;
-    let clientRemote = (remote = doc.createElement('remote'));
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemote);
-    replaceHTML(clientRemote, serializedRemote);
-    this.element = assertingElement(host.firstChild);
-
-    this.renderClientSide(template, { remote: clientRemote });
-    this.assertRehydrationStats({ nodesRemoved: 2 });
-    this.assert.strictEqual(toInnerHTML(clientRemote), '<inner>Wat Wat</inner>');
-  }
+      );
+
+      doc = ctx.delegate.clientDoc;
+      let clientRemote = (remote = doc.createElement('remote'));
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemote);
+      replaceHTML(clientRemote, serializedRemote);
+      ctx.element = assertingElement(host.firstChild);
+
+      ctx.renderClientSide(template, { remote: clientRemote });
+      ctx.assertRehydrationStats({ nodesRemoved: 2 });
+      ctx.assert.strictEqual(toInnerHTML(clientRemote), '<inner>Wat Wat</inner>');
+    });
 
-  @test
-  'in-element with insertBefore=null can rehydrate'() {
-    let template = strip`
+    test('in-element with insertBefore=null can rehydrate', (ctx) => {
+      let template = strip`
       <outer><prefix></prefix>
       {{#in-element this.remote insertBefore=null}}<inner>Wat Wat</inner>{{/in-element}}
       <suffix></suffix></outer>
       `;
-    let doc = this.delegate.serverDoc;
-    let remote = doc.createElement('remote');
-    let prefix = doc.createElement('prefix');
-    let suffix = doc.createElement('suffix');
-    remote.appendChild(prefix);
-    remote.appendChild(suffix);
-
-    this.renderServerSide(template, { remote });
-    let serializedRemote = this.delegate.serialize(remote);
-    let b = blockStack();
-    assertSerializedInElement(
-      serializedRemote,
-      strip`
+      let doc = ctx.delegate.serverDoc;
+      let remote = doc.createElement('remote');
+      let prefix = doc.createElement('prefix');
+      let suffix = doc.createElement('suffix');
+      remote.appendChild(prefix);
+      remote.appendChild(suffix);
+
+      ctx.renderServerSide(template, { remote });
+      let serializedRemote = ctx.delegate.serialize(remote);
+      let b = blockStack();
+      assertSerializedInElement(
+        serializedRemote,
+        strip`
       ${b(2)}
       <inner>Wat Wat</inner>
       ${b(2)}
     `
-    );
-
-    doc = this.delegate.clientDoc;
-    let clientRemote = (remote = doc.createElement('remote'));
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemote);
-    replaceHTML(clientRemote, serializedRemote);
-    this.element = assertingElement(host.firstChild);
-
-    this.renderClientSide(template, { remote: clientRemote });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assert.strictEqual(
-      toInnerHTML(clientRemote),
-      '<prefix></prefix><suffix></suffix><inner>Wat Wat</inner>'
-    );
-  }
+      );
+
+      doc = ctx.delegate.clientDoc;
+      let clientRemote = (remote = doc.createElement('remote'));
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemote);
+      replaceHTML(clientRemote, serializedRemote);
+      ctx.element = assertingElement(host.firstChild);
+
+      ctx.renderClientSide(template, { remote: clientRemote });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assert.strictEqual(
+        toInnerHTML(clientRemote),
+        '<prefix></prefix><suffix></suffix><inner>Wat Wat</inner>'
+      );
+    });
 
-  @test
-  'in-element with insertBefore=element can rehydrate'() {
-    let template = strip`
+    test('in-element with insertBefore=element can rehydrate', (ctx) => {
+      let template = strip`
       <outer><prefix></prefix>
       {{#in-element this.remote insertBefore=this.prefix}}<inner>Wat Wat</inner>{{/in-element}}
       <suffix></suffix></outer>
       `;
-    let doc = this.delegate.serverDoc;
-    let remote = doc.createElement('remote');
-    let prefix = doc.createElement('prefix');
-    let suffix = doc.createElement('suffix');
-    remote.appendChild(prefix);
-    remote.appendChild(suffix);
-
-    this.renderServerSide(template, { remote, prefix, suffix });
-    let serializedRemote = this.delegate.serialize(remote);
-    let b = blockStack();
-    assertSerializedInElement(
-      serializedRemote,
-      strip`
+      let doc = ctx.delegate.serverDoc;
+      let remote = doc.createElement('remote');
+      let prefix = doc.createElement('prefix');
+      let suffix = doc.createElement('suffix');
+      remote.appendChild(prefix);
+      remote.appendChild(suffix);
+
+      ctx.renderServerSide(template, { remote, prefix, suffix });
+      let serializedRemote = ctx.delegate.serialize(remote);
+      let b = blockStack();
+      assertSerializedInElement(
+        serializedRemote,
+        strip`
       ${b(2)}
       <inner>Wat Wat</inner>
       ${b(2)}
       <prefix></prefix>
       <suffix></suffix>
     `
-    );
-
-    doc = this.delegate.clientDoc;
-    let clientRemote = (remote = doc.createElement('remote'));
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemote);
-    replaceHTML(clientRemote, serializedRemote);
-    this.element = assertingElement(host.firstChild);
-    let clientPrefix = clientRemote.childNodes[4];
-
-    this.renderClientSide(template, { remote: clientRemote, prefix: clientPrefix });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assert.strictEqual(
-      toInnerHTML(clientRemote),
-      '<inner>Wat Wat</inner><prefix></prefix><suffix></suffix>'
-    );
-  }
+      );
+
+      doc = ctx.delegate.clientDoc;
+      let clientRemote = (remote = doc.createElement('remote'));
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemote);
+      replaceHTML(clientRemote, serializedRemote);
+      ctx.element = assertingElement(host.firstChild);
+      let clientPrefix = clientRemote.childNodes[4];
+
+      ctx.renderClientSide(template, { remote: clientRemote, prefix: clientPrefix });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assert.strictEqual(
+        toInnerHTML(clientRemote),
+        '<inner>Wat Wat</inner><prefix></prefix><suffix></suffix>'
+      );
+    });
 
-  @test
-  'in-element can rehydrate into pre-existing content'() {
-    let template = strip`
+    test('in-element can rehydrate into pre-existing content', (ctx) => {
+      let template = strip`
       <outer>
       {{#in-element this.remote insertBefore=undefined}}<inner>Wat Wat</inner>{{/in-element}}
       </outer>
       `;
-    let doc = this.delegate.serverDoc;
-    let remote = doc.createElement('remote');
-
-    this.renderServerSide(template, { remote });
-    let serializedRemote = '<preexisting><preexisting>';
-
-    doc = this.delegate.clientDoc;
-    let clientRemote = (remote = doc.createElement('remote'));
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemote);
-    replaceHTML(clientRemote, serializedRemote);
-    this.element = assertingElement(host.firstChild);
-
-    this.renderClientSide(template, { remote: clientRemote });
-    this.assertRehydrationStats({ nodesRemoved: 1 });
-    this.assert.strictEqual(toInnerHTML(clientRemote), '<inner>Wat Wat</inner>');
-  }
+      let doc = ctx.delegate.serverDoc;
+      let remote = doc.createElement('remote');
+
+      ctx.renderServerSide(template, { remote });
+      let serializedRemote = '<preexisting><preexisting>';
+
+      doc = ctx.delegate.clientDoc;
+      let clientRemote = (remote = doc.createElement('remote'));
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemote);
+      replaceHTML(clientRemote, serializedRemote);
+      ctx.element = assertingElement(host.firstChild);
+
+      ctx.renderClientSide(template, { remote: clientRemote });
+      ctx.assertRehydrationStats({ nodesRemoved: 1 });
+      ctx.assert.strictEqual(toInnerHTML(clientRemote), '<inner>Wat Wat</inner>');
+    });
 
-  @test
-  'in-element with insertBefore=null can rehydrate into pre-existing content'() {
-    let template = strip`
+    test('in-element with insertBefore=null can rehydrate into pre-existing content', (ctx) => {
+      let template = strip`
       <outer>
       {{#in-element this.remote insertBefore=null}}<inner>Wat Wat</inner>{{/in-element}}
       </outer>
       `;
-    let doc = this.delegate.serverDoc;
-    let remote = doc.createElement('remote');
-    let preexisting = doc.createElement('preexisting');
-    remote.appendChild(preexisting);
-
-    this.renderServerSide(template, { remote, preexisting });
-    let serializedRemote = '<preexisting></preexisting>';
-
-    doc = this.delegate.clientDoc;
-    let clientRemote = (remote = doc.createElement('remote'));
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemote);
-    replaceHTML(clientRemote, serializedRemote);
-    this.element = assertingElement(host.firstChild);
-
-    this.renderClientSide(template, { remote: clientRemote });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assert.strictEqual(
-      toInnerHTML(clientRemote),
-      '<preexisting></preexisting><inner>Wat Wat</inner>'
-    );
-  }
+      let doc = ctx.delegate.serverDoc;
+      let remote = doc.createElement('remote');
+      let preexisting = doc.createElement('preexisting');
+      remote.appendChild(preexisting);
+
+      ctx.renderServerSide(template, { remote, preexisting });
+      let serializedRemote = '<preexisting></preexisting>';
+
+      doc = ctx.delegate.clientDoc;
+      let clientRemote = (remote = doc.createElement('remote'));
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemote);
+      replaceHTML(clientRemote, serializedRemote);
+      ctx.element = assertingElement(host.firstChild);
+
+      ctx.renderClientSide(template, { remote: clientRemote });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assert.strictEqual(
+        toInnerHTML(clientRemote),
+        '<preexisting></preexisting><inner>Wat Wat</inner>'
+      );
+    });
 
-  @test
-  'in-element with insertBefore=element can rehydrate into pre-existing content'() {
-    let template = strip`
+    test('in-element with insertBefore=element can rehydrate into pre-existing content', (ctx) => {
+      let template = strip`
       <outer>
       {{#in-element this.remote insertBefore=this.preexisting}}<inner>Wat Wat</inner>{{/in-element}}
       </outer>
       `;
-    let doc = this.delegate.serverDoc;
-    let remote = doc.createElement('remote');
-    let prefix = doc.createElement('prefix');
-    let preexisting = doc.createElement('preexisting');
-    remote.appendChild(prefix);
-    remote.appendChild(preexisting);
-
-    this.renderServerSide(template, { remote, prefix, preexisting });
-    let serializedRemote = '<prefix></prefix><preexisting></preexisting>';
-
-    doc = this.delegate.clientDoc;
-    let clientRemote = (remote = doc.createElement('remote'));
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemote);
-    replaceHTML(clientRemote, serializedRemote);
-    let clientPreexisting = clientRemote.childNodes[1];
-    this.element = assertingElement(host.firstChild);
-
-    this.renderClientSide(template, {
-      remote: clientRemote,
-      prefix,
-      preexisting: clientPreexisting,
+      let doc = ctx.delegate.serverDoc;
+      let remote = doc.createElement('remote');
+      let prefix = doc.createElement('prefix');
+      let preexisting = doc.createElement('preexisting');
+      remote.appendChild(prefix);
+      remote.appendChild(preexisting);
+
+      ctx.renderServerSide(template, { remote, prefix, preexisting });
+      let serializedRemote = '<prefix></prefix><preexisting></preexisting>';
+
+      doc = ctx.delegate.clientDoc;
+      let clientRemote = (remote = doc.createElement('remote'));
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemote);
+      replaceHTML(clientRemote, serializedRemote);
+      let clientPreexisting = clientRemote.childNodes[1];
+      ctx.element = assertingElement(host.firstChild);
+
+      ctx.renderClientSide(template, {
+        remote: clientRemote,
+        prefix,
+        preexisting: clientPreexisting,
+      });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assert.strictEqual(
+        toInnerHTML(clientRemote),
+        '<prefix></prefix><inner>Wat Wat</inner><preexisting></preexisting>'
+      );
     });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assert.strictEqual(
-      toInnerHTML(clientRemote),
-      '<prefix></prefix><inner>Wat Wat</inner><preexisting></preexisting>'
-    );
-  }
 
-  @test
-  'nested in-element can rehydrate'() {
-    let template = strip`
+    test('nested in-element can rehydrate', (ctx) => {
+      let template = strip`
     <outer>
       {{#in-element this.remoteParent}}
         <inner>{{#in-element this.remoteChild}}Wat Wat{{/in-element}}</inner>
       {{/in-element}}
     </outer>
     `;
-    let doc = this.delegate.serverDoc;
-    let remoteParent = doc.createElement('remote');
-    let remoteChild = doc.createElement('other');
-
-    this.renderServerSide(template, { remoteParent, remoteChild });
-    let serializedParentRemote = this.delegate.serialize(remoteParent);
-    let serializedRemoteChild = this.delegate.serialize(remoteChild);
-    let b = blockStack();
-    assertSerializedInElement(
-      serializedParentRemote,
-      strip`
+      let doc = ctx.delegate.serverDoc;
+      let remoteParent = doc.createElement('remote');
+      let remoteChild = doc.createElement('other');
+
+      ctx.renderServerSide(template, { remoteParent, remoteChild });
+      let serializedParentRemote = ctx.delegate.serialize(remoteParent);
+      let serializedRemoteChild = ctx.delegate.serialize(remoteChild);
+      let b = blockStack();
+      assertSerializedInElement(
+        serializedParentRemote,
+        strip`
       ${b(2)}
         <inner>
           ${b(3)}<!---->${b(3)}
         </inner>
       ${b(2)}
     `,
-      'Serialized parent remote'
-    );
-    assertSerializedInElement(
-      serializedRemoteChild,
-      strip`
+        'Serialized parent remote'
+      );
+      assertSerializedInElement(
+        serializedRemoteChild,
+        strip`
       ${b(4)}Wat Wat${b(4)}
     `,
-      'Serialized nested remote'
-    );
-    doc = this.delegate.clientDoc;
-    let clientRemoteParent = doc.createElement('remote');
-    let clientRemoteChild = doc.createElement('other');
-    let host = doc.createElement('div');
-    host.appendChild(this.element);
-    host.appendChild(clientRemoteParent);
-    host.appendChild(clientRemoteChild);
-
-    replaceHTML(clientRemoteParent, serializedParentRemote);
-    replaceHTML(clientRemoteChild, serializedRemoteChild);
-    this.element = assertingElement(host.firstChild);
-    this.renderClientSide(template, {
-      remoteParent: clientRemoteParent,
-      remoteChild: clientRemoteChild,
+        'Serialized nested remote'
+      );
+      doc = ctx.delegate.clientDoc;
+      let clientRemoteParent = doc.createElement('remote');
+      let clientRemoteChild = doc.createElement('other');
+      let host = doc.createElement('div');
+      host.appendChild(ctx.element);
+      host.appendChild(clientRemoteParent);
+      host.appendChild(clientRemoteChild);
+
+      replaceHTML(clientRemoteParent, serializedParentRemote);
+      replaceHTML(clientRemoteChild, serializedRemoteChild);
+      ctx.element = assertingElement(host.firstChild);
+      ctx.renderClientSide(template, {
+        remoteParent: clientRemoteParent,
+        remoteChild: clientRemoteChild,
+      });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assert.strictEqual(toInnerHTML(clientRemoteParent), '<inner><!----></inner>');
+      ctx.assert.strictEqual(toInnerHTML(clientRemoteChild), 'Wat Wat');
     });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assert.strictEqual(toInnerHTML(clientRemoteParent), '<inner><!----></inner>');
-    this.assert.strictEqual(toInnerHTML(clientRemoteChild), 'Wat Wat');
-  }
 
-  @test
-  'svg elements'() {
-    let template = '<svg>{{#if this.isTrue}}<circle />{{/if}}</svg><p>Hello</p>';
-    this.renderServerSide(template, { isTrue: true });
-    let b = blockStack();
-    this.assertHTML(strip`
+    test('svg elements', (ctx) => {
+      let template = '<svg>{{#if this.isTrue}}<circle />{{/if}}</svg><p>Hello</p>';
+      ctx.renderServerSide(template, { isTrue: true });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       <svg>
         ${b(1)}
@@ -711,49 +681,47 @@ class Rehydration extends AbstractRehydrationTests {
       <p>Hello</p>
       ${b(0)}
     `);
-    this.renderClientSide(template, { isTrue: true });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML(strip`
+      ctx.renderClientSide(template, { isTrue: true });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML(strip`
       <svg>
       <circle />
       </svg>
       <p>Hello</p>
     `);
-    this.assertStableRerender();
-  }
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'title tag'() {
-    let template =
-      '<title>{{this.pageTitle}} some {{{this.other}}}{{this.thing}} <b>hey!</b></title>';
-    this.renderServerSide(template, { pageTitle: 'kiwi', other: 'other', thing: 'thing' });
-    let b = blockStack();
-    this.assertHTML(strip`
+    test('title tag', (ctx) => {
+      let template =
+        '<title>{{this.pageTitle}} some {{{this.other}}}{{this.thing}} <b>hey!</b></title>';
+      ctx.renderServerSide(template, { pageTitle: 'kiwi', other: 'other', thing: 'thing' });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       <title>
         kiwi some otherthing <b>hey!</b>
       </title>
       ${b(0)}
     `);
-    this.renderClientSide(template, { pageTitle: 'kiwi', other: 'other', thing: 'thing' });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML(strip`
+      ctx.renderClientSide(template, { pageTitle: 'kiwi', other: 'other', thing: 'thing' });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML(strip`
       <title>
         kiwi some otherthing <b>hey!</b>
       </title>
     `);
-    this.assertStableRerender();
-  }
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'script tag'() {
-    let template = strip`
+    test('script tag', (ctx) => {
+      let template = strip`
       <script type="application/ld+json">{{this.data}}</script>
       <script type="application/ld+json">{{this.otherData}}</script>
     `;
-    this.renderServerSide(template, { data: '{ "status": "ok" }', otherData: '{ "code": 200 }' });
-    let b = blockStack();
-    this.assertHTML(strip`
+      ctx.renderServerSide(template, { data: '{ "status": "ok" }', otherData: '{ "code": 200 }' });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       <script type="application/ld+json">
         { "status": "ok" }
@@ -764,9 +732,9 @@ class Rehydration extends AbstractRehydrationTests {
       </script>
       ${b(0)}
     `);
-    this.renderClientSide(template, { data: '{ "status": "ok" }', otherData: '{ "code": 200 }' });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML(strip`
+      ctx.renderClientSide(template, { data: '{ "status": "ok" }', otherData: '{ "code": 200 }' });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML(strip`
       <script type="application/ld+json">
         { "status": "ok" }
       </script>
@@ -775,43 +743,41 @@ class Rehydration extends AbstractRehydrationTests {
         { "code": 200 }
       </script>
     `);
-    this.assertStableRerender();
-  }
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'style tag'() {
-    let template = '<style>{{this.selector}} { color: #fff; }</style>';
-    this.renderServerSide(template, { selector: 'div' });
-    let b = blockStack();
-    this.assertHTML(strip`
+    test('style tag', (ctx) => {
+      let template = '<style>{{this.selector}} { color: #fff; }</style>';
+      ctx.renderServerSide(template, { selector: 'div' });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       <style>
         div { color: #fff; }
       </style>
       ${b(0)}
     `);
-    this.renderClientSide(template, { selector: 'div' });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML(strip`
+      ctx.renderClientSide(template, { selector: 'div' });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML(strip`
       <style>
         div { color: #fff; }
       </style>
     `);
-    this.assertStableRerender();
-  }
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'clearing bounds'() {
-    let template = strip`
+    test('clearing bounds', (ctx) => {
+      let template = strip`
       {{#if this.isTrue}}
         {{#each this.items key="id" as |item i|}}
           <p>{{item}}-{{i}}</p>
         {{/each}}
       {{/if}}
     `;
-    this.renderServerSide(template, { isTrue: true, items: [1, 2] });
-    let b = blockStack();
-    this.assertHTML(strip`
+      ctx.renderServerSide(template, { isTrue: true, items: [1, 2] });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       ${b(1)}
       ${b(2)}
@@ -844,16 +810,15 @@ class Rehydration extends AbstractRehydrationTests {
       ${b(0)}
     `);
 
-    this.renderClientSide(template, { isTrue: false, items: [3, 4] });
-    // Removes the block and each <p>
-    this.assertRehydrationStats({ nodesRemoved: 2 });
-    this.assertHTML('<!---->');
-    this.assertStableRerender();
-  }
+      ctx.renderClientSide(template, { isTrue: false, items: [3, 4] });
+      // Removes the block and each <p>
+      ctx.assertRehydrationStats({ nodesRemoved: 2 });
+      ctx.assertHTML('<!---->');
+      ctx.assertStableRerender();
+    });
 
-  @test
-  'top-level clearing bounds'() {
-    let template = strip`
+    test('top-level clearing bounds', (ctx) => {
+      let template = strip`
       <top>
       {{#if this.isTrue}}
         <inside>
@@ -869,9 +834,9 @@ class Rehydration extends AbstractRehydrationTests {
         {{/each}}
       {{/if}}
     `;
-    this.renderServerSide(template, { isTrue: true, items: [1, 2], isFalse: false });
-    let b = blockStack();
-    this.assertHTML(strip`
+      ctx.renderServerSide(template, { isTrue: true, items: [1, 2], isFalse: false });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       <top>
         ${b(1)}
@@ -911,19 +876,18 @@ class Rehydration extends AbstractRehydrationTests {
       ${b(0)}
     `);
 
-    this.renderClientSide(template, { isTrue: false, items: [3, 4], isFalse: true });
-    // Clears block markers for both and removes `inside`
-    this.assertRehydrationStats({ nodesRemoved: 1 });
-    this.assertHTML('<top><!----></top><p>3-0</p><p>4-1</p>');
-    this.assertStableRerender();
-  }
+      ctx.renderClientSide(template, { isTrue: false, items: [3, 4], isFalse: true });
+      // Clears block markers for both and removes `inside`
+      ctx.assertRehydrationStats({ nodesRemoved: 1 });
+      ctx.assertHTML('<top><!----></top><p>3-0</p><p>4-1</p>');
+      ctx.assertStableRerender();
+    });
 
-  @test
-  '#each rehydration'() {
-    let template = "{{#each this.items key='id' as |item|}}<p>{{item}}</p>{{/each}}";
-    this.renderServerSide(template, { items: [1, 2, 3] });
-    let b = blockStack();
-    this.assertHTML(strip`
+    test('#each rehydration', (ctx) => {
+      let template = "{{#each this.items key='id' as |item|}}<p>{{item}}</p>{{/each}}";
+      ctx.renderServerSide(template, { items: [1, 2, 3] });
+      let b = blockStack();
+      ctx.assertHTML(strip`
       ${b(0)}
       ${b(1)}
       ${b(2)}
@@ -953,18 +917,29 @@ class Rehydration extends AbstractRehydrationTests {
       ${b(0)}
     `);
 
-    this.renderClientSide(template, { items: [1, 2, 4] });
-    this.assertRehydrationStats({ nodesRemoved: 0 });
-    this.assertHTML(strip`
+      ctx.renderClientSide(template, { items: [1, 2, 4] });
+      ctx.assertRehydrationStats({ nodesRemoved: 0 });
+      ctx.assertHTML(strip`
       <p>1</p>
       <p>2</p>
       <p>4</p>
     `);
-    this.assertStableRerender();
+      ctx.assertStableRerender();
+    });
   }
-}
+);
 
-class RehydratingComponents extends AbstractRehydrationTests {
+RehydrationTests.test(RehydrationDelegate);
+
+// On the server, elements come after block start boundaries.
+const SERVER_ELEMENT_OFFSET = 2;
+
+// the Dynamic test type is using {{component 'foo'}} style invocation
+// and therefore an extra node is added delineating the block start
+const SERVER_DYNAMIC_OFFSET = 3;
+
+@suite('Rehydrating components')
+class RehydratingComponents extends RehydrationContext {
   _buildComponent(blueprint: ComponentBlueprint, properties: Dict<unknown> = {}) {
     let template = this.buildComponent(blueprint);
     if (this.testType === 'Dynamic' && properties['componentName'] === undefined) {
@@ -973,16 +948,25 @@ class RehydratingComponents extends AbstractRehydrationTests {
     return template;
   }
 
-  assertServerComponent(html: string, attrs: Object = {}) {
-    // the Dynamic test type is using {{component 'foo'}} style invocation
-    // and therefore an extra node is added delineating the block start
-    let elementIndex = this.testType === 'Dynamic' ? 3 : 2;
+  assertServerComponent(html: string, attrs?: Dict) {
+    let elementIndex = this.testType === 'Dynamic' ? SERVER_DYNAMIC_OFFSET : SERVER_ELEMENT_OFFSET;
+
     let element = assertingElement(this.element.childNodes[elementIndex]);
 
-    if (this.testType === 'Glimmer') {
-      assertElementShape(element, 'div', attrs, html);
-    } else {
-      assertEmberishElement(element, 'div', attrs, html);
+    switch (this.testType) {
+      case 'TemplateOnly':
+        assertElementShape(element, 'div', attrs ?? {}, html);
+        break;
+
+      case 'Glimmer':
+        assertElementShape(element, 'div', attrs ?? {}, html);
+        break;
+      case 'Curly':
+        assertEmberishElement(element, 'div', attrs, html);
+        break;
+      case 'Dynamic':
+        assertEmberishElement(element, 'div', attrs, html);
+        break;
     }
   }
 
@@ -996,7 +980,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     super.renderClientSide(template, properties);
   }
 
-  @test
+  @render
   'Component invocations'() {
     let layout = 'Hello {{@name}}';
     let args = { name: 'this.name' };
@@ -1023,7 +1007,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Mismatched Component invocations'() {
     let layout = 'Hello {{@name}}';
     let args = { name: 'this.name' };
@@ -1050,7 +1034,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   '<p> invoking a block which emits a <div>'() {
     let componentToRender = {
       layout: '<p>hello {{#if @show}}<div>world!</div>{{/if}}</p>',
@@ -1077,7 +1061,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableNodes();
   }
 
-  @test
+  @render
   'Component invocations with block params'() {
     let layout = 'Hello {{yield @name}}';
     let template = '{{this.name}}';
@@ -1111,7 +1095,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Mismatched Component invocations with block params'() {
     let layout = 'Hello {{yield @name}}';
     let template = '{{this.name}}';
@@ -1145,7 +1129,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Component invocations with template'() {
     let layout = 'Hello {{yield}}';
     let template = 'Filewatcher';
@@ -1167,7 +1151,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Mismatched Component invocations with template'() {
     let layout = 'Hello {{yield}}';
     let template = 'Filewatcher';
@@ -1186,7 +1170,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Component invocations with empty args'() {
     let layout = 'Hello {{@foo}}';
     this.renderServerSide({
@@ -1204,7 +1188,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Multiple invocations'() {
     let name;
     let template;
@@ -1219,7 +1203,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
       template = '<FooBar>World</FooBar>';
     }
 
-    this.registerComponent(this.testType, name, 'Hello {{yield}}');
+    this.register.component(this.testType, name, 'Hello {{yield}}');
     let layout = `{{yield}}`;
     this.renderServerSide({
       layout,
@@ -1246,7 +1230,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'Mismatched Multiple invocations'() {
     let name;
     let template;
@@ -1261,7 +1245,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
       template = '<FooBar>World</FooBar>';
     }
 
-    this.registerComponent(this.testType, name, 'Hello {{yield}}');
+    this.register.component(this.testType, name, 'Hello {{yield}}');
     let layout = `{{yield}}`;
     this.renderServerSide({
       layout,
@@ -1292,7 +1276,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'interacting with builtins'() {
     let layout = strip`
       <ul>
@@ -1304,12 +1288,12 @@ class RehydratingComponents extends AbstractRehydrationTests {
           {{/if}}
         {{/each}}
       </ul>`;
-    this.registerHelper(
+    this.register.helper(
       'even',
       (params: ReadonlyArray<unknown>) => (params[0] as number) % 2 === 0
     );
     let template = '{{#if (even i)}}<FooBar @count={{i}} />{{/if}}';
-    this.registerComponent('TemplateOnly', 'FooBar', '<li>{{@count}}</li>');
+    this.register.component('TemplateOnly', 'FooBar', '<li>{{@count}}</li>');
     let blockParams = ['i'];
     let args = { items: 'this.items' };
 
@@ -1392,7 +1376,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertStableRerender();
   }
 
-  @test
+  @render
   'mismatched interacting with builtins'() {
     let layout = strip`
       <ul>
@@ -1404,12 +1388,12 @@ class RehydratingComponents extends AbstractRehydrationTests {
           {{/if}}
         {{/each}}
       </ul>`;
-    this.registerHelper(
+    this.register.helper(
       'even',
       (params: ReadonlyArray<unknown>) => (params[0] as number) % 2 === 0
     );
     let template = '{{#if (even i)}}<FooBar @count={{i}} />{{/if}}';
-    this.registerComponent('TemplateOnly', 'FooBar', '<li>{{@count}}</li>');
+    this.register.component('TemplateOnly', 'FooBar', '<li>{{@count}}</li>');
     let blockParams = ['i'];
     let args = { items: 'this.items' };
 
@@ -1491,7 +1475,7 @@ class RehydratingComponents extends AbstractRehydrationTests {
     this.assertComponent('<ul><li>Industry</li><li>Standard</li><li>Components</li></ul>');
   }
 
-  @test
+  @render
   'mismatched blocks interacting with builtins'() {
     let layout = strip`
       <ul>
@@ -1513,12 +1497,12 @@ class RehydratingComponents extends AbstractRehydrationTests {
         {{/each}}
       </ul>
     `;
-    this.registerHelper(
+    this.register.helper(
       'even',
       (params: ReadonlyArray<unknown>) => (params[0] as number) % 2 === 0
     );
     let template = '{{#if (even i)}}<FooBar @count={{i}} />{{/if}}';
-    this.registerComponent('TemplateOnly', 'FooBar', '<li>{{@count}}</li>');
+    this.register.component('TemplateOnly', 'FooBar', '<li>{{@count}}</li>');
     let blockParams = ['i'];
     let args = { items: 'this.items', things: 'this.things' };
 
@@ -1606,6 +1590,4 @@ class RehydratingComponents extends AbstractRehydrationTests {
   }
 }
 
-suite(Rehydration, RehydrationDelegate);
-jitSuite(RenderTests);
 componentSuite(RehydratingComponents, RehydrationDelegate);
diff --git a/packages/@glimmer-workspace/integration-tests/test/input-range-test.ts b/packages/@glimmer-workspace/integration-tests/test/input-range-test.ts
index 8ab6e30350..9a7eb5b5bb 100644
--- a/packages/@glimmer-workspace/integration-tests/test/input-range-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/input-range-test.ts
@@ -1,4 +1,6 @@
-import { EmberishCurlyComponent, type EmberishCurlyComponentFactory, jitSuite, test } from '..';
+import type {EmberishCurlyComponentFactory} from '../lib';
+
+import { EmberishCurlyComponent,  jitSuite, test } from '../lib';
 import { AttributesTests } from './attributes-test';
 
 abstract class RangeTests extends AttributesTests {
@@ -49,7 +51,7 @@ abstract class TemplateRangeTests extends RangeTests {
   abstract readonly attrs: string;
 
   renderRange(value: number) {
-    this.render(`<input ${this.attrs} />`, {
+    this.render.template(`<input ${this.attrs} />`, {
       max: this.max,
       min: this.min,
       value,
@@ -87,8 +89,8 @@ jitSuite(
     }
 
     renderRange(value: number): void {
-      this.registerComponent('Curly', 'range-input', '', this.component());
-      this.render(`{{range-input max=this.max min=this.min value=this.value}}`, {
+      this.register.component('Curly', 'range-input', '', this.component());
+      this.render.template(`{{range-input max=this.max min=this.min value=this.value}}`, {
         max: this.max,
         min: this.min,
         value,
@@ -108,8 +110,8 @@ jitSuite(
     attrs = 'type="range" value="%x" min="-5" max="50"';
 
     renderRange(value: number): void {
-      this.registerComponent('Glimmer', 'RangeInput', '<input ...attributes/>');
-      this.render(`<RangeInput ${this.attrs.replace('%x', value.toString())} />`);
+      this.register.component('Glimmer', 'RangeInput', '<input ...attributes/>');
+      this.render.template(`<RangeInput ${this.attrs.replace('%x', value.toString())} />`);
     }
 
     assertRangeValue(value: number): void {
@@ -125,8 +127,8 @@ jitSuite(
     attrs = 'type="range" value="%x" min="-5" max="50"';
 
     renderRange(value: number): void {
-      this.registerComponent('Glimmer', 'RangeInput', '<input type="text" ...attributes/>');
-      this.render(`<RangeInput ${this.attrs.replace('%x', value.toString())} />`);
+      this.register.component('Glimmer', 'RangeInput', '<input type="text" ...attributes/>');
+      this.render.template(`<RangeInput ${this.attrs.replace('%x', value.toString())} />`);
     }
 
     assertRangeValue(value: number): void {
@@ -142,12 +144,12 @@ jitSuite(
     attrs = 'type="text" min="-5" max="50"';
 
     renderRange(value: number): void {
-      this.registerComponent(
+      this.register.component(
         'Glimmer',
         'RangeInput',
         `<input ...attributes type="range" value="${value}" />`
       );
-      this.render(`<RangeInput ${this.attrs.replace('%x', value.toString())} />`);
+      this.render.template(`<RangeInput ${this.attrs.replace('%x', value.toString())} />`);
     }
 
     assertRangeValue(value: number): void {
diff --git a/packages/@glimmer-workspace/integration-tests/test/invalid-html-test.ts b/packages/@glimmer-workspace/integration-tests/test/invalid-html-test.ts
index c9349f053a..5559c52826 100644
--- a/packages/@glimmer-workspace/integration-tests/test/invalid-html-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/invalid-html-test.ts
@@ -1,106 +1,220 @@
-import { jitSuite, preprocess, RenderTest, syntaxErrorFor, test } from '..';
-
-class CompileErrorTests extends RenderTest {
+import {
+  jitSuite,
+  preprocess,
+  RenderTestContext,
+  syntaxErrorFor,
+  test,
+} from '@glimmer-workspace/integration-tests';
+
+class CompileErrorTests extends RenderTestContext {
   static suiteName = 'compile errors';
 
   @test
   'A helpful error message is provided for unclosed elements'() {
-    this.assert.throws(() => {
-      preprocess('\n<div class="my-div" \n foo={{bar}}>\n<span>\n</span>\n', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Unclosed element `div`', '<div class="my-div" \n foo={{bar}}>', 'test-module', 2, 0));
-
-    this.assert.throws(() => {
-      preprocess('\n<div class="my-div">\n<span>\n', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Unclosed element `span`', '<span>', 'test-module', 3, 0));
+    this.assert.throws(
+      () => {
+        preprocess('\n<div class="my-div" \n foo={{bar}}>\n<span>\n</span>\n', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Unclosed element `div`',
+        '<div class="my-div" \n foo={{bar}}>',
+        'test-module',
+        2,
+        0
+      )
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('\n<div class="my-div">\n<span>\n', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor('Unclosed element `span`', '<span>', 'test-module', 3, 0)
+    );
   }
 
   @test
   'A helpful error message is provided for unmatched end tags'() {
-    this.assert.throws(() => {
-      preprocess('</p>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Closing tag </p> without an open tag', '</p>', 'test-module', 1, 0));
-
-    this.assert.throws(() => {
-      preprocess('<em>{{ foo }}</em> \n {{ bar }}\n</div>', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Closing tag </div> without an open tag', '</div>', 'test-module', 3, 0));
+    this.assert.throws(
+      () => {
+        preprocess('</p>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor('Closing tag </p> without an open tag', '</p>', 'test-module', 1, 0)
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('<em>{{ foo }}</em> \n {{ bar }}\n</div>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor('Closing tag </div> without an open tag', '</div>', 'test-module', 3, 0)
+    );
   }
 
   @test
   'A helpful error message is provided for end tags for void elements'() {
-    this.assert.throws(() => {
-      preprocess('<input></input>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('<input> elements do not need end tags. You should remove it', '</input>', 'test-module', 1, 7));
+    this.assert.throws(
+      () => {
+        preprocess('<input></input>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '<input> elements do not need end tags. You should remove it',
+        '</input>',
+        'test-module',
+        1,
+        7
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('<div>\n  <input></input>\n</div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('<input> elements do not need end tags. You should remove it', '</input>', 'test-module', 2, 9));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n  <input></input>\n</div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '<input> elements do not need end tags. You should remove it',
+        '</input>',
+        'test-module',
+        2,
+        9
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('\n\n</br>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('<br> elements do not need end tags. You should remove it', '</br>', 'test-module', 3, 0));
+    this.assert.throws(
+      () => {
+        preprocess('\n\n</br>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '<br> elements do not need end tags. You should remove it',
+        '</br>',
+        'test-module',
+        3,
+        0
+      )
+    );
   }
 
   @test
   'A helpful error message is provided for end tags with attributes'() {
-    this.assert.throws(() => {
-      preprocess('<div>\nSomething\n\n</div foo="bar">', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Invalid end tag: closing tag must not have attributes', '</div foo="bar"', 'test-module', 4, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\nSomething\n\n</div foo="bar">', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Invalid end tag: closing tag must not have attributes',
+        '</div foo="bar"',
+        'test-module',
+        4,
+        0
+      )
+    );
   }
 
   @test
   'A helpful error message is provided for mismatched start/end tags'() {
-    this.assert.throws(() => {
-      preprocess('<div>\n<p>\nSomething\n\n</div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Closing tag </div> did not match last open tag <p> (on line 2)', '</div>', 'test-module', 5, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n<p>\nSomething\n\n</div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Closing tag </div> did not match last open tag <p> (on line 2)',
+        '</div>',
+        'test-module',
+        5,
+        0
+      )
+    );
   }
 
   @test
   'error line numbers include comment lines'() {
-    this.assert.throws(() => {
-      preprocess('<div>\n<p>\n{{! some comment}}\n\n</div>', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Closing tag </div> did not match last open tag <p> (on line 2)', '</div>', 'test-module', 5, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n<p>\n{{! some comment}}\n\n</div>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Closing tag </div> did not match last open tag <p> (on line 2)',
+        '</div>',
+        'test-module',
+        5,
+        0
+      )
+    );
   }
 
   @test
   'error line numbers include mustache only lines'() {
-    this.assert.throws(() => {
-      preprocess('<div>\n<p>\n{{someProp}}\n\n</div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Closing tag </div> did not match last open tag <p> (on line 2)', '</div>', 'test-module', 5, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n<p>\n{{someProp}}\n\n</div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Closing tag </div> did not match last open tag <p> (on line 2)',
+        '</div>',
+        'test-module',
+        5,
+        0
+      )
+    );
   }
 
   @test
   'error line numbers include block lines'() {
-    this.assert.throws(() => {
-      preprocess('<div>\n<p>\n{{#some-comment}}\n{{/some-comment}}\n</div>', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Closing tag </div> did not match last open tag <p> (on line 2)', '</div>', 'test-module', 5, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n<p>\n{{#some-comment}}\n{{/some-comment}}\n</div>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Closing tag </div> did not match last open tag <p> (on line 2)',
+        '</div>',
+        'test-module',
+        5,
+        0
+      )
+    );
   }
 
   @test
   'error line numbers include whitespace control mustaches'() {
-    this.assert.throws(() => {
-      preprocess('<div>\n<p>\n{{someProp~}}\n\n</div>{{some-comment}}', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Closing tag </div> did not match last open tag <p> (on line 2)', '</div>', 'test-module', 5, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n<p>\n{{someProp~}}\n\n</div>{{some-comment}}', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Closing tag </div> did not match last open tag <p> (on line 2)',
+        '</div>',
+        'test-module',
+        5,
+        0
+      )
+    );
   }
 
   @test
   'error line numbers include multiple mustache lines'() {
-    this.assert.throws(() => {
-      preprocess('<div>\n<p>\n{{some-comment}}</div>{{some-comment}}', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Closing tag </div> did not match last open tag <p> (on line 2)', '</div>', 'test-module', 3, 16));
+    this.assert.throws(
+      () => {
+        preprocess('<div>\n<p>\n{{some-comment}}</div>{{some-comment}}', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Closing tag </div> did not match last open tag <p> (on line 2)',
+        '</div>',
+        'test-module',
+        3,
+        16
+      )
+    );
   }
 
   @test
diff --git a/packages/@glimmer-workspace/integration-tests/test/invocation-generation-test.ts b/packages/@glimmer-workspace/integration-tests/test/invocation-generation-test.ts
index 0cfc5d17fa..5ac0e350e8 100644
--- a/packages/@glimmer-workspace/integration-tests/test/invocation-generation-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/invocation-generation-test.ts
@@ -1,364 +1,392 @@
-import { JitRenderDelegate, RenderTest } from '..';
-import { module } from './support';
-
-let renderTests: RenderTest;
-module(
-  'Render Tests: buildComponent',
-  {
-    beforeEach() {
-      renderTests = new RenderTest(new JitRenderDelegate());
-    },
-  },
-  ({ test }) => {
-    test('Can build basic glimmer invocation', (assert) => {
-      renderTests['testType'] = 'Glimmer';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello',
-      });
+import type { RenderTestState } from '@glimmer-workspace/integration-tests';
+import { RenderTestContext } from '@glimmer-workspace/integration-tests';
 
-      assert.strictEqual(invocation, '<TestComponent />');
-    });
+import type { DeclaredComponentType } from '../lib/test-helpers/constants';
+import type { ExpandType } from '../lib/test-helpers/module';
 
-    test('Can build glimmer invocation with template', (assert) => {
-      renderTests['testType'] = 'Glimmer';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-      });
+import { render, suite } from '../lib/test-decorator';
+import { jitSuite } from '../lib/test-helpers/module';
 
-      assert.strictEqual(invocation, '<TestComponent>World</TestComponent>');
+@suite('buildComponent')
+class BuildComponentTest extends RenderTestContext {
+  @render('glimmer') 'Can build basic glimmer invocation'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      layout: 'Hello',
     });
 
-    test('Can build glimmer invocation with args', (assert) => {
-      renderTests['testType'] = 'Glimmer';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, literal: "'literal'" },
-      });
+    assert.strictEqual(invocation, '<TestComponent />');
+  }
 
-      assert.strictEqual(
-        invocation,
-        "<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}} @literal='literal'>World</TestComponent>"
-      );
+  @render('glimmer') 'Can build glimmer invocation with template'(
+    assert: RenderTestState<'glimmer'>
+  ) {
+    // renderTests['testType'] = 'Glimmer';
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
     });
 
-    test('Can build glimmer invocation with attributes', (assert) => {
-      renderTests['testType'] = 'Glimmer';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-        attributes: { 'data-foo': 'bar', id: 'wat' },
-      });
+    assertGlimmerInvocation(assert, invocation, '<TestComponent>World</TestComponent>');
+  }
 
-      assert.strictEqual(
-        invocation,
-        '<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}} data-foo=bar id=wat>World</TestComponent>'
-      );
+  @render('glimmer') 'Can build glimmer invocation with args'(assert: RenderTestState<'glimmer'>) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, literal: "'literal'" },
     });
 
-    test('Can build glimmer invocation with custom tag name', (assert) => {
-      renderTests['testType'] = 'Glimmer';
-      let invocation = renderTests.buildComponent({
-        name: 'LolWat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-        attributes: { 'data-foo': '"bar"', id: '"wat"' },
-      });
+    assertGlimmerInvocation(
+      assert,
+      invocation,
+      "<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}} @literal='literal'>World</TestComponent>"
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `<LolWat @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat">World</LolWat>`
-      );
+  @render('glimmer') 'Can build glimmer invocation with attributes'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
+      attributes: { 'data-foo': 'bar', id: 'wat' },
     });
 
-    test('Can build glimmer invocation with block params', (assert) => {
-      renderTests['testType'] = 'Glimmer';
-      let invocation = renderTests.buildComponent({
-        name: 'Lol',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-        attributes: { 'data-foo': '"bar"', id: '"wat"' },
-        blockParams: ['a b c'],
-      });
+    assert.strictEqual(
+      invocation,
+      '<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}} data-foo={{bar}} id={{wat}}>World</TestComponent>'
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `<Lol @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat" as |a b c|>World</Lol>`
-      );
+  @render('glimmer') 'Can build glimmer invocation with custom tag name'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      name: 'LolWat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
+      attributes: { 'data-foo': '"bar"', id: '"wat"' },
     });
 
-    test('Can build basic curly invocation', (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello',
-      });
+    assert.strictEqual(
+      invocation,
+      `<LolWat @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat">World</LolWat>`
+    );
+  }
 
-      assert.strictEqual(invocation, '{{test-component}}');
+  @render('glimmer') 'Can build glimmer invocation with block params'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      name: 'Lol',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
+      attributes: { 'data-foo': '"bar"', id: '"wat"' },
+      blockParams: ['a b c'],
     });
 
-    test('Can build curly invocation with template', (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-      });
+    assert.strictEqual(
+      invocation,
+      `<Lol @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat" as |a b c|>World</Lol>`
+    );
+  }
 
-      assert.strictEqual(invocation, '{{#test-component}}World{{/test-component}}');
+  @render('curly') 'Can build basic curly invocation'(assert: RenderTestState<'curly'>) {
+    let invocation = this.buildComponent({
+      layout: 'Hello',
     });
 
-    test('Can build curly invocation with args', (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-      });
+    assertInvocation(assert, invocation, {
+      curly: '{{test-component}}',
+      dynamic: '{{component this.componentName}}',
+    });
+  }
 
-      assert.strictEqual(
-        invocation,
-        '{{#test-component foo=bar baz=1 bar=null}}World{{/test-component}}'
-      );
+  @render('curly') 'Can build curly invocation with template'(assert: RenderTestState<'curly'>) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
     });
 
-    test('Can build curly invocation with attributes throws', (assert) => {
-      renderTests['testType'] = 'Curly';
+    assertInvocation(assert, invocation, {
+      curly: '{{#test-component}}World{{/test-component}}',
+      dynamic: '{{#component this.componentName}}World{{/component}}',
+    });
+  }
 
-      assert.throws(() => {
-        renderTests.buildComponent({
-          layout: 'Hello {{yield}}',
-          template: 'World',
-          args: { foo: 'bar', baz: 1, bar: null },
-          attributes: { 'data-foo': '"bar"', id: '"wat"' },
-        });
-      }, /Cannot pass attributes to curly components/u);
+  @render('curly') 'Can build curly invocation with args'(assert: RenderTestState<'curly'>) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
     });
 
-    test("Can build curly invocation with 'attributes' in args", (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
+    assertInvocation(assert, invocation, {
+      curly: '{{#test-component foo=bar baz=1 bar=null}}World{{/test-component}}',
+      dynamic: '{{#component this.componentName foo=bar baz=1 bar=null}}World{{/component}}',
+    });
+  }
+
+  @render('curly') 'Can build curly invocation with attributes throws'(assert: RenderTestState) {
+    assert.throws(() => {
+      this.buildComponent({
         layout: 'Hello {{yield}}',
         template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
+        args: { foo: 'bar', baz: 1, bar: null },
+        attributes: { 'data-foo': '"bar"', id: '"wat"' },
       });
+    }, /Cannot pass attributes to curly components/u);
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#test-component foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/test-component}}`
-      );
+  @render('curly') "Can build curly invocation with 'attributes' in args"(
+    assert: RenderTestState<'curly'>
+  ) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
     });
 
-    test('Can build curly invocation with custom tag name', (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
-        name: 'lol-wat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
-      });
+    assertInvocation(assert, invocation, {
+      curly:
+        '{{#test-component foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/test-component}}',
+      dynamic:
+        '{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/component}}',
+    });
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#lol-wat foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/lol-wat}}`
-      );
+  @render('curly') 'Can build curly invocation with custom tag name'(
+    assert: RenderTestState<'curly'>
+  ) {
+    let invocation = this.buildComponent({
+      name: 'lol-wat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
     });
 
-    test('Can build curly invocation with block params', (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
-        name: 'lol-wat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
-        blockParams: ['a b c'],
-      });
+    assertInvocation(assert, invocation, {
+      curly: '{{#lol-wat foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/lol-wat}}',
+      dynamic:
+        '{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/component}}',
+    });
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#lol-wat foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{/lol-wat}}`
-      );
+  @render('curly') 'Can build curly invocation with block params'(
+    assert: RenderTestState<'curly'>
+  ) {
+    let invocation = this.buildComponent({
+      name: 'lol-wat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
+      blockParams: ['a b c'],
     });
 
-    test('Can build curly invocation with else', (assert) => {
-      renderTests['testType'] = 'Curly';
-      let invocation = renderTests.buildComponent({
-        name: 'lol-wat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
-        blockParams: ['a b c'],
-        else: 'ELSE',
-      });
+    assertInvocation(assert, invocation, {
+      curly:
+        '{{#lol-wat foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{/lol-wat}}',
+      dynamic:
+        '{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{/component}}',
+    });
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#lol-wat foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{else}}ELSE{{/lol-wat}}`
-      );
+  @render('curly') 'Can build curly invocation with else'(assert: RenderTestState<'curly'>) {
+    let invocation = this.buildComponent({
+      name: 'lol-wat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
+      blockParams: ['a b c'],
+      else: 'ELSE',
     });
 
-    test('Can build basic dynamic invocation', (assert) => {
-      renderTests['testType'] = 'Dynamic';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello',
-      });
+    assertInvocation(assert, invocation, {
+      curly:
+        '{{#lol-wat foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{else}}ELSE{{/lol-wat}}',
+      dynamic:
+        '{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{else}}ELSE{{/component}}',
+    });
+  }
 
-      assert.strictEqual(invocation, '{{component this.componentName}}');
+  @render('dynamic') 'Can build basic dynamic invocation'(assert: RenderTestState<'dynamic'>) {
+    let invocation = this.buildComponent({
+      layout: 'Hello',
     });
 
-    test('Can build dynamic invocation with template', (assert) => {
-      renderTests['testType'] = 'Dynamic';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-      });
+    assertInvocation(assert, invocation, {
+      dynamic: '{{component this.componentName}}',
+    });
+  }
 
-      assert.strictEqual(invocation, '{{#component this.componentName}}World{{/component}}');
+  @render('dynamic') 'Can build dynamic invocation with template'(
+    assert: RenderTestState<'dynamic'>
+  ) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
     });
 
-    test('Can build dynamic invocation with args', (assert) => {
-      renderTests['testType'] = 'Dynamic';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-      });
+    assertInvocation(assert, invocation, {
+      dynamic: '{{#component this.componentName}}World{{/component}}',
+    });
+  }
 
-      assert.strictEqual(
-        invocation,
-        '{{#component this.componentName foo=bar baz=1 bar=null}}World{{/component}}'
-      );
+  @render('dynamic') 'Can build dynamic invocation with args'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
     });
 
-    test('Can build dynamic invocation with custom tag name', (assert) => {
-      renderTests['testType'] = 'Dynamic';
-      let invocation = renderTests.buildComponent({
-        name: 'lol-wat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
-      });
+    assert.strictEqual(
+      invocation,
+      '{{#component this.componentName foo=bar baz=1 bar=null}}World{{/component}}'
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/component}}`
-      );
+  @render('dynamic') 'Can build dynamic invocation with custom tag name'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      name: 'lol-wat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
     });
 
-    test('Can build dynamic invocation with block params', (assert) => {
-      renderTests['testType'] = 'Dynamic';
-      let invocation = renderTests.buildComponent({
-        name: 'lol-wat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
-        blockParams: ['a b c'],
-      });
+    assert.strictEqual(
+      invocation,
+      `{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat"}}World{{/component}}`
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{/component}}`
-      );
+  @render('dynamic') 'Can build dynamic invocation with block params'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      name: 'lol-wat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
+      blockParams: ['a b c'],
     });
 
-    test('Can build dynamic invocation with else', (assert) => {
-      renderTests['testType'] = 'Dynamic';
-      let invocation = renderTests.buildComponent({
-        name: 'lol-wat',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
-        blockParams: ['a b c'],
-        else: 'ELSE',
-      });
+    assert.strictEqual(
+      invocation,
+      `{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{/component}}`
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{else}}ELSE{{/component}}`
-      );
+  @render('dynamic') 'Can build dynamic invocation with else'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      name: 'lol-wat',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null, 'data-foo': '"bar"', id: '"wat"' },
+      blockParams: ['a b c'],
+      else: 'ELSE',
     });
 
-    test('Can build basic component invocation', (assert) => {
-      renderTests['testType'] = 'TemplateOnly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello',
-      });
+    assert.strictEqual(
+      invocation,
+      `{{#component this.componentName foo=bar baz=1 bar=null data-foo="bar" id="wat" as |a b c|}}World{{else}}ELSE{{/component}}`
+    );
+  }
 
-      assert.strictEqual(invocation, '<TestComponent />');
+  @render('templateOnly') 'Can build basic component invocation'(assert: RenderTestState) {
+    let invocation = this.buildComponent({
+      layout: 'Hello',
     });
 
-    test('Can build basic component invocation with template', (assert) => {
-      renderTests['testType'] = 'TemplateOnly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-      });
+    assert.strictEqual(invocation, '<TestComponent />');
+  }
 
-      assert.strictEqual(invocation, '<TestComponent>World</TestComponent>');
+  @render('templateOnly') 'Can build basic component invocation with template'(
+    assert: RenderTestState
+  ) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
     });
 
-    test('Can build basic component invocation with args', (assert) => {
-      renderTests['testType'] = 'TemplateOnly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-      });
+    assert.strictEqual(invocation, '<TestComponent>World</TestComponent>');
+  }
 
-      assert.strictEqual(
-        invocation,
-        '<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}}>World</TestComponent>'
-      );
+  @render('templateOnly') 'Can build basic component invocation with args'(
+    assert: RenderTestState
+  ) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
     });
 
-    test('Can build basic component invocation with attributes', (assert) => {
-      renderTests['testType'] = 'TemplateOnly';
-      let invocation = renderTests.buildComponent({
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-        attributes: { 'data-foo': 'bar', id: 'wat' },
-      });
+    assert.strictEqual(
+      invocation,
+      '<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}}>World</TestComponent>'
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        '<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}} data-foo=bar id=wat>World</TestComponent>'
-      );
+  @render('templateOnly') 'Can build basic component invocation with attributes'(
+    assert: RenderTestState
+  ) {
+    let invocation = this.buildComponent({
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
+      attributes: { 'data-foo': 'bar', id: 'wat' },
     });
 
-    test('Can build basic component invocation with custom tag name', (assert) => {
-      renderTests['testType'] = 'TemplateOnly';
-      let invocation = renderTests.buildComponent({
-        name: 'Lol',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-        attributes: { 'data-foo': '"bar"', id: '"wat"' },
-      });
+    assert.strictEqual(
+      invocation,
+      '<TestComponent @foo={{bar}} @baz={{1}} @bar={{null}} data-foo={{bar}} id={{wat}}>World</TestComponent>'
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `<Lol @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat">World</Lol>`
-      );
+  @render('templateOnly') 'Can build basic component invocation with custom tag name'(
+    assert: RenderTestState
+  ) {
+    let invocation = this.buildComponent({
+      name: 'Lol',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
+      attributes: { 'data-foo': '"bar"', id: '"wat"' },
     });
 
-    test('Can build basic component invocation with block params', (assert) => {
-      renderTests['testType'] = 'TemplateOnly';
-      let invocation = renderTests.buildComponent({
-        name: 'Lol',
-        layout: 'Hello {{yield}}',
-        template: 'World',
-        args: { foo: 'bar', baz: 1, bar: null },
-        attributes: { 'data-foo': '"bar"', id: '"wat"' },
-        blockParams: ['a b c'],
-      });
+    assert.strictEqual(
+      invocation,
+      `<Lol @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat">World</Lol>`
+    );
+  }
 
-      assert.strictEqual(
-        invocation,
-        `<Lol @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat" as |a b c|>World</Lol>`
-      );
+  @render('templateOnly') 'Can build basic component invocation with block params'(
+    assert: RenderTestState
+  ) {
+    let invocation = this.buildComponent({
+      name: 'Lol',
+      layout: 'Hello {{yield}}',
+      template: 'World',
+      args: { foo: 'bar', baz: 1, bar: null },
+      attributes: { 'data-foo': '"bar"', id: '"wat"' },
+      blockParams: ['a b c'],
     });
+
+    assert.strictEqual(
+      invocation,
+      `<Lol @foo={{bar}} @baz={{1}} @bar={{null}} data-foo="bar" id="wat" as |a b c|>World</Lol>`
+    );
   }
-);
+}
+
+jitSuite(BuildComponentTest);
+
+function assertInvocation<K extends Exclude<DeclaredComponentType, 'glimmer'>>(
+  context: RenderTestState<K, K>,
+  invocation: string,
+  all: Record<ExpandType<K>, string>
+) {
+  context.strictEqual(invocation, all[context.types.invoker]);
+}
+
+function assertGlimmerInvocation(
+  context: RenderTestState<'glimmer'>,
+  actual: string,
+  expected: string
+) {
+  context.strictEqual(actual, expected);
+}
diff --git a/packages/@glimmer-workspace/integration-tests/test/jit-suites-test.ts b/packages/@glimmer-workspace/integration-tests/test/jit-suites-test.ts
index 0318ff4932..4901614d1a 100644
--- a/packages/@glimmer-workspace/integration-tests/test/jit-suites-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/jit-suites-test.ts
@@ -3,8 +3,6 @@ import {
   EachSuite,
   EmberishComponentTests,
   GlimmerishComponents,
-  HasBlockParamsHelperSuite,
-  HasBlockSuite,
   InElementSuite,
   jitComponentSuite,
   jitSuite,
@@ -13,7 +11,7 @@ import {
   TemplateOnlyComponents,
   WithDynamicVarsSuite,
   YieldSuite,
-} from '..';
+} from '@glimmer-workspace/integration-tests';
 
 jitSuite(DebuggerSuite);
 jitSuite(EachSuite);
@@ -22,8 +20,6 @@ jitSuite(InElementSuite);
 jitComponentSuite(GlimmerishComponents);
 jitComponentSuite(TemplateOnlyComponents);
 jitComponentSuite(EmberishComponentTests);
-jitComponentSuite(HasBlockSuite);
-jitComponentSuite(HasBlockParamsHelperSuite);
 jitComponentSuite(ScopeSuite);
 jitComponentSuite(ShadowingSuite);
 jitComponentSuite(WithDynamicVarsSuite);
diff --git a/packages/@glimmer-workspace/integration-tests/test/keywords/log-test.ts b/packages/@glimmer-workspace/integration-tests/test/keywords/log-test.ts
index 703f79997a..30eb04ef16 100644
--- a/packages/@glimmer-workspace/integration-tests/test/keywords/log-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/keywords/log-test.ts
@@ -1,25 +1,25 @@
-import { jitSuite, RenderTest, test } from '../..';
+import { jitSuite, RenderTestContext, test } from '@glimmer-workspace/integration-tests';
 
-class LogTest extends RenderTest {
+class LogTest extends RenderTestContext {
   static suiteName = '{{log}} keyword';
 
   originalLog?: () => void;
   logCalls: unknown[] = [];
 
-  beforeEach() {
+  override readonly beforeEach = () => {
     /* eslint-disable no-console */
     this.originalLog = console.log;
     console.log = (...args: unknown[]) => {
       this.logCalls.push(...args);
       /* eslint-enable no-console */
     };
-  }
+  };
 
-  afterEach() {
+  override readonly afterEach = () => {
     /* eslint-disable no-console */
     console.log = this.originalLog!;
     /* eslint-enable no-console */
-  }
+  };
 
   assertLog(values: unknown[]) {
     this.assertHTML('');
@@ -32,14 +32,14 @@ class LogTest extends RenderTest {
 
   @test
   'correctly logs primitives'() {
-    this.render(`{{log "one" 1 true}}`);
+    this.render.template(`{{log "one" 1 true}}`);
 
     this.assertLog(['one', 1, true]);
   }
 
   @test
   'correctly logs a property'() {
-    this.render(`{{log this.value}}`, {
+    this.render.template(`{{log this.value}}`, {
       value: 'one',
     });
 
@@ -48,7 +48,7 @@ class LogTest extends RenderTest {
 
   @test
   'correctly logs multiple arguments'() {
-    this.render(`{{log "my variable:" this.value}}`, {
+    this.render.template(`{{log "my variable:" this.value}}`, {
       value: 'one',
     });
 
@@ -57,21 +57,21 @@ class LogTest extends RenderTest {
 
   @test
   'correctly logs `this`'() {
-    this.render(`{{log this}}`);
+    this.render.template(`{{log this}}`);
 
-    this.assertLog([this.context]);
+    this.assertLog([this.self.inner]);
   }
 
   @test
   'correctly logs as a subexpression'() {
-    this.render(`{{if (log "one" 1 true) "Hello!"}}`);
+    this.render.template(`{{if (log "one" 1 true) "Hello!"}}`);
 
     this.assertLog(['one', 1, true]);
   }
 
   @test
   'correctly logs when values update'() {
-    this.render(`{{log this.foo}}`, { foo: 123 });
+    this.render.template(`{{log this.foo}}`, { foo: 123 });
 
     this.rerender({ foo: 456 });
     this.rerender({ foo: true });
diff --git a/packages/@glimmer-workspace/integration-tests/test/lexical-scope-test.ts b/packages/@glimmer-workspace/integration-tests/test/lexical-scope-test.ts
index df50effefe..47edc9ac9e 100644
--- a/packages/@glimmer-workspace/integration-tests/test/lexical-scope-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/lexical-scope-test.ts
@@ -1,6 +1,11 @@
-import { defineComponent, jitSuite, RenderTest, test } from '..';
+import {
+  defineComponent,
+  jitSuite,
+  RenderTestContext,
+  test,
+} from '@glimmer-workspace/integration-tests';
 
-class LexicalScopeTest extends RenderTest {
+class LexicalScopeTest extends RenderTestContext {
   static suiteName = 'loose mode: lexical scope';
 
   @test
@@ -8,7 +13,7 @@ class LexicalScopeTest extends RenderTest {
     const Foo = defineComponent({}, 'Hello, world!', { strictMode: false });
     const Bar = defineComponent({ Foo }, '<Foo/>', { strictMode: false });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
diff --git a/packages/@glimmer-workspace/integration-tests/test/managers/helper-manager-test.ts b/packages/@glimmer-workspace/integration-tests/test/managers/helper-manager-test.ts
index be0d80f68e..fc779ce78b 100644
--- a/packages/@glimmer-workspace/integration-tests/test/managers/helper-manager-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/managers/helper-manager-test.ts
@@ -1,19 +1,18 @@
 import type { Arguments, Owner } from '@glimmer/interfaces';
 import { helperCapabilities, setHelperManager, setModifierManager } from '@glimmer/manager';
-
 import {
   defineComponent,
   GlimmerishComponent,
   jitSuite,
-  RenderTest,
+  RenderTestContext,
   test,
   TestHelper,
   TestHelperManager,
   tracked,
   trackedObj,
-} from '../..';
+} from '@glimmer-workspace/integration-tests';
 
-class HelperManagerTest extends RenderTest {
+class HelperManagerTest extends RenderTestContext {
   static suiteName = 'Helper Managers';
 
   @test 'it works'() {
@@ -25,7 +24,7 @@ class HelperManagerTest extends RenderTest {
 
     const Main = defineComponent({ hello: Hello }, '{{hello}}');
 
-    this.renderComponent(Main);
+    this.render.component(Main);
 
     this.assertHTML('hello');
 
@@ -45,7 +44,7 @@ class HelperManagerTest extends RenderTest {
 
     const Main = defineComponent({ hello }, '{{hello}}');
 
-    this.renderComponent(Main);
+    this.render.component(Main);
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('plain function');
@@ -69,7 +68,7 @@ class HelperManagerTest extends RenderTest {
 
     const Main = defineComponent({}, '{{(@hello)}}');
 
-    this.renderComponent(Main, {
+    this.render.component(Main, {
       hello,
     });
 
@@ -97,7 +96,7 @@ class HelperManagerTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Main);
+    this.render.component(Main);
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('plain function');
@@ -118,7 +117,7 @@ class HelperManagerTest extends RenderTest {
     };
     let args = trackedObj({ value: 'hello', unused: 'unused' });
 
-    this.renderComponent(defineComponent({ obj }, '{{obj @value @unused}}'), args);
+    this.render.component(defineComponent({ obj }, '{{obj @value @unused}}'), args);
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('hello');
@@ -146,7 +145,7 @@ class HelperManagerTest extends RenderTest {
       return trackedState['value'];
     };
 
-    this.renderComponent(defineComponent({ obj }, '{{obj}}'));
+    this.render.component(defineComponent({ obj }, '{{obj}}'));
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('hello');
@@ -167,7 +166,7 @@ class HelperManagerTest extends RenderTest {
     };
     let args = trackedObj({ value: 'hello', unused: 'unused' });
 
-    this.renderComponent(defineComponent({ obj }, '{{obj @value namedOpt=@unused}}'), args);
+    this.render.component(defineComponent({ obj }, '{{obj @value namedOpt=@unused}}'), args);
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('hello');
 
@@ -189,7 +188,7 @@ class HelperManagerTest extends RenderTest {
 
     let args = trackedObj({ value: 'hello', used: 'used' });
 
-    this.renderComponent(defineComponent({ obj }, '{{obj @value namedOpt=@used}}'), args);
+    this.render.component(defineComponent({ obj }, '{{obj @value namedOpt=@used}}'), args);
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('used');
 
@@ -212,7 +211,7 @@ class HelperManagerTest extends RenderTest {
 
     let args = trackedObj({});
 
-    this.renderComponent(defineComponent({ obj }, 'result: {{obj}}'), args);
+    this.render.component(defineComponent({ obj }, 'result: {{obj}}'), args);
     this.assertHTML('result: default value');
     assert.strictEqual(count, 1, 'rendered once');
   }
@@ -229,7 +228,7 @@ class HelperManagerTest extends RenderTest {
 
     let args = trackedObj({ value: undefined });
 
-    this.renderComponent(defineComponent({ obj }, 'result: {{obj @value}}'), args);
+    this.render.component(defineComponent({ obj }, 'result: {{obj @value}}'), args);
     this.assertHTML('result: default value');
     assert.strictEqual(count, 1, 'rendered once');
 
@@ -252,7 +251,7 @@ class HelperManagerTest extends RenderTest {
 
     let args = trackedObj({ foo: 123 });
 
-    this.renderComponent(defineComponent({ hello: Hello }, '{{hello foo=@foo}}'), args);
+    this.render.component(defineComponent({ hello: Hello }, '{{hello foo=@foo}}'), args);
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('123');
@@ -281,7 +280,7 @@ class HelperManagerTest extends RenderTest {
 
     let args = trackedObj({ foo: 123 });
 
-    this.renderComponent(defineComponent({ hello: Hello }, '{{hello @foo}}'), args);
+    this.render.component(defineComponent({ hello: Hello }, '{{hello @foo}}'), args);
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('123');
@@ -317,7 +316,7 @@ class HelperManagerTest extends RenderTest {
         return this.foo;
       }
     }
-    this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+    this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
 
     assert.strictEqual(count, 1, 'rendered once');
     this.assertHTML('123');
@@ -345,7 +344,7 @@ class HelperManagerTest extends RenderTest {
       }
     }
 
-    this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+    this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
 
     this.assertHTML('hello');
   }
@@ -361,7 +360,7 @@ class HelperManagerTest extends RenderTest {
     }
 
     assert.throws(() => {
-      this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+      this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
     }, /You attempted to update `foo` on/u);
   }
 
@@ -399,7 +398,7 @@ class HelperManagerTest extends RenderTest {
   @test 'helper manager and modifier manager can be associated with the same value'() {
     abstract class TestModifierHelper extends TestHelper {}
 
-    setModifierManager(() => ({} as any), TestHelper);
+    setModifierManager(() => ({}) as any, TestHelper);
 
     class Hello extends TestModifierHelper {
       value() {
@@ -407,7 +406,7 @@ class HelperManagerTest extends RenderTest {
       }
     }
 
-    this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+    this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
 
     this.assertHTML('hello');
 
@@ -436,7 +435,7 @@ class HelperManagerTest extends RenderTest {
     }
 
     assert.throws(() => {
-      this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+      this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
     }, /Custom helper managers must have a `capabilities` property that is the result of calling the `capabilities\('3.23'\)` \(imported via `import \{ capabilities \} from '@ember\/helper';`\). /u);
   }
 
@@ -464,7 +463,7 @@ class HelperManagerTest extends RenderTest {
     }
 
     assert.throws(() => {
-      this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+      this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
     }, /You attempted to update `foo` on /u);
   }
 
@@ -486,7 +485,7 @@ class HelperManagerTest extends RenderTest {
     }
 
     assert.throws(() => {
-      this.renderComponent(defineComponent({ hello: Hello }, '{{hello}}'));
+      this.render.component(defineComponent({ hello: Hello }, '{{hello}}'));
     }, /You attempted to update `foo` on /u);
   }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/test/managers/modifier-manager-test.ts b/packages/@glimmer-workspace/integration-tests/test/managers/modifier-manager-test.ts
index f56f06ccee..7aea5485ee 100644
--- a/packages/@glimmer-workspace/integration-tests/test/managers/modifier-manager-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/managers/modifier-manager-test.ts
@@ -1,69 +1,76 @@
 import type { Arguments, ModifierManager, Owner } from '@glimmer/interfaces';
+import type { RecordedEvents } from '@glimmer-workspace/integration-tests';
+import { destroy, registerDestructor } from '@glimmer/destroyable';
 import { modifierCapabilities, setModifierManager } from '@glimmer/manager';
-import { getOwner, setOwner } from '@glimmer/owner';
-
-import { defineComponent, jitSuite, RenderTest, test, tracked, trackedObj } from '../..';
-
-abstract class CustomModifier {
-  static create<This extends { new (owner: object, args: Arguments): unknown }>(
-    this: This,
-    args: Arguments
-  ): InstanceType<This> {
-    return new this(getOwner(args)!, args) as InstanceType<This>;
-  }
-
-  constructor(owner: Owner, public args: Arguments) {
-    setOwner(this, owner);
-  }
-
-  declare element: Element;
-
-  didInsertElement(): void {}
-  didUpdate(): void {}
-  willDestroyElement(): void {}
+import {
+  defineComponent,
+  jitSuite,
+  RenderTestContext,
+  test,
+  tracked,
+  trackedObj,
+} from '@glimmer-workspace/integration-tests';
+
+type CreateCustomModifier = (options: {
+  owner: Owner;
+  args: Arguments;
+  lifetime: object;
+  events: RecordedEvents;
+}) => CustomModifier;
+/**
+ * The { instance } wrapper is a lifetime -- it can be the target for destructor APIs and will
+ * be destroyed when the modifier is destroyed.
+ */
+
+interface CustomModifierInstance {
+  install: CustomModifier;
+  lifetime: object;
+  didUpdate?: DidUpdate | void;
 }
+type CustomModifier = (element: Element, args: Arguments) => DidInsert | void;
+type DidInsert = (args: Arguments) => DidUpdate | void;
+type DidUpdate = (args: Arguments) => DidUpdate | void;
 
-abstract class ModifierManagerTest extends RenderTest {
-  abstract CustomModifierManager: { new (owner: Owner): ModifierManager<CustomModifier> };
+abstract class ModifierManagerTest extends RenderTestContext {
+  abstract CustomModifierManager: {
+    new (owner: Owner, events: RecordedEvents): ModifierManager<CustomModifierInstance>;
+  };
 
-  defineModifier<T extends object>(Klass: T): T {
+  defineModifier<T extends CreateCustomModifier>(modifier: T): T {
     return setModifierManager((owner) => {
-      return new this.CustomModifierManager(owner);
-    }, Klass);
+      return new this.CustomModifierManager(owner, this.events);
+    }, modifier);
   }
 
   @test 'can register a custom element modifier and render it'() {
-    let foo = this.defineModifier(
-      class extends CustomModifier {
-        override didInsertElement() {}
-        override didUpdate() {}
-        override willDestroyElement() {}
-      }
-    );
+    let foo = this.defineModifier(() => () => {});
 
     const Main = defineComponent({ foo }, '<h1 {{foo}}>hello world</h1>');
 
-    this.renderComponent(Main);
+    this.render.component(Main);
 
     this.assertHTML(`<h1>hello world</h1>`);
   }
 
   @test 'custom lifecycle hooks'(assert: Assert) {
-    let foo = this.defineModifier(
-      class extends CustomModifier {
-        override didInsertElement() {
-          assert.step('Called didInsertElement');
-          assert.strictEqual(this.args.positional[0], true, 'gets initial args');
-        }
-        override didUpdate() {
-          assert.step('Called didUpdate');
-          assert.strictEqual(this.args.positional[0], 'true', 'gets updated args');
-        }
-        override willDestroyElement() {
-          assert.step('Called willDestroyElement');
-        }
-      }
-    );
+    let foo = this.defineModifier(({ lifetime, events }) => {
+      registerDestructor(lifetime, () => events.record('willDestroy'));
+
+      return (_, args) => {
+        events.record('install');
+        assert.strictEqual(args.positional[0], true, 'gets initial args');
+
+        return (args) => {
+          events.record('didInsertElement');
+          assert.strictEqual(args.positional[0], true, 'gets updated args');
+
+          return (args) => {
+            events.record('didUpdate');
+            assert.strictEqual(args.positional[0], 'true', 'gets updated args');
+          };
+        };
+      };
+    });
 
     const Main = defineComponent(
       { foo },
@@ -71,86 +78,117 @@ abstract class ModifierManagerTest extends RenderTest {
     );
     let args = trackedObj({ truthy: true });
 
-    this.renderComponent(Main, args);
+    this.render.component(Main, args);
 
     this.assertHTML(`<h1>hello world</h1>`);
-    assert.verifySteps(['Called didInsertElement']);
+    this.events.all.expect([
+      'manager:createModifier',
+      'manager:installModifier',
+      'install',
+      'didInsertElement',
+    ]);
 
     args['truthy'] = 'true';
     this.rerender();
-    assert.verifySteps(['Called didUpdate']);
+    this.events.all.expect(['env:begin', 'manager:updateModifier', 'didUpdate', 'env:commit']);
 
     args['truthy'] = false;
     this.rerender();
-    assert.verifySteps(['Called willDestroyElement']);
+    this.events.all.expect(['env:begin', 'manager:destroyModifier', 'willDestroy', 'env:commit']);
 
     args['truthy'] = true;
     this.rerender();
-    assert.verifySteps(['Called didInsertElement']);
+    this.events.all.expect([
+      'env:begin',
+      'manager:createModifier',
+      'manager:installModifier',
+      'install',
+      'didInsertElement',
+      'env:commit',
+    ]);
   }
 
-  @test 'associates manager even through an inheritance structure'(assert: Assert) {
-    let Foo = this.defineModifier(
-      class extends CustomModifier {
-        override didInsertElement() {
-          assert.step('Foo didInsertElement');
-          assert.strictEqual(this.args.positional[0], true, 'gets initial args');
-        }
+  @test 'associates manager even through an inheritance structure'() {
+    const events = this.events;
+
+    class Parent {
+      constructor(readonly owner: Owner) {}
+
+      didInsertElement() {
+        events.record('parent:didInsertElement');
       }
-    );
+    }
 
-    class Bar extends Foo {
+    setModifierManager((owner: Owner) => {
+      return {
+        capabilities: modifierCapabilities('3.22'),
+        createModifier: (factory: typeof Parent) => {
+          return new factory(owner);
+        },
+        installModifier: (instance: Parent) => {
+          instance.didInsertElement();
+        },
+        destroyModifier: () => {},
+        updateModifier: () => {},
+      };
+    }, Parent);
+
+    class Child extends Parent {
       override didInsertElement() {
         super.didInsertElement();
-        assert.step('Bar didInsertElement');
-        assert.strictEqual(this.args.positional[0], true, 'gets initial args');
+        events.record('child:didInsertElement');
       }
     }
 
-    const Main = defineComponent({ bar: Bar }, '<h1 {{bar @truthy}}>hello world</h1>');
+    const Main = defineComponent({ child: Child }, '<h1 {{child @truthy}}>hello world</h1>');
 
-    this.renderComponent(Main, { truthy: true });
+    this.render.component(Main, { truthy: true });
     this.assertHTML(`<h1>hello world</h1>`);
-    assert.verifySteps(['Foo didInsertElement', 'Bar didInsertElement']);
+    events
+      .prefixed(['parent', 'child'])
+      .expect(['parent:didInsertElement', 'child:didInsertElement']);
   }
 
   @test 'can give consistent access to underlying DOM element'(assert: Assert) {
-    assert.expect(6);
+    const events = this.events;
 
-    let foo = this.defineModifier(
-      class extends CustomModifier {
-        savedElement?: Element;
+    let foo = this.defineModifier(({ events, lifetime }) => {
+      registerDestructor(lifetime, () => events.record('willDestroy'));
 
-        override didInsertElement() {
-          // consume first positional argument (ensures updates run)
-           
-          this.args.positional[0];
+      return (element) => {
+        events.record('install');
 
-          assert.strictEqual(this.element.tagName, 'H1');
-          this.savedElement = this.element;
-        }
+        return (args) => {
+          events.record('didInsertElement');
+          args.positional[0];
 
-        override didUpdate() {
-          assert.strictEqual(this.element, this.savedElement);
-        }
+          assert.strictEqual(element.tagName, 'H1');
 
-        override willDestroyElement() {
-          assert.strictEqual(this.element, this.savedElement);
-        }
-      }
-    );
+          return () => {
+            events.record('didUpdate');
+          };
+        };
+      };
+    });
 
     const Main = defineComponent({ foo }, '<h1 {{foo @truthy}}>hello world</h1>');
     let args = trackedObj({ truthy: true });
 
-    this.renderComponent(Main, args);
+    this.render.component(Main, args);
+
+    events.expect(['install', 'didInsertElement']);
     this.assertHTML(`<h1>hello world</h1>`);
 
     args['truthy'] = 'true';
     this.rerender();
+    events.expect(['didUpdate']);
+
+    this.destroy();
+
+    events.expect(['willDestroy']);
   }
 
-  @test 'lifecycle hooks are autotracked by default'(assert: Assert) {
+  @test 'lifecycle hooks are autotracked by default'() {
     class TrackedClass {
       @tracked count = 0;
     }
@@ -158,104 +196,108 @@ abstract class ModifierManagerTest extends RenderTest {
     let trackedOne = new TrackedClass();
     let trackedTwo = new TrackedClass();
 
-    let insertCount = 0;
-    let updateCount = 0;
+    let foo = this.defineModifier(({ events }) => {
+      events.record('create');
+
+      return () => {
+        events.record('install');
 
-    let foo = this.defineModifier(
-      class extends CustomModifier {
-        override didInsertElement() {
-          // track the count of the first item
-           
+        return () => {
+          events.record('didInsertElement');
           trackedOne.count;
-          insertCount++;
-        }
 
-        override didUpdate() {
-          // track the count of the second item
-           
-          trackedTwo.count;
-          updateCount++;
-        }
-      }
-    );
+          return () => {
+            events.record('didUpdate');
+            trackedTwo.count;
+          };
+        };
+      };
+    });
 
     let Main = defineComponent({ foo }, '<h1 {{foo}}>hello world</h1>');
 
-    this.renderComponent(Main);
+    this.render.component(Main);
     this.assertHTML(`<h1>hello world</h1>`);
 
-    assert.strictEqual(insertCount, 1);
-    assert.strictEqual(updateCount, 0);
+    this.events.expect(['create', 'install', 'didInsertElement']);
 
     trackedTwo.count++;
     this.rerender();
-    assert.strictEqual(updateCount, 0);
+    this.events.expect([]);
 
     trackedOne.count++;
     this.rerender();
-    assert.strictEqual(updateCount, 1);
+    this.events.expect(['didUpdate']);
 
     trackedOne.count++;
     this.rerender();
-    assert.strictEqual(updateCount, 1);
+    this.events.expect([]);
 
     trackedTwo.count++;
     this.rerender();
-    assert.strictEqual(updateCount, 2);
+    this.events.expect(['didUpdate']);
   }
 
   @test
   'provides a helpful deprecation when mutating a tracked value that was consumed already within constructor'(
     assert: Assert
   ) {
-    class Foo extends CustomModifier {
+    class State {
       @tracked foo = 123;
+    }
+
+    const state = new State();
+
+    let modifier = this.defineModifier(({ events }) => {
+      events.record('create');
 
-      constructor(owner: Owner, args: Arguments) {
-        super(owner, args);
+      return () => {
+        events.record('install');
 
         // first read the tracked property
-         
-        this.foo;
+        state.foo;
 
-        // then attempt to update the tracked property
-        this.foo = 456;
-      }
+        // then attempt mutate the tracked property
+        state.foo = 456;
 
-      override didInsertElement() {}
-      override didUpdate() {}
-      override willDestroyElement() {}
-    }
+        return (args) => {
+          events.record('didInsertElement');
+          args.positional[1];
 
-    let foo = this.defineModifier(Foo);
+          return (args) => {
+            events.record('didUpdate');
+            args.positional[1];
+          };
+        };
+      };
+    });
 
-    let Main = defineComponent({ foo }, '<h1 {{foo}}>hello world</h1>');
+    let Main = defineComponent({ modifier }, '<h1 {{modifier}}>hello world</h1>');
 
     assert.throws(() => {
-      this.renderComponent(Main);
+      this.render.component(Main);
     }, /You attempted to update `foo` on `.*`, but it had already been used previously in the same computation/u);
+
+    this.events.expect(['create', 'install']);
   }
 
   @test
-  'does not eagerly access arguments during destruction'(assert: Assert) {
-    class Foo extends CustomModifier {}
-
-    let foo = this.defineModifier(Foo);
+  'does not eagerly access arguments, including during destruction'() {
+    const modifier = this.defineModifier(() => () => {});
 
     let Main = defineComponent(
-      { foo },
-      '{{#if @state.show}}<h1 {{foo @state.bar baz=@state.baz}}>hello world</h1>{{/if}}'
+      { modifier },
+      '{{#if @state.show}}<h1 {{modifier @state.bar baz=@state.baz}}>hello world</h1>{{/if}}'
     );
 
-    let barCount = 0;
-    let bazCount = 0;
+    const events = this.events;
 
     class State {
       @tracked show = true;
 
       get bar() {
         if (this.show === false) {
-          barCount++;
+          events.record('get bar');
         }
 
         return;
@@ -263,7 +305,7 @@ abstract class ModifierManagerTest extends RenderTest {
 
       get baz() {
         if (this.show === false) {
-          bazCount++;
+          events.record('get baz');
         }
 
         return;
@@ -272,71 +314,95 @@ abstract class ModifierManagerTest extends RenderTest {
 
     let state = new State();
 
-    this.renderComponent(Main, { state });
+    this.render.component(Main, { state });
 
     state.show = false;
 
     this.rerender();
 
-    assert.strictEqual(barCount, 0, 'bar was not accessed during detruction');
-    assert.strictEqual(bazCount, 0, 'baz was not accessed during detruction');
+    events
+      .prefixed(['manager'])
+      .expect(['manager:createModifier', 'manager:installModifier', 'manager:destroyModifier']);
   }
 }
 
 class ModifierManagerTest322 extends ModifierManagerTest {
   static suiteName = 'Basic Custom Modifier Manager: 3.22';
 
-  CustomModifierManager = class CustomModifierManager implements ModifierManager<CustomModifier> {
+  CustomModifierManager = class CustomModifierManager
+    implements ModifierManager<CustomModifierInstance>
+  {
     capabilities = modifierCapabilities('3.22');
+    readonly #events: RecordedEvents;
 
-    constructor(public owner: Owner) {}
-
-    createModifier(
-      Modifier: { new (owner: Owner, args: Arguments): CustomModifier },
-      args: Arguments
+    constructor(
+      public owner: Owner,
+      events: RecordedEvents
     ) {
-      return new Modifier(this.owner, args);
+      this.#events = events;
     }
 
-    installModifier(instance: CustomModifier, element: Element, args: Arguments) {
-      instance.element = element;
-      instance.args = args;
-      instance.didInsertElement();
+    createModifier(Modifier: CreateCustomModifier, args: Arguments) {
+      this.#events.record('manager:createModifier');
+
+      const lifetime = {};
+      const install = Modifier({ owner: this.owner, args, lifetime, events: this.#events });
+
+      return {
+        install,
+        lifetime,
+      };
     }
 
-    updateModifier(instance: CustomModifier, args: Arguments) {
-      instance.args = args;
-      instance.didUpdate();
+    installModifier(instance: CustomModifierInstance, element: Element, args: Arguments) {
+      this.#events.record('manager:installModifier');
+
+      const didInsert = instance.install(element, args);
+
+      if (didInsert) {
+        instance.didUpdate = didInsert(args);
+      }
     }
 
-    destroyModifier(instance: CustomModifier) {
-      instance.willDestroyElement();
+    updateModifier(instance: CustomModifierInstance, args: Arguments) {
+      this.#events.record('manager:updateModifier');
+
+      if (instance.didUpdate) {
+        const newDidUpdate = instance.didUpdate(args);
+
+        if (newDidUpdate) {
+          instance.didUpdate = newDidUpdate;
+        }
+      }
+    }
+
+    destroyModifier(instance: CustomModifierInstance) {
+      this.#events.record('manager:destroyModifier');
+
+      destroy(instance.lifetime);
     }
   };
 
-  @test 'modifers only track positional arguments they consume'(assert: Assert) {
-    let insertCount = 0;
-    let updateCount = 0;
+  @test 'modifers only track positional arguments they consume'() {
+    let foo = this.defineModifier(({ events }) => {
+      events.record('create');
 
-    let foo = this.defineModifier(
-      class extends CustomModifier {
-        override didInsertElement() {
-          insertCount++;
+      return () => {
+        events.record('install');
 
-          // consume the second positional
-           
-          this.args.positional[1];
-        }
+        return (args) => {
+          4;
 
-        override didUpdate() {
-          updateCount++;
+          events.record('didInsertElement');
+          args.positional[1];
 
-          // consume the second positional
-           
-          this.args.positional[1];
-        }
-      }
-    );
+          return (args) => {
+            events.record('didUpdate');
+            args.positional[1];
+          };
+        };
+      };
+    });
 
     let Main = defineComponent(
       { foo },
@@ -350,43 +416,39 @@ class ModifierManagerTest322 extends ModifierManagerTest {
       qux: 'quz',
     });
 
-    this.renderComponent(Main, args);
+    this.render.component(Main, args);
 
     this.assertHTML(`<h1>hello world</h1>`);
 
-    assert.strictEqual(insertCount, 1);
-    assert.strictEqual(updateCount, 0);
+    this.events.expect(['create', 'install', 'didInsertElement']);
 
     args['positionOne'] = 'no first?';
     this.rerender();
-    assert.strictEqual(updateCount, 0);
+    this.events.expect([]);
 
     args['positionTwo'] = 'YASSSSSSS!!!';
     this.rerender();
-    assert.strictEqual(updateCount, 1);
+    this.events.expect(['didUpdate']);
+    // assert.strictEqual(updateCount, 1);
   }
 
-  @test 'modifers only track named arguments they consume'(assert: Assert) {
-    let insertCount = 0;
-    let updateCount = 0;
+  @test 'modifers only track named arguments they consume'() {
+    let foo = this.defineModifier(({ events }) => {
+      events.record('create');
 
-    let foo = this.defineModifier(
-      class extends CustomModifier {
-        override didInsertElement() {
-          insertCount++;
+      return () => {
+        events.record('install');
 
-          // consume the second positional
-           
-          // consume the second positional
-           
-          this.args.named['qux'];
-        }
+        return (args) => {
+          events.record('didInsertElement');
+          args.named['qux'];
 
-        override didUpdate() {
-          updateCount++;
-        }
-      }
-    );
+          return () => {
+            events.record('didUpdate');
+          };
+        };
+      };
+    });
 
     let Main = defineComponent(
       { foo },
@@ -398,20 +460,19 @@ class ModifierManagerTest322 extends ModifierManagerTest {
       qux: 'quz',
     });
 
-    this.renderComponent(Main, args);
+    this.render.component(Main, args);
 
     this.assertHTML(`<h1>hello world</h1>`);
 
-    assert.strictEqual(insertCount, 1);
-    assert.strictEqual(updateCount, 0);
+    this.events.expect(['create', 'install', 'didInsertElement']);
 
     args['bar'] = 'other bar';
     this.rerender();
-    assert.strictEqual(updateCount, 0);
+    this.events.expect([]);
 
     args['qux'] = 'quuuuxxxxxx';
     this.rerender();
-    assert.strictEqual(updateCount, 1);
+    this.events.expect(['didUpdate']);
   }
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/modifiers-test.ts b/packages/@glimmer-workspace/integration-tests/test/modifiers-test.ts
index 2a7b2f1221..2542ccd357 100644
--- a/packages/@glimmer-workspace/integration-tests/test/modifiers-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/modifiers-test.ts
@@ -1,6 +1,10 @@
 import type { Dict, Nullable, SimpleElement } from '@glimmer/interfaces';
-
-import { type Count, jitSuite, RenderTest, test } from '..';
+import type {Count} from '@glimmer-workspace/integration-tests';
+import {
+  jitSuite,
+  RenderTestContext,
+  test
+} from '@glimmer-workspace/integration-tests';
 
 class BaseModifier {
   element?: SimpleElement;
@@ -17,12 +21,12 @@ abstract class AbstractDestroyable extends BaseModifier {
   abstract override willDestroyElement(): void;
 }
 
-class ModifierTests extends RenderTest {
+class ModifierTests extends RenderTestContext {
   static suiteName = 'modifiers';
 
   @test
   'Element modifier with hooks'(assert: Assert, count: Count) {
-    this.registerModifier(
+    this.register.modifier(
       'foo',
       class {
         element?: SimpleElement;
@@ -44,7 +48,7 @@ class ModifierTests extends RenderTest {
       }
     );
 
-    this.render('{{#if this.ok}}<div data-ok=true {{foo this.bar}}></div>{{/if}}', {
+    this.render.template('{{#if this.ok}}<div data-ok=true {{foo this.bar}}></div>{{/if}}', {
       bar: 'bar',
       ok: true,
     });
@@ -55,7 +59,7 @@ class ModifierTests extends RenderTest {
 
   @test
   'didUpdate is not called when params are constants'(assert: Assert, count: Count) {
-    this.registerModifier(
+    this.register.modifier(
       'foo',
       class {
         element?: SimpleElement;
@@ -73,7 +77,7 @@ class ModifierTests extends RenderTest {
       }
     );
 
-    this.render('{{#if this.ok}}<div {{foo "foo" bar="baz"}}></div>{{/if}}{{this.ok}}', {
+    this.render.template('{{#if this.ok}}<div {{foo "foo" bar="baz"}}></div>{{/if}}{{this.ok}}', {
       ok: true,
       data: 'ok',
     });
@@ -95,9 +99,9 @@ class ModifierTests extends RenderTest {
         modifiedElement = this.element;
       }
     }
-    this.registerComponent('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
-    this.registerModifier('bar', Bar);
-    this.render('<TheFoo {{bar "something" foo="else"}}/>');
+    this.register.component('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
+    this.register.modifier('bar', Bar);
+    this.render.template('<TheFoo {{bar "something" foo="else"}}/>');
     assert.deepEqual(modifierParams, ['something']);
     assert.deepEqual(modifierNamedArgs, { foo: 'else' });
     assert.strictEqual(
@@ -121,13 +125,13 @@ class ModifierTests extends RenderTest {
         }
       }
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'TheFoo',
       '<div id="inner-one" ...attributes>Foo</div><div id="inner-two" ...attributes>Bar</div>'
     );
-    this.registerModifier('bar', Bar);
-    this.render('<TheFoo {{bar "something" foo="else"}}/>');
+    this.register.modifier('bar', Bar);
+    this.render.template('<TheFoo {{bar "something" foo="else"}}/>');
     assert.deepEqual(
       elementIds,
       ['inner-one', 'inner-two'],
@@ -152,9 +156,9 @@ class ModifierTests extends RenderTest {
         modifiedElement = this.element;
       }
     }
-    this.registerComponent('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
-    this.registerModifier('bar', Bar);
-    this.render('<TheFoo {{bar this.something foo=this.foo}}/>', {
+    this.register.component('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
+    this.register.modifier('bar', Bar);
+    this.render.template('<TheFoo {{bar this.something foo=this.foo}}/>', {
       something: 'something',
       foo: 'else',
     });
@@ -196,9 +200,9 @@ class ModifierTests extends RenderTest {
     }
     let context = { id: 1 };
     let context2 = { id: 2 };
-    this.registerComponent('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
-    this.registerModifier('bar', Bar);
-    this.render('<TheFoo {{bar "name" this foo=this}}/>', context);
+    this.register.component('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
+    this.register.modifier('bar', Bar);
+    this.render.template('<TheFoo {{bar "name" this foo=this}}/>', context);
     assert.deepEqual(modifierParams, ['name', context]);
     assert.deepEqual(modifierNamedArgs, { foo: context });
     assert.strictEqual(
@@ -235,9 +239,9 @@ class ModifierTests extends RenderTest {
         modifiedElement = this.element;
       }
     }
-    this.registerComponent('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
-    this.registerModifier('bar', Bar);
-    this.render(
+    this.register.component('Glimmer', 'TheFoo', '<div id="inner-div" ...attributes>Foo</div>');
+    this.register.modifier('bar', Bar);
+    this.render.template(
       `
       {{#let this.foo as |v|}}
         <TheFoo {{bar v foo=v}}/>
@@ -277,18 +281,18 @@ class ModifierTests extends RenderTest {
         }
       }
     }
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'TheInner',
       '<div id="inner-div" ...attributes>{{yield}}</div>'
     );
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'TheFoo',
       '<div id="outer-div" ...attributes>Outer</div><TheInner ...attributes>Hello</TheInner>'
     );
-    this.registerModifier('bar', Bar);
-    this.render(
+    this.register.modifier('bar', Bar);
+    this.render.template(
       `
       {{#let this.foo as |v|}}
         <TheFoo {{bar v foo=v}}/>
@@ -316,10 +320,10 @@ class ModifierTests extends RenderTest {
         insertionOrder.push('bar');
       }
     }
-    this.registerModifier('bar', Bar);
-    this.registerModifier('foo', Foo);
+    this.register.modifier('bar', Bar);
+    this.register.modifier('foo', Foo);
 
-    this.render('<div {{foo}} {{bar}}></div>');
+    this.render.template('<div {{foo}} {{bar}}></div>');
     assert.deepEqual(insertionOrder, ['foo', 'bar']);
   }
 
@@ -338,10 +342,10 @@ class ModifierTests extends RenderTest {
         destructionOrder.push('bar');
       }
     }
-    this.registerModifier('bar', Bar);
-    this.registerModifier('foo', Foo);
+    this.register.modifier('bar', Bar);
+    this.register.modifier('foo', Foo);
 
-    this.render('{{#if this.nuke}}<div {{foo}} {{bar}}></div>{{/if}}', { nuke: true });
+    this.render.template('{{#if this.nuke}}<div {{foo}} {{bar}}></div>{{/if}}', { nuke: true });
     assert.deepEqual(destructionOrder, []);
     this.rerender({ nuke: false });
     assert.deepEqual(destructionOrder, ['foo', 'bar']);
@@ -362,10 +366,10 @@ class ModifierTests extends RenderTest {
         insertionOrder.push('bar');
       }
     }
-    this.registerModifier('bar', Bar);
-    this.registerModifier('foo', Foo);
+    this.register.modifier('bar', Bar);
+    this.register.modifier('foo', Foo);
 
-    this.render('<div {{foo}}><div {{bar}}></div></div>');
+    this.render.template('<div {{foo}}><div {{bar}}></div></div>');
     assert.deepEqual(insertionOrder, ['bar', 'foo']);
   }
 
@@ -384,10 +388,12 @@ class ModifierTests extends RenderTest {
         destructionOrder.push('bar');
       }
     }
-    this.registerModifier('bar', Bar);
-    this.registerModifier('foo', Foo);
+    this.register.modifier('bar', Bar);
+    this.register.modifier('foo', Foo);
 
-    this.render('{{#if this.nuke}}<div {{foo}}><div {{bar}}></div></div>{{/if}}', { nuke: true });
+    this.render.template('{{#if this.nuke}}<div {{foo}}><div {{bar}}></div></div>{{/if}}', {
+      nuke: true,
+    });
     assert.deepEqual(destructionOrder, []);
     this.rerender({ nuke: false });
     assert.deepEqual(destructionOrder, ['bar', 'foo']);
@@ -414,11 +420,11 @@ class ModifierTests extends RenderTest {
         insertionOrder.push('baz');
       }
     }
-    this.registerModifier('bar', Bar);
-    this.registerModifier('foo', Foo);
-    this.registerModifier('baz', Baz);
+    this.register.modifier('bar', Bar);
+    this.register.modifier('foo', Foo);
+    this.register.modifier('baz', Baz);
 
-    this.render('<div {{foo}}><div {{bar}}></div><div {{baz}}></div></div>');
+    this.render.template('<div {{foo}}><div {{bar}}></div><div {{baz}}></div></div>');
     assert.deepEqual(insertionOrder, ['bar', 'baz', 'foo']);
   }
 
@@ -443,11 +449,11 @@ class ModifierTests extends RenderTest {
         destructionOrder.push('baz');
       }
     }
-    this.registerModifier('bar', Bar);
-    this.registerModifier('foo', Foo);
-    this.registerModifier('baz', Baz);
+    this.register.modifier('bar', Bar);
+    this.register.modifier('foo', Foo);
+    this.register.modifier('baz', Baz);
 
-    this.render(
+    this.render.template(
       '{{#if this.nuke}}<div {{foo}}><div {{bar}}></div><div {{baz}}></div></div>{{/if}}',
       {
         nuke: true,
@@ -470,8 +476,8 @@ class ModifierTests extends RenderTest {
         assert.strictEqual(foo, 'foo');
       }
     }
-    this.registerModifier('foo', Foo);
-    this.render('<div {{foo this.bar}}></div>', { bar: 'bar' });
+    this.register.modifier('foo', Foo);
+    this.render.template('<div {{foo this.bar}}></div>', { bar: 'bar' });
     this.rerender({ bar: 'foo' });
   }
 
@@ -487,8 +493,8 @@ class ModifierTests extends RenderTest {
         assert.strictEqual(bar, 'foo');
       }
     }
-    this.registerModifier('foo', Foo);
-    this.render('<div {{foo bar=this.bar}}></div>', { bar: 'bar' });
+    this.register.modifier('foo', Foo);
+    this.render.template('<div {{foo bar=this.bar}}></div>', { bar: 'bar' });
     this.rerender({ bar: 'foo' });
   }
 
@@ -506,8 +512,8 @@ class ModifierTests extends RenderTest {
         assert.strictEqual(foo, 'foo');
       }
     }
-    this.registerModifier('foo', Foo);
-    this.render('<div {{foo this.baz bar=this.bar}}></div>', { bar: 'bar', baz: 'baz' });
+    this.register.modifier('foo', Foo);
+    this.render.template('<div {{foo this.baz bar=this.bar}}></div>', { bar: 'bar', baz: 'baz' });
     this.rerender({ bar: 'foo', baz: 'foo' });
   }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/test/modifiers/dynamic-modifiers-test.ts b/packages/@glimmer-workspace/integration-tests/test/modifiers/dynamic-modifiers-test.ts
index 96bdeddcc1..f649a3ce3c 100644
--- a/packages/@glimmer-workspace/integration-tests/test/modifiers/dynamic-modifiers-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/modifiers/dynamic-modifiers-test.ts
@@ -4,19 +4,19 @@ import {
   defineSimpleModifier,
   GlimmerishComponent,
   jitSuite,
-  RenderTest,
+  RenderTestContext,
   syntaxErrorFor,
   test,
-} from '../..';
+} from '@glimmer-workspace/integration-tests';
 
-class DynamicModifiersResolutionModeTest extends RenderTest {
+class DynamicModifiersResolutionModeTest extends RenderTestContext {
   static suiteName = 'dynamic modifiers in resolution mode';
 
   @test
   'Can use a dynamic modifier'() {
     const foo = defineSimpleModifier((element: Element) => (element.innerHTML = 'Hello, world!'));
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'Bar',
       '<div {{this.foo}}></div>',
@@ -25,7 +25,7 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
       }
     );
 
-    this.render('<Bar/>');
+    this.render.template('<Bar/>');
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -33,9 +33,9 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
   @test
   'Can use a nested argument as a modifier'() {
     const foo = defineSimpleModifier((element: Element) => (element.innerHTML = 'Hello, world!'));
-    this.registerComponent('TemplateOnly', 'Foo', '<div {{@x.foo}}></div>');
+    this.register.component('TemplateOnly', 'Foo', '<div {{@x.foo}}></div>');
 
-    this.render('<Foo @x={{this.x}}/>', { x: { foo } });
+    this.render.template('<Foo @x={{this.x}}/>', { x: { foo } });
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -45,9 +45,9 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
     const foo = defineSimpleModifier((element: Element, [value]: [string]): void => {
       element.innerHTML = value;
     });
-    this.registerComponent('TemplateOnly', 'Foo', '<div {{@value}}></div>');
+    this.register.component('TemplateOnly', 'Foo', '<div {{@value}}></div>');
 
-    this.render('<Foo @value={{modifier this.foo "Hello, world!"}}/>', { foo });
+    this.render.template('<Foo @value={{modifier this.foo "Hello, world!"}}/>', { foo });
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -57,10 +57,10 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
     const foo = defineSimpleModifier(
       (element: Element, values: string[]) => (element.innerHTML = values.join(' '))
     );
-    this.registerComponent('TemplateOnly', 'Foo', '<div {{@value "three"}}></div>');
-    this.registerComponent('TemplateOnly', 'Bar', '<Foo @value={{modifier @value "two"}}/>');
+    this.register.component('TemplateOnly', 'Foo', '<div {{@value "three"}}></div>');
+    this.register.component('TemplateOnly', 'Bar', '<Foo @value={{modifier @value "two"}}/>');
 
-    this.render('<Bar @value={{modifier this.foo "one"}}/>', { foo });
+    this.render.template('<Bar @value={{modifier this.foo "one"}}/>', { foo });
     this.assertHTML('<div>one two three</div>');
     this.assertStableRerender();
   }
@@ -70,9 +70,9 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
     const foo = defineSimpleModifier(
       (element: Element, [first, second]: string[]) => (element.innerHTML = `${first} ${second}`)
     );
-    this.registerComponent('TemplateOnly', 'Foo', '<div {{@value "world!"}}></div>');
+    this.register.component('TemplateOnly', 'Foo', '<div {{@value "world!"}}></div>');
 
-    this.render('<Foo @value={{modifier this.foo "Hello,"}}/>', { foo });
+    this.render.template('<Foo @value={{modifier this.foo "Hello,"}}/>', { foo });
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -83,13 +83,13 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
       (element: Element, _: unknown, { greeting }: { greeting: string }) =>
         (element.innerHTML = greeting)
     );
-    this.registerComponent(
+    this.register.component(
       'TemplateOnly',
       'Foo',
       '<div {{@value greeting="Hello, Nebula!"}}></div>'
     );
 
-    this.render('<Foo @value={{modifier this.foo greeting="Hello, world!"}}/>', { foo });
+    this.render.template('<Foo @value={{modifier this.foo greeting="Hello, world!"}}/>', { foo });
     this.assertHTML('<div>Hello, Nebula!</div>');
     this.assertStableRerender();
   }
@@ -101,14 +101,14 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
         (element.innerHTML = `${greeting} ${name}`)
     );
 
-    this.registerComponent('TemplateOnly', 'Foo', '<div {{@value name="Nebula!"}}></div>');
-    this.registerComponent(
+    this.register.component('TemplateOnly', 'Foo', '<div {{@value name="Nebula!"}}></div>');
+    this.register.component(
       'TemplateOnly',
       'Bar',
       '<Foo @value={{modifier @value greeting="Hello," name="world!"}}/>'
     );
 
-    this.render('<Bar @value={{modifier this.foo greeting="Hola,"}}/>', { foo });
+    this.render.template('<Bar @value={{modifier this.foo greeting="Hola,"}}/>', { foo });
     this.assertHTML('<div>Hello, Nebula!</div>');
     this.assertStableRerender();
   }
@@ -116,22 +116,31 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
   @test
   'Can invoke a yielded nested modifier'() {
     const foo = defineSimpleModifier((element: Element) => (element.innerHTML = 'Hello, world!'));
-    this.registerComponent(
+    this.register.component(
       'TemplateOnly',
       'Bar',
       '{{#let @x as |x|}}<div {{x.foo}}></div>{{/let}}'
     );
 
-    this.render('<Bar @x={{this.x}} />', { x: { foo } });
+    this.render.template('<Bar @x={{this.x}} />', { x: { foo } });
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
 
   @test
   'Cannot invoke a modifier definition based on this fallback lookup in resolution mode'() {
-    this.assert.throws(() => {
-      this.registerComponent('TemplateOnly', 'Bar', '<div {{x.foo}}></div>');
-    }, syntaxErrorFor('You attempted to invoke a path (`{{#x.foo}}`) as a modifier, but x was not in scope. Try adding `this` to the beginning of the path', '{{x.foo}}', 'an unknown module', 1, 5));
+    this.assert.throws(
+      () => {
+        this.register.component('TemplateOnly', 'Bar', '<div {{x.foo}}></div>');
+      },
+      syntaxErrorFor(
+        'You attempted to invoke a path (`{{#x.foo}}`) as a modifier, but x was not in scope. Try adding `this` to the beginning of the path',
+        '{{x.foo}}',
+        'an unknown module',
+        1,
+        5
+      )
+    );
   }
 
   @test
@@ -146,7 +155,7 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -164,7 +173,7 @@ class DynamicModifiersResolutionModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
diff --git a/packages/@glimmer-workspace/integration-tests/test/modifiers/on-test.ts b/packages/@glimmer-workspace/integration-tests/test/modifiers/on-test.ts
index 14f7bfbed8..deeccbe32a 100644
--- a/packages/@glimmer-workspace/integration-tests/test/modifiers/on-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/modifiers/on-test.ts
@@ -1,8 +1,7 @@
 import { getInternalModifierManager } from '@glimmer/manager';
 import { on } from '@glimmer/runtime';
 import { castToBrowser, expect } from '@glimmer/util';
-
-import { jitSuite, RenderTest, test } from '../..';
+import { jitSuite, RenderTestContext, test } from '@glimmer-workspace/integration-tests';
 
 // check if window exists and actually is the global
 const hasDom =
@@ -48,7 +47,7 @@ function getOnManager() {
 }
 
 if (hasDom) {
-  class OnTest extends RenderTest {
+  class OnTest extends RenderTestContext {
     static suiteName = '{{on}} Modifier';
 
     startingCounters: Counters = { adds: 0, removes: 0 };
@@ -60,10 +59,10 @@ if (hasDom) {
       );
     }
 
-    beforeEach() {
+    override readonly beforeEach = () => {
       // might error if getOnManagerInstance fails
       this.startingCounters = getOnManager().counters;
-    }
+    };
 
     assertCounts(expected: Counters) {
       this.assert.deepEqual(
@@ -91,7 +90,7 @@ if (hasDom) {
     'it adds an event listener'(assert: Assert) {
       let count = 0;
 
-      this.render('<button {{on "click" this.callback}}>Click Me</button>', {
+      this.render.template('<button {{on "click" this.callback}}>Click Me</button>', {
         callback() {
           count++;
         },
@@ -118,7 +117,7 @@ if (hasDom) {
     'passes the event to the listener'(assert: Assert) {
       let event: UIEvent;
 
-      this.render('<button {{on "click" this.callback}}>Click Me</button>', {
+      this.render.template('<button {{on "click" this.callback}}>Click Me</button>', {
         callback(evt: UIEvent) {
           event = evt;
         },
@@ -140,7 +139,7 @@ if (hasDom) {
       let firstCallback = () => first++;
       let secondCallback = () => second++;
 
-      this.render('<button {{on "click" this.callback}}>Click Me</button>', {
+      this.render.template('<button {{on "click" this.callback}}>Click Me</button>', {
         callback: firstCallback,
       });
 
@@ -168,7 +167,7 @@ if (hasDom) {
     'setting once named argument ensures the callback is only called once'(assert: Assert) {
       let count = 0;
 
-      this.render('<button {{on "click" this.callback once=true}}>Click Me</button>', {
+      this.render.template('<button {{on "click" this.callback once=true}}>Click Me</button>', {
         callback() {
           count++;
         },
@@ -202,13 +201,16 @@ if (hasDom) {
     ) {
       let count = 0;
 
-      this.render('<button {{on "click" this.callback once=this.once}}>Click Me</button>', {
-        callback() {
-          count++;
-        },
+      this.render.template(
+        '<button {{on "click" this.callback once=this.once}}>Click Me</button>',
+        {
+          callback() {
+            count++;
+          },
 
-        once: false,
-      });
+          once: false,
+        }
+      );
 
       let button = this.findButton();
 
@@ -238,7 +240,7 @@ if (hasDom) {
       let matcher =
         /You marked this listener as 'passive', meaning that you must not call 'event.preventDefault\(\)'/u;
 
-      this.render('<button {{on "click" this.callback passive=true}}>Click Me</button>', {
+      this.render.template('<button {{on "click" this.callback passive=true}}>Click Me</button>', {
         callback(event: UIEvent) {
           assert.throws(() => {
             event.preventDefault();
@@ -251,7 +253,7 @@ if (hasDom) {
 
     @test
     'by default bubbling is used (capture: false)'(assert: Assert) {
-      this.render(
+      this.render.template(
         `
           <button class="outer" {{on 'click' this.handleOuterClick}}>
             <button class="inner" {{on 'click' this.handleInnerClick}}></button>
@@ -274,7 +276,7 @@ if (hasDom) {
 
     @test
     'specifying capture named argument uses capture semantics'(assert: Assert) {
-      this.render(
+      this.render.template(
         `
           <button class="outer" {{on 'click' this.handleOuterClick capture=true}}>
             <button class="inner" {{on 'click' this.handleInnerClick}}></button>
@@ -297,7 +299,7 @@ if (hasDom) {
 
     @test
     'can use capture and once together'(assert: Assert) {
-      this.render(
+      this.render.template(
         `
           <button class="outer" {{on 'click' this.handleOuterClick once=true capture=true}}>
             <button class="inner" {{on 'click' this.handleInnerClick}}></button>
@@ -326,7 +328,7 @@ if (hasDom) {
     'unrelated updates to `this` context does not result in removing + re-adding'(assert: Assert) {
       let called = false;
 
-      this.render('<button {{on "click" this.callback}}>Click Me</button>', {
+      this.render.template('<button {{on "click" this.callback}}>Click Me</button>', {
         callback() {
           called = true;
         },
@@ -346,7 +348,7 @@ if (hasDom) {
     @test
     'asserts when eventName is missing'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on undefined this.callback}}>Click Me</button>`, {
+        this.render.template(`<button {{on undefined this.callback}}>Click Me</button>`, {
           callback() {},
         });
       }, /You must pass a valid DOM event name as the first argument to the `on` modifier/u);
@@ -355,16 +357,19 @@ if (hasDom) {
     @test
     'asserts when eventName is a bound undefined value'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on this.someUndefinedThing this.callback}}>Click Me</button>`, {
-          callback() {},
-        });
+        this.render.template(
+          `<button {{on this.someUndefinedThing this.callback}}>Click Me</button>`,
+          {
+            callback() {},
+          }
+        );
       }, /You must pass a valid DOM event name as the first argument to the `on` modifier/u);
     }
 
     @test
     'asserts when eventName is a function'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on this.callback}}>Click Me</button>`, {
+        this.render.template(`<button {{on this.callback}}>Click Me</button>`, {
           callback() {},
         });
       }, /You must pass a valid DOM event name as the first argument to the `on` modifier/u);
@@ -373,21 +378,21 @@ if (hasDom) {
     @test
     'asserts when callback is missing'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on 'click'}}>Click Me</button>`);
+        this.render.template(`<button {{on 'click'}}>Click Me</button>`);
       }, /You must pass a function as the second argument to the `on` modifier/u);
     }
 
     @test
     'asserts when callback is undefined'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on 'click' this.foo}}>Click Me</button>`);
+        this.render.template(`<button {{on 'click' this.foo}}>Click Me</button>`);
       }, /You must pass a function as the second argument to the `on` modifier; you passed undefined. While rendering:\n{2}this.foo/u);
     }
 
     @test
     'asserts when callback is null'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on 'click' this.foo}}>Click Me</button>`, { foo: null });
+        this.render.template(`<button {{on 'click' this.foo}}>Click Me</button>`, { foo: null });
       }, /You must pass a function as the second argument to the `on` modifier; you passed null. While rendering:\n{2}this.foo/u);
     }
 
@@ -395,7 +400,7 @@ if (hasDom) {
     'asserts if the provided callback accesses `this` without being bound prior to passing to on'(
       assert: Assert
     ) {
-      this.render(`<button {{on 'click' this.myFunc}}>Click Me</button>`, {
+      this.render.template(`<button {{on 'click' this.myFunc}}>Click Me</button>`, {
         myFunc(this: any) {
           assert.throws(() => {
             this.arg1;
@@ -411,10 +416,13 @@ if (hasDom) {
     @test
     'asserts if more than 2 positional parameters are provided'(assert: Assert) {
       assert.throws(() => {
-        this.render(`<button {{on 'click' this.callback this.someArg}}>Click Me</button>`, {
-          callback() {},
-          someArg: 'foo',
-        });
+        this.render.template(
+          `<button {{on 'click' this.callback this.someArg}}>Click Me</button>`,
+          {
+            callback() {},
+            someArg: 'foo',
+          }
+        );
       }, /You can only pass two positional arguments \(event name and callback\) to the `on` modifier, but you provided 3. Consider using the `fn` helper to provide additional arguments to the `on` callback./u);
     }
 
@@ -422,7 +430,7 @@ if (hasDom) {
     'it removes the modifier when the element is removed'(assert: Assert) {
       let count = 0;
 
-      this.render(
+      this.render.template(
         '{{#if this.showButton}}<button {{on "click" this.callback}}>Click Me</button>{{/if}}',
         {
           callback() {
diff --git a/packages/@glimmer-workspace/integration-tests/test/node-suites-node-test.ts b/packages/@glimmer-workspace/integration-tests/test/node-suites-node-test.ts
index 33ffde87ff..d1e9c869ef 100644
--- a/packages/@glimmer-workspace/integration-tests/test/node-suites-node-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/node-suites-node-test.ts
@@ -8,15 +8,15 @@ import {
   SerializedDOMHelperTests,
   ServerSideComponentSuite,
   ServerSideSuite,
-  suite,
-} from '..';
+  testSuite,
+} from '../lib';
 
 nodeSuite(ServerSideSuite);
 nodeComponentSuite(ServerSideComponentSuite);
 
-suite(DOMHelperTests, NodeJitRenderDelegate);
-suite(SerializedDOMHelperTests, JitSerializationDelegate);
+testSuite(DOMHelperTests, NodeJitRenderDelegate);
+testSuite(SerializedDOMHelperTests, JitSerializationDelegate);
 
 if (typeof process !== 'undefined') {
-  suite(CompilationTests, NodeJitRenderDelegate);
+  testSuite(CompilationTests, NodeJitRenderDelegate);
 }
diff --git a/packages/@glimmer-workspace/integration-tests/test/owner-test.ts b/packages/@glimmer-workspace/integration-tests/test/owner-test.ts
index d36c7309f9..e9c45e76e1 100644
--- a/packages/@glimmer-workspace/integration-tests/test/owner-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/owner-test.ts
@@ -5,21 +5,21 @@ import type {
   WithCreateInstance,
   WithSubOwner,
 } from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
+import type {RenderDelegateOptions} from '@glimmer-workspace/integration-tests';
 import { setInternalComponentManager } from '@glimmer/manager';
-import { NULL_REFERENCE, type Reference } from '@glimmer/reference';
-
+import { NULL_REFERENCE  } from '@glimmer/reference';
 import {
+  ClientSideRenderDelegate,
   createTemplate,
   defineComponent,
   EmberishCurlyComponent,
   GlimmerishComponent,
-  JitRenderDelegate,
-  type RenderDelegateOptions,
-  RenderTest,
-  suite,
+  RenderTestContext,
   test,
   TestJitRuntimeResolver,
-} from '..';
+  testSuite
+} from '@glimmer-workspace/integration-tests';
 
 class OwnerJitRuntimeResolver extends TestJitRuntimeResolver {
   override lookupComponent(name: string, owner: () => void): ResolvedComponentDefinition | null {
@@ -29,7 +29,7 @@ class OwnerJitRuntimeResolver extends TestJitRuntimeResolver {
   }
 }
 
-class OwnerJitRenderDelegate extends JitRenderDelegate {
+class OwnerJitRenderDelegate extends ClientSideRenderDelegate {
   constructor(options?: RenderDelegateOptions) {
     super({
       ...options,
@@ -71,7 +71,7 @@ class MountManager implements WithCreateInstance<object>, WithSubOwner<object> {
     return state.owner;
   }
 
-  getSelf(): Reference {
+  getSelf(): Reactive {
     return NULL_REFERENCE;
   }
 
@@ -112,7 +112,7 @@ function defineCheckOwnerComponent(ownerToCheck: object | undefined, assert: Ass
   });
 }
 
-class OwnerTest extends RenderTest {
+class OwnerTest extends RenderTestContext {
   static suiteName = '[owner]';
 
   declare delegate: OwnerJitRenderDelegate;
@@ -131,21 +131,20 @@ class OwnerTest extends RenderTest {
       });
     }
 
-    this.delegate.registerComponent('Curly', 'Curly', 'FooBar', null, FooBar);
-    this.delegate.registerComponent('Curly', 'Curly', 'FooBaz', null, FooBaz);
-    this.delegate.registerComponent('TemplateOnly', 'TemplateOnly', 'FooQux', 'testing');
+    this.register.component('Curly', 'FooBar', null, FooBar);
+    this.register.component('Curly', 'FooBaz', null, FooBaz);
+    this.register.component('TemplateOnly', 'FooQux', 'testing');
 
-    this.render('<FooBar/>');
+    this.render.template('<FooBar/>');
 
     assert.verifySteps(['foo-bar owner called', 'foo-baz owner called'], 'owners used correctly');
   }
 
   @test
   'owner can be used per-template in runtime resolver'(assert: Assert) {
-    this.delegate.registerComponent('TemplateOnly', 'TemplateOnly', 'FooQux', 'testing');
+    this.register.component('TemplateOnly', 'FooQux', 'testing');
 
-    this.delegate.registerComponent(
-      'Curly',
+    this.register.component(
       'Curly',
       'FooBaz',
       null,
@@ -156,8 +155,7 @@ class OwnerTest extends RenderTest {
       }
     );
 
-    this.delegate.registerComponent(
-      'Curly',
+    this.register.component(
       'Curly',
       'FooBar',
       null,
@@ -168,7 +166,7 @@ class OwnerTest extends RenderTest {
       }
     );
 
-    this.render('<FooBar/>');
+    this.render.template('<FooBar/>');
 
     assert.verifySteps(['foo-bar owner called', 'foo-baz owner called'], 'owners used correctly');
   }
@@ -188,7 +186,7 @@ class OwnerTest extends RenderTest {
       `<CheckOwner1/><Mount2><CheckOwner1/></Mount2>`
     );
 
-    this.renderComponent(Mount1);
+    this.render.component(Mount1);
   }
 
   @test
@@ -206,7 +204,7 @@ class OwnerTest extends RenderTest {
       `<CheckOwner1/><Mount2 @CheckOwner1={{component CheckOwner1}}/>`
     );
 
-    this.renderComponent(Mount1);
+    this.render.component(Mount1);
   }
 
   // TODO: This behavior could be confusing the users, but currently we don't know of a way
@@ -227,18 +225,18 @@ class OwnerTest extends RenderTest {
       `<CheckOwner1/><Mount2 @CheckOwner2={{CheckOwner2}}/>`
     );
 
-    this.renderComponent(Mount1);
+    this.render.component(Mount1);
   }
 
   @test
   'resolution mode components defined within strict mode components receive correct owner during compilation'() {
-    this.registerComponent('TemplateOnly', 'Foo', 'Hello, world!');
+    this.register.component('TemplateOnly', 'Foo', 'Hello, world!');
 
     const Bar = defineComponent(null, '<Foo/>');
     const Baz = defineComponent({ Bar }, '<Bar/>');
 
-    this.renderComponent(Baz);
+    this.render.component(Baz);
   }
 }
 
-suite(OwnerTest, OwnerJitRenderDelegate);
+testSuite(OwnerTest, OwnerJitRenderDelegate);
diff --git a/packages/@glimmer-workspace/integration-tests/test/package.json b/packages/@glimmer-workspace/integration-tests/test/package.json
new file mode 100644
index 0000000000..1b75d58404
--- /dev/null
+++ b/packages/@glimmer-workspace/integration-tests/test/package.json
@@ -0,0 +1,20 @@
+{
+  "type": "module",
+  "private": true,
+  "dependencies": {
+    "@glimmer-workspace/integration-tests": "workspace:^",
+    "@glimmer/manager": "workspace:^",
+    "@glimmer/compiler": "workspace:^",
+    "@glimmer/destroyable": "workspace:^",
+    "@glimmer/interfaces": "workspace:^",
+    "@glimmer/reference": "workspace:^",
+    "@glimmer/runtime": "workspace:^",
+    "@glimmer/util": "workspace:^",
+    "@glimmer/validator": "workspace:^",
+    "@glimmer/syntax": "workspace:^",
+    "@glimmer/local-debug-flags": "workspace:^",
+    "@glimmer/opcode-compiler": "workspace:^",
+    "@glimmer/global-context": "workspace:^",
+    "@glimmer/wire-format": "workspace:^"
+  }
+}
diff --git a/packages/@glimmer-workspace/integration-tests/test/partial-rehydration-test.ts b/packages/@glimmer-workspace/integration-tests/test/partial-rehydration-test.ts
index 1c9e37ed8a..c8c212c9d4 100644
--- a/packages/@glimmer-workspace/integration-tests/test/partial-rehydration-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/partial-rehydration-test.ts
@@ -1,27 +1,27 @@
 import { castToSimple } from '@glimmer/util';
-
 import {
   CLOSE,
   content,
   OPEN,
   PartialRehydrationDelegate,
   qunitFixture,
-  RenderTest,
+  RenderTestContext,
   replaceHTML,
   stripTight,
-  suite,
   test,
-} from '..';
+  testSuite,
+} from '@glimmer-workspace/integration-tests';
 
-export class PartialRehydrationTest extends RenderTest {
+export class PartialRehydrationTest extends RenderTestContext {
   static suiteName = 'partial rehydration';
   declare delegate: PartialRehydrationDelegate;
 
   @test
   'can rehydrate from non starting blocks'() {
-    this.delegate.registerTemplateOnlyComponent('RehydratingComponent', '{{@a}}{{@b}}{{@c}}');
+    this.register.component('TemplateOnly', 'RehydratingComponent', '{{@a}}{{@b}}{{@c}}');
 
-    this.delegate.registerTemplateOnlyComponent(
+    this.register.component(
+      'TemplateOnly',
       'Root',
       '<div id="placeholder"><RehydratingComponent @a={{@a}} @b={{@b}} @c={{@c}}/></div>'
     );
@@ -75,11 +75,12 @@ export class PartialRehydrationTest extends RenderTest {
 
   @test
   'can rehydrate multiple call sites'() {
-    this.delegate.registerTemplateOnlyComponent('Nav', '{{@title}}');
-    this.delegate.registerTemplateOnlyComponent('Carousel', '{{@name}}');
-    this.delegate.registerTemplateOnlyComponent('Header', '<h1>I am a test</h1>');
+    this.register.component('TemplateOnly', 'Nav', '{{@title}}');
+    this.register.component('TemplateOnly', 'Carousel', '{{@name}}');
+    this.register.component('TemplateOnly', 'Header', '<h1>I am a test</h1>');
 
-    this.delegate.registerTemplateOnlyComponent(
+    this.register.component(
+      'TemplateOnly',
       'Root',
       stripTight`
         <div class="nav-container">
@@ -192,4 +193,4 @@ export class PartialRehydrationTest extends RenderTest {
   }
 }
 
-suite(PartialRehydrationTest, PartialRehydrationDelegate);
+testSuite(PartialRehydrationTest, PartialRehydrationDelegate);
diff --git a/packages/@glimmer-workspace/integration-tests/test/precompile-test.ts b/packages/@glimmer-workspace/integration-tests/test/precompile-test.ts
index e075ad6a8f..622bc3e241 100644
--- a/packages/@glimmer-workspace/integration-tests/test/precompile-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/precompile-test.ts
@@ -1,9 +1,8 @@
-import { precompile } from '@glimmer/compiler';
 import type { SerializedTemplateWithLazyBlock } from '@glimmer/interfaces';
+import type {TemplateFactoryWithIdAndMeta, TemplateWithIdAndReferrer} from '@glimmer/opcode-compiler';
+import { precompile } from '@glimmer/compiler';
 import {
-  templateFactory,
-  type TemplateFactoryWithIdAndMeta,
-  type TemplateWithIdAndReferrer,
+  templateFactory
 } from '@glimmer/opcode-compiler';
 import { unwrapTemplate } from '@glimmer/util';
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/smoke-test.ts b/packages/@glimmer-workspace/integration-tests/test/smoke-test.ts
index 4badfef870..5d25be6509 100644
--- a/packages/@glimmer-workspace/integration-tests/test/smoke-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/smoke-test.ts
@@ -1,6 +1,6 @@
-import { jitSuite, RenderTest, test } from '..';
+import { jitSuite, RenderTestContext, test } from '@glimmer-workspace/integration-tests';
 
-class SmokeTests extends RenderTest {
+class SmokeTests extends RenderTestContext {
   static suiteName = 'Smoke Tests';
 
   @test
@@ -13,7 +13,7 @@ class SmokeTests extends RenderTest {
       output += '<div id="test">HelloBye</div>';
     }
 
-    this.render(input);
+    this.render.template(input);
     this.assertHTML(output);
   }
 }
diff --git a/packages/@glimmer-workspace/integration-tests/test/strict-mode-test.ts b/packages/@glimmer-workspace/integration-tests/test/strict-mode-test.ts
index 57241e6a10..d8b980e79e 100644
--- a/packages/@glimmer-workspace/integration-tests/test/strict-mode-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/strict-mode-test.ts
@@ -1,20 +1,19 @@
 import { array, concat, fn, get, hash, on } from '@glimmer/runtime';
 import { castToBrowser } from '@glimmer/util';
-
 import {
   defineComponent,
   defineSimpleHelper,
   defineSimpleModifier,
   GlimmerishComponent,
   jitSuite,
-  RenderTest,
+  RenderTestContext,
   syntaxErrorFor,
   test,
   TestHelper,
   trackedObj,
-} from '..';
+} from '@glimmer-workspace/integration-tests';
 
-class GeneralStrictModeTest extends RenderTest {
+class GeneralStrictModeTest extends RenderTestContext {
   static suiteName = 'strict mode: general properties';
 
   @test
@@ -22,7 +21,7 @@ class GeneralStrictModeTest extends RenderTest {
     const plusOne = defineSimpleHelper((value = 0) => value + 1);
     const Bar = defineComponent({ plusOne }, '{{(plusOne)}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('1');
     this.assertStableRerender();
   }
@@ -33,18 +32,18 @@ class GeneralStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ plusOne, Foo }, '<Foo @value={{(plusOne)}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('1');
     this.assertStableRerender();
   }
 
   @test
   'Can call helper in argument position as subexpression in non-strict template (cross-compat test)'() {
-    this.registerHelper('plusOne', () => 'Hello, world!');
-    this.registerComponent('TemplateOnly', 'Foo', '{{@value}}');
-    this.registerComponent('TemplateOnly', 'Bar', '<Foo @value={{(plusOne)}}/>');
+    this.register.helper('plusOne', () => 'Hello, world!');
+    this.register.component('TemplateOnly', 'Foo', '{{@value}}');
+    this.register.component('TemplateOnly', 'Bar', '<Foo @value={{(plusOne)}}/>');
 
-    this.render('<Bar/>');
+    this.render.template('<Bar/>');
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -55,7 +54,7 @@ class GeneralStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ plusOne, Foo }, '<Foo @value={{(plusOne 1)}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('2');
     this.assertStableRerender();
   }
@@ -66,7 +65,7 @@ class GeneralStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ plusOne, Foo }, '<Foo @value={{plusOne 1}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('2');
     this.assertStableRerender();
   }
@@ -80,7 +79,7 @@ class GeneralStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Foo);
+      this.render.component(Foo);
     }, /Attempted to resolve a value in a strict mode template, but that value was not in scope: bar/u);
   }
 
@@ -100,7 +99,7 @@ class GeneralStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Foo);
+      this.render.component(Foo);
     }, /Error: Attempted to resolve a dynamic component with a string definition, `bar` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly./u);
   }
 
@@ -121,7 +120,7 @@ class GeneralStrictModeTest extends RenderTest {
 
     let args = trackedObj({ Bar });
 
-    this.renderComponent(Foo, args);
+    this.render.component(Foo, args);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
 
@@ -148,7 +147,7 @@ class GeneralStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Foo);
+      this.render.component(Foo);
     }, /Error: Attempted to resolve a dynamic component with a string definition, `bar` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly./u);
   }
 
@@ -160,7 +159,7 @@ class GeneralStrictModeTest extends RenderTest {
 
     let args = trackedObj({ Bar });
 
-    this.renderComponent(Foo, args);
+    this.render.component(Foo, args);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
 
@@ -187,7 +186,7 @@ class GeneralStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Error: Attempted to resolve a dynamic component with a string definition, `bar` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly./u);
   }
 
@@ -199,7 +198,7 @@ class GeneralStrictModeTest extends RenderTest {
 
     let args = trackedObj({ Bar });
 
-    this.renderComponent(Foo, args);
+    this.render.component(Foo, args);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
 
@@ -212,18 +211,18 @@ class GeneralStrictModeTest extends RenderTest {
 
   @test
   'works with a curried string component defined in a resolution mode component'() {
-    this.registerComponent('TemplateOnly', 'Hello', 'Hello, world!');
+    this.register.component('TemplateOnly', 'Hello', 'Hello, world!');
 
     const Foo = defineComponent(null, '{{component "Hello"}}');
     const Bar = defineComponent({ Foo }, '<Foo/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
 }
 
-class StaticStrictModeTest extends RenderTest {
+class StaticStrictModeTest extends RenderTestContext {
   static suiteName = 'strict mode: static template values';
 
   @test
@@ -231,7 +230,7 @@ class StaticStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, 'Hello, world!');
     const Bar = defineComponent({ Foo }, '<Foo/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -241,7 +240,7 @@ class StaticStrictModeTest extends RenderTest {
     const foo = defineSimpleHelper(() => 'Hello, world!');
     const Bar = defineComponent({ foo }, '{{foo}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -251,7 +250,7 @@ class StaticStrictModeTest extends RenderTest {
     const foo = defineSimpleHelper((value: string) => value);
     const Bar = defineComponent({ foo }, '{{foo "Hello, world!"}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -262,7 +261,7 @@ class StaticStrictModeTest extends RenderTest {
     const bar = defineSimpleHelper((value: string) => value);
     const Baz = defineComponent({ foo, bar }, '{{bar (foo)}}');
 
-    this.renderComponent(Baz);
+    this.render.component(Baz);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -272,7 +271,7 @@ class StaticStrictModeTest extends RenderTest {
     const foo = defineSimpleModifier((element: Element) => (element.innerHTML = 'Hello, world!'));
     const Bar = defineComponent({ foo }, '<div {{foo}}></div>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -282,7 +281,7 @@ class StaticStrictModeTest extends RenderTest {
     const ifComponent = defineComponent({}, 'Hello, world!');
     const Bar = defineComponent({ if: ifComponent }, '{{#if}}{{/if}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -293,7 +292,7 @@ class StaticStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{yield "Hello"}}');
     const Bar = defineComponent({ Foo, place }, '<Foo as |hi|>{{hi}}, {{place}}!</Foo>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -303,7 +302,7 @@ class StaticStrictModeTest extends RenderTest {
     const foo = defineComponent({}, 'Hello, world!');
     const bar = defineComponent({ foo }, '{{foo}}');
 
-    this.renderComponent(bar);
+    this.render.component(bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -313,7 +312,7 @@ class StaticStrictModeTest extends RenderTest {
     const foo = defineComponent({}, '{{@value}}');
     const bar = defineComponent({ foo }, '{{foo value="Hello, world!"}}');
 
-    this.renderComponent(bar);
+    this.render.component(bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -324,7 +323,7 @@ class StaticStrictModeTest extends RenderTest {
 
     const Foo = defineComponent({ value }, '{{value}}');
 
-    this.renderComponent(Foo);
+    this.render.component(Foo);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -336,7 +335,7 @@ class StaticStrictModeTest extends RenderTest {
     const foo = defineSimpleHelper((value: unknown) => value);
     const Bar = defineComponent({ foo, value }, '{{foo value}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -348,7 +347,7 @@ class StaticStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ Foo, value }, '<Foo @value={{value}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -358,7 +357,7 @@ class StaticStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ Foo }, '{{component Foo value="Hello, world!"}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -372,16 +371,25 @@ class StaticStrictModeTest extends RenderTest {
       '<Bar @Baz={{component Foo value="Hello, world!"}}/>'
     );
 
-    this.renderComponent(Baz);
+    this.render.component(Baz);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
 
   @test
   'Throws an error if component is not in scope'() {
-    this.assert.throws(() => {
-      defineComponent({}, '<Foo/>');
-    }, syntaxErrorFor('Attempted to invoke a component that was not in scope in a strict mode template, `<Foo>`. If you wanted to create an element with that name, convert it to lowercase - `<foo>`', '<Foo/>', 'an unknown module', 1, 0));
+    this.assert.throws(
+      () => {
+        defineComponent({}, '<Foo/>');
+      },
+      syntaxErrorFor(
+        'Attempted to invoke a component that was not in scope in a strict mode template, `<Foo>`. If you wanted to create an element with that name, convert it to lowercase - `<foo>`',
+        '<Foo/>',
+        'an unknown module',
+        1,
+        0
+      )
+    );
   }
 
   @test
@@ -389,7 +397,7 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({}, '{{foo}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a value in a strict mode template, but that value was not in scope: foo/u);
   }
 
@@ -398,7 +406,7 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({}, '{{foo "bar"}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a component or helper in a strict mode template, but that value was not in scope: foo/u);
   }
 
@@ -408,7 +416,7 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({ Foo }, '<Foo @foo={{bar}}/>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a value in a strict mode template, but that value was not in scope: bar/u);
   }
 
@@ -418,7 +426,7 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({ Foo }, '<Foo @foo={{bar "aoeu"}}/>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a helper in a strict mode template, but that value was not in scope: bar/u);
   }
 
@@ -428,70 +436,70 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({ foo }, '{{foo (bar)}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a helper in a strict mode template, but that value was not in scope: bar/u);
   }
 
   @test
   'Throws an error if value in append position is not in scope, and component is registered'() {
-    this.registerComponent('TemplateOnly', 'foo', 'Hello, world!');
+    this.register.component('TemplateOnly', 'foo', 'Hello, world!');
     const Bar = defineComponent({}, '{{foo}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a value in a strict mode template, but that value was not in scope: foo/u);
   }
 
   @test
   'Throws an error if value in append position is not in scope, and helper is registered'() {
-    this.registerHelper('foo', () => 'Hello, world!');
+    this.register.helper('foo', () => 'Hello, world!');
     const Bar = defineComponent({}, '{{foo}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a value in a strict mode template, but that value was not in scope: foo/u);
   }
 
   @test
   'Throws an error if component or helper in append position is not in scope, and helper is registered'() {
-    this.registerHelper('foo', () => 'Hello, world!');
+    this.register.helper('foo', () => 'Hello, world!');
     const Bar = defineComponent({}, '{{foo "bar"}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a component or helper in a strict mode template, but that value was not in scope: foo/u);
   }
 
   @test
   'Throws an error if a value in argument position is not in scope, and helper is registered'() {
-    this.registerHelper('bar', () => 'Hello, world!');
+    this.register.helper('bar', () => 'Hello, world!');
     const Foo = defineComponent({}, '{{@foo}}');
     const Bar = defineComponent({ Foo }, '<Foo @foo={{bar}}/>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a value in a strict mode template, but that value was not in scope: bar/u);
   }
 
   @test
   'Throws an error if helper in argument position (with args) is not in scope, and helper is registered'() {
-    this.registerHelper('bar', () => 'Hello, world!');
+    this.register.helper('bar', () => 'Hello, world!');
     const Foo = defineComponent({}, '{{@foo}}');
     const Bar = defineComponent({ Foo }, '<Foo @foo={{bar "aoeu"}}/>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a helper in a strict mode template, but that value was not in scope: bar/u);
   }
 
   @test
   'Throws an error if helper in subexpression position is not in scope, and helper is registered'() {
-    this.registerHelper('bar', () => 'Hello, world!');
+    this.register.helper('bar', () => 'Hello, world!');
     const foo = defineSimpleHelper((value: string) => value);
     const Bar = defineComponent({ foo }, '{{foo (bar)}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a helper in a strict mode template, but that value was not in scope: bar/u);
   }
 
@@ -500,17 +508,17 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({}, '<div {{foo}}></div>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a modifier in a strict mode template, but it was not in scope: foo/u);
   }
 
   @test
   'Throws an error if modifier is not in scope, and modifier is registred'() {
-    this.registerModifier('name', class {});
+    this.register.modifier('name', class {});
     const Bar = defineComponent({}, '<div {{foo}}></div>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to resolve a modifier in a strict mode template, but it was not in scope: foo/u);
   }
 
@@ -520,7 +528,7 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({ Foo }, '<Foo/>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to load a component, but there wasn't a component manager associated with the definition. The definition was:/u);
   }
 
@@ -530,7 +538,7 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({ foo }, '{{#if (foo)}}{{/if}}');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to load a helper, but there wasn't a helper manager associated with the definition. The definition was:/u);
   }
 
@@ -540,12 +548,12 @@ class StaticStrictModeTest extends RenderTest {
     const Bar = defineComponent({ foo }, '<div {{foo}}></div>');
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Attempted to load a modifier, but there wasn't a modifier manager associated with the definition. The definition was:/u);
   }
 }
 
-class DynamicStrictModeTest extends RenderTest {
+class DynamicStrictModeTest extends RenderTestContext {
   static suiteName = 'strict mode: dynamic template values';
 
   @test
@@ -557,7 +565,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -571,7 +579,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -585,7 +593,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -599,7 +607,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -613,7 +621,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -627,7 +635,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -641,7 +649,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -655,7 +663,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -670,7 +678,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -685,7 +693,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -696,7 +704,7 @@ class DynamicStrictModeTest extends RenderTest {
       definition: class extends GlimmerishComponent {},
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('');
     this.assertStableRerender();
   }
@@ -726,7 +734,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@helper}}');
     let args = trackedObj({ helper: Helper1 });
 
-    this.renderComponent(Foo, args);
+    this.render.component(Foo, args);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
 
@@ -771,7 +779,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Bar = defineComponent({ Foo }, '<Foo @helper={{helper @helper "world"}}/>');
     let args = trackedObj({ helper: Helper1 });
 
-    this.renderComponent(Bar, args);
+    this.render.component(Bar, args);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
 
@@ -799,7 +807,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -810,7 +818,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@value}}></div>');
     const Bar = defineComponent({ foo, Foo }, '<Foo @value={{foo}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -823,7 +831,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@value "Hello, world!"}}></div>');
     const Bar = defineComponent({ foo, Foo }, '<Foo @value={{foo}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -837,7 +845,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@value greeting="Hello, world!"}}></div>');
     const Bar = defineComponent({ foo, Foo }, '<Foo @value={{foo}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -850,7 +858,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@value}}></div>');
     const Bar = defineComponent({ foo, Foo }, '<Foo @value={{modifier foo "Hello, world!"}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -863,7 +871,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@value "world!"}}></div>');
     const Bar = defineComponent({ foo, Foo }, '<Foo @value={{modifier foo "Hello,"}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -877,7 +885,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Bar = defineComponent({ Foo }, '<Foo @value={{modifier @value "two"}}/>');
     const Baz = defineComponent({ foo, Bar }, '<Bar @value={{modifier foo "one"}}/>');
 
-    this.renderComponent(Baz);
+    this.render.component(Baz);
     this.assertHTML('<div>one two three</div>');
     this.assertStableRerender();
   }
@@ -894,7 +902,7 @@ class DynamicStrictModeTest extends RenderTest {
       '<Foo @value={{modifier foo greeting="Hello, world!"}}/>'
     );
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, Nebula!</div>');
     this.assertStableRerender();
   }
@@ -913,7 +921,7 @@ class DynamicStrictModeTest extends RenderTest {
     );
     const Baz = defineComponent({ foo, Bar }, '<Bar @value={{modifier foo greeting="Hola,"}}/>');
 
-    this.renderComponent(Baz);
+    this.render.component(Baz);
     this.assertHTML('<div>Hello, Nebula!</div>');
     this.assertStableRerender();
   }
@@ -925,7 +933,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@x.foo}}></div>');
     const Bar = defineComponent({ Foo, x }, '<Foo @x={{x}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -936,7 +944,7 @@ class DynamicStrictModeTest extends RenderTest {
       definition: class extends GlimmerishComponent {},
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div></div>');
     this.assertStableRerender();
   }
@@ -962,7 +970,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '<div {{@modifier}}></div>');
     let args = trackedObj({ modifier: modifier1 });
 
-    this.renderComponent(Foo, args);
+    this.render.component(Foo, args);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
 
@@ -1003,7 +1011,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Bar = defineComponent({ Foo }, '<Foo @modifier={{modifier @modifier "world"}}/>');
     let args = trackedObj({ modifier: modifier1 });
 
-    this.renderComponent(Bar, args);
+    this.render.component(Bar, args);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
 
@@ -1023,14 +1031,15 @@ class DynamicStrictModeTest extends RenderTest {
   }
 
   @test
-  'Calling a dynamic modifier using if helper'(assert: Assert) {
-    // Make sure the destructor gets called
-    assert.expect(14);
+  'Calling a dynamic modifier using if helper'() {
+    const events = this.events;
 
     const world = defineSimpleModifier((element: Element) => {
       element.innerHTML = `Hello, world!`;
 
-      return () => assert.ok(true, 'destructor called');
+      return () => {
+        events.record('destructor');
+      };
     });
     const nebula = defineSimpleModifier(
       (element: Element, [name]: string[]) => (element.innerHTML = `Hello, ${name}!`)
@@ -1043,19 +1052,22 @@ class DynamicStrictModeTest extends RenderTest {
 
     let args = trackedObj({ inSpace: false, name: 'Nebula' });
 
-    this.renderComponent(Bar, args);
+    this.render.component(Bar, args);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
+    this.events.expect([]);
 
     args['inSpace'] = true;
     this.rerender();
     this.assertHTML('<div>Hello, Nebula!</div>');
     this.assertStableRerender();
+    this.events.expect(['destructor']);
 
     args['name'] = 'Luna';
     this.rerender();
     this.assertHTML('<div>Hello, Luna!</div>');
     this.assertStableRerender();
+    this.events.expect([]);
   }
 
   @test
@@ -1068,7 +1080,7 @@ class DynamicStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was `\{\{this.foo\}\}`, and the incorrect definition is the value at the path `this.foo`, which was:/u);
   }
 
@@ -1078,7 +1090,7 @@ class DynamicStrictModeTest extends RenderTest {
     const x = { Foo };
     const Bar = defineComponent({ x }, '<x.Foo/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1089,7 +1101,7 @@ class DynamicStrictModeTest extends RenderTest {
     const x = { foo };
     const Bar = defineComponent({ x }, '{{x.foo}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1100,7 +1112,7 @@ class DynamicStrictModeTest extends RenderTest {
     const x = { foo };
     const Bar = defineComponent({ x }, '<div {{x.foo}}></div>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('<div>Hello, world!</div>');
     this.assertStableRerender();
   }
@@ -1111,7 +1123,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ Foo, x }, '<Foo @value={{x.value}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1121,7 +1133,7 @@ class DynamicStrictModeTest extends RenderTest {
     const x = { value: 'Hello, world!' };
     const Bar = defineComponent({ x }, '{{x.value}}');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1135,7 +1147,7 @@ class DynamicStrictModeTest extends RenderTest {
       },
     });
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1154,7 +1166,7 @@ class DynamicStrictModeTest extends RenderTest {
       }
     );
 
-    this.renderComponent(Baz);
+    this.render.component(Baz);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1169,7 +1181,7 @@ class DynamicStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Expected a dynamic component definition, but received an object or function that did not have a component manager associated with it. The dynamic invocation was `<this.Foo>` or `\{\{this.Foo\}\}`, and the incorrect definition is the value at the path `this.Foo`, which was:/u);
   }
 
@@ -1179,7 +1191,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ plusOne, Foo }, '<Foo @value={{plusOne}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1190,7 +1202,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value 123}}');
     const Bar = defineComponent({ plusOne, Foo }, '<Foo @value={{plusOne}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('124');
     this.assertStableRerender();
   }
@@ -1201,7 +1213,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value}}');
     const Bar = defineComponent({ plusOne, Foo }, '<Foo @value={{helper plusOne 123}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('124');
     this.assertStableRerender();
   }
@@ -1212,7 +1224,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value 2}}');
     const Bar = defineComponent({ add, Foo }, '<Foo @value={{helper add 1}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('3');
     this.assertStableRerender();
   }
@@ -1222,7 +1234,7 @@ class DynamicStrictModeTest extends RenderTest {
     const Foo = defineComponent({}, '{{@value 2}}');
     const Bar = defineComponent({ Foo }, '<Foo @value={{helper @foo 1}}/>');
 
-    this.renderComponent(Bar);
+    this.render.component(Bar);
     this.assertHTML('');
     this.assertStableRerender();
   }
@@ -1237,12 +1249,12 @@ class DynamicStrictModeTest extends RenderTest {
     });
 
     this.assert.throws(() => {
-      this.renderComponent(Bar);
+      this.render.component(Bar);
     }, /Expected a dynamic helper definition, but received an object or function that did not have a helper manager associated with it. The dynamic invocation was `\{\{this.foo\}\}` or `\(this.foo\)`, and the incorrect definition is the value at the path `this.foo`, which was:/u);
   }
 }
 
-class BuiltInsStrictModeTest extends RenderTest {
+class BuiltInsStrictModeTest extends RenderTestContext {
   static suiteName = 'strict mode: built in modifiers and helpers';
 
   @test
@@ -1252,7 +1264,7 @@ class BuiltInsStrictModeTest extends RenderTest {
       '{{#let (hash value="Hello, world!") as |hash|}}{{hash.value}}{{/let}}'
     );
 
-    this.renderComponent(Foo);
+    this.render.component(Foo);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1264,7 +1276,7 @@ class BuiltInsStrictModeTest extends RenderTest {
       '{{#each (array "Hello, world!") as |value|}}{{value}}{{/each}}'
     );
 
-    this.renderComponent(Foo);
+    this.render.component(Foo);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1273,7 +1285,7 @@ class BuiltInsStrictModeTest extends RenderTest {
   'Can use concat'() {
     let Foo = defineComponent({ concat }, '{{(concat "Hello" ", " "world!")}}');
 
-    this.renderComponent(Foo);
+    this.render.component(Foo);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
@@ -1285,16 +1297,15 @@ class BuiltInsStrictModeTest extends RenderTest {
       '{{#let (hash value="Hello, world!") as |hash|}}{{(get hash "value")}}{{/let}}'
     );
 
-    this.renderComponent(Foo);
+    this.render.component(Foo);
     this.assertHTML('Hello, world!');
     this.assertStableRerender();
   }
 
   @test
   'Can use on and fn'(assert: Assert) {
-    assert.expect(3);
-
     let handleClick = (value: number) => {
+      this.events.record('handleClick');
       assert.strictEqual(value, 123, 'handler called with correct value');
     };
 
@@ -1303,9 +1314,10 @@ class BuiltInsStrictModeTest extends RenderTest {
       '<button {{on "click" (fn handleClick 123)}}>Click</button>'
     );
 
-    this.renderComponent(Foo);
+    this.render.component(Foo);
 
     castToBrowser(this.element, 'div').querySelector('button')!.click();
+    this.events.expect(['handleClick']);
   }
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/style-warnings-test.ts b/packages/@glimmer-workspace/integration-tests/test/style-warnings-test.ts
index 889cd92db7..089ac61008 100644
--- a/packages/@glimmer-workspace/integration-tests/test/style-warnings-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/style-warnings-test.ts
@@ -1,15 +1,16 @@
-import { type GlobalContext, testOverrideGlobalContext } from '@glimmer/global-context';
+import type {GlobalContext} from '@glimmer/global-context';
+import {  testOverrideGlobalContext } from '@glimmer/global-context';
+import { jitSuite, RenderTestContext, test } from '@glimmer-workspace/integration-tests';
 
-import { jitSuite, RenderTest, test } from '..';
 import { assert } from './support';
 
 let warnings = 0;
 let originalContext: GlobalContext | null;
 
-class StyleWarningsTest extends RenderTest {
+class StyleWarningsTest extends RenderTestContext {
   static suiteName = 'Style attributes';
 
-  beforeEach() {
+  override readonly beforeEach = () => {
     warnings = 0;
     originalContext =
       testOverrideGlobalContext?.({
@@ -21,24 +22,24 @@ class StyleWarningsTest extends RenderTest {
           return (obj as Record<string, unknown>)[key];
         },
       }) ?? null;
-  }
+  };
 
-  afterEach() {
+  override readonly afterEach = () => {
     testOverrideGlobalContext?.(originalContext);
-  }
+  };
 
   @test
   'Standard element with static style and element modifier does not give you a warning'() {
-    this.registerModifier('foo', class {});
-    this.render('<button style="display: flex" {{foo}}>click me</button>', {});
+    this.register.modifier('foo', class {});
+    this.render.template('<button style="display: flex" {{foo}}>click me</button>', {});
 
     assert.strictEqual(warnings, 0);
   }
 
   @test
   'Standard element with dynamic style and element modifier gives you 1 warning'() {
-    this.registerModifier('foo', class {});
-    this.render('<button style={{this.dynAttr}} {{foo}}>click me</button>', {
+    this.register.modifier('foo', class {});
+    this.render.template('<button style={{this.dynAttr}} {{foo}}>click me</button>', {
       dynAttr: 'display:flex',
     });
 
@@ -47,7 +48,7 @@ class StyleWarningsTest extends RenderTest {
 
   @test
   'using a static inline style on an element does not give you a warning'() {
-    this.render(`<div style="background: red">Thing</div>`, {});
+    this.render.template(`<div style="background: red">Thing</div>`, {});
 
     assert.strictEqual(warnings, 0);
     this.assertHTML('<div style="background: red">Thing</div>', 'initial render');
@@ -55,7 +56,7 @@ class StyleWarningsTest extends RenderTest {
 
   @test
   'triple curlies are trusted'() {
-    this.render(`<div foo={{this.foo}} style={{{this.styles}}}>Thing</div>`, {
+    this.render.template(`<div foo={{this.foo}} style={{{this.styles}}}>Thing</div>`, {
       styles: 'background: red',
     });
 
@@ -65,7 +66,10 @@ class StyleWarningsTest extends RenderTest {
 
   @test
   'using a static inline style on an namespaced element does not give you a warning'() {
-    this.render(`<svg xmlns:svg="http://www.w3.org/2000/svg" style="background: red" />`, {});
+    this.render.template(
+      `<svg xmlns:svg="http://www.w3.org/2000/svg" style="background: red" />`,
+      {}
+    );
 
     assert.strictEqual(warnings, 0);
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/syntax/argument-less-helper-paren-less-invoke-test.ts b/packages/@glimmer-workspace/integration-tests/test/syntax/argument-less-helper-paren-less-invoke-test.ts
index 7428ff81c2..3455133d01 100644
--- a/packages/@glimmer-workspace/integration-tests/test/syntax/argument-less-helper-paren-less-invoke-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/syntax/argument-less-helper-paren-less-invoke-test.ts
@@ -1,18 +1,23 @@
-import { defineSimpleHelper, jitSuite, RenderTest, test } from '../..';
-
-class ArgumentLessHelperParenLessInvokeTest extends RenderTest {
+import {
+  defineSimpleHelper,
+  jitSuite,
+  RenderTestContext,
+  test,
+} from '@glimmer-workspace/integration-tests';
+
+class ArgumentLessHelperParenLessInvokeTest extends RenderTestContext {
   static suiteName = 'argument-less helper paren-less invoke';
 
   @test
   'invoking an argument-less helper without parens in named argument position is deprecated'(
     assert: Assert
   ) {
-    this.registerHelper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
+    this.register.helper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
 
-    this.registerHelper('foo', () => 'Hello, world!');
-    this.registerComponent('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
+    this.register.helper('foo', () => 'Hello, world!');
+    this.register.component('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
 
-    this.render('<Bar @content={{foo}} />', { foo: 'Not it!' });
+    this.render.template('<Bar @content={{foo}} />', { foo: 'Not it!' });
     this.assertHTML('[true][Hello, world!]');
     this.assertStableRerender();
 
@@ -30,50 +35,50 @@ class ArgumentLessHelperParenLessInvokeTest extends RenderTest {
 
   @test
   'invoking an argument-less helper with parens in named argument position is not deprecated'() {
-    this.registerHelper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
+    this.register.helper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
 
-    this.registerHelper('foo', () => 'Hello, world!');
-    this.registerComponent('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
+    this.register.helper('foo', () => 'Hello, world!');
+    this.register.component('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
 
-    this.render('<Bar @content={{(foo)}} />');
+    this.render.template('<Bar @content={{(foo)}} />');
     this.assertHTML('[true][Hello, world!]');
     this.assertStableRerender();
   }
 
   @test
   'invoking an argument-less helper with quotes in named argument position is not deprecated'() {
-    this.registerHelper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
+    this.register.helper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
 
-    this.registerHelper('foo', () => 'Hello, world!');
-    this.registerComponent('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
+    this.register.helper('foo', () => 'Hello, world!');
+    this.register.component('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
 
-    this.render('<Bar @content="{{foo}}" />');
+    this.render.template('<Bar @content="{{foo}}" />');
     this.assertHTML('[true][Hello, world!]');
     this.assertStableRerender();
   }
 
   @test
   'passing a local helper in named argument position is not deprecated'() {
-    this.registerHelper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
+    this.register.helper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
 
     const foo = defineSimpleHelper(() => 'Hello, world!');
 
-    this.registerComponent('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
+    this.register.component('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
 
-    this.render('{{#let this.foo as |foo|}}<Bar @content={{foo}} />{{/let}}', { foo });
+    this.render.template('{{#let this.foo as |foo|}}<Bar @content={{foo}} />{{/let}}', { foo });
     this.assertHTML('[false][Hello, world!]');
     this.assertStableRerender();
   }
 
   @test
   'invoking a local helper with parens in named argument position is not deprecated'() {
-    this.registerHelper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
+    this.register.helper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
 
     const foo = defineSimpleHelper(() => 'Hello, world!');
 
-    this.registerComponent('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
+    this.register.component('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
 
-    this.render('{{#let this.foo as |foo|}}<Bar @content={{(foo)}} />{{/let}}', { foo });
+    this.render.template('{{#let this.foo as |foo|}}<Bar @content={{(foo)}} />{{/let}}', { foo });
     this.assertHTML('[true][Hello, world!]');
     this.assertStableRerender();
   }
@@ -82,11 +87,11 @@ class ArgumentLessHelperParenLessInvokeTest extends RenderTest {
 
   // @test
   // 'invoking a helper with quotes in named argument position is not deprecated'() {
-  //   this.registerHelper('is-string', ([value]: readonly unknown[]) => typeof value === 'string');
+  //   this.register.helper('is-string', ([value]: readonly unknown[]) => typeof value === 'string' );
 
   //   const foo = defineSimpleHelper(() => 'Hello, world!');
 
-  //   this.registerComponent('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
+  //   this.register.component('TemplateOnly', 'Bar', '[{{is-string @content}}][{{@content}}]');
 
   //   this.render('{{#let this.foo as |foo|}}<Bar @content="{{foo}}" />{{/let}}', { foo });
   //   this.assertHTML('[true][Hello, world!]');
diff --git a/packages/@glimmer-workspace/integration-tests/test/syntax/general-errors-test.ts b/packages/@glimmer-workspace/integration-tests/test/syntax/general-errors-test.ts
index c969675839..822fe852b5 100644
--- a/packages/@glimmer-workspace/integration-tests/test/syntax/general-errors-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/syntax/general-errors-test.ts
@@ -1,81 +1,198 @@
-import { jitSuite, preprocess, RenderTest, syntaxErrorFor, test } from '../..';
+import {
+  jitSuite,
+  preprocess,
+  RenderTestContext,
+  syntaxErrorFor,
+  test,
+} from '@glimmer-workspace/integration-tests';
 
-class SyntaxErrors extends RenderTest {
+class SyntaxErrors extends RenderTestContext {
   static suiteName = 'general syntax errors';
 
   @test
   'context switching using ../ is not allowed'() {
-    this.assert.throws(() => {
-      preprocess('<div><p>{{../value}}</p></div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Changing context using "../" is not supported in Glimmer', '../value', 'test-module', 1, 10));
+    this.assert.throws(
+      () => {
+        preprocess('<div><p>{{../value}}</p></div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Changing context using "../" is not supported in Glimmer',
+        '../value',
+        'test-module',
+        1,
+        10
+      )
+    );
   }
 
   @test
   'mixing . and / is not allowed'() {
-    this.assert.throws(() => {
-      preprocess('<div><p>{{a/b.c}}</p></div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths", 'a/b.c', 'test-module', 1, 10));
+    this.assert.throws(
+      () => {
+        preprocess('<div><p>{{a/b.c}}</p></div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "Mixing '.' and '/' in paths is not supported in Glimmer; use only '.' to separate property paths",
+        'a/b.c',
+        'test-module',
+        1,
+        10
+      )
+    );
   }
 
   @test
   'explicit self ref with ./ is not allowed'() {
-    this.assert.throws(() => {
-      preprocess('<div><p>{{./value}}</p></div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Using "./" is not supported in Glimmer and unnecessary', './value', 'test-module', 1, 10));
+    this.assert.throws(
+      () => {
+        preprocess('<div><p>{{./value}}</p></div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Using "./" is not supported in Glimmer and unnecessary',
+        './value',
+        'test-module',
+        1,
+        10
+      )
+    );
   }
 
   @test
   'Block params in HTML syntax - Throws exception if given zero parameters'() {
-    this.assert.throws(() => {
-      preprocess('<x-bar as ||>foo</x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Cannot use zero block parameters', '<x-bar as ||>foo</x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as ||>foo</x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Cannot use zero block parameters',
+        '<x-bar as ||>foo</x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('<x-bar as | |>foo</x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Cannot use zero block parameters', '<x-bar as | |>foo</x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as | |>foo</x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Cannot use zero block parameters',
+        '<x-bar as | |>foo</x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Block params in HTML syntax - Throws an error on invalid block params syntax'() {
-    this.assert.throws(() => {
-      preprocess('<x-bar as |x y>{{x}},{{y}}</x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("Invalid block parameters syntax, 'as |x y'", '<x-bar as |x y>{{x}},{{y}}</x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as |x y>{{x}},{{y}}</x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "Invalid block parameters syntax, 'as |x y'",
+        '<x-bar as |x y>{{x}},{{y}}</x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('<x-bar as |x| y>{{x}},{{y}}</x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("Invalid block parameters syntax, 'as |x| y'", '<x-bar as |x| y>{{x}},{{y}}</x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as |x| y>{{x}},{{y}}</x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "Invalid block parameters syntax, 'as |x| y'",
+        '<x-bar as |x| y>{{x}},{{y}}</x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('<x-bar as |x| y|>{{x}},{{y}}</x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("Invalid block parameters syntax, 'as |x| y|'", '<x-bar as |x| y|>{{x}},{{y}}</x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as |x| y|>{{x}},{{y}}</x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "Invalid block parameters syntax, 'as |x| y|'",
+        '<x-bar as |x| y|>{{x}},{{y}}</x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Block params in HTML syntax - Throws an error on invalid identifiers for params'() {
-    this.assert.throws(() => {
-      preprocess('<x-bar as |x foo.bar|></x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("Invalid identifier for block parameters, 'foo.bar'", '<x-bar as |x foo.bar|></x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as |x foo.bar|></x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "Invalid identifier for block parameters, 'foo.bar'",
+        '<x-bar as |x foo.bar|></x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('<x-bar as |x "foo"|></x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('" is not a valid character within attribute names', '', 'test-module', 1, 17));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as |x "foo"|></x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor('" is not a valid character within attribute names', '', 'test-module', 1, 17)
+    );
 
-    this.assert.throws(() => {
-      preprocess('<x-bar as |foo[bar]|></x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("Invalid identifier for block parameters, 'foo[bar]'", '<x-bar as |foo[bar]|></x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar as |foo[bar]|></x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "Invalid identifier for block parameters, 'foo[bar]'",
+        '<x-bar as |foo[bar]|></x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Block params in HTML syntax - Throws an error on missing `as`'() {
-    this.assert.throws(() => {
-      preprocess('<x-bar |x|></x-bar>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Block parameters must be preceded by the `as` keyword, detected block parameters without `as`', '<x-bar |x|></x-bar>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar |x|></x-bar>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Block parameters must be preceded by the `as` keyword, detected block parameters without `as`',
+        '<x-bar |x|></x-bar>',
+        'test-module',
+        1,
+        0
+      )
+    );
 
-    this.assert.throws(() => {
-      preprocess('<x-bar><:baz |x|></:baz></x-bar>', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Block parameters must be preceded by the `as` keyword, detected block parameters without `as`', '<:baz |x|></:baz>', 'test-module', 1, 7));
+    this.assert.throws(
+      () => {
+        preprocess('<x-bar><:baz |x|></:baz></x-bar>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Block parameters must be preceded by the `as` keyword, detected block parameters without `as`',
+        '<:baz |x|></:baz>',
+        'test-module',
+        1,
+        7
+      )
+    );
   }
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/syntax/if-unless-test.ts b/packages/@glimmer-workspace/integration-tests/test/syntax/if-unless-test.ts
index 2ca6af6cc5..30f8421245 100644
--- a/packages/@glimmer-workspace/integration-tests/test/syntax/if-unless-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/syntax/if-unless-test.ts
@@ -1,95 +1,217 @@
- 
-import { jitSuite, preprocess, RenderTest, syntaxErrorFor, test } from '../..';
+import {
+  jitSuite,
+  preprocess,
+  RenderTestContext,
+  syntaxErrorFor,
+  test,
+} from '@glimmer-workspace/integration-tests';
 
 let types = ['if', 'unless'];
 
 for (let type of types) {
-  class SyntaxErrors extends RenderTest {
+  class SyntaxErrors extends RenderTestContext {
     static suiteName = `if/unless (${type}) keyword syntax errors`;
 
     @test
     '{{#${type}}} throws if it received named args'() {
-      this.assert.throws(() => {
-        preprocess(`{{#${type} condition=true}}{{/${type}}}`, {
-          meta: { moduleName: 'test-module' },
-        });
-      }, syntaxErrorFor(`{{#${type}}} cannot receive named parameters, received condition`, `{{#${type} condition=true}}{{/${type}}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{#${type} condition=true}}{{/${type}}}`, {
+            meta: { moduleName: 'test-module' },
+          });
+        },
+        syntaxErrorFor(
+          `{{#${type}}} cannot receive named parameters, received condition`,
+          `{{#${type} condition=true}}{{/${type}}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '{{#${type}}} throws if it received no positional params'() {
-      this.assert.throws(() => {
-        preprocess(`{{#${type}}}{{/${type}}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`{{#${type}}} requires a condition as its first positional parameter, did not receive any parameters`, `{{#${type}}}{{/${type}}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{#${type}}}{{/${type}}}`, { meta: { moduleName: 'test-module' } });
+        },
+        syntaxErrorFor(
+          `{{#${type}}} requires a condition as its first positional parameter, did not receive any parameters`,
+          `{{#${type}}}{{/${type}}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '{{#${type}}} throws if it received more than one positional param'() {
-      this.assert.throws(() => {
-        preprocess(`{{#${type} true false}}{{/${type}}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`{{#${type}}} can only receive one positional parameter in block form, the conditional value. Received 2 parameters`, `{{#${type} true false}}{{/${type}}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{#${type} true false}}{{/${type}}}`, {
+            meta: { moduleName: 'test-module' },
+          });
+        },
+        syntaxErrorFor(
+          `{{#${type}}} can only receive one positional parameter in block form, the conditional value. Received 2 parameters`,
+          `{{#${type} true false}}{{/${type}}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '{{${type}}} throws if it received named args'() {
-      this.assert.throws(() => {
-        preprocess(`{{${type} condition=true}}`, {
-          meta: { moduleName: 'test-module' },
-        });
-      }, syntaxErrorFor(`(${type}) cannot receive named parameters, received condition`, `{{${type} condition=true}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{${type} condition=true}}`, {
+            meta: { moduleName: 'test-module' },
+          });
+        },
+        syntaxErrorFor(
+          `(${type}) cannot receive named parameters, received condition`,
+          `{{${type} condition=true}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '{{${type}}} throws if it received no positional params'() {
-      this.assert.throws(() => {
-        preprocess(`{{${type}}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${type === 'if' ? 'true' : 'false'}. Did not receive any parameters`, `{{${type}}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{${type}}}`, { meta: { moduleName: 'test-module' } });
+        },
+        syntaxErrorFor(
+          `When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${
+            type === 'if' ? 'true' : 'false'
+          }. Did not receive any parameters`,
+          `{{${type}}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '{{${type}}} throws if it received only one positional param'() {
-      this.assert.throws(() => {
-        preprocess(`{{${type} true}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${type === 'if' ? 'true' : 'false'}. Received only one parameter, the condition`, `{{${type} true}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{${type} true}}`, { meta: { moduleName: 'test-module' } });
+        },
+        syntaxErrorFor(
+          `When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${
+            type === 'if' ? 'true' : 'false'
+          }. Received only one parameter, the condition`,
+          `{{${type} true}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '{{${type}}} throws if it received more than 3 positional params'() {
-      this.assert.throws(() => {
-        preprocess(`{{${type} true false true false}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${type === 'if' ? 'true' : 'false'}, and 3. the value to return if the condition is ${type === 'if' ? 'false' : 'true'}. Received 4 parameters`, `{{${type} true false true false}}`, 'test-module', 1, 0));
+      this.assert.throws(
+        () => {
+          preprocess(`{{${type} true false true false}}`, { meta: { moduleName: 'test-module' } });
+        },
+        syntaxErrorFor(
+          `When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${
+            type === 'if' ? 'true' : 'false'
+          }, and 3. the value to return if the condition is ${
+            type === 'if' ? 'false' : 'true'
+          }. Received 4 parameters`,
+          `{{${type} true false true false}}`,
+          'test-module',
+          1,
+          0
+        )
+      );
     }
 
     @test
     '(${type}) throws if it received named args'() {
-      this.assert.throws(() => {
-        preprocess(`{{foo (${type} condition=true)}}`, {
-          meta: { moduleName: 'test-module' },
-        });
-      }, syntaxErrorFor(`(${type}) cannot receive named parameters, received condition`, `(${type} condition=true)`, 'test-module', 1, 6));
+      this.assert.throws(
+        () => {
+          preprocess(`{{foo (${type} condition=true)}}`, {
+            meta: { moduleName: 'test-module' },
+          });
+        },
+        syntaxErrorFor(
+          `(${type}) cannot receive named parameters, received condition`,
+          `(${type} condition=true)`,
+          'test-module',
+          1,
+          6
+        )
+      );
     }
 
     @test
     '(${type}) throws if it received no positional params'() {
-      this.assert.throws(() => {
-        preprocess(`{{foo (${type})}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${type === 'if' ? 'true' : 'false'}. Did not receive any parameters`, `(${type})`, 'test-module', 1, 6));
+      this.assert.throws(
+        () => {
+          preprocess(`{{foo (${type})}}`, { meta: { moduleName: 'test-module' } });
+        },
+        syntaxErrorFor(
+          `When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${
+            type === 'if' ? 'true' : 'false'
+          }. Did not receive any parameters`,
+          `(${type})`,
+          'test-module',
+          1,
+          6
+        )
+      );
     }
 
     @test
     '(${type}) throws if it received only one positional param'() {
-      this.assert.throws(() => {
-        preprocess(`{{foo (${type} true)}}`, { meta: { moduleName: 'test-module' } });
-      }, syntaxErrorFor(`When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${type === 'if' ? 'true' : 'false'}. Received only one parameter, the condition`, `(${type} true)`, 'test-module', 1, 6));
+      this.assert.throws(
+        () => {
+          preprocess(`{{foo (${type} true)}}`, { meta: { moduleName: 'test-module' } });
+        },
+        syntaxErrorFor(
+          `When used inline, (${type}) requires at least two parameters 1. the condition that determines the state of the (${type}), and 2. the value to return if the condition is ${
+            type === 'if' ? 'true' : 'false'
+          }. Received only one parameter, the condition`,
+          `(${type} true)`,
+          'test-module',
+          1,
+          6
+        )
+      );
     }
 
     @test
     '(${type}) throws if it received more than 3 positional params'() {
-      this.assert.throws(() => {
-        preprocess(`{{foo (${type} true false true false)}}`, {
-          meta: { moduleName: 'test-module' },
-        });
-      }, syntaxErrorFor(`When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${type === 'if' ? 'true' : 'false'}, and 3. the value to return if the condition is ${type === 'if' ? 'false' : 'true'}. Received 4 parameters`, `(${type} true false true false)`, 'test-module', 1, 6));
+      this.assert.throws(
+        () => {
+          preprocess(`{{foo (${type} true false true false)}}`, {
+            meta: { moduleName: 'test-module' },
+          });
+        },
+        syntaxErrorFor(
+          `When used inline, (${type}) can receive a maximum of three positional parameters 1. the condition that determines the state of the (${type}), 2. the value to return if the condition is ${
+            type === 'if' ? 'true' : 'false'
+          }, and 3. the value to return if the condition is ${
+            type === 'if' ? 'false' : 'true'
+          }. Received 4 parameters`,
+          `(${type} true false true false)`,
+          'test-module',
+          1,
+          6
+        )
+      );
     }
   }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/syntax/keyword-errors-test.ts b/packages/@glimmer-workspace/integration-tests/test/syntax/keyword-errors-test.ts
index 843da937de..98f6c7c226 100644
--- a/packages/@glimmer-workspace/integration-tests/test/syntax/keyword-errors-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/syntax/keyword-errors-test.ts
@@ -1,6 +1,11 @@
-import { KEYWORDS_TYPES, type KeywordType } from '@glimmer/syntax';
-
-import { jitSuite, preprocess, RenderTest, test } from '../..';
+import type {KeywordType} from '@glimmer/syntax';
+import { KEYWORDS_TYPES  } from '@glimmer/syntax';
+import {
+  jitSuite,
+  preprocess,
+  RenderTestContext,
+  test,
+} from '@glimmer-workspace/integration-tests';
 
 type KeywordName = keyof typeof KEYWORDS_TYPES;
 const TYPES: Record<KeywordName, readonly KeywordType[]> = KEYWORDS_TYPES;
@@ -12,7 +17,7 @@ const CALL_KEYWORDS = KEYWORDS.filter((key) => TYPES[key].includes('Call'));
 const MODIFIER_KEYWORDS = KEYWORDS.filter((key) => TYPES[key].includes('Modifier'));
 
 for (let keyword of KEYWORDS) {
-  class KeywordSyntaxErrors extends RenderTest {
+  class KeywordSyntaxErrors extends RenderTestContext {
     static suiteName = `\`${keyword}\` keyword syntax errors`;
 
     @test
@@ -147,9 +152,14 @@ for (let keyword of KEYWORDS) {
         return;
       }
 
-      this.assert.throws(() => {
-        preprocess(`{{#${keyword}}}{{/${keyword}}}`, { meta: { moduleName: 'test-module' } });
-      }, new RegExp(`The \`${keyword}\` keyword was used incorrectly. It was used as a block statement, but its valid usages are:`));
+      this.assert.throws(
+        () => {
+          preprocess(`{{#${keyword}}}{{/${keyword}}}`, { meta: { moduleName: 'test-module' } });
+        },
+        new RegExp(
+          `The \`${keyword}\` keyword was used incorrectly. It was used as a block statement, but its valid usages are:`
+        )
+      );
     }
 
     @test
@@ -158,9 +168,14 @@ for (let keyword of KEYWORDS) {
         return;
       }
 
-      this.assert.throws(() => {
-        preprocess(`{{${keyword}}}`, { meta: { moduleName: 'test-module' } });
-      }, new RegExp(`The \`${keyword}\` keyword was used incorrectly. It was used as an append statement, but its valid usages are:`));
+      this.assert.throws(
+        () => {
+          preprocess(`{{${keyword}}}`, { meta: { moduleName: 'test-module' } });
+        },
+        new RegExp(
+          `The \`${keyword}\` keyword was used incorrectly. It was used as an append statement, but its valid usages are:`
+        )
+      );
     }
 
     @test
@@ -169,9 +184,14 @@ for (let keyword of KEYWORDS) {
         return;
       }
 
-      this.assert.throws(() => {
-        preprocess(`{{some-helper (${keyword})}}`, { meta: { moduleName: 'test-module' } });
-      }, new RegExp(`The \`${keyword}\` keyword was used incorrectly. It was used as a call expression, but its valid usages are:`));
+      this.assert.throws(
+        () => {
+          preprocess(`{{some-helper (${keyword})}}`, { meta: { moduleName: 'test-module' } });
+        },
+        new RegExp(
+          `The \`${keyword}\` keyword was used incorrectly. It was used as a call expression, but its valid usages are:`
+        )
+      );
     }
 
     @test
@@ -180,9 +200,14 @@ for (let keyword of KEYWORDS) {
         return;
       }
 
-      this.assert.throws(() => {
-        preprocess(`<div {{${keyword}}}></div>`, { meta: { moduleName: 'test-module' } });
-      }, new RegExp(`The \`${keyword}\` keyword was used incorrectly. It was used as a modifier, but its valid usages are:`));
+      this.assert.throws(
+        () => {
+          preprocess(`<div {{${keyword}}}></div>`, { meta: { moduleName: 'test-module' } });
+        },
+        new RegExp(
+          `The \`${keyword}\` keyword was used incorrectly. It was used as a modifier, but its valid usages are:`
+        )
+      );
     }
   }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/syntax/named-blocks-test.ts b/packages/@glimmer-workspace/integration-tests/test/syntax/named-blocks-test.ts
index c66c7427d0..b0b5c83eca 100644
--- a/packages/@glimmer-workspace/integration-tests/test/syntax/named-blocks-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/syntax/named-blocks-test.ts
@@ -1,100 +1,245 @@
-import { jitSuite, preprocess, RenderTest, syntaxErrorFor, test } from '../..';
-
-class NamedBlocksSyntaxErrors extends RenderTest {
+import {
+  jitSuite,
+  preprocess,
+  RenderTestContext,
+  syntaxErrorFor,
+  test,
+} from '@glimmer-workspace/integration-tests';
+
+class NamedBlocksSyntaxErrors extends RenderTestContext {
   static suiteName = 'named blocks syntax errors';
 
   @test
   'Defining block params on a component which has named blocks'() {
-    this.assert.throws(() => {
-      preprocess('<Foo as |bar|><:foo></:foo></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Unexpected block params list on <Foo> component invocation: when passing named blocks, the invocation tag cannot take block params', '<Foo as |bar|><:foo></:foo></Foo>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo as |bar|><:foo></:foo></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Unexpected block params list on <Foo> component invocation: when passing named blocks, the invocation tag cannot take block params',
+        '<Foo as |bar|><:foo></:foo></Foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Defining named blocks on a plain element is not allowed'() {
-    this.assert.throws(() => {
-      preprocess('<div><:foo></:foo></div>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Unexpected named block <:foo> inside <div> HTML element', '<div><:foo></:foo></div>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<div><:foo></:foo></div>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Unexpected named block <:foo> inside <div> HTML element',
+        '<div><:foo></:foo></div>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Defining top level named blocks is not allowed'() {
-    this.assert.throws(() => {
-      preprocess('<:foo></:foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Unexpected named block at the top-level of a template', '<:foo></:foo>', 'test-module', 1, 0));
-
-    this.assert.throws(() => {
-      preprocess('{{#if}}<:foo></:foo>{{/if}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Unexpected named block nested in a normal block', '<:foo></:foo>', 'test-module', 1, 7));
+    this.assert.throws(
+      () => {
+        preprocess('<:foo></:foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Unexpected named block at the top-level of a template',
+        '<:foo></:foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('{{#if}}<:foo></:foo>{{/if}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Unexpected named block nested in a normal block',
+        '<:foo></:foo>',
+        'test-module',
+        1,
+        7
+      )
+    );
   }
 
   @test
   'Passing multiple of the same named block throws an error'() {
-    this.assert.throws(() => {
-      preprocess('<Foo><:foo></:foo><:foo></:foo></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Component had two named blocks with the same name, `<:foo>`. Only one block with a given name may be passed', '<Foo><:foo></:foo><:foo></:foo></Foo>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:foo></:foo><:foo></:foo></Foo>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Component had two named blocks with the same name, `<:foo>`. Only one block with a given name may be passed',
+        '<Foo><:foo></:foo><:foo></:foo></Foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Throws an error if both inverse and else named blocks are passed, inverse first'() {
-    this.assert.throws(() => {
-      preprocess('<Foo><:inverse></:inverse><:else></:else></Foo>', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>', '<Foo><:inverse></:inverse><:else></:else></Foo>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:inverse></:inverse><:else></:else></Foo>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>',
+        '<Foo><:inverse></:inverse><:else></:else></Foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Throws an error if both inverse and else named blocks are passed, else first'() {
-    this.assert.throws(() => {
-      preprocess('<Foo><:else></:else><:inverse></:inverse></Foo>', {
-        meta: { moduleName: 'test-module' },
-      });
-    }, syntaxErrorFor('Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>', '<Foo><:else></:else><:inverse></:inverse></Foo>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:else></:else><:inverse></:inverse></Foo>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>',
+        '<Foo><:else></:else><:inverse></:inverse></Foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Throws an error if there is content outside of the blocks'() {
-    this.assert.throws(() => {
-      preprocess('<Foo>Hello!<:foo></:foo></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Unexpected content inside <Foo> component invocation: when using named blocks, the tag cannot contain other content', '<Foo>Hello!<:foo></:foo></Foo>', 'test-module', 1, 0));
-
-    this.assert.throws(() => {
-      preprocess('<Foo><:foo></:foo>Hello!</Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Unexpected content inside <Foo> component invocation: when using named blocks, the tag cannot contain other content', '<Foo><:foo></:foo>Hello!</Foo>', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo>Hello!<:foo></:foo></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Unexpected content inside <Foo> component invocation: when using named blocks, the tag cannot contain other content',
+        '<Foo>Hello!<:foo></:foo></Foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:foo></:foo>Hello!</Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Unexpected content inside <Foo> component invocation: when using named blocks, the tag cannot contain other content',
+        '<Foo><:foo></:foo>Hello!</Foo>',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'Cannot pass self closing named block'() {
-    this.assert.throws(() => {
-      preprocess('<Foo><:foo/></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('<:foo/> is not a valid named block: named blocks cannot be self-closing', '<:foo/>', 'test-module', 1, 5));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:foo/></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '<:foo/> is not a valid named block: named blocks cannot be self-closing',
+        '<:foo/>',
+        'test-module',
+        1,
+        5
+      )
+    );
   }
 
   @test
   'Named blocks must start with a lower case letter'() {
-    this.assert.throws(() => {
-      preprocess('<Foo><:Bar></:Bar></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('<:Bar> is not a valid named block, and named blocks must begin with a lowercase letter', '<:Bar></:Bar>', 'test-module', 1, 5));
-
-    this.assert.throws(() => {
-      preprocess('<Foo><:1bar><:/1bar></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('Invalid named block named detected, you may have created a named block without a name, or you may have began your name with a number. Named blocks must have names that are at least one character long, and begin with a lower case letter', '<:/1bar>', 'test-module', 1, 12));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:Bar></:Bar></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '<:Bar> is not a valid named block, and named blocks must begin with a lowercase letter',
+        '<:Bar></:Bar>',
+        'test-module',
+        1,
+        5
+      )
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:1bar><:/1bar></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'Invalid named block named detected, you may have created a named block without a name, or you may have began your name with a number. Named blocks must have names that are at least one character long, and begin with a lower case letter',
+        '<:/1bar>',
+        'test-module',
+        1,
+        12
+      )
+    );
   }
 
   @test
   'Named blocks cannot have arguments, attributes, or modifiers'() {
-    this.assert.throws(() => {
-      preprocess('<Foo><:bar attr="baz"></:bar></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('named block <:bar> cannot have attributes, arguments, or modifiers', '<:bar attr="baz"></:bar>', 'test-module', 1, 5));
-
-    this.assert.throws(() => {
-      preprocess('<Foo><:bar @arg="baz"></:bar></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('named block <:bar> cannot have attributes, arguments, or modifiers', '<:bar @arg="baz"></:bar>', 'test-module', 1, 5));
-
-    this.assert.throws(() => {
-      preprocess('<Foo><:bar {{modifier}}></:bar></Foo>', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('named block <:bar> cannot have attributes, arguments, or modifiers', '<:bar {{modifier}}></:bar>', 'test-module', 1, 5));
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:bar attr="baz"></:bar></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'named block <:bar> cannot have attributes, arguments, or modifiers',
+        '<:bar attr="baz"></:bar>',
+        'test-module',
+        1,
+        5
+      )
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:bar @arg="baz"></:bar></Foo>', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'named block <:bar> cannot have attributes, arguments, or modifiers',
+        '<:bar @arg="baz"></:bar>',
+        'test-module',
+        1,
+        5
+      )
+    );
+
+    this.assert.throws(
+      () => {
+        preprocess('<Foo><:bar {{modifier}}></:bar></Foo>', {
+          meta: { moduleName: 'test-module' },
+        });
+      },
+      syntaxErrorFor(
+        'named block <:bar> cannot have attributes, arguments, or modifiers',
+        '<:bar {{modifier}}></:bar>',
+        'test-module',
+        1,
+        5
+      )
+    );
   }
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/syntax/yield-keywords-test.ts b/packages/@glimmer-workspace/integration-tests/test/syntax/yield-keywords-test.ts
index d5c81c635b..ceeb6fd580 100644
--- a/packages/@glimmer-workspace/integration-tests/test/syntax/yield-keywords-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/syntax/yield-keywords-test.ts
@@ -1,62 +1,140 @@
-import { jitSuite, preprocess, RenderTest, syntaxErrorFor, test } from '../..';
+import {
+  jitSuite,
+  preprocess,
+  RenderTestContext,
+  syntaxErrorFor,
+  test,
+} from '@glimmer-workspace/integration-tests';
 
-class NamedBlocksSyntaxErrors extends RenderTest {
+class NamedBlocksSyntaxErrors extends RenderTestContext {
   static suiteName = 'yield keywords syntax errors';
 
   @test
   'yield throws if receiving any named args besides `to`'() {
-    this.assert.throws(() => {
-      preprocess('{{yield foo="bar"}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor("yield only takes a single named argument: 'to'", 'foo="bar"', 'test-module', 1, 8));
+    this.assert.throws(
+      () => {
+        preprocess('{{yield foo="bar"}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        "yield only takes a single named argument: 'to'",
+        'foo="bar"',
+        'test-module',
+        1,
+        8
+      )
+    );
   }
 
   @test
   'you can only yield to a literal string value'() {
-    this.assert.throws(() => {
-      preprocess('{{yield to=this.bar}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('you can only yield to a literal string value', 'this.bar', 'test-module', 1, 11));
+    this.assert.throws(
+      () => {
+        preprocess('{{yield to=this.bar}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        'you can only yield to a literal string value',
+        'this.bar',
+        'test-module',
+        1,
+        11
+      )
+    );
   }
 
   @test
   'has-block throws if receiving any named args'() {
-    this.assert.throws(() => {
-      preprocess('{{has-block foo="bar"}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('(has-block) does not take any named arguments', '{{has-block foo="bar"}}', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('{{has-block foo="bar"}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '(has-block) does not take any named arguments',
+        '{{has-block foo="bar"}}',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'has-block throws if receiving multiple positional'() {
-    this.assert.throws(() => {
-      preprocess('{{has-block "foo" "bar"}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('(has-block) only takes a single positional argument', '{{has-block "foo" "bar"}}', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('{{has-block "foo" "bar"}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '(has-block) only takes a single positional argument',
+        '{{has-block "foo" "bar"}}',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'has-block throws if receiving a value besides a string'() {
-    this.assert.throws(() => {
-      preprocess('{{has-block this.bar}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('(has-block) can only receive a string literal as its first argument', '{{has-block this.bar}}', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('{{has-block this.bar}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '(has-block) can only receive a string literal as its first argument',
+        '{{has-block this.bar}}',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'has-block-params throws if receiving any named args'() {
-    this.assert.throws(() => {
-      preprocess('{{has-block-params foo="bar"}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('(has-block-params) does not take any named arguments', '{{has-block-params foo="bar"}}', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('{{has-block-params foo="bar"}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '(has-block-params) does not take any named arguments',
+        '{{has-block-params foo="bar"}}',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'has-block-params throws if receiving multiple positional'() {
-    this.assert.throws(() => {
-      preprocess('{{has-block-params "foo" "bar"}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('(has-block-params) only takes a single positional argument', '{{has-block-params "foo" "bar"}}', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('{{has-block-params "foo" "bar"}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '(has-block-params) only takes a single positional argument',
+        '{{has-block-params "foo" "bar"}}',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 
   @test
   'has-block-params throws if receiving a value besides a string'() {
-    this.assert.throws(() => {
-      preprocess('{{has-block-params this.bar}}', { meta: { moduleName: 'test-module' } });
-    }, syntaxErrorFor('(has-block-params) can only receive a string literal as its first argument', '{{has-block-params this.bar}}', 'test-module', 1, 0));
+    this.assert.throws(
+      () => {
+        preprocess('{{has-block-params this.bar}}', { meta: { moduleName: 'test-module' } });
+      },
+      syntaxErrorFor(
+        '(has-block-params) can only receive a string literal as its first argument',
+        '{{has-block-params this.bar}}',
+        'test-module',
+        1,
+        0
+      )
+    );
   }
 }
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/updating-content-matrix-test.ts b/packages/@glimmer-workspace/integration-tests/test/updating-content-matrix-test.ts
index 3d4ea6a3fe..0e67ce2538 100644
--- a/packages/@glimmer-workspace/integration-tests/test/updating-content-matrix-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/updating-content-matrix-test.ts
@@ -1,9 +1,13 @@
 import type { SimpleElement, SimpleNode } from '@glimmer/interfaces';
-import type { SafeString } from '@glimmer/runtime';
+import type { RenderTestConstructor } from '@glimmer-workspace/integration-tests';
 import { NS_SVG } from '@glimmer/util';
+import { jitSuite, RenderTestContext } from '@glimmer-workspace/integration-tests';
 
-import { jitSuite, RenderTest, type RenderTestConstructor } from '..';
-import type RenderDelegate from '../lib/render-delegate';
+import type { RenderDelegate } from '../lib/render-delegate';
+
+export interface SafeString {
+  toHTML(): string;
+}
 
 function makeSafeString(value: string): SafeString {
   return new SafeStringImpl(value);
@@ -19,23 +23,23 @@ class SafeStringImpl implements SafeString {
   }
 }
 
-class ContentTest extends RenderTest {
+class ContentTest extends RenderTestContext {
   static suiteName = 'Updating - Content';
 
   makeElement(tag: string, content: string): SimpleElement {
-    const el = this.delegate.createElement(tag);
-    el.appendChild(this.delegate.createTextNode(content));
+    const el = this.dom.createElement(tag);
+    el.appendChild(this.dom.createTextNode(content));
     return el;
   }
 
   makeSVGElement(tag: string, content: string): SimpleElement {
-    const el = this.delegate.createElementNS(NS_SVG, tag);
-    el.appendChild(this.delegate.createTextNode(content));
+    const el = this.dom.createElementNS(NS_SVG, tag);
+    el.appendChild(this.dom.createTextNode(content));
     return el;
   }
 
   makeFragment(nodes: SimpleNode[]) {
-    const frag = this.delegate.createDocumentFragment();
+    const frag = this.dom.createDocumentFragment();
     nodes.forEach((node) => frag.appendChild(node));
     return frag;
   }
@@ -73,7 +77,7 @@ interface ContentTestCase {
 }
 
 function generateContentTestCase(
-  suite: RenderTestConstructor<RenderDelegate, RenderTest>,
+  suite: RenderTestConstructor<RenderDelegate, RenderTestContext>,
   tc: ContentTestCase
 ): void {
   [
@@ -151,7 +155,7 @@ function generateContentTestCase(
         }
 
         if (index === 0) {
-          this.render(template, { value: input });
+          this.render.template(template, { value: input });
           this.assertHTML(
             wrapper.before + expected + wrapper.after,
             `expected initial render (${description})`
diff --git a/packages/@glimmer-workspace/integration-tests/test/updating-modifiers-test.ts b/packages/@glimmer-workspace/integration-tests/test/updating-modifiers-test.ts
index 294805ed8f..f5fc27c5a9 100644
--- a/packages/@glimmer-workspace/integration-tests/test/updating-modifiers-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/updating-modifiers-test.ts
@@ -1,6 +1,6 @@
 import type { SimpleElement } from '@glimmer/interfaces';
+import { jitSuite, RenderTestContext, test } from '@glimmer-workspace/integration-tests';
 
-import { jitSuite, RenderTest, test } from '..';
 import { assert } from './support';
 
 function makeSyncDataAttrModifier(hooks: string[]) {
@@ -22,16 +22,16 @@ function makeSyncDataAttrModifier(hooks: string[]) {
   };
 }
 
-class UpdatingModifiers extends RenderTest {
+class UpdatingModifiers extends RenderTestContext {
   static suiteName = 'Updating Element Modifier';
 
   @test
   'Updating a element modifier'() {
     let hooks: string[] = [];
 
-    this.registerModifier('foo', makeSyncDataAttrModifier(hooks));
+    this.register.modifier('foo', makeSyncDataAttrModifier(hooks));
 
-    this.render('<div><div {{foo this.bar baz=this.fizz}}></div></div>', {
+    this.render.template('<div><div {{foo this.bar baz=this.fizz}}></div></div>', {
       bar: 'Super Metroid',
     });
 
@@ -58,9 +58,9 @@ class UpdatingModifiers extends RenderTest {
   "Const input doesn't trigger update in a element modifier"() {
     let hooks: string[] = [];
 
-    this.registerModifier('foo', makeSyncDataAttrModifier(hooks));
+    this.register.modifier('foo', makeSyncDataAttrModifier(hooks));
 
-    this.render('<div><div {{foo "bar"}}></div></div>', {});
+    this.render.template('<div><div {{foo "bar"}}></div></div>', {});
     this.assertHTML('<div><div data-modifier="installed - bar"></div></div>', 'initial render');
     assert.deepEqual(hooks, ['didInsertElement'], 'hooks fired correctly on initial render');
 
@@ -74,9 +74,9 @@ class UpdatingModifiers extends RenderTest {
   'Destructor is triggered on element modifiers'() {
     let hooks: string[] = [];
 
-    this.registerModifier('foo', makeSyncDataAttrModifier(hooks));
+    this.register.modifier('foo', makeSyncDataAttrModifier(hooks));
 
-    this.render('{{#if this.bar}}<div {{foo this.bar}}></div>{{else}}<div></div>{{/if}}', {
+    this.render.template('{{#if this.bar}}<div {{foo this.bar}}></div>{{else}}<div></div>{{/if}}', {
       bar: true,
     });
 
diff --git a/packages/@glimmer-workspace/integration-tests/test/updating-svg-test.ts b/packages/@glimmer-workspace/integration-tests/test/updating-svg-test.ts
index c13195a51b..cdcad941cd 100644
--- a/packages/@glimmer-workspace/integration-tests/test/updating-svg-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/updating-svg-test.ts
@@ -1,15 +1,20 @@
 import type { SimpleElement } from '@glimmer/interfaces';
 import { NS_HTML, NS_SVG, NS_XLINK } from '@glimmer/util';
+import {
+  assertNodeTagName,
+  jitSuite,
+  RenderTestContext,
+  test,
+} from '@glimmer-workspace/integration-tests';
 
-import { assertNodeTagName, jitSuite, RenderTest, test } from '..';
 import { assert } from './support';
 
-class UpdatingSvgTest extends RenderTest {
+class UpdatingSvgTest extends RenderTestContext {
   static suiteName = 'Updating SVG';
 
   @test
   'HTML namespace from root element is continued to child templates'() {
-    this.render('<svg>{{#if this.hasCircle}}<circle />{{/if}}</svg>', { hasCircle: true });
+    this.render.template('<svg>{{#if this.hasCircle}}<circle />{{/if}}</svg>', { hasCircle: true });
 
     const assertNamespaces = () => {
       if (assertNodeTagName(this.element.firstChild, 'svg')) {
@@ -36,7 +41,7 @@ class UpdatingSvgTest extends RenderTest {
   @test
   'context.root <foreignObject> tag is SVG namespaced'() {
     const parent = this.element;
-    const svg = this.delegate.createElementNS(NS_SVG, 'svg');
+    const svg = this.dom.createElementNS(NS_SVG, 'svg');
     this.element.appendChild(svg);
     this.element = svg;
 
@@ -49,9 +54,12 @@ class UpdatingSvgTest extends RenderTest {
       }
     };
 
-    this.render('{{#if this.hasForeignObject}}<foreignObject><div></div></foreignObject>{{/if}}', {
-      hasForeignObject: true,
-    });
+    this.render.template(
+      '{{#if this.hasForeignObject}}<foreignObject><div></div></foreignObject>{{/if}}',
+      {
+        hasForeignObject: true,
+      }
+    );
 
     this.assertHTML('<svg><foreignObject><div></div></foreignObject></svg>', parent);
     assertNamespaces();
@@ -69,9 +77,12 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'elements nested inside <foreignObject> have an XHTML namespace'() {
-    this.render('<svg><foreignObject>{{#if this.hasDiv}}<div></div>{{/if}}</foreignObject></svg>', {
-      hasDiv: true,
-    });
+    this.render.template(
+      '<svg><foreignObject>{{#if this.hasDiv}}<div></div>{{/if}}</foreignObject></svg>',
+      {
+        hasDiv: true,
+      }
+    );
 
     const assertNamespaces = () => {
       if (assertNodeTagName(this.element.firstChild, 'svg')) {
@@ -101,7 +112,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'Namespaced attribute with a quoted expression'() {
-    this.render('<svg xlink:title="{{this.title}}">content</svg>', { title: 'svg-title' });
+    this.render.template('<svg xlink:title="{{this.title}}">content</svg>', { title: 'svg-title' });
 
     const assertNamespaces = () => {
       if (assertNodeTagName(this.element.firstChild, 'svg')) {
@@ -131,7 +142,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   '<svg> tag and expression as sibling'() {
-    this.render('<svg></svg>{{this.name}}', { name: 'svg-title' });
+    this.render.template('<svg></svg>{{this.name}}', { name: 'svg-title' });
 
     const assertNamespace = () => {
       if (assertNodeTagName(this.element.firstChild, 'svg')) {
@@ -156,7 +167,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   '<svg> tag and unsafe expression as sibling'() {
-    this.render('<svg></svg>{{{this.name}}}', { name: '<i>Biff</i>' });
+    this.render.template('<svg></svg>{{{this.name}}}', { name: '<i>Biff</i>' });
 
     const assertNamespaces = (isUnsafe: boolean) => {
       if (assertNodeTagName(this.element.firstChild, 'svg')) {
@@ -184,7 +195,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'unsafe expression nested inside a namespace'() {
-    this.render('<svg>{{{this.content}}}</svg><div></div>', {
+    this.render.template('<svg>{{{this.content}}}</svg><div></div>', {
       content: '<path></path>',
     });
 
@@ -274,7 +285,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'expression nested inside a namespace'() {
-    this.render('<div><svg>{{this.content}}</svg></div>', {
+    this.render.template('<div><svg>{{this.content}}</svg></div>', {
       content: 'Milly',
     });
 
@@ -304,7 +315,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'expression nested inside a namespaced context.root element'() {
-    this.render('<svg>{{this.content}}</svg>', { content: 'Maurice' });
+    this.render.template('<svg>{{this.content}}</svg>', { content: 'Maurice' });
 
     const assertSvg = (withSVG?: (svg: SVGSVGElement) => void) => {
       if (assertNodeTagName(this.element.firstChild, 'svg')) {
@@ -331,7 +342,7 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'HTML namespace is created in child templates'() {
-    this.render('{{#if this.isTrue}}<svg></svg>{{else}}<div><svg></svg></div>{{/if}}', {
+    this.render.template('{{#if this.isTrue}}<svg></svg>{{else}}<div><svg></svg></div>{{/if}}', {
       isTrue: true,
     });
 
@@ -367,7 +378,9 @@ class UpdatingSvgTest extends RenderTest {
 
   @test
   'HTML namespace is continued to child templates'() {
-    this.render('<div><svg>{{#if this.isTrue}}<circle />{{/if}}</svg></div>', { isTrue: true });
+    this.render.template('<div><svg>{{#if this.isTrue}}<circle />{{/if}}</svg></div>', {
+      isTrue: true,
+    });
 
     const assertNamespaces = (isTrue: boolean) => {
       if (assertNodeTagName(this.element.firstChild, 'div')) {
diff --git a/packages/@glimmer-workspace/integration-tests/test/updating-test.ts b/packages/@glimmer-workspace/integration-tests/test/updating-test.ts
index a587d6d6c6..68b55c1524 100644
--- a/packages/@glimmer-workspace/integration-tests/test/updating-test.ts
+++ b/packages/@glimmer-workspace/integration-tests/test/updating-test.ts
@@ -1,23 +1,23 @@
-import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
 import type { Nullable, SimpleElement, SimpleNode } from '@glimmer/interfaces';
-import { createComputeRef, createConstRef, createPrimitiveRef } from '@glimmer/reference';
 import type { SafeString } from '@glimmer/runtime';
-import { expect } from '@glimmer/util';
+import type {ClientSideRenderDelegate} from '@glimmer-workspace/integration-tests';
+import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
+import { createPrimitiveCell, Formula, ReadonlyCell } from '@glimmer/reference';
+import { devmode, expect } from '@glimmer/util';
 import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
-
 import {
   assertNodeTagName,
   getElementByClassName,
   getElementsByTagName,
   GlimmerishComponent,
-  type JitRenderDelegate,
   jitSuite,
-  RenderTest,
+  RenderTestContext,
   stripTight,
   test,
   tracked,
-  trimLines,
-} from '..';
+  trimLines
+} from '@glimmer-workspace/integration-tests';
+
 import { assert } from './support';
 
 function makeSafeString(value: string): SafeString {
@@ -34,14 +34,14 @@ class SafeStringImpl implements SafeString {
   }
 }
 
-class UpdatingTest extends RenderTest {
+class UpdatingTest extends RenderTestContext {
   static suiteName = 'Updating';
 
-  declare delegate: JitRenderDelegate;
+  declare delegate: ClientSideRenderDelegate;
 
   @test
   'updating a single curly'() {
-    this.render('<div><p>{{this.value}}</p></div>', { value: 'hello world' });
+    this.render.template('<div><p>{{this.value}}</p></div>', { value: 'hello world' });
     this.assertHTML('<div><p>hello world</p></div>', 'Initial render');
     this.assertStableRerender();
 
@@ -52,7 +52,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'updating a single curly with siblings'() {
-    this.render('<div>hello {{this.value}}world</div>', { value: 'brave new ' });
+    this.render.template('<div>hello {{this.value}}world</div>', { value: 'brave new ' });
     this.assertHTML('<div>hello brave new world</div>');
     this.assertStableRerender();
 
@@ -67,7 +67,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'null and undefined produces empty text nodes'() {
-    this.render('<div><p>{{this.v1}}</p><p>{{this.v2}}</p></div>', {
+    this.render.template('<div><p>{{this.v1}}</p><p>{{this.v2}}</p></div>', {
       v1: null,
       v2: undefined,
     });
@@ -98,12 +98,12 @@ class UpdatingTest extends RenderTest {
       false: 'false',
       this: 'this',
       'foo.bar': 'foo.bar',
-      nested: null as any | null,
+      nested: null as any,
     };
 
     state.nested = state;
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           [{{this.['']}}]
@@ -224,7 +224,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'updating a single trusting curly'() {
-    this.render('<div>{{{this.value}}}</div>', { value: '<p>hello world</p>' });
+    this.render.template('<div>{{{this.value}}}</div>', { value: '<p>hello world</p>' });
 
     this.assertHTML(`<div><p>hello world</p></div>`, 'Initial render');
     this.assertStableRerender();
@@ -244,7 +244,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'updating a single trusting curly with siblings'() {
-    this.render('<div>hello {{{this.value}}}world</div>', {
+    this.render.template('<div>hello {{{this.value}}}world</div>', {
       value: '<b>brave new </b>',
     });
 
@@ -266,7 +266,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'updating a single trusting curly with previous sibling'() {
-    this.render('<div>hello {{{this.value}}}</div>', {
+    this.render.template('<div>hello {{{this.value}}}</div>', {
       value: '<b>brave new </b>',
     });
 
@@ -288,7 +288,7 @@ class UpdatingTest extends RenderTest {
     let a = '<p>A</p>';
     let b = '<p>B</p>';
 
-    this.render('<div>{{{this.value}}}</div>', { value: a });
+    this.render.template('<div>{{{this.value}}}</div>', { value: a });
 
     this.assertHTML('<div><p>A</p></div>', 'Initial render');
 
@@ -323,7 +323,7 @@ class UpdatingTest extends RenderTest {
     };
     let unsafeString = '<b>Big old world!</b>';
 
-    this.render('<div>{{this.value}}</div>', {
+    this.render.template('<div>{{this.value}}</div>', {
       value: safeString,
     });
 
@@ -347,7 +347,7 @@ class UpdatingTest extends RenderTest {
     let safeString = makeSafeString('<p>hello world</p>');
     let unsafeString = '<b>Big old world!</b>';
 
-    this.render('<div>{{{this.value}}}</div>', {
+    this.render.template('<div>{{{this.value}}}</div>', {
       value: safeString,
     });
 
@@ -369,7 +369,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'triple curlies with empty string initial value'() {
-    this.render('<div>{{{this.value}}}</div>', {
+    this.render.template('<div>{{{this.value}}}</div>', {
       value: '',
     });
 
@@ -391,11 +391,11 @@ class UpdatingTest extends RenderTest {
   'double curlies with const SafeString'() {
     let rawString = '<b>bold</b> and spicy';
 
-    this.registerInternalHelper('const-foobar', () => {
-      return createConstRef(makeSafeString(rawString), 'safe-string');
+    this.register.internalHelper('const-foobar', () => {
+      return ReadonlyCell(makeSafeString(rawString), 'safe-string');
     });
 
-    this.render('<div>{{const-foobar}}</div>', {});
+    this.render.template('<div>{{const-foobar}}</div>', {});
     this.assertHTML('<div><b>bold</b> and spicy</div>', 'initial render');
     this.assertStableRerender();
   }
@@ -404,11 +404,11 @@ class UpdatingTest extends RenderTest {
   'double curlies with const Node'() {
     let rawString = '<b>bold</b> and spicy';
 
-    this.registerInternalHelper('const-foobar', () => {
-      return createConstRef(this.delegate.createTextNode(rawString), 'text-node');
+    this.register.internalHelper('const-foobar', () => {
+      return ReadonlyCell(this.dom.createTextNode(rawString), 'text-node');
     });
 
-    this.render('<div>{{const-foobar}}</div>');
+    this.render.template('<div>{{const-foobar}}</div>');
     this.assertHTML('<div>&lt;b&gt;bold&lt;/b&gt; and spicy</div>', 'initial render');
     this.assertStableRerender();
   }
@@ -417,11 +417,11 @@ class UpdatingTest extends RenderTest {
   'triple curlies with const SafeString'() {
     let rawString = '<b>bold</b> and spicy';
 
-    this.registerInternalHelper('const-foobar', () => {
-      return createConstRef(makeSafeString(rawString), 'safe-string');
+    this.register.internalHelper('const-foobar', () => {
+      return ReadonlyCell(makeSafeString(rawString), 'safe-string');
     });
 
-    this.render('<div>{{{const-foobar}}}</div>');
+    this.render.template('<div>{{{const-foobar}}}</div>');
     this.assertHTML('<div><b>bold</b> and spicy</div>', 'initial render');
     this.assertStableRerender();
   }
@@ -430,11 +430,11 @@ class UpdatingTest extends RenderTest {
   'triple curlies with const Node'() {
     let rawString = '<b>bold</b> and spicy';
 
-    this.registerInternalHelper('const-foobar', () => {
-      return createConstRef(this.delegate.createTextNode(rawString), 'text-node');
+    this.register.internalHelper('const-foobar', () => {
+      return ReadonlyCell(this.dom.createTextNode(rawString), 'text-node');
     });
 
-    this.render('<div>{{{const-foobar}}}</div>');
+    this.render.template('<div>{{{const-foobar}}}</div>');
     this.assertHTML('<div>&lt;b&gt;bold&lt;/b&gt; and spicy</div>', 'initial render');
     this.assertStableRerender();
   }
@@ -449,15 +449,15 @@ class UpdatingTest extends RenderTest {
       destroyable.count++;
     });
 
-    this.registerInternalHelper('destroy-me', (_args) => {
-      let ref = createPrimitiveRef('destroy me!');
+    this.register.internalHelper('destroy-me', (_args) => {
+      let ref = createPrimitiveCell('destroy me!');
 
       associateDestroyableChild(ref, destroyable);
 
       return ref;
     });
 
-    this.render('<div>{{destroy-me}}</div>', {});
+    this.render.template('<div>{{destroy-me}}</div>', {});
 
     this.assertHTML('<div>destroy me!</div>', 'initial render');
     assert.strictEqual(destroyable.count, 0, 'not destroyed');
@@ -486,13 +486,20 @@ class UpdatingTest extends RenderTest {
     let { template, truthyValue, falsyValue, element } = arg1;
     let didCreate = 0;
     let didDestroy = 0;
-    let tag = createTag();
+    let tag = createTag(
+      devmode(() => ({
+        kind: 'formula',
+        fallible: true,
+        readonly: true,
+        label: ['(stateful helper)'],
+      }))
+    );
     let currentValue: T | U = truthyValue;
 
-    this.registerInternalHelper('stateful-foo', (_args) => {
+    this.register.internalHelper('stateful-foo', (_args) => {
       didCreate++;
 
-      let ref = createComputeRef(() => {
+      let ref = Formula(() => {
         consumeTag(tag);
         return currentValue;
       });
@@ -508,7 +515,7 @@ class UpdatingTest extends RenderTest {
     assert.strictEqual(didCreate, 0, 'didCreate: before render');
     assert.strictEqual(didDestroy, 0, 'didDestroy: before render');
 
-    this.render(template, {});
+    this.render.template(template, {});
 
     this.assertHTML('Yes', element, 'initial render');
     assert.strictEqual(didCreate, 1, 'didCreate: after initial render');
@@ -583,7 +590,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'helpers passed as arguments to {{component}} are not torn down when switching between blocks'() {
-    this.registerComponent('Glimmer', 'XYasss', 'Yes');
+    this.register.component('Glimmer', 'XYasss', 'Yes');
 
     let options = {
       template: '{{component (stateful-foo)}}',
@@ -596,7 +603,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'helpers passed as arguments to {{#in-element}} are not torn down when switching between blocks'() {
-    let externalElement = this.delegate.createElement('div');
+    let externalElement = this.dom.createElement('div');
 
     let options = {
       template: '{{#in-element (stateful-foo)}}Yes{{/in-element}}',
@@ -610,7 +617,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'updating a curly with this'() {
-    this.render('<div><p>{{this.value}}</p></div>', { value: 'hello world' });
+    this.render.template('<div><p>{{this.value}}</p></div>', { value: 'hello world' });
 
     this.assertHTML('<div><p>hello world</p></div>');
     this.assertStableRerender();
@@ -622,7 +629,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'a simple implementation of a dirtying rerender'() {
-    this.render(
+    this.render.template(
       '<div>{{#if this.condition}}<p>{{this.value}}</p>{{else}}<p>Nothing</p>{{/if}}</div>',
       {
         condition: true,
@@ -644,7 +651,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The if helper should consider an empty array truthy'() {
-    this.render(
+    this.render.template(
       '<div>{{#if this.condition}}<p>{{this.value}}</p>{{else}}<p>Nothing</p>{{/if}}</div>',
       { condition: [], value: 'hello world' }
     );
@@ -660,7 +667,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'a simple implementation of a dirtying rerender without else'() {
-    this.render('<div>{{#if this.condition}}<p>{{this.value}}</p>{{/if}}</div>', {
+    this.render.template('<div>{{#if this.condition}}<p>{{this.value}}</p>{{/if}}</div>', {
       condition: true,
       value: 'hello world',
     });
@@ -679,7 +686,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The unless helper without else'() {
-    this.render('<div>{{#unless this.condition}}<p>{{this.value}}</p>{{/unless}}</div>', {
+    this.render.template('<div>{{#unless this.condition}}<p>{{this.value}}</p>{{/unless}}</div>', {
       condition: true,
       value: 'hello world',
     });
@@ -698,7 +705,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The unless helper with else'() {
-    this.render(
+    this.render.template(
       '<div>{{#unless this.condition}}<p>{{this.value}}</p>{{else}}<p>Nothing</p>{{/unless}}</div>',
       { condition: true, value: 'hello world' }
     );
@@ -717,7 +724,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The unless helper should consider an empty array truthy'() {
-    this.render(
+    this.render.template(
       '<div>{{#unless this.condition}}<p>{{this.value}}</p>{{else}}<p>Nothing</p>{{/unless}}</div>',
       { condition: [], value: 'hello world' }
     );
@@ -733,7 +740,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'if keyword in append position'() {
-    this.render('{{if this.condition "truthy"}}', {
+    this.render.template('{{if this.condition "truthy"}}', {
       condition: true,
     });
 
@@ -748,9 +755,9 @@ class UpdatingTest extends RenderTest {
 
   @test
   'if keyword in SubExpression without falsey value returns undefined [GH emberjs/ember.js#19409]'() {
-    this.registerHelper('to-string', (args) => `${args[0]}`);
+    this.register.helper('to-string', (args) => `${args[0]}`);
 
-    this.render('{{to-string (if this.condition "truthy")}}', {
+    this.render.template('{{to-string (if this.condition "truthy")}}', {
       condition: false,
     });
 
@@ -759,7 +766,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'if keyword in append position with falsy'() {
-    this.render('{{if this.condition "truthy" "falsy"}}', {
+    this.render.template('{{if this.condition "truthy" "falsy"}}', {
       condition: true,
     });
 
@@ -774,7 +781,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'unless keyword in append position'() {
-    this.render('{{unless this.condition "falsy"}}', {
+    this.render.template('{{unless this.condition "falsy"}}', {
       condition: false,
     });
 
@@ -789,7 +796,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'unless keyword in append position with truthy'() {
-    this.render('{{unless this.condition "falsy" "truthy"}}', {
+    this.render.template('{{unless this.condition "falsy" "truthy"}}', {
       condition: false,
     });
 
@@ -804,8 +811,8 @@ class UpdatingTest extends RenderTest {
 
   @test
   'if keyword in call position'() {
-    this.registerComponent('TemplateOnly', 'Foo', '{{@value}}');
-    this.render('<Foo @value={{if this.condition "truthy"}}/>', {
+    this.register.component('TemplateOnly', 'Foo', '{{@value}}');
+    this.render.template('<Foo @value={{if this.condition "truthy"}}/>', {
       condition: true,
     });
 
@@ -820,8 +827,8 @@ class UpdatingTest extends RenderTest {
 
   @test
   'if keyword in call position with falsy'() {
-    this.registerComponent('TemplateOnly', 'Foo', '{{@value}}');
-    this.render('<Foo @value={{if this.condition "truthy" "falsy"}}/>', {
+    this.register.component('TemplateOnly', 'Foo', '{{@value}}');
+    this.render.template('<Foo @value={{if this.condition "truthy" "falsy"}}/>', {
       condition: true,
     });
 
@@ -836,8 +843,8 @@ class UpdatingTest extends RenderTest {
 
   @test
   'unless keyword in call position'() {
-    this.registerComponent('TemplateOnly', 'Foo', '{{@value}}');
-    this.render('<Foo @value={{unless this.condition "falsy"}}/>', {
+    this.register.component('TemplateOnly', 'Foo', '{{@value}}');
+    this.render.template('<Foo @value={{unless this.condition "falsy"}}/>', {
       condition: false,
     });
 
@@ -852,8 +859,8 @@ class UpdatingTest extends RenderTest {
 
   @test
   'unless keyword in call position with truthy'() {
-    this.registerComponent('TemplateOnly', 'Foo', '{{@value}}');
-    this.render('<Foo @value={{unless this.condition "falsy" "truthy"}}/>', {
+    this.register.component('TemplateOnly', 'Foo', '{{@value}}');
+    this.render.template('<Foo @value={{unless this.condition "falsy" "truthy"}}/>', {
       condition: false,
     });
 
@@ -868,7 +875,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'a conditional that is false on the first run'() {
-    this.render('<div>{{#if this.condition}}<p>{{this.value}}</p>{{/if}}</div>', {
+    this.render.template('<div>{{#if this.condition}}<p>{{this.value}}</p>{{/if}}</div>', {
       condition: false,
       value: 'hello world',
     });
@@ -899,7 +906,7 @@ class UpdatingTest extends RenderTest {
 
     const person = { name: new Name('Godfrey', 'Chan') };
 
-    this.render('<div>{{#with this.person.name.first as |f|}}{{f}}{{/with}}</div>', {
+    this.render.template('<div>{{#with this.person.name.first as |f|}}{{f}}{{/with}}</div>', {
       person,
     });
 
@@ -917,19 +924,19 @@ class UpdatingTest extends RenderTest {
 
   @test
   'missing helper'(assert: Assert) {
-    this.registerHelper('hello', () => 'hello');
+    this.register.helper('hello', () => 'hello');
 
     assert.throws(() => {
-      this.delegate.compileTemplate('{{helo world}}');
+      this.delegate.compileTemplate('{{helo world}}', this.plugins);
     }, /Error: Attempted to resolve `helo`, which was expected to be a component or helper, but nothing was found./u);
   }
 
   @test
   'block arguments should have higher precedence than helpers'() {
     // Note: This test intentionally tests property fallback
-    this.registerHelper('foo', () => 'foo-helper');
-    this.registerHelper('bar', () => 'bar-helper');
-    this.registerHelper('echo', (args) => args[0]);
+    this.register.helper('foo', () => 'foo-helper');
+    this.register.helper('bar', () => 'bar-helper');
+    this.register.helper('echo', (args) => args[0]);
 
     let template = trimLines`
       <div>
@@ -975,7 +982,7 @@ class UpdatingTest extends RenderTest {
       </div>
     `;
 
-    this.render(template, { foo: 'foo-value', bar: 'bar-value', value: 'value-value' });
+    this.render.template(template, { foo: 'foo-value', bar: 'bar-value', value: 'value-value' });
 
     this.assertHTML(
       trimLines`
@@ -1107,10 +1114,13 @@ class UpdatingTest extends RenderTest {
   @test
   'block arguments (ensure balanced push/pop)'() {
     let person = { name: { first: 'Godfrey', last: 'Chan' } };
-    this.render('<div>{{#with this.person.name.first as |f|}}{{f}}{{/with}}{{this.f}}</div>', {
-      person,
-      f: 'Outer',
-    });
+    this.render.template(
+      '<div>{{#with this.person.name.first as |f|}}{{f}}{{/with}}{{this.f}}</div>',
+      {
+        person,
+        f: 'Outer',
+      }
+    );
 
     this.assertHTML('<div>GodfreyOuter</div>', 'Initial render');
 
@@ -1122,9 +1132,9 @@ class UpdatingTest extends RenderTest {
 
   @test
   'block arguments cannot be accessed through {{this}}'() {
-    this.registerHelper('noop', (params) => params[0]);
+    this.register.helper('noop', (params) => params[0]);
 
-    this.render(
+    this.render.template(
       stripTight`
         <div>
           [{{#with this.person as |name|}}{{this.name}}{{/with}}]
@@ -1147,7 +1157,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The with helper should consider an empty array truthy'() {
-    this.render('<div>{{#with this.condition as |c|}}{{c.length}}{{/with}}</div>', {
+    this.render.template('<div>{{#with this.condition as |c|}}{{c.length}}{{/with}}</div>', {
       condition: [],
     });
 
@@ -1162,7 +1172,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'block helpers whose template has a morph at the edge'() {
-    this.render('{{#if true}}{{this.value}}{{/if}}', { value: 'hello world' });
+    this.render.template('{{#if true}}{{this.value}}{{/if}}', { value: 'hello world' });
     this.assertHTML('hello world');
 
     let firstNode = this.element.firstChild;
@@ -1181,7 +1191,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   "clean content doesn't get blown away"() {
-    this.render('<div>{{this.value}}</div>', { value: 'hello' });
+    this.render.template('<div>{{this.value}}</div>', { value: 'hello' });
 
     let firstNode: Nullable<SimpleNode> = this.element.firstChild;
     let textNode: Node | null;
@@ -1205,7 +1215,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'helper calls follow the normal dirtying rules'() {
-    this.registerHelper('capitalize', function (params) {
+    this.register.helper('capitalize', (params) => {
       let value = params[0];
       if (value !== null && value !== undefined && typeof value === 'string') {
         return value.toUpperCase();
@@ -1213,7 +1223,7 @@ class UpdatingTest extends RenderTest {
       return;
     });
 
-    this.render('<div>{{capitalize this.value}}</div>', { value: 'hello' });
+    this.render.template('<div>{{capitalize this.value}}</div>', { value: 'hello' });
     this.assertHTML('<div>HELLO</div>');
 
     this.rerender({
@@ -1233,7 +1243,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'class attribute follow the normal dirtying rules'() {
-    this.render("<div class='{{this.value}}'>hello</div>", { value: 'world' });
+    this.render.template("<div class='{{this.value}}'>hello</div>", { value: 'world' });
 
     this.assertHTML("<div class='world'>hello</div>", 'Initial render');
 
@@ -1253,7 +1263,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'class attribute w/ concat follow the normal dirtying rules'() {
-    this.render("<div class='hello {{this.value}}'>hello</div>", { value: 'world' });
+    this.render.template("<div class='hello {{this.value}}'>hello</div>", { value: 'world' });
 
     this.assertHTML("<div class='hello world'>hello</div>");
     this.assertStableRerender();
@@ -1270,7 +1280,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'class attribute is removed if the binding becomes null or undefined'() {
-    this.render('<div class={{this.value}}>hello</div>', { value: 'foo' });
+    this.render.template('<div class={{this.value}}>hello</div>', { value: 'foo' });
 
     this.assertHTML("<div class='foo'>hello</div>");
     this.assertStableRerender();
@@ -1290,7 +1300,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'attribute nodes follow the normal dirtying rules'() {
-    this.render("<div data-value='{{this.value}}'>hello</div>", { value: 'world' });
+    this.render.template("<div data-value='{{this.value}}'>hello</div>", { value: 'world' });
     this.assertHTML("<div data-value='world'>hello</div>", 'Initial render');
 
     this.rerender({ value: 'universe' });
@@ -1306,7 +1316,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'attribute nodes w/ concat follow the normal dirtying rules'() {
-    this.render("<div data-value='hello {{this.value}}'>hello</div>", { value: 'world' });
+    this.render.template("<div data-value='hello {{this.value}}'>hello</div>", { value: 'world' });
     this.assertHTML("<div data-value='hello world'>hello</div>");
     this.assertStableRerender();
 
@@ -1322,7 +1332,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'attributes values are normalized correctly'() {
-    this.render('<div data-value={{this.value}}>hello</div>', {
+    this.render.template('<div data-value={{this.value}}>hello</div>', {
       value: {
         toString() {
           return 'world';
@@ -1356,7 +1366,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'namespaced attribute nodes follow the normal dirtying rules'() {
-    this.render("<div xml:lang='{{this.lang}}'>hello</div>", { lang: 'en-us' });
+    this.render.template("<div xml:lang='{{this.lang}}'>hello</div>", { lang: 'en-us' });
 
     this.assertHTML("<div xml:lang='en-us'>hello</div>", 'Initial render');
 
@@ -1368,7 +1378,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'namespaced attribute nodes w/ concat follow the normal dirtying rules'() {
-    this.render("<div xml:lang='en-{{this.locale}}'>hello</div>", { locale: 'us' });
+    this.render.template("<div xml:lang='en-{{this.locale}}'>hello</div>", { locale: 'us' });
 
     this.assertHTML("<div xml:lang='en-us'>hello</div>", 'Initial render');
     this.assertStableRerender();
@@ -1385,7 +1395,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'non-standard namespaced attribute nodes follow the normal dirtying rules'() {
-    this.render("<div epub:type='{{this.type}}'>hello</div>", { type: 'dedication' });
+    this.render.template("<div epub:type='{{this.type}}'>hello</div>", { type: 'dedication' });
     this.assertHTML("<div epub:type='dedication'>hello</div>", 'Initial render');
 
     this.rerender({ type: 'backmatter' });
@@ -1395,7 +1405,9 @@ class UpdatingTest extends RenderTest {
 
   @test
   'non-standard namespaced attribute nodes w/ concat follow the normal dirtying rules'() {
-    this.render("<div epub:type='dedication {{this.type}}'>hello</div>", { type: 'backmatter' });
+    this.render.template("<div epub:type='dedication {{this.type}}'>hello</div>", {
+      type: 'backmatter',
+    });
 
     this.assertHTML("<div epub:type='dedication backmatter'>hello</div>", 'Initial render');
     this.assertStableRerender();
@@ -1417,8 +1429,7 @@ class UpdatingTest extends RenderTest {
       let actualSelected = [];
 
       for (const option of options) {
-        // TODO: these type errors reflect real incompatibility with
-        // SimpleDOM
+        // TODO: these type errors reflect real incompatibility with SimpleDOM
 
         if (!('selected' in option) || !('value' in option)) {
           assert.notOk(
@@ -1447,7 +1458,7 @@ class UpdatingTest extends RenderTest {
       </select>
     `;
 
-    this.render(template, {
+    this.render.template(template, {
       one: true,
       two: 'is-true',
       three: undefined,
@@ -1536,7 +1547,7 @@ class UpdatingTest extends RenderTest {
     let tom = { key: '1', name: 'Tom Dale', class: 'tomdale' };
     let yehuda = { key: '2', name: 'Yehuda Katz', class: 'wycats' };
 
-    this.render("{{#each this.list key='key' as |item|}}{{item.name}}{{/each}}", {
+    this.render.template("{{#each this.list key='key' as |item|}}{{item.name}}{{/each}}", {
       list: [tom, yehuda],
     });
     this.assertInvariants('initial render');
@@ -1559,7 +1570,7 @@ class UpdatingTest extends RenderTest {
     let tom = { name: 'Tom Dale' };
     let yehuda = { name: 'Yehuda Katz' };
 
-    this.render('{{#if this.item}}{{this.item.name}}{{/if}}', { item: tom });
+    this.render.template('{{#if this.item}}{{this.item.name}}{{/if}}', { item: tom });
     this.assertInvariants('initial render');
 
     this.rerender();
@@ -1574,7 +1585,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'top-level bounds are correct when changing innerHTML'() {
-    this.render('{{{this.html}}}', { html: '<b>inner</b>-<b>before</b>' });
+    this.render.template('{{{this.html}}}', { html: '<b>inner</b>-<b>before</b>' });
     this.assertInvariants('initial render');
 
     this.rerender();
@@ -1592,7 +1603,7 @@ class UpdatingTest extends RenderTest {
     let tom = { key: '1', name: 'Tom Dale', class: 'tomdale' };
     let yehuda = { key: '2', name: 'Yehuda Katz', class: 'wycats' };
 
-    this.render(
+    this.render.template(
       "<ul>{{#each this.list key='key' as |item|}}<li class='{{item.class}}'>{{item.name}}</li>{{/each}}</ul>",
       { list: [tom, yehuda] }
     );
@@ -1642,7 +1653,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The each helper with empty string items'() {
-    this.render(
+    this.render.template(
       `<ul>{{#each this.list key='@identity' as |item|}}<li>{{item}}</li>{{/each}}</ul>`,
       {
         list: [''],
@@ -1669,7 +1680,7 @@ class UpdatingTest extends RenderTest {
 
   @test
   'The each helper with else'() {
-    this.render(
+    this.render.template(
       `<ul>{{#each this.list key='name' as |item|}}<li class="{{item.class}}">{{item.name}}</li>{{else}}<li class="none">none</li>{{/each}}</ul>`,
       {
         list: [],
@@ -1709,7 +1720,7 @@ class UpdatingTest extends RenderTest {
     let tom = { name: 'Tom Dale', class: 'tomdale' };
     let yehuda = { name: 'Yehuda Katz', class: 'wycats' };
 
-    this.render(
+    this.render.template(
       "<ul>{{#each this.list key='@index' as |item index|}}<li class='{{item.class}}'>{{item.name}}<p class='index-{{index}}'>{{index}}</p></li>{{/each}}</ul>",
       { list: [tom, yehuda] }
     );
@@ -1868,7 +1879,7 @@ class UpdatingTest extends RenderTest {
     let tom = { key: '1', name: 'Tom Dale', class: 'tomdale' };
     let yehuda = { key: '2', name: 'Yehuda Katz', class: 'wycats' };
 
-    this.render(
+    this.render.template(
       "<ul>{{#each this.list key='key' as |item index|}}<li class='{{item.class}}'>{{item.name}}<p class='index-{{index}}'>{{index}}</p></li>{{/each}}</ul>",
       { list: [tom, yehuda] }
     );
@@ -2028,7 +2039,7 @@ class UpdatingTest extends RenderTest {
   '{{each}} items destroy correctly when destroying the whole list (new and updated items)'() {
     let destroyCount = 0;
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'DestroyableComponent',
       '{{@item}}',
@@ -2039,7 +2050,7 @@ class UpdatingTest extends RenderTest {
       }
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#each this.list as |item|}}
           <div><DestroyableComponent @item={{item}}/></div>
@@ -2066,7 +2077,7 @@ class UpdatingTest extends RenderTest {
   '{{each}} items destroy correctly if they were added after initial render'() {
     let destroyCount = 0;
 
-    this.registerComponent(
+    this.register.component(
       'Glimmer',
       'DestroyableComponent',
       '{{@item}}',
@@ -2077,7 +2088,7 @@ class UpdatingTest extends RenderTest {
       }
     );
 
-    this.render(
+    this.render.template(
       stripTight`
         {{#each this.list as |item|}}
           <div><DestroyableComponent @item={{item}}/></div>
diff --git a/packages/@glimmer-workspace/tsconfig.json b/packages/@glimmer-workspace/tsconfig.json
index 893afe5de9..b864209b13 100644
--- a/packages/@glimmer-workspace/tsconfig.json
+++ b/packages/@glimmer-workspace/tsconfig.json
@@ -3,13 +3,17 @@
     "composite": true,
     "baseUrl": "..",
 
+    "allowJs": true,
+    "checkJs": true,
+
     "target": "esnext",
     "module": "esnext",
     "moduleResolution": "bundler",
     "allowSyntheticDefaultImports": true,
-    "experimentalDecorators": true,
+    "esModuleInterop": true,
     "verbatimModuleSyntax": true,
 
+    "experimentalDecorators": true,
     "outDir": "../../ts-dist/@glimmer-workspace",
 
     "strict": true,
@@ -22,10 +26,13 @@
     "skipLibCheck": true,
     "types": ["qunit", "node", "vite/client"]
   },
-  "include": ["./*/index.*", "./*/lib/**/*", "./*/test/**/*"],
+  "include": ["./*/index.*", "./*/lib/**/*.*", "./*/test/**/*.*"],
   "references": [
     {
       "path": "../@glimmer/tsconfig.json"
+    },
+    {
+      "path": "./build/tsconfig.json"
     }
   ]
 }
diff --git a/packages/@glimmer/.eslintrc.cjs b/packages/@glimmer/.eslintrc.cjs
index e278bec5c5..59cf3c778a 100644
--- a/packages/@glimmer/.eslintrc.cjs
+++ b/packages/@glimmer/.eslintrc.cjs
@@ -15,6 +15,22 @@ module.exports = {
       },
       plugins: ['@glimmer-workspace'],
       extends: ['plugin:@glimmer-workspace/recommended'],
+      rules: {
+        'n/no-unpublished-import': 'off',
+      },
+    },
+    {
+      files: ['./reference/lib/**/*.ts'],
+      rules: {
+        'import/no-relative-parent-imports': 'error',
+
+        'import/no-internal-modules': [
+          'error',
+          {
+            allow: ['**/internal/*', '**/index.*'],
+          },
+        ],
+      },
     },
     // QUnit is a weird package, and there are some issues open about fixing it
     // - https://github.com/qunitjs/qunit/issues/1729
diff --git a/packages/@glimmer/compiler/lib/builder/builder-interface.ts b/packages/@glimmer/compiler/lib/builder/builder-interface.ts
index 1ef02b54b8..0e2cfca37c 100644
--- a/packages/@glimmer/compiler/lib/builder/builder-interface.ts
+++ b/packages/@glimmer/compiler/lib/builder/builder-interface.ts
@@ -676,7 +676,7 @@ export function normalizeAppendExpression(
           type: ExpressionKind.Concat,
           params: normalizeParams(expression.slice(1)) as [
             NormalizedExpression,
-            ...NormalizedExpression[]
+            ...NormalizedExpression[],
           ],
         };
 
@@ -764,7 +764,7 @@ export function normalizeExpression(expression: BuilderExpression): NormalizedEx
           type: ExpressionKind.Concat,
           params: normalizeParams(expression.slice(1)) as [
             NormalizedExpression,
-            ...NormalizedExpression[]
+            ...NormalizedExpression[],
           ],
         };
 
diff --git a/packages/@glimmer/compiler/lib/builder/builder.ts b/packages/@glimmer/compiler/lib/builder/builder.ts
index 031ecfdd20..51efc4c07f 100644
--- a/packages/@glimmer/compiler/lib/builder/builder.ts
+++ b/packages/@glimmer/compiler/lib/builder/builder.ts
@@ -21,26 +21,29 @@ import {
 } from '@glimmer/util';
 import { SexpOpcodes as Op, VariableResolutionContext } from '@glimmer/wire-format';
 
+import type {
+  BuilderComment,
+  BuilderStatement,
+  NormalizedAngleInvocation,
+  NormalizedAttrs,
+  NormalizedBlock,
+  NormalizedBlocks,
+  NormalizedElement,
+  NormalizedExpression,
+  NormalizedHash,
+  NormalizedHead,
+  NormalizedKeywordStatement,
+  NormalizedParams,
+  NormalizedPath,
+  NormalizedStatement,
+  Variable,
+} from './builder-interface';
+
 import {
   Builder,
-  type BuilderComment,
-  type BuilderStatement,
   ExpressionKind,
   HeadKind,
-  type NormalizedAngleInvocation,
-  type NormalizedAttrs,
-  type NormalizedBlock,
-  type NormalizedBlocks,
-  type NormalizedElement,
-  type NormalizedExpression,
-  type NormalizedHash,
-  type NormalizedHead,
-  type NormalizedKeywordStatement,
-  type NormalizedParams,
-  type NormalizedPath,
-  type NormalizedStatement,
   normalizeStatement,
-  type Variable,
   VariableKind,
 } from './builder-interface';
 
@@ -110,7 +113,10 @@ export class ProgramSymbols implements Symbols {
 class LocalSymbols implements Symbols {
   private locals: Dict<number> = dict();
 
-  constructor(private parent: Symbols, locals: string[]) {
+  constructor(
+    private parent: Symbols,
+    locals: string[]
+  ) {
     for (let local of locals) {
       this.locals[local] = parent.top.symbol(local);
     }
diff --git a/packages/@glimmer/compiler/lib/compiler.ts b/packages/@glimmer/compiler/lib/compiler.ts
index ff407432c7..0157205626 100644
--- a/packages/@glimmer/compiler/lib/compiler.ts
+++ b/packages/@glimmer/compiler/lib/compiler.ts
@@ -4,14 +4,13 @@ import type {
   SerializedTemplateWithLazyBlock,
   TemplateJavascript,
 } from '@glimmer/interfaces';
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
-import {
-  normalize,
-  type PrecompileOptions,
-  type PrecompileOptionsWithLexicalScope,
-  src,
-  type TemplateIdFn,
+import type {
+  PrecompileOptions,
+  PrecompileOptionsWithLexicalScope,
+  TemplateIdFn,
 } from '@glimmer/syntax';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
+import { normalize, src } from '@glimmer/syntax';
 import { LOCAL_LOGGER } from '@glimmer/util';
 
 import pass0 from './passes/1-normalization/index';
@@ -85,8 +84,8 @@ export function precompileJSON(
     return pass2(pass2In);
   });
 
-  if (LOCAL_SHOULD_LOG) {
-    LOCAL_LOGGER.log(`Template ->`, block);
+  if (LOCAL_TRACE_LOGGING) {
+    LOCAL_LOGGER.debug(`Template ->`, block);
   }
 
   if (block.isOk) {
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts
index 2aa9c1dd9b..6f1a4af998 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts
@@ -3,6 +3,7 @@ import type { ASTv2, SymbolTable } from '@glimmer/syntax';
 import type { OptionalList } from '../../shared/list';
 import type { Result } from '../../shared/result';
 import type * as mir from '../2-encoding/mir';
+
 import { VISIT_STMTS } from './visitors/statements';
 
 /**
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts
index e83deb2459..d2972780c2 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts
@@ -1,8 +1,9 @@
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
 import type { ASTv2, src } from '@glimmer/syntax';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { LOCAL_LOGGER } from '@glimmer/util';
 
 import type { Result } from '../../shared/result';
+
 import * as mir from '../2-encoding/mir';
 import { NormalizationState } from './context';
 import { VISIT_STMTS } from './visitors/statements';
@@ -53,20 +54,20 @@ export default function normalize(
   // create a new context for the normalization pass
   let state = new NormalizationState(root.table, isStrict);
 
-  if (LOCAL_SHOULD_LOG) {
+  if (LOCAL_TRACE_LOGGING) {
     LOCAL_LOGGER.groupCollapsed(`pass0: visiting`);
-    LOCAL_LOGGER.log('symbols', root.table);
-    LOCAL_LOGGER.log('source', source);
+    LOCAL_LOGGER.debug('symbols', root.table);
+    LOCAL_LOGGER.debug('source', source);
     LOCAL_LOGGER.groupEnd();
   }
 
   let body = VISIT_STMTS.visitList(root.body, state);
 
-  if (LOCAL_SHOULD_LOG) {
+  if (LOCAL_TRACE_LOGGING) {
     if (body.isOk) {
-      LOCAL_LOGGER.log('-> pass0: out', body.value);
+      LOCAL_LOGGER.debug('-> pass0: out', body.value);
     } else {
-      LOCAL_LOGGER.log('-> pass0: error', body.reason);
+      LOCAL_LOGGER.debug('-> pass0: error', body.reason);
     }
   }
 
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts
index 1790b2ea57..288b0db55c 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts
@@ -1,9 +1,10 @@
 import { ASTv2, generateSyntaxError, src } from '@glimmer/syntax';
 import { CurriedTypes } from '@glimmer/vm';
 
+import type { NormalizationState } from '../context';
+
 import { Err, Ok, Result } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
-import type { NormalizationState } from '../context';
 import { VISIT_EXPRS } from '../visitors/expressions';
 import { keywords } from './impl';
 import { toAppend } from './utils/call-to-append';
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts
index 0179e3eb38..5c71bf9cd1 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts
@@ -1,9 +1,12 @@
-import { type ASTv2, generateSyntaxError } from '@glimmer/syntax';
+import type { Nullable } from '@glimmer/interfaces';
+import type {ASTv2} from '@glimmer/syntax';
+import {  generateSyntaxError } from '@glimmer/syntax';
 import { CurriedTypes } from '@glimmer/vm';
 
+import type { NormalizationState } from '../context';
+
 import { Err, Ok, Result } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
-import type { NormalizationState } from '../context';
 import { VISIT_EXPRS } from '../visitors/expressions';
 import { VISIT_STMTS } from '../visitors/statements';
 import { keywords } from './impl';
@@ -87,6 +90,59 @@ export const BLOCK_KEYWORDS = keywords('Block')
         );
     },
   })
+  .kw('-try', {
+    assert(node: ASTv2.InvokeBlock): Result<{
+      handler: Nullable<ASTv2.ExpressionNode>;
+    }> {
+      let { args } = node;
+
+      if (!args.named.isEmpty()) {
+        return Err(
+          generateSyntaxError(
+            `{{#-try}} cannot receive named parameters, received ${args.named.entries
+              .map((e) => e.name.chars)
+              .join(', ')}`,
+            node.loc
+          )
+        );
+      }
+
+      if (args.positional.size > 1) {
+        return Err(
+          generateSyntaxError(
+            `{{#-try}} can only receive one positional parameter in block form, the handler. Received ${args.positional.size} parameters`,
+            node.loc
+          )
+        );
+      }
+
+      let handler = args.nth(0);
+
+      return Ok({ handler });
+    },
+
+    translate(
+      { node, state }: { node: ASTv2.InvokeBlock; state: NormalizationState },
+      { handler }: { handler: ASTv2.ExpressionNode }
+    ): Result<mir.HandleError> {
+      let block = node.blocks.get('default');
+      let inverse = node.blocks.get('else');
+
+      let handlerResult = handler ? VISIT_EXPRS.visit(handler, state) : Ok(null);
+      let blockResult = VISIT_STMTS.NamedBlock(block, state);
+      let inverseResult = inverse ? VISIT_STMTS.NamedBlock(inverse, state) : Ok(null);
+
+      return Result.all(handlerResult, blockResult, inverseResult).mapOk(
+        ([handler, block, inverse]) =>
+          new mir.HandleError({
+            loc: node.loc,
+            handler,
+            block,
+            inverse,
+          })
+      );
+    },
+  })
   .kw('if', {
     assert(node: ASTv2.InvokeBlock): Result<{
       condition: ASTv2.ExpressionNode;
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts
index 96e5e65eb4..5a74831103 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts
@@ -1,15 +1,16 @@
+import type {ASTv2, KeywordType} from '@glimmer/syntax';
 import {
-  type ASTv2,
   generateSyntaxError,
   isKeyword,
-  KEYWORDS_TYPES,
-  type KeywordType,
+  KEYWORDS_TYPES
 } from '@glimmer/syntax';
 import { exhausted } from '@glimmer/util';
 
-import { Err, type Result } from '../../../shared/result';
+import type {Result} from '../../../shared/result';
 import type { NormalizationState } from '../context';
 
+import { Err  } from '../../../shared/result';
+
 export interface KeywordDelegate<Match extends KeywordMatch, V, Out> {
   assert(options: Match, state: NormalizationState): Result<V>;
   translate(options: { node: Match; state: NormalizationState }, param: V): Result<Out>;
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/call-to-append.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/call-to-append.ts
index 3566e21d08..3e3e56bcc1 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/call-to-append.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/call-to-append.ts
@@ -1,8 +1,9 @@
 import type { Result } from '../../../../shared/result';
-import * as mir from '../../../2-encoding/mir';
 import type { NormalizationState } from '../../context';
 import type { GenericKeywordNode, KeywordDelegate } from '../impl';
 
+import * as mir from '../../../2-encoding/mir';
+
 export function toAppend<T>({
   assert,
   translate,
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/curry.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/curry.ts
index 1ea76a42e8..528ff4eb07 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/curry.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/curry.ts
@@ -2,11 +2,12 @@ import type { CurriedType } from '@glimmer/interfaces';
 import { ASTv2, generateSyntaxError } from '@glimmer/syntax';
 import { CurriedTypes } from '@glimmer/vm';
 
+import type { NormalizationState } from '../../context';
+import type { KeywordDelegate } from '../impl';
+
 import { Err, Ok, Result } from '../../../../shared/result';
 import * as mir from '../../../2-encoding/mir';
-import type { NormalizationState } from '../../context';
 import { VISIT_EXPRS } from '../../visitors/expressions';
-import type { KeywordDelegate } from '../impl';
 
 const CurriedTypeToReadableType = {
   [CurriedTypes.Component]: 'component',
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/dynamic-vars.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/dynamic-vars.ts
index 1e9a507627..39d1c4cc02 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/dynamic-vars.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/dynamic-vars.ts
@@ -1,11 +1,14 @@
-import { type ASTv2, generateSyntaxError } from '@glimmer/syntax';
+import type {ASTv2} from '@glimmer/syntax';
+import {  generateSyntaxError } from '@glimmer/syntax';
 
-import { Err, Ok, type Result } from '../../../../shared/result';
-import * as mir from '../../../2-encoding/mir';
+import type {Result} from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
-import { VISIT_EXPRS } from '../../visitors/expressions';
 import type { GenericKeywordNode, KeywordDelegate } from '../impl';
 
+import { Err, Ok  } from '../../../../shared/result';
+import * as mir from '../../../2-encoding/mir';
+import { VISIT_EXPRS } from '../../visitors/expressions';
+
 function assertGetDynamicVarKeyword(node: GenericKeywordNode): Result<ASTv2.ExpressionNode> {
   let call = node.type === 'AppendContent' ? node.value : node;
 
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/has-block.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/has-block.ts
index 102408c85d..4cf19c7235 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/has-block.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/has-block.ts
@@ -1,10 +1,12 @@
 import { ASTv2, generateSyntaxError, SourceSlice } from '@glimmer/syntax';
 
-import { Err, Ok, type Result } from '../../../../shared/result';
-import * as mir from '../../../2-encoding/mir';
+import type {Result} from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
 import type { GenericKeywordNode, KeywordDelegate } from '../impl';
 
+import { Err, Ok  } from '../../../../shared/result';
+import * as mir from '../../../2-encoding/mir';
+
 function assertHasBlockKeyword(type: string) {
   return (node: GenericKeywordNode): Result<SourceSlice> => {
     let call = node.type === 'AppendContent' ? node.value : node;
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/if-unless.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/if-unless.ts
index 72fcb63de8..734379290b 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/if-unless.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/if-unless.ts
@@ -1,10 +1,12 @@
-import { type ASTv2, generateSyntaxError } from '@glimmer/syntax';
+import type {ASTv2} from '@glimmer/syntax';
+import {  generateSyntaxError } from '@glimmer/syntax';
+
+import type { NormalizationState } from '../../context';
+import type { KeywordDelegate } from '../impl';
 
 import { Err, Ok, Result } from '../../../../shared/result';
 import * as mir from '../../../2-encoding/mir';
-import type { NormalizationState } from '../../context';
 import { VISIT_EXPRS } from '../../visitors/expressions';
-import type { KeywordDelegate } from '../impl';
 
 function assertIfUnlessInlineKeyword(type: string) {
   return (
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/log.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/log.ts
index 73ce1255f3..1602dde3b5 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/log.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/utils/log.ts
@@ -1,11 +1,14 @@
-import { type ASTv2, generateSyntaxError } from '@glimmer/syntax';
+import type {ASTv2} from '@glimmer/syntax';
+import {  generateSyntaxError } from '@glimmer/syntax';
 
-import { Err, Ok, type Result } from '../../../../shared/result';
-import * as mir from '../../../2-encoding/mir';
+import type {Result} from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
-import { VISIT_EXPRS } from '../../visitors/expressions';
 import type { GenericKeywordNode, KeywordDelegate } from '../impl';
 
+import { Err, Ok  } from '../../../../shared/result';
+import * as mir from '../../../2-encoding/mir';
+import { VISIT_EXPRS } from '../../visitors/expressions';
+
 function assertLogKeyword(node: GenericKeywordNode): Result<ASTv2.PositionalArguments> {
   let {
     args: { named, positional },
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/utils/is-node.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/utils/is-node.ts
index 1f056bd770..53da0b184a 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/utils/is-node.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/utils/is-node.ts
@@ -1,5 +1,6 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { ASTv2, generateSyntaxError, type SourceSlice } from '@glimmer/syntax';
+import type {SourceSlice} from '@glimmer/syntax';
+import { ASTv2, generateSyntaxError  } from '@glimmer/syntax';
 import { unreachable } from '@glimmer/util';
 
 export type HasPath<Node extends ASTv2.CallNode = ASTv2.CallNode> = Node & {
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/classified.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/classified.ts
index 8b3fa5b0fd..ec3317b73a 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/classified.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/classified.ts
@@ -1,10 +1,11 @@
 import { ASTv2, maybeLoc, src } from '@glimmer/syntax';
 
+import type { NormalizationState } from '../../context';
+
 import { OptionalList } from '../../../../shared/list';
 import { Ok, Result, ResultArray } from '../../../../shared/result';
 import { getAttrNamespace } from '../../../../utils';
 import * as mir from '../../../2-encoding/mir';
-import type { NormalizationState } from '../../context';
 import { MODIFIER_KEYWORDS } from '../../keywords';
 import { assertIsValidModifier, isHelperInvocation } from '../../utils/is-node';
 import { convertPathToCallIfKeyword, VISIT_EXPRS } from '../expressions';
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/component.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/component.ts
index 9f36ec546c..2f46d30c09 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/component.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/component.ts
@@ -1,11 +1,12 @@
 import type { ASTv2 } from '@glimmer/syntax';
 
 import type { Result } from '../../../../shared/result';
-import * as mir from '../../../2-encoding/mir';
 import type { NormalizationState } from '../../context';
+import type { Classified, ClassifiedElement, PreparedArgs } from './classified';
+
+import * as mir from '../../../2-encoding/mir';
 import { convertPathToCallIfKeyword, VISIT_EXPRS } from '../expressions';
 import { VISIT_STMTS } from '../statements';
-import type { Classified, ClassifiedElement, PreparedArgs } from './classified';
 
 export class ClassifiedComponent implements Classified {
   readonly dynamicFeatures = true;
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/simple-element.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/simple-element.ts
index 5a2840ae82..802b23d982 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/simple-element.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/element/simple-element.ts
@@ -1,9 +1,12 @@
-import { type ASTv2, generateSyntaxError, type SourceSlice } from '@glimmer/syntax';
+import type {ASTv2, SourceSlice} from '@glimmer/syntax';
+import {  generateSyntaxError  } from '@glimmer/syntax';
 
-import { Err, type Result } from '../../../../shared/result';
+import type {Result} from '../../../../shared/result';
+import type { Classified, ClassifiedElement, PreparedArgs } from './classified';
+
+import { Err  } from '../../../../shared/result';
 import * as mir from '../../../2-encoding/mir';
 import { VISIT_STMTS } from '../statements';
-import type { Classified, ClassifiedElement, PreparedArgs } from './classified';
 
 export class ClassifiedSimpleElement implements Classified {
   constructor(
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts
index 43ad602089..8df5ed41c5 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts
@@ -3,9 +3,10 @@ import { ASTv2, KEYWORDS_TYPES } from '@glimmer/syntax';
 import { getLast, isPresentArray } from '@glimmer/util';
 
 import type { AnyOptionalList, PresentList } from '../../../shared/list';
+import type { NormalizationState } from '../context';
+
 import { Ok, Result, ResultArray } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
-import type { NormalizationState } from '../context';
 import { CALL_KEYWORDS } from '../keywords';
 import { hasPath } from '../utils/is-node';
 
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/statements.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/statements.ts
index 6355180e65..4968eec669 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/statements.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/statements.ts
@@ -1,9 +1,10 @@
 import { ASTv2 } from '@glimmer/syntax';
 
+import type { NormalizationState } from '../context';
+
 import { OptionalList } from '../../../shared/list';
 import { Ok, Result, ResultArray } from '../../../shared/result';
 import * as mir from '../../2-encoding/mir';
-import type { NormalizationState } from '../context';
 import { BLOCK_KEYWORDS } from '../keywords';
 import { APPEND_KEYWORDS } from '../keywords/append';
 import { ClassifiedElement, hasDynamicFeatures } from './element/classified';
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
index b6e6ca39eb..77343a648c 100644
--- a/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
+++ b/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
@@ -9,14 +9,16 @@ import type {
   WellKnownAttrName,
   WireFormat,
 } from '@glimmer/interfaces';
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
+import { ASTv2, SourceSpan } from '@glimmer/syntax';
 import { exhausted, LOCAL_LOGGER } from '@glimmer/util';
 import { SexpOpcodes } from '@glimmer/wire-format';
 
 import type { OptionalList } from '../../shared/list';
+import type * as mir from './mir';
+
 import { deflateAttrName, deflateTagName } from '../../utils';
 import { EXPR } from './expressions';
-import type * as mir from './mir';
 
 class WireStatements<S extends WireFormat.Statement = WireFormat.Statement> {
   constructor(private statements: readonly S[]) {}
@@ -44,8 +46,8 @@ export class ContentEncoder {
   }
 
   content(stmt: mir.Statement): WireFormat.Statement | WireStatements {
-    if (LOCAL_SHOULD_LOG) {
-      LOCAL_LOGGER.log(`encoding`, stmt);
+    if (LOCAL_TRACE_LOGGING) {
+      LOCAL_LOGGER.debug(`encoding`, stmt);
     }
 
     return this.visitContent(stmt);
@@ -73,6 +75,8 @@ export class ContentEncoder {
         return this.InvokeBlock(stmt);
       case 'If':
         return this.If(stmt);
+      case 'HandleError':
+        return this.HandleError(stmt);
       case 'Each':
         return this.Each(stmt);
       case 'With':
@@ -201,6 +205,22 @@ export class ContentEncoder {
     ];
   }
 
+  HandleError({ handler, block, inverse }: mir.HandleError): WireFormat.Statements.HandleError {
+    return [
+      SexpOpcodes.HandleError,
+      handler
+        ? EXPR.expr(handler)
+        : EXPR.Literal(
+            new ASTv2.LiteralExpression({
+              value: null,
+              loc: SourceSpan.synthetic('null'),
+            })
+          ),
+      CONTENT.NamedBlock(block)[1],
+      inverse ? CONTENT.NamedBlock(inverse)[1] : null,
+    ];
+  }
+
   Each({ value, key, block, inverse }: mir.Each): WireFormat.Statements.Each {
     return [
       SexpOpcodes.Each,
@@ -260,7 +280,7 @@ function staticAttr({ name, value, namespace }: mir.StaticAttr): StaticAttrArgs
 export type DynamicAttrArgs = [
   name: string | WellKnownAttrName,
   value: WireFormat.Expression,
-  namespace?: string
+  namespace?: string,
 ];
 
 function dynamicAttr({ name, value, namespace }: mir.DynamicAttr): DynamicAttrArgs {
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/index.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/index.ts
index e20e6db31e..4d54f7d059 100644
--- a/packages/@glimmer/compiler/lib/passes/2-encoding/index.ts
+++ b/packages/@glimmer/compiler/lib/passes/2-encoding/index.ts
@@ -1,10 +1,11 @@
 import type { WireFormat } from '@glimmer/interfaces';
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { LOCAL_LOGGER } from '@glimmer/util';
 
+import type * as mir from './mir';
+
 import WireFormatDebugger from '../../wire-format-debug';
 import { CONTENT } from './content';
-import type * as mir from './mir';
 
 export function visit(template: mir.Template): WireFormat.SerializedTemplateBlock {
   let statements = CONTENT.list(template.body);
@@ -12,13 +13,13 @@ export function visit(template: mir.Template): WireFormat.SerializedTemplateBloc
   let block: WireFormat.SerializedTemplateBlock = [
     statements,
     scope.symbols,
-    scope.hasEval,
+    scope.hasDebug,
     scope.upvars,
   ];
 
-  if (LOCAL_SHOULD_LOG) {
+  if (LOCAL_TRACE_LOGGING) {
     let debug = new WireFormatDebugger(block);
-    LOCAL_LOGGER.log(
+    LOCAL_LOGGER.debug(
       `-> `,
       statements.map((s) => debug.formatOpcode(s))
     );
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts
index 33302af3ba..b274d3ab9f 100644
--- a/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts
+++ b/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts
@@ -1,11 +1,7 @@
-import type { CurriedType, PresentArray } from '@glimmer/interfaces';
+import type { CurriedType, Nullable, PresentArray } from '@glimmer/interfaces';
+import type {ASTv2, BlockSymbolTable, ProgramSymbolTable, SourceSlice, SymbolTable} from '@glimmer/syntax';
 import {
-  type ASTv2,
-  type BlockSymbolTable,
-  node,
-  type ProgramSymbolTable,
-  type SourceSlice,
-  type SymbolTable,
+  node
 } from '@glimmer/syntax';
 
 import type { AnyOptionalList, OptionalList, PresentList } from '../../shared/list';
@@ -30,6 +26,12 @@ export class If extends node('If').fields<{
   inverse: NamedBlock | null;
 }>() {}
 
+export class HandleError extends node('HandleError').fields<{
+  handler: Nullable<ExpressionNode>;
+  block: NamedBlock;
+  inverse: NamedBlock | null;
+}>() {}
+
 export class IfInline extends node('IfInline').fields<{
   condition: ExpressionNode;
   truthy: ExpressionNode;
@@ -241,6 +243,7 @@ export type Statement =
   | InvokeBlock
   | AppendComment
   | If
+  | HandleError
   | Each
   | With
   | Let
diff --git a/packages/@glimmer/compiler/lib/shared/result.ts b/packages/@glimmer/compiler/lib/shared/result.ts
index 31aa026032..400e31e933 100644
--- a/packages/@glimmer/compiler/lib/shared/result.ts
+++ b/packages/@glimmer/compiler/lib/shared/result.ts
@@ -1,6 +1,8 @@
 import type { GlimmerSyntaxError } from '@glimmer/syntax';
 
-import { type AnyOptionalList, OptionalList } from './list';
+import type {AnyOptionalList} from './list';
+
+import {  OptionalList } from './list';
 
 abstract class ResultImpl<T> {
   static all<T extends Result<unknown>[]>(...results: T): MapAll<T> {
diff --git a/packages/@glimmer/compiler/lib/wire-encoding.md b/packages/@glimmer/compiler/lib/wire-encoding.md
index 106ca1c403..77ceb82705 100644
--- a/packages/@glimmer/compiler/lib/wire-encoding.md
+++ b/packages/@glimmer/compiler/lib/wire-encoding.md
@@ -130,9 +130,9 @@ when otherwise explicitly stated.
 
 ## Flags
 
-| 0        | 1        | 2        | 3        | 4          | 5       |
-| -------- | -------- | -------- | -------- | ---------- | ------- |
-| reserved | reserved | reserved | reserved | has upvars | hasEval |
+| 0        | 1        | 2        | 3        | 4          | 5        |
+| -------- | -------- | -------- | -------- | ---------- | -------- |
+| reserved | reserved | reserved | reserved | has upvars | hasDebug |
 
 # Expression
 
diff --git a/packages/@glimmer/compiler/lib/wire-format-debug.ts b/packages/@glimmer/compiler/lib/wire-format-debug.ts
index e320b5025d..d6e3500165 100644
--- a/packages/@glimmer/compiler/lib/wire-format-debug.ts
+++ b/packages/@glimmer/compiler/lib/wire-format-debug.ts
@@ -15,7 +15,7 @@ export default class WireFormatDebugger {
   private upvars: string[];
   private symbols: string[];
 
-  constructor([_statements, symbols, _hasEval, upvars]: SerializedTemplateBlock) {
+  constructor([_statements, symbols, _hasDebug, upvars]: SerializedTemplateBlock) {
     this.upvars = upvars;
     this.symbols = symbols;
   }
@@ -279,7 +279,9 @@ export default class WireFormatDebugger {
     }
   }
 
-  private formatElementParams(opcodes: Nullable<WireFormat.ElementParameter[]>): Nullable<unknown[]> {
+  private formatElementParams(
+    opcodes: Nullable<WireFormat.ElementParameter[]>
+  ): Nullable<unknown[]> {
     if (opcodes === null) return null;
     return opcodes.map((o) => this.formatOpcode(o));
   }
diff --git a/packages/@glimmer/compiler/test/compiler-test.ts b/packages/@glimmer/compiler/test/compiler-test.ts
index a73874f1e5..9c4c4209ba 100644
--- a/packages/@glimmer/compiler/test/compiler-test.ts
+++ b/packages/@glimmer/compiler/test/compiler-test.ts
@@ -1,8 +1,13 @@
 /* eslint-disable qunit/no-test-expect-argument */
 
+import type {BuilderStatement} from '@glimmer/compiler';
+import type {
+  SerializedTemplate,
+  SerializedTemplateBlock,
+  SerializedTemplateWithLazyBlock,
+} from '@glimmer/interfaces';
 import {
   Builder,
-  type BuilderStatement,
   buildStatements,
   c,
   NEWLINE,
@@ -10,13 +15,8 @@ import {
   ProgramSymbols,
   s,
   unicode,
-  WireFormatDebugger,
+  WireFormatDebugger
 } from '@glimmer/compiler';
-import type {
-  SerializedTemplate,
-  SerializedTemplateBlock,
-  SerializedTemplateWithLazyBlock,
-} from '@glimmer/interfaces';
 import { assign, strip } from '@glimmer/util';
 
 QUnit.module('@glimmer/compiler - compiling source to wire format');
@@ -55,7 +55,7 @@ const Concat = Builder.Concat;
 
 QUnit.test(
   '@arguments are on regular non-component/regular HTML nodes throws syntax error',
-  function (assert) {
+  (assert) => {
     const template = strip`
     <a @onClick={{action "hi"}}>Link</a>
   `;
diff --git a/packages/@glimmer/debug/index.ts b/packages/@glimmer/debug/index.ts
index b05cc97099..57cc35ef05 100644
--- a/packages/@glimmer/debug/index.ts
+++ b/packages/@glimmer/debug/index.ts
@@ -1,4 +1,33 @@
-export { debug, debugSlice, logOpcode } from './lib/debug';
+export {
+  type AnyOperand,
+  debug,
+  type DebugOp,
+  DisassembledOperand,
+  type DynamicDisassembledOperand,
+  getOpSnapshot,
+  logOpcodeSlice,
+  type OpSnapshot,
+  type RawDisassembledOperand,
+  type RegisterName,
+  type SomeDisassembledOperand,
+  type StaticDisassembledOperand,
+} from './lib/debug';
 export * from './lib/metadata';
 export { opcodeMetadata } from './lib/opcode-metadata';
+export * from './lib/render/combinators';
+export type { Fragment } from './lib/render/fragment';
+export { DebugLogger } from './lib/render/lines';
+export {
+  as,
+  dom,
+  empty,
+  frag,
+  type IntoFragment,
+  intoFragment,
+  join,
+  value,
+} from './lib/render/presets';
+export { SerializeBlockContext } from './lib/render/serialize';
+export * from './lib/render/state';
+export * from './lib/snapshot';
 export * from './lib/stack-check';
diff --git a/packages/@glimmer/debug/lib/debug.ts b/packages/@glimmer/debug/lib/debug.ts
index 61eaadfa3b..793ea14c2b 100644
--- a/packages/@glimmer/debug/lib/debug.ts
+++ b/packages/@glimmer/debug/lib/debug.ts
@@ -1,43 +1,60 @@
 import type {
-  CompileTimeConstants,
+  BlockMetadata,
+  DebugConstants,
   Dict,
-  Maybe,
-  Recast,
-  ResolutionTimeConstants,
+  Nullable,
+  RuntimeConstants,
   RuntimeOp,
   TemplateCompilationContext,
-} from "@glimmer/interfaces";
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
-import { decodeHandle, decodeImmediate, enumerate, LOCAL_LOGGER } from '@glimmer/util';
-import { $fp, $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0, type Register } from '@glimmer/vm';
+} from '@glimmer/interfaces';
+import { LOCAL_DEBUG, LOCAL_SUBTLE_LOGGING, LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
+import {
+  decodeHandle,
+  decodeImmediate,
+  enumerate,
+  exhausted,
+  expect,
+ LOCAL_LOGGER,  unreachable } from '@glimmer/util';
+import {
+  $fp,
+  $pc,
+  $ra,
+  $s0,
+  $s1,
+  $sp,
+  $t0,
+  $t1,
+  $v0,
+  CURRIED_COMPONENT,
+  CURRIED_HELPER,
+  CURRIED_MODIFIER,
+} from '@glimmer/vm';
 
-import { opcodeMetadata } from './opcode-metadata';
 import type { Primitive } from './stack-check';
+import type { OperandLabel } from './utils';
 
-export interface DebugConstants {
-  getValue<T>(handle: number): T;
-  getArray<T>(value: number): T[];
-}
+import { DebugLogger, frag } from '..';
+import { OPERANDS } from './dism/operands';
+import { opcodeMetadata } from './opcode-metadata';
+import { DebugOpState } from './render/state';
 
-export function debugSlice(context: TemplateCompilationContext, start: number, end: number) {
-  if (LOCAL_SHOULD_LOG) {
+export function logOpcodeSlice(context: TemplateCompilationContext, start: number, end: number) {
+  if (LOCAL_TRACE_LOGGING) {
+    const logger = new DebugLogger(LOCAL_LOGGER, { showSubtle: LOCAL_SUBTLE_LOGGING });
     LOCAL_LOGGER.group(`%c${start}:${end}`, 'color: #999');
 
+    const constants = context.program.constants;
+
     let heap = context.program.heap;
     let opcode = context.program.createOp(heap);
 
     let _size = 0;
-    for (let i = start; i < end; i = i + _size) {
+    for (let i = start; i <= end; i = i + _size) {
       opcode.offset = i;
-      let [name, params] = debug(
-        context.program.constants as Recast<
-          CompileTimeConstants & ResolutionTimeConstants,
-          DebugConstants
-        >,
-        opcode,
-        opcode.isMachine
-      )!;
-      LOCAL_LOGGER.log(`${i}. ${logOpcode(name, params)}`);
+      const op = new DebugOpState(constants, getOpSnapshot(opcode), context.meta);
+
+      logger.log(frag`${i}. ${op.describe()}`);
+
       _size = opcode.size;
     }
     opcode.offset = -_size;
@@ -45,13 +62,13 @@ export function debugSlice(context: TemplateCompilationContext, start: number, e
   }
 }
 
-export function logOpcode(type: string, params: Maybe<Dict>): string | void {
-  if (LOCAL_SHOULD_LOG) {
+export function describeOpcode(type: string, params: Dict<SomeDisassembledOperand>): string | void {
+  if (LOCAL_DEBUG) {
     let out = type;
 
     if (params) {
-      let args = Object.keys(params)
-        .map((p) => ` ${p}=${json(params[p])}`)
+      let args = Object.entries(params)
+        .map(([p, v]) => ` ${p}=${json(v)}`)
         .join('');
       out += args;
     }
@@ -59,130 +76,369 @@ export function logOpcode(type: string, params: Maybe<Dict>): string | void {
   }
 }
 
-function json(param: unknown) {
-  if (LOCAL_SHOULD_LOG) {
-    if (typeof param === 'function') {
-      return '<function>';
-    }
+function stringify(value: number, type: 'constant'): string;
+function stringify(value: RegisterName, type: 'register'): string;
+function stringify(value: number, type: 'variable' | 'pc'): string;
+function stringify(value: DisassembledOperand['value'], type: 'stringify' | 'unknown'): string;
+function stringify(
+  value: unknown,
+  type: 'stringify' | 'constant' | 'register' | 'variable' | 'pc' | 'unknown'
+) {
+  switch (type) {
+    case 'stringify':
+      return JSON.stringify(value);
+    case 'constant':
+      return `${stringify(value, 'unknown')}`;
+    case 'register':
+      return value;
+    case 'variable':
+      return `{$fp+${value}}`;
+    case 'pc':
+      return `@${value}`;
+    case 'unknown': {
+      switch (typeof value) {
+        case 'function':
+          return '<function>';
+        case 'number':
+        case 'string':
+        case 'bigint':
+        case 'boolean':
+          return JSON.stringify(value);
+        case 'symbol':
+          return `${String(value)}`;
+        case 'undefined':
+          return 'undefined';
+        case 'object': {
+          if (value === null) return 'null';
+          if (Array.isArray(value)) return `<array[${value.length}]>`;
 
-    let string;
-    try {
-      string = JSON.stringify(param);
-    } catch (e) {
-      return '<object>';
-    }
+          let name = value.constructor.name;
 
-    if (string === undefined) {
-      return 'undefined';
-    }
+          switch (name) {
+            case 'Error':
+            case 'RangeError':
+            case 'ReferenceError':
+            case 'SyntaxError':
+            case 'TypeError':
+            case 'WeakMap':
+            case 'WeakSet':
+              return `<${name}>`;
+            case 'Object':
+              return `<${name}>`;
+          }
 
-    let debug = JSON.parse(string);
-    if (typeof debug === 'object' && debug !== null && debug.GlimmerDebug !== undefined) {
-      return debug.GlimmerDebug;
+          if (value instanceof Map) {
+            return `<Map[${value.size}]>`;
+          } else if (value instanceof Set) {
+            return `<Set[${value.size}]>`;
+          } else {
+            return `<${name}>`;
+          }
+        }
+      }
     }
+  }
+}
+
+function json(param: SomeDisassembledOperand): string | string[] | null {
+  switch (param.type) {
+    case 'number':
+    case 'boolean':
+    case 'string':
+    case 'primitive':
+      return stringify(param.value, 'stringify');
+    case 'array':
+      return param.value?.map((value) => stringify(value, 'unknown')) ?? null;
+    case 'dynamic':
+      return stringify(param.value, 'unknown');
+    case 'constant':
+      return stringify(param.value, 'constant');
+    case 'register':
+      return stringify(param.value, 'register');
+    case 'instruction':
+      return stringify(param.value, 'pc');
+    case 'variable':
+      return stringify(param.value, 'variable');
+    case 'error:opcode':
+      return `{raw:${param.value}}`;
+    case 'error:operand':
+      return `{err:${param.options.label.name}=${param.value}}`;
+    case 'enum<curry>':
+      return `<curry:${param.value}>`;
+
+    default:
+      exhausted(param);
+  }
+}
+
+export type RegisterName =
+  | '$pc'
+  | '$ra'
+  | '$fp'
+  | '$sp'
+  | '$s0'
+  | '$s1'
+  | '$t0'
+  | '$t1'
+  | '$v0'
+  | `$bug${number}`;
+
+export type AnyOperand = [type: string, value: never, options?: object];
+export type OperandType<O extends AnyOperand> = O[0];
+export type OperandValue<O extends AnyOperand> = O[1];
+export type OperandOptions<O extends AnyOperand> = O extends [
+  type: string,
+  value: never,
+  options: infer Options,
+]
+  ? Options
+  : void;
+export type OperandOptionsA<O extends AnyOperand> = O extends [
+  type: string,
+  value: never,
+  options: infer Options,
+]
+  ? Options
+  : {};
+
+type ExtractA<O> = O extends { a: infer A } ? A : never;
+type ExpandUnion<U> = U extends infer O ? ExtractA<{ a: O }> : never;
+
+export type NullableOperand<O extends AnyOperand> =
+  | [OperandType<O>, OperandValue<O>, Expand<OperandOptionsA<O> & { nullable?: false }>]
+  | [OperandType<O>, Nullable<OperandValue<O>>, Expand<OperandOptionsA<O> & { nullable: true }>];
+
+export type NullableName<T extends string> = T extends `${infer N}?` ? N : never;
+
+export type WithOptions<O extends AnyOperand, Options> = ExpandUnion<
+  [OperandType<O>, OperandValue<O>, Expand<OperandOptionsA<O> & Options>]
+>;
+
+// expands object types one level deep
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+type DefineOperand<T extends string, V, Options = undefined> = undefined extends Options
+  ? readonly [type: T, value: V]
+  : readonly [type: T, value: V, options: Options];
+
+type DefineNullableOperand<T extends string, V, Options = undefined> = Options extends undefined
+  ?
+      | readonly [type: T, value: V]
+      | readonly [type: T, value: Nullable<V>, options: { nullable: true }]
+      | readonly [type: T, value: V, options: { nullable?: false }]
+  :
+      | readonly [type: T, value: Nullable<V>, options: Expand<Options & { nullable: true }>]
+      | readonly [type: T, value: V, options: Expand<Options & { nullable?: false }>]
+      | readonly [type: T, value: V, options: Options];
+
+/**
+ * A dynamic operand has a value that can't be easily represented as an embedded string.
+ */
+export type RawDynamicDisassembledOperand =
+  | DefineOperand<'dynamic', unknown>
+  | DefineOperand<'constant', number>
+  | DefineNullableOperand<'array', unknown[]>
+  | DefineOperand<'variable', number, { name?: string | null }>;
+
+export type RawStaticDisassembledOperand =
+  | DefineOperand<'error:operand', number, { label: OperandLabel }>
+  | DefineOperand<'error:opcode', number, { kind: number }>
+  | DefineOperand<'number', number>
+  | DefineOperand<'boolean', boolean>
+  | DefineOperand<'primitive', Primitive>
+  | DefineOperand<'register', RegisterName>
+  | DefineOperand<'instruction', number>
+  | DefineOperand<'enum<curry>', 'component' | 'helper' | 'modifier'>
+  | DefineOperand<'array', number[], { kind: typeof Number }>
+  | DefineNullableOperand<'array', string[], { kind: typeof String }>
+  /**
+   * A variable is a numeric offset into the stack (relative to the $fp register).
+   */
+  | DefineNullableOperand<'string', string>;
+
+export type RawDisassembledOperand = RawStaticDisassembledOperand | RawDynamicDisassembledOperand;
+
+type ObjectForRaw<R> = R extends RawDisassembledOperand
+  ? R[2] extends undefined
+    ? {
+        type: R[0];
+        value: R[1];
+        options?: R[2];
+      }
+    : {
+        type: R[0];
+        value: R[1];
+        options: R[2];
+      }
+  : never;
 
-    return string;
+export class DisassembledOperand<R extends RawDisassembledOperand = RawDisassembledOperand> {
+  static of(raw: RawDisassembledOperand): SomeDisassembledOperand {
+    return new DisassembledOperand(raw) as never;
+  }
+
+  readonly #raw: R;
+
+  private constructor(raw: R) {
+    this.#raw = raw;
+  }
+
+  get type(): R[0] {
+    return this.#raw[0];
+  }
+
+  get value(): R[1] {
+    return this.#raw[1];
+  }
+
+  get options(): R[2] {
+    return this.#raw[2];
+  }
+}
+
+export type StaticDisassembledOperand = ObjectForRaw<RawStaticDisassembledOperand> & {
+  isDynamic: false;
+};
+export type DynamicDisassembledOperand = ObjectForRaw<RawDynamicDisassembledOperand> & {
+  isDynamic: true;
+};
+
+export type SomeDisassembledOperand = StaticDisassembledOperand | DynamicDisassembledOperand;
+
+export interface DebugOp {
+  name: string;
+  params: Dict<SomeDisassembledOperand>;
+  meta: BlockMetadata | null;
+}
+
+export type OpSnapshot = Pick<RuntimeOp, 'size' | 'type' | 'op1' | 'op2' | 'op3'>;
+
+export function getOpSnapshot(op: RuntimeOp): OpSnapshot {
+  return {
+    size: op.size,
+    type: op.type,
+    op1: op.op1,
+    op2: op.op2,
+    op3: op.op3,
+  };
+}
+
+class DebugOperandInfo {
+  readonly #operand: OperandLabel;
+  readonly #value: number;
+  readonly #constants: DebugConstants;
+  readonly #metadata: BlockMetadata | null;
+
+  constructor(
+    operand: OperandLabel,
+    value: number,
+    constants: DebugConstants,
+    metadata: BlockMetadata | null
+  ) {
+    this.#operand = operand;
+    this.#value = value;
+    this.#constants = constants;
+    this.#metadata = metadata;
+  }
+
+  toDebug(): RawDisassembledOperand {
+    const spec = expect(
+      OPERANDS[this.#operand.type],
+      `Unknown operand type: ${this.#operand.type}`
+    );
+
+    return spec({
+      label: this.#operand,
+      value: this.#value,
+      constants: this.#constants,
+      meta: this.#metadata,
+    });
   }
 }
 
 export function debug(
-  c: DebugConstants,
-  op: RuntimeOp,
-  isMachine: 0 | 1
-): [string, Dict] | undefined {
-  if (LOCAL_SHOULD_LOG) {
-    let metadata = opcodeMetadata(op.type, isMachine);
+  constants: RuntimeConstants,
+  op: OpSnapshot,
+  meta: BlockMetadata | null
+): DebugOp {
+  if (LOCAL_DEBUG) {
+    let metadata = opcodeMetadata(op.type);
 
+    let out: Dict<RawDisassembledOperand> = Object.create(null);
     if (!metadata) {
-      throw new Error(`Missing Opcode Metadata for ${op}`);
-    }
+      for (let i = 0; i < op.size; i++) {
+        out[i] = ['error:opcode', i, { kind: op.type }];
+      }
 
-    let out = Object.create(null);
-
-    for (const [index, operand] of enumerate(metadata.ops)) {
-      let actualOperand = opcodeOperand(op, index);
-
-      switch (operand.type) {
-        case 'u32':
-        case 'i32':
-        case 'owner':
-          out[operand.name] = actualOperand;
-          break;
-        case 'handle':
-          out[operand.name] = c.getValue(actualOperand);
-          break;
-        case 'str':
-        case 'option-str':
-        case 'array':
-          out[operand.name] = c.getValue(actualOperand);
-          break;
-        case 'str-array':
-          out[operand.name] = c.getArray(actualOperand);
-          break;
-        case 'bool':
-          out[operand.name] = !!actualOperand;
-          break;
-        case 'primitive':
-          out[operand.name] = decodePrimitive(actualOperand, c);
-          break;
-        case 'register':
-          out[operand.name] = decodeRegister(actualOperand);
-          break;
-        case 'unknown':
-          out[operand.name] = c.getValue(actualOperand);
-          break;
-        case 'symbol-table':
-        case 'scope':
-          out[operand.name] = `<scope ${actualOperand}>`;
-          break;
-        default:
-          throw new Error(`Unexpected operand type ${operand.type} for debug output`);
+      return { name: `{unknown ${op.type}}`, params: fromRaw(out), meta };
+    } else {
+      for (const [index, operand] of enumerate(metadata.ops)) {
+        const info = new DebugOperandInfo(operand, getOperand(op, index), constants, meta);
+        out[operand.name] = info.toDebug();
       }
+      return { name: metadata.name, params: fromRaw(out), meta };
     }
-
-    return [metadata.name, out];
   }
 
-  return undefined;
+  unreachable(`BUG: Don't try to debug opcodes while trace is disabled`);
 }
 
-function opcodeOperand(opcode: RuntimeOp, index: number): number {
+function getOperand(op: OpSnapshot, index: 0 | 1 | 2): number {
   switch (index) {
     case 0:
-      return opcode.op1;
+      return op.op1;
     case 1:
-      return opcode.op2;
+      return op.op2;
     case 2:
-      return opcode.op3;
+      return op.op3;
+  }
+}
+
+function fromRaw(operands: Dict<RawDisassembledOperand>): Dict<SomeDisassembledOperand> {
+  return Object.fromEntries(
+    Object.entries(operands).map(([name, raw]) => [name, DisassembledOperand.of(raw)])
+  );
+}
+
+export function decodeCurry(curry: number): 'component' | 'helper' | 'modifier' {
+  switch (curry) {
+    case CURRIED_COMPONENT:
+      return 'component';
+    case CURRIED_HELPER:
+      return 'helper';
+    case CURRIED_MODIFIER:
+      return 'modifier';
     default:
-      throw new Error(`Unexpected operand index (must be 0-2)`);
+      throw Error(`Unexpected curry value: ${curry}`);
   }
 }
 
-function decodeRegister(register: Register): string {
+export function decodeRegister(register: number): RegisterName {
   switch (register) {
     case $pc:
-      return 'pc';
+      return '$pc';
     case $ra:
-      return 'ra';
+      return '$ra';
     case $fp:
-      return 'fp';
+      return '$fp';
     case $sp:
-      return 'sp';
+      return '$sp';
     case $s0:
-      return 's0';
+      return '$s0';
     case $s1:
-      return 's1';
+      return '$s1';
     case $t0:
-      return 't0';
+      return '$t0';
     case $t1:
-      return 't1';
+      return '$t1';
     case $v0:
-      return 'v0';
+      return '$v0';
+    default:
+      return `$bug${register}`;
   }
 }
 
-function decodePrimitive(primitive: number, constants: DebugConstants): Primitive {
+export function decodePrimitive(primitive: number, constants: DebugConstants): Primitive {
   if (primitive >= 0) {
     return constants.getValue(decodeHandle(primitive));
   }
diff --git a/packages/@glimmer/debug/lib/dism/operands.ts b/packages/@glimmer/debug/lib/dism/operands.ts
new file mode 100644
index 0000000000..fc0073e9f1
--- /dev/null
+++ b/packages/@glimmer/debug/lib/dism/operands.ts
@@ -0,0 +1,119 @@
+import type { BlockMetadata, DebugConstants } from '@glimmer/interfaces';
+import { decodeHandle } from '@glimmer/util';
+
+import type {RawDisassembledOperand} from '../debug';
+import type {
+  NonNullableOperandType,
+  NullableOperandType,
+  OperandLabel,
+  OperandType,
+} from '../utils';
+
+import {
+  decodeCurry,
+  decodePrimitive,
+  decodeRegister
+} from '../debug';
+
+interface DisassemblyState {
+  label: OperandLabel;
+  value: number;
+  constants: DebugConstants;
+  meta: BlockMetadata | null;
+}
+
+export type OperandDisassembler = (options: DisassemblyState) => RawDisassembledOperand;
+
+const todo: OperandDisassembler = ({ label, value }) => ['error:operand', value, { label }];
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Left<D extends Disassembler<any>> = D extends Disassembler<infer Added>
+  ? Exclude<OperandType, Added>
+  : never;
+
+type AllOperands = OperandType;
+
+class Disassembler<in out Added extends OperandType> {
+  static build(
+    builder: (disassembler: Disassembler<never>) => Disassembler<AllOperands>
+  ): Record<OperandType, OperandDisassembler> {
+    return builder(new Disassembler()).#disms as Record<OperandType, OperandDisassembler>;
+  }
+
+  readonly #disms: Record<string, OperandDisassembler>;
+
+  private constructor() {
+    this.#disms = {};
+  }
+
+  addNullable<const K extends Left<this> & NullableOperandType>(
+    names: K[],
+    dism: OperandDisassembler
+  ): Disassembler<Added | K | `${K}?`> {
+    for (const name of names) {
+      this.#disms[name] = dism;
+      this.#disms[`${name}?`] = dism;
+    }
+
+    return this as Disassembler<Added | K | `${K}?`>;
+  }
+
+  add<const K extends Left<this> & NonNullableOperandType>(
+    names: K[],
+    dism: OperandDisassembler
+  ): Disassembler<Added | K> {
+    const add = (name: K, dism: OperandDisassembler) => (this.#disms[name] = dism);
+    for (const name of names) {
+      add(name, dism);
+    }
+
+    return this;
+  }
+}
+
+export const OPERANDS = Disassembler.build((d) => {
+  return d
+    .add(['imm/u32', 'imm/i32', 'imm/u32{todo}', 'imm/i32{todo}'], ({ value }) => ['number', value])
+    .add(['const/i32[]'], ({ value, constants }) => [
+      'array',
+      constants.getArray<number[]>(value),
+      { kind: Number },
+    ])
+    .add(['const/bool'], ({ value }) => ['boolean', !!value])
+    .add(['imm/bool'], ({ value, constants }) => [
+      'boolean',
+      constants.getValue<boolean>(decodeHandle(value)),
+    ])
+    .add(['handle'], ({ constants, value }) => ['constant', constants.getValue<number>(value)])
+    .add(['imm/pc'], ({ value }) => ['instruction', value])
+    .add(['const/any[]'], ({ value, constants }) => ['array', constants.getArray<unknown[]>(value)])
+    .add(['const/primitive'], ({ value, constants }) => [
+      'primitive',
+      decodePrimitive(value, constants),
+    ])
+    .add(['register'], ({ value }) => ['register', decodeRegister(value)])
+    .add(['const/any'], ({ value, constants }) => ['dynamic', constants.getValue<unknown>(value)])
+    .add(['variable'], ({ value, meta }) => {
+      return ['variable', value, { name: meta?.debugSymbols?.at(value) ?? null }];
+    })
+    .add(['register/instruction'], ({ value }) => ['instruction', value])
+    .add(['imm/enum<curry>'], ({ value }) => ['enum<curry>', decodeCurry(value)])
+    .addNullable(['const/str'], ({ value, constants }) => [
+      'string',
+      constants.getValue<string>(value),
+    ])
+    .addNullable(['const/str[]'], ({ value, constants }) => [
+      'array',
+      constants.getArray<string[]>(value),
+      { kind: String },
+    ])
+    .add(['imm/block:handle'], todo)
+    .add(['const/definition'], todo)
+    .add(['const/fn'], todo)
+    .add(['instruction/absolute'], todo)
+    .add(['instruction/relative'], todo)
+    .add(['register/sN'], todo)
+    .add(['register/stack'], todo)
+    .add(['register/tN'], todo)
+    .add(['register/v0'], todo);
+});
diff --git a/packages/@glimmer/debug/lib/generated/op-list.ts b/packages/@glimmer/debug/lib/generated/op-list.ts
new file mode 100644
index 0000000000..31ca3cf168
--- /dev/null
+++ b/packages/@glimmer/debug/lib/generated/op-list.ts
@@ -0,0 +1,244 @@
+// This code was generated by $root/bin/opcodes.mts.
+// Do not change it manually.
+
+import type { VmOpMap } from '@glimmer/interfaces';
+
+export const DebugOpList = [
+  'PushFrame',
+  'PopFrame',
+  'Jump',
+  'ReturnTo',
+  'UnwindTypeFrame',
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  'PushBegin',
+  'Begin',
+  'Catch',
+  'Finally',
+  'InvokeVirtual',
+  'InvokeStatic',
+  'Start',
+  'Return',
+  'Helper',
+  'SetNamedVariables',
+  'SetBlocks',
+  'SetVariable',
+  'SetBlock',
+  'GetVariable',
+  'GetProperty',
+  'GetBlock',
+  'SpreadBlock',
+  'HasBlock',
+  'HasBlockParams',
+  'Concat',
+  'Constant',
+  'ConstantReference',
+  'Primitive',
+  'PrimitiveReference',
+  'ReifyU32',
+  'Dup',
+  'Pop',
+  'Load',
+  'Fetch',
+  'RootScope',
+  'VirtualRootScope',
+  'ChildScope',
+  'PopScope',
+  'Text',
+  'Comment',
+  'AppendHTML',
+  'AppendSafeHTML',
+  'AppendDocumentFragment',
+  'AppendNode',
+  'AppendText',
+  'OpenElement',
+  'OpenDynamicElement',
+  'PushRemoteElement',
+  'StaticAttr',
+  'DynamicAttr',
+  'ComponentAttr',
+  'FlushElement',
+  'CloseElement',
+  'PopRemoteElement',
+  'Modifier',
+  'BindDynamicScope',
+  'PushDynamicScope',
+  'PopDynamicScope',
+  'CompileBlock',
+  'PushBlockScope',
+  'PushSymbolTable',
+  'InvokeYield',
+  'JumpIf',
+  'JumpUnless',
+  'JumpEq',
+  'AssertSame',
+  'Enter',
+  'Exit',
+  'ToBoolean',
+  'EnterList',
+  'ExitList',
+  'Iterate',
+  'Main',
+  'ContentType',
+  'Curry',
+  'PushComponentDefinition',
+  'PushDynamicComponentInstance',
+  'ResolveDynamicComponent',
+  'ResolveCurriedComponent',
+  'PushArgs',
+  'PushEmptyArgs',
+  'PrepareArgs',
+  'CaptureArgs',
+  'CreateComponent',
+  'RegisterComponentDestructor',
+  'PutComponentOperations',
+  'GetComponentSelf',
+  'GetComponentTagName',
+  'GetComponentLayout',
+  'SetupForEval',
+  'PopulateLayout',
+  'InvokeComponentLayout',
+  'BeginComponentTransaction',
+  'CommitComponentTransaction',
+  'DidCreateElement',
+  'DidRenderLayout',
+  'Debugger',
+  'StaticComponentAttr',
+  'DynamicContentType',
+  'DynamicHelper',
+  'DynamicModifier',
+  'IfInline',
+  'Not',
+  'GetDynamicVar',
+  'Log',
+  'PushUnwindTarget',
+] as const satisfies { [P in keyof VmOpMap as VmOpMap[P]]: P };
+
+export type DebugOpList = [
+  'PushFrame',
+  'PopFrame',
+  'Jump',
+  'ReturnTo',
+  'UnwindTypeFrame',
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  null,
+  'PushBegin',
+  'Begin',
+  'Catch',
+  'Finally',
+  'InvokeVirtual',
+  'InvokeStatic',
+  'Start',
+  'Return',
+  'Helper',
+  'SetNamedVariables',
+  'SetBlocks',
+  'SetVariable',
+  'SetBlock',
+  'GetVariable',
+  'GetProperty',
+  'GetBlock',
+  'SpreadBlock',
+  'HasBlock',
+  'HasBlockParams',
+  'Concat',
+  'Constant',
+  'ConstantReference',
+  'Primitive',
+  'PrimitiveReference',
+  'ReifyU32',
+  'Dup',
+  'Pop',
+  'Load',
+  'Fetch',
+  'RootScope',
+  'VirtualRootScope',
+  'ChildScope',
+  'PopScope',
+  'Text',
+  'Comment',
+  'AppendHTML',
+  'AppendSafeHTML',
+  'AppendDocumentFragment',
+  'AppendNode',
+  'AppendText',
+  'OpenElement',
+  'OpenDynamicElement',
+  'PushRemoteElement',
+  'StaticAttr',
+  'DynamicAttr',
+  'ComponentAttr',
+  'FlushElement',
+  'CloseElement',
+  'PopRemoteElement',
+  'Modifier',
+  'BindDynamicScope',
+  'PushDynamicScope',
+  'PopDynamicScope',
+  'CompileBlock',
+  'PushBlockScope',
+  'PushSymbolTable',
+  'InvokeYield',
+  'JumpIf',
+  'JumpUnless',
+  'JumpEq',
+  'AssertSame',
+  'Enter',
+  'Exit',
+  'ToBoolean',
+  'EnterList',
+  'ExitList',
+  'Iterate',
+  'Main',
+  'ContentType',
+  'Curry',
+  'PushComponentDefinition',
+  'PushDynamicComponentInstance',
+  'ResolveDynamicComponent',
+  'ResolveCurriedComponent',
+  'PushArgs',
+  'PushEmptyArgs',
+  'PrepareArgs',
+  'CaptureArgs',
+  'CreateComponent',
+  'RegisterComponentDestructor',
+  'PutComponentOperations',
+  'GetComponentSelf',
+  'GetComponentTagName',
+  'GetComponentLayout',
+  'SetupForEval',
+  'PopulateLayout',
+  'InvokeComponentLayout',
+  'BeginComponentTransaction',
+  'CommitComponentTransaction',
+  'DidCreateElement',
+  'DidRenderLayout',
+  'Debugger',
+  'StaticComponentAttr',
+  'DynamicContentType',
+  'DynamicHelper',
+  'DynamicModifier',
+  'IfInline',
+  'Not',
+  'GetDynamicVar',
+  'Log',
+  'PushUnwindTarget',
+];
diff --git a/packages/@glimmer/debug/lib/metadata.ts b/packages/@glimmer/debug/lib/metadata.ts
index 1eb18f77bf..a25f8978f0 100644
--- a/packages/@glimmer/debug/lib/metadata.ts
+++ b/packages/@glimmer/debug/lib/metadata.ts
@@ -1,45 +1,22 @@
-import type { Dict, Nullable, PresentArray } from '@glimmer/interfaces';
+import type { DebugVmSnapshot, Dict, PresentArray } from '@glimmer/interfaces';
 
-// TODO: How do these map onto constant and machine types?
-export const OPERAND_TYPES = [
-  'u32',
-  'i32',
-  'owner',
-  'handle',
-  'str',
-  'option-str',
-  'array',
-  'str-array',
-  'bool',
-  'primitive',
-  'register',
-  'unknown',
-  'symbol-table',
-  'scope',
-];
+import type { UNCHANGED } from './stack/params';
+import type { Op, OperandList, ShorthandStackReturn } from './utils';
 
-function isOperandType(s: string): s is OperandType {
-  return OPERAND_TYPES.indexOf(s as any) !== -1;
-}
-
-export type OperandType = (typeof OPERAND_TYPES)[number];
+export type UncheckedStack = { type: 'unchecked'; reason: string };
+export type StackCheck = DynamicStackFn | UncheckedStack;
 
-export interface Operand {
-  type: OperandType;
-  name: string;
+export function isUnchecked(check: StackCheck): check is UncheckedStack {
+  return typeof check !== 'function';
 }
 
-export type OperandList = ([] | [Operand] | [Operand, Operand] | [Operand, Operand, Operand]) &
-  Operand[];
-
-export interface NormalizedMetadata {
+export interface OpcodeMetadata {
   name: string;
   mnemonic: string;
   before: null;
-  stackChange: Nullable<number>;
+  stack: DynamicStackFn;
   ops: OperandList;
   operands: number;
-  check: boolean;
 }
 
 export type Stack = [string[], string[]];
@@ -56,133 +33,9 @@ export interface RawOperandMetadata {
 export type OperandName = `${string}:${string}`;
 export type RawOperandFormat = OperandName | PresentArray<OperandName>;
 
-export function normalize(key: string, input: RawOperandMetadata): NormalizedMetadata {
-  let name: string;
-
-  if (input.format === undefined) {
-    throw new Error(`Missing format in ${JSON.stringify(input)}`);
-  }
-
-  if (Array.isArray(input.format)) {
-    name = input.format[0];
-  } else {
-    name = input.format;
-  }
-
-  let ops: OperandList = Array.isArray(input.format) ? operands(input.format.slice(1)) : [];
-
-  return {
-    name,
-    mnemonic: key,
-    before: null,
-    stackChange: stackChange(input['operand-stack']),
-    ops,
-    operands: ops.length,
-    check: input.skip === true ? false : true,
-  };
-}
-
-function stackChange(stack?: Stack): Nullable<number> {
-  if (stack === undefined) {
-    return 0;
-  }
-
-  let before = stack[0];
-  let after = stack[1];
-
-  if (hasRest(before) || hasRest(after)) {
-    return null;
-  }
-
-  return after.length - before.length;
-}
-
-function hasRest(input: string[]): boolean {
-  if (!Array.isArray(input)) {
-    throw new Error(`Unexpected stack entry: ${JSON.stringify(input)}`);
-  }
-  return input.some((s) => s.slice(-3) === '...');
-}
-
-function operands(input: `${string}:${string}`[]): OperandList {
-  if (!Array.isArray(input)) {
-    throw new Error(`Expected operands array, got ${JSON.stringify(input)}`);
-  }
-  return input.map(op) as OperandList;
-}
-
-function op(input: `${string}:${string}`): Operand {
-  let [name, type] = input.split(':') as [string, string];
-
-  if (isOperandType(type)) {
-    return { name, type };
-  } else {
-    throw new Error(`Expected operand, found ${JSON.stringify(input)}`);
-  }
-}
-
 export interface NormalizedOpcodes {
-  readonly machine: Dict<NormalizedMetadata>;
-  readonly syscall: Dict<NormalizedMetadata>;
-}
-
-export function normalizeAll(parsed: {
-  machine: Dict<RawOperandMetadata>;
-  syscall: Dict<RawOperandMetadata>;
-}): NormalizedOpcodes {
-  let machine = normalizeParsed(parsed.machine);
-  let syscall = normalizeParsed(parsed.syscall);
-
-  return { machine, syscall };
-}
-
-export function normalizeParsed(parsed: Dict<RawOperandMetadata>): Dict<NormalizedMetadata> {
-  let out = Object.create(null) as Dict<NormalizedMetadata>;
-
-  for (const [key, value] of Object.entries(parsed)) {
-    out[key] = normalize(key, value);
-  }
-
-  return out;
-}
-
-export function buildEnum(
-  name: string,
-  parsed: Dict<NormalizedMetadata>,
-  offset: number,
-  max?: number
-): { enumString: string; predicate: string } {
-  let e = [`export enum ${name} {`];
-
-  let last: number;
-
-  Object.values(parsed).forEach((value, i) => {
-    e.push(`  ${value.name} = ${offset + i},`);
-    last = i;
-  });
-
-  e.push(`  Size = ${last! + offset + 1},`);
-  e.push('}');
-
-  let enumString = e.join('\n');
-
-  let predicate;
-
-  if (max) {
-    predicate = strip`
-      export function is${name}(value: number): value is ${name} {
-        return value >= ${offset} && value <= ${max};
-      }
-    `;
-  } else {
-    predicate = strip`
-      export function is${name}(value: number): value is ${name} {
-        return value >= ${offset};
-      }
-    `;
-  }
-
-  return { enumString, predicate };
+  readonly machine: Dict<OpcodeMetadata>;
+  readonly syscall: Dict<OpcodeMetadata>;
 }
 
 export function strip(strings: TemplateStringsArray, ...args: unknown[]) {
@@ -217,7 +70,7 @@ export function strip(strings: TemplateStringsArray, ...args: unknown[]) {
 export const META_KIND = ['METADATA', 'MACHINE_METADATA'];
 export type META_KIND = (typeof META_KIND)[number];
 
-export function buildSingleMeta<D extends Dict<NormalizedMetadata>>(
+export function buildSingleMeta<D extends Dict<OpcodeMetadata>>(
   kind: META_KIND,
   all: D,
   key: keyof D
@@ -249,7 +102,7 @@ function stringify(o: unknown, pad: number): string {
   return out.join('\n');
 }
 
-export function buildMetas(kind: META_KIND, all: Dict<NormalizedMetadata>): string {
+export function buildMetas(kind: META_KIND, all: Dict<OpcodeMetadata>): string {
   let out = [];
 
   for (let key of Object.keys(all)) {
@@ -258,3 +111,27 @@ export function buildMetas(kind: META_KIND, all: Dict<NormalizedMetadata>): stri
 
   return out.join('\n\n');
 }
+
+/**
+ * Takes an operand and dynamically computes the stack change.
+ *
+ * If the function returns a number, that number is used as the stack change
+ * (and stack parameters are ignored).
+ *
+ * If the return value is an array:
+ *
+ * - If the first value is `UNCHANGED`, the stack change is the length of the
+ *   return values after `UNCHANGED`.
+ * - Otherwise, the stack change is the length of the return values minus
+ *   the length of the parameters.
+ */
+export type DynamicStackFnSpec = (
+  op: Op,
+  state: DebugVmSnapshot
+) => [typeof UNCHANGED, ...ShorthandStackReturn[]] | ShorthandStackReturn[] | number;
+export type DynamicStackFn = (op: Op, state: DebugVmSnapshot) => StackSpec;
+
+export type StackSpec =
+  | { type: 'delta'; delta: number }
+  | { type: 'operations'; pop: number; push: number; peek: number; delta: number }
+  | { type: 'unchecked'; reason: string; delta?: undefined };
diff --git a/packages/@glimmer/debug/lib/opcode-metadata.ts b/packages/@glimmer/debug/lib/opcode-metadata.ts
index 9a1f8de3f6..d6d2ffd919 100644
--- a/packages/@glimmer/debug/lib/opcode-metadata.ts
+++ b/packages/@glimmer/debug/lib/opcode-metadata.ts
@@ -1,1342 +1,399 @@
-/* This file is generated by build/debug.js */
+import type { VmOp } from '@glimmer/interfaces';
 
-import type { Nullable, VmMachineOp, VmOp } from "@glimmer/interfaces";
-import { MachineOp, Op } from '@glimmer/vm';
+import type { OpcodeMetadata } from './metadata';
 
-import type { NormalizedMetadata } from './metadata';
+import { define } from './stack/define-metadata';
+import { UNCHANGED } from './stack/params';
+import { MetadataBuilder, RESERVED } from './utils';
 
-function fillNulls<T>(count: number): T[] {
-  let arr = new Array(count);
-
-  for (let i = 0; i < count; i++) {
-    arr[i] = null;
-  }
-
-  return arr;
+export function opcodeMetadata(op: VmOp): OpcodeMetadata {
+  return METADATA[op];
 }
 
-export function opcodeMetadata(
-  op: VmMachineOp | VmOp,
-  isMachine: 0 | 1
-): Nullable<NormalizedMetadata> {
-  let value = isMachine ? MACHINE_METADATA[op] : METADATA[op];
-
-  return value || null;
-}
-
-const METADATA: Nullable<NormalizedMetadata>[] = fillNulls(Op.Size);
-const MACHINE_METADATA: Nullable<NormalizedMetadata>[] = fillNulls(MachineOp.Size);
-MACHINE_METADATA[MachineOp.PushFrame] = {
-  name: 'PushFrame',
-  mnemonic: 'pushf',
-  before: null,
-  stackChange: 2,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-MACHINE_METADATA[MachineOp.PopFrame] = {
-  name: 'PopFrame',
-  mnemonic: 'popf',
-  before: null,
-  stackChange: -2,
-  ops: [],
-  operands: 0,
-  check: false,
-};
-
-MACHINE_METADATA[MachineOp.InvokeVirtual] = {
-  name: 'InvokeVirtual',
-  mnemonic: 'vcall',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-MACHINE_METADATA[MachineOp.InvokeStatic] = {
-  name: 'InvokeStatic',
-  mnemonic: 'scall',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'offset',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-MACHINE_METADATA[MachineOp.Jump] = {
-  name: 'Jump',
-  mnemonic: 'goto',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'to',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-MACHINE_METADATA[MachineOp.Return] = {
-  name: 'Return',
-  mnemonic: 'ret',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: false,
-};
-
-MACHINE_METADATA[MachineOp.ReturnTo] = {
-  name: 'ReturnTo',
-  mnemonic: 'setra',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'offset',
-      type: 'i32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-METADATA[Op.Helper] = {
-  name: 'Helper',
-  mnemonic: 'ncall',
-  before: null,
-  stackChange: null,
-  ops: [
-    {
-      name: 'helper',
-      type: 'handle',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.DynamicHelper] = {
-  name: 'DynamicHelper',
-  mnemonic: 'dynamiccall',
-  before: null,
-  stackChange: null,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.SetNamedVariables] = {
-  name: 'SetNamedVariables',
-  mnemonic: 'vsargs',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'register',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.SetBlocks] = {
-  name: 'SetBlocks',
-  mnemonic: 'vbblocks',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'register',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.SetVariable] = {
-  name: 'SetVariable',
-  mnemonic: 'sbvar',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'symbol',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.SetBlock] = {
-  name: 'SetBlock',
-  mnemonic: 'sblock',
-  before: null,
-  stackChange: -3,
-  ops: [
-    {
-      name: 'symbol',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.GetVariable] = {
-  name: 'GetVariable',
-  mnemonic: 'symload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'symbol',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.GetProperty] = {
-  name: 'GetProperty',
-  mnemonic: 'getprop',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'property',
-      type: 'str',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.GetBlock] = {
-  name: 'GetBlock',
-  mnemonic: 'blockload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'block',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.SpreadBlock] = {
-  name: 'SpreadBlock',
-  mnemonic: 'blockspread',
-  before: null,
-  stackChange: 2,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.HasBlock] = {
-  name: 'HasBlock',
-  mnemonic: 'hasblockload',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.HasBlockParams] = {
-  name: 'HasBlockParams',
-  mnemonic: 'hasparamsload',
-  before: null,
-  stackChange: -2,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Concat] = {
-  name: 'Concat',
-  mnemonic: 'concat',
-  before: null,
-  stackChange: null,
-  ops: [
-    {
-      name: 'count',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.IfInline] = {
-  name: 'IfInline',
-  mnemonic: 'ifinline',
-  before: null,
-  stackChange: -2,
-  ops: [
-    {
-      name: 'count',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Not] = {
-  name: 'Not',
-  mnemonic: 'not',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'count',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Constant] = {
-  name: 'Constant',
-  mnemonic: 'rconstload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'constant',
-      type: 'unknown',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.ConstantReference] = {
-  name: 'ConstantReference',
-  mnemonic: 'rconstrefload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'constant',
-      type: 'unknown',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Primitive] = {
-  name: 'Primitive',
-  mnemonic: 'pconstload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'constant',
-      type: 'primitive',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PrimitiveReference] = {
-  name: 'PrimitiveReference',
-  mnemonic: 'ptoref',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.ReifyU32] = {
-  name: 'ReifyU32',
-  mnemonic: 'reifyload',
-  before: null,
-  stackChange: 1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Dup] = {
-  name: 'Dup',
-  mnemonic: 'dup',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'register',
-      type: 'u32',
-    },
-    {
-      name: 'offset',
-      type: 'u32',
-    },
-  ],
-  operands: 2,
-  check: true,
-};
-
-METADATA[Op.Pop] = {
-  name: 'Pop',
-  mnemonic: 'pop',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'count',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: false,
-};
-
-METADATA[Op.Load] = {
-  name: 'Load',
-  mnemonic: 'put',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'register',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Fetch] = {
-  name: 'Fetch',
-  mnemonic: 'regload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'register',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.RootScope] = {
-  name: 'RootScope',
-  mnemonic: 'rscopepush',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'symbols',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.VirtualRootScope] = {
-  name: 'VirtualRootScope',
-  mnemonic: 'vrscopepush',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'register',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.ChildScope] = {
-  name: 'ChildScope',
-  mnemonic: 'cscopepush',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PopScope] = {
-  name: 'PopScope',
-  mnemonic: 'scopepop',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Text] = {
-  name: 'Text',
-  mnemonic: 'apnd_text',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'contents',
-      type: 'str',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Comment] = {
-  name: 'Comment',
-  mnemonic: 'apnd_comment',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'contents',
-      type: 'str',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.AppendHTML] = {
-  name: 'AppendHTML',
-  mnemonic: 'apnd_dynhtml',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.AppendSafeHTML] = {
-  name: 'AppendSafeHTML',
-  mnemonic: 'apnd_dynshtml',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.AppendDocumentFragment] = {
-  name: 'AppendDocumentFragment',
-  mnemonic: 'apnd_dynfrag',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.AppendNode] = {
-  name: 'AppendNode',
-  mnemonic: 'apnd_dynnode',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.AppendText] = {
-  name: 'AppendText',
-  mnemonic: 'apnd_dyntext',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.OpenElement] = {
-  name: 'OpenElement',
-  mnemonic: 'apnd_tag',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'tag',
-      type: 'str',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.OpenDynamicElement] = {
-  name: 'OpenDynamicElement',
-  mnemonic: 'apnd_dyntag',
-  before: null,
-  stackChange: -1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PushRemoteElement] = {
-  name: 'PushRemoteElement',
-  mnemonic: 'apnd_remotetag',
-  before: null,
-  stackChange: -3,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.StaticAttr] = {
-  name: 'StaticAttr',
-  mnemonic: 'apnd_attr',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'name',
-      type: 'str',
-    },
-    {
-      name: 'value',
-      type: 'str',
-    },
-    {
-      name: 'namespace',
-      type: 'option-str',
-    },
-  ],
-  operands: 3,
-  check: true,
-};
-
-METADATA[Op.DynamicAttr] = {
-  name: 'DynamicAttr',
-  mnemonic: 'apnd_dynattr',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'name',
-      type: 'str',
-    },
-    {
-      name: 'trusting',
-      type: 'bool',
-    },
-    {
-      name: 'namespace',
-      type: 'option-str',
-    },
-  ],
-  operands: 3,
-  check: true,
-};
-
-METADATA[Op.ComponentAttr] = {
-  name: 'ComponentAttr',
-  mnemonic: 'apnd_cattr',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'name',
-      type: 'str',
-    },
-    {
-      name: 'trusting',
-      type: 'bool',
-    },
-    {
-      name: 'namespace',
-      type: 'option-str',
-    },
-  ],
-  operands: 3,
-  check: true,
-};
-
-METADATA[Op.FlushElement] = {
-  name: 'FlushElement',
-  mnemonic: 'apnd_flushtag',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.CloseElement] = {
-  name: 'CloseElement',
-  mnemonic: 'apnd_closetag',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PopRemoteElement] = {
-  name: 'PopRemoteElement',
-  mnemonic: 'apnd_closeremotetag',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Modifier] = {
-  name: 'Modifier',
-  mnemonic: 'apnd_modifier',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'helper',
-      type: 'handle',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.BindDynamicScope] = {
-  name: 'BindDynamicScope',
-  mnemonic: 'setdynscope',
-  before: null,
-  stackChange: null,
-  ops: [
-    {
-      name: 'names',
-      type: 'str-array',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PushDynamicScope] = {
-  name: 'PushDynamicScope',
-  mnemonic: 'dynscopepush',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PopDynamicScope] = {
-  name: 'PopDynamicScope',
-  mnemonic: 'dynscopepop',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.CompileBlock] = {
-  name: 'CompileBlock',
-  mnemonic: 'cmpblock',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PushBlockScope] = {
-  name: 'PushBlockScope',
-  mnemonic: 'scopeload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'scope',
-      type: 'scope',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PushSymbolTable] = {
-  name: 'PushSymbolTable',
-  mnemonic: 'dsymload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'table',
-      type: 'symbol-table',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.InvokeYield] = {
-  name: 'InvokeYield',
-  mnemonic: 'invokeyield',
-  before: null,
-  stackChange: null,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.JumpIf] = {
-  name: 'JumpIf',
-  mnemonic: 'iftrue',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'to',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.JumpUnless] = {
-  name: 'JumpUnless',
-  mnemonic: 'iffalse',
-  before: null,
-  stackChange: -1,
-  ops: [
-    {
-      name: 'to',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.JumpEq] = {
-  name: 'JumpEq',
-  mnemonic: 'ifeq',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'to',
-      type: 'i32',
-    },
-    {
-      name: 'comparison',
-      type: 'i32',
-    },
-  ],
-  operands: 2,
-  check: true,
-};
-
-METADATA[Op.AssertSame] = {
-  name: 'AssertSame',
-  mnemonic: 'assert_eq',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Enter] = {
-  name: 'Enter',
-  mnemonic: 'blk_start',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'args',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Exit] = {
-  name: 'Exit',
-  mnemonic: 'blk_end',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.ToBoolean] = {
-  name: 'ToBoolean',
-  mnemonic: 'anytobool',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.EnterList] = {
-  name: 'EnterList',
-  mnemonic: 'list_start',
-  before: null,
-  stackChange: null,
-  ops: [
-    {
-      name: 'address',
-      type: 'u32',
-    },
-    {
-      name: 'address',
-      type: 'u32',
-    },
-  ],
-  operands: 2,
-  check: true,
-};
-
-METADATA[Op.ExitList] = {
-  name: 'ExitList',
-  mnemonic: 'list_end',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Iterate] = {
-  name: 'Iterate',
-  mnemonic: 'iter',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'end',
-      type: 'u32',
-    },
-  ],
-  operands: 1,
-  check: false,
-};
-
-METADATA[Op.Main] = {
-  name: 'Main',
-  mnemonic: 'main',
-  before: null,
-  stackChange: -2,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.ContentType] = {
-  name: 'ContentType',
-  mnemonic: 'ctload',
-  before: null,
-  stackChange: 1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.DynamicContentType] = {
-  name: 'DynamicContentType',
-  mnemonic: 'dctload',
-  before: null,
-  stackChange: 1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.Curry] = {
-  name: 'Curry',
-  mnemonic: 'curry',
-  before: null,
-  stackChange: null,
-  ops: [
-    {
-      name: 'type',
-      type: 'u32',
-    },
-    {
-      name: 'is-strict',
-      type: 'bool',
-    },
-  ],
-  operands: 2,
-  check: true,
-};
-
-METADATA[Op.PushComponentDefinition] = {
-  name: 'PushComponentDefinition',
-  mnemonic: 'cmload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'spec',
-      type: 'handle',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PushDynamicComponentInstance] = {
-  name: 'PushDynamicComponentInstance',
-  mnemonic: 'dciload',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.ResolveDynamicComponent] = {
-  name: 'ResolveDynamicComponent',
-  mnemonic: 'cdload',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'owner',
-      type: 'owner',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PushArgs] = {
-  name: 'PushArgs',
-  mnemonic: 'argsload',
-  before: null,
-  stackChange: null,
-  ops: [
-    {
-      name: 'names',
-      type: 'str-array',
-    },
-    {
-      name: 'block-names',
-      type: 'str-array',
-    },
-    {
-      name: 'flags',
-      type: 'u32',
-    },
-  ],
-  operands: 3,
-  check: true,
-};
-
-METADATA[Op.PushEmptyArgs] = {
-  name: 'PushEmptyArgs',
-  mnemonic: 'emptyargsload',
-  before: null,
-  stackChange: 1,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PopArgs] = {
-  name: 'PopArgs',
-  mnemonic: 'argspop',
-  before: null,
-  stackChange: null,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.PrepareArgs] = {
-  name: 'PrepareArgs',
-  mnemonic: 'argsprep',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: false,
-};
-
-METADATA[Op.CaptureArgs] = {
-  name: 'CaptureArgs',
-  mnemonic: 'argscapture',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.CreateComponent] = {
-  name: 'CreateComponent',
-  mnemonic: 'comp_create',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'flags',
-      type: 'u32',
-    },
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 2,
-  check: true,
-};
-
-METADATA[Op.RegisterComponentDestructor] = {
-  name: 'RegisterComponentDestructor',
-  mnemonic: 'comp_dest',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PutComponentOperations] = {
-  name: 'PutComponentOperations',
-  mnemonic: 'comp_elops',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.GetComponentSelf] = {
-  name: 'GetComponentSelf',
-  mnemonic: 'comp_selfload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.GetComponentTagName] = {
-  name: 'GetComponentTagName',
-  mnemonic: 'comp_tagload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.GetComponentLayout] = {
-  name: 'GetComponentLayout',
-  mnemonic: 'comp_layoutload',
-  before: null,
-  stackChange: 2,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.BindEvalScope] = {
-  name: 'BindEvalScope',
-  mnemonic: 'eval_scope',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.SetupForEval] = {
-  name: 'SetupForEval',
-  mnemonic: 'eval_setup',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.PopulateLayout] = {
-  name: 'PopulateLayout',
-  mnemonic: 'comp_layoutput',
-  before: null,
-  stackChange: -2,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.InvokeComponentLayout] = {
-  name: 'InvokeComponentLayout',
-  mnemonic: 'comp_invokelayout',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.BeginComponentTransaction] = {
-  name: 'BeginComponentTransaction',
-  mnemonic: 'comp_begin',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.CommitComponentTransaction] = {
-  name: 'CommitComponentTransaction',
-  mnemonic: 'comp_commit',
-  before: null,
-  stackChange: 0,
-  ops: [],
-  operands: 0,
-  check: true,
-};
-
-METADATA[Op.DidCreateElement] = {
-  name: 'DidCreateElement',
-  mnemonic: 'comp_created',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.DidRenderLayout] = {
-  name: 'DidRenderLayout',
-  mnemonic: 'comp_rendered',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'state',
-      type: 'register',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.ResolveMaybeLocal] = {
-  name: 'ResolveMaybeLocal',
-  mnemonic: 'eval_varload',
-  before: null,
-  stackChange: 1,
-  ops: [
-    {
-      name: 'local',
-      type: 'str',
-    },
-  ],
-  operands: 1,
-  check: true,
-};
-
-METADATA[Op.Debugger] = {
-  name: 'Debugger',
-  mnemonic: 'debugger',
-  before: null,
-  stackChange: 0,
-  ops: [
-    {
-      name: 'symbols',
-      type: 'str-array',
-    },
-    {
-      name: 'debugInfo',
-      type: 'array',
-    },
-  ],
-  operands: 2,
-  check: true,
-};
+export const PushFrame = define('PushFrame', (d) =>
+  d.ops().pushes('register/ra', 'register/fp').reads('$fp', '$sp').changes('$fp')
+);
+
+export const PopFrame = define('PopFrame', (d) =>
+  d
+    .peeks('ra', 'register/ra', { from: '$fp' })
+    .peeks('fp', 'register/fp', { from: '$fp' })
+    .changesFrame()
+    .reads('$fp')
+    .changes('$ra', '$sp', '$fp')
+);
+
+export const Jump = define('Jump', (d) =>
+  d.ops(['to', 'instruction/relative']).unchanged().reads('$pc').changes('$pc')
+);
+
+export const ReturnTo = define('ReturnTo', (d) =>
+  d.ops(['to', 'instruction/relative']).unchanged().reads('$pc').changes('$ra')
+);
+
+export const PopTryFrame = define('Finally', (d) =>
+  d
+    .ops(['catchPc', 'instruction/relative'])
+    .pops('handler', 'ref/function?')
+    .reads('$pc', '$sp', '$fp')
+    .changes('$up')
+);
+
+export const PushTryFrame = define.throws('Begin', (d) =>
+  d
+    .ops(['catchPc', 'instruction/relative'])
+    .pops('handler', 'ref/function?')
+    .pushes('ref/any')
+    .reads('$pc', '$sp', '$fp')
+    .changes('$up')
+);
+
+export const InvokeVirtual = define('InvokeVirtual', (d) =>
+  d.pops('block', 'handle/block').reads('$pc').changes('$ra', '$pc')
+);
+
+export const InvokeStatic = define('InvokeStatic', (d) =>
+  d.ops(['handle', 'handle/block']).unchanged().reads('$pc').changes('$ra', '$pc')
+);
+
+export const Start = define('Start', (d) => d.unchanged());
+export const Return = define('Return', (d) => d.unchanged().reads('$ra').changes('$pc'));
+
+export const Helper = define.throws('Helper', (d) =>
+  d
+    .ops(['helper', 'const/function'])
+    .pops('args', 'args')
+    .peeks('args', 'stack/args')
+    .reads('owner', 'dynamic-scope/value')
+    .changes('destroyable', ['$v0', 'ref/any'])
+);
+
+export const GetVariable = define('GetVariable', (d) =>
+  d.ops(['symbol', 'variable']).pushes('ref/any').reads(['lexical-scope/value', 'variable'])
+);
+
+export const SetVariable = define('SetVariable', (d) =>
+  d.ops(['symbol', 'variable']).pops('expr', 'ref/any').changes(['lexical-scope/value', 'variable'])
+);
+
+export const SetBlock = define('SetBlock', (d) =>
+  d
+    .ops(['symbol', 'variable/block'])
+    .pops('handle', 'block/compilable')
+    .pops('scope', 'scope')
+    .pops('table', 'table/block')
+    .changes(['lexical-scope/block', 'variable/block'])
+);
+
+export const PushRootScope = define('RootScope', (d) =>
+  d.ops(['symbols', 'unsigned']).reads('owner').changes('scope')
+);
+
+export const GetProperty = define('GetProperty', (d) =>
+  d.ops(['key', 'const/string']).pops('expr', 'ref/any').pushes('ref/any')
+);
+
+export const GetBlock = define('GetBlock', (d) =>
+  d
+    .ops(['block', 'variable/block'])
+    .pushes('block/scope?')
+    .reads(['lexical-scope/block', 'block/scope?'])
+);
+
+export const SpreadBlock = define('SpreadBlock', (d) =>
+  // @todo this could be an undefined reference
+  d.pops('block', 'block/scope?').pushes('table/block?', 'block/scope?', 'block/compilable?')
+);
+
+export const HasBlock = define('HasBlock', (d) =>
+  d.pops('block', 'block/scope?').pushes('ref/boolean')
+);
+
+export const HasBlockParams = define('HasBlockParams', (d) =>
+  d
+    .pops('block', 'block/compilable?')
+    .pops('scope', 'block/scope?')
+    .pops('table', 'table/block?')
+    .pushes('ref/boolean')
+);
+
+// @active
+const METADATA = MetadataBuilder.build(({ add, stack }) =>
+  add(`PushFrame as pushf`, stack.params([]).returns(['register/instruction', 'register/stack']))
+    .add(
+      `PopFrame as popf`,
+      stack.dynamic({ reason: 'frames pop an arbitrary number of stack elements' })
+    )
+    .add(`Jump as goto`, ['to:imm/u32'])
+    .add(`ReturnTo as setra`, ['offset:imm/pc'])
+    .add(`UnwindTypeFrame as unwind`)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+    .add(RESERVED)
+
+    .add(
+      `PushBegin as push<-begin`,
+      ['catch:imm/pc'],
+      stack.params(['handler:reference/any']).returns(['reference/any'])
+    )
+    .add(`Begin as begin`)
+    .add(`Catch as catch`)
+    .add(`Finally as finally`)
+    .add(`InvokeVirtual as vcall`, stack.delta(-1))
+    .add(`InvokeStatic as scall`, ['offset:imm/u32'])
+    .add(`Start as start`)
+    .add(`Return as ret`)
+    .add(`Helper as ncall`, [`helper:handle`], stack.params(['args:args']).returns([]))
+    .add(`SetNamedVariables as vsargs`, [`register:register`])
+    .add(`SetBlocks as vbblocks`, [`register:register`])
+    .add(`SetVariable as sbvar`, [`symbol:variable`], stack.delta(-1))
+    .add(`SetBlock as sbblock`, [`symbol:variable`], stack.delta(-3))
+    .add(`GetVariable as symload`, [`symbol:variable`], stack.params([]).returns(['reference/any']))
+
+    .add(
+      `GetProperty as replace<-prop`,
+      [`property:const/str`],
+      stack.params(['obj:reference/any']).returns(['reference/any'])
+    )
+    .add(`GetBlock as push<-scope`, [`block:variable`], stack.delta(+1))
+    .add(`SpreadBlock as push2<-block`, stack.delta(+2))
+    .add(`HasBlock as store<-hasblock`)
+    .add(
+      `HasBlockParams as pop2->hasparam`,
+      stack.params(['block:block/handle', 'scope:scope', 'table:block/table?']).returns(['bool'])
+    )
+    .add(
+      `Concat as concat`,
+      ['count:imm/u32'],
+      stack.dynamic(({ op1 }) => ({
+        type: 'operations',
+        peek: 0,
+        pop: op1,
+        push: 1,
+        delta: -op1 + 1,
+      }))
+    )
+    .add(`Constant as rconstload`, ['constant:const/any'], stack.delta(+1))
+    .add(`ConstantReference as rconstrefload`, ['constant:const/any'], stack.delta(+1))
+    .add(`Primitive as pconstload`, ['constant:const/primitive'], stack.delta(+1))
+    .add(`PrimitiveReference as ptoref`, [])
+    .add(`ReifyU32 as reifyload`, stack.delta(+1))
+    .add(`Dup as push_dup`, ['register:register', 'offset:imm/u32'], stack.delta(+1))
+    .add(
+      `Pop as pop`,
+      ['count:imm/u32'],
+      stack.dynamic(({ op1 }) => ({ type: 'operations', pop: op1, push: 0, peek: 0, delta: -op1 }))
+    )
+    .add(`Load as stack->store`, ['register:register'], stack.delta(-1))
+    .add(`Fetch as load->stack`, ['register:register'], stack.delta(+1))
+    .add(`RootScope as rscopepush`, ['size:imm/u32'])
+    .add(`VirtualRootScope as vrscopepush`, ['register:register'])
+    .add(`ChildScope as cscopepush`, [])
+    .add(`PopScope as popscope`)
+
+    // apnd_* get the values from a register (and therefore leave the stack untouched)
+    // apnd_dyn* get the values from the stack (and therefore decrement the stack)
+
+    .add(`Text as apnd_text`, ['contents:const/str'])
+    .add(`Comment as apend_comment`, ['contents:const/str'])
+    .add(`AppendHTML as apnd_dynhtml`, stack.delta(-1))
+    .add(`AppendSafeHTML as apnd_dynshtml`, stack.delta(-1))
+    .add(`AppendDocumentFragment as apnd_dynfrag`, stack.delta(-1))
+    .add(`AppendNode as apnd_dynnode`, [], stack.delta(-1))
+    .add(`AppendText as apnd_dyntext`, [], stack.delta(-1))
+    .add(`OpenElement as apnd_tag`, ['tag:const/str'])
+    .add(`OpenDynamicElement as apnd_dyntag`, [], stack.delta(-1))
+    .add(`PushRemoteElement as apnd_remotetag`, stack.delta(-3))
+    .add(`StaticAttr as apnd_attr`, ['name:const/str', 'value:const/str', 'namespace:const/str?'])
+    .add(
+      `DynamicAttr as apnd_dynattr`,
+      ['name:const/str', 'value:const/str'],
+      stack.params(['value:reference/any']).returns([])
+    )
+    .add(
+      `ComponentAttr as apnd_compattr`,
+      ['name:const/str', 'value:const/str', 'namespace:const/str?'],
+      stack.params(['value:reference/any']).returns([])
+    )
+    .add(`FlushElement as apnd_flush`, [])
+    .add(`CloseElement as apnd_close`, [])
+    .add(`PopRemoteElement as apnd_remoteclose`, [])
+    // @audit what's this parameter?
+    .add(`Modifier as apnd_modifier`, ['helper:const/fn'], stack.delta(-1))
+    .add(
+      `BindDynamicScope as setdynscope`,
+      ['names:const/str[]'],
+      stack.dynamic(({ op1 }, state) => {
+        const names = state.constant.constants.getArray<string[]>(op1);
+        return { type: 'operations', pop: names.length, push: 0, peek: 0, delta: -names.length };
+      })
+    )
+    .add(`PushDynamicScope as dynscopepush`)
+    .add(`PopDynamicScope as dynscopepop`)
+    .add(
+      `CompileBlock as cmpblock`,
+      stack.params(['template:block/template']).returns(['block/handle'])
+    )
+    .add(`PushBlockScope as push<-scope`, stack.params([]).returns(['scope']))
+    .add(`PushSymbolTable as push<-table`, stack.params([]).returns(['table']))
+    .add(
+      `InvokeYield as invoke`,
+      stack
+        .params(['table:block/table', 'scope:scope', 'block:block/handle?', 'args:args'])
+        // ra, fp
+        .returns(['register/stack', 'register/stack'])
+    )
+    .add(
+      `JumpIf as pop->cgoto`,
+      ['target:register/instruction'],
+      stack.params(['condition:reference/bool']).returns([])
+    )
+    .add(
+      `JumpUnless as pop->cngoto`,
+      ['target:register/instruction'],
+      stack.params(['condition:reference/bool']).returns([])
+    )
+    .add(
+      `JumpEq as gotoeq`,
+      ['target:register/instruction', 'comparison:instruction/relative'],
+      stack.peeks(['other:i32'])
+    )
+    .add(`AssertSame as assert_eq`, stack.params(['reference:reference/any']).returns(UNCHANGED))
+    .add(`Enter as enter`, ['count:imm/u32', 'begin:imm/bool'])
+    .add(`Exit as exit1`)
+    .add(
+      `ToBoolean as tobool(top)`,
+      stack.params(['value:reference/any']).returns(['reference/bool'])
+    )
+    .add(
+      `EnterList as list/start`,
+      ['start:instruction/relative', 'else:instruction/absolute'],
+      stack
+        .params(['key:reference/fn', 'list:reference/any'])
+        .dynamic({ reason: 'the stack only changes if the iterator is non-empty' })
+    )
+    .add(`ExitList as list/done`)
+    .add(
+      `Iterate as list/item`,
+      ['breaks:instruction/absolute'],
+      stack.params(['iterator:glimmer/iterator']).dynamic({
+        reason: 'the behavior is different depending on the result of iterating the iterator',
+      })
+    )
+    .add(
+      `Main as call/main`,
+      ['register:register/sN'],
+      stack.params(['invocation:block/invocation', 'component:component/definition']).returns([])
+      // @todo characterize loading into $s0
+    )
+    .add(`ContentType as push<-ctype`, stack.peeks(['value:reference/any']).pushes(['enum/ctype']))
+    .add(
+      `Curry as v0<-curryref[pop2]`,
+      ['type:imm/enum<curry>', 'strict?:const/bool'],
+      stack.params(['args:args/captured', 'definition:reference/definition']).returns([])
+    )
+    .add(
+      `PushComponentDefinition as push<-def`,
+      ['definition:const/definition'],
+      stack.params([]).returns(['component/instance'])
+    )
+    .add(
+      `PushDynamicComponentInstance as push<-s0(definition)`,
+      stack.params(['definition:component/definition']).returns(['component/instance'])
+    )
+    .add(
+      `ResolveDynamicComponent as push<-pop_definition`,
+      stack.params(['definition:component/%definition']).returns(['component/definition'])
+    )
+    .add(
+      `ResolveCurriedComponent as push<-pop_curryref`,
+      stack.params(['definition:component/%value']).returns(['component/definition'])
+    )
+    .add(
+      `PushArgs as push<-args`,
+      ['names:const/str[]', 'block-names:const/str[]', 'flags:imm/u32{todo}'],
+      stack.params([]).returns(['args'])
+    )
+    .add(`PushEmptyArgs as push<-args0`, stack.params([]).returns(['args']))
+    .add(
+      `PrepareArgs as prepare<-args0`,
+      stack.dynamic({
+        reason:
+          "The behavior of PrepareArgs is highly dynamic. It may be useful to verify it, but it's not worth the effort at the moment.",
+      })
+    )
+
+    .add(`CaptureArgs as push<-args0`, stack.params(['args:args']).returns(['args/captured']))
+    .add(`CreateComponent as s0/component_create`, ['flags:imm/i32{todo}', 'instance:register/sN'])
+    .add(`RegisterComponentDestructor as `, ['instance:register/sN'])
+    .add(`PutComponentOperations as t0<-new_operations`)
+    .add(
+      `GetComponentSelf as push<-self`,
+      ['instance:register/sN', 'names:const/str[]?'],
+      stack.params([]).returns(['value/dynamic'])
+    )
+    .add(
+      `GetComponentTagName as `,
+      ['instance:register/sN'],
+      stack.params([]).returns(['value/str'])
+    )
+    .add(
+      `GetComponentLayout as push<-layout`,
+      ['instance:register/sN'],
+      stack.params([]).returns(['block/table', 'block/handle'])
+    )
+    .add(`SetupForEval as scope<-eval`, ['finished-instance:register/sN'])
+    .add(
+      `PopulateLayout as instance<-block`,
+      ['instance:register/sN'],
+      stack.params(['table:block/table', 'block:block/handle']).returns([])
+    )
+    .add(`InvokeComponentLayout as pc<-instance/handle`, ['finished-instance:register/sN'])
+    // cg means cache group
+    // push a block and a cache group
+    .add(`BeginComponentTransaction as blocks<-push_cg`, ['instance:register/sN'])
+    // pop the cache group
+    .add(`CommitComponentTransaction as blocks<-pop_cg`)
+    .add(`DidCreateElement as hook(cm_didcreate)`, ['instance:register/sN'])
+    // pop the block
+    .add(`DidRenderLayout as blocks<-pop`, ['instance:register/sN'])
+    .add(`Debugger as hook(debugger)`, ['symbols:const/str[]', 'info:const/i32[]'])
+    .add(`StaticComponentAttr as element<-attr<static>`, [
+      'name:const/str',
+      'value:const/str',
+      'namespace:const/str?',
+    ])
+    .add(`DynamicContentType as `, stack.params(['value:reference/any']).pushes(['enum/ctype']))
+    .add(
+      `DynamicHelper as v0<-helper`,
+      stack.params(['args:args', 'ref:reference/any']).returns([])
+    )
+    .add(
+      `DynamicModifier as element<-modifier`,
+      stack.params(['args:args', 'ref:reference/any']).returns([])
+    )
+    .add(
+      `IfInline as push<-if[pop3]`,
+      stack
+        .params(['falsy:reference/any', 'truthy:reference/any', 'condition:reference/any'])
+        .returns(['reference/any'])
+    )
+    .add(`Not as push<-not[pop1]`, stack.params(['ref:reference/any']).returns(['reference/bool']))
+    .add(
+      `GetDynamicVar as push<-dynvar[pop1]`,
+      stack.params(['name:reference/any']).returns(['reference/any'])
+    )
+    .add(`Log as v0<-log_ref[pop1]`, stack.params(['args:args']).returns([]))
+    .add(
+      `PushUnwindTarget as push<-target`,
+      stack.params(['target:register/instruction']).returns([])
+    )
+);
diff --git a/packages/@glimmer/debug/lib/render/combinators.ts b/packages/@glimmer/debug/lib/render/combinators.ts
new file mode 100644
index 0000000000..64f36609bc
--- /dev/null
+++ b/packages/@glimmer/debug/lib/render/combinators.ts
@@ -0,0 +1,371 @@
+import type {
+  BlockBounds,
+  DebugCursor,
+  Dict,
+  Nullable,
+  Optional,
+  PartialBoundsDebug,
+  Reactive,
+  ScopeSlot,
+  SnapshotArray,
+  UpdatingOpcode,
+} from '@glimmer/interfaces';
+import { readReactive, unwrapReactive } from '@glimmer/reference';
+import { inDevmode, isCompilable, stringifyDebugLabel, zip } from '@glimmer/util';
+
+import type { Fragment } from './fragment';
+import type { IntoFragment } from './presets';
+
+import { isReference } from '../utils';
+import { as, dom, empty, frag, group, intoFragment, join, value } from './presets';
+
+export function pick<const T extends object, const K extends keyof T>(
+  obj: T,
+  keys: K[]
+): Pick<T, K> {
+  return Object.fromEntries(keys.map((k) => [k, obj[k]])) as Pick<T, K>;
+}
+
+export type As<T> = (value: T) => Fragment;
+
+interface EntriesOptions<T> {
+  as?: As<T>;
+  subtle?: boolean | undefined | ((value: T) => boolean);
+}
+function normalizeOptions<T>(options: EntriesOptions<T> | undefined): {
+  map: (value: T) => Fragment;
+  isSubtle: (value: T) => boolean;
+} {
+  let isSubtle: (value: T) => boolean;
+
+  const subtleOption = options?.subtle;
+  if (typeof subtleOption === 'boolean') {
+    isSubtle = () => subtleOption;
+  } else if (typeof subtleOption === 'function') {
+    isSubtle = subtleOption;
+  } else {
+    isSubtle = () => false;
+  }
+
+  return {
+    map: options?.as ?? ((value) => intoFragment(value as IntoFragment)),
+    isSubtle,
+  };
+}
+function entries<T>(entries: [string, T][], options?: EntriesOptions<T>): Fragment {
+  const { map, isSubtle } = normalizeOptions(options);
+
+  return join(
+    entries.map(([k, v]) =>
+      isSubtle(v)
+        ? frag`${as.subtle(k)}: ${as.subtle(String(v))}`.subtle()
+        : frag`${as.kw(k)}: ${map(v)}`
+    ),
+    ', '
+  );
+}
+export function record(record: Dict<IntoFragment>): Fragment;
+export function record<T extends object>(record: T, options: EntriesOptions<T[keyof T]>): Fragment;
+export function record(record: Dict<unknown>, options?: EntriesOptions<unknown>): Fragment {
+  return wrap('[ ', entries(Object.entries(record), options), ']');
+}
+export function tuple(record: Dict<IntoFragment>): Fragment;
+export function tuple<T extends object>(record: T, options?: EntriesOptions<T[keyof T]>): Fragment;
+export function tuple(record: Dict<unknown>, options?: EntriesOptions<unknown>): Fragment {
+  return wrap('[ ', entries(Object.entries(record), options), ']');
+}
+/**
+ * The prepend function returns a subtle fragment if the contents are subtle.
+ */
+export function prepend(before: IntoFragment, contents: Fragment): Fragment {
+  return contents.map((f) => frag`${before}${f}`);
+}
+/**
+ * The append function returns a subtle fragment if the contents are subtle.
+ */
+function append(contents: Fragment, after: IntoFragment): Fragment {
+  return contents.map((f) => frag`${f}${after}`);
+}
+/**
+ * The `wrap` function returns a subtle fragment if the contents are subtle.
+ */
+export function wrap(start: IntoFragment, contents: Fragment, end: IntoFragment) {
+  return append(prepend(start, contents), end);
+}
+
+export function nullableArray<T>(
+  items: Nullable<T[] | readonly T[]>,
+  options: EntriesOptions<T>
+): Fragment {
+  if (items === null) {
+    return value(null);
+  } else {
+    return array(items, options);
+  }
+}
+
+/**
+ * A compact array makes the wrapping `[]` subtle if there's only one element.
+ */
+export function compactArray<T>(
+  items: readonly T[],
+  options: EntriesOptions<T> & {
+    when: {
+      allSubtle: IntoFragment;
+      empty?: IntoFragment;
+    };
+  }
+): Fragment {
+  const [first] = items;
+
+  if (first === undefined) {
+    return options.when?.empty ? intoFragment(options.when.empty) : frag`[]`.subtle();
+  }
+
+  const { map, isSubtle } = normalizeOptions(options);
+
+  const contents = items.map((item) => (isSubtle(item) ? frag`${map(item)}`.subtle() : map(item)));
+  const body = join(contents, ', ');
+
+  const unsubtle = contents.filter((f) => !f.isSubtle());
+
+  if (unsubtle.length === 0) {
+    return intoFragment(options.when.allSubtle).subtle();
+  } else if (unsubtle.length === 1) {
+    return group(frag`[`.subtle(), body, frag`]`.subtle());
+  } else {
+    return wrap('[ ', body, ' ]');
+  }
+}
+
+export function array(items: IntoFragment[]): Fragment;
+export function array<T>(items: T[] | readonly T[], options: EntriesOptions<T>): Fragment;
+export function array(
+  items: unknown[] | readonly unknown[],
+  options?: EntriesOptions<unknown>
+): Fragment {
+  if (items.length === 0) {
+    return frag`[]`;
+  } else {
+    const { map, isSubtle } = normalizeOptions(options);
+
+    const contents = items.map((item) =>
+      isSubtle(item) ? frag`${map(item)}`.subtle() : map(item)
+    );
+    return wrap('[ ', join(contents, ', '), ' ]');
+  }
+}
+
+function describeRef(ref: Reactive): Fragment {
+  const debug = inDevmode(ref.description);
+
+  if (debug.read === 'infallible') {
+    if (debug.serialization === 'String') {
+      return frag`<${as.kw('readonly')} ${String(unwrapReactive(ref))}>`;
+    }
+  }
+
+  const label = as.type(String(stringifyDebugLabel(ref)) ?? '');
+  const result = readReactive(ref);
+
+  switch (result.type) {
+    case 'err':
+      return frag`<${as.error('ref')} ${label} ${as.error('error')}=${value(result.value)}>`;
+    case 'ok': {
+      return frag`<${as.kw('ref')} ${join([label, value(result.value)], ' ')}>`;
+    }
+  }
+}
+
+export function stackValue(element: unknown): Fragment {
+  if (isReference(element)) {
+    return describeRef(element);
+  } else if (isCompilable(element)) {
+    const table = element.symbolTable;
+
+    if ('parameters' in table) {
+      const blockParams =
+        table.parameters.length === 0
+          ? empty()
+          : frag` as |${join(
+              table.parameters.map((s) => element.meta.debugSymbols?.at(s - 1) ?? `?${s}`),
+              ' '
+            )}|`;
+      return value(element, {
+        full: frag`<${as.kw('block')}${blockParams}>`,
+        short: 'block',
+      });
+    } else {
+      return frag` <${as.kw('template')} ${element.meta.moduleName ?? '(unknown module)'}>`;
+    }
+  } else {
+    return value(element);
+  }
+}
+
+export function updatingOpcodes(opcodes: SnapshotArray<UpdatingOpcode>): Fragment {
+  return array(opcodes, { as: updatingOpcode });
+}
+
+export function updatingOpcode(opcode: UpdatingOpcode): Fragment {
+  const name = as.kw(opcode.constructor.name);
+
+  return opcode.debug ? frag`<${name} ${stackValue(opcode.debug)}>` : name;
+}
+
+export function eqCursor(a: DebugCursor, b: DebugCursor) {
+  return a.parent === b.parent && a.next === b.next;
+}
+
+export function cursor({ parent, next }: DebugCursor): Fragment {
+  if (next) {
+    return frag`<${as.kw('insert')} before ${stackValue(next)}>`;
+  } else {
+    return frag`<${as.kw('append to')} ${stackValue(parent)}>`;
+  }
+}
+
+export function scopeValue(element: ScopeSlot): Fragment {
+  if (Array.isArray(element)) {
+    return frag`<${as.kw('block')}>`;
+  } else if (element === null) {
+    return value(null);
+  } else {
+    return stackValue(element);
+  }
+}
+
+export function bounds(bounds: BlockBounds): Fragment {
+  const parent = bounds.parentElement();
+  const { first, last } = bounds;
+
+  if (first === null) {
+    return frag`<${as.kw('bounds')} (empty) ${dom(parent)}>`;
+  } else if (first === last) {
+    return frag`<${as.kw('bounds')} ${dom(first)}>`;
+  } else {
+    return frag`<${as.kw('bounds')} ${dom(first)}..${last ? dom(last) : as.kw('unfinished')}>`;
+  }
+}
+
+export function partialBounds(bounds: PartialBoundsDebug): Fragment {
+  return frag`<${as.kw('partial')}:${as.sublabel(bounds.type)} ${dom(bounds.node)}>`;
+}
+
+export function eqBlock(a: BlockBounds, b: BlockBounds) {
+  return a.constructor === b.constructor && a.parentElement() === b.parentElement();
+}
+
+export function stackChange<T>(
+  before: Nullable<SnapshotArray<T>>,
+  after: Nullable<SnapshotArray<T>>,
+  options: { as: As<T> }
+) {
+  if (eqStack(before, after)) {
+    return frag`${as.subtle('(unchanged)')} ${nullableArray(after, options)}`.subtle();
+  }
+
+  return describeDiff(diffStacks(before ?? [], after ?? []), options);
+}
+
+export function changeArray<T>(
+  a: Nullable<SnapshotArray<T>>,
+  b: Nullable<SnapshotArray<T>>,
+  {
+    eq = Object.is,
+    as,
+    or = value,
+  }: {
+    eq?: (a: Nullable<SnapshotArray<T>>, b: Nullable<SnapshotArray<T>>) => boolean;
+    as: As<T>;
+    or?: As<null | undefined>;
+  }
+): Fragment {
+  if (b === undefined || b === null) {
+    return or(b);
+  }
+
+  return array(b, { as, subtle: eq(a, b) });
+}
+
+export function eqStack<T>(a: Nullable<SnapshotArray<T>>, b: Nullable<SnapshotArray<T>>) {
+  if (a === null || b === null) {
+    return a === b;
+  }
+
+  return a.length === b.length && a.every((a, i) => Object.is(a, b[i]));
+}
+
+export function eqStackStack<T>(
+  a: Optional<SnapshotArray<SnapshotArray<T>>>,
+  b: Optional<SnapshotArray<SnapshotArray<T>>>
+) {
+  if (a === null || a === undefined || b === null || b === undefined) {
+    return a === b;
+  }
+
+  return a.length === b.length && a.every((a, i) => eqStack(a, b[i] ?? null));
+}
+
+export function diffStacks<T>(
+  before: Nullable<readonly T[]>,
+  after: Nullable<readonly T[]>,
+  eq: (a: T, b: T) => boolean = Object.is
+): Diffs<T> {
+  if (eqStack(before, after)) {
+    return { unused: after ?? [], popped: [], pushed: [], peeked: [] };
+  }
+
+  let diverged = false;
+  const same: T[] = [];
+  const popped: T[] = [];
+  const pushed: T[] = [];
+
+  for (const [a, b] of zip(before ?? [], after ?? [])) {
+    if (a === undefined || b === undefined) {
+      diverged = true;
+
+      if (b === undefined) {
+        popped.push(a as T);
+      } else {
+        pushed.push(b as T);
+      }
+
+      continue;
+    } else if (diverged || !eq(a, b)) {
+      popped.push(a as T);
+      pushed.push(b as T);
+    } else {
+      same.push(b as T);
+    }
+  }
+
+  return { unused: same, peeked: [], popped, pushed };
+}
+
+interface Diffs<T> {
+  unused: readonly T[];
+  // peeks can only be determined from a spec -- diffs will never produce them.
+  peeked: readonly T[];
+  popped: readonly T[];
+  pushed: readonly T[];
+}
+
+export function describeDiff<T>(
+  { unused, peeked, pushed, popped }: Diffs<T>,
+  options: EntriesOptions<T>
+): Fragment {
+  return join(
+    [
+      array(unused, options).subtle(),
+      labelled('peeks', compactArray(peeked, { ...options, when: { allSubtle: 'no peeks' } })),
+      labelled('pops', compactArray(popped, { ...options, when: { allSubtle: 'no pops' } })),
+      labelled('pushes', compactArray(pushed, { ...options, when: { allSubtle: 'no pushes' } })),
+    ],
+    ' '
+  );
+}
+
+export function labelled(label: string, value: Fragment): Fragment {
+  return prepend(frag`${as.sublabel(label)} `, value);
+}
diff --git a/packages/@glimmer/debug/lib/render/fragment.ts b/packages/@glimmer/debug/lib/render/fragment.ts
new file mode 100644
index 0000000000..b9524a1a11
--- /dev/null
+++ b/packages/@glimmer/debug/lib/render/fragment.ts
@@ -0,0 +1,427 @@
+import type { SimpleNode } from '@glimmer/interfaces';
+import { assertNever,isObject, isUserException  } from '@glimmer/util';
+
+import type {IntoFormat} from './presets';
+
+import {  intoFormat, STYLES } from './presets';
+
+interface AbstractLeafFragment {
+  readonly value: unknown;
+  readonly style?: string | undefined;
+  readonly subtle?: boolean;
+}
+
+export interface ValueFragment extends AbstractLeafFragment {
+  readonly kind: 'value';
+  readonly value: unknown;
+  readonly annotation?: { compact: string; full: Fragment } | undefined;
+}
+
+export interface StringFragment extends AbstractLeafFragment {
+  readonly kind: 'string';
+  readonly value: string;
+}
+
+export interface IntegerFragment extends AbstractLeafFragment {
+  readonly kind: 'integer';
+  readonly value: number;
+}
+
+export interface DomFragment extends AbstractLeafFragment {
+  readonly kind: 'dom';
+  readonly value: SimpleNode | Node;
+}
+
+export type LeafFragmentType = StringFragment | IntegerFragment | ValueFragment | DomFragment;
+
+const FORMATTERS = {
+  value: '%O',
+  string: '%s',
+  integer: '%d',
+  dom: '%o',
+} as const;
+
+export type FragmentType =
+  | LeafFragmentType
+  | {
+      kind: 'multi';
+      value: LeafFragment[];
+    };
+
+export type LeafFragment = Fragment<LeafFragmentType>;
+
+export interface DisplayFragmentOptions {
+  readonly showSubtle: boolean;
+}
+
+export class Fragment<T extends FragmentType = FragmentType> {
+  readonly #type: T;
+
+  constructor(type: T) {
+    this.#type = type;
+  }
+
+  get width() {
+    return this.leaves().reduce((sum, leaf) => {
+      const { kind, value } = leaf.#type;
+
+      switch (kind) {
+        case 'integer':
+        case 'string':
+          return sum + String(value).length;
+        case 'value':
+        case 'dom':
+          // @fixme this assumes one-digit references
+          return sum + '[]'.length + 1;
+      }
+    }, 0);
+  }
+
+  isSubtle(): boolean {
+    return this.leaves().every((leaf) => leaf.#type.subtle);
+  }
+
+  map(ifPresent: (value: Fragment) => Fragment): Fragment {
+    if (this.isEmpty()) return this;
+    const fragment = ifPresent(this);
+    return this.isSubtle() ? fragment.subtle() : fragment;
+  }
+
+  isEmpty(options: DisplayFragmentOptions = { showSubtle: true }): boolean {
+    return this.leaves().every((leaf) => !leaf.#shouldShow(options));
+  }
+
+  leaves(): LeafFragment[] {
+    if (this.#type.kind === 'multi') {
+      return this.#type.value.flatMap((f) => f.leaves());
+    } else if (this.#type.kind === 'string' && this.#type.value === '') {
+      return [];
+    } else {
+      return [this as LeafFragment];
+    }
+  }
+
+  subtle(isSubtle = true): Fragment<T> {
+    if (this.isSubtle() === false && isSubtle === false) {
+      return this;
+    }
+
+    const fragment = this.#subtle(isSubtle);
+    return isSubtle ? fragment.styleAll('subtle') : fragment;
+  }
+
+  #subtle(isSubtle: boolean): Fragment<T> {
+    if (this.#type.kind === 'multi') {
+      return new Fragment({
+        ...this.#type,
+        value: this.leaves().flatMap((f) => f.subtle(isSubtle).leaves()),
+      });
+    } else {
+      return new Fragment({
+        ...this.#type,
+        subtle: isSubtle,
+      });
+    }
+  }
+
+  styleAll(...allStyle: IntoFormat[]): Fragment<T> {
+    if (allStyle.length === 0) return this;
+
+    if (this.#type.kind === 'multi') {
+      return new Fragment({
+        ...this.#type,
+        value: this.#type.value.flatMap((f) => f.styleAll(...allStyle).leaves()),
+      });
+    } else {
+      return new Fragment({
+        ...this.#type,
+        style: mergeStyle(this.#type.style, styles(...allStyle)),
+      });
+    }
+  }
+
+  stringify(options: DisplayFragmentOptions): string {
+    return this.leaves()
+      .filter((leaf) => leaf.#shouldShow(options))
+      .map((leaf) => {
+        const fragment = leaf.#type;
+
+        if (fragment.kind === 'value') {
+          return `<object>`;
+        } else {
+          return String(fragment.value);
+        }
+      })
+      .join('');
+  }
+
+  #shouldShow(options: DisplayFragmentOptions): boolean {
+    return this.leaves().some((leaf) => {
+      const fragment = leaf.#type;
+
+      if (fragment.subtle && !options.showSubtle) {
+        return false;
+      } else if (fragment.kind === 'string' && fragment.value === '') {
+        return false;
+      }
+
+      return true;
+    });
+  }
+
+  toLog(options: DisplayFragmentOptions): [LogLine, ...LogEntry[]] {
+    const buffer = new LogFragmentBuffer(options);
+
+    for (const leaf of this.leaves()) {
+      leaf.appendTo(buffer);
+    }
+
+    return buffer.flush();
+  }
+
+  appendTo(buffer: LogFragmentBuffer): void {
+    const fragment = this.#type;
+
+    if (fragment.kind === 'value') {
+      if (fragment.value === null || fragment.value === undefined) {
+        return this.#asString(String(fragment.value), STYLES.null).appendTo(buffer);
+      } else if (typeof fragment.value === 'string') {
+        return this.#asString(JSON.stringify(fragment.value), STYLES.string).appendTo(buffer);
+      } else if (typeof fragment.value === 'number') {
+        return this.#asString(String(fragment.value), STYLES.number).appendTo(buffer);
+      }
+    }
+
+    if (fragment.kind === 'multi') {
+      for (const f of fragment.value) {
+        f.appendTo(buffer);
+      }
+    } else {
+      switch (fragment.kind) {
+        case 'string':
+        case 'integer':
+          buffer.append(
+            fragment.subtle ?? false,
+            `%c${FORMATTERS[fragment.kind]}`,
+            fragment.style,
+            fragment.value
+          );
+          break;
+        case 'dom':
+        case 'value': {
+          const error = getErrorInstance(fragment.value);
+          const annotation = fragment.kind === 'value' && !error ? fragment.annotation : undefined;
+          const index = buffer.nextFootnote;
+          const style = ANNOTATION_STYLES[index % ANNOTATION_STYLES.length] as string;
+
+          if (annotation) {
+            annotation.full.subtle(this.isSubtle()).styleAll({ style }).appendTo(buffer);
+          } else if (error) {
+            buffer.append(fragment.subtle ?? false, `%c${error.message}`, style);
+            buffer.append(true, `%c(${error.name})`, styles('specialVar'));
+          } else {
+            buffer.append(fragment.subtle ?? false, `%c[${buffer.nextFootnote}]`, style);
+          }
+
+          if (error) {
+            buffer.enqueue.group(
+              ['%cStack', mergeStyle(STYLES.unbold, style)],
+              [`%c${error.stack}`, styles('stack')],
+              { collapsed: true }
+            );
+
+            let cause = error.cause;
+
+            while (cause) {
+              if (isErrorInstance(cause)) {
+                buffer.enqueue.group(
+                  [`%cCaused by`, styles('unbold', 'errorLabel')],
+                  [`%c${cause.message}`, styles('errorMessage')],
+                  [`%c${cause.stack}`, styles('stack')],
+                  { subtle: fragment.subtle ?? false, collapsed: true }
+                );
+                cause = cause.cause;
+              }
+            }
+          } else {
+            buffer.enqueue.line(
+              fragment.subtle ?? false,
+              `%c[${annotation?.compact ?? buffer.nextFootnote}]%c %c${FORMATTERS[fragment.kind]}`,
+              style,
+              '',
+              error ? STYLES.errorMessage : mergeStyle(fragment.style, style),
+              fragment.value
+            );
+          }
+          break;
+        }
+        default:
+          assertNever(fragment);
+      }
+    }
+  }
+
+  #asString(value: string, style?: string | undefined): Fragment {
+    return new Fragment({
+      kind: 'string',
+      value,
+      style,
+      subtle: this.isSubtle(),
+    });
+  }
+}
+
+export interface LogLine {
+  readonly type: 'line';
+  readonly line: unknown[];
+}
+
+export interface LogGroup {
+  type: 'group';
+  collapsed: boolean;
+  heading: unknown[];
+  children: LogEntry[];
+}
+
+export type LogEntry = LogLine | LogGroup;
+
+type RawLine = [template: string, ...substitutions: unknown[]];
+
+interface QueuedLine {
+  type: 'line';
+  subtle: boolean;
+  template: string;
+  substitutions: unknown[];
+}
+
+interface QueuedGroup {
+  type: 'group';
+  collapsed: boolean;
+  heading: QueuedLine;
+  children: QueuedEntry[];
+}
+
+type QueuedEntry = QueuedLine | QueuedGroup;
+
+export type FlushedLines = [LogLine, ...LogEntry[]];
+
+export class LogFragmentBuffer {
+  #template = '';
+  readonly #options: DisplayFragmentOptions;
+  readonly #substitutions: unknown[] = [];
+  readonly #queued: QueuedEntry[] = [];
+
+  constructor(options: DisplayFragmentOptions) {
+    this.#options = options;
+  }
+
+  get nextFootnote(): number {
+    return this.#queued.length;
+  }
+
+  readonly enqueue = {
+    line: (subtle: boolean, template: string, ...substitutions: unknown[]): void => {
+      this.#queued.push({ type: 'line', subtle, template, substitutions });
+    },
+
+    group: (
+      ...args:
+        | [RawLine, ...RawLine[], { collapsed?: boolean; subtle?: boolean; bold?: boolean }]
+        | [RawLine, ...RawLine[]]
+    ): void => {
+      const { collapsed, subtle } = !Array.isArray(args.at(-1))
+        ? { collapsed: false, subtle: false, ...args.pop() }
+        : { collapsed: false, subtle: false };
+      const [heading, ...children] = args as [RawLine, ...RawLine[]];
+
+      this.#queued.push({
+        type: 'group',
+        collapsed,
+        heading: {
+          type: 'line',
+          subtle,
+          template: heading[0],
+          substitutions: heading.slice(1),
+        },
+        children: children.map((line) => ({
+          type: 'line',
+          subtle,
+          template: line[0],
+          substitutions: line.slice(1),
+        })),
+      });
+    },
+  };
+
+  append(subtle: boolean, template: string, ...substitutions: unknown[]) {
+    if (subtle && !this.#options.showSubtle) return;
+    this.#template += template;
+
+    this.#substitutions.push(...substitutions);
+  }
+
+  #mapLine(line: QueuedLine): LogLine[] {
+    if (line.subtle && !this.#options.showSubtle) return [];
+    return [{ type: 'line', line: [line.template, ...line.substitutions] }];
+  }
+
+  #mapGroup(group: QueuedGroup): LogGroup {
+    return {
+      type: 'group',
+      collapsed: group.collapsed,
+      heading: [group.heading.template, ...group.heading.substitutions],
+      children: group.children.flatMap((queued) => this.#mapEntry(queued)),
+    } satisfies LogGroup;
+  }
+
+  #mapEntry(entry: QueuedEntry): LogEntry[] {
+    if (entry.type === 'line') {
+      return this.#mapLine(entry);
+    } else {
+      return [this.#mapGroup(entry)];
+    }
+  }
+
+  flush(): FlushedLines {
+    return [
+      { type: 'line', line: [this.#template, ...this.#substitutions] },
+      ...this.#queued.flatMap((queued) => this.#mapEntry(queued)),
+    ];
+  }
+}
+
+function styles(...styles: IntoFormat[]) {
+  return styles.map((c) => intoFormat(c).style).join('; ');
+}
+
+function mergeStyle(a?: string | undefined, b?: string | undefined): string | undefined {
+  if (a && b) {
+    return `${a}; ${b}`;
+  } else {
+    return a || b;
+  }
+}
+
+const ANNOTATION_STYLES = [
+  'background-color: oklch(93% 0.03 300); color: oklch(34% 0.18 300)',
+  'background-color: oklch(93% 0.03 250); color: oklch(34% 0.18 250)',
+  'background-color: oklch(93% 0.03 200); color: oklch(34% 0.18 200)',
+  'background-color: oklch(93% 0.03 150); color: oklch(34% 0.18 150)',
+  'background-color: oklch(93% 0.03 100); color: oklch(34% 0.18 100)',
+  'background-color: oklch(93% 0.03 50); color: oklch(34% 0.18 50)',
+  'background-color: oklch(93% 0.03 0); color: oklch(34% 0.18 0)',
+] as const;
+
+function isErrorInstance(value: unknown): value is Error {
+  return isObject(value) && value instanceof Error;
+}
+
+function getErrorInstance(value: unknown): Error | undefined {
+  if (isErrorInstance(value)) {
+    if (isUserException(value)) {
+      return isErrorInstance(value.cause) ? value.cause : value;
+    } else {
+      return value;
+    }
+  }
+}
diff --git a/packages/@glimmer/debug/lib/render/lines.ts b/packages/@glimmer/debug/lib/render/lines.ts
new file mode 100644
index 0000000000..3eacd260ac
--- /dev/null
+++ b/packages/@glimmer/debug/lib/render/lines.ts
@@ -0,0 +1,267 @@
+import type { LOCAL_LOGGER } from "@glimmer/util";
+import { getFlagValues } from '@glimmer/local-debug-flags';
+
+import type { DisplayFragmentOptions, FlushedLines, Fragment, LogEntry } from './fragment';
+import type {IntoFormat, IntoFragment} from './presets';
+
+import { prepend } from './combinators';
+import { as, frag,   intoFragment } from './presets';
+
+type FlatOp =
+  | Atom
+  | {
+      type: 'newline';
+    }
+  | {
+      type: 'indent';
+    }
+  | {
+      type: 'outdent';
+    };
+
+/**
+ * An Atom can't be line-broken
+ */
+interface Atom {
+  readonly type: 'atom';
+  readonly fragment: Fragment;
+}
+
+/**
+ * A Fork chooses its fragment based upon whether it's broken or not.
+ */
+interface Fork {
+  readonly type: 'fork';
+  readonly oneline: SubDoc;
+  readonly multi: SubDoc;
+}
+
+/**
+ * If a Break is a direct child of a group and the group is rendered as a oneline, then
+ * the break's oneline is rendered. Otherwise, the break is rendered as a newline.
+ */
+interface Break {
+  readonly type: 'break';
+  readonly oneline: Fragment;
+}
+
+/**
+ * A nest's oneline is its prefix + its body's oneline + its suffix. A nest's multi is
+ * its prefix, a nest increment, its body, a nest decrement, and its suffix.
+ */
+interface Nest {
+  readonly type: 'nest';
+  readonly oneline: {
+    prefix: Fragment;
+    suffix: Fragment;
+  };
+  readonly multi: {
+    prefix: Fragment;
+    suffix: Fragment;
+  };
+  readonly body: SubDoc;
+}
+
+/**
+ * A Group can be line-broken.
+ */
+interface Doc {
+  readonly type: 'doc';
+  readonly children: SubDoc[];
+}
+
+type SubDoc = Atom | Break | Fork | Nest | Doc;
+
+class State {
+  readonly #width: number;
+  #indent = 0;
+
+  constructor(width: number) {
+    this.#width = width;
+  }
+
+  indent(): void {
+    this.#indent += 1;
+  }
+
+  outdent(): void {
+    this.#indent -= 1;
+  }
+
+  get width() {
+    return this.#width - this.#indent * 2;
+  }
+}
+
+export function render(doc: Doc, width: number): FlatOp[] {
+  if (onelineWidth(doc) <= width) return renderOneline(doc);
+
+  const state = new State(width);
+
+  return renderMulti(doc, state);
+}
+
+function renderMulti(child: SubDoc, state: State): FlatOp[] {
+  switch (child.type) {
+    case 'atom':
+      return [child];
+    case 'break':
+      return [{ type: 'newline' }];
+    case 'fork': {
+      const width = onelineWidth(child);
+      if (width <= width) {
+        return renderOneline(child);
+      } else {
+        return renderMulti(child.multi, state);
+      }
+    }
+    case 'nest': {
+      const width = onelineWidth(child);
+      if (width <= width) {
+        return renderOneline(child);
+      } else {
+        const out: FlatOp[] = [];
+        out.push({ type: 'atom', fragment: child.multi.prefix });
+        state.indent();
+        out.push({ type: 'indent' });
+        out.push(...renderMulti(child.body, state));
+        out.push({ type: 'outdent' });
+        state.outdent();
+        return out;
+      }
+    }
+    case 'doc': {
+      const width = onelineWidth(child);
+      if (width <= width) {
+        return renderOneline(child);
+      } else {
+        return child.children.flatMap((child) => renderMulti(child, state));
+      }
+    }
+  }
+}
+
+function renderOneline(doc: SubDoc): FlatOp[] {
+  switch (doc.type) {
+    case 'atom':
+      return [doc];
+    case 'break':
+      return [{ type: 'atom', fragment: doc.oneline }];
+    case 'fork':
+      return renderOneline(doc.oneline);
+    case 'nest':
+      return [
+        { type: 'atom', fragment: doc.oneline.prefix },
+        ...renderOneline(doc.body),
+        { type: 'atom', fragment: doc.oneline.suffix },
+      ];
+    case 'doc': {
+      return doc.children.flatMap(renderOneline);
+    }
+  }
+}
+
+function onelineWidth(subdoc: SubDoc): number {
+  switch (subdoc.type) {
+    case 'atom':
+      return subdoc.fragment.width;
+    case 'break':
+      return subdoc.oneline.width;
+    case 'fork':
+      return onelineWidth(subdoc.oneline);
+    case 'nest':
+      return subdoc.oneline.prefix.width + subdoc.oneline.suffix.width + onelineWidth(subdoc.body);
+    case 'doc':
+      return subdoc.children.reduce((sum, breakDoc) => sum + onelineWidth(breakDoc), 0);
+  }
+}
+
+export class DebugLogger {
+  readonly #logger: typeof LOCAL_LOGGER;
+  readonly #options: DisplayFragmentOptions;
+
+  constructor(logger: typeof LOCAL_LOGGER, options: DisplayFragmentOptions) {
+    this.#logger = logger;
+    this.#options = options;
+  }
+
+  #logEntry(entry: LogEntry) {
+    switch (entry.type) {
+      case 'line': {
+        this.#logger.debug(...entry.line);
+        break;
+      }
+
+      case 'group': {
+        if (entry.collapsed) {
+          this.#logger.groupCollapsed(...entry.heading);
+        } else {
+          this.#logger.group(...entry.heading);
+        }
+
+        for (const line of entry.children) {
+          this.#logEntry(line);
+        }
+
+        this.#logger.groupEnd();
+      }
+    }
+  }
+
+  #lines(type: 'log' | 'debug' | 'group' | 'groupCollapsed', lines: FlushedLines): void {
+    const [first, ...rest] = lines;
+
+    if (first) {
+      this.#logger[type](...first.line);
+
+      for (const entry of rest) {
+        this.#logEntry(entry);
+      }
+    }
+  }
+
+  internals(...args: IntoFragment[]): void {
+    this.#lines(
+      'groupCollapsed',
+      frag`🔍 ${intoFragment('internals').styleAll('internals')}`.toLog(this.#options)
+    );
+    this.#lines('debug', frag`${args}`.toLog(this.#options));
+    this.#logger.groupEnd();
+  }
+
+  log(...args: IntoFragment[]): void {
+    const fragment = frag`${args}`;
+
+    if (!fragment.isEmpty(this.#options)) this.#lines('debug', fragment.toLog(this.#options));
+  }
+
+  labelled(label: string, ...args: IntoFragment[]): void {
+    const fragment = frag`${args}`;
+
+    const styles: IntoFormat[] = ['kw'];
+
+    const { focus, focusColor } = getFlagValues('focus_highlight').includes(label)
+      ? ({ focus: ['focus'], focusColor: ['focusColor'] } as const)
+      : { focus: [], focusColor: [] };
+
+    this.log(
+      prepend(
+        frag`${as.label(label)} `.styleAll(...styles, ...focus, ...focusColor),
+        fragment.styleAll(...focus)
+      )
+    );
+  }
+
+  group(...args: IntoFragment[]): { expanded: () => () => void; collapsed: () => () => void } {
+    return {
+      expanded: () => {
+        this.#lines('group', frag`${args}`.styleAll('unbold').toLog(this.#options));
+        return () => this.#logger.groupEnd();
+      },
+      collapsed: () => {
+        this.#lines('groupCollapsed', frag`${args}`.styleAll('unbold').toLog(this.#options));
+        return () => this.#logger.groupEnd();
+      },
+    };
+  }
+}
diff --git a/packages/@glimmer/debug/lib/render/presets.ts b/packages/@glimmer/debug/lib/render/presets.ts
new file mode 100644
index 0000000000..168c6bc38e
--- /dev/null
+++ b/packages/@glimmer/debug/lib/render/presets.ts
@@ -0,0 +1,212 @@
+import type { Optional, SimpleNode } from '@glimmer/interfaces';
+
+import type {LeafFragment} from './fragment';
+
+import { Fragment  } from './fragment';
+
+// inspired by https://github.com/ChromeDevTools/devtools-frontend/blob/c2c17396c9e0da3f1ce6514c3a946f88a06b17f2/front_end/ui/legacy/themeColors.css#L65
+export const STYLES = {
+  var: 'color: grey',
+  varReference: 'color: blue; text-decoration: underline',
+  varBinding: 'color: blue;',
+  specialVar: 'color: blue',
+  prop: 'color: grey',
+  specialProp: 'color: red',
+  token: 'color: green',
+  def: 'color: blue',
+  builtin: 'color: blue',
+  punct: 'color: grey',
+  kw: 'color: rgb(185 0 99 / 100%);',
+  type: 'color: teal',
+  number: 'color: blue',
+  string: 'color: red',
+  null: 'color: grey',
+  specialString: 'color: darkred',
+  atom: 'color: blue',
+  attrName: 'color: orange',
+  attrValue: 'color: blue',
+  comment: 'color: green',
+  meta: 'color: grey',
+  register: 'color: purple',
+  constant: 'color: purple',
+  subtle: 'color: lightgrey',
+  internals: 'color: lightgrey; font-style: italic',
+
+  sublabel: 'font-style: italic; color: grey',
+  error: 'color: red',
+  label: 'text-decoration: underline',
+  errorLabel: 'color: darkred; font-style: italic',
+  errorMessage: 'color: darkred; text-decoration: underline',
+  stack: 'color: grey; font-style: italic',
+  unbold: 'font-weight: normal',
+  pointer: 'background-color: lavender; color: indigo',
+  pointee: 'background-color: lavender; color: indigo',
+  focus: 'font-weight: bold',
+  focusColor: 'background-color: lightred; color: darkred',
+} as const;
+
+export const as = Object.fromEntries(
+  Object.entries(STYLES).map(([k, v]) => [
+    k,
+    (value: IntoFragment) => intoFragment(value).styleAll({ style: v }),
+  ])
+) as {
+  [K in keyof typeof STYLES]: ((value: IntoLeafFragment) => LeafFragment) &
+    ((value: IntoFragment) => Fragment);
+};
+
+export type Format = { style: string };
+export type IntoFormat = { style: string } | keyof typeof STYLES;
+
+export function intoFormat(format: IntoFormat): Format {
+  if (typeof format === 'string') {
+    return { style: STYLES[format] };
+  } else {
+    return format;
+  }
+}
+
+export type IntoFragment = Fragment | IntoFragment[] | number | string | null;
+type IntoLeafFragment = LeafFragment | number | string | null;
+
+export function intoFragment(value: IntoFragment): Fragment {
+  const fragments = intoFragments(value);
+  const [first, ...rest] = fragments;
+
+  if (first !== undefined && rest.length === 0) {
+    return first;
+  }
+
+  return new Fragment({ kind: 'multi', value: fragments });
+}
+
+function intoFragments(value: IntoFragment): LeafFragment[] {
+  if (Array.isArray(value)) {
+    return value.flatMap(intoFragments);
+  } else if (typeof value === 'object' && value !== null) {
+    return value.leaves();
+  } else {
+    return [intoLeafFragment(value)];
+  }
+}
+
+function intoLeafFragment(value: IntoLeafFragment): LeafFragment {
+  if (value === null) {
+    return new Fragment({ kind: 'value', value: null });
+  } else if (typeof value === 'number') {
+    return new Fragment({ kind: 'integer', value });
+  } else if (typeof value === 'string') {
+    if (/^[\s\p{P}]*$/u.test(value)) {
+      return new Fragment({ kind: 'string', value, style: STYLES.punct });
+    } else {
+      return new Fragment({ kind: 'string', value });
+    }
+  } else {
+    return value;
+  }
+}
+
+export function plain(string: string): LeafFragment {
+  return new Fragment({ kind: 'string', value: string });
+}
+
+export function styled(fragment: IntoLeafFragment, format: IntoFormat): LeafFragment;
+export function styled(fragment: IntoFragment, format: IntoFormat): Fragment;
+export function styled(fragment: IntoFragment, format: IntoFormat): Fragment {
+  return intoFragment(fragment).styleAll(format);
+}
+
+export function colored({ color, message }: { color: string; message: string }): LeafFragment {
+  return new Fragment({ kind: 'string', value: message, style: `color: ${color}` });
+}
+
+export function value(
+  value: unknown,
+  options?: { annotation: string } | { short: string; full: IntoFragment }
+): LeafFragment {
+  // const annotation = options && 'annotation' in options ? { }
+
+  const normalize = () => {
+    if (options === undefined) return;
+
+    if ('annotation' in options) {
+      return { compact: options.annotation, full: intoFragment(options.annotation) };
+    } else {
+      return { compact: options.short, full: intoFragment(options.full) };
+    }
+  };
+
+  return new Fragment({
+    kind: 'value',
+    value,
+    annotation: normalize(),
+  });
+}
+
+export function integer(value: number): LeafFragment {
+  return new Fragment({ kind: 'integer', value });
+}
+
+export function dom(value: Node | SimpleNode): LeafFragment {
+  return new Fragment({ kind: 'dom', value });
+}
+
+export function empty(): LeafFragment {
+  return new Fragment({ kind: 'string', value: '' });
+}
+
+export function join(frags: IntoFragment[], separator?: Optional<IntoFragment>): Fragment {
+  const sep = separator ? intoFragment(separator) : empty();
+
+  if (frags.length === 0) {
+    return empty();
+  }
+
+  let seenUnsubtle = false;
+  let seenAny = false;
+
+  const output: LeafFragment[] = [];
+
+  for (const frag of frags) {
+    const fragment = intoFragment(frag);
+    const isSubtle = fragment.isSubtle();
+    const sepIsSubtle = isSubtle || !seenUnsubtle;
+
+    // If the succeeding fragment is subtle, the separator is also subtle. If the succeeding
+    // fragment is unstubtle, the separator is unsubtle only if we've already seen an unsubtle
+    // fragment. This ensures that separators are not ultimately present if the next element is not
+    // printed.
+
+    if (seenAny) {
+      output.push(...sep.subtle(sepIsSubtle).leaves());
+    }
+
+    output.push(...fragment.leaves());
+    seenUnsubtle = !isSubtle;
+    seenAny = true;
+  }
+
+  return new Fragment({ kind: 'multi', value: output });
+}
+
+export function group(...frags: IntoFragment[]): Fragment {
+  return new Fragment({ kind: 'multi', value: frags.flatMap((f) => intoFragment(f).leaves()) });
+}
+
+export function frag(strings: TemplateStringsArray, ...values: IntoFragment[]): Fragment {
+  const buffer: LeafFragment[] = [];
+
+  strings.forEach((string, i) => {
+    buffer.push(...intoFragment(string).leaves());
+    const dynamic = values[i];
+    if (dynamic) {
+      buffer.push(...intoFragment(dynamic).leaves());
+    }
+  });
+
+  return new Fragment({ kind: 'multi', value: buffer });
+}
+
+export function subtle(strings: TemplateStringsArray, ...values: IntoFragment[]): Fragment {
+  return frag(strings, ...values).subtle();
+}
diff --git a/packages/@glimmer/debug/lib/render/serialize.ts b/packages/@glimmer/debug/lib/render/serialize.ts
new file mode 100644
index 0000000000..faae8beb4b
--- /dev/null
+++ b/packages/@glimmer/debug/lib/render/serialize.ts
@@ -0,0 +1,140 @@
+import type { BlockMetadata, DebugVmSnapshot } from '@glimmer/interfaces';
+import { exhausted } from '@glimmer/util';
+
+import type { DisassembledOperand, RegisterName, SomeDisassembledOperand } from '../debug';
+import type {IntoFragment} from './presets';
+
+import { stackValue } from './combinators';
+import { as,frag  } from './presets';
+
+export class SerializeBlockContext {
+  readonly #block: Pick<BlockMetadata, 'debugSymbols'> | null;
+
+  constructor(block: Pick<BlockMetadata, 'debugSymbols'> | null) {
+    this.#block = block;
+  }
+
+  serialize(param: SomeDisassembledOperand): IntoFragment {
+    switch (param.type) {
+      case 'number':
+      case 'boolean':
+      case 'string':
+      case 'primitive':
+        return this.#stringify(param.value, 'stringify');
+      case 'array':
+        return param.value?.map((value) => this.#stringify(value, 'unknown')) ?? null;
+      case 'dynamic':
+      case 'constant':
+        return stackValue(param.value);
+      case 'register':
+        return this.#stringify(param.value, 'register');
+      case 'instruction':
+        return this.#stringify(param.value, 'pc');
+      case 'variable': {
+        const value = param.value;
+        if (value === 0) {
+          return frag`{${as.kw('this')}}`;
+        } else if (this.#block?.debugSymbols && this.#block.debugSymbols.length >= value) {
+          // @fixme something is wrong here -- remove the `&&` to get test failures
+          return frag`${as.varReference(
+            this.#block.debugSymbols[value - 1]!
+          )}${frag`:${value}`.subtle()}`;
+        } else {
+          return frag`{${as.register('$fp')}+${value}}`;
+        }
+      }
+
+      case 'error:opcode':
+        return `{raw:${param.value}}`;
+      case 'error:operand':
+        return `{err:${param.options.label.name}=${param.value}}`;
+      case 'enum<curry>':
+        return `<curry:${param.value}>`;
+
+      default:
+        exhausted(param);
+    }
+  }
+
+  #stringify(value: number, type: 'constant'): string;
+  #stringify(value: RegisterName, type: 'register'): string;
+  #stringify(value: number, type: 'variable' | 'pc'): string;
+  #stringify(value: DisassembledOperand['value'], type: 'stringify' | 'unknown'): string;
+  #stringify(
+    value: unknown,
+    type: 'stringify' | 'constant' | 'register' | 'variable' | 'pc' | 'unknown'
+  ) {
+    switch (type) {
+      case 'stringify':
+        return JSON.stringify(value);
+      case 'constant':
+        return `${this.#stringify(value, 'unknown')}`;
+      case 'register':
+        return value;
+      case 'variable': {
+        if (value === 0) {
+          return `{this}`;
+        } else if (
+          this.#block?.debugSymbols &&
+          this.#block.debugSymbols.length >= (value as number)
+        ) {
+          return `{${this.#block.debugSymbols[(value as number) - 1]}:${value}}`;
+        } else {
+          return `{$fp+${value}}`;
+        }
+      }
+      case 'pc':
+        return `@${value}`;
+      case 'unknown': {
+        switch (typeof value) {
+          case 'function':
+            return '<function>';
+          case 'number':
+          case 'string':
+          case 'bigint':
+          case 'boolean':
+            return JSON.stringify(value);
+          case 'symbol':
+            return `${String(value)}`;
+          case 'undefined':
+            return 'undefined';
+          case 'object': {
+            if (value === null) return 'null';
+            if (Array.isArray(value)) return `<array[${value.length}]>`;
+
+            let name = value.constructor.name;
+
+            switch (name) {
+              case 'Error':
+              case 'RangeError':
+              case 'ReferenceError':
+              case 'SyntaxError':
+              case 'TypeError':
+              case 'WeakMap':
+              case 'WeakSet':
+                return `<${name}>`;
+              case 'Object':
+                return `<${name}>`;
+            }
+
+            if (value instanceof Map) {
+              return `<Map[${value.size}]>`;
+            } else if (value instanceof Set) {
+              return `<Set[${value.size}]>`;
+            } else {
+              return `<${name}>`;
+            }
+          }
+        }
+      }
+    }
+  }
+}
+
+export type SerializableDebug = {
+  [P in keyof DebugVmSnapshot as SerializableKey<DebugVmSnapshot, P>]: DebugVmSnapshot[P];
+};
+
+export type SerializableKey<O, P extends keyof O> = {
+  [K in P]: O[P] extends IntoFragment ? K : never;
+}[P];
diff --git a/packages/@glimmer/debug/lib/render/state.ts b/packages/@glimmer/debug/lib/render/state.ts
new file mode 100644
index 0000000000..20d35d6606
--- /dev/null
+++ b/packages/@glimmer/debug/lib/render/state.ts
@@ -0,0 +1,442 @@
+import type {
+  BlockMetadata,
+  DebugConstants,
+  DebugVmSnapshot,
+  Dict,
+  RuntimeConstants,
+  RuntimeHeap,
+  SnapshotArray,
+} from '@glimmer/interfaces';
+import { decodeHandle, enumerate } from '@glimmer/util';
+
+import type {OpSnapshot, SomeDisassembledOperand} from '../debug';
+import type { OpcodeMetadata, StackSpec } from '../metadata';
+import type { Fragment } from './fragment';
+import type { DebugLogger } from './lines';
+import type {IntoFragment} from './presets';
+
+import { debug   } from '../debug';
+import { opcodeMetadata } from '../opcode-metadata';
+import {
+  array,
+  bounds,
+  changeArray,
+  compactArray,
+  cursor,
+  describeDiff,
+  diffStacks,
+  eqBlock,
+  eqCursor,
+  eqStack,
+  pick,
+  prepend,
+  scopeValue,
+  stackValue,
+  tuple,
+  updatingOpcode,
+  wrap,
+} from './combinators';
+import { as, frag, group,  intoFragment, join, subtle, value } from './presets';
+import { SerializeBlockContext } from './serialize';
+
+export class DebugState {
+  readonly #state: DebugVmSnapshot;
+
+  constructor(state: DebugVmSnapshot) {
+    this.#state = state;
+  }
+
+  target(relative: number): number {
+    return this.#state.currentPc + relative;
+  }
+
+  derefHandle<T>(handle: number): T {
+    return this.constants.getValue<T>(decodeHandle(handle));
+  }
+
+  derefArrayHandle<T extends unknown[] = unknown[]>(handle: number): T {
+    return this.constants.getArray<T>(decodeHandle(handle));
+  }
+
+  get stack(): SnapshotArray<unknown> {
+    return this.rawStack;
+  }
+
+  get rawStack(): SnapshotArray<unknown> {
+    return this.#state.frame.stack;
+  }
+
+  get snapshot(): DebugVmSnapshot {
+    return this.#state;
+  }
+
+  get constants(): DebugConstants {
+    return this.#state.constant.constants;
+  }
+
+  get heap(): RuntimeHeap {
+    return this.#state.constant.heap;
+  }
+
+  get dom(): DebugVmSnapshot['dom'] {
+    return this.#state.dom;
+  }
+
+  get frame(): DebugVmSnapshot['frame'] {
+    return this.#state.frame;
+  }
+
+  /**
+   * The next instruction to be executed
+   */
+  get nextPc(): number {
+    return this.#state.$pc;
+  }
+
+  get sp(): number {
+    return this.#state.$sp;
+  }
+
+  get fp(): number {
+    return this.#state.$fp;
+  }
+
+  get symbols(): string[] {
+    return this.#state.constant.block?.debugSymbols ?? [];
+  }
+
+  get registers() {
+    return {
+      frame: pick(this.#state, ['$pc', '$fp', '$sp', '$ra']),
+      saved: pick(this.#state, ['$s0', '$s1']),
+      temporaries: pick(this.#state, ['$t0', '$t1']),
+      return: this.#state.$v0,
+      returnTo: pick(this.#state, ['$v0', '$up']),
+    } as const;
+  }
+}
+export class DebugOpState {
+  readonly #op: OpSnapshot;
+  readonly #debug: { name: string; params: Dict<SomeDisassembledOperand> };
+  readonly #metadata: OpcodeMetadata;
+  readonly #block: SerializeBlockContext;
+
+  constructor(constants: RuntimeConstants, op: OpSnapshot, block: BlockMetadata | null) {
+    this.#op = op;
+
+    const { name, params } = debug(constants, op, block)!;
+    this.#debug = { name, params };
+    this.#metadata = opcodeMetadata(op.type);
+    this.#block = new SerializeBlockContext(block);
+  }
+
+  get metadata(): OpcodeMetadata {
+    return this.#metadata;
+  }
+
+  stack(before: DebugState): StackSpec {
+    return this.#metadata.stack(this.#op, before.snapshot);
+  }
+
+  expectedStackDelta(before: DebugState): number | undefined {
+    return this.stack(before)?.delta;
+  }
+
+  /**
+   * The current instruction, computed by subtracting the size of the opcode from the next
+   * instruction.
+   */
+
+  pos(before: DebugState): number {
+    return before.nextPc - this.#op.size;
+  }
+
+  get name() {
+    return this.#debug.name;
+  }
+
+  get params() {
+    return this.#debug.params;
+  }
+
+  get dynamicParams(): Dict<SomeDisassembledOperand> | null {
+    const entries = Object.entries(this.#debug.params).filter(
+      (entry): entry is [string, SomeDisassembledOperand] => entry[1].isDynamic
+    );
+
+    if (entries.length === 0) {
+      return null;
+    } else {
+      return Object.fromEntries(entries);
+    }
+  }
+
+  describe(): Fragment {
+    const { name, params } = this.#debug;
+
+    let args: IntoFragment[] = Object.entries(params).map(
+      ([p, v]) => frag`${as.attrName(p)}=${this.#serialize(v)}`
+    );
+    return frag`(${join([as.kw(name), ...args], ' ')})`;
+  }
+
+  #serialize(value: SomeDisassembledOperand) {
+    return this.#block.serialize(value);
+  }
+}
+export class DiffState {
+  // readonly #prev: DebugState | undefined;
+  readonly #before: DebugState | undefined;
+  readonly #after: DebugState;
+
+  constructor(prev: DebugState | undefined, before: DebugState | undefined, after: DebugState) {
+    // this.#prev = prev;
+    this.#before = before;
+    this.#after = after;
+  }
+
+  #change<T>(compare: (state: DebugVmSnapshot) => T, create: (value: T) => Fragment) {
+    if (this.#before === undefined) {
+      return create(compare(this.#after.snapshot));
+    }
+
+    const prev = compare(this.#before.snapshot);
+    const current = compare(this.#after.snapshot);
+
+    if (Object.is(prev, current)) {
+      return create(current).subtle().styleAll('subtle');
+    } else {
+      return create(current);
+    }
+  }
+
+  log(logger: DebugLogger, op?: DebugOpState) {
+    logger.log(this.ra);
+    logger.log(this.return);
+    logger.labelled('saved', this.saved);
+    logger.labelled('temporaries', this.temporaries);
+
+    logger.log(tuple(this.#after.registers.frame, { as: intoFragment }).subtle());
+    logger.log(this.up);
+
+    if (op && this.#before) {
+      logger.labelled('frame', this.frame(op.stack(this.#before)));
+    }
+    logger.labelled('scope', this.scope);
+    logger.labelled('updating', this.updating);
+    logger.labelled('destructors', this.destructors);
+
+    logger.labelled('cursors', this.cursors);
+    logger.labelled('constructing', this.constructing);
+    logger.labelled('blocks', this.blocks);
+  }
+
+  change<T>(compare: (state: DebugVmSnapshot) => T, create: (value: T) => Fragment) {
+    if (this.#before === undefined) {
+      return create(compare(this.#after.snapshot));
+    }
+
+    const prev = compare(this.#before.snapshot);
+    const current = compare(this.#after.snapshot);
+
+    if (Object.is(prev, current)) {
+      return create(prev).subtle().styleAll('subtle');
+    } else {
+      return create(prev);
+    }
+  }
+
+  get return(): Fragment {
+    return this.#formatState('$v0', { as: value, desc: 'return value' });
+  }
+
+  get pc(): Fragment {
+    return this.#formatState('$pc', { as: intoFragment }).subtle();
+  }
+
+  get up(): Fragment {
+    return this.#formatState('$up', { as: value });
+  }
+
+  get ra(): Fragment {
+    return this.#formatState('$ra', { as: intoFragment });
+  }
+
+  get saved(): Fragment {
+    const s0 = this.#formatState('$s0', { as: value });
+    const s1 = this.#formatState('$s1', { as: value });
+
+    return array([s0, s1]);
+  }
+
+  get temporaries(): Fragment {
+    const t0 = this.#formatState('$t0', { as: value });
+    const t1 = this.#formatState('$t1', { as: value });
+
+    return array([t0, t1]);
+  }
+
+  get destructors(): Fragment {
+    const befores = this.#before?.snapshot.frame.destructors ?? null;
+    const afters = this.#after?.snapshot.frame.destructors ?? null;
+
+    return describeDiff(diffStacks(befores, afters), { as: stackValue });
+  }
+
+  get updating(): Fragment {
+    const befores = this.#before?.snapshot.frame.updating ?? null;
+    const afters = this.#after?.snapshot.frame.updating ?? null;
+
+    let fragments: [
+      change: 'pops list' | 'pushes' | 'changes' | 'retains' | 'inner',
+      index: number,
+      fragment: Fragment,
+    ][] = [];
+
+    for (const [i, before] of enumerate(befores ?? [])) {
+      const after = afters.at(i);
+
+      if (after === undefined) {
+        fragments.push(['pops list', i, array(before, { as: updatingOpcode })]);
+        continue;
+      }
+
+      if (eqStack(before, after)) {
+        fragments.push([
+          'retains',
+          i,
+          compactArray(after, { as: updatingOpcode, when: { allSubtle: '' } }).subtle(),
+        ]);
+        continue;
+      }
+
+      fragments.push([
+        'changes',
+        i,
+        describeDiff(diffStacks(before, after), { as: updatingOpcode }),
+      ]);
+    }
+
+    const pushAfter = befores?.length ?? 0;
+    const pushes = afters.slice(pushAfter);
+
+    for (const [i, push] of enumerate(pushes)) {
+      fragments.push([
+        'pushes',
+        i + pushAfter,
+        compactArray(push, {
+          as: updatingOpcode,
+          when: { empty: as.specialString('new list'), allSubtle: '' },
+        }),
+      ]);
+    }
+
+    const body = fragments.map(([kind, originalIndex, fragment]) => {
+      const isSubtle = kind === 'changes' && pushes.length === 0;
+      return prepend(frag`  ${String(originalIndex)}. ${kind} `.subtle(isSubtle), fragment);
+    });
+
+    const needsWrapper = fragments.some(([type]) => {
+      return type === 'pops list' || type === 'pushes';
+    });
+
+    if (needsWrapper) {
+      return wrap('[\n', join(body, ',\n'), '\n]');
+    } else {
+      return group(frag`[\n`.subtle(), join(body, ',\n'), frag`\n]`.subtle());
+    }
+  }
+
+  get scope(): Fragment {
+    const before = this.#before?.snapshot.frame.scope ?? null;
+    const after = this.#after?.snapshot.frame.scope ?? null;
+
+    return changeArray(before, after, { eq: eqStack, as: scopeValue, or: value });
+  }
+
+  get cursors(): Fragment {
+    const before = this.#before?.snapshot.dom.inserting ?? null;
+    const after = this.#after?.snapshot.dom.inserting ?? null;
+
+    return describeDiff(diffStacks(before, after, eqCursor), { as: cursor });
+  }
+
+  get constructing(): Fragment {
+    const before = this.#before?.snapshot.dom.constructing ?? null;
+    const after = this.#after?.snapshot.dom.constructing ?? null;
+
+    if ((before === null && after === null) || before === after) {
+      return subtle`(unchanged) ${value(before)}`;
+    }
+
+    if (before === null) {
+      return frag`${subtle`null -> `}${value(after)}`;
+    }
+
+    if (after === null) {
+      return frag`${subtle`${value(before)} -> `}null`;
+    }
+
+    return frag`${subtle`${value(before)} -> `}${value(after)}`;
+  }
+
+  get blocks(): Fragment {
+    const before = this.#before?.snapshot.dom.blocks ?? null;
+    const after = this.#after?.snapshot.dom.blocks ?? null;
+
+    return describeDiff(diffStacks(before ?? [], after ?? [], eqBlock), { as: bounds });
+  }
+
+  frame(spec: StackSpec): Fragment {
+    const before: SnapshotArray<unknown> = this.#before?.stack ?? ([] as const);
+    const after: SnapshotArray<unknown> = this.#after?.stack ?? ([] as const);
+
+    if (spec.type === 'delta' || spec.type === 'unchecked') {
+      if (eqStack(before, after)) {
+        return frag`${as.subtle('(unchanged)')} ${value(before)}`.subtle();
+      }
+
+      return describeDiff(diffStacks(before, after), { as: stackValue });
+    }
+
+    const { before: beforePopped, after: popped } = partitionFromEnd(before, spec.pop);
+    const { before: unused, after: peeked } = partitionFromEnd(beforePopped, spec.peek);
+    const pushed = partitionFromEnd(after, spec.push).after;
+
+    return describeDiff({ unused, peeked, pushed, popped }, { as: stackValue });
+  }
+
+  /**
+   * If the state has changed, returns a fragment that describes the change. Otherwise, returns a
+   * subtle fragment describing the state.
+   */
+  #formatState<K extends keyof DebugVmSnapshot>(
+    key: K,
+    {
+      as: map,
+      desc,
+    }: {
+      as: (value: DebugVmSnapshot[K]) => IntoFragment;
+      desc?: IntoFragment;
+    }
+  ): Fragment {
+    return this.#change(
+      (state) => state[key],
+      (value) => {
+        const description = desc ? frag` (${desc})`.styleAll('comment') : '';
+        return frag`${as.kw(key)}${description}: ${map(value)}`;
+      }
+    );
+  }
+}
+
+function partitionFromEnd<T>(
+  array: readonly T[],
+  position: number
+): { before: readonly T[]; after: readonly T[] } {
+  if (position === 0) {
+    return { before: array, after: [] };
+  } else {
+    return { before: array.slice(0, -position), after: array.slice(-position) };
+  }
+}
diff --git a/packages/@glimmer/debug/lib/snapshot.ts b/packages/@glimmer/debug/lib/snapshot.ts
new file mode 100644
index 0000000000..8b8dd4a326
--- /dev/null
+++ b/packages/@glimmer/debug/lib/snapshot.ts
@@ -0,0 +1,136 @@
+import type {
+  BlockMetadata,
+  Cursor,
+  DebugConstants,
+  DebugCursor,
+  DebugStack,
+  DebugVmSnapshot,
+  Destroyable,
+  LiveBlock,
+  Nullable,
+  RuntimeHeap,
+  ScopeSlot,
+  SimpleElement,
+  UnwindTarget,
+  UpdatingOpcode,
+} from '@glimmer/interfaces';
+
+/**
+ * Snapshot the current state of the VM for debugging. This function should **never** save off live
+ * references to objects managed by the VM, as the state from the `before` debug stage can be used
+ * in the `after` debug stage (for example, to perform stack verification).
+ */
+export function snapshotVM(vm: SnapshottableVM): DebugVmSnapshot {
+  const debug = vm.debug;
+  const dom = debug.dom;
+  const stack = debug.stack.all();
+
+  return {
+    $pc: debug.pc,
+    $sp: debug.sp,
+    $ra: debug.ra,
+    $fp: debug.fp,
+    $up: debug.up,
+    $s0: vm.s0,
+    $s1: vm.s1,
+    $t0: vm.t0,
+    $t1: vm.t1,
+    $v0: vm.v0,
+    currentPc: debug.currentPc,
+
+    // these values don't need to be snapshotted since they (by definition) can't change.
+    constant: {
+      ...debug.constant,
+      block: debug.block.metadata,
+    },
+
+    dom: {
+      constructing: dom.constructing,
+      inserting: snapshotCursors(dom.inserting),
+      blocks: [...dom.blocks] as const,
+    },
+
+    frame: {
+      scope: debug.scope ? ([...debug.scope] as const) : [],
+      stack: stack.frame,
+      before: stack.before,
+      updating: Object.freeze(debug.updating.map((s) => [...s] as const)),
+      destructors: [...debug.destroyable] as const,
+    },
+
+    threw: debug.threw,
+  };
+}
+
+export interface VmDebugState {
+  readonly fp: number;
+  readonly ra: number;
+  readonly pc: number;
+  readonly sp: number;
+  readonly up: UnwindTarget;
+  /**
+   * even though the scope object itself doesn't change, its current scope values do.
+   *
+   * @mutable
+   */
+  readonly scope: Nullable<ScopeSlot[]>;
+
+  readonly updating: UpdatingOpcode[][];
+
+  /** @mutable */
+  readonly destroyable: Destroyable[];
+
+  // The value of $pc minus the size of the current op. Since $pc represents the *next* op, this
+  // produces the position of the current op.
+  readonly currentPc: number;
+
+  readonly dom: {
+    readonly constructing: Nullable<SimpleElement>;
+    /** @mutable */
+    readonly inserting: Cursor[];
+    /** @mutable */
+    readonly blocks: LiveBlock[];
+  };
+
+  // these values change only when the current block changes, so they can be cached and reused
+  // whenever a block change occurs.
+  readonly block: {
+    metadata: BlockMetadata | null;
+  };
+
+  // these values don't ever need to be snapshotted and this object can be cached up front when the
+  // VM is created.
+  readonly constant: {
+    readonly constants: DebugConstants;
+    readonly heap: RuntimeHeap;
+  };
+
+  /** @mutable */
+  readonly stack: DebugStack;
+  readonly threw: Error | undefined;
+}
+
+export interface SnapshottableVM {
+  debug: VmDebugState;
+  s0: unknown;
+  s1: unknown;
+  t0: unknown;
+  t1: unknown;
+  v0: unknown;
+}
+
+function snapshotCursors(cursors: readonly Cursor[]): readonly DebugCursor[] {
+  return cursors.map((cursor) => {
+    const { element, nextSibling } = cursor;
+    if (nextSibling) {
+      return new (class InsertAt {
+        readonly parent = element;
+        readonly next = nextSibling;
+      })();
+    } else {
+      return new (class AppendTo {
+        readonly parent = element;
+      })();
+    }
+  });
+}
diff --git a/packages/@glimmer/debug/lib/stack-check.ts b/packages/@glimmer/debug/lib/stack-check.ts
index b4855f30d5..0cec6d88e2 100644
--- a/packages/@glimmer/debug/lib/stack-check.ts
+++ b/packages/@glimmer/debug/lib/stack-check.ts
@@ -7,16 +7,19 @@ import type {
   SimpleDocumentFragment,
   SimpleElement,
   SimpleNode,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
+import type { SyscallRegister } from '@glimmer/vm';
+import { $s0, $s1, $t0, $t1, $v0 } from '@glimmer/vm';
 
 export interface Checker<T> {
   type: T;
 
   validate(value: unknown): value is T;
   expected(): string;
+  got?: (value: unknown, expected?: string) => string | undefined;
 }
 
-export function wrap<T>(checker: () => Checker<T>): Checker<T> {
+export function WrapCheck<T>(checker: () => Checker<T>): Checker<T> {
   class Wrapped {
     declare type: T;
 
@@ -50,6 +53,20 @@ class TypeofChecker<T> implements Checker<T> {
   }
 }
 
+class NumberChecker extends TypeofChecker<number> {
+  constructor() {
+    super('number');
+  }
+
+  override validate(value: unknown): value is number {
+    return super.validate(value) && Number.isFinite(value);
+  }
+
+  override expected(): string {
+    return `a finite number`;
+  }
+}
+
 export type Primitive = undefined | null | boolean | number | string;
 
 class PrimitiveChecker implements Checker<Primitive> {
@@ -82,6 +99,27 @@ class NullChecker implements Checker<null> {
   }
 }
 
+class SyscallRegisterChecker implements Checker<SyscallRegister> {
+  declare type: SyscallRegister;
+
+  validate(value: unknown): value is SyscallRegister {
+    switch (value) {
+      case $s0:
+      case $s1:
+      case $t0:
+      case $t1:
+      case $v0:
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  expected(): string {
+    return `a syscall register ($s0, $s1, $t0, $t1, or $v0)`;
+  }
+}
+
 class InstanceofChecker<T> implements Checker<T> {
   declare type: T;
 
@@ -96,13 +134,16 @@ class InstanceofChecker<T> implements Checker<T> {
   }
 }
 
-class OptionChecker<T> implements Checker<Nullable<T>> {
-  declare type: Nullable<T>;
+class MaybeChecker<T, Empty extends null | undefined> implements Checker<T | Empty> {
+  declare type: T | Empty;
 
-  constructor(private checker: Checker<T>, private emptyValue: null | undefined) {}
+  constructor(
+    private checker: Checker<T>,
+    private emptyValue: Empty[]
+  ) {}
 
-  validate(value: unknown): value is Nullable<T> {
-    if (value === this.emptyValue) return true;
+  validate(value: unknown): value is T | Empty {
+    if ((this.emptyValue as unknown[]).includes(value)) return true;
     return this.checker.validate(value);
   }
 
@@ -111,25 +152,13 @@ class OptionChecker<T> implements Checker<Nullable<T>> {
   }
 }
 
-class MaybeChecker<T> implements Checker<Maybe<T>> {
-  declare type: Maybe<T>;
-
-  constructor(private checker: Checker<T>) {}
-
-  validate(value: unknown): value is Maybe<T> {
-    if (value === null || value === undefined) return true;
-    return this.checker.validate(value);
-  }
-
-  expected(): string {
-    return `${this.checker.expected()} or null or undefined`;
-  }
-}
-
 class OrChecker<T, U> implements Checker<T | U> {
   declare type: T | U;
 
-  constructor(private left: Checker<T>, private right: Checker<U>) {}
+  constructor(
+    private left: Checker<T>,
+    private right: Checker<U>
+  ) {}
 
   validate(value: unknown): value is T | U {
     return this.left.validate(value) || this.right.validate(value);
@@ -143,7 +172,10 @@ class OrChecker<T, U> implements Checker<T | U> {
 class ExactValueChecker<T> implements Checker<T> {
   declare type: T;
 
-  constructor(private value: T, private desc: string) {}
+  constructor(
+    private value: T,
+    private desc: string
+  ) {}
 
   validate(obj: unknown): obj is T {
     return obj === this.value;
@@ -254,6 +286,7 @@ class SafeStringChecker implements Checker<SafeString> {
 
   validate(value: unknown): value is SafeString {
     return (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any -- @todo
       typeof value === 'object' && value !== null && typeof (value as any).toHTML === 'function'
     );
   }
@@ -267,17 +300,21 @@ export function CheckInstanceof<T>(Class: Constructor<T>): Checker<T> {
   return new InstanceofChecker<T>(Class);
 }
 
-export function CheckOption<T>(checker: Checker<T>): Checker<Nullable<T>> {
-  return new OptionChecker(checker, null);
+export function CheckNullable<T>(checker: Checker<T>): Checker<Nullable<T>> {
+  return new MaybeChecker(checker, [null]);
+}
+
+export function CheckOptional<T>(checker: Checker<T>): Checker<Maybe<T>> {
+  return new MaybeChecker(checker, [undefined]);
 }
 
 export function CheckMaybe<T>(checker: Checker<T>): Checker<Maybe<T>> {
-  return new MaybeChecker(checker);
+  return new MaybeChecker(checker, [null, undefined]);
 }
 
 export function CheckInterface<
   I extends { [P in keyof O]: O[P]['type'] },
-  O extends Dict<Checker<unknown>>
+  O extends Dict<Checker<unknown>>,
 >(obj: O): Checker<I> {
   return new PropertyChecker(obj);
 }
@@ -290,8 +327,12 @@ export function CheckDict<T>(obj: Checker<T>): Checker<Dict<T>> {
   return new DictChecker(obj);
 }
 
+export const CheckSyscallRegister = new SyscallRegisterChecker();
+
 function defaultMessage(value: unknown, expected: string): string {
-  return `Got ${value}, expected:\n${expected}`;
+  const actual =
+    value === null ? `null` : typeof value === 'string' ? value : `some ${typeof value}`;
+  return `Got ${actual}, expected:${expected.includes('\n') ? `\n${expected}` : ` ${expected}`}`;
 }
 
 export function check<T>(
@@ -303,8 +344,23 @@ export function check<T, U extends T>(value: T, checker: (value: T) => asserts v
 export function check<T>(
   value: unknown,
   checker: Checker<T> | ((value: unknown) => void),
-  message: (value: unknown, expected: string) => string = defaultMessage
+  message?: (value: unknown, expected: string) => string
 ): T {
+  if (!message) {
+    if (typeof checker === 'function') {
+      message = defaultMessage;
+    } else {
+      const got = checker.got;
+      if (!got) {
+        message = defaultMessage;
+      } else {
+        message = (value: unknown, expected: string) => {
+          return defaultMessage(got(value) ?? value, expected);
+        };
+      }
+    }
+  }
+
   if (typeof checker === 'function') {
     checker(value);
     return value as T;
@@ -334,7 +390,7 @@ export function expectStackChange(stack: { sp: number }, expected: number, name:
 
 export const CheckPrimitive: Checker<Primitive> = new PrimitiveChecker();
 export const CheckFunction: Checker<Function> = new TypeofChecker<Function>('function');
-export const CheckNumber: Checker<number> = new TypeofChecker<number>('number');
+export const CheckNumber: Checker<number> = new NumberChecker();
 export const CheckBoolean: Checker<boolean> = new TypeofChecker<boolean>('boolean');
 export const CheckHandle: Checker<number> = CheckNumber;
 export const CheckString: Checker<string> = new TypeofChecker<string>('string');
@@ -356,7 +412,7 @@ export const CheckBlockSymbolTable: Checker<BlockSymbolTable> = CheckInterface({
 });
 
 export const CheckProgramSymbolTable: Checker<ProgramSymbolTable> = CheckInterface({
-  hasEval: CheckBoolean,
+  hasDebug: CheckBoolean,
   symbols: CheckArray(CheckString),
 });
 
diff --git a/packages/@glimmer/debug/lib/stack/declared/define-operand.ts b/packages/@glimmer/debug/lib/stack/declared/define-operand.ts
new file mode 100644
index 0000000000..9d4d79baf1
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/declared/define-operand.ts
@@ -0,0 +1,56 @@
+import { NULL_HANDLE } from '@glimmer/util';
+
+import type { NullableName } from '../../debug';
+import type { FallibleVmCheck, InfallibleVmCheck, VmCheck } from '../types';
+import type { OperandSpecName } from './operands';
+import type { NamedSpecValue } from './shared';
+
+export type VmOperandCheck<N extends OperandSpecName = OperandSpecName> = VmCheck<number, N>;
+
+export function define<const N extends OperandSpecName>(
+  name: N,
+  unpack: InfallibleVmCheck<number, N>['unpack']
+): VmOperandCheck<N> {
+  return { name, unpack };
+}
+
+define.fallible = <const N extends OperandSpecName>(
+  name: N,
+  expected: string,
+  unpack: FallibleVmCheck<number, N>['unpack']
+) => {
+  return {
+    name,
+    expected,
+    unpack,
+  };
+};
+
+export function nullable<N extends NullableName<OperandSpecName>>(
+  spec: VmOperandCheck<N>
+): VmOperandCheck<`${N}?`> {
+  if ('expected' in spec) {
+    return {
+      name: `${spec.name}?`,
+      expected: `a nullable ${spec.expected}`,
+      unpack: (value, debug) => {
+        if (value === NULL_HANDLE) {
+          return null as any;
+        } else {
+          return spec.unpack(value, debug);
+        }
+      },
+    };
+  } else {
+    return {
+      name: `${spec.name}?`,
+      unpack: (value, debug) => {
+        if (value === NULL_HANDLE) {
+          return null as unknown as NamedSpecValue<`${N}?`>;
+        } else {
+          return spec.unpack(value, debug) as unknown as NamedSpecValue<`${N}?`>;
+        }
+      },
+    };
+  }
+}
diff --git a/packages/@glimmer/debug/lib/stack/declared/define-runtime-value.ts b/packages/@glimmer/debug/lib/stack/declared/define-runtime-value.ts
new file mode 100644
index 0000000000..7c4222d3da
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/declared/define-runtime-value.ts
@@ -0,0 +1,56 @@
+import type { NullableName } from '../../debug';
+import type { FallibleVmCheck, InfallibleVmCheck, VmCheck } from '../types';
+import type { RuntimeValueSpecName } from './runtime-value';
+import type { NamedSpecValue } from './shared';
+
+export type VmRuntimeValueCheck<N extends RuntimeValueSpecName> = VmCheck<unknown, N>;
+
+export function infallible<const N extends RuntimeValueSpecName>(
+  name: N,
+  unpack: InfallibleVmCheck<unknown, N>['unpack']
+): VmRuntimeValueCheck<N> {
+  return { name, unpack };
+}
+
+export function define<const N extends RuntimeValueSpecName>(
+  name: N,
+  expected: string,
+  unpack: FallibleVmCheck<unknown, N>['unpack']
+) {
+  return {
+    name,
+    expected,
+    unpack,
+  };
+}
+
+define.infallible = infallible;
+
+export function nullable<N extends NullableName<RuntimeValueSpecName>>(
+  spec: VmRuntimeValueCheck<N>
+): VmRuntimeValueCheck<`${N}?`> {
+  if ('expected' in spec) {
+    return {
+      name: `${spec.name}?`,
+      expected: `a nullable ${spec.expected}`,
+      unpack: (value, debug) => {
+        if (value === null) {
+          return null as any;
+        } else {
+          return spec.unpack(value, debug);
+        }
+      },
+    };
+  } else {
+    return {
+      name: `${spec.name}?`,
+      unpack: (value, debug) => {
+        if (value === null) {
+          return null as unknown as NamedSpecValue<`${N}?`>;
+        } else {
+          return spec.unpack(value, debug) as unknown as NamedSpecValue<`${N}?`>;
+        }
+      },
+    };
+  }
+}
diff --git a/packages/@glimmer/debug/lib/stack/declared/operands.ts b/packages/@glimmer/debug/lib/stack/declared/operands.ts
new file mode 100644
index 0000000000..cc947fa793
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/declared/operands.ts
@@ -0,0 +1,197 @@
+import type { ComponentDefinition, Nullable } from '@glimmer/interfaces';
+import { decodeHandle, decodeImmediate, isHandle } from '@glimmer/util';
+import {
+  $fp,
+  $s0,
+  $s1,
+  $sp,
+  $t0,
+  $t1,
+  $v0,
+  CURRIED_COMPONENT,
+  CURRIED_HELPER,
+  CURRIED_MODIFIER,
+} from '@glimmer/vm';
+
+import type { Primitive } from '../../stack-check';
+import type { AnyFunction } from './shared';
+
+import { define, nullable } from './define-operand';
+import { MISMATCH, ok } from './shared';
+
+export const ImmU32 = define('unsigned', (value) => {
+  return value;
+});
+
+// The program counter relative to the start of the current
+// intstruction.
+export const ImmRelativeInstruction = define('instruction/relative', (value, vm) =>
+  vm.target(value)
+);
+
+// An absolute instruction.
+export const ImmInstruction = define('instruction', (value) => value);
+
+export const BlockHandle = define('handle/block', (handle, debug) => debug.heap.getaddr(handle));
+
+export const ConstAny = define('const/any', (value, vm) => vm.derefHandle<unknown>(value));
+
+export const ConstI32Arr = define('const/number[]', (value, { constants }) =>
+  constants.getArray<number[]>(value)
+);
+
+export const ConstAnyArr = define('const/any[]', (handle, vm) =>
+  vm.derefArrayHandle<unknown[]>(handle)
+);
+
+export const ConstStrArr = define('const/string[]', (handle, vm) =>
+  vm.derefArrayHandle<string[]>(handle)
+);
+
+export const ConstNullableStrArr = nullable(ConstStrArr);
+
+export const ConstComponentDefinition = define('const/definition<component>', (handle, vm) =>
+  vm.derefHandle<ComponentDefinition>(handle)
+);
+
+export const EncodedPrimitive = define('primitive', (encoded, { constants }) => {
+  if (isHandle(encoded)) {
+    return constants.getValue(decodeHandle(encoded));
+  } else {
+    return decodeImmediate(encoded);
+  }
+});
+
+export const Variable = define('variable', (symbol, debug) => {
+  const symbols = debug.symbols;
+
+  // the 0th symbol is always 'this', so it's not included in debug symbols
+  const offset = symbol - 1;
+  return { name: symbols[offset] ?? null, symbol };
+});
+
+export const CopyingVariable = define('variable/copying', (symbol) => symbol);
+
+export const ArgFlags = define('flags/args', (flags) => {
+  const positionalCount = flags >> 4;
+  const atNames = flags & 0b1000;
+  const hasBlocks = flags & 0b0111;
+
+  return {
+    positional: positionalCount,
+    hasAtNames: !!atNames,
+    hasBlocks: !!hasBlocks,
+  };
+});
+
+export const StackRegister = define.fallible(
+  'register/sp',
+  `a stack register ($sp or $fp)`,
+  (register, vm) => {
+    switch (register) {
+      case $sp:
+        return ok(vm.sp);
+      case $fp:
+        return ok(vm.fp);
+      default:
+        return MISMATCH;
+    }
+  }
+);
+
+export const SavedRegister = define.fallible(
+  'register/saved',
+  `a saved register ($s0 or $s1)`,
+  (register, vm) => {
+    switch (register) {
+      case $s0:
+        return ok(['s0', vm.registers.saved.$s0]);
+      case $s1:
+        return ok(['s1', vm.registers.saved.$s1]);
+      default:
+        return MISMATCH;
+    }
+  }
+);
+
+export const SyscallRegister = define.fallible(
+  'register/syscall',
+  `a syscall register ($s0, $s1, $t0, $t1, or $v0)`,
+  (register, vm) => {
+    switch (register) {
+      case $s0:
+        return ok(['s0', vm.registers.saved.$s0]);
+      case $s1:
+        return ok(['s1', vm.registers.saved.$s1]);
+      case $t0:
+        return ok(['t0', vm.registers.temporaries.$t0]);
+      case $t1:
+        return ok(['t1', vm.registers.temporaries.$t1]);
+      case $v0:
+        return ok(['v0', vm.registers.return]);
+      default:
+        return MISMATCH;
+    }
+  }
+);
+
+export const ConstBool = define('const/boolean', (handle, vm) => vm.derefHandle<boolean>(handle));
+
+export const ConstString = define('const/string', (handle, vm) => vm.derefHandle<string>(handle));
+export const ConstNullableString = nullable(ConstString);
+
+export const HelperHandle = define('const/function', (handle, vm) => {
+  // @premerge should this be decodeHandle? It's not what happens at runtime,
+  // but that's probably just because decodeHandle doesn't do anything other
+  // than debug-time verification so it wouldn't have been missed?
+  return vm.constants.getValue<AnyFunction>(handle);
+});
+
+export const CurryType = define.fallible('enum<curry>', 'a curry type (0, 1 or 2)', (value) => {
+  switch (value) {
+    case CURRIED_COMPONENT:
+      return ok('component');
+    case CURRIED_HELPER:
+      return ok('helper');
+    case CURRIED_MODIFIER:
+      return ok('modifier');
+    default:
+      return MISMATCH;
+  }
+});
+
+export type OperandSpec =
+  | readonly ['const/any[]', unknown[]]
+  | readonly ['const/number[]', number[]]
+  | readonly ['const/string[]', string[]]
+  | readonly ['const/string[]?', Nullable<string[]>]
+  | readonly ['const/boolean', boolean]
+  | readonly ['const/string', string]
+  | readonly ['const/string?', Nullable<string>]
+  | readonly ['const/function', AnyFunction]
+  | readonly ['const/any', unknown]
+  // if the name is null, it's unknown for some reason.
+  | readonly ['variable', { name: Nullable<string>; symbol: number }]
+  | readonly ['variable/block', { name: Nullable<string>; symbol: number }]
+  // @todo symbols are copied before their block is processed, so we don't have
+  // the block's containing meta yet.
+  | readonly ['variable/copying', number]
+  | readonly ['const/definition<component>', ComponentDefinition]
+  | readonly ['primitive', Primitive]
+  | readonly ['handle/block', number]
+  | readonly ['instruction', number]
+  | readonly ['instruction/relative', number]
+  | readonly [`register/syscall`, readonly ['s0' | 's1' | 't0' | 't1' | 'v0', unknown]]
+  | readonly [`register/saved`, readonly ['s0' | 's1', unknown]]
+  | readonly ['register/temporary', readonly ['t0' | 't1', unknown]]
+  | readonly ['register/v0', unknown]
+  | readonly ['register/sp', number]
+  | readonly ['enum<curry>', 'component' | 'helper' | 'modifier']
+  | readonly ['register/fp', number]
+  | readonly ['flags/args', { positional: number; hasAtNames: boolean; hasBlocks: boolean }]
+  | readonly ['signed', number]
+  | readonly ['unsigned', number]
+  | readonly ['error', { expected: string; got: number }];
+
+export type OperandSpecName = OperandSpec[0];
+export type OperandSpecValue = OperandSpec[1];
diff --git a/packages/@glimmer/debug/lib/stack/declared/runtime-value.ts b/packages/@glimmer/debug/lib/stack/declared/runtime-value.ts
new file mode 100644
index 0000000000..faddcae4bf
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/declared/runtime-value.ts
@@ -0,0 +1,93 @@
+import type {
+  BlockSymbolTable,
+  CompilableBlock,
+  Nullable,
+  Scope,
+  ScopeBlock,
+} from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
+import type { AnyFunction } from '@glimmer/util';
+import { readReactive  } from '@glimmer/reference';
+
+import type { DebugState } from '../../render/state';
+import type { FallibleCheckResult } from '../types';
+
+import { isReference } from '../../utils';
+import { define } from './define-runtime-value';
+import { MISMATCH, ok } from './shared';
+
+export const RegisterRa = define(
+  'register/ra',
+  'the value of the $ra register',
+  (value, debug: DebugState) => {
+    return value === debug.registers.frame.$ra ? ok(value) : MISMATCH;
+  }
+);
+
+export const RefFunction = define('ref/function', 'a function ref', (reference) => {
+  if (isReference(reference)) {
+    return deref(reference, (value): value is AnyFunction => typeof value === 'function');
+  } else {
+    return MISMATCH;
+  }
+});
+
+function deref<const T, const U extends T>(
+  reference: Reactive<T>,
+  check: (value: T) => value is U
+): FallibleCheckResult<Deref<U>> {
+  try {
+    const result = readReactive(reference);
+
+    if (result.type === 'err') {
+      return { error: 'deref', threw: result.value };
+    }
+
+    const value = result.value;
+
+    if (check(value)) {
+      return ok({
+        reference: reference as unknown as Reactive<U>,
+        value,
+      } satisfies Deref<U>);
+    } else {
+      return MISMATCH;
+    }
+  } catch (e) {
+    return { error: 'deref', threw: e };
+  }
+}
+
+export type DebugTypeName = RuntimeValueSpec[0];
+export interface ErrorSpec {
+  readonly expected: string;
+  readonly got: number;
+}
+
+// Ideally this would have a type because we'd like to be able to present it in
+// the debugger.
+type TODO = unknown;
+
+interface Deref<T> {
+  readonly reference: Reactive<T>;
+  readonly value: T;
+}
+
+export type RuntimeValueSpec =
+  | readonly ['register/ra', number]
+  | readonly ['ref/function', Deref<AnyFunction>]
+  | readonly ['ref/function?', Nullable<Deref<AnyFunction>>]
+  | readonly ['ref/boolean', Deref<boolean>]
+  | readonly ['ref/any', Deref<unknown>]
+  | readonly ['block/compilable', CompilableBlock]
+  | readonly ['block/compilable?', Nullable<CompilableBlock>]
+  | readonly ['block/scope', ScopeBlock]
+  | readonly ['block/scope?', Nullable<ScopeBlock>]
+  | readonly ['scope', Scope]
+  | readonly ['table/block', BlockSymbolTable]
+  | readonly ['table/block?', Nullable<BlockSymbolTable>]
+  | readonly ['args', TODO]
+  // basically dynamic for now -- meant to be used with `peek`
+  | readonly ['stack/args', void]
+  | readonly ['deref/error', Error];
+export type RuntimeValueSpecName = RuntimeValueSpec[0];
diff --git a/packages/@glimmer/debug/lib/stack/declared/shared.ts b/packages/@glimmer/debug/lib/stack/declared/shared.ts
new file mode 100644
index 0000000000..d2e0e9857d
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/declared/shared.ts
@@ -0,0 +1,25 @@
+import type { OperandSpec, OperandSpecName } from './operands';
+import type { RuntimeValueSpec, RuntimeValueSpecName } from './runtime-value';
+
+/** @deprecated import directly from `@glimmer/util` */
+export type { AnyFunction } from '@glimmer/util';
+
+export interface ErrorSpec {
+  readonly expected: string;
+  readonly got: number;
+}
+
+export const MISMATCH = { error: 'mismatch' } as const;
+export type MISMATCH = typeof MISMATCH;
+
+export function ok<const T>(value: T): { ok: T } {
+  return { ok: value };
+}
+
+export type Spec = OperandSpec | RuntimeValueSpec;
+export type SpecName = OperandSpecName | RuntimeValueSpecName;
+export type NamedSpecValue<N extends SpecName> = NamedSpec<N>[1];
+export type NamedSpec<N extends SpecName> = Extract<Spec, { 0: N }>;
+
+export type TypedSpec<T = Spec[1]> = Spec & [string, T];
+export type TypedSpecName<T> = TypedSpec<T>[0];
diff --git a/packages/@glimmer/debug/lib/stack/define-metadata.ts b/packages/@glimmer/debug/lib/stack/define-metadata.ts
new file mode 100644
index 0000000000..ed1061e34c
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/define-metadata.ts
@@ -0,0 +1,211 @@
+import type { Expand, VmOpName } from '@glimmer/interfaces';
+
+import type { SpecName } from './declared/shared';
+import type { OpcodeSpec, OpSpec, StackParamSpec, StackSpec, StateSpec } from './types';
+
+type Mutable<T> = { -readonly [P in keyof T]: T[P] };
+
+interface MutableInitializeStack {
+  params: StackParamSpec[];
+  pushes: SpecName[] | 'frame:change';
+}
+
+type Spread<T, U> = {
+  [P in keyof T]: P extends keyof U ? U[P] : T[P];
+};
+
+export class Define<O extends OpSpec> {
+  static done<O extends OpSpec>(define: Define<O>): O {
+    return define.#spec;
+  }
+
+  readonly #spec: O;
+
+  constructor(spec: O) {
+    this.#spec = spec;
+  }
+
+  ops<Opcodes extends OpcodeSpec>(...ops: Opcodes): Define<Spread<O, { ops: Opcodes }>> {
+    (this.#spec as Mutable<O>).ops = ops;
+    return this as any;
+  }
+
+  reads<const S extends readonly StateSpec[]>(
+    ...reads: S
+  ): Define<Spread<O, { readonly reads: S }>> {
+    (this.#spec as Mutable<O>).reads = reads;
+    return this as any;
+  }
+
+  changes<const S extends readonly StateSpec[]>(
+    ...changes: S
+  ): Define<Spread<O, { readonly changes: S }>> {
+    (this.#spec as Mutable<O>).changes = changes;
+    return this as any;
+  }
+
+  changesFrame(): Define<O> {
+    this.#initializedStack().pushes = 'frame:change';
+    return this as any;
+  }
+
+  #initializedStack(): MutableInitializeStack {
+    if (!this.#spec.stack || typeof this.#spec.stack === 'string') {
+      (this.#spec as Mutable<OpSpec>).stack = {
+        params: [],
+        pushes: [],
+      } as const;
+    }
+
+    return this.#spec.stack as Mutable<{
+      params: StackParamSpec[];
+      pushes: SpecName[];
+    }>;
+  }
+
+  unchanged(): Define<Spread<O, { stack: { params: []; pushes: [] } }>> {
+    (this.#spec as Mutable<O>).stack = {
+      params: [],
+      pushes: [],
+    };
+    return this as any;
+  }
+
+  pushes<S extends SpecName[]>(
+    ...pushes: S
+  ): Define<
+    Spread<
+      O,
+      {
+        stack: {
+          params: O['stack']['params'];
+          pushes: S;
+        };
+      }
+    >
+  > {
+    this.#initializedStack().pushes = pushes;
+    return this as any;
+  }
+
+  pops<Name extends string, Param extends SpecName>(
+    name: Name,
+    param: Param
+  ): Define<
+    Spread<
+      O,
+      {
+        stack: {
+          params: [...O['stack']['params'], [`pop:${Name}`, Param]];
+          pushes: O['stack']['pushes'];
+        };
+      }
+    >
+  > {
+    this.#initializedStack().params.push([`pop:${name}`, param]);
+    return this as any;
+  }
+
+  peeks<Name extends string, Param extends SpecName>(
+    name: Name,
+    param: Param
+  ): Define<
+    Spread<
+      O,
+      {
+        stack: {
+          params: [...StackSpec['params'], [`peek:${Name}`, Param]];
+          pushes: O['stack']['pushes'];
+        };
+      }
+    >
+  >;
+  peeks<Name extends string, Param extends SpecName>(
+    name: Name,
+    param: Param,
+    options: { from: '$fp' }
+  ): Define<
+    Spread<
+      O,
+      {
+        stack: {
+          params: [...StackSpec['params'], [`peek:${Name}`, Param, { from: '$fp' }]];
+          pushes: O['stack']['pushes'];
+        };
+      }
+    >
+  >;
+  peeks<Name extends string, Args extends [type: SpecName, options?: { from: '$fp' }]>(
+    name: Name,
+    ...args: Args
+  ) {
+    this.#initializedStack().params.push([`peek:${name}`, ...args]);
+    return this as any;
+  }
+}
+
+interface InitialOpSpec<N extends VmOpName> {
+  name: N;
+  ops: [];
+  stack: {
+    params: [];
+    pushes: [];
+  };
+  reads: [];
+  changes: [];
+  throws: false;
+}
+
+export function define<
+  N extends VmOpName,
+  const Build extends (define: Define<InitialOpSpec<N>>) => Define<OpSpec>,
+>(
+  name: N,
+  build: Build
+): Expand<
+  ReturnType<Build> extends Define<infer O>
+    ? {
+        // sort the keys in the same order as OpSpec
+        [P in keyof OpSpec]: O[P];
+      }
+    : never
+> {
+  const builder = new Define({
+    name,
+    ops: [],
+    stack: { params: [], pushes: [] },
+    reads: [],
+    changes: [],
+    throws: false,
+  } satisfies InitialOpSpec<N>);
+  const define = build(builder);
+  return Define.done(define) as any;
+}
+
+define.throws = <
+  N extends VmOpName,
+  const Build extends (
+    define: Define<Spread<InitialOpSpec<N>, { throws: true }>>
+  ) => Define<OpSpec>,
+>(
+  name: N,
+  build: Build
+): Expand<
+  ReturnType<Build> extends Define<infer O>
+    ? {
+        // sort the keys in the same order as OpSpec
+        [P in keyof OpSpec]: O[P];
+      }
+    : never
+> => {
+  const builder = new Define({
+    name,
+    ops: [],
+    stack: { params: [], pushes: [] },
+    reads: [],
+    changes: [],
+    throws: true,
+  } satisfies Spread<InitialOpSpec<N>, { throws: true }>);
+  const define = build(builder);
+  return Define.done(define) as any;
+};
diff --git a/packages/@glimmer/debug/lib/stack/params.ts b/packages/@glimmer/debug/lib/stack/params.ts
new file mode 100644
index 0000000000..2326db31df
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/params.ts
@@ -0,0 +1,234 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Dict, Expand, RETURN_TYPE, VM } from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import { INTERNAL_REFERENCE as REFERENCE } from '@glimmer/reference';
+import { enumerate, isObject } from '@glimmer/util';
+
+export const UNCHANGED = Symbol('UNCHANGED');
+
+type ErrorInfo =
+  | { type: 'record'; errors: Record<string, ErrorInfo> }
+  | { type: 'list'; errors: Record<number, ErrorInfo> }
+  | { type: 'leaf'; expected: string };
+
+type CoerceResult<T> = ['ok', T] | [status: 'fail', aggregate: ErrorInfo];
+
+type LazyStackType<T, Default extends string = any> =
+  | (<N extends string>(name: N) => StackType<N | Default, T>)
+  | (() => StackType<Default, T>);
+
+const Ok = <T>(value: T): CoerceResult<T> => ['ok', value];
+const Fail = <T>(expected: string): CoerceResult<T> => ['fail', { type: 'leaf', expected }];
+
+interface StackType<N extends string, T = unknown> {
+  readonly name: N;
+  coerce: Coerce<T>;
+}
+
+type Coerce<T> = (item: unknown, vm: VM) => CoerceResult<T>;
+
+function define<const T extends Record<string, <N extends string>(name: N) => StackType<N>>>(
+  types: T
+): Expand<{
+  [N in Extract<keyof T, string>]: StackType<N, T[N] extends LazyStackType<infer U> ? U : T[N]>;
+}> {
+  return Object.entries(types).reduce(
+    (acc, [name, build]) => ({
+      ...acc,
+      [name]: build(name),
+    }),
+    {}
+  ) as RETURN_TYPE;
+}
+
+const IsReference = {
+  name: 'reference',
+  coerce: (value) => {
+    return isObject(value) && REFERENCE in value ? Ok(value as Reactive) : Fail('reference');
+  },
+} satisfies StackType<'reference', Reactive>;
+
+export const types = define({
+  'imm/bool': pipe(isBool, (value) => !!value),
+  'imm/i32': coerce(isI32),
+
+  args: instance(Object),
+  'args/captured': IsInterface({
+    positional: IsArray(IsReference),
+    named: IsDict(IsReference),
+  }),
+});
+
+function IsArray<N extends string, T>(kind: StackType<N, T>): LazyStackType<T[], `${N}[]`> {
+  return () => ({
+    name: `${kind.name}[]` as const,
+    coerce: (value: unknown, vm: VM): CoerceResult<T[]> => {
+      let errors: Record<number, ErrorInfo> = {};
+
+      if (!Array.isArray(value)) {
+        return Fail(`${kind.name}[]`);
+      }
+
+      for (let [i, item] of enumerate(value)) {
+        let result = kind.coerce(item, vm);
+        if (result[0] === 'fail') {
+          errors[i] = result[1];
+        }
+      }
+
+      if (Object.keys(errors).length > 0) {
+        return ['fail', { type: 'list', errors }];
+      } else {
+        return Ok(value as T[]);
+      }
+    },
+  });
+}
+
+function IsDict<N extends string, T>(kind: StackType<N, T>): LazyStackType<Dict<T>, `Dict<${N}>`> {
+  return () => ({
+    name: `Dict<${kind.name}>` as const,
+    coerce: (value: unknown, vm: VM): CoerceResult<Dict<T>> => {
+      let errors: Record<string, ErrorInfo> = {};
+
+      if (!isObject(value)) {
+        return Fail(`Dict<${kind.name}>`);
+      }
+
+      for (let [key, item] of Object.entries(value)) {
+        let result = kind.coerce(item, vm);
+        if (result[0] === 'fail') {
+          errors[key] = result[1];
+        }
+      }
+
+      if (Object.keys(errors).length > 0) {
+        return ['fail', { type: 'list', errors }];
+      } else {
+        return Ok(value as Dict<T>);
+      }
+    },
+  });
+}
+
+function pipe<T, U = T>(
+  check: (value: unknown) => value is T,
+  then: (value: T) => U = (value: T) => value as unknown as U
+): LazyStackType<U, never> {
+  return (name) => ({
+    name,
+    coerce: (value) => {
+      if (check(value)) {
+        return Ok(then(value));
+      } else {
+        return Fail(name);
+      }
+    },
+  });
+}
+
+function coerce<T>(check: (value: unknown) => value is T): LazyStackType<T> {
+  return (name) => ({
+    name,
+    coerce: (value) => {
+      if (check(value)) {
+        return Ok(value);
+      } else {
+        return Fail(name);
+      }
+    },
+  });
+}
+
+function instance<T>(Class: abstract new (...args: any[]) => T): LazyStackType<T, never> {
+  return (name) => ({
+    name,
+    coerce: (item) => (item instanceof Class ? Ok(item) : Fail(`instanceof ${Class.name}`)),
+  });
+}
+
+type GetInterface<R extends Record<string, LazyStackType<any, any>>> = Expand<{
+  [K in keyof R]: ReturnType<R[K]>;
+}>;
+
+function IsInterface<R extends Record<string, LazyStackType<any, any>>>(
+  record: R
+): LazyStackType<GetInterface<R>, never> {
+  return (name) => ({
+    name,
+    coerce: (item, vm) => {
+      let errors: Record<string, ErrorInfo> = {};
+
+      for (let [key, type] of Object.entries(record)) {
+        let [result, err] = type(key).coerce(item, vm);
+
+        if (result === 'fail') {
+          errors[key] = err;
+        }
+      }
+
+      if (Object.keys(errors).length > 0) {
+        return ['fail', { type: 'record', errors }];
+      } else {
+        return Ok(item as GetInterface<R>);
+      }
+    },
+  });
+}
+
+function isBool(value: unknown): value is boolean {
+  return value === 0 || value === 1;
+}
+
+function isI32(value: unknown): value is number {
+  return typeof value === 'number' && value <= 0x7fffffff;
+}
+
+// @note STACK_TYPES
+export const STACK_TYPES = [
+  'block/template',
+  'block/invocation',
+  // a block is a pair of [block/table, block/handle]
+  'block/table',
+  'block/handle',
+  'block/table?',
+  'block/handle?',
+
+  'component/definition',
+  'component/%definition',
+  'component/%value',
+  'component/instance',
+
+  // either a block or program table
+  'table',
+  'scope',
+  'bool',
+
+  'args',
+  'args/captured',
+
+  // $pc or $ra
+  'register/instruction',
+  // $sp or $fp
+  'register/stack',
+
+  'reference/bool',
+  'reference/any',
+  'reference/fn',
+  'reference/definition',
+
+  'i32',
+  'i32/todo',
+
+  /**
+   * {@linkcode ContentType | Content Type Enum}
+   */
+  'enum/ctype',
+
+  'glimmer/iterator',
+
+  'value/dynamic',
+  'value/str',
+
+  UNCHANGED,
+] as const;
diff --git a/packages/@glimmer/debug/lib/stack/types.ts b/packages/@glimmer/debug/lib/stack/types.ts
new file mode 100644
index 0000000000..0aa4c977d0
--- /dev/null
+++ b/packages/@glimmer/debug/lib/stack/types.ts
@@ -0,0 +1,69 @@
+import type { DebugState } from '../render/state';
+import type { OperandSpecValue } from './declared/operands';
+import type { MISMATCH, NamedSpecValue, SpecName, TypedSpecName } from './declared/shared';
+
+export type StackParamSpec<T = unknown> =
+  | readonly [op: `peek:${string}`, name: TypedSpecName<T>, options?: { from: '$fp' }]
+  | readonly [op: `pop:${string}`, name: TypedSpecName<T>];
+
+export interface StackSpec {
+  readonly params: readonly StackParamSpec[];
+  readonly pushes: readonly SpecName[] | ['frame:change'];
+}
+
+export type Operand<T extends OperandSpecValue> = [op: string, name: TypedSpecName<T>];
+
+type MachineRegisterName = '$ra' | '$sp' | '$fp' | '$pc';
+type ValueRegisterName = '$s0' | '$s1' | '$t0' | '$t1' | '$v0';
+type UnwindRegisterName = '$up';
+type VmStateName =
+  | 'owner'
+  | ['lexical-scope/value', TypedSpecName<number>]
+  | ['lexical-scope/block', TypedSpecName<number>]
+  // changes the entire lexical scope
+  | 'scope'
+  | 'dynamic-scope/value'
+  | 'destroyable';
+
+export type StateSpec =
+  | MachineRegisterName
+  | UnwindRegisterName
+  | VmStateName
+  | [ValueRegisterName, SpecName];
+
+export type OpcodeSpec<A = unknown, B = unknown, C = unknown> =
+  | readonly []
+  | readonly [Operand<A>]
+  | readonly [Operand<A>, Operand<B>]
+  | readonly [Operand<A>, Operand<B>, Operand<C>];
+
+export interface OpSpec {
+  readonly name: string;
+  readonly ops: OpcodeSpec;
+  readonly stack: StackSpec;
+  readonly reads: readonly StateSpec[];
+  readonly changes: readonly StateSpec[];
+  readonly throws: boolean;
+}
+export interface DebugNarrow<Wide, In extends Wide> {
+  readonly expected: string;
+  coerce: (value: Wide, debug: DebugState) => In | MISMATCH;
+}
+
+export type FallibleCheckResult<T> =
+  | { ok: T }
+  | { error: 'mismatch' }
+  | { error: 'deref'; threw: unknown };
+
+export type FallibleVmCheck<In, N extends SpecName> = {
+  readonly name: N;
+  readonly expected: string;
+  readonly unpack: (value: In, debug: DebugState) => FallibleCheckResult<NamedSpecValue<N>>;
+};
+
+export type InfallibleVmCheck<In, N extends SpecName> = {
+  readonly name: N;
+  readonly unpack: (value: In, debug: DebugState) => NamedSpecValue<N>;
+};
+
+export type VmCheck<In, N extends SpecName> = FallibleVmCheck<In, N> | InfallibleVmCheck<In, N>;
diff --git a/packages/@glimmer/debug/lib/utils.ts b/packages/@glimmer/debug/lib/utils.ts
new file mode 100644
index 0000000000..3eed23ddc6
--- /dev/null
+++ b/packages/@glimmer/debug/lib/utils.ts
@@ -0,0 +1,422 @@
+import type { Nullable, Optional, Reactive, VmOpName } from '@glimmer/interfaces';
+import { INTERNAL_REFERENCE } from '@glimmer/reference';
+import { assertNever, fillNulls } from '@glimmer/util';
+import { OpSize } from '@glimmer/vm';
+
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+import type { DebugOpList } from './generated/op-list';
+import type { DynamicStackFn, OpcodeMetadata } from './metadata';
+import type { STACK_TYPES } from './stack/params';
+
+import { UNCHANGED } from './stack/params';
+
+type NameDef<Name extends Nullable<VmOpName> = VmOpName> = Name extends null
+  ? null
+  : `${Name} as ${string}`;
+
+export function define(
+  nameDef: NameDef,
+  ops: ShorthandOperandList,
+  stackCheck: DynamicStackFn
+): Nullable<OpcodeMetadata> {
+  let [name, mnemonic] = nameDef.split(' as ') as [string, string];
+  return {
+    name,
+    mnemonic,
+    before: null,
+    stack: stackCheck,
+    ops: ops.map(op) as OperandList,
+    operands: ops.length,
+  };
+}
+
+export interface CheckedMetadata {
+  stackChange: number;
+}
+
+export interface UncheckedMetadata {
+  reason: string;
+}
+
+export type MetadataDefinition = CheckedMetadata | UncheckedMetadata;
+
+export type StackType = (typeof STACK_TYPES)[number];
+
+// @note OPERAND_TYPES
+export const OPERAND_TYPES = [
+  // imm means immediate
+  'imm/u32',
+  'imm/i32',
+  // encoded as 0 or 1
+  'imm/bool',
+  // the operand is an i32 or u32, but it has a more specific meaning that should be captured here
+  'imm/u32{todo}',
+  'imm/i32{todo}',
+
+  'imm/enum<curry>',
+  'imm/block:handle',
+
+  'imm/pc',
+  'handle',
+
+  'const/i32[]',
+  'const/str?',
+  'const/any[]',
+  'const/str[]?',
+  'const/bool',
+  'const/fn',
+  'const/any',
+
+  // could be an immediate
+  'const/primitive',
+  'const/definition',
+
+  'register',
+  // $pc, $ra
+  'register/instruction',
+  // $sp, $fp
+  'register/stack',
+  // $s0, $s1, $t0, $t1, $v0
+  'register/sN',
+  'register/tN',
+  'register/v0',
+
+  'variable',
+
+  'instruction/relative',
+  'instruction/absolute',
+] as const;
+
+export function isOperandType(s: string): s is OperandType {
+  return OPERAND_TYPES.includes(s as never) || OPERAND_TYPES.includes(`${s}?` as never);
+}
+
+export type OPERAND_TYPE = (typeof OPERAND_TYPES)[number];
+export type NonNullableOperandType = Exclude<OPERAND_TYPE, `${string}?`>;
+export type NullableOperandType = Extract<OPERAND_TYPE, `${string}?`> extends `${infer S}?`
+  ? S
+  : never;
+export type OperandType = NonNullableOperandType | NullableOperandType | `${NullableOperandType}?`;
+
+export interface OperandLabel {
+  type: OperandType;
+  name: string;
+}
+
+export type OperandList =
+  | []
+  | [OperandLabel]
+  | [OperandLabel, OperandLabel]
+  | [OperandLabel, OperandLabel, OperandLabel];
+
+export type ShorthandOperandList =
+  | []
+  | [ShorthandOp]
+  | [ShorthandOp, ShorthandOp]
+  | [ShorthandOp, ShorthandOp, ShorthandOp];
+
+type ShorthandOp = `${string}:${OperandType}`;
+
+type ShorthandStackParam = `${string}:${Exclude<StackType, symbol>}`;
+export type ShorthandStackReturn<T extends StackType = StackType> = Extract<StackType, T>;
+
+function op(input: ShorthandOp): OperandLabel {
+  let [name, type] = input.split(':') as [string, string];
+
+  if (isOperandType(type)) {
+    return { name, type };
+  } else {
+    throw new Error(`Expected operand, found ${JSON.stringify(input)}`);
+  }
+}
+
+type OpName = VmOpName;
+
+export interface Op {
+  readonly op1: number;
+  readonly op2: number;
+  readonly op3: number;
+}
+type StackOption =
+  | {
+      type: 'stack:unchecked';
+      reason: string;
+    }
+  | {
+      type: 'stack:delta';
+      value: number;
+    }
+  | {
+      type: 'stack:params';
+      value: ShorthandStackParam[];
+    }
+  | {
+      type: 'stack:peeks';
+      value: ShorthandStackParam[];
+    }
+  | {
+      type: 'stack:returns';
+      value: ShorthandStackReturn[];
+    }
+  | {
+      type: 'stack:dynamic';
+      value: DynamicStackFn | { reason: string };
+    };
+
+type MetadataOption =
+  | ShorthandOperandList
+  | {
+      type: 'multi';
+      options: StackOption[];
+    }
+  | StackOption;
+
+function stackDelta(change: number): MetadataOption {
+  return { type: 'stack:delta', value: change };
+}
+
+export const stack = {
+  peeks: stackPeeks,
+  params: stackParams,
+  dynamic: stackDynamic,
+  delta: stackDelta,
+} as const;
+
+type IntoReturnType<T = ShorthandStackReturn> =
+  | Extract<ShorthandStackReturn, T>
+  | Extract<ShorthandStackReturn, T>[];
+
+function intoReturnType(from: IntoReturnType): ShorthandStackReturn[] {
+  return Array.isArray(from) ? from : [from];
+}
+
+function stackPeeks(
+  params: ShorthandStackParam[]
+): MetadataOption & { pushes: (returns: IntoReturnType) => MetadataOption } {
+  return {
+    type: 'stack:peeks',
+    value: params,
+    pushes: (returns) => ({
+      type: 'multi',
+      options: [
+        { type: 'stack:peeks', value: params },
+        { type: 'stack:returns', value: intoReturnType(returns) },
+      ],
+    }),
+  };
+}
+
+function stackParams(params: ShorthandStackParam[]): {
+  /**
+   * Multiple returns mean multiple choices
+   */
+  returns: (returns: IntoReturnType) => MetadataOption;
+  pushes: (params: IntoReturnType<string>) => MetadataOption;
+  dynamic: (dynamic: DynamicStackFn | { reason: string }) => MetadataOption;
+} {
+  const paramsOption = { type: 'stack:params', value: params } as const;
+
+  return {
+    returns: (returns) => ({
+      type: 'multi',
+      options: [paramsOption, { type: 'stack:returns', value: intoReturnType(returns) }],
+    }),
+
+    pushes: (returns) => ({
+      type: 'multi',
+      options: [
+        paramsOption,
+        { type: 'stack:returns', value: [UNCHANGED, ...intoReturnType(returns)] },
+      ],
+    }),
+
+    dynamic: (dynamic: DynamicStackFn | { reason: string }): MetadataOption => ({
+      type: 'multi',
+      options: [paramsOption, { type: 'stack:dynamic', value: dynamic }],
+    }),
+  };
+}
+
+function stackDynamic(dynamic: DynamicStackFn | { reason: string }): MetadataOption {
+  return { type: 'stack:dynamic', value: dynamic ?? null };
+}
+
+// @active
+function toOptions(options: MetadataOption[]): NormalizedOptions {
+  let operands: ShorthandOperandList = [];
+
+  const stackInfo = new StackInfo();
+
+  for (let option of options) {
+    if (Array.isArray(option)) {
+      operands = option;
+      continue;
+    }
+
+    switch (option.type) {
+      case 'multi':
+        stackInfo.add(...option.options);
+        break;
+      default:
+        stackInfo.add(option);
+    }
+  }
+
+  return [operands, stackInfo.toStackCheck()];
+}
+
+type StackParam =
+  | { type: 'pop'; value: ShorthandStackParam }
+  | { type: 'peek'; value: ShorthandStackParam };
+
+class StackInfo {
+  #params: StackParam[] = [];
+  #returns: ShorthandStackReturn[] = [];
+  #delta: number | undefined;
+  #dynamic: Optional<DynamicStackFn | { reason: string }> = undefined;
+
+  add(...options: StackOption[]): void {
+    for (const option of options) {
+      switch (option.type) {
+        case 'stack:unchecked':
+          this.#dynamic = { reason: option.reason };
+          break;
+        case 'stack:params':
+          this.#params.push(
+            ...option.value.map((param) => ({ type: 'pop', value: param }) as const)
+          );
+          break;
+        case 'stack:peeks':
+          this.#params.push(
+            ...option.value.map((param) => ({ type: 'peek', value: param }) as const)
+          );
+          break;
+        case 'stack:returns':
+          this.#returns = option.value;
+          break;
+        case 'stack:delta':
+          this.#delta = option.value;
+          break;
+        case 'stack:dynamic':
+          this.#dynamic = option.value;
+          break;
+        default:
+          assertNever(option);
+      }
+    }
+  }
+
+  toStackCheck(): DynamicStackFn {
+    const dynamic = this.#dynamic;
+
+    if (dynamic === undefined) {
+      if (this.#delta) {
+        return () => ({ type: 'delta', delta: this.delta });
+      } else {
+        return () => ({
+          type: 'operations',
+          peek: this.#peeks.length,
+          pop: this.#pops.length,
+          push: this.#returns.length,
+          delta: this.delta,
+        });
+      }
+    }
+
+    if (typeof dynamic === 'function') {
+      return dynamic;
+    } else {
+      return () => ({ type: 'unchecked', delta: undefined, ...dynamic });
+    }
+  }
+
+  get #pops(): ShorthandStackParam[] {
+    return this.#params.filter((p) => p.type === 'pop').map((p) => p.value);
+  }
+
+  get #peeks(): ShorthandStackParam[] {
+    return this.#params.filter((p) => p.type === 'peek').map((p) => p.value);
+  }
+
+  get delta(): number {
+    if (this.#delta) {
+      return this.#delta;
+    } else {
+      return this.#returns.length - this.#pops.length;
+    }
+  }
+}
+
+export type NormalizedMetadataArray<O> = {
+  [K in keyof O]: O[K] extends null ? null : OpcodeMetadata;
+};
+
+export const RESERVED = Symbol('RESERVED');
+export type RESERVED = typeof RESERVED;
+
+type NormalizedOptions = [ops: ShorthandOperandList, check: DynamicStackFn];
+
+export class MetadataBuilder<
+  out Op,
+  in out SoFar extends Nullable<OpName>[],
+  in out Rest extends Nullable<OpName>[],
+> {
+  static build<T extends Nullable<OpName>[]>(
+    build: (
+      builder: MetadataBuilder<DebugOpList, [], DebugOpList>
+    ) => MetadataBuilder<DebugOpList, T, []>
+  ): NormalizedMetadataArray<T> {
+    let builder = new MetadataBuilder<DebugOpList, [], DebugOpList>(fillNulls(OpSize));
+    return build(builder).#done() as NormalizedMetadataArray<T>;
+  }
+
+  #inserting = 0;
+  #metadata: Nullable<OpcodeMetadata>[];
+
+  private constructor(metadata: Nullable<OpcodeMetadata>[]) {
+    this.#metadata = metadata;
+  }
+
+  declare NEXT: Rest[0];
+
+  readonly stack = stack;
+  readonly from = stackParams;
+
+  readonly add = (
+    name: Rest[0] extends null ? RESERVED : NameDef<NonNullable<Rest[0]>>,
+    ...options: MetadataOption[]
+  ): MetadataBuilder<Op, [...SoFar, Rest[0]], Slice<Rest>> => {
+    if (name === RESERVED) {
+      this.#inserting++;
+    } else {
+      const normalizedOptions: NormalizedOptions =
+        name === RESERVED
+          ? ([
+              [],
+              () => ({ type: 'unchecked', reason: 'reserved', delta: undefined }),
+            ] satisfies NormalizedOptions)
+          : toOptions(options);
+
+      this.#push(name, normalizedOptions);
+    }
+
+    return this as never;
+  };
+
+  #push(name: NameDef, options: NormalizedOptions): void {
+    this.#metadata[this.#inserting++] = name === null ? null : define(name, ...options);
+  }
+
+  #done(): NormalizedMetadataArray<Op> {
+    return this.#metadata as NormalizedMetadataArray<Op>;
+  }
+}
+
+type TupleToParams<T extends unknown[]> = (...args: T) => void;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Slice<T extends unknown[]> = TupleToParams<T> extends (first: any, ...rest: infer Rest) => void
+  ? Rest
+  : never;
+export function isReference(value: unknown): value is Reactive {
+  return !!(value && typeof value === 'object' && INTERNAL_REFERENCE in value);
+}
diff --git a/packages/@glimmer/debug/package.json b/packages/@glimmer/debug/package.json
index adf007594c..9ef01505a9 100644
--- a/packages/@glimmer/debug/package.json
+++ b/packages/@glimmer/debug/package.json
@@ -4,6 +4,7 @@
   "repository": "https://github.com/glimmerjs/glimmer-vm/tree/master/packages/@glimmer/debug",
   "main": "index.ts",
   "types": "index.ts",
+  "type": "module",
   "exports": {
     "types": "./index.ts",
     "development": "./index.ts"
@@ -20,6 +21,7 @@
   },
   "dependencies": {
     "@glimmer/interfaces": "workspace:^",
+    "@glimmer/reference": "workspace:^",
     "@glimmer/util": "workspace:^",
     "@glimmer/vm": "workspace:^"
   },
diff --git a/packages/@glimmer/destroyable/index.ts b/packages/@glimmer/destroyable/index.ts
index f88e3b4c85..e9ccc577a8 100644
--- a/packages/@glimmer/destroyable/index.ts
+++ b/packages/@glimmer/destroyable/index.ts
@@ -1,5 +1,5 @@
-import { scheduleDestroy, scheduleDestroyed } from '@glimmer/global-context';
 import type { Destroyable, Destructor } from '@glimmer/interfaces';
+import { scheduleDestroy, scheduleDestroyed } from '@glimmer/global-context';
 import { debugToString } from '@glimmer/util';
 
 const enum DestroyingState {
diff --git a/packages/@glimmer/destroyable/test/destroyables-test.ts b/packages/@glimmer/destroyable/test/destroyables-test.ts
index fa52dcf27e..aff6b32cce 100644
--- a/packages/@glimmer/destroyable/test/destroyables-test.ts
+++ b/packages/@glimmer/destroyable/test/destroyables-test.ts
@@ -1,3 +1,4 @@
+import type {GlobalContext} from '@glimmer/global-context';
 import {
   assertDestroyablesDestroyed,
   associateDestroyableChild,
@@ -9,7 +10,7 @@ import {
   registerDestructor,
   unregisterDestructor,
 } from '@glimmer/destroyable';
-import { type GlobalContext, testOverrideGlobalContext } from '@glimmer/global-context';
+import {  testOverrideGlobalContext } from '@glimmer/global-context';
 import { unwrap } from '@glimmer/util';
 
 const { module, test } = QUnit;
diff --git a/packages/@glimmer/dom-change-list/lib/tree-construction.ts b/packages/@glimmer/dom-change-list/lib/tree-construction.ts
index f7e662cc15..06b047ff86 100644
--- a/packages/@glimmer/dom-change-list/lib/tree-construction.ts
+++ b/packages/@glimmer/dom-change-list/lib/tree-construction.ts
@@ -7,9 +7,10 @@ import type {
 } from '@glimmer/interfaces';
 import { NS_HTML } from '@glimmer/util';
 
-import { OperationsBuilder, run } from './dom-operations';
 import type { NodeTokensImpl } from './node-tokens';
 
+import { OperationsBuilder, run } from './dom-operations';
+
 // https://github.com/whatwg/dom/issues/270
 
 export class DOMTreeConstruction {
diff --git a/packages/@glimmer/dom-change-list/test/change-list-test.ts b/packages/@glimmer/dom-change-list/test/change-list-test.ts
index 76f62897ea..5d6baf5143 100644
--- a/packages/@glimmer/dom-change-list/test/change-list-test.ts
+++ b/packages/@glimmer/dom-change-list/test/change-list-test.ts
@@ -1,10 +1,11 @@
-import { DOMTreeConstruction, type NodeTokensImpl } from '@glimmer/dom-change-list';
+import type {NodeTokensImpl} from '@glimmer/dom-change-list';
 import type {
   Namespace,
   SimpleDocument,
   SimpleDocumentFragment,
   SimpleElement,
 } from '@glimmer/interfaces';
+import { DOMTreeConstruction  } from '@glimmer/dom-change-list';
 import { NS_SVG, NS_XLINK } from '@glimmer/util';
 import createDocument from '@simple-dom/document';
 
diff --git a/packages/@glimmer/dom-change-list/test/tree-builder-test.ts b/packages/@glimmer/dom-change-list/test/tree-builder-test.ts
index 19bf339444..c9b837af63 100644
--- a/packages/@glimmer/dom-change-list/test/tree-builder-test.ts
+++ b/packages/@glimmer/dom-change-list/test/tree-builder-test.ts
@@ -1,5 +1,6 @@
-import { DOMTreeConstruction, type NodeTokensImpl, TreeBuilder } from '@glimmer/dom-change-list';
+import type {NodeTokensImpl} from '@glimmer/dom-change-list';
 import type { SimpleDocument, SimpleDocumentFragment, SimpleElement } from '@glimmer/interfaces';
+import { DOMTreeConstruction,  TreeBuilder } from '@glimmer/dom-change-list';
 import createHTMLDocument from '@simple-dom/document';
 
 import { Builder as TestBuilder, toHTML, toHTMLNS, XLINK } from './support';
diff --git a/packages/@glimmer/encoder/lib/encoder.ts b/packages/@glimmer/encoder/lib/encoder.ts
index 31df22eb20..7d16b1985c 100644
--- a/packages/@glimmer/encoder/lib/encoder.ts
+++ b/packages/@glimmer/encoder/lib/encoder.ts
@@ -3,8 +3,6 @@ import type {
   InstructionEncoder,
   MACHINE_MASK,
   Operand,
-  SomeVmOp,
-  VmMachineOp,
   VmOp,
 } from '@glimmer/interfaces';
 import { ARG_SHIFT, MAX_SIZE, TYPE_SIZE } from '@glimmer/vm';
@@ -14,9 +12,9 @@ export class InstructionEncoderImpl implements InstructionEncoder {
 
   size = 0;
 
-  encode(type: VmMachineOp, machine: MACHINE_MASK, ...operands: Operand[]): void;
+  encode(type: VmOp, machine: MACHINE_MASK, ...operands: Operand[]): void;
   encode(type: VmOp, machine: 0, ...operands: Operand[]): void;
-  encode(type: SomeVmOp, machine: 0 | MACHINE_MASK, ...args: Operand[]) {
+  encode(type: VmOp, machine: 0 | MACHINE_MASK, ...args: Operand[]) {
     if ((type as number) > TYPE_SIZE) {
       throw new Error(`Opcode type over 8-bits. Got ${type}.`);
     }
diff --git a/packages/@glimmer/global-context/index.ts b/packages/@glimmer/global-context/index.ts
index 3c458dff14..40f435f893 100644
--- a/packages/@glimmer/global-context/index.ts
+++ b/packages/@glimmer/global-context/index.ts
@@ -1,18 +1,21 @@
 /**
- * This package contains global context functions for Glimmer. These functions
- * are set by the embedding environment and must be set before initial render.
+ * This package contains global context functions for Glimmer. These functions are set by the
+ * embedding environment and must be set before initial render.
  *
  * These functions should meet the following criteria:
  *
- * - Must be provided by the embedder, due to having framework specific
- *   behaviors (e.g. interop with classic Ember behaviors that should not be
- *   upstreamed) or to being out of scope for the VM (e.g. scheduling a
- *   revalidation)
+ * - Must be provided by the embedder, due to having framework specific behaviors (e.g. interop with
+ *   classic Ember behaviors that should not be upstreamed) or to being out of scope for the VM
+ *   (e.g. scheduling a revalidation)
  * - Never differ between render roots
  * - Never change over time
  *
  */
 
+type Index = string | symbol;
+type Indexable<T = unknown> = object & Record<string | symbol, T>;
+type Dict<T = unknown> = object & Record<string, T>;
+
 //////////
 
 /**
@@ -71,27 +74,70 @@ export let toIterator: (value: unknown) => IteratorDelegate | null;
 export let toBool: (value: unknown) => boolean;
 
 /**
- * Hook for specifying how Glimmer should access properties in cases where it
- * needs to. For instance, accessing an object's values in templates.
+ * Hook for specifying how Glimmer should access properties in cases where it needs to. For
+ * instance, accessing an object's values in templates.
+ *
+ * If you want to support symbol keys, use `getProperty` instead.
+ *
+ * @param obj The object provided to get a value from
+ * @param path The path to get the value from
+ */
+export let getProp: GlobalContext['getProp'];
+
+const defaultGetProperty: GlobalContext['getProperty'] = (parent, key) => {
+  const prop: string | symbol = typeof key === 'number' ? String(key) : key;
+
+  if (typeof prop === 'symbol') {
+    return parent[key];
+  } else if (getProp) {
+    return getProp(parent, prop) as never;
+  } else {
+    return parent[prop];
+  }
+};
+
+/**
+ * An expanded version of {@linkcode getProp} that supports symbol keys.
  *
  * @param obj The object provided to get a value from
  * @param path The path to get the value from
  */
-export let getProp: (obj: object, path: string) => unknown;
+export let getProperty: GlobalContext['getProperty'] = defaultGetProperty;
 
 /**
- * Hook for specifying how Glimmer should update props in cases where it needs
- * to. For instance, when updating a template reference (e.g. 2-way-binding)
+ * Hook for specifying how Glimmer should update props in cases where it needs to. For instance,
+ * when updating a template reference (e.g. 2-way-binding)
  *
  * @param obj The object provided to get a value from
  * @param prop The prop to set the value at
  * @param value The value to set the value to
  */
-export let setProp: (obj: object, prop: string, value: unknown) => void;
+export let setProp: GlobalContext['setProp'];
+
+const defaultSetProperty: GlobalContext['setProperty'] = (parent, key, value) => {
+  const prop: string | symbol = typeof key === 'number' ? String(key) : key;
+
+  if (typeof prop === 'symbol') {
+    parent[key] = value;
+  } else if (setProp) {
+    setProp(parent, prop, value);
+  } else {
+    (parent as Dict)[prop] = value;
+  }
+};
 
 /**
- * Hook for specifying how Glimmer should access paths in cases where it needs
- * to. For instance, the `key` value of `{{each}}` loops.
+ * An expanded version of {@linkcode setProp} that supports symbol keys.
+ *
+ * @param obj The object provided to get a value from
+ * @param prop The prop to set the value at
+ * @param value The value to set the value to
+ */
+export let setProperty: GlobalContext['setProperty'] = defaultSetProperty;
+
+/**
+ * Hook for specifying how Glimmer should access paths in cases where it needs to. For instance, the
+ * `key` value of `{{each}}` loops.
  *
  * @param obj The object provided to get a value from
  * @param path The path to get the value from
@@ -99,29 +145,29 @@ export let setProp: (obj: object, prop: string, value: unknown) => void;
 export let getPath: (obj: object, path: string) => unknown;
 
 /**
- * Hook for specifying how Glimmer should update paths in cases where it needs
- * to. For instance, when updating a template reference (e.g. 2-way-binding)
+ * Hook for specifying how Glimmer should update paths in cases where it needs to. For instance,
+ * when updating a template reference (e.g. 2-way-binding)
  *
  * @param obj The object provided to get a value from
- * @param path The path to get the value from
+ * @param prop The path to get the value from
+ * @param value The value to set the value to
  */
 export let setPath: (obj: object, path: string, value: unknown) => unknown;
 
 /**
- * Hook to warn if a style binding string or value was not marked as trusted
- * (e.g. HTMLSafe)
+ * Hook to warn if a style binding string or value was not marked as trusted (e.g. HTMLSafe)
  */
 export let warnIfStyleNotTrusted: (value: unknown) => void;
 
 /**
- * Hook to customize assertion messages in the VM. Usages can be stripped out
- * by using the @glimmer/vm-babel-plugins package.
+ * Hook to customize assertion messages in the VM. Usages can be stripped out by using the
+ * @glimmer/vm-babel-plugins package.
  */
 export let assert: (test: unknown, msg: string, options?: { id: string }) => asserts test;
 
 /**
- * Hook to customize deprecation messages in the VM. Usages can be stripped out
- * by using the @glimmer/vm-babel-plugins package.
+ * Hook to customize deprecation messages in the VM. Usages can be stripped out by using the
+ * @glimmer/vm-babel-plugins package.
  */
 export let deprecate: (
   msg: string,
@@ -140,7 +186,15 @@ export interface GlobalContext {
   toIterator: (value: unknown) => IteratorDelegate | null;
   toBool: (value: unknown) => boolean;
   getProp: (obj: object, path: string) => unknown;
+  /**
+   * Optionally set up `getProperty` if you want to be able to support symbol keys
+   */
+  getProperty: (parent: Indexable, key: Index) => unknown;
   setProp: (obj: object, prop: string, value: unknown) => void;
+  /**
+   * Optionally set up `setProperty` if you want to be able to support symbol keys
+   */
+  setProperty: (parent: Indexable, key: Index, value: unknown) => void;
   getPath: (obj: object, path: string) => unknown;
   setPath: (obj: object, prop: string, value: unknown) => void;
   warnIfStyleNotTrusted: (value: unknown) => void;
@@ -159,7 +213,10 @@ export interface GlobalContext {
 
 let globalContextWasSet = false;
 
-export default function setGlobalContext(context: GlobalContext) {
+export default function setGlobalContext(
+  context: Omit<GlobalContext, 'getProperty' | 'setProperty'> &
+    Partial<Pick<GlobalContext, 'getProperty' | 'setProperty'>>
+): void {
   if (import.meta.env.DEV) {
     if (globalContextWasSet) {
       throw new Error('Attempted to set the global context twice. This should only be set once.');
@@ -173,8 +230,6 @@ export default function setGlobalContext(context: GlobalContext) {
   scheduleDestroyed = context.scheduleDestroyed;
   toIterator = context.toIterator;
   toBool = context.toBool;
-  getProp = context.getProp;
-  setProp = context.setProp;
   getPath = context.getPath;
   setPath = context.setPath;
   warnIfStyleNotTrusted = context.warnIfStyleNotTrusted;
@@ -205,7 +260,9 @@ if (import.meta.env.DEV) {
           toIterator,
           toBool,
           getProp,
+          getProperty,
           setProp,
+          setProperty,
           getPath,
           setPath,
           warnIfStyleNotTrusted,
@@ -220,14 +277,16 @@ if (import.meta.env.DEV) {
       globalContextWasSet = true;
     }
 
-    // We use `undefined as any` here to unset the values when resetting the
-    // context at the end of a test.
+    // We use `undefined as any` here to unset the values when resetting the context at the end of a
+    // test.
     scheduleRevalidate = context?.scheduleRevalidate || (undefined as any);
     scheduleDestroy = context?.scheduleDestroy || (undefined as any);
     scheduleDestroyed = context?.scheduleDestroyed || (undefined as any);
     toIterator = context?.toIterator || (undefined as any);
     toBool = context?.toBool || (undefined as any);
+    getProperty = context?.getProperty || defaultGetProperty;
     getProp = context?.getProp || (undefined as any);
+    setProperty = context?.setProperty || defaultSetProperty;
     setProp = context?.setProp || (undefined as any);
     getPath = context?.getPath || (undefined as any);
     setPath = context?.setPath || (undefined as any);
diff --git a/packages/@glimmer/interfaces/index.d.ts b/packages/@glimmer/interfaces/index.d.ts
index 44d2854abf..ee58ad6a4d 100644
--- a/packages/@glimmer/interfaces/index.d.ts
+++ b/packages/@glimmer/interfaces/index.d.ts
@@ -6,6 +6,7 @@ export * from './lib/components';
 export * from './lib/content';
 export * from './lib/core';
 export * from './lib/curry';
+export * from './lib/devmode';
 export * from './lib/dom/attributes';
 export * from './lib/dom/bounds';
 export * from './lib/dom/changes';
@@ -14,10 +15,12 @@ export * from './lib/dom/tree-construction';
 export * from './lib/managers';
 export * from './lib/program';
 export * from './lib/references';
+export * from './lib/result';
 export * from './lib/runtime';
 export * from './lib/runtime/vm';
 export * from './lib/serialize';
 export * from './lib/stack';
+export * from './lib/stack-aspect';
 export * from './lib/tags';
 export * from './lib/template';
 export * from './lib/tier1/symbol-table';
diff --git a/packages/@glimmer/interfaces/lib/compile/encoder.ts b/packages/@glimmer/interfaces/lib/compile/encoder.ts
index 06e7f47d0b..98a754933c 100644
--- a/packages/@glimmer/interfaces/lib/compile/encoder.ts
+++ b/packages/@glimmer/interfaces/lib/compile/encoder.ts
@@ -2,7 +2,7 @@ import type { CompileTimeComponent } from '../..';
 import type { Nullable } from '../core';
 import type { CompileTimeConstants } from '../program';
 import type { HandleResult, NamedBlocks } from '../template';
-import type { VmMachineOp as MachineOp, VmOp as Op } from '../vm-opcodes';
+import type { VmMachineOp as MachineOp, VmSyscallOp as SyscallOp } from '../vm-opcodes';
 import type { SingleBuilderOperand } from './operands';
 import type * as WireFormat from './wire-format/api';
 
@@ -14,12 +14,7 @@ export type HighLevelStopLabels = 1002;
 export type HighLevelStart = HighLevelLabel;
 export type HighLevelEnd = HighLevelStopLabels;
 
-export type HighLevelBuilderOpcode =
-  | HighLevelLabel
-  | HighLevelStartLabels
-  | HighLevelStopLabels
-  | HighLevelStart
-  | HighLevelEnd;
+export type HighLevelBuilderOpcode = HighLevelLabel | HighLevelStartLabels | HighLevelStopLabels;
 
 export type HighLevelResolveModifier = 1003;
 export type HighLevelResolveComponent = 1004;
@@ -42,9 +37,7 @@ export type HighLevelResolutionOpcode =
   | HighLevelResolveOptionalComponentOrHelper
   | HighLevelResolveFree
   | HighLevelResolveLocal
-  | HighLevelResolveTemplateLocal
-  | HighLevelResolveStart
-  | HighLevelRevolveEnd;
+  | HighLevelResolveTemplateLocal;
 
 export interface SimpleArgsOptions {
   positional: Nullable<WireFormat.Core.Params>;
@@ -68,13 +61,13 @@ export type HighLevelBuilderOp = StartLabelsOp | StopLabelsOp | LabelOp;
 export type ResolveModifierOp = [
   op: HighLevelResolveModifier,
   op1: WireFormat.Expressions.Expression,
-  op2: (handle: number) => void
+  op2: (handle: number) => void,
 ];
 
 export type ResolveComponentOp = [
   op: HighLevelResolveComponent,
   op1: WireFormat.Expressions.Expression,
-  op2: (component: CompileTimeComponent) => void
+  op2: (component: CompileTimeComponent) => void,
 ];
 
 export type ResolveComponentOrHelperOp = [
@@ -83,13 +76,13 @@ export type ResolveComponentOrHelperOp = [
   op2: {
     ifComponent: (component: CompileTimeComponent) => void;
     ifHelper: (handle: number) => void;
-  }
+  },
 ];
 
 export type ResolveHelperOp = [
   op: HighLevelResolveHelper,
   op1: WireFormat.Expressions.Expression,
-  op2: (handle: number) => void
+  op2: (handle: number) => void,
 ];
 
 export type ResolveOptionalHelperOp = [
@@ -97,7 +90,7 @@ export type ResolveOptionalHelperOp = [
   op1: WireFormat.Expressions.Expression,
   op2: {
     ifHelper: (handle: number, name: string, moduleName: string) => void;
-  }
+  },
 ];
 
 export type ResolveOptionalComponentOrHelperOp = [
@@ -107,7 +100,7 @@ export type ResolveOptionalComponentOrHelperOp = [
     ifComponent: (component: CompileTimeComponent) => void;
     ifHelper: (handle: number) => void;
     ifValue: (handle: number) => void;
-  }
+  },
 ];
 
 export type ResolveFreeOp = [op: HighLevelResolveFree, op1: number, op2: (handle: number) => void];
@@ -115,13 +108,13 @@ export type ResolveFreeOp = [op: HighLevelResolveFree, op1: number, op2: (handle
 export type ResolveTemplateLocalOp = [
   op: HighLevelResolveTemplateLocal,
   op1: number,
-  op2: (handle: number) => void
+  op2: (handle: number) => void,
 ];
 
 export type ResolveLocalOp = [
   op: HighLevelResolveLocal,
   op1: number,
-  op2: (name: string, moduleName: string) => void
+  op2: (name: string, moduleName: string) => void,
 ];
 
 export type HighLevelResolutionOp =
@@ -137,13 +130,13 @@ export type HighLevelResolutionOp =
 
 export type HighLevelOp = HighLevelBuilderOp | HighLevelResolutionOp;
 
-export type BuilderOpcode = Op | MachineOp;
+export type BuilderOpcode = SyscallOp | MachineOp;
 
 export type BuilderOp = [
   op: BuilderOpcode,
   op1?: SingleBuilderOperand,
   op1?: SingleBuilderOperand,
-  op1?: SingleBuilderOperand
+  op1?: SingleBuilderOperand,
 ];
 
 export interface EncoderError {
diff --git a/packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts b/packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts
index 59d0e27bdb..00070dfe01 100644
--- a/packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts
+++ b/packages/@glimmer/interfaces/lib/compile/wire-format/api.d.ts
@@ -29,6 +29,7 @@ import type {
   GetLexicalSymbolOpcode,
   GetStrictKeywordOpcode,
   GetSymbolOpcode,
+  HandleErrorOpcode,
   HasBlockOpcode,
   HasBlockParamsOpcode,
   IfInlineOpcode,
@@ -102,13 +103,13 @@ export namespace Expressions {
   export type GetStrictFree = [GetStrictKeywordOpcode, number];
   export type GetFreeAsComponentOrHelperHeadOrThisFallback = [
     GetFreeAsComponentOrHelperHeadOrThisFallbackOpcode,
-    number
+    number,
   ];
   export type GetFreeAsComponentOrHelperHead = [GetFreeAsComponentOrHelperHeadOpcode, number];
   export type GetFreeAsHelperHeadOrThisFallback = [GetFreeAsHelperHeadOrThisFallbackOpcode, number];
   export type GetFreeAsDeprecatedHelperHeadOrThisFallback = [
     GetFreeAsDeprecatedHelperHeadOrThisFallbackOpcode,
-    number
+    number,
   ];
   export type GetFreeAsHelperHead = [GetFreeAsHelperHeadOpcode, number];
   export type GetFreeAsModifierHead = [GetFreeAsModifierHeadOpcode, number];
@@ -131,22 +132,22 @@ export namespace Expressions {
   export type GetPathFreeAsComponentOrHelperHeadOrThisFallback = [
     GetFreeAsComponentOrHelperHeadOrThisFallbackOpcode,
     number,
-    Path
+    Path,
   ];
   export type GetPathFreeAsComponentOrHelperHead = [
     GetFreeAsComponentOrHelperHeadOpcode,
     number,
-    Path
+    Path,
   ];
   export type GetPathFreeAsHelperHeadOrThisFallback = [
     GetFreeAsHelperHeadOrThisFallbackOpcode,
     number,
-    Path
+    Path,
   ];
   export type GetPathFreeAsDeprecatedHelperHeadOrThisFallback = [
     GetFreeAsDeprecatedHelperHeadOrThisFallbackOpcode,
     number,
-    Path
+    Path,
   ];
   export type GetPathFreeAsHelperHead = [GetFreeAsHelperHeadOpcode, number, Path];
   export type GetPathFreeAsModifierHead = [GetFreeAsModifierHeadOpcode, number, Path];
@@ -199,7 +200,7 @@ export namespace Expressions {
     op: IfInlineOpcode,
     condition: Expression,
     truthyValue: Expression,
-    falsyValue?: Nullable<Expression>
+    falsyValue?: Nullable<Expression>,
   ];
 
   export type Not = [op: NotOpcode, value: Expression];
@@ -255,7 +256,7 @@ export namespace Statements {
     tag: Expression,
     parameters: Core.ElementParameters,
     args: Hash,
-    blocks: Blocks
+    blocks: Blocks,
   ];
   export type OpenElement = [OpenElementOpcode, string | WellKnownTagName];
   export type OpenElementWithSplat = [OpenElementWithSplatOpcode, string | WellKnownTagName];
@@ -266,7 +267,7 @@ export namespace Statements {
     op: Op,
     name: string | WellKnownAttrName,
     value: Expression,
-    namespace?: string | undefined
+    namespace?: string | undefined,
   ];
 
   export type StaticAttr = Attr<StaticAttrOpcode>;
@@ -296,14 +297,21 @@ export namespace Statements {
     block: SerializedInlineBlock,
     guid: string,
     destination: Expression,
-    insertBefore?: Expression
+    insertBefore?: Expression,
   ];
 
   export type If = [
     op: IfOpcode,
     condition: Expression,
     block: SerializedInlineBlock,
-    inverse: Nullable<SerializedInlineBlock>
+    inverse: Nullable<SerializedInlineBlock>,
+  ];
+
+  export type HandleError = [
+    op: HandleErrorOpcode,
+    handler: Expression,
+    block: SerializedInlineBlock,
+    inverse: Nullable<SerializedInlineBlock>,
   ];
 
   export type Each = [
@@ -311,14 +319,14 @@ export namespace Statements {
     condition: Expression,
     key: Nullable<Expression>,
     block: SerializedInlineBlock,
-    inverse: Nullable<SerializedInlineBlock>
+    inverse: Nullable<SerializedInlineBlock>,
   ];
 
   export type With = [
     op: WithOpcode,
     value: Expression,
     block: SerializedInlineBlock,
-    inverse: Nullable<SerializedInlineBlock>
+    inverse: Nullable<SerializedInlineBlock>,
   ];
 
   export type Let = [op: LetOpcode, positional: Core.Params, block: SerializedInlineBlock];
@@ -326,7 +334,7 @@ export namespace Statements {
   export type WithDynamicVars = [
     op: WithDynamicVarsOpcode,
     args: Core.Hash,
-    block: SerializedInlineBlock
+    block: SerializedInlineBlock,
   ];
 
   export type InvokeComponent = [
@@ -334,7 +342,7 @@ export namespace Statements {
     definition: Expression,
     positional: Core.Params,
     named: Core.Hash,
-    blocks: Blocks | null
+    blocks: Blocks | null,
   ];
 
   /**
@@ -363,7 +371,8 @@ export namespace Statements {
     | With
     | Let
     | WithDynamicVars
-    | InvokeComponent;
+    | InvokeComponent
+    | HandleError;
 
   export type Attribute =
     | StaticAttr
@@ -402,7 +411,11 @@ export type SyntaxWithInternal =
  */
 export type SerializedBlock = [statements: Statements.Statement[]];
 
-export type SerializedInlineBlock = [statements: Statements.Statement[], parameters: number[]];
+export type SerializedInlineBlock = [
+  statements: Statements.Statement[],
+  parameters: number[],
+  names?: string[],
+];
 
 /**
  * A JSON object that the compiled TemplateBlock was serialized into.
@@ -415,7 +428,7 @@ export type SerializedTemplateBlock = [
   // hasDebug
   boolean,
   // upvars
-  string[]
+  string[],
 ];
 
 /**
diff --git a/packages/@glimmer/interfaces/lib/compile/wire-format/opcodes.d.ts b/packages/@glimmer/interfaces/lib/compile/wire-format/opcodes.d.ts
index 91d8270019..6150417cf3 100644
--- a/packages/@glimmer/interfaces/lib/compile/wire-format/opcodes.d.ts
+++ b/packages/@glimmer/interfaces/lib/compile/wire-format/opcodes.d.ts
@@ -71,6 +71,7 @@ export type NotOpcode = 51;
 export type IfInlineOpcode = 52;
 export type GetDynamicVarOpcode = 53;
 export type LogOpcode = 54;
+export type HandleErrorOpcode = 55;
 
 export type GetStartOpcode = GetSymbolOpcode;
 export type GetEndOpcode = GetFreeAsComponentHeadOpcode;
diff --git a/packages/@glimmer/interfaces/lib/components.d.ts b/packages/@glimmer/interfaces/lib/components.d.ts
index 2ef7ec9f7c..c16c964c89 100644
--- a/packages/@glimmer/interfaces/lib/components.d.ts
+++ b/packages/@glimmer/interfaces/lib/components.d.ts
@@ -1,6 +1,6 @@
 import type { Dict } from './core';
 import type { InternalComponentManager } from './managers';
-import type { Reference } from './references';
+import type { Reactive } from './references';
 import type { ScopeSlot } from './runtime';
 import type { CompilableProgram } from './template';
 import type { ProgramSymbolTable } from './tier1/symbol-table';
@@ -41,6 +41,6 @@ export interface ComponentInstance<
 }
 
 export interface PreparedArguments {
-  positional: ReadonlyArray<Reference>;
-  named: Dict<Reference>;
+  positional: ReadonlyArray<Reactive>;
+  named: Dict<Reactive>;
 }
diff --git a/packages/@glimmer/interfaces/lib/core.d.ts b/packages/@glimmer/interfaces/lib/core.d.ts
index cd3eaca9f8..af73b9630e 100644
--- a/packages/@glimmer/interfaces/lib/core.d.ts
+++ b/packages/@glimmer/interfaces/lib/core.d.ts
@@ -4,7 +4,14 @@ export type Optional<T> = T | undefined;
 export type Maybe<T> = Nullable<T> | Optional<T>;
 export type FIXME<T, _S extends string> = T;
 
-export type Dict<T = unknown> = Record<string, T>;
+/*
+  eslint-disable-next-line @typescript-eslint/no-explicit-any -- inferred from the return type
+ */
+export type RETURN_TYPE = any;
+
+export type Index = string | symbol;
+export type Indexable<T = unknown> = object & Record<Index, T>;
+export type Dict<T = unknown> = object & Record<string, T>;
 
 export type DictValue<D extends Dict> = D extends Dict<infer V> ? V : never;
 
diff --git a/packages/@glimmer/interfaces/lib/devmode.d.ts b/packages/@glimmer/interfaces/lib/devmode.d.ts
new file mode 100644
index 0000000000..7e9b05b325
--- /dev/null
+++ b/packages/@glimmer/interfaces/lib/devmode.d.ts
@@ -0,0 +1,18 @@
+export declare class DevModeClass<T> {
+  static value<T>(devmode: DevMode<T>): T;
+
+  // make the class nominal;
+  // eslint-disable-next-line no-unused-private-class-members
+  readonly #value: T;
+
+  constructor(value: T);
+
+  toString(): string;
+}
+
+/**
+ * DevMode<T> is a value that can be dereferenced in dev mode, and is actually undefined in
+ * production mode. However, the only way to actually access the value is via `inDevmode`, which
+ * shouldn't exist in production mode (and if it does, it throws an error).
+ */
+export type DevMode<T> = DevModeClass<T>;
diff --git a/packages/@glimmer/interfaces/lib/dom/attributes.d.ts b/packages/@glimmer/interfaces/lib/dom/attributes.d.ts
index 1d6ca4a2eb..e8df06451d 100644
--- a/packages/@glimmer/interfaces/lib/dom/attributes.d.ts
+++ b/packages/@glimmer/interfaces/lib/dom/attributes.d.ts
@@ -1,7 +1,6 @@
 import type { Maybe, Nullable } from '../core';
 import type { ElementOperations, Environment, ModifierInstance } from '../runtime';
-import type { Stack } from '../stack';
-import type { Bounds, Cursor } from './bounds';
+import type { BlockBounds, Cursor } from './bounds';
 import type { GlimmerTreeChanges, GlimmerTreeConstruction } from './changes';
 import type {
   AttrNamespace,
@@ -12,12 +11,47 @@ import type {
   SimpleText,
 } from './simple';
 
-export interface LiveBlock extends Bounds {
+export type PartialBoundsDebug =
+  | {
+      type: 'first';
+      node: SimpleNode;
+    }
+  | {
+      type: 'last';
+      node: SimpleNode;
+    };
+
+export type BlockBoundsDebug =
+  | {
+      type: 'empty';
+      kind: string;
+      parent: SimpleElement;
+    }
+  | {
+      type: 'range';
+      kind: string;
+      range: [SimpleNode, SimpleNode];
+      collapsed: boolean;
+    };
+
+export type SomeBoundsDebug = BlockBoundsDebug | PartialBoundsDebug;
+
+export interface LiveBlock extends BlockBounds {
+  readonly isRemote: boolean;
+
+  debug?: () => BlockBoundsDebug;
+
   openElement(element: SimpleElement): void;
   closeElement(): void;
   didAppendNode(node: SimpleNode): void;
-  didAppendBounds(bounds: Bounds): void;
+  didAppendBounds(bounds: BlockBounds): void;
   finalize(stack: ElementBuilder): void;
+
+  /**
+   * This is called when an error occurred in the block. Any existing nodes are cleared and a
+   * comment is inserted instead.
+   */
+  catch(stack: ElementBuilder): void;
 }
 
 export interface SimpleLiveBlock extends LiveBlock {
@@ -26,8 +60,6 @@ export interface SimpleLiveBlock extends LiveBlock {
   lastNode(): SimpleNode;
 }
 
-export type RemoteLiveBlock = SimpleLiveBlock
-
 export interface UpdatableBlock extends SimpleLiveBlock {
   reset(env: Environment): Nullable<SimpleNode>;
 }
@@ -37,7 +69,7 @@ export interface DOMStack {
     element: SimpleElement,
     guid: string,
     insertBefore: Maybe<SimpleNode>
-  ): Nullable<RemoteLiveBlock>;
+  ): Nullable<SimpleLiveBlock>;
   popRemoteElement(): void;
   popElement(): void;
   openElement(tag: string, _operations?: ElementOperations): SimpleElement;
@@ -69,32 +101,36 @@ export interface TreeOperations {
   __appendText(text: string): SimpleText;
   __appendComment(string: string): SimpleComment;
   __appendNode(node: SimpleNode): SimpleNode;
-  __appendHTML(html: string): Bounds;
+  __appendHTML(html: string): BlockBounds;
   __setAttribute(name: string, value: string, namespace: Nullable<string>): void;
   __setProperty(name: string, value: unknown): void;
 }
 
-declare const CURSOR_STACK: unique symbol;
-export type CursorStackSymbol = typeof CURSOR_STACK;
-
 export interface ElementBuilder extends Cursor, DOMStack, TreeOperations {
-  [CURSOR_STACK]: Stack<Cursor>;
-
-  nextSibling: Nullable<SimpleNode>;
-  dom: GlimmerTreeConstruction;
-  updateOperations: GlimmerTreeChanges;
-  constructing: Nullable<SimpleElement>;
-  element: SimpleElement;
-
-  hasBlocks: boolean;
-  debugBlocks(): LiveBlock[];
+  readonly debug: {
+    readonly /** @mutable */ blocks: LiveBlock[];
+    readonly /** @mutable */ inserting: Cursor[];
+    readonly constructing: SimpleElement | null;
+  };
+  readonly nextSibling: Nullable<SimpleNode>;
+  readonly dom: GlimmerTreeConstruction;
+  readonly updateOperations: GlimmerTreeChanges;
+  readonly constructing: Nullable<SimpleElement>;
+  readonly element: SimpleElement;
+
+  readonly hasBlocks: boolean;
+  readonly block: LiveBlock;
+
+  begin(): LiveBlock;
+  finally(): void;
+  catch(): void;
 
   pushSimpleBlock(): LiveBlock;
   pushUpdatableBlock(): UpdatableBlock;
-  pushBlockList(list: Bounds[]): LiveBlock;
+  pushBlockList(list: BlockBounds[]): LiveBlock;
   popBlock(): LiveBlock;
 
-  didAppendBounds(bounds: Bounds): void;
+  didAppendBounds(bounds: BlockBounds): void;
 }
 
 export interface AttributeCursor {
diff --git a/packages/@glimmer/interfaces/lib/dom/bounds.d.ts b/packages/@glimmer/interfaces/lib/dom/bounds.d.ts
index bae04d9a3a..de546de6a5 100644
--- a/packages/@glimmer/interfaces/lib/dom/bounds.d.ts
+++ b/packages/@glimmer/interfaces/lib/dom/bounds.d.ts
@@ -1,13 +1,35 @@
 import type { Nullable } from '../core';
+import type { SomeBoundsDebug } from './attributes';
 import type { SimpleElement, SimpleNode } from './simple';
 
-export interface Bounds {
+export interface FirstNode {
+  readonly first: Nullable<SimpleNode>;
+  debug?: () => SomeBoundsDebug;
+
+  // `firstNode()` is allowed to throw during construction
+  firstNode(): SimpleNode;
+}
+
+export interface LastNode {
+  readonly last: Nullable<SimpleNode>;
+  debug?: () => SomeBoundsDebug;
+
+  // `lastNode()` is allowed to throw during construction
+  lastNode(): SimpleNode;
+}
+
+export interface BlockBounds extends FirstNode, LastNode {
   // a method to future-proof for wormholing; may not be needed ultimately
   parentElement(): SimpleElement;
   firstNode(): SimpleNode;
   lastNode(): SimpleNode;
+
+  debug?: () => SomeBoundsDebug;
 }
 
+export type PartialBounds = FirstNode | LastNode;
+export type Bounds = BlockBounds | PartialBounds;
+
 export interface Cursor {
   readonly element: SimpleElement;
   readonly nextSibling: Nullable<SimpleNode>;
diff --git a/packages/@glimmer/interfaces/lib/dom/changes.d.ts b/packages/@glimmer/interfaces/lib/dom/changes.d.ts
index 48e8a043ec..09b0cc643b 100644
--- a/packages/@glimmer/interfaces/lib/dom/changes.d.ts
+++ b/packages/@glimmer/interfaces/lib/dom/changes.d.ts
@@ -1,11 +1,11 @@
 import type { Nullable } from '../core';
-import type { Bounds } from './bounds';
+import type { BlockBounds } from './bounds';
 import type { Namespace, SimpleComment, SimpleElement, SimpleNode, SimpleText } from './simple';
 
 export interface GlimmerDOMOperations {
   createElement(tag: string, context?: SimpleElement): SimpleElement;
   insertBefore(parent: SimpleElement, node: SimpleNode, reference: Nullable<SimpleNode>): void;
-  insertHTMLBefore(parent: SimpleElement, nextSibling: Nullable<SimpleNode>, html: string): Bounds;
+  insertHTMLBefore(parent: SimpleElement, nextSibling: Nullable<SimpleNode>, html: string): BlockBounds;
   createTextNode(text: string): SimpleText;
   createComment(data: string): SimpleComment;
 }
diff --git a/packages/@glimmer/interfaces/lib/generated/vm-opcodes.d.ts b/packages/@glimmer/interfaces/lib/generated/vm-opcodes.d.ts
new file mode 100644
index 0000000000..52189df47e
--- /dev/null
+++ b/packages/@glimmer/interfaces/lib/generated/vm-opcodes.d.ts
@@ -0,0 +1,329 @@
+// This code was generated by $root/bin/opcodes.mts.
+// Do not change it manually.
+
+export interface VmOpMap {
+  PushFrame: 0;
+  PopFrame: 1;
+  Jump: 2;
+  ReturnTo: 3;
+  UnwindTypeFrame: 4;
+  PushBegin: 16;
+  Begin: 17;
+  Catch: 18;
+  Finally: 19;
+  InvokeVirtual: 20;
+  InvokeStatic: 21;
+  Start: 22;
+  Return: 23;
+  Helper: 24;
+  SetNamedVariables: 25;
+  SetBlocks: 26;
+  SetVariable: 27;
+  SetBlock: 28;
+  GetVariable: 29;
+  GetProperty: 30;
+  GetBlock: 31;
+  SpreadBlock: 32;
+  HasBlock: 33;
+  HasBlockParams: 34;
+  Concat: 35;
+  Constant: 36;
+  ConstantReference: 37;
+  Primitive: 38;
+  PrimitiveReference: 39;
+  ReifyU32: 40;
+  Dup: 41;
+  Pop: 42;
+  Load: 43;
+  Fetch: 44;
+  RootScope: 45;
+  VirtualRootScope: 46;
+  ChildScope: 47;
+  PopScope: 48;
+  Text: 49;
+  Comment: 50;
+  AppendHTML: 51;
+  AppendSafeHTML: 52;
+  AppendDocumentFragment: 53;
+  AppendNode: 54;
+  AppendText: 55;
+  OpenElement: 56;
+  OpenDynamicElement: 57;
+  PushRemoteElement: 58;
+  StaticAttr: 59;
+  DynamicAttr: 60;
+  ComponentAttr: 61;
+  FlushElement: 62;
+  CloseElement: 63;
+  PopRemoteElement: 64;
+  Modifier: 65;
+  BindDynamicScope: 66;
+  PushDynamicScope: 67;
+  PopDynamicScope: 68;
+  CompileBlock: 69;
+  PushBlockScope: 70;
+  PushSymbolTable: 71;
+  InvokeYield: 72;
+  JumpIf: 73;
+  JumpUnless: 74;
+  JumpEq: 75;
+  AssertSame: 76;
+  Enter: 77;
+  Exit: 78;
+  ToBoolean: 79;
+  EnterList: 80;
+  ExitList: 81;
+  Iterate: 82;
+  Main: 83;
+  ContentType: 84;
+  Curry: 85;
+  PushComponentDefinition: 86;
+  PushDynamicComponentInstance: 87;
+  ResolveDynamicComponent: 88;
+  ResolveCurriedComponent: 89;
+  PushArgs: 90;
+  PushEmptyArgs: 91;
+  PrepareArgs: 92;
+  CaptureArgs: 93;
+  CreateComponent: 94;
+  RegisterComponentDestructor: 95;
+  PutComponentOperations: 96;
+  GetComponentSelf: 97;
+  GetComponentTagName: 98;
+  GetComponentLayout: 99;
+  SetupForEval: 100;
+  PopulateLayout: 101;
+  InvokeComponentLayout: 102;
+  BeginComponentTransaction: 103;
+  CommitComponentTransaction: 104;
+  DidCreateElement: 105;
+  DidRenderLayout: 106;
+  Debugger: 107;
+  StaticComponentAttr: 108;
+  DynamicContentType: 109;
+  DynamicHelper: 110;
+  DynamicModifier: 111;
+  IfInline: 112;
+  Not: 113;
+  GetDynamicVar: 114;
+  Log: 115;
+  PushUnwindTarget: 116;
+}
+
+export type VmMachineOp =
+  // PushFrame
+  | 0
+  // PopFrame
+  | 1
+  // Jump
+  | 2
+  // ReturnTo
+  | 3
+  // UnwindTypeFrame
+  | 4;
+
+export type VmSyscallOp =
+  // PushBegin
+  | 16
+  // Begin
+  | 17
+  // Catch
+  | 18
+  // Finally
+  | 19
+  // InvokeVirtual
+  | 20
+  // InvokeStatic
+  | 21
+  // Start
+  | 22
+  // Return
+  | 23
+  // Helper
+  | 24
+  // SetNamedVariables
+  | 25
+  // SetBlocks
+  | 26
+  // SetVariable
+  | 27
+  // SetBlock
+  | 28
+  // GetVariable
+  | 29
+  // GetProperty
+  | 30
+  // GetBlock
+  | 31
+  // SpreadBlock
+  | 32
+  // HasBlock
+  | 33
+  // HasBlockParams
+  | 34
+  // Concat
+  | 35
+  // Constant
+  | 36
+  // ConstantReference
+  | 37
+  // Primitive
+  | 38
+  // PrimitiveReference
+  | 39
+  // ReifyU32
+  | 40
+  // Dup
+  | 41
+  // Pop
+  | 42
+  // Load
+  | 43
+  // Fetch
+  | 44
+  // RootScope
+  | 45
+  // VirtualRootScope
+  | 46
+  // ChildScope
+  | 47
+  // PopScope
+  | 48
+  // Text
+  | 49
+  // Comment
+  | 50
+  // AppendHTML
+  | 51
+  // AppendSafeHTML
+  | 52
+  // AppendDocumentFragment
+  | 53
+  // AppendNode
+  | 54
+  // AppendText
+  | 55
+  // OpenElement
+  | 56
+  // OpenDynamicElement
+  | 57
+  // PushRemoteElement
+  | 58
+  // StaticAttr
+  | 59
+  // DynamicAttr
+  | 60
+  // ComponentAttr
+  | 61
+  // FlushElement
+  | 62
+  // CloseElement
+  | 63
+  // PopRemoteElement
+  | 64
+  // Modifier
+  | 65
+  // BindDynamicScope
+  | 66
+  // PushDynamicScope
+  | 67
+  // PopDynamicScope
+  | 68
+  // CompileBlock
+  | 69
+  // PushBlockScope
+  | 70
+  // PushSymbolTable
+  | 71
+  // InvokeYield
+  | 72
+  // JumpIf
+  | 73
+  // JumpUnless
+  | 74
+  // JumpEq
+  | 75
+  // AssertSame
+  | 76
+  // Enter
+  | 77
+  // Exit
+  | 78
+  // ToBoolean
+  | 79
+  // EnterList
+  | 80
+  // ExitList
+  | 81
+  // Iterate
+  | 82
+  // Main
+  | 83
+  // ContentType
+  | 84
+  // Curry
+  | 85
+  // PushComponentDefinition
+  | 86
+  // PushDynamicComponentInstance
+  | 87
+  // ResolveDynamicComponent
+  | 88
+  // ResolveCurriedComponent
+  | 89
+  // PushArgs
+  | 90
+  // PushEmptyArgs
+  | 91
+  // PrepareArgs
+  | 92
+  // CaptureArgs
+  | 93
+  // CreateComponent
+  | 94
+  // RegisterComponentDestructor
+  | 95
+  // PutComponentOperations
+  | 96
+  // GetComponentSelf
+  | 97
+  // GetComponentTagName
+  | 98
+  // GetComponentLayout
+  | 99
+  // SetupForEval
+  | 100
+  // PopulateLayout
+  | 101
+  // InvokeComponentLayout
+  | 102
+  // BeginComponentTransaction
+  | 103
+  // CommitComponentTransaction
+  | 104
+  // DidCreateElement
+  | 105
+  // DidRenderLayout
+  | 106
+  // Debugger
+  | 107
+  // StaticComponentAttr
+  | 108
+  // DynamicContentType
+  | 109
+  // DynamicHelper
+  | 110
+  // DynamicModifier
+  | 111
+  // IfInline
+  | 112
+  // Not
+  | 113
+  // GetDynamicVar
+  | 114
+  // Log
+  | 115
+  // PushUnwindTarget
+  | 116;
+
+export type OpSize = 117;
diff --git a/packages/@glimmer/interfaces/lib/managers/internal/component.d.ts b/packages/@glimmer/interfaces/lib/managers/internal/component.d.ts
index 3216d728f7..f6a9cc2f41 100644
--- a/packages/@glimmer/interfaces/lib/managers/internal/component.d.ts
+++ b/packages/@glimmer/interfaces/lib/managers/internal/component.d.ts
@@ -1,8 +1,8 @@
 import type { ComponentInstanceState, PreparedArguments } from '../../components';
 import type { Destroyable, Nullable } from '../../core';
-import type { Bounds } from '../../dom/bounds';
+import type { BlockBounds } from '../../dom/bounds';
 import type { SimpleElement } from '../../dom/simple';
-import type { Reference } from '../../references';
+import type { Reactive } from '../../references';
 import type { Owner } from '../../runtime';
 import type { CapturedArguments, VMArguments } from '../../runtime/arguments';
 import type { RenderNode } from '../../runtime/debug-render-tree';
@@ -10,7 +10,7 @@ import type { ElementOperations } from '../../runtime/element';
 import type { Environment } from '../../runtime/environment';
 import type { DynamicScope } from '../../runtime/scope';
 import type { RuntimeResolver } from '../../serialize';
-import type { CompilableProgram } from '../../template';
+import type { BlockMetadata,CompilableProgram } from '../../template';
 import type { ProgramSymbolTable } from '../../tier1/symbol-table';
 
 /**
@@ -147,10 +147,10 @@ export type InternalComponentCapability =
 
 export interface InternalComponentManager<
   TComponentStateBucket = unknown,
-  TComponentDefinition = object
+  TComponentDefinition = object,
 > {
   getCapabilities(state: TComponentDefinition): InternalComponentCapabilities;
-  getSelf(state: TComponentStateBucket): Reference;
+  getSelf(state: TComponentStateBucket): Reactive;
   getDestroyable(state: TComponentStateBucket): Nullable<Destroyable>;
   getDebugName(state: TComponentDefinition): string;
 }
@@ -161,7 +161,7 @@ export interface CustomRenderNode extends RenderNode {
 
 export interface WithCustomDebugRenderTree<
   ComponentInstanceState = unknown,
-  ComponentDefinitionState = unknown
+  ComponentDefinitionState = unknown,
 > extends InternalComponentManager<ComponentInstanceState, ComponentDefinitionState> {
   // APIs for hooking into the debug render tree, used by components that
   // represent multiple logical components. Specifically, {{mount}} and {{outlet}}
@@ -175,7 +175,7 @@ export interface WithCustomDebugRenderTree<
 
 export interface WithPrepareArgs<
   ComponentInstanceState = unknown,
-  ComponentDefinitionState = unknown
+  ComponentDefinitionState = unknown,
 > extends InternalComponentManager<ComponentInstanceState, ComponentDefinitionState> {
   // The component manager is asked to prepare the arguments needed
   // for `create`. This allows for things like closure> components where the
@@ -192,7 +192,7 @@ export interface WithSubOwner<ComponentInstanceState = unknown, ComponentDefinit
 export interface WithCreateInstance<
   ComponentInstanceState = unknown,
   ComponentDefinitionState = unknown,
-  O extends Owner = Owner
+  O extends Owner = Owner,
 > extends InternalComponentManager<ComponentInstanceState, ComponentDefinitionState> {
   // The component manager is asked to create a bucket of state for
   // the supplied arguments. From the perspective of Glimmer, this is
@@ -203,7 +203,7 @@ export interface WithCreateInstance<
     args: Nullable<VMArguments>,
     env: Environment,
     dynamicScope: Nullable<DynamicScope>,
-    caller: Nullable<Reference>,
+    caller: Nullable<Reactive>,
     hasDefaultBlock: boolean
   ): ComponentInstanceState;
 
@@ -211,13 +211,13 @@ export interface WithCreateInstance<
   //
   // Hosts should use `didCreate`, which runs asynchronously after the rendering
   // process, to provide hooks for user code.
-  didRenderLayout(state: ComponentInstanceState, bounds: Bounds): void;
+  didRenderLayout(state: ComponentInstanceState, bounds: BlockBounds): void;
 
   // This hook is run after the entire layout has been updated.
   //
   // Hosts should use `didUpdate`, which runs asynchronously after the rendering
   // process, to provide hooks for user code.
-  didUpdateLayout(state: ComponentInstanceState, bounds: Bounds): void;
+  didUpdateLayout(state: ComponentInstanceState, bounds: BlockBounds): void;
 
   // Once the whole top-down rendering process is complete, Glimmer invokes
   // the `didCreate` callbacks.
@@ -237,7 +237,7 @@ export interface WithUpdateHook<ComponentInstanceState = unknown>
 
 export interface WithDynamicLayout<
   I = ComponentInstanceState,
-  R extends RuntimeResolver = RuntimeResolver
+  R extends RuntimeResolver = RuntimeResolver,
 > extends InternalComponentManager<I> {
   // Return the compiled layout to use for this component. This is called
   // *after* the component instance has been created, because you might
@@ -281,4 +281,5 @@ export interface WithElementHook<ComponentInstanceState>
 export interface Invocation {
   handle: number;
   symbolTable: ProgramSymbolTable;
+  meta: BlockMetadata | null;
 }
diff --git a/packages/@glimmer/interfaces/lib/program.d.ts b/packages/@glimmer/interfaces/lib/program.d.ts
index 8d9a889ed5..07a7e211bb 100644
--- a/packages/@glimmer/interfaces/lib/program.d.ts
+++ b/packages/@glimmer/interfaces/lib/program.d.ts
@@ -1,16 +1,17 @@
 import type { Encoder } from './compile';
 import type { ComponentDefinition, ComponentDefinitionState } from './components';
+import type { Nullable } from './core';
 import type { HelperDefinitionState } from './runtime';
 import type { ModifierDefinitionState } from './runtime/modifier';
 import type { CompileTimeResolver, ResolvedComponentDefinition } from './serialize';
-import type { ContainingMetadata, STDLib, Template } from './template';
-import type { SomeVmOp, VmMachineOp, VmOp } from './vm-opcodes';
+import type { BlockMetadata, STDLib, Template } from './template';
+import type { VmMachineOp, VmOp } from './vm-opcodes';
 
 export type CreateRuntimeOp = (heap: CompileTimeHeap) => RuntimeOp;
 
 export interface RuntimeOp {
   offset: number;
-  type: SomeVmOp;
+  type: VmOp;
   op1: number;
   op2: number;
   op3: number;
@@ -49,14 +50,19 @@ export interface RuntimeHeap extends OpcodeHeap {
   sizeof(handle: number): number;
 }
 
-export interface CompileTimeCompilationContext {
+export interface DebugConstants {
+  getValue<T>(handle: number): T;
+  getArray<T extends Nullable<unknown[]>>(value: number): T;
+}
+
+export interface JitContext {
   // The offsets to stdlib functions
   readonly stdlib: STDLib;
 
   readonly createOp: CreateRuntimeOp;
 
   // Interned constants
-  readonly constants: CompileTimeConstants & ResolutionTimeConstants;
+  readonly constants: CompileTimeConstants & ResolutionTimeConstants & DebugConstants;
 
   // The mechanism of resolving names to values at compile-time
   readonly resolver: CompileTimeResolver;
@@ -71,9 +77,9 @@ export interface CompileTimeCompilationContext {
  * template when compiling blocks nested inside of it.
  */
 export interface TemplateCompilationContext {
-  readonly program: CompileTimeCompilationContext;
+  readonly program: JitContext;
   readonly encoder: Encoder;
-  readonly meta: ContainingMetadata;
+  readonly meta: BlockMetadata;
 }
 
 export type EMPTY_ARRAY = Array<ReadonlyArray<never>>;
@@ -132,12 +138,12 @@ export interface ResolutionTimeConstants {
   ): ComponentDefinition;
 }
 
-export interface RuntimeConstants {
+export interface RuntimeConstants extends DebugConstants {
   getValue<T>(handle: number): T;
-  getArray<T>(handle: number): T[];
+  getArray<T extends Nullable<unknown[]>>(handle: number): T;
 }
 
 export interface CompileTimeArtifacts {
   heap: CompileTimeHeap;
-  constants: CompileTimeConstants & ResolutionTimeConstants;
+  constants: CompileTimeConstants & ResolutionTimeConstants & DebugConstants;
 }
diff --git a/packages/@glimmer/interfaces/lib/references.d.ts b/packages/@glimmer/interfaces/lib/references.d.ts
index c54fe2dc69..ebcba50909 100644
--- a/packages/@glimmer/interfaces/lib/references.d.ts
+++ b/packages/@glimmer/interfaces/lib/references.d.ts
@@ -1,29 +1,212 @@
-import type { Nullable } from './core';
+import type { DevMode, Result } from '@glimmer/interfaces';
 
-export type ConstantReference = 0;
-export type ComputeReference = 1;
-export type UnboundReference = 2;
-export type InvokableReference = 3;
+import type { Nullable, Optional } from './core';
 
-export interface ReferenceTypes {
-  readonly Constant: ConstantReference;
-  readonly Compute: ComputeReference;
-  readonly Unbound: UnboundReference;
-  readonly Invokable: InvokableReference;
+/**
+ * A mutable cell represents a mutable, infallible piece of storage. Children of a data cell are not
+ * necessarily data cells. A mutable data cell can be directly mutated, and the mutation is also
+ * infallible.
+ */
+export type MutableCellType = 0;
+/**
+ * A readonly cell represents an infallible piece of storage. Children of a data cell are not
+ * necessarily data cells. A readonly data cell cannot be directly mutated.
+ */
+export type ReadonlyCellType = 1;
+/**
+ * A deeply constant cell is a cell whose value cannot change. Children of a data cell are also
+ * deeply constant (recursively).
+ */
+export type DeeplyConstantType = 2;
+/**
+ * A formula represents a user-space computation that could fail.
+ */
+export type FormulaType = 3;
+/**
+ * An computed cell represents a computation created by the VM. It is not allowed to fail. If
+ * a computed cell throws an exception, there is no error recovery.
+ */
+export type ComputedCellType = 4;
+/**
+ * An accessor has both a user-space computation and a userspace update. Both are fallible.
+ */
+export type AccessorType = 5;
+export type ConstantErrorType = 6;
+
+export interface ReactiveTypes {
+  readonly MutableCell: MutableCellType;
+  readonly ReadonlyCell: ReadonlyCellType;
+  readonly DeeplyConstant: DeeplyConstantType;
+  readonly ComputedCell: ReactiveComputedCell;
+  readonly Formula: FormulaType;
+  readonly Accessor: AccessorType;
+  readonly ConstantError: ConstantErrorType;
 }
 
-export type ReferenceType =
-  | ConstantReference
-  | ComputeReference
-  | UnboundReference
-  | InvokableReference;
+export type ReactiveType =
+  | MutableCellType
+  | ReadonlyCellType
+  | DeeplyConstantType
+  | ComputedCellType
+  | FormulaType
+  | AccessorType
+  | ConstantErrorType;
 
 declare const REFERENCE: unique symbol;
 export type ReferenceSymbol = typeof REFERENCE;
 
-export interface Reference<T = unknown> {
-  [REFERENCE]: ReferenceType;
-  debugLabel?: string | undefined;
-  compute: Nullable<() => T>;
-  children: null | Map<string | Reference, Reference>;
+export interface UserException extends Error {
+  readonly error: Error | undefined;
+  readonly exception: unknown;
+}
+
+/**
+ * A cell can be read from (or written to without any chance of error). Computing a formula (or
+ * writing to an accessor) may produce an error. A poisoned value is permanently an error and any
+ * attempt to read or write it will produce an error.
+ */
+type ReferenceReason = string;
+
+export type DebugLabel = readonly [string, ...(string | symbol)[]];
+
+export type DebugLabelSpec = DebugLabel | string;
+
+export type DescriptionSpec =
+  | DebugLabelSpec
+  | false
+  | undefined
+  | {
+      readonly label: DebugLabelSpec;
+
+      readonly serialization?: 'String' | 'JSON' | undefined;
+
+      /**
+       * If the reactive value represents an internal implementation detail, you should populate this
+       * field.
+       */
+      readonly internal?: {
+        parent: ReferenceDescription;
+        reason: string;
+      };
+    };
+
+/**
+ * These fields are provided by the reference constructors, and provide defaults for specific
+ * reference types.
+ */
+export type DefaultDescriptionFields<D extends Description = ReferenceDescription> = {
+  [P in keyof D as Extract<P, 'reason' | 'type' | 'read' | 'write' | 'property' | 'label'>]: D[P];
+};
+interface Described<D extends Description = Description> {
+  description: DevMode<D>;
 }
+
+interface Description {
+  readonly reason?: string | undefined;
+
+  /**
+   * Each part in a label represents a property path.
+   */
+  readonly label: DebugLabel;
+}
+
+interface ValidatableDescription extends Description {
+  readonly reason?: string | undefined;
+
+  /**
+   * If serialization is `String`, the value can be converted to a string using `String()`. If the
+   * serialization is `JSON`, the value can be converted to a useful string using `JSON.stringify`.
+   * Otherwise, the value is a regular object and cannot be easily serialized for debugging purposes.
+   */
+  readonly serialization?: 'String' | 'JSON' | undefined;
+
+  internal?: {
+    readonly parent?: ValidatableDescription;
+    readonly internal?: string;
+  };
+}
+
+/**
+ * Fallible storage might produce an error when accessed.
+ */
+type FALLIBLE_STORAGE = 'fallible';
+
+/**
+ * Infallible storage does not produce an error when accessed. It is usually a cell, but can also be
+ * special `InfallibleFormula` references that are asserted to be infallible. If accessing an
+ * infallible storage throws, there is no error recovery.
+ */
+type INFALLIBLE_STORAGE = 'infallible';
+
+/**
+ * When storage is not accessible for an operation, that operation is not available.
+ */
+type NOT_ACCESSIBLE = 'none';
+
+interface ReferenceDescription extends ValidatableDescription {
+  /**
+   * The name of the primitive reactive constructor that was used to create this
+   * reactive value (e.g. "ReadonlyCell").
+   */
+  readonly type: string;
+
+  read: FALLIBLE_STORAGE | INFALLIBLE_STORAGE;
+  write: FALLIBLE_STORAGE | INFALLIBLE_STORAGE | NOT_ACCESSIBLE;
+
+  /**
+   * The default value of `property` is:
+   *
+   * { read: 'fallible', write: 'fallible' }
+   */
+  property?:
+    | {
+        read: FALLIBLE_STORAGE | INFALLIBLE_STORAGE;
+        write: FALLIBLE_STORAGE | INFALLIBLE_STORAGE | NOT_ACCESSIBLE;
+      }
+    | undefined;
+}
+
+interface TagDescription extends ValidatableDescription {
+  subtags?: readonly TagDescription[];
+}
+
+export interface RawReactive<T = unknown, K = ReactiveType>
+  extends Described<ReferenceDescription> {
+  [REFERENCE]: K;
+  error: UserException | null;
+  /**
+   * If `compute` produces an error, it should set `error` and return `undefined`.
+   */
+  compute: Nullable<() => Optional<T>>;
+  properties: null | Map<PropertyKey | RawReactive, RawReactive>;
+}
+
+export type Reactive<T = unknown> =
+  | ReactiveCell<T>
+  | ReactiveComputedCell<T>
+  | ReactiveFormula<T>
+  | ReactiveAccessor<T>
+  | ConstantReactiveError;
+
+export type DeeplyConstantReactiveCell<T = unknown> = RawReactive<T, DeeplyConstantType>;
+export type ConstantReactiveError = RawReactive<void, ConstantErrorType> & {
+  error: UserException;
+};
+
+export type ReadonlyReactiveCell<T = unknown> =
+  | DeeplyConstantReactiveCell<T>
+  | RawReactive<T, ReadonlyCellType>;
+export type MutableReactiveCell<T = unknown> =
+  | DeeplyConstantReactiveCell<T>
+  | RawReactive<T, MutableCellType>;
+
+export type ReactiveCell<T = unknown> =
+  | ReadonlyReactiveCell<T>
+  | MutableReactiveCell<T>
+  | ReactiveComputedCell<T>;
+
+export type ReactiveComputedCell<T = unknown> = RawReactive<T, ComputedCellType>;
+export type ReactiveFormula<T = unknown> = RawReactive<T, FormulaType>;
+export type ReactiveAccessor<T = unknown> = RawReactive<T, AccessorType>;
+
+export type ReactiveResult<T> = Result<T, UserException>;
diff --git a/packages/@glimmer/interfaces/lib/result.d.ts b/packages/@glimmer/interfaces/lib/result.d.ts
new file mode 100644
index 0000000000..2bb9400502
--- /dev/null
+++ b/packages/@glimmer/interfaces/lib/result.d.ts
@@ -0,0 +1,19 @@
+export interface OkResult<T> {
+  type: 'ok';
+  value: T;
+}
+
+export interface ErrResult<E = unknown> {
+  type: 'err';
+  value: E;
+}
+
+export type Result<T, E = unknown> = { type: 'ok'; value: T } | { type: 'err'; value: E };
+export type Unwrap<R extends Result<unknown>> = R extends Result<infer T> ? T : never;
+export type UnwrapN<R extends Result<unknown> | readonly Result<unknown>[]> = R extends Result<
+  infer T
+>
+  ? T
+  : R extends readonly Result<unknown>[]
+  ? { [K in keyof R & number]: Unwrap<R[K]> }
+  : never;
diff --git a/packages/@glimmer/interfaces/lib/runtime.d.ts b/packages/@glimmer/interfaces/lib/runtime.d.ts
index 58ac633f73..dccb89359f 100644
--- a/packages/@glimmer/interfaces/lib/runtime.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime.d.ts
@@ -1,5 +1,6 @@
 export * from './runtime/arguments';
 export * from './runtime/debug-render-tree';
+export * from './runtime/debug-vm';
 export * from './runtime/element';
 export * from './runtime/environment';
 export * from './runtime/helper';
diff --git a/packages/@glimmer/interfaces/lib/runtime/arguments.d.ts b/packages/@glimmer/interfaces/lib/runtime/arguments.d.ts
index 4b0f267082..3f7ed8394c 100644
--- a/packages/@glimmer/interfaces/lib/runtime/arguments.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/arguments.d.ts
@@ -1,5 +1,5 @@
 import type { Nullable } from '../core';
-import type { Reference } from '../references';
+import type { Reactive } from '../references';
 import type { ScopeBlock } from './scope';
 
 declare const CAPTURED_ARGS: unique symbol;
@@ -9,7 +9,7 @@ export interface VMArguments {
   positional: PositionalArguments;
   named: NamedArguments;
 
-  at(pos: number): Reference;
+  at(pos: number): Reactive;
   capture(): CapturedArguments;
 }
 
@@ -21,11 +21,11 @@ export interface CapturedArguments {
 
 export interface PositionalArguments {
   length: number;
-  at(position: number): Reference;
+  at(position: number): Reactive;
   capture(): CapturedPositionalArguments;
 }
 
-export interface CapturedPositionalArguments extends Array<Reference> {
+export interface CapturedPositionalArguments extends Array<Reactive> {
   [CAPTURED_ARGS]: true;
 }
 
@@ -33,7 +33,7 @@ export interface NamedArguments {
   names: readonly string[];
   length: number;
   has(name: string): boolean;
-  get(name: string): Reference;
+  get(name: string): Reactive;
   capture(): CapturedNamedArguments;
 }
 
@@ -52,7 +52,7 @@ export interface CapturedBlockArguments {
   get(name: string): Nullable<ScopeBlock>;
 }
 
-export interface CapturedNamedArguments extends Record<string, Reference> {
+export interface CapturedNamedArguments extends Record<string, Reactive> {
   [CAPTURED_ARGS]: true;
 }
 
diff --git a/packages/@glimmer/interfaces/lib/runtime/debug-render-tree.d.ts b/packages/@glimmer/interfaces/lib/runtime/debug-render-tree.d.ts
index f50bf99222..7e997a0d66 100644
--- a/packages/@glimmer/interfaces/lib/runtime/debug-render-tree.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/debug-render-tree.d.ts
@@ -1,6 +1,6 @@
 import type { SimpleElement, SimpleNode } from '@simple-dom/interface';
 
-import type { Bounds } from '../dom/bounds';
+import type { BlockBounds } from '../dom/bounds';
 import type { Arguments, CapturedArguments } from './arguments';
 
 export type RenderNodeType = 'outlet' | 'engine' | 'route-template' | 'component';
@@ -35,7 +35,7 @@ export interface DebugRenderTree<Bucket extends object = object> {
 
   update(state: Bucket): void;
 
-  didRender(state: Bucket, bounds: Bounds): void;
+  didRender(state: Bucket, bounds: BlockBounds): void;
 
   willDestroy(state: Bucket): void;
 
diff --git a/packages/@glimmer/interfaces/lib/runtime/debug-vm.d.ts b/packages/@glimmer/interfaces/lib/runtime/debug-vm.d.ts
new file mode 100644
index 0000000000..55ebdd4a80
--- /dev/null
+++ b/packages/@glimmer/interfaces/lib/runtime/debug-vm.d.ts
@@ -0,0 +1,84 @@
+import type {
+  BlockBounds,
+  BlockMetadata,
+  DebugConstants,
+  Destroyable,
+  Nullable,
+  RuntimeHeap,
+  ScopeSlot,
+  SimpleElement,
+  SimpleNode,
+  UpdatingOpcode,
+} from '@glimmer/interfaces';
+
+// Make assignment fail in both directions (univariant).
+type SnapshotArray<T = unknown> = readonly T[] & { push?: never };
+
+export interface DebugVmSnapshot {
+  $pc: number;
+  $sp: number;
+  $ra: number;
+  $fp: number;
+  $up: unknown;
+  $s0: unknown;
+  $s1: unknown;
+  $t0: unknown;
+  $t1: unknown;
+  $v0: unknown;
+  currentPc: number;
+
+  // these values don't need to be snapshotted since they (by definition) can't change.
+  readonly constant: {
+    // The runtime heap is append-only, so it's safe to cache.
+    readonly heap: RuntimeHeap;
+    // Constants are created by deserializing the wire format. The `DebugConstants` value is
+    // readonly.
+    readonly constants: DebugConstants;
+    // The VM's meta pointer changes when the block changes, but the internals of `BlockMetadata`
+    // never change.
+    readonly block: BlockMetadata | null;
+  };
+
+  readonly dom: {
+    readonly constructing: SimpleElement | null;
+    readonly inserting: SnapshotArray<DebugCursor>;
+    readonly blocks: SnapshotArray<BlockBounds>;
+  };
+
+  readonly frame: {
+    scope: Nullable<SnapshotArray<ScopeSlot>>;
+    stack: SnapshotArray;
+    before: SnapshotArray;
+    updating: SnapshotArray<SnapshotArray<UpdatingOpcode>>;
+    destructors: SnapshotArray<Destroyable>;
+  };
+
+  readonly threw: Error | undefined;
+}
+
+export interface ReadonlyStack {
+  readonly size: number;
+  get<T = number>(position: number, base?: number): T;
+  top<T>(offset?: number): T;
+}
+
+export interface CleanStack extends ReadonlyStack {
+  push(...values: unknown[]): void;
+  pop<T>(count?: number): T;
+  dup(position?: number): void;
+}
+
+export interface InternalStack extends CleanStack {
+  reset(): void;
+}
+
+export interface DebugStack extends InternalStack {
+  /** @snapshots */
+  frame(): readonly unknown[];
+  /** @snapshots */
+  all(): { before: readonly unknown[]; readonly frame: readonly unknown[] };
+}
+export interface DebugCursor {
+  readonly parent: SimpleElement;
+  readonly next?: Nullable<SimpleNode>;
+}
diff --git a/packages/@glimmer/interfaces/lib/runtime/element.d.ts b/packages/@glimmer/interfaces/lib/runtime/element.d.ts
index 5e8c647c64..67f6f4b24a 100644
--- a/packages/@glimmer/interfaces/lib/runtime/element.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/element.d.ts
@@ -1,8 +1,8 @@
 import type { Nullable } from '../core';
-import type { Reference } from '../references';
+import type { Reactive } from '../references';
 
 export interface ElementOperations {
-  setAttribute(name: string, value: Reference, trusting: boolean, namespace: Nullable<string>): void;
+  setAttribute(name: string, value: Reactive, trusting: boolean, namespace: Nullable<string>): void;
 
   setStaticAttribute(name: string, value: string, namespace: Nullable<string>): void;
 }
diff --git a/packages/@glimmer/interfaces/lib/runtime/environment.d.ts b/packages/@glimmer/interfaces/lib/runtime/environment.d.ts
index 62cea92a84..a6f4085a1b 100644
--- a/packages/@glimmer/interfaces/lib/runtime/environment.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/environment.d.ts
@@ -7,9 +7,9 @@ import type {
 } from '../components';
 import type { Nullable } from '../core';
 import type { GlimmerTreeChanges, GlimmerTreeConstruction } from '../dom/changes';
+import type { WithCreateInstance } from '../managers';
 import type { DebugRenderTree } from './debug-render-tree';
 import type { ModifierInstance } from './modifier';
-import type { WithCreateInstance } from '../managers';
 
 export interface EnvironmentOptions {
   document?: SimpleDocument;
@@ -36,6 +36,7 @@ export interface Environment {
 
   scheduleInstallModifier(modifier: ModifierInstance): void;
   scheduleUpdateModifier(modifier: ModifierInstance): void;
+  scheduleAfterRender(callback: () => void): void;
 
   begin(): void;
   commit(): void;
@@ -44,5 +45,7 @@ export interface Environment {
   getAppendOperations(): GlimmerTreeConstruction;
 
   isInteractive: boolean;
-  debugRenderTree?: DebugRenderTree | undefined;
+  debugRenderTree: DebugRenderTree | undefined;
+
+  withDebug(debug: (tree: DebugRenderTree) => void): void;
 }
diff --git a/packages/@glimmer/interfaces/lib/runtime/helper.d.ts b/packages/@glimmer/interfaces/lib/runtime/helper.d.ts
index f4edafcbfa..1d47e99b29 100644
--- a/packages/@glimmer/interfaces/lib/runtime/helper.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/helper.d.ts
@@ -1,4 +1,4 @@
-import type { Reference } from '../references';
+import type { Reactive } from '../references';
 import type { CapturedArguments } from './arguments';
 import type { Owner } from './owner';
 import type { DynamicScope } from './scope';
@@ -6,5 +6,5 @@ import type { DynamicScope } from './scope';
 export type HelperDefinitionState = object;
 
 export interface Helper<O extends Owner = Owner> {
-  (args: CapturedArguments, owner: O | undefined, dynamicScope?: DynamicScope): Reference;
+  (args: CapturedArguments, owner: O | undefined, dynamicScope?: DynamicScope): Reactive;
 }
diff --git a/packages/@glimmer/interfaces/lib/runtime/render.d.ts b/packages/@glimmer/interfaces/lib/runtime/render.d.ts
index 22708f89f1..a309b562a1 100644
--- a/packages/@glimmer/interfaces/lib/runtime/render.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/render.d.ts
@@ -1,16 +1,20 @@
 import type { SimpleElement, SimpleNode } from '@simple-dom/interface';
 
 import type { RichIteratorResult } from '../core';
-import type { Bounds } from '../dom/bounds';
+import type { BlockBounds } from '../dom/bounds';
 import type { Environment } from './environment';
+import type { UpdatingOpcode } from './vm';
 
 export interface ExceptionHandler {
+  unwind(): boolean;
   handleException(): void;
 }
 
-export interface RenderResult extends Bounds, ExceptionHandler {
+export interface RenderResult extends BlockBounds, ExceptionHandler {
   readonly env: Environment;
   readonly drop: object;
+  readonly error?: unknown;
+  readonly children: UpdatingOpcode[];
 
   rerender(options?: { alwaysRevalidate: false }): void;
 
diff --git a/packages/@glimmer/interfaces/lib/runtime/runtime.d.ts b/packages/@glimmer/interfaces/lib/runtime/runtime.d.ts
index a3e9cf188f..ad7418a670 100644
--- a/packages/@glimmer/interfaces/lib/runtime/runtime.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/runtime.d.ts
@@ -16,12 +16,14 @@ export interface RuntimeContext {
 }
 
 export interface RuntimeProgram {
-  readonly constants: RuntimeConstants & ResolutionTimeConstants;
+  readonly constants: ProgramConstants;
   readonly heap: RuntimeHeap;
 
   opcode(offset: number): RuntimeOp;
 }
 
+export type ProgramConstants = RuntimeConstants & ResolutionTimeConstants;
+
 export interface RuntimeArtifacts {
   readonly constants: RuntimeConstants & ResolutionTimeConstants;
   readonly heap: RuntimeHeap;
diff --git a/packages/@glimmer/interfaces/lib/runtime/scope.d.ts b/packages/@glimmer/interfaces/lib/runtime/scope.d.ts
index b3a8292c1e..f1b9b2ba56 100644
--- a/packages/@glimmer/interfaces/lib/runtime/scope.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/scope.d.ts
@@ -1,5 +1,5 @@
 import type { Dict, Nullable } from '../core';
-import type { Reference } from '../references';
+import type { Reactive } from '../references';
 import type { CompilableBlock } from '../template';
 import type { BlockSymbolTable } from '../tier1/symbol-table';
 import type { Owner } from './owner';
@@ -8,24 +8,24 @@ export type Block = CompilableBlock | number;
 
 export type ScopeBlock = [CompilableBlock, Scope, BlockSymbolTable];
 export type BlockValue = ScopeBlock[0 | 1 | 2];
-export type ScopeSlot = Reference | ScopeBlock | null;
+export type ScopeSlot = Reactive | ScopeBlock | null;
 
 export interface Scope {
   // for debug only
   readonly slots: Array<ScopeSlot>;
   readonly owner: Owner;
 
-  getSelf(): Reference;
-  getSymbol(symbol: number): Reference;
+  getSelf(): Reactive;
+  getSymbol(symbol: number): Reactive;
   getBlock(symbol: number): Nullable<ScopeBlock>;
   getEvalScope(): Nullable<Dict<ScopeSlot>>;
-  getPartialMap(): Nullable<Dict<Reference>>;
+  getPartialMap(): Nullable<Dict<Reactive>>;
   bind(symbol: number, value: ScopeSlot): void;
-  bindSelf(self: Reference): void;
-  bindSymbol(symbol: number, value: Reference): void;
+  bindSelf(self: Reactive): void;
+  bindSymbol(symbol: number, value: Reactive): void;
   bindBlock(symbol: number, value: Nullable<ScopeBlock>): void;
   bindEvalScope(map: Nullable<Dict<ScopeSlot>>): void;
-  bindPartialMap(map: Dict<Reference>): void;
+  bindPartialMap(map: Dict<Reactive>): void;
   child(): Scope;
 }
 
@@ -34,7 +34,7 @@ export interface PartialScope extends Scope {
 }
 
 export interface DynamicScope {
-  get(key: string): Reference<unknown>;
-  set(key: string, reference: Reference<unknown>): Reference<unknown>;
+  get(key: string): Reactive<unknown>;
+  set(key: string, reference: Reactive<unknown>): Reactive<unknown>;
   child(): DynamicScope;
 }
diff --git a/packages/@glimmer/interfaces/lib/runtime/vm.d.ts b/packages/@glimmer/interfaces/lib/runtime/vm.d.ts
index f62b4ffb84..f2dad5a540 100644
--- a/packages/@glimmer/interfaces/lib/runtime/vm.d.ts
+++ b/packages/@glimmer/interfaces/lib/runtime/vm.d.ts
@@ -1,24 +1,39 @@
-import type { Destroyable } from '../core';
+import type { Destroyable, Nullable } from '../core';
 import type { GlimmerTreeChanges } from '../dom/changes';
-import type { Reference } from '../references';
+import type { MutableReactiveCell, Reactive } from '../references';
+import type { Result } from '../result';
 import type { Environment } from './environment';
 import type { Owner } from './owner';
 import type { ExceptionHandler } from './render';
 import type { DynamicScope } from './scope';
 /**
- * This is used in the Glimmer Embedding API. In particular, embeddings
- * provide helpers through the `CompileTimeLookup` interface, and the
- * helpers they provide implement the `Helper` interface, which is a
- * function that takes a `VM` as a parameter.
+ * This is used in the Glimmer Embedding API. In particular, embeddings provide helpers through the
+ * `CompileTimeLookup` interface, and the helpers they provide implement the `Helper` interface,
+ * which is a function that takes a `VM` as a parameter.
  */
 export interface VM<O extends Owner = Owner> {
   env: Environment;
-  dynamicScope(): DynamicScope;
+  readonly dynamicScope: DynamicScope;
+
   getOwner(): O;
-  getSelf(): Reference;
+  getSelf(): Reactive;
   associateDestroyable(child: Destroyable): void;
 }
 
+export interface CatchState {
+  isTryFrame: boolean;
+  handler: Nullable<ErrorHandler>;
+  error: MutableReactiveCell<number>;
+}
+
+export interface HandleException {
+  readonly handler: ExceptionHandler;
+  /**
+   * If present, unwinding should stop at this frame.
+   */
+  readonly unwind: Nullable<CatchState>;
+}
+
 export interface UpdatingVM {
   env: Environment;
   dom: GlimmerTreeChanges;
@@ -26,10 +41,36 @@ export interface UpdatingVM {
 
   execute(opcodes: UpdatingOpcode[], handler: ExceptionHandler): void;
   goto(index: number): void;
-  try(ops: UpdatingOpcode[], handler: ExceptionHandler | null): void;
-  throw(): void;
+  try(ops: UpdatingOpcode[], error: Nullable<HandleException>): void;
+  unwind(): void;
+  reset(): void;
+  deref<T>(reactive: Reactive<T>, then: (value: T) => void): void;
 }
 
 export interface UpdatingOpcode {
   evaluate(vm: UpdatingVM): void;
+  debug?: unknown;
+}
+
+export interface TargetState {
+  ip: number;
+  ra: number;
+  fp: number;
+  handler: ErrorHandler | null;
+  error: MutableReactiveCell<number>;
+}
+
+export type ErrorHandler = (error: unknown, retry: () => void) => Result<void>;
+
+export interface UnwindTarget {
+  child(state: TargetState): UnwindTarget;
+
+  finally(): UnwindTarget | null;
+
+  catch(error: unknown): TargetState;
+
+  /**
+   * Returns the error caught by the VM, but only if it hasn't been handled.
+   */
+  get unhandled(): Result<void>;
 }
diff --git a/packages/@glimmer/interfaces/lib/stack-aspect.d.ts b/packages/@glimmer/interfaces/lib/stack-aspect.d.ts
new file mode 100644
index 0000000000..9d7f44b058
--- /dev/null
+++ b/packages/@glimmer/interfaces/lib/stack-aspect.d.ts
@@ -0,0 +1,25 @@
+/**
+ * See guides/07-error-recovery.md
+ */
+export interface VmStackAspect {
+  readonly debug?: { frames: DebugStackAspectFrame[] };
+
+  begin(): this;
+  catch(): this;
+  finally(): this;
+
+  onCatch?(handler: () => void): this;
+  onFinally?(handler: () => void): this;
+}
+
+export type DebugStackAspectFrame = DebugParentStackFrame | LeafStackAspect;
+
+export interface DebugParentStackFrame {
+  label: string;
+  aspects: Record<string, DebugStackAspectFrame>;
+}
+
+export interface LeafStackAspect {
+  label: string;
+  values: unknown[];
+}
diff --git a/packages/@glimmer/interfaces/lib/stack.d.ts b/packages/@glimmer/interfaces/lib/stack.d.ts
index 3dfd730390..578abe2037 100644
--- a/packages/@glimmer/interfaces/lib/stack.d.ts
+++ b/packages/@glimmer/interfaces/lib/stack.d.ts
@@ -1,12 +1,63 @@
+import type { VmStackAspect } from '..';
 import type { Nullable } from './core';
 
-export interface Stack<T> {
-  current: Nullable<T>;
-
-  size: number;
+export interface Stack<in out T> extends Iterable<T>, VmStackAspect {
+  readonly current: Nullable<T>;
+  readonly size: number;
   push(item: T): void;
   pop(): Nullable<T>;
+
+  /**
+   * Returns the nth value (0-indexed) from the end. For example, if the stack was:
+   * `[1, 2, 3]`, `nth(0)` would return `3`, `nth(1)` would return `2`, and `nth(2)` would
+   * return `1`.
+   *
+   * During a transaction, `nth()` can be used to access the items that were on the stack
+   * before the transaction began.
+   *
+   * Returns `null` if the stack is empty.
+   */
   nth(from: number): Nullable<T>;
-  isEmpty(): boolean;
+
+  /**
+   * Return the stack as a snapshotted array. In a transaction, `toArray()` returns the entire
+   * stack, including the items that were on the stack before the transaction began.
+   */
   toArray(): T[];
+
+  /**
+   * Creates (and returns) a new tranactional stack. Pushes to the transactional stack will work as
+   * normal. Popping past the start of the transaction will throw an error.
+   *
+   * The expected usage pattern is:
+   *
+   * 1. `begin()` returns a new stack
+   * 2. pushes and pops inside the stack are balanced
+   * 3. call `finally()` after making all changes
+   *   a. alternatively, call `rollback()` if you want to abandon any pushes made during the
+   *      transaction.
+   *
+   * You call `finally()` at the end of the balanced operations made during the transaction. After
+   * `finally`, you can pop items from the original stack.
+   *
+   * You call `rollback()` if you want to abandon any pushes made during the transaction. It returns
+   * the original stack, and allows you to abandon pushes without balanced pops.
+   *
+   * Nested transactions are allowed.
+   */
+  begin(): this;
+
+  /**
+   * Rolls back the stack to its state before the most recent call to `begin()`. This allows you to
+   * abandon any unbalanced pushes.
+   *
+   * `rollback()` returns the original stack.
+   */
+  catch(): this;
+
+  /**
+   * Validates that there were balanced pushes and pops during the transaction and returns the
+   * original stack.
+   */
+  finally(): this;
 }
diff --git a/packages/@glimmer/interfaces/lib/tags.d.ts b/packages/@glimmer/interfaces/lib/tags.d.ts
index 00bf6227d2..ca0f61e0d8 100644
--- a/packages/@glimmer/interfaces/lib/tags.d.ts
+++ b/packages/@glimmer/interfaces/lib/tags.d.ts
@@ -1,3 +1,5 @@
+import type { Described, TagDescription } from './references';
+
 declare const TYPE: unique symbol;
 export type TagTypeSymbol = typeof TYPE;
 
@@ -30,7 +32,7 @@ export type TagId = MonomorphicTagId | PolymorphicTagId;
 
 export type Revision = number;
 
-export interface Tag {
+export interface Tag extends Described<TagDescription> {
   readonly [TYPE]: TagId;
   readonly subtag?: Tag | Tag[] | null | undefined;
   [COMPUTE](): Revision;
@@ -55,3 +57,8 @@ export interface ConstantTag extends MonomorphicTag {
 export interface CombinatorTag extends MonomorphicTag {
   readonly [TYPE]: COMBINATOR_TAG_ID;
 }
+
+export type SomeTag = UpdatableTag | DirtyableTag | ConstantTag | CombinatorTag;
+export type TagForId<Id extends MonomorphicTagId> = SomeTag extends infer T extends { [TYPE]: Id }
+  ? T
+  : never;
diff --git a/packages/@glimmer/interfaces/lib/template.d.ts b/packages/@glimmer/interfaces/lib/template.d.ts
index 86325ec94a..f42565a8a8 100644
--- a/packages/@glimmer/interfaces/lib/template.d.ts
+++ b/packages/@glimmer/interfaces/lib/template.d.ts
@@ -3,7 +3,7 @@ import type { Operand, SerializedInlineBlock, SerializedTemplateBlock } from './
 import type { EncoderError } from './compile/encoder';
 import type { Nullable } from './core';
 import type { InternalComponentCapabilities } from './managers/internal/component';
-import type { CompileTimeCompilationContext, ConstantPool, SerializedHeap } from './program';
+import type { ConstantPool, JitContext, SerializedHeap } from './program';
 import type { Owner } from './runtime';
 import type { BlockSymbolTable, ProgramSymbolTable, SymbolTable } from './tier1/symbol-table';
 
@@ -93,8 +93,8 @@ export interface NamedBlocks {
   names: string[];
 }
 
-export interface ContainingMetadata {
-  evalSymbols: Nullable<string[]>;
+export interface BlockMetadata {
+  debugSymbols: Nullable<string[]>;
   upvars: Nullable<string[]>;
   scopeValues: unknown[] | null;
   isStrictMode: boolean;
@@ -108,7 +108,12 @@ export interface CompilerArtifacts {
   constants: ConstantPool;
 }
 
+export declare const IS_COMPILABLE_TEMPLATE_BRAND: unique symbol;
+export type IS_COMPILABLE_TEMPLATE_BRAND = typeof IS_COMPILABLE_TEMPLATE_BRAND;
+
 export interface CompilableTemplate<S extends SymbolTable = SymbolTable> {
+  readonly [IS_COMPILABLE_TEMPLATE_BRAND]: true;
   symbolTable: S;
-  compile(context: CompileTimeCompilationContext): HandleResult;
+  meta: BlockMetadata;
+  compile(context: JitContext): HandleResult;
 }
diff --git a/packages/@glimmer/interfaces/lib/tier1/symbol-table.d.ts b/packages/@glimmer/interfaces/lib/tier1/symbol-table.d.ts
index 57332a275b..44fe712e53 100644
--- a/packages/@glimmer/interfaces/lib/tier1/symbol-table.d.ts
+++ b/packages/@glimmer/interfaces/lib/tier1/symbol-table.d.ts
@@ -1,5 +1,5 @@
 export interface ProgramSymbolTable {
-  hasEval: boolean;
+  hasDebug: boolean;
   symbols: string[];
 }
 
diff --git a/packages/@glimmer/interfaces/lib/vm-opcodes.d.ts b/packages/@glimmer/interfaces/lib/vm-opcodes.d.ts
index c428f832fc..75235ec411 100644
--- a/packages/@glimmer/interfaces/lib/vm-opcodes.d.ts
+++ b/packages/@glimmer/interfaces/lib/vm-opcodes.d.ts
@@ -1,217 +1,6 @@
-/* This file is generated by build/debug.js */
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+import type { VmMachineOp, VmOpMap,VmSyscallOp } from './generated/vm-opcodes';
 
-export type VmMachinePushFrame = 0;
-export type VmMachinePopFrame = 1;
-export type VmMachineInvokeVirtual = 2;
-export type VmMachineInvokeStatic = 3;
-export type VmMachineJump = 4;
-export type VmMachineReturn = 5;
-export type VmMachineReturnTo = 6;
-export type VmMachineSize = 7;
-
-export type VmMachineOp =
-  | VmMachinePushFrame
-  | VmMachinePopFrame
-  | VmMachineInvokeVirtual
-  | VmMachineInvokeStatic
-  | VmMachineJump
-  | VmMachineReturn
-  | VmMachineReturnTo
-  | VmMachineSize;
-
-export type VmHelper = 16;
-export type VmSetNamedVariables = 17;
-export type VmSetBlocks = 18;
-export type VmSetVariable = 19;
-export type VmSetBlock = 20;
-export type VmGetVariable = 21;
-export type VmGetProperty = 22;
-export type VmGetBlock = 23;
-export type VmSpreadBlock = 24;
-export type VmHasBlock = 25;
-export type VmHasBlockParams = 26;
-export type VmConcat = 27;
-export type VmConstant = 28;
-export type VmConstantReference = 29;
-export type VmPrimitive = 30;
-export type VmPrimitiveReference = 31;
-export type VmReifyU32 = 32;
-export type VmDup = 33;
-export type VmPop = 34;
-export type VmLoad = 35;
-export type VmFetch = 36;
-export type VmRootScope = 37;
-export type VmVirtualRootScope = 38;
-export type VmChildScope = 39;
-export type VmPopScope = 40;
-export type VmText = 41;
-export type VmComment = 42;
-export type VmAppendHTML = 43;
-export type VmAppendSafeHTML = 44;
-export type VmAppendDocumentFragment = 45;
-export type VmAppendNode = 46;
-export type VmAppendText = 47;
-export type VmOpenElement = 48;
-export type VmOpenDynamicElement = 49;
-export type VmPushRemoteElement = 50;
-export type VmStaticAttr = 51;
-export type VmDynamicAttr = 52;
-export type VmComponentAttr = 53;
-export type VmFlushElement = 54;
-export type VmCloseElement = 55;
-export type VmPopRemoteElement = 56;
-export type VmModifier = 57;
-export type VmBindDynamicScope = 58;
-export type VmPushDynamicScope = 59;
-export type VmPopDynamicScope = 60;
-export type VmCompileBlock = 61;
-export type VmPushBlockScope = 62;
-export type VmPushSymbolTable = 63;
-export type VmInvokeYield = 64;
-export type VmJumpIf = 65;
-export type VmJumpUnless = 66;
-export type VmJumpEq = 67;
-export type VmAssertSame = 68;
-export type VmEnter = 69;
-export type VmExit = 70;
-export type VmToBoolean = 71;
-export type VmEnterList = 72;
-export type VmExitList = 73;
-export type VmIterate = 74;
-export type VmMain = 75;
-export type VmContentType = 76;
-export type VmCurry = 77;
-export type VmPushComponentDefinition = 78;
-export type VmPushDynamicComponentInstance = 79;
-export type VmResolveDynamicComponent = 80;
-export type VmResolveCurriedComponent = 81;
-export type VmPushArgs = 82;
-export type VmPushEmptyArgs = 83;
-export type VmPopArgs = 84;
-export type VmPrepareArgs = 85;
-export type VmCaptureArgs = 86;
-export type VmCreateComponent = 87;
-export type VmRegisterComponentDestructor = 88;
-export type VmPutComponentOperations = 89;
-export type VmGetComponentSelf = 90;
-export type VmGetComponentTagName = 91;
-export type VmGetComponentLayout = 92;
-export type VmBindEvalScope = 93;
-export type VmSetupForEval = 94;
-export type VmPopulateLayout = 95;
-export type VmInvokeComponentLayout = 96;
-export type VmBeginComponentTransaction = 97;
-export type VmCommitComponentTransaction = 98;
-export type VmDidCreateElement = 99;
-export type VmDidRenderLayout = 100;
-export type VmResolveMaybeLocal = 102;
-export type VmDebugger = 103;
-export type VmSize = 104;
-export type VmStaticComponentAttr = 105;
-export type VmDynamicContentType = 106;
-export type VmDynamicHelper = 107;
-export type VmDynamicModifier = 108;
-export type VmIfInline = 109;
-export type VmNot = 110;
-export type VmGetDynamicVar = 111;
-export type VmLog = 112;
-
-export type VmOp =
-  | VmHelper
-  | VmSetNamedVariables
-  | VmSetBlocks
-  | VmSetVariable
-  | VmSetBlock
-  | VmGetVariable
-  | VmGetProperty
-  | VmGetBlock
-  | VmSpreadBlock
-  | VmHasBlock
-  | VmHasBlockParams
-  | VmConcat
-  | VmConstant
-  | VmConstantReference
-  | VmPrimitive
-  | VmPrimitiveReference
-  | VmReifyU32
-  | VmDup
-  | VmPop
-  | VmLoad
-  | VmFetch
-  | VmRootScope
-  | VmVirtualRootScope
-  | VmChildScope
-  | VmPopScope
-  | VmText
-  | VmComment
-  | VmAppendHTML
-  | VmAppendSafeHTML
-  | VmAppendDocumentFragment
-  | VmAppendNode
-  | VmAppendText
-  | VmOpenElement
-  | VmOpenDynamicElement
-  | VmPushRemoteElement
-  | VmStaticAttr
-  | VmDynamicAttr
-  | VmComponentAttr
-  | VmFlushElement
-  | VmCloseElement
-  | VmPopRemoteElement
-  | VmModifier
-  | VmBindDynamicScope
-  | VmPushDynamicScope
-  | VmPopDynamicScope
-  | VmCompileBlock
-  | VmPushBlockScope
-  | VmPushSymbolTable
-  | VmInvokeYield
-  | VmJumpIf
-  | VmJumpUnless
-  | VmJumpEq
-  | VmAssertSame
-  | VmEnter
-  | VmExit
-  | VmToBoolean
-  | VmEnterList
-  | VmExitList
-  | VmIterate
-  | VmMain
-  | VmContentType
-  | VmCurry
-  | VmPushComponentDefinition
-  | VmPushDynamicComponentInstance
-  | VmResolveDynamicComponent
-  | VmResolveCurriedComponent
-  | VmPushArgs
-  | VmPushEmptyArgs
-  | VmPopArgs
-  | VmPrepareArgs
-  | VmCaptureArgs
-  | VmCreateComponent
-  | VmRegisterComponentDestructor
-  | VmPutComponentOperations
-  | VmGetComponentSelf
-  | VmGetComponentTagName
-  | VmGetComponentLayout
-  | VmBindEvalScope
-  | VmSetupForEval
-  | VmPopulateLayout
-  | VmInvokeComponentLayout
-  | VmBeginComponentTransaction
-  | VmCommitComponentTransaction
-  | VmDidCreateElement
-  | VmDidRenderLayout
-  | VmResolveMaybeLocal
-  | VmDebugger
-  | VmSize
-  | VmStaticComponentAttr
-  | VmDynamicContentType
-  | VmDynamicHelper
-  | VmDynamicModifier
-  | VmIfInline
-  | VmNot
-  | VmGetDynamicVar
-  | VmLog;
-
-export type SomeVmOp = VmOp | VmMachineOp;
+export type { VmMachineOp, VmOpMap,VmSyscallOp };
+export type VmOpName = keyof VmOpMap;
+export type VmOp = VmMachineOp | VmSyscallOp;
diff --git a/packages/@glimmer/interfaces/package.json b/packages/@glimmer/interfaces/package.json
index 5458c2d17e..9e4cb6b223 100644
--- a/packages/@glimmer/interfaces/package.json
+++ b/packages/@glimmer/interfaces/package.json
@@ -2,9 +2,11 @@
   "name": "@glimmer/interfaces",
   "version": "0.85.3",
   "repository": "https://github.com/glimmerjs/glimmer-vm/tree/master/packages/@glimmer/interfaces",
-  "types": "index.ts",
+  "main": "index.d.ts",
+  "types": "index.d.ts",
   "exports": {
-    "types": "./index.d.ts"
+    "types": "./index.d.ts",
+    "default": "./index.d.ts"
   },
   "scripts": {
     "test:lint": "eslint .",
diff --git a/packages/@glimmer/local-debug-flags/index.ts b/packages/@glimmer/local-debug-flags/index.ts
index c0e9aa27f2..df7071ce1b 100644
--- a/packages/@glimmer/local-debug-flags/index.ts
+++ b/packages/@glimmer/local-debug-flags/index.ts
@@ -1,19 +1,160 @@
-export const LOCAL_DEBUG: true | false =
-  import.meta.env.DEV &&
-  (() => {
-    let location = typeof window !== 'undefined' && window.location;
-    if (location && /[&?]disable_local_debug/u.test(window.location.search)) {
-      return false;
+/* eslint-disable no-console */
+export const LOCAL_DEBUG = import.meta.env.DEV && !hasFlag('disable_local_debug');
+export const LOCAL_TRACE_LOGGING = hasFlag('enable_trace_logging');
+export const LOCAL_EXPLAIN_LOGGING = hasFlag('enable_trace_explanations');
+export const LOCAL_INTERNALS_LOGGING = hasFlag('enable_internals_logging');
+export const LOCAL_SUBTLE_LOGGING = hasFlag('enable_subtle_logging');
+
+if (LOCAL_INTERNALS_LOGGING || LOCAL_EXPLAIN_LOGGING) {
+  console.group('%cLogger Flags:', 'font-weight: normal; color: teal');
+  log(
+    'LOCAL_DEBUG',
+    LOCAL_DEBUG,
+    'Enables debug logging for people working on this repository. If this is off, none of the other flags will do anything.'
+  );
+  log(
+    'LOCAL_TRACE_LOGGING',
+    LOCAL_TRACE_LOGGING,
+    `Enables trace logging. This is most useful if you're working on the internals, and includes a trace of compiled templates and a trace of VM execution that includes state changes. If you want to see all of the state, enable LOCAL_SUBTLE_LOGGING.`
+  );
+  log(
+    'LOCAL_EXPLAIN_LOGGING',
+    LOCAL_EXPLAIN_LOGGING,
+    'Enables trace explanations (like this one!)'
+  );
+  log(
+    'LOCAL_INTERNALS_LOGGING',
+    LOCAL_INTERNALS_LOGGING,
+    `Enables logging of internal state. This is most useful if you're working on the debug infrastructure itself.`
+  );
+  log(
+    'LOCAL_SUBTLE_LOGGING',
+    LOCAL_SUBTLE_LOGGING,
+    'Enables more complete logging, even when the result would be extremely verbose and not usually necessary. Subtle logs are dimmed when enabled.'
+  );
+  log(
+    'audit_logging',
+    getFlag('audit_logging'),
+    'Enables specific audit logs. These logs are useful during an internal refactor and can help pinpoint exactly where legacy code is being used (e.g. infallible_deref and throwing_deref).'
+  );
+  log(
+    'focus_highlight',
+    getFlag('focus_highlight'),
+    `Enables focus highlighting of specific trace logs. This makes it easy to see specific aspects of the trace at a glance.`
+  );
+  console.log();
+  console.groupEnd();
+
+  function log(flag: string, value: boolean | string | string[] | undefined, explanation: string) {
+    const { formatted, style } = format(value);
+
+    const header = [
+      `%c[${flag}]%c %c${formatted}`,
+      `font-weight: normal; background-color: ${style}; color: white`,
+      ``,
+      `font-weight: normal; color: ${style}`,
+    ];
+
+    if (LOCAL_EXPLAIN_LOGGING) {
+      console.group(...header);
+      console.log(`%c${explanation}`, 'color: grey');
+      console.groupEnd();
+    } else {
+      console.log(...header);
     }
-    return true;
-  })();
-
-export const LOCAL_SHOULD_LOG: true | false =
-  import.meta.env.DEV &&
-  (() => {
-    let location = typeof window !== 'undefined' && window.location;
-    if (location && /[&?]enable_local_should_log/u.test(window.location.search)) {
-      return true;
+  }
+
+  function format(flagValue: boolean | string | string[] | undefined): {
+    formatted: string;
+    style: string;
+  } {
+    if (flagValue === undefined || flagValue === false) {
+      return { formatted: 'off', style: 'grey' };
+    } else if (flagValue === true) {
+      return { formatted: 'on', style: 'green' };
+    } else if (typeof flagValue === 'string') {
+      return { formatted: flagValue, style: 'blue' };
+    } else if (Array.isArray(flagValue)) {
+      if (flagValue.length === 0) {
+        return { formatted: 'none', style: 'grey' };
+      }
+      return { formatted: `[${flagValue.join(', ')}]`, style: 'teal' };
+    } else {
+      assertNever(flagValue);
     }
+  }
+
+  function assertNever(_never: never): never {
+    throw new Error('unreachable');
+  }
+}
+
+// This function should turn into a constant `return false` in `import.meta.env.PROD`,
+// which should inline properly via terser, swc and esbuild.
+//
+// https://tiny.katz.zone/BNqN3F
+function hasFlag(flag: string): true | false {
+  if (import.meta.env.DEV) {
+    const url =
+      typeof window !== 'undefined' && window.location ? new URL(window.location.href) : null;
+
+    return url?.searchParams.has(flag) ?? false;
+  } else {
     return false;
-  })();
+  }
+}
+
+if (import.meta.env.DEV) {
+  Error.stackTraceLimit = Infinity;
+}
+
+/**
+ * If the specified flag is set as a boolean flag with no value, `true` is returned.
+ *
+ * Otherwise, this function returns true if the flag value is a pattern that matches `value`.
+ *
+ * The pattern can have a `*`, which matches any number of characters.
+ */
+export function hasFlagWith(flag: string, value: string): boolean {
+  if (import.meta.env.DEV) {
+    const url =
+      typeof window !== 'undefined' && window.location ? new URL(window.location.href) : null;
+
+    const pattern = new RegExp(`^${value.replace(/\*/gu, '.*')}$`, 'u');
+
+    return url?.searchParams.getAll(flag).some((param) => pattern.test(param)) ?? false;
+  } else {
+    return false;
+  }
+}
+
+export function getFlagValues(flag: string): string[] {
+  if (import.meta.env.DEV) {
+    const url =
+      typeof window !== 'undefined' && window.location ? new URL(window.location.href) : null;
+
+    const all = url?.searchParams.getAll(flag);
+    return all?.filter((a) => a !== '') ?? [];
+  } else {
+    return [];
+  }
+}
+
+export function getFlag(flag: string): boolean | string | string[] | undefined {
+  if (import.meta.env.DEV) {
+    const url =
+      typeof window !== 'undefined' && window.location ? new URL(window.location.href) : null;
+
+    const all = url?.searchParams.getAll(flag);
+
+    if (all) {
+      if (all.length === 1) {
+        return all[0] === '' ? true : all[0];
+      } else {
+        return all;
+      }
+    }
+  } else {
+    return undefined;
+  }
+}
diff --git a/packages/@glimmer/manager/lib/public/component.ts b/packages/@glimmer/manager/lib/public/component.ts
index f534f389ec..0630f84085 100644
--- a/packages/@glimmer/manager/lib/public/component.ts
+++ b/packages/@glimmer/manager/lib/public/component.ts
@@ -1,4 +1,3 @@
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
   Arguments,
   ComponentCapabilities,
@@ -15,12 +14,15 @@ import type {
   Nullable,
   Owner,
   VMArguments,
-} from "@glimmer/interfaces";
-import { createConstRef, type Reference } from '@glimmer/reference';
+} from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
+import { registerDestructor } from '@glimmer/destroyable';
+import { ReadonlyCell  } from '@glimmer/reference';
+
+import type { ManagerFactory } from './api';
 
 import { argsProxyFor } from '../util/args-proxy';
 import { buildCapabilities, FROM_CAPABILITIES } from '../util/capabilities';
-import type { ManagerFactory } from './api';
 
 const CAPABILITIES = {
   dynamicLayout: false,
@@ -80,13 +82,12 @@ export function hasDestructors<ComponentInstance>(
 }
 
 /**
-  The CustomComponentManager allows addons to provide custom component
-  implementations that integrate seamlessly into Ember. This is accomplished
-  through a delegate, registered with the custom component manager, which
-  implements a set of hooks that determine component behavior.
+  The CustomComponentManager allows addons to provide custom component implementations that
+  integrate seamlessly into Ember. This is accomplished through a delegate, registered with the
+  custom component manager, which implements a set of hooks that determine component behavior.
 
-  To create a custom component manager, instantiate a new CustomComponentManager
-  class and pass the delegate as the first argument:
+  To create a custom component manager, instantiate a new CustomComponentManager class and pass the
+  delegate as the first argument:
 
   ```js
   let manager = new CustomComponentManager({
@@ -96,9 +97,8 @@ export function hasDestructors<ComponentInstance>(
 
   ## Delegate Hooks
 
-  Throughout the lifecycle of a component, the component manager will invoke
-  delegate hooks that are responsible for surfacing those lifecycle changes to
-  the end developer.
+  Throughout the lifecycle of a component, the component manager will invoke delegate hooks that are
+  responsible for surfacing those lifecycle changes to the end developer.
 
   * `create()` - invoked when a new instance of a component should be created
   * `update()` - invoked when the arguments passed to a component change
@@ -120,10 +120,12 @@ export class CustomComponentManager<O extends Owner, ComponentInstance>
       delegate = factory(owner);
 
       if (import.meta.env.DEV && !FROM_CAPABILITIES!.has(delegate.capabilities)) {
-        // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
+        // TODO: This error message should make sense in both Ember and Glimmer
+        // https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(
           `Custom component managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.13')\` (imported via \`import { capabilities } from '@ember/component';\`). Received: \`${JSON.stringify(
             delegate.capabilities
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @todo
           )}\` for: \`${delegate}\``
         );
       }
@@ -148,6 +150,7 @@ export class CustomComponentManager<O extends Owner, ComponentInstance>
   }
 
   getDebugName(definition: ComponentDefinitionState): string {
+    // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @todo
     return typeof definition === 'function' ? definition.name : definition.toString();
   }
 
@@ -176,8 +179,8 @@ export class CustomComponentManager<O extends Owner, ComponentInstance>
 
   didUpdateLayout(): void {}
 
-  getSelf({ component, delegate }: CustomComponentState<ComponentInstance>): Reference {
-    return createConstRef(delegate.getContext(component), 'this');
+  getSelf({ component, delegate }: CustomComponentState<ComponentInstance>): Reactive {
+    return ReadonlyCell(delegate.getContext(component), 'this');
   }
 
   getDestroyable(bucket: CustomComponentState<ComponentInstance>): Nullable<Destroyable> {
diff --git a/packages/@glimmer/manager/lib/public/helper.ts b/packages/@glimmer/manager/lib/public/helper.ts
index a5e2105837..fbe3f340d6 100644
--- a/packages/@glimmer/manager/lib/public/helper.ts
+++ b/packages/@glimmer/manager/lib/public/helper.ts
@@ -1,4 +1,3 @@
-import { associateDestroyableChild } from '@glimmer/destroyable';
 import type {
   Helper,
   HelperCapabilities,
@@ -9,12 +8,14 @@ import type {
   HelperManagerWithValue,
   InternalHelperManager,
   Owner,
-} from "@glimmer/interfaces";
-import { createComputeRef, createConstRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
+} from '@glimmer/interfaces';
+import { associateDestroyableChild } from '@glimmer/destroyable';
+import { Formula, ReadonlyCell, UNDEFINED_REFERENCE } from '@glimmer/reference';
+
+import type { ManagerFactory } from './index';
 
 import { argsProxyFor } from '../util/args-proxy';
 import { buildCapabilities, FROM_CAPABILITIES } from '../util/capabilities';
-import type { ManagerFactory } from './index';
 
 export function helperCapabilities<Version extends keyof HelperCapabilitiesVersions>(
   managerAPI: Version,
@@ -77,10 +78,12 @@ export class CustomHelperManager<O extends Owner = Owner> implements InternalHel
       delegate = factory(owner);
 
       if (import.meta.env.DEV && !FROM_CAPABILITIES!.has(delegate.capabilities)) {
-        // TODO: This error message should make sense in both Ember and Glimmer https://github.com/glimmerjs/glimmer-vm/issues/1200
+        // TODO: This error message should make sense in both Ember and Glimmer
+        // https://github.com/glimmerjs/glimmer-vm/issues/1200
         throw new Error(
           `Custom helper managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.23')\` (imported via \`import { capabilities } from '@ember/helper';\`). Received: \`${JSON.stringify(
             delegate.capabilities
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @todo
           )}\` for: \`${delegate}\``
         );
       }
@@ -114,9 +117,8 @@ export class CustomHelperManager<O extends Owner = Owner> implements InternalHel
       const bucket = manager.createHelper(definition, args);
 
       if (hasValue(manager)) {
-        let cache = createComputeRef(
+        let cache = Formula(
           () => (manager as HelperManagerWithValue<unknown>).getValue(bucket),
-          null,
           import.meta.env.DEV && manager.getDebugName && manager.getDebugName(definition)
         );
 
@@ -126,7 +128,7 @@ export class CustomHelperManager<O extends Owner = Owner> implements InternalHel
 
         return cache;
       } else if (hasDestroyable(manager)) {
-        let ref = createConstRef(
+        let ref = ReadonlyCell(
           undefined,
           import.meta.env.DEV && (manager.getDebugName?.(definition) ?? 'unknown helper')
         );
diff --git a/packages/@glimmer/manager/lib/public/modifier.ts b/packages/@glimmer/manager/lib/public/modifier.ts
index cb9deb9475..5c8444b3f4 100644
--- a/packages/@glimmer/manager/lib/public/modifier.ts
+++ b/packages/@glimmer/manager/lib/public/modifier.ts
@@ -1,22 +1,32 @@
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
   Arguments,
   CapturedArguments,
+  DevMode,
   InternalModifierManager,
   ModifierCapabilities,
   ModifierCapabilitiesVersions,
   ModifierManager,
   Owner,
   SimpleElement,
+  TagDescription,
   UpdatableTag,
 } from '@glimmer/interfaces';
-import { valueForRef } from '@glimmer/reference';
-import { castToBrowser, dict } from '@glimmer/util';
+import { registerDestructor } from '@glimmer/destroyable';
+import { unwrapReactive } from '@glimmer/reference';
+import {
+  castToBrowser,
+  devmode,
+  devmodeOr,
+  dict,
+  setDescription,
+  stringifyDebugLabel,
+} from '@glimmer/util';
 import { createUpdatableTag, untrack } from '@glimmer/validator';
 
+import type { ManagerFactory } from '.';
+
 import { argsProxyFor } from '../util/args-proxy';
 import { buildCapabilities, FROM_CAPABILITIES } from '../util/capabilities';
-import type { ManagerFactory } from '.';
 
 export function modifierCapabilities<Version extends keyof ModifierCapabilitiesVersions>(
   managerAPI: Version,
@@ -37,7 +47,7 @@ export interface CustomModifierState<ModifierInstance> {
   modifier: ModifierInstance;
   delegate: ModifierManager<ModifierInstance>;
   args: Arguments;
-  debugName?: string;
+  description: DevMode<TagDescription>;
 }
 
 /**
@@ -84,6 +94,7 @@ export class CustomModifierManager<O extends Owner, ModifierInstance>
         throw new Error(
           `Custom modifier managers must have a \`capabilities\` property that is the result of calling the \`capabilities('3.22')\` (imported via \`import { capabilities } from '@ember/modifier';\`). Received: \`${JSON.stringify(
             delegate.capabilities
+            // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @todo
           )}\` for: \`${delegate}\``
         );
       }
@@ -100,10 +111,19 @@ export class CustomModifierManager<O extends Owner, ModifierInstance>
     let args = argsProxyFor(capturedArgs, 'modifier');
     let instance: ModifierInstance = delegate.createModifier(definition, args);
 
-    let tag = createUpdatableTag();
-    let state: CustomModifierState<ModifierInstance>;
+    const description = devmode(
+      () =>
+        ({
+          reason: 'modifier',
+          // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @todo
+          label: typeof definition === 'function' ? [definition.name] : [`${definition}`],
+        }) satisfies TagDescription
+    );
+
+    let tag = createUpdatableTag(description);
+    // let state: CustomModifierState<ModifierInstance>;
 
-    state = {
+    const state = {
       tag,
       element,
       delegate,
@@ -111,17 +131,15 @@ export class CustomModifierManager<O extends Owner, ModifierInstance>
       modifier: instance,
     };
 
-    if (import.meta.env.DEV) {
-      state.debugName = typeof definition === 'function' ? definition.name : definition.toString();
-    }
+    setDescription(state, description);
 
     registerDestructor(state, () => delegate.destroyModifier(instance, args));
 
     return state;
   }
 
-  getDebugName({ debugName }: CustomModifierState<ModifierInstance>) {
-    return debugName!;
+  getDebugName(state: CustomModifierState<ModifierInstance>) {
+    return devmodeOr(() => stringifyDebugLabel(state), 'modifier');
   }
 
   getTag({ tag }: CustomModifierState<ModifierInstance>) {
@@ -160,10 +178,10 @@ export function reifyArgs({ named, positional }: CapturedArguments): {
   let reifiedNamed = dict();
 
   for (const [key, value] of Object.entries(named)) {
-    reifiedNamed[key] = valueForRef(value);
+    reifiedNamed[key] = unwrapReactive(value);
   }
 
-  let reifiedPositional = positional.map(valueForRef);
+  let reifiedPositional = positional.map(unwrapReactive);
 
   return {
     named: reifiedNamed,
diff --git a/packages/@glimmer/manager/lib/util/args-proxy.ts b/packages/@glimmer/manager/lib/util/args-proxy.ts
index 890513b141..a6e8a7704e 100644
--- a/packages/@glimmer/manager/lib/util/args-proxy.ts
+++ b/packages/@glimmer/manager/lib/util/args-proxy.ts
@@ -4,8 +4,10 @@ import type {
   CapturedNamedArguments,
   CapturedPositionalArguments,
 } from '@glimmer/interfaces';
-import { valueForRef } from '@glimmer/reference';
-import { type Tag, track } from '@glimmer/validator';
+import type {Tag} from '@glimmer/validator';
+import { unwrapReactive } from '@glimmer/reference';
+import { devmode } from '@glimmer/util';
+import {  track } from '@glimmer/validator';
 
 const CUSTOM_TAG_FOR = new WeakMap<object, (obj: object, key: string) => Tag>();
 
@@ -28,27 +30,35 @@ function convertToInt(prop: number | string | symbol): number | null {
 }
 
 function tagForNamedArg(namedArgs: CapturedNamedArguments, key: string): Tag {
-  return track(() => {
-    if (key in namedArgs) {
-      valueForRef(namedArgs[key]!);
-    }
-  });
+  return track(
+    () => {
+      if (key in namedArgs) {
+        unwrapReactive(namedArgs[key]!);
+      }
+    },
+    devmode(() => ({
+      label: [`@${key}`],
+    }))
+  );
 }
 
 function tagForPositionalArg(positionalArgs: CapturedPositionalArguments, key: string): Tag {
-  return track(() => {
-    if (key === '[]') {
-      // consume all of the tags in the positional array
-      positionalArgs.forEach(valueForRef);
-    }
-
-    const parsed = convertToInt(key);
-
-    if (parsed !== null && parsed < positionalArgs.length) {
-      // consume the tag of the referenced index
-      valueForRef(positionalArgs[parsed]!);
-    }
-  });
+  return track(
+    () => {
+      if (key === '[]') {
+        // consume all of the tags in the positional array
+        positionalArgs.forEach(unwrapReactive);
+      }
+
+      const parsed = convertToInt(key);
+
+      if (parsed !== null && parsed < positionalArgs.length) {
+        // consume the tag of the referenced index
+        unwrapReactive(positionalArgs[parsed]!);
+      }
+    },
+    devmode(() => ({ label: [`#${key}`] }))
+  );
 }
 
 class NamedArgsProxy implements ProxyHandler<{}> {
@@ -60,7 +70,7 @@ class NamedArgsProxy implements ProxyHandler<{}> {
     const ref = this.named[prop as string];
 
     if (ref !== undefined) {
-      return valueForRef(ref);
+      return unwrapReactive(ref);
     }
   }
 
@@ -108,7 +118,7 @@ class PositionalArgsProxy implements ProxyHandler<[]> {
     const parsed = convertToInt(prop);
 
     if (parsed !== null && parsed < positional.length) {
-      return valueForRef(positional[parsed]!);
+      return unwrapReactive(positional[parsed]!);
     }
 
     return (target as any)[prop];
diff --git a/packages/@glimmer/manager/lib/util/capabilities.ts b/packages/@glimmer/manager/lib/util/capabilities.ts
index 9c0ed2e08b..39bf102bd4 100644
--- a/packages/@glimmer/manager/lib/util/capabilities.ts
+++ b/packages/@glimmer/manager/lib/util/capabilities.ts
@@ -1,4 +1,3 @@
-import { check, CheckNumber } from '@glimmer/debug';
 import type {
   AttributeHookCapability,
   Capabilities,
@@ -24,6 +23,7 @@ import type {
   WithUpdateHook,
   WrappedCapability,
 } from '@glimmer/interfaces';
+import { check, CheckNumber } from '@glimmer/debug';
 import { InternalComponentCapabilities } from '@glimmer/vm';
 
 export const FROM_CAPABILITIES = import.meta.env.DEV ? new WeakSet() : undefined;
diff --git a/packages/@glimmer/manager/test/managers-test.ts b/packages/@glimmer/manager/test/managers-test.ts
index bd3947267c..d50c42c1ae 100644
--- a/packages/@glimmer/manager/test/managers-test.ts
+++ b/packages/@glimmer/manager/test/managers-test.ts
@@ -5,10 +5,10 @@ import type {
   InternalHelperManager,
   ModifierManager,
 } from '@glimmer/interfaces';
+import type {CustomHelperManager} from '@glimmer/manager';
 import {
   componentCapabilities,
   CustomComponentManager,
-  type CustomHelperManager,
   CustomModifierManager,
   getInternalComponentManager,
   getInternalHelperManager,
@@ -20,7 +20,7 @@ import {
   setInternalComponentManager,
   setInternalHelperManager,
   setInternalModifierManager,
-  setModifierManager,
+  setModifierManager
 } from '@glimmer/manager';
 import { UNDEFINED_REFERENCE } from '@glimmer/reference';
 import { createUpdatableTag } from '@glimmer/validator';
diff --git a/packages/@glimmer/node/lib/node-dom-helper.ts b/packages/@glimmer/node/lib/node-dom-helper.ts
index 3ebf2487be..057124e902 100644
--- a/packages/@glimmer/node/lib/node-dom-helper.ts
+++ b/packages/@glimmer/node/lib/node-dom-helper.ts
@@ -1,5 +1,5 @@
 import type {
-  Bounds,
+  BlockBounds,
   Nullable,
   SimpleDocument,
   SimpleElement,
@@ -21,7 +21,7 @@ export default class NodeDOMTreeConstruction extends DOMTreeConstruction {
     parent: SimpleElement,
     reference: Nullable<SimpleNode>,
     html: string
-  ): Bounds {
+  ): BlockBounds {
     let raw = this.document.createRawHTMLSection!(html);
     parent.insertBefore(raw, reference);
     return new ConcreteBounds(parent, raw, raw);
diff --git a/packages/@glimmer/node/lib/serialize-builder.ts b/packages/@glimmer/node/lib/serialize-builder.ts
index a3e9cbbef2..481bd8b9ee 100644
--- a/packages/@glimmer/node/lib/serialize-builder.ts
+++ b/packages/@glimmer/node/lib/serialize-builder.ts
@@ -1,5 +1,6 @@
 import type {
-  Bounds,
+  BlockBounds,
+  Cursor,
   ElementBuilder,
   Environment,
   Maybe,
@@ -9,7 +10,8 @@ import type {
   SimpleNode,
   SimpleText,
 } from '@glimmer/interfaces';
-import { ConcreteBounds, NewElementBuilder, type RemoteLiveBlock } from '@glimmer/runtime';
+import type { RemoteLiveBlock } from '@glimmer/runtime';
+import { AbstractElementBuilder, ConcreteBounds, CursorImpl } from '@glimmer/runtime';
 
 const TEXT_NODE = 3;
 
@@ -27,9 +29,13 @@ function currentNode(
   }
 }
 
-class SerializeBuilder extends NewElementBuilder implements ElementBuilder {
+class SerializeBuilder extends AbstractElementBuilder implements ElementBuilder {
   private serializeBlockDepth = 0;
 
+  createCursor(element: SimpleElement, nextSibling: Maybe<SimpleNode> = null): Cursor {
+    return new CursorImpl(element, nextSibling);
+  }
+
   override __openBlock(): void {
     let { tagName } = this.element;
 
@@ -52,7 +58,7 @@ class SerializeBuilder extends NewElementBuilder implements ElementBuilder {
     }
   }
 
-  override __appendHTML(html: string): Bounds {
+  override __appendHTML(html: string): BlockBounds {
     let { tagName } = this.element;
 
     if (tagName === 'TITLE' || tagName === 'SCRIPT' || tagName === 'STYLE') {
@@ -87,7 +93,8 @@ class SerializeBuilder extends NewElementBuilder implements ElementBuilder {
     if (tagName === 'TITLE' || tagName === 'SCRIPT' || tagName === 'STYLE') {
       return super.__appendText(string);
     } else if (string === '') {
-      return this.__appendComment('% %') as any as SimpleText;
+      return this.__appendComment('% %') as unknown as SimpleText;
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
     } else if (current && current.nodeType === TEXT_NODE) {
       this.__appendComment('%|%');
     }
diff --git a/packages/@glimmer/node/package.json b/packages/@glimmer/node/package.json
index d705214184..cde517dbb7 100644
--- a/packages/@glimmer/node/package.json
+++ b/packages/@glimmer/node/package.json
@@ -9,7 +9,7 @@
     "@simple-dom/document": "^1.4.0"
   },
   "devDependencies": {
-    "@types/qunit": "^2.19.7",
+    "@types/qunit": "workspace:^",
     "@glimmer/compiler": "workspace:^",
     "@glimmer-workspace/build-support": "workspace:^"
   },
diff --git a/packages/@glimmer/opcode-compiler/index.ts b/packages/@glimmer/opcode-compiler/index.ts
index 9242b9e98b..3121ed578d 100644
--- a/packages/@glimmer/opcode-compiler/index.ts
+++ b/packages/@glimmer/opcode-compiler/index.ts
@@ -1,4 +1,4 @@
-export { compilable, compileStatements } from './lib/compilable-template';
+export { compilable, compileStatements, isCompilable } from './lib/compilable-template';
 export { debugCompiler } from './lib/compiler';
 export * from './lib/opcode-builder/context';
 export * from './lib/opcode-builder/delegate';
diff --git a/packages/@glimmer/opcode-compiler/lib/compilable-template.ts b/packages/@glimmer/opcode-compiler/lib/compilable-template.ts
index 28e759139e..81693fea01 100644
--- a/packages/@glimmer/opcode-compiler/lib/compilable-template.ts
+++ b/packages/@glimmer/opcode-compiler/lib/compilable-template.ts
@@ -1,13 +1,13 @@
 import type {
+  BlockMetadata,
   BlockSymbolTable,
   BuilderOp,
   CompilableBlock,
   CompilableProgram,
   CompilableTemplate,
-  CompileTimeCompilationContext,
-  ContainingMetadata,
   HandleResult,
   HighLevelOp,
+  JitContext,
   LayoutWithContext,
   Nullable,
   SerializedBlock,
@@ -15,25 +15,28 @@ import type {
   Statement,
   SymbolTable,
   WireFormat,
-} from "@glimmer/interfaces";
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
-import { EMPTY_ARRAY } from '@glimmer/util';
+} from '@glimmer/interfaces';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
+import { EMPTY_ARRAY, IS_COMPILABLE_TEMPLATE } from '@glimmer/util';
+
+import type { HighLevelStatementOp } from './syntax/compilers';
 
 import { debugCompiler } from './compiler';
 import { templateCompilationContext } from './opcode-builder/context';
 import { encodeOp } from './opcode-builder/encoder';
 import { meta } from './opcode-builder/helpers/shared';
-import type { HighLevelStatementOp } from './syntax/compilers';
+import { definePushOp } from './syntax/compilers';
 import { STATEMENTS } from './syntax/statements';
 
 export const PLACEHOLDER_HANDLE = -1;
 
 class CompilableTemplateImpl<S extends SymbolTable> implements CompilableTemplate<S> {
   compiled: Nullable<HandleResult> = null;
+  readonly [IS_COMPILABLE_TEMPLATE] = true;
 
   constructor(
     readonly statements: WireFormat.Statement[],
-    readonly meta: ContainingMetadata,
+    readonly meta: BlockMetadata,
     // Part of CompilableTemplate
     readonly symbolTable: S,
     // Used for debugging
@@ -41,19 +44,23 @@ class CompilableTemplateImpl<S extends SymbolTable> implements CompilableTemplat
   ) {}
 
   // Part of CompilableTemplate
-  compile(context: CompileTimeCompilationContext): HandleResult {
+  compile(context: JitContext): HandleResult {
     return maybeCompile(this, context);
   }
 }
 
+export function isCompilable(value: unknown): value is CompilableTemplate {
+  return !!(value && value instanceof CompilableTemplateImpl);
+}
+
 export function compilable(layout: LayoutWithContext, moduleName: string): CompilableProgram {
-  let [statements, symbols, hasEval] = layout.block;
+  let [statements, symbols, hasDebug] = layout.block;
   return new CompilableTemplateImpl(
     statements,
     meta(layout),
     {
       symbols,
-      hasEval,
+      hasDebug,
     },
     moduleName
   );
@@ -61,7 +68,7 @@ export function compilable(layout: LayoutWithContext, moduleName: string): Compi
 
 function maybeCompile(
   compilable: CompilableTemplateImpl<SymbolTable>,
-  context: CompileTimeCompilationContext
+  context: JitContext
 ): HandleResult {
   if (compilable.compiled !== null) return compilable.compiled;
 
@@ -77,8 +84,8 @@ function maybeCompile(
 
 export function compileStatements(
   statements: Statement[],
-  meta: ContainingMetadata,
-  syntaxContext: CompileTimeCompilationContext
+  meta: BlockMetadata,
+  syntaxContext: JitContext
 ): HandleResult {
   let sCompiler = STATEMENTS;
   let context = templateCompilationContext(syntaxContext, meta);
@@ -92,13 +99,15 @@ export function compileStatements(
     encodeOp(encoder, constants, resolver, meta, op as BuilderOp | HighLevelOp);
   }
 
+  const op = definePushOp(pushOp);
+
   for (const statement of statements) {
-    sCompiler.compile(pushOp, statement);
+    sCompiler.compile(op, statement);
   }
 
   let handle = context.encoder.commit(meta.size);
 
-  if (LOCAL_SHOULD_LOG) {
+  if (LOCAL_TRACE_LOGGING) {
     debugCompiler(context, handle);
   }
 
@@ -107,7 +116,7 @@ export function compileStatements(
 
 export function compilableBlock(
   block: SerializedInlineBlock | SerializedBlock,
-  containing: ContainingMetadata
+  containing: BlockMetadata
 ): CompilableBlock {
   return new CompilableTemplateImpl<BlockSymbolTable>(block[0], containing, {
     parameters: block[1] || (EMPTY_ARRAY as number[]),
diff --git a/packages/@glimmer/opcode-compiler/lib/compiler.ts b/packages/@glimmer/opcode-compiler/lib/compiler.ts
index 21c0985e18..656bd6636e 100644
--- a/packages/@glimmer/opcode-compiler/lib/compiler.ts
+++ b/packages/@glimmer/opcode-compiler/lib/compiler.ts
@@ -1,17 +1,17 @@
-import { debugSlice } from '@glimmer/debug';
 import type { HandleResult, TemplateCompilationContext } from "@glimmer/interfaces";
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
+import { logOpcodeSlice } from '@glimmer/debug';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { extractHandle } from '@glimmer/util';
 
 export let debugCompiler: (context: TemplateCompilationContext, handle: HandleResult) => void;
 
-if (LOCAL_SHOULD_LOG) {
+if (LOCAL_TRACE_LOGGING) {
   debugCompiler = (context: TemplateCompilationContext, result: HandleResult) => {
     let handle = extractHandle(result);
     let { heap } = context.program;
     let start = heap.getaddr(handle);
     let end = start + heap.sizeof(handle);
 
-    debugSlice(context, start, end);
+    logOpcodeSlice(context, start, end);
   };
 }
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/context.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/context.ts
index 9267d8a892..f4ee43054c 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/context.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/context.ts
@@ -1,11 +1,11 @@
 import type {
+  BlockMetadata,
   CompileTimeArtifacts,
-  CompileTimeCompilationContext,
   CompileTimeResolver,
-  ContainingMetadata,
   CreateRuntimeOp,
+  JitContext,
   TemplateCompilationContext,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 
 import { CompileTimeCompilationContextImpl } from '../program-context';
 import { EncoderImpl } from './encoder';
@@ -14,13 +14,13 @@ export function programCompilationContext(
   artifacts: CompileTimeArtifacts,
   resolver: CompileTimeResolver,
   createOp: CreateRuntimeOp
-): CompileTimeCompilationContext {
+): JitContext {
   return new CompileTimeCompilationContextImpl(artifacts, resolver, createOp);
 }
 
 export function templateCompilationContext(
-  program: CompileTimeCompilationContext,
-  meta: ContainingMetadata
+  program: JitContext,
+  meta: BlockMetadata
 ): TemplateCompilationContext {
   let encoder = new EncoderImpl(program.heap, meta, program.stdlib);
 
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts
index 9e929e8797..043f8e3f89 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts
@@ -1,11 +1,10 @@
-import { InstructionEncoderImpl } from '@glimmer/encoder';
 import type {
+  BlockMetadata,
   BuilderOp,
   BuilderOpcode,
   CompileTimeConstants,
   CompileTimeHeap,
   CompileTimeResolver,
-  ContainingMetadata,
   Dict,
   Encoder,
   EncoderError,
@@ -17,6 +16,7 @@ import type {
   SingleBuilderOperand,
   STDLib,
 } from '@glimmer/interfaces';
+import { InstructionEncoderImpl } from '@glimmer/encoder';
 import {
   assert,
   dict,
@@ -26,7 +26,7 @@ import {
   isPresentArray,
   Stack,
 } from '@glimmer/util';
-import { ARG_SHIFT, isMachineOp, MACHINE_MASK, MachineOp, Op, TYPE_SIZE } from '@glimmer/vm';
+import { ARG_SHIFT, isMachineOp, MACHINE_MASK, Op, TYPE_SIZE } from '@glimmer/vm';
 
 import { compilableBlock } from '../compilable-template';
 import {
@@ -69,7 +69,7 @@ export function encodeOp(
   encoder: Encoder,
   constants: CompileTimeConstants & ResolutionTimeConstants,
   resolver: CompileTimeResolver,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   op: BuilderOp | HighLevelOp
 ): void {
   if (isBuilderOpcode(op[0])) {
@@ -141,14 +141,14 @@ export function encodeOp(
 }
 
 export class EncoderImpl implements Encoder {
-  private labelsStack = new Stack<Labels>();
+  private labelsStack = Stack.empty<Labels>();
   private encoder: InstructionEncoder = new InstructionEncoderImpl([]);
   private errors: EncoderError[] = [];
   private handle: number;
 
   constructor(
     private heap: CompileTimeHeap,
-    private meta: ContainingMetadata,
+    private meta: BlockMetadata,
     private stdlib?: STDLib
   ) {
     this.handle = heap.malloc();
@@ -162,7 +162,7 @@ export class EncoderImpl implements Encoder {
   commit(size: number): HandleResult {
     let handle = this.handle;
 
-    this.heap.pushMachine(MachineOp.Return);
+    this.heap.pushOp(Op.Return);
     this.heap.finishMalloc(handle, size);
 
     if (isPresentArray(this.errors)) {
@@ -212,7 +212,7 @@ export class EncoderImpl implements Encoder {
             return encodeHandle(constants.value(this.meta.isStrictMode));
 
           case HighLevelOperands.DebugSymbols:
-            return encodeHandle(constants.array(this.meta.evalSymbols || EMPTY_STRING_ARRAY));
+            return encodeHandle(constants.array(this.meta.debugSymbols || EMPTY_STRING_ARRAY));
 
           case HighLevelOperands.Block:
             return encodeHandle(constants.value(compilableBlock(operand.value, this.meta)));
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/blocks.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/blocks.ts
index 54250a012a..b7409dc602 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/blocks.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/blocks.ts
@@ -1,7 +1,8 @@
-import type { Nullable, WireFormat } from "@glimmer/interfaces";
-import { $fp, MachineOp, Op } from '@glimmer/vm';
+import type { Nullable, WireFormat } from '@glimmer/interfaces';
+import { $fp, Op } from '@glimmer/vm';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
+
 import { blockOperand, symbolTableOperand } from '../operands';
 import { SimpleArgs } from './shared';
 import { PushPrimitive } from './vm';
@@ -23,7 +24,7 @@ export function YieldBlock(
   op(Op.CompileBlock);
   op(Op.InvokeYield);
   op(Op.PopScope);
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
 }
 
 /**
@@ -50,11 +51,11 @@ export function InvokeStaticBlock(
   op: PushStatementOp,
   block: WireFormat.SerializedInlineBlock
 ): void {
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   PushCompilable(op, block);
   op(Op.CompileBlock);
-  op(MachineOp.InvokeVirtual);
-  op(MachineOp.PopFrame);
+  op(Op.InvokeVirtual);
+  op(Op.PopFrame);
 }
 
 /**
@@ -78,7 +79,7 @@ export function InvokeStaticBlockWithStack(
     return;
   }
 
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
 
   if (count) {
     op(Op.ChildScope);
@@ -91,13 +92,13 @@ export function InvokeStaticBlockWithStack(
 
   PushCompilable(op, block);
   op(Op.CompileBlock);
-  op(MachineOp.InvokeVirtual);
+  op(Op.InvokeVirtual);
 
   if (count) {
     op(Op.PopScope);
   }
 
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
 }
 
 export function PushSymbolTable(op: PushExpressionOp, parameters: number[] | null): void {
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/components.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/components.ts
index 45a7adf04f..4968119327 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/components.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/components.ts
@@ -6,20 +6,14 @@ import type {
   NamedBlocks,
   Nullable,
   WireFormat,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
+import type { SavedRegister } from '@glimmer/vm';
 import { hasCapability } from '@glimmer/manager';
-import { EMPTY_STRING_ARRAY, reverse, unwrap } from '@glimmer/util';
-import {
-  $s0,
-  $s1,
-  $sp,
-  InternalComponentCapabilities,
-  MachineOp,
-  Op,
-  type SavedRegister,
-} from '@glimmer/vm';
+import { EMPTY_STRING_ARRAY, encodeBoolean, reverse, unwrap } from '@glimmer/util';
+import { $s0, $s1, $sp, InternalComponentCapabilities, Op } from '@glimmer/vm';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
+
 import { namedBlocks } from '../../utils';
 import { HighLevelBuilderOpcodes } from '../opcodes';
 import { isStrictMode, labelOperand, layoutOperand, symbolTableOperand } from '../operands';
@@ -119,31 +113,33 @@ export function InvokeDynamicComponent(
   Replayable(
     op,
 
-    () => {
-      expr(op, definition);
-      op(Op.Dup, $sp, 0);
-      return 2;
-    },
-
-    () => {
-      op(Op.JumpUnless, labelOperand('ELSE'));
-
-      if (curried) {
-        op(Op.ResolveCurriedComponent);
-      } else {
-        op(Op.ResolveDynamicComponent, isStrictMode());
-      }
-
-      op(Op.PushDynamicComponentInstance);
-      InvokeNonStaticComponent(op, {
-        capabilities: true,
-        elementBlock,
-        positional,
-        named,
-        atNames,
-        blocks,
-      });
-      op(HighLevelBuilderOpcodes.Label, 'ELSE');
+    {
+      args: () => {
+        expr(op, definition);
+        op(Op.Dup, $sp, 0);
+        return 2;
+      },
+
+      body: () => {
+        op(Op.JumpUnless, labelOperand('ELSE'));
+
+        if (curried) {
+          op(Op.ResolveCurriedComponent);
+        } else {
+          op(Op.ResolveDynamicComponent, isStrictMode());
+        }
+
+        op(Op.PushDynamicComponentInstance);
+        InvokeNonStaticComponent(op, {
+          capabilities: true,
+          elementBlock,
+          positional,
+          named,
+          atNames,
+          blocks,
+        });
+        op(HighLevelBuilderOpcodes.Label, 'ELSE');
+      },
     }
   );
 }
@@ -155,7 +151,7 @@ function InvokeStaticComponent(
   let { symbolTable } = layout;
 
   let bailOut =
-    symbolTable.hasEval || hasCapability(capabilities, InternalComponentCapabilities.prepareArgs);
+    symbolTable.hasDebug || hasCapability(capabilities, InternalComponentCapabilities.prepareArgs);
 
   if (bailOut) {
     InvokeNonStaticComponent(op, {
@@ -174,7 +170,7 @@ function InvokeStaticComponent(
   op(Op.Fetch, $s0);
   op(Op.Dup, $sp, 1);
   op(Op.Load, $s0);
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
 
   // Setup arguments
   let { symbols } = symbolTable;
@@ -273,13 +269,13 @@ function InvokeStaticComponent(
   }
 
   if (hasCapability(capabilities, InternalComponentCapabilities.createInstance)) {
-    op(Op.CreateComponent, (blocks.has('default') as any) | 0, $s0);
+    op(Op.CreateComponent, encodeBoolean(blocks.has('default')) | 0, $s0);
   }
 
   op(Op.RegisterComponentDestructor, $s0);
 
   if (hasCapability(capabilities, InternalComponentCapabilities.createArgs)) {
-    op(Op.GetComponentSelf, $s0);
+    op(Op.GetComponentSelf, $s0, null);
   } else {
     op(Op.GetComponentSelf, $s0, argNames);
   }
@@ -318,10 +314,10 @@ function InvokeStaticComponent(
 
   op(Op.Constant, layoutOperand(layout));
   op(Op.CompileBlock);
-  op(MachineOp.InvokeVirtual);
+  op(Op.InvokeVirtual);
   op(Op.DidRenderLayout, $s0);
 
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
   op(Op.PopScope);
 
   if (hasCapability(capabilities, InternalComponentCapabilities.dynamicScope)) {
@@ -348,7 +344,7 @@ export function InvokeNonStaticComponent(
   op(Op.Dup, $sp, 1);
   op(Op.Load, $s0);
 
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   CompileArgs(op, positional, named, blocks, atNames);
   op(Op.PrepareArgs, $s0);
 
@@ -405,7 +401,7 @@ export function invokePreparedComponent(
   op(Op.BeginComponentTransaction, $s0);
   op(Op.PushDynamicScope);
 
-  op(Op.CreateComponent, (hasBlock as any) | 0, $s0);
+  op(Op.CreateComponent, encodeBoolean(hasBlock), $s0);
 
   // this has to run after createComponent to allow
   // for late-bound layouts, but a caller is free
@@ -416,7 +412,7 @@ export function invokePreparedComponent(
   }
 
   op(Op.RegisterComponentDestructor, $s0);
-  op(Op.GetComponentSelf, $s0);
+  op(Op.GetComponentSelf, $s0, null);
 
   op(Op.VirtualRootScope, $s0);
   op(Op.SetVariable, 0);
@@ -428,7 +424,7 @@ export function invokePreparedComponent(
   op(Op.Pop, 1);
   op(Op.InvokeComponentLayout, $s0);
   op(Op.DidRenderLayout, $s0);
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
 
   op(Op.PopScope);
   op(Op.PopDynamicScope);
@@ -440,7 +436,7 @@ export function InvokeBareComponent(op: PushStatementOp): void {
   op(Op.Dup, $sp, 1);
   op(Op.Load, $s0);
 
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   op(Op.PushEmptyArgs);
   op(Op.PrepareArgs, $s0);
   invokePreparedComponent(op, false, false, true, () => {
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/conditional.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/conditional.ts
index 46b5b6876d..606e4787ce 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/conditional.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/conditional.ts
@@ -1,7 +1,8 @@
 import { unwrap } from '@glimmer/util';
-import { MachineOp, Op } from '@glimmer/vm';
+import { Op } from '@glimmer/vm';
 
 import type { PushStatementOp } from '../../syntax/compilers';
+
 import { HighLevelBuilderOpcodes } from '../opcodes';
 import { labelOperand } from '../operands';
 
@@ -25,7 +26,7 @@ export function SwitchCases(
   matcher(when);
 
   // Emit the opcodes for the switch
-  op(Op.Enter, 1);
+  op(Op.Enter, 1, false);
   bootstrap();
   op(HighLevelBuilderOpcodes.StartLabels);
 
@@ -47,7 +48,7 @@ export function SwitchCases(
     // The first match is special: it is placed directly before the END
     // label, so no additional jump is needed at the end of it.
     if (i !== 0) {
-      op(MachineOp.Jump, labelOperand('END'));
+      op(Op.Jump, labelOperand('END'));
     }
   }
 
@@ -117,16 +118,19 @@ export function SwitchCases(
  * encountered, the program jumps to -1 rather than the END label,
  * and the PopFrame opcode is not needed.
  */
-export function Replayable(op: PushStatementOp, args: () => number, body: () => void): void {
+export function Replayable(
+  op: PushStatementOp,
+  { begin = false, args, body }: { begin?: boolean; args: () => number; body: () => void }
+): void {
   // Start a new label frame, to give END and RETURN
   // a unique meaning.
 
   op(HighLevelBuilderOpcodes.StartLabels);
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
 
   // 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'));
+  op(Op.ReturnTo, labelOperand('ENDINITIAL'));
 
   // Push the arguments onto the stack. The args() function
   // tells us how many stack elements to retain for re-execution
@@ -143,7 +147,7 @@ export function Replayable(op: PushStatementOp, args: () => number, body: () =>
   // 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(Op.Enter, count, begin);
 
   // Evaluate the body of the block. The body of the block may
   // return, which will jump execution to END during initial
@@ -161,12 +165,12 @@ export function Replayable(op: PushStatementOp, args: () => number, body: () =>
   // 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(Op.Return);
 
   // Cleanup code for the block. Runs on initial execution
   // but not on updating.
   op(HighLevelBuilderOpcodes.Label, 'ENDINITIAL');
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
   op(HighLevelBuilderOpcodes.StopLabels);
 }
 
@@ -191,23 +195,26 @@ export function ReplayableIf(
   ifTrue: () => void,
   ifFalse?: () => void
 ): void {
-  return Replayable(op, args, () => {
-    // If the conditional is false, jump to the ELSE label.
-    op(Op.JumpUnless, 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');
-
-    // 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
-    // has no other behavior.
-    if (ifFalse !== undefined) {
-      ifFalse();
-    }
+  return Replayable(op, {
+    args,
+    body: () => {
+      // If the conditional is false, jump to the ELSE label.
+      op(Op.JumpUnless, 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(Op.Jump, labelOperand('FINALLY'));
+      op(HighLevelBuilderOpcodes.Label, '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
+      // has no other behavior.
+      if (ifFalse !== undefined) {
+        ifFalse();
+      }
+    },
   });
 }
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/debug.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/debug.ts
new file mode 100644
index 0000000000..23d065deaa
--- /dev/null
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/debug.ts
@@ -0,0 +1,9 @@
+import type { BuilderOp } from '@glimmer/interfaces';
+
+import type { PushStatementOp } from '../../syntax/compilers';
+
+export function Debug(op: PushStatementOp, ...perform: BuilderOp): void {
+  if (import.meta.env.DEV) {
+    op(...perform);
+  }
+}
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts
index 85f01778a2..4fd6a56c5d 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts
@@ -2,6 +2,7 @@ import type { WireFormat } from "@glimmer/interfaces";
 import { Op } from '@glimmer/vm';
 
 import type { PushExpressionOp } from '../../syntax/compilers';
+
 import { EXPRESSIONS } from '../../syntax/expressions';
 import { PushPrimitive } from './vm';
 
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/resolution.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/resolution.ts
index d5f3dd8211..cf745d2a8c 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/resolution.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/resolution.ts
@@ -1,7 +1,7 @@
 import type {
+  BlockMetadata,
   CompileTimeConstants,
   CompileTimeResolver,
-  ContainingMetadata,
   Expressions,
   Owner,
   ResolutionTimeConstants,
@@ -62,12 +62,12 @@ export const isGetFreeOptionalComponentOrHelper = makeResolutionTypeVerifier(
   SexpOpcodes.GetFreeAsComponentOrHelperHeadOrThisFallback
 );
 
-interface ResolvedContainingMetadata extends ContainingMetadata {
+interface ResolvedContainingMetadata extends BlockMetadata {
   owner: Owner;
   upvars: string[];
 }
 
-function assertResolverInvariants(meta: ContainingMetadata): ResolvedContainingMetadata {
+function assertResolverInvariants(meta: BlockMetadata): ResolvedContainingMetadata {
   if (import.meta.env.DEV) {
     if (!meta.upvars) {
       throw new Error(
@@ -93,7 +93,7 @@ function assertResolverInvariants(meta: ContainingMetadata): ResolvedContainingM
 export function resolveComponent(
   resolver: CompileTimeResolver,
   constants: CompileTimeConstants & ResolutionTimeConstants,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   [, expr, then]: ResolveComponentOp
 ): void {
   assert(isGetFreeComponent(expr), 'Attempted to resolve a component with incorrect opcode');
@@ -143,7 +143,7 @@ export function resolveComponent(
 export function resolveHelper(
   resolver: CompileTimeResolver,
   constants: CompileTimeConstants & ResolutionTimeConstants,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   [, expr, then]: ResolveHelperOp
 ): void {
   assert(isGetFreeHelper(expr), 'Attempted to resolve a helper with incorrect opcode');
@@ -185,7 +185,7 @@ export function resolveHelper(
 export function resolveModifier(
   resolver: CompileTimeResolver,
   constants: CompileTimeConstants & ResolutionTimeConstants,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   [, expr, then]: ResolveModifierOp
 ): void {
   assert(isGetFreeModifier(expr), 'Attempted to resolve a modifier with incorrect opcode');
@@ -232,7 +232,7 @@ export function resolveModifier(
 export function resolveComponentOrHelper(
   resolver: CompileTimeResolver,
   constants: CompileTimeConstants & ResolutionTimeConstants,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   [, expr, { ifComponent, ifHelper }]: ResolveComponentOrHelperOp
 ): void {
   assert(
@@ -308,7 +308,7 @@ export function resolveComponentOrHelper(
 export function resolveOptionalHelper(
   resolver: CompileTimeResolver,
   constants: CompileTimeConstants & ResolutionTimeConstants,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   [, expr, { ifHelper }]: ResolveOptionalHelperOp
 ): void {
   assert(
@@ -331,7 +331,7 @@ export function resolveOptionalHelper(
 export function resolveOptionalComponentOrHelper(
   resolver: CompileTimeResolver,
   constants: CompileTimeConstants & ResolutionTimeConstants,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   [, expr, { ifComponent, ifHelper, ifValue }]: ResolveOptionalComponentOrHelperOp
 ): void {
   assert(
@@ -401,7 +401,7 @@ export function resolveOptionalComponentOrHelper(
 function lookupBuiltInHelper(
   expr: Expressions.GetStrictFree,
   resolver: CompileTimeResolver,
-  meta: ContainingMetadata,
+  meta: BlockMetadata,
   constants: ResolutionTimeConstants,
   type: string
 ): number {
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts
index a1ff61f13e..d15d562e06 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts
@@ -1,14 +1,15 @@
 import type {
-  ContainingMetadata,
+  BlockMetadata,
   LayoutWithContext,
   NamedBlocks,
   Nullable,
   WireFormat,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 import { EMPTY_ARRAY, EMPTY_STRING_ARRAY } from '@glimmer/util';
 import { Op } from '@glimmer/vm';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
+
 import { PushYieldableBlock } from './blocks';
 import { expr } from './expr';
 
@@ -104,11 +105,11 @@ export function CompilePositional(
   return positional.length;
 }
 
-export function meta(layout: LayoutWithContext): ContainingMetadata {
+export function meta(layout: LayoutWithContext): BlockMetadata {
   let [, symbols, , upvars] = layout.block;
 
   return {
-    evalSymbols: evalSymbols(layout),
+    debugSymbols: debugSymbols(layout),
     upvars: upvars,
     scopeValues: layout.scope?.() ?? null,
     isStrictMode: layout.isStrictMode,
@@ -118,9 +119,10 @@ export function meta(layout: LayoutWithContext): ContainingMetadata {
   };
 }
 
-export function evalSymbols(layout: LayoutWithContext): Nullable<string[]> {
+export function debugSymbols(layout: LayoutWithContext): Nullable<string[]> {
   let { block } = layout;
-  let [, symbols, hasEval] = block;
+  let [, symbols, hasDebug] = block;
 
-  return hasEval ? symbols : null;
+  // include debug symbols in dev mode, or if the template using `debugger`.
+  return import.meta.env.DEV || hasDebug ? symbols : null;
 }
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts
index 7bd71c20a9..11cc8ab443 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts
@@ -1,12 +1,19 @@
-import type {
-  BuilderOp,
-  CompileTimeCompilationContext,
-  ContainingMetadata,
-  HighLevelOp,
-} from "@glimmer/interfaces";
-import { $s0, ContentType, MachineOp, Op } from '@glimmer/vm';
-
-import type { HighLevelStatementOp, PushStatementOp } from '../../syntax/compilers';
+import type { BlockMetadata, BuilderOp, HighLevelOp, JitContext } from '@glimmer/interfaces';
+import { $s0, Op } from '@glimmer/vm';
+import {
+  COMPONENT_CONTENT,
+  FRAGMENT_CONTENT,
+  HELPER_CONTENT,
+  NODE_CONTENT,
+  SAFE_STRING_CONTENT,
+  STRING_CONTENT,
+} from '@glimmer/vm/lib/content';
+
+import type {HighLevelStatementOp, PushStatementOp} from '../../syntax/compilers';
+
+import {
+  definePushOp
+} from '../../syntax/compilers';
 import { encodeOp, EncoderImpl } from '../encoder';
 import { StdLib } from '../stdlib';
 import { InvokeBareComponent, invokePreparedComponent } from './components';
@@ -35,7 +42,7 @@ export function StdAppend(
     op,
     () => op(Op.ContentType),
     (when) => {
-      when(ContentType.String, () => {
+      when(STRING_CONTENT, () => {
         if (trusting) {
           op(Op.AssertSame);
           op(Op.AppendHTML);
@@ -45,40 +52,40 @@ export function StdAppend(
       });
 
       if (typeof nonDynamicAppend === 'number') {
-        when(ContentType.Component, () => {
+        when(COMPONENT_CONTENT, () => {
           op(Op.ResolveCurriedComponent);
           op(Op.PushDynamicComponentInstance);
           InvokeBareComponent(op);
         });
 
-        when(ContentType.Helper, () => {
+        when(HELPER_CONTENT, () => {
           CallDynamic(op, null, null, () => {
-            op(MachineOp.InvokeStatic, nonDynamicAppend);
+            op(Op.InvokeStatic, nonDynamicAppend);
           });
         });
       } else {
         // 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, () => {
+        when(COMPONENT_CONTENT, () => {
           op(Op.AppendText);
         });
 
-        when(ContentType.Helper, () => {
+        when(HELPER_CONTENT, () => {
           op(Op.AppendText);
         });
       }
 
-      when(ContentType.SafeString, () => {
+      when(SAFE_STRING_CONTENT, () => {
         op(Op.AssertSame);
         op(Op.AppendSafeHTML);
       });
 
-      when(ContentType.Fragment, () => {
+      when(FRAGMENT_CONTENT, () => {
         op(Op.AssertSame);
         op(Op.AppendDocumentFragment);
       });
 
-      when(ContentType.Node, () => {
+      when(NODE_CONTENT, () => {
         op(Op.AssertSame);
         op(Op.AppendNode);
       });
@@ -86,7 +93,7 @@ export function StdAppend(
   );
 }
 
-export function compileStd(context: CompileTimeCompilationContext): StdLib {
+export function compileStd(context: JitContext): StdLib {
   let mainHandle = build(context, (op) => main(op));
   let trustingGuardedNonDynamicAppend = build(context, (op) => StdAppend(op, true, null));
   let cautiousGuardedNonDynamicAppend = build(context, (op) => StdAppend(op, false, null));
@@ -107,8 +114,8 @@ export function compileStd(context: CompileTimeCompilationContext): StdLib {
   );
 }
 
-export const STDLIB_META: ContainingMetadata = {
-  evalSymbols: null,
+export const STDLIB_META: BlockMetadata = {
+  debugSymbols: null,
   upvars: null,
   moduleName: 'stdlib',
 
@@ -119,10 +126,7 @@ export const STDLIB_META: ContainingMetadata = {
   size: 0,
 };
 
-function build(
-  program: CompileTimeCompilationContext,
-  builder: (op: PushStatementOp) => void
-): number {
+function build(program: JitContext, builder: (op: PushStatementOp) => void): number {
   let { constants, heap, resolver } = program;
   let encoder = new EncoderImpl(heap, STDLIB_META);
 
@@ -130,7 +134,7 @@ function build(
     encodeOp(encoder, constants, resolver, STDLIB_META, op as BuilderOp | HighLevelOp);
   }
 
-  builder(pushOp);
+  builder(definePushOp(pushOp));
 
   let result = encoder.commit(0);
 
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/vm.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/vm.ts
index af25c8c9b0..3ba8a2d6cc 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/vm.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/vm.ts
@@ -1,8 +1,9 @@
-import type { CurriedType, NonSmallIntOperand, Nullable, WireFormat } from "@glimmer/interfaces";
+import type { CurriedType, NonSmallIntOperand, Nullable, WireFormat } from '@glimmer/interfaces';
 import { encodeImmediate, isSmallInt } from '@glimmer/util';
-import { $fp, $v0, MachineOp, Op } from '@glimmer/vm';
+import { $fp, $v0, Op } from '@glimmer/vm';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
+
 import { isStrictMode, nonSmallIntOperand } from '../operands';
 import { expr } from './expr';
 import { SimpleArgs } from './shared';
@@ -53,10 +54,10 @@ export function Call(
   positional: WireFormat.Core.Params,
   named: WireFormat.Core.Hash
 ): void {
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   SimpleArgs(op, positional, named, false);
   op(Op.Helper, handle);
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
   op(Op.Fetch, $v0);
 }
 
@@ -73,17 +74,17 @@ export function CallDynamic(
   named: WireFormat.Core.Hash,
   append?: () => void
 ): void {
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   SimpleArgs(op, positional, named, false);
   op(Op.Dup, $fp, 1);
   op(Op.DynamicHelper);
   if (append) {
     op(Op.Fetch, $v0);
     append();
-    op(MachineOp.PopFrame);
+    op(Op.PopFrame);
     op(Op.Pop, 1);
   } else {
-    op(MachineOp.PopFrame);
+    op(Op.PopFrame);
     op(Op.Pop, 1);
     op(Op.Fetch, $v0);
   }
@@ -111,11 +112,11 @@ export function Curry(
   positional: WireFormat.Core.Params,
   named: WireFormat.Core.Hash
 ): void {
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   SimpleArgs(op, positional, named, false);
   op(Op.CaptureArgs);
   expr(op, definition);
   op(Op.Curry, type, isStrictMode());
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
   op(Op.Fetch, $v0);
 }
diff --git a/packages/@glimmer/opcode-compiler/lib/program-context.ts b/packages/@glimmer/opcode-compiler/lib/program-context.ts
index 1fe5748287..0f71cd2235 100644
--- a/packages/@glimmer/opcode-compiler/lib/program-context.ts
+++ b/packages/@glimmer/opcode-compiler/lib/program-context.ts
@@ -1,18 +1,19 @@
 import type {
   CompileTimeArtifacts,
-  CompileTimeCompilationContext,
   CompileTimeConstants,
   CompileTimeHeap,
   CompileTimeResolver,
   CreateRuntimeOp,
+  DebugConstants,
+  JitContext,
   ResolutionTimeConstants,
   STDLib,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 
 import { compileStd } from './opcode-builder/helpers/stdlib';
 
-export class CompileTimeCompilationContextImpl implements CompileTimeCompilationContext {
-  readonly constants: CompileTimeConstants & ResolutionTimeConstants;
+export class CompileTimeCompilationContextImpl implements JitContext {
+  readonly constants: CompileTimeConstants & ResolutionTimeConstants & DebugConstants;
   readonly heap: CompileTimeHeap;
   readonly stdlib: STDLib;
 
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts b/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts
index 704e442042..9ef0f5854d 100644
--- a/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts
@@ -1,37 +1,75 @@
-import type { BuilderOp, HighLevelOp, SexpOpcode, SexpOpcodeMap } from "@glimmer/interfaces";
+import type {
+  BuilderOp,
+  HighLevelOp,
+  LabelOperand,
+  SexpOpcode,
+  SexpOpcodeMap,
+} from '@glimmer/interfaces';
 import { assert, unwrap } from '@glimmer/util';
 
-export type PushExpressionOp = (...op: BuilderOp | HighLevelOp) => void;
+import { HighLevelBuilderOpcodes } from '../opcode-builder/opcodes';
+import { labelOperand } from '../opcode-builder/operands';
+
+export interface PushOp<Op extends unknown[]> {
+  (...op: Op): void;
+  (...op: HighLevelOp): void;
+  label: (name: string) => void;
+  target: (name: string) => LabelOperand;
+  labels: (block: () => void) => void;
+}
+
+export type PushExpressionOp = PushOp<BuilderOp | HighLevelOp>;
+export type PushStatementOp = PushOp<BuilderOp | HighLevelOp | HighLevelStatementOp>;
+
+export function definePushOp<Op extends unknown[]>(
+  fn: ((...op: Op) => void) & ((...op: HighLevelOp) => void)
+): PushOp<Op> {
+  function op(...op: Parameters<typeof fn>): void {
+    fn(...op);
+  }
+
+  op.label = (name: string) => {
+    op(HighLevelBuilderOpcodes.Label, name);
+  };
+
+  op.labels = (block: () => void) => {
+    op(HighLevelBuilderOpcodes.StartLabels);
+    block();
+    op(HighLevelBuilderOpcodes.StopLabels);
+  };
+
+  op.target = (target: string) => labelOperand(target);
+
+  return op as PushOp<Op>;
+}
 
 declare const STATEMENT: unique symbol;
 
 export type HighLevelStatementOp = [{ [STATEMENT]: undefined }];
 
-export type PushStatementOp = (...op: BuilderOp | HighLevelOp | HighLevelStatementOp) => void;
-
 export type CompilerFunction<PushOp extends PushExpressionOp, TSexp> = (
   op: PushOp,
   sexp: TSexp
 ) => void;
 
 export class Compilers<PushOp extends PushExpressionOp, TSexpOpcodes extends SexpOpcode> {
-  private names: {
+  readonly #names: {
     [name: number]: number;
   } = {};
 
-  private funcs: CompilerFunction<PushOp, any>[] = [];
+  readonly #funcs: CompilerFunction<PushOp, any>[] = [];
 
   add<TSexpOpcode extends TSexpOpcodes>(
     name: TSexpOpcode,
     func: CompilerFunction<PushOp, SexpOpcodeMap[TSexpOpcode]>
   ): void {
-    this.names[name] = this.funcs.push(func) - 1;
+    this.#names[name] = this.#funcs.push(func) - 1;
   }
 
   compile(op: PushOp, sexp: SexpOpcodeMap[TSexpOpcodes]): void {
     let name = sexp[0];
-    let index = unwrap(this.names[name]);
-    let func = this.funcs[index];
+    let index = unwrap(this.#names[name]);
+    let func = this.#funcs[index];
     assert(!!func, `expected an implementation for ${sexp[0]}`);
 
     func(op, sexp);
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/content.ts b/packages/@glimmer/opcode-compiler/lib/syntax/content.ts
new file mode 100644
index 0000000000..60ea7c94cc
--- /dev/null
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/content.ts
@@ -0,0 +1,327 @@
+import type { CompileTimeComponent, WireFormat } from '@glimmer/interfaces';
+import { $fp, $sp, COMPONENT_CONTENT, HELPER_CONTENT, Op } from '@glimmer/vm';
+import { SexpOpcodes } from '@glimmer/wire-format';
+
+import type { DefineStatement } from './statements';
+
+import {
+  InvokeStaticBlock,
+  InvokeStaticBlockWithStack,
+  YieldBlock,
+} from '../opcode-builder/helpers/blocks';
+import {
+  InvokeComponent,
+  InvokeDynamicComponent,
+  InvokeNonStaticComponent,
+} from '../opcode-builder/helpers/components';
+import { Replayable, ReplayableIf, SwitchCases } from '../opcode-builder/helpers/conditional';
+import { expr } from '../opcode-builder/helpers/expr';
+import {
+  isGetFreeComponent,
+  isGetFreeComponentOrHelper,
+  isGetFreeOptionalComponentOrHelper,
+} from '../opcode-builder/helpers/resolution';
+import { CompilePositional } from '../opcode-builder/helpers/shared';
+import {
+  Call,
+  CallDynamic,
+  DynamicScope,
+  PushPrimitiveReference,
+} from '../opcode-builder/helpers/vm';
+import { HighLevelBuilderOpcodes, HighLevelResolutionOpcodes } from '../opcode-builder/opcodes';
+import { debugSymbolsOperand, labelOperand, stdlibOperand } from '../opcode-builder/operands';
+import { namedBlocks } from '../utils';
+
+export function defineContent(statements: DefineStatement) {
+  statements.add(SexpOpcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, params));
+
+  statements.add(SexpOpcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null));
+
+  statements.add(SexpOpcodes.Debugger, (op, [, debugInfo]) =>
+    op(Op.Debugger, debugSymbolsOperand(), debugInfo)
+  );
+
+  statements.add(SexpOpcodes.Append, (op, [, value]) => {
+    // Special case for static values
+    if (!Array.isArray(value)) {
+      op(Op.Text, value === null || value === undefined ? '' : String(value));
+    } else if (isGetFreeOptionalComponentOrHelper(value)) {
+      op(HighLevelResolutionOpcodes.OptionalComponentOrHelper, value, {
+        ifComponent(component: CompileTimeComponent) {
+          InvokeComponent(op, component, null, null, null, null);
+        },
+
+        ifHelper(handle: number) {
+          op(Op.PushFrame);
+          Call(op, handle, null, null);
+          op(Op.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
+          op(Op.PopFrame);
+        },
+
+        ifValue(handle: number) {
+          op(Op.PushFrame);
+          op(Op.ConstantReference, handle);
+          op(Op.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
+          op(Op.PopFrame);
+        },
+      });
+    } else if (value[0] === SexpOpcodes.Call) {
+      let [, expression, positional, named] = value;
+
+      if (isGetFreeComponentOrHelper(expression)) {
+        op(HighLevelResolutionOpcodes.ComponentOrHelper, expression, {
+          ifComponent(component: CompileTimeComponent) {
+            InvokeComponent(op, component, null, positional, hashToArgs(named), null);
+          },
+          ifHelper(handle: number) {
+            op(Op.PushFrame);
+            Call(op, handle, positional, named);
+            op(Op.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
+            op(Op.PopFrame);
+          },
+        });
+      } else {
+        SwitchCases(
+          op,
+          () => {
+            expr(op, expression);
+            op(Op.DynamicContentType);
+          },
+          (when) => {
+            when(COMPONENT_CONTENT, () => {
+              op(Op.ResolveCurriedComponent);
+              op(Op.PushDynamicComponentInstance);
+              InvokeNonStaticComponent(op, {
+                capabilities: true,
+                elementBlock: null,
+                positional,
+                named,
+                atNames: false,
+                blocks: namedBlocks(null),
+              });
+            });
+
+            when(HELPER_CONTENT, () => {
+              CallDynamic(op, positional, named, () => {
+                op(Op.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
+              });
+            });
+          }
+        );
+      }
+    } else {
+      op(Op.PushFrame);
+      expr(op, value);
+      op(Op.InvokeStatic, stdlibOperand('cautious-append'));
+      op(Op.PopFrame);
+    }
+  });
+
+  statements.add(SexpOpcodes.TrustingAppend, (op, [, value]) => {
+    if (!Array.isArray(value)) {
+      op(Op.Text, value === null || value === undefined ? '' : String(value));
+    } else {
+      op(Op.PushFrame);
+      expr(op, value);
+      op(Op.InvokeStatic, stdlibOperand('trusting-append'));
+      op(Op.PopFrame);
+    }
+  });
+
+  statements.add(SexpOpcodes.Block, (op, [, expr, positional, named, blocks]) => {
+    if (isGetFreeComponent(expr)) {
+      op(HighLevelResolutionOpcodes.Component, expr, (component: CompileTimeComponent) => {
+        InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
+      });
+    } else {
+      InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
+    }
+  });
+
+  statements.add(SexpOpcodes.InElement, (op, [, block, guid, destination, insertBefore]) => {
+    ReplayableIf(
+      op,
+
+      () => {
+        expr(op, guid);
+
+        if (insertBefore === undefined) {
+          PushPrimitiveReference(op, undefined);
+        } else {
+          expr(op, insertBefore);
+        }
+
+        expr(op, destination);
+        op(Op.Dup, $sp, 0);
+
+        return 4;
+      },
+
+      () => {
+        op(Op.PushRemoteElement);
+        InvokeStaticBlock(op, block);
+        op(Op.PopRemoteElement);
+      }
+    );
+  });
+
+  statements.add(SexpOpcodes.HandleError, (op, [, handler, block, _inverse]) => {
+    op.labels(() => {
+      Replayable(op, {
+        begin: true,
+        args: () => {
+          expr(op, handler);
+          op(Op.PushBegin, op.target('CATCH'));
+
+          return 2;
+        },
+        body: () => {
+          op(Op.AssertSame);
+
+          op(Op.Begin);
+          InvokeStaticBlock(op, block);
+          op(Op.Finally);
+          op(Op.Jump, op.target('FINALLY'));
+          op.label('CATCH');
+          op.label('FINALLY');
+        },
+      });
+      // ReplayableIf(
+      //   op,
+      //   () => {
+      //     PushPrimitive(op, true);
+      //     op(Op.PrimitiveReference);
+      //     return 1;
+      //   },
+      //   () => {
+      //     InvokeStaticBlock(op, block);
+      //     op(Op.PopTryFrame);
+      //     // Jump over the catch block
+      //     op(Op.Jump, op.target('FINALLY'));
+      //   }
+      // );
+    });
+  });
+
+  statements.add(SexpOpcodes.If, (op, [, condition, block, inverse]) =>
+    ReplayableIf(
+      op,
+      () => {
+        expr(op, condition);
+        op(Op.ToBoolean);
+
+        return 1;
+      },
+
+      () => {
+        InvokeStaticBlock(op, block);
+      },
+
+      inverse
+        ? () => {
+            InvokeStaticBlock(op, inverse);
+          }
+        : undefined
+    )
+  );
+
+  statements.add(SexpOpcodes.Each, (op, [, value, key, block, inverse]) =>
+    Replayable(
+      op,
+
+      {
+        args: () => {
+          if (key) {
+            expr(op, key);
+          } else {
+            PushPrimitiveReference(op, null);
+          }
+
+          expr(op, value);
+
+          return 2;
+        },
+
+        body: () => {
+          op(Op.EnterList, labelOperand('BODY'), labelOperand('ELSE'));
+          op(Op.PushFrame);
+          op(Op.Dup, $fp, 1);
+          op(Op.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(Op.Jump, labelOperand('FINALLY'));
+          op(HighLevelBuilderOpcodes.Label, 'BREAK');
+          op(Op.PopFrame);
+          op(Op.ExitList);
+          op(Op.Jump, labelOperand('FINALLY'));
+          op(HighLevelBuilderOpcodes.Label, 'ELSE');
+
+          if (inverse) {
+            InvokeStaticBlock(op, inverse);
+          }
+        },
+      }
+    )
+  );
+
+  statements.add(SexpOpcodes.With, (op, [, value, block, inverse]) => {
+    ReplayableIf(
+      op,
+
+      () => {
+        expr(op, value);
+        op(Op.Dup, $sp, 0);
+        op(Op.ToBoolean);
+
+        return 2;
+      },
+
+      () => {
+        InvokeStaticBlockWithStack(op, block, 1);
+      },
+
+      () => {
+        if (inverse) {
+          InvokeStaticBlock(op, inverse);
+        }
+      }
+    );
+  });
+
+  statements.add(SexpOpcodes.Let, (op, [, positional, block]) => {
+    let count = CompilePositional(op, positional);
+    InvokeStaticBlockWithStack(op, block, count);
+  });
+
+  statements.add(SexpOpcodes.WithDynamicVars, (op, [, named, block]) => {
+    if (named) {
+      let [names, expressions] = named;
+
+      CompilePositional(op, expressions);
+      DynamicScope(op, names, () => {
+        InvokeStaticBlock(op, block);
+      });
+    } else {
+      InvokeStaticBlock(op, block);
+    }
+  });
+
+  statements.add(SexpOpcodes.InvokeComponent, (op, [, expr, positional, named, blocks]) => {
+    if (isGetFreeComponent(expr)) {
+      op(HighLevelResolutionOpcodes.Component, expr, (component: CompileTimeComponent) => {
+        InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
+      });
+    } else {
+      InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
+    }
+  });
+}
+
+function hashToArgs(hash: WireFormat.Core.Hash | null): WireFormat.Core.Hash | null {
+  if (hash === null) return null;
+  let names = hash[0].map((key) => `@${key}`);
+  return [names as [string, ...string[]], hash[1]];
+}
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/dom.ts b/packages/@glimmer/opcode-compiler/lib/syntax/dom.ts
new file mode 100644
index 0000000000..03235bf0bf
--- /dev/null
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/dom.ts
@@ -0,0 +1,104 @@
+import type {
+  CompileTimeComponent,
+  StatementSexpOpcode,
+  WellKnownAttrName,
+  WellKnownTagName,
+} from '@glimmer/interfaces';
+import { $fp, Op } from '@glimmer/vm';
+import { SexpOpcodes } from '@glimmer/wire-format';
+
+import type { Compilers, PushStatementOp } from './compilers';
+
+import { InvokeComponent, InvokeDynamicComponent } from '../opcode-builder/helpers/components';
+import { expr } from '../opcode-builder/helpers/expr';
+import { isGetFreeComponent, isGetFreeModifier } from '../opcode-builder/helpers/resolution';
+import { SimpleArgs } from '../opcode-builder/helpers/shared';
+import { HighLevelResolutionOpcodes } from '../opcode-builder/opcodes';
+
+const INFLATE_ATTR_TABLE: {
+  [I in WellKnownAttrName]: string;
+} = ['class', 'id', 'value', 'name', 'type', 'style', 'href'];
+const INFLATE_TAG_TABLE: {
+  [I in WellKnownTagName]: string;
+} = ['div', 'span', 'p', 'a'];
+
+export function inflateTagName(tagName: string | WellKnownTagName): string {
+  return typeof tagName === 'string' ? tagName : INFLATE_TAG_TABLE[tagName];
+}
+
+export function inflateAttrName(attrName: string | WellKnownAttrName): string {
+  return typeof attrName === 'string' ? attrName : INFLATE_ATTR_TABLE[attrName];
+}
+
+export function defineDOM(statements: Compilers<PushStatementOp, StatementSexpOpcode>) {
+  statements.add(SexpOpcodes.Comment, (op, sexp) => op(Op.Comment, sexp[1]));
+  statements.add(SexpOpcodes.CloseElement, (op) => op(Op.CloseElement));
+  statements.add(SexpOpcodes.FlushElement, (op) => op(Op.FlushElement));
+
+  statements.add(SexpOpcodes.Modifier, (op, [, expression, positional, named]) => {
+    if (isGetFreeModifier(expression)) {
+      op(HighLevelResolutionOpcodes.Modifier, expression, (handle: number) => {
+        op(Op.PushFrame);
+        SimpleArgs(op, positional, named, false);
+        op(Op.Modifier, handle);
+        op(Op.PopFrame);
+      });
+    } else {
+      expr(op, expression);
+      op(Op.PushFrame);
+      SimpleArgs(op, positional, named, false);
+      op(Op.Dup, $fp, 1);
+      op(Op.DynamicModifier);
+      op(Op.PopFrame);
+    }
+  });
+
+  statements.add(SexpOpcodes.StaticAttr, (op, [, name, value, namespace]) => {
+    op(Op.StaticAttr, inflateAttrName(name), value as string, namespace ?? null);
+  });
+
+  statements.add(SexpOpcodes.StaticComponentAttr, (op, [, name, value, namespace]) => {
+    op(Op.StaticComponentAttr, inflateAttrName(name), value as string, namespace ?? null);
+  });
+
+  statements.add(SexpOpcodes.DynamicAttr, (op, [, name, value, namespace]) => {
+    expr(op, value);
+    op(Op.DynamicAttr, inflateAttrName(name), false, namespace ?? null);
+  });
+
+  statements.add(SexpOpcodes.TrustingDynamicAttr, (op, [, name, value, namespace]) => {
+    expr(op, value);
+    op(Op.DynamicAttr, inflateAttrName(name), true, namespace ?? null);
+  });
+
+  statements.add(SexpOpcodes.ComponentAttr, (op, [, name, value, namespace]) => {
+    expr(op, value);
+    op(Op.ComponentAttr, inflateAttrName(name), false, namespace ?? null);
+  });
+
+  statements.add(SexpOpcodes.TrustingComponentAttr, (op, [, name, value, namespace]) => {
+    expr(op, value);
+    op(Op.ComponentAttr, inflateAttrName(name), true, namespace ?? null);
+  });
+
+  statements.add(SexpOpcodes.OpenElement, (op, [, tag]) => {
+    op(Op.OpenElement, inflateTagName(tag));
+  });
+
+  statements.add(SexpOpcodes.OpenElementWithSplat, (op, [, tag]) => {
+    op(Op.PutComponentOperations);
+    op(Op.OpenElement, inflateTagName(tag));
+  });
+
+  statements.add(SexpOpcodes.Component, (op, [, expr, elementBlock, named, blocks]) => {
+    if (isGetFreeComponent(expr)) {
+      op(HighLevelResolutionOpcodes.Component, expr, (component: CompileTimeComponent) => {
+        InvokeComponent(op, component, elementBlock, null, named, blocks);
+      });
+    } else {
+      // 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, true, true);
+    }
+  });
+}
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts b/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts
index 77267b0b33..7e29807e85 100644
--- a/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts
@@ -1,14 +1,16 @@
+import type { ExpressionSexpOpcode } from '@glimmer/interfaces';
 import { assert, deprecate } from '@glimmer/global-context';
-import type { ExpressionSexpOpcode } from "@glimmer/interfaces";
-import { $v0, MachineOp, Op } from '@glimmer/vm';
+import { $v0, Op } from '@glimmer/vm';
 import { SexpOpcodes } from '@glimmer/wire-format';
 
+import type { PushExpressionOp } from './compilers';
+
 import { expr } from '../opcode-builder/helpers/expr';
 import { isGetFreeHelper } from '../opcode-builder/helpers/resolution';
 import { SimpleArgs } from '../opcode-builder/helpers/shared';
 import { Call, CallDynamic, Curry, PushPrimitiveReference } from '../opcode-builder/helpers/vm';
 import { HighLevelResolutionOpcodes } from '../opcode-builder/opcodes';
-import { Compilers, type PushExpressionOp } from './compilers';
+import { Compilers } from './compilers';
 
 export const EXPRESSIONS = new Compilers<PushExpressionOp, ExpressionSexpOpcode>();
 
@@ -147,9 +149,9 @@ EXPRESSIONS.add(SexpOpcodes.GetDynamicVar, (op, [, expression]) => {
 });
 
 EXPRESSIONS.add(SexpOpcodes.Log, (op, [, positional]) => {
-  op(MachineOp.PushFrame);
+  op(Op.PushFrame);
   SimpleArgs(op, positional, null, false);
   op(Op.Log);
-  op(MachineOp.PopFrame);
+  op(Op.PopFrame);
   op(Op.Fetch, $v0);
 });
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts b/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
index d4feac3fce..54c223a88a 100644
--- a/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
@@ -1,379 +1,14 @@
-import type {
-  CompileTimeComponent,
-  StatementSexpOpcode,
-  WellKnownAttrName,
-  WellKnownTagName,
-  WireFormat,
-} from "@glimmer/interfaces";
-import { $fp, $sp, ContentType, MachineOp, Op } from '@glimmer/vm';
-import { SexpOpcodes } from '@glimmer/wire-format';
+import type { StatementSexpOpcode } from '@glimmer/interfaces';
 
-import {
-  InvokeStaticBlock,
-  InvokeStaticBlockWithStack,
-  YieldBlock,
-} from '../opcode-builder/helpers/blocks';
-import {
-  InvokeComponent,
-  InvokeDynamicComponent,
-  InvokeNonStaticComponent,
-} from '../opcode-builder/helpers/components';
-import { Replayable, ReplayableIf, SwitchCases } from '../opcode-builder/helpers/conditional';
-import { expr } from '../opcode-builder/helpers/expr';
-import {
-  isGetFreeComponent,
-  isGetFreeComponentOrHelper,
-  isGetFreeModifier,
-  isGetFreeOptionalComponentOrHelper,
-} from '../opcode-builder/helpers/resolution';
-import { CompilePositional, SimpleArgs } from '../opcode-builder/helpers/shared';
-import {
-  Call,
-  CallDynamic,
-  DynamicScope,
-  PushPrimitiveReference,
-} from '../opcode-builder/helpers/vm';
-import { HighLevelBuilderOpcodes, HighLevelResolutionOpcodes } from '../opcode-builder/opcodes';
-import { debugSymbolsOperand, labelOperand, stdlibOperand } from '../opcode-builder/operands';
-import { namedBlocks } from '../utils';
-import { Compilers, type PushStatementOp } from './compilers';
+import type { PushStatementOp } from './compilers';
 
-export const STATEMENTS = new Compilers<PushStatementOp, StatementSexpOpcode>();
-
-const INFLATE_ATTR_TABLE: {
-  [I in WellKnownAttrName]: string;
-} = ['class', 'id', 'value', 'name', 'type', 'style', 'href'];
-const INFLATE_TAG_TABLE: {
-  [I in WellKnownTagName]: string;
-} = ['div', 'span', 'p', 'a'];
-
-export function inflateTagName(tagName: string | WellKnownTagName): string {
-  return typeof tagName === 'string' ? tagName : INFLATE_TAG_TABLE[tagName];
-}
-
-export function inflateAttrName(attrName: string | WellKnownAttrName): string {
-  return typeof attrName === 'string' ? attrName : INFLATE_ATTR_TABLE[attrName];
-}
-
-STATEMENTS.add(SexpOpcodes.Comment, (op, sexp) => op(Op.Comment, sexp[1]));
-STATEMENTS.add(SexpOpcodes.CloseElement, (op) => op(Op.CloseElement));
-STATEMENTS.add(SexpOpcodes.FlushElement, (op) => op(Op.FlushElement));
-
-STATEMENTS.add(SexpOpcodes.Modifier, (op, [, expression, positional, named]) => {
-  if (isGetFreeModifier(expression)) {
-    op(HighLevelResolutionOpcodes.Modifier, expression, (handle: number) => {
-      op(MachineOp.PushFrame);
-      SimpleArgs(op, positional, named, false);
-      op(Op.Modifier, handle);
-      op(MachineOp.PopFrame);
-    });
-  } else {
-    expr(op, expression);
-    op(MachineOp.PushFrame);
-    SimpleArgs(op, positional, named, false);
-    op(Op.Dup, $fp, 1);
-    op(Op.DynamicModifier);
-    op(MachineOp.PopFrame);
-  }
-});
-
-STATEMENTS.add(SexpOpcodes.StaticAttr, (op, [, name, value, namespace]) => {
-  op(Op.StaticAttr, inflateAttrName(name), value as string, namespace ?? null);
-});
-
-STATEMENTS.add(SexpOpcodes.StaticComponentAttr, (op, [, name, value, namespace]) => {
-  op(Op.StaticComponentAttr, inflateAttrName(name), value as string, namespace ?? null);
-});
-
-STATEMENTS.add(SexpOpcodes.DynamicAttr, (op, [, name, value, namespace]) => {
-  expr(op, value);
-  op(Op.DynamicAttr, inflateAttrName(name), false, namespace ?? null);
-});
-
-STATEMENTS.add(SexpOpcodes.TrustingDynamicAttr, (op, [, name, value, namespace]) => {
-  expr(op, value);
-  op(Op.DynamicAttr, inflateAttrName(name), true, namespace ?? null);
-});
-
-STATEMENTS.add(SexpOpcodes.ComponentAttr, (op, [, name, value, namespace]) => {
-  expr(op, value);
-  op(Op.ComponentAttr, inflateAttrName(name), false, namespace ?? null);
-});
-
-STATEMENTS.add(SexpOpcodes.TrustingComponentAttr, (op, [, name, value, namespace]) => {
-  expr(op, value);
-  op(Op.ComponentAttr, inflateAttrName(name), true, namespace ?? null);
-});
-
-STATEMENTS.add(SexpOpcodes.OpenElement, (op, [, tag]) => {
-  op(Op.OpenElement, inflateTagName(tag));
-});
-
-STATEMENTS.add(SexpOpcodes.OpenElementWithSplat, (op, [, tag]) => {
-  op(Op.PutComponentOperations);
-  op(Op.OpenElement, inflateTagName(tag));
-});
-
-STATEMENTS.add(SexpOpcodes.Component, (op, [, expr, elementBlock, named, blocks]) => {
-  if (isGetFreeComponent(expr)) {
-    op(HighLevelResolutionOpcodes.Component, expr, (component: CompileTimeComponent) => {
-      InvokeComponent(op, component, elementBlock, null, named, blocks);
-    });
-  } else {
-    // 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, true, true);
-  }
-});
-
-STATEMENTS.add(SexpOpcodes.Yield, (op, [, to, params]) => YieldBlock(op, to, params));
-
-STATEMENTS.add(SexpOpcodes.AttrSplat, (op, [, to]) => YieldBlock(op, to, null));
-
-STATEMENTS.add(SexpOpcodes.Debugger, (op, [, debugInfo]) =>
-  op(Op.Debugger, debugSymbolsOperand(), debugInfo)
-);
-
-STATEMENTS.add(SexpOpcodes.Append, (op, [, value]) => {
-  // Special case for static values
-  if (!Array.isArray(value)) {
-    op(Op.Text, value === null || value === undefined ? '' : String(value));
-  } else if (isGetFreeOptionalComponentOrHelper(value)) {
-    op(HighLevelResolutionOpcodes.OptionalComponentOrHelper, value, {
-      ifComponent(component: CompileTimeComponent) {
-        InvokeComponent(op, component, null, null, null, null);
-      },
-
-      ifHelper(handle: number) {
-        op(MachineOp.PushFrame);
-        Call(op, handle, null, null);
-        op(MachineOp.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
-        op(MachineOp.PopFrame);
-      },
-
-      ifValue(handle: number) {
-        op(MachineOp.PushFrame);
-        op(Op.ConstantReference, handle);
-        op(MachineOp.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
-        op(MachineOp.PopFrame);
-      },
-    });
-  } else if (value[0] === SexpOpcodes.Call) {
-    let [, expression, positional, named] = value;
-
-    if (isGetFreeComponentOrHelper(expression)) {
-      op(HighLevelResolutionOpcodes.ComponentOrHelper, expression, {
-        ifComponent(component: CompileTimeComponent) {
-          InvokeComponent(op, component, null, positional, hashToArgs(named), null);
-        },
-        ifHelper(handle: number) {
-          op(MachineOp.PushFrame);
-          Call(op, handle, positional, named);
-          op(MachineOp.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
-          op(MachineOp.PopFrame);
-        },
-      });
-    } else {
-      SwitchCases(
-        op,
-        () => {
-          expr(op, expression);
-          op(Op.DynamicContentType);
-        },
-        (when) => {
-          when(ContentType.Component, () => {
-            op(Op.ResolveCurriedComponent);
-            op(Op.PushDynamicComponentInstance);
-            InvokeNonStaticComponent(op, {
-              capabilities: true,
-              elementBlock: null,
-              positional,
-              named,
-              atNames: false,
-              blocks: namedBlocks(null),
-            });
-          });
-
-          when(ContentType.Helper, () => {
-            CallDynamic(op, positional, named, () => {
-              op(MachineOp.InvokeStatic, stdlibOperand('cautious-non-dynamic-append'));
-            });
-          });
-        }
-      );
-    }
-  } else {
-    op(MachineOp.PushFrame);
-    expr(op, value);
-    op(MachineOp.InvokeStatic, stdlibOperand('cautious-append'));
-    op(MachineOp.PopFrame);
-  }
-});
-
-STATEMENTS.add(SexpOpcodes.TrustingAppend, (op, [, value]) => {
-  if (!Array.isArray(value)) {
-    op(Op.Text, value === null || value === undefined ? '' : String(value));
-  } else {
-    op(MachineOp.PushFrame);
-    expr(op, value);
-    op(MachineOp.InvokeStatic, stdlibOperand('trusting-append'));
-    op(MachineOp.PopFrame);
-  }
-});
-
-STATEMENTS.add(SexpOpcodes.Block, (op, [, expr, positional, named, blocks]) => {
-  if (isGetFreeComponent(expr)) {
-    op(HighLevelResolutionOpcodes.Component, expr, (component: CompileTimeComponent) => {
-      InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
-    });
-  } else {
-    InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
-  }
-});
+import { Compilers } from './compilers';
+import { defineContent } from './content';
+import { defineDOM } from './dom';
 
-STATEMENTS.add(SexpOpcodes.InElement, (op, [, block, guid, destination, insertBefore]) => {
-  ReplayableIf(
-    op,
+export type DefineStatement = Compilers<PushStatementOp, StatementSexpOpcode>;
 
-    () => {
-      expr(op, guid);
-
-      if (insertBefore === undefined) {
-        PushPrimitiveReference(op, undefined);
-      } else {
-        expr(op, insertBefore);
-      }
-
-      expr(op, destination);
-      op(Op.Dup, $sp, 0);
-
-      return 4;
-    },
-
-    () => {
-      op(Op.PushRemoteElement);
-      InvokeStaticBlock(op, block);
-      op(Op.PopRemoteElement);
-    }
-  );
-});
-
-STATEMENTS.add(SexpOpcodes.If, (op, [, condition, block, inverse]) =>
-  ReplayableIf(
-    op,
-    () => {
-      expr(op, condition);
-      op(Op.ToBoolean);
-
-      return 1;
-    },
-
-    () => {
-      InvokeStaticBlock(op, block);
-    },
-
-    inverse
-      ? () => {
-          InvokeStaticBlock(op, inverse);
-        }
-      : undefined
-  )
-);
-
-STATEMENTS.add(SexpOpcodes.Each, (op, [, value, key, block, inverse]) =>
-  Replayable(
-    op,
-
-    () => {
-      if (key) {
-        expr(op, key);
-      } else {
-        PushPrimitiveReference(op, null);
-      }
-
-      expr(op, value);
-
-      return 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');
-
-      if (inverse) {
-        InvokeStaticBlock(op, inverse);
-      }
-    }
-  )
-);
-
-STATEMENTS.add(SexpOpcodes.With, (op, [, value, block, inverse]) => {
-  ReplayableIf(
-    op,
-
-    () => {
-      expr(op, value);
-      op(Op.Dup, $sp, 0);
-      op(Op.ToBoolean);
-
-      return 2;
-    },
-
-    () => {
-      InvokeStaticBlockWithStack(op, block, 1);
-    },
-
-    () => {
-      if (inverse) {
-        InvokeStaticBlock(op, inverse);
-      }
-    }
-  );
-});
-
-STATEMENTS.add(SexpOpcodes.Let, (op, [, positional, block]) => {
-  let count = CompilePositional(op, positional);
-  InvokeStaticBlockWithStack(op, block, count);
-});
-
-STATEMENTS.add(SexpOpcodes.WithDynamicVars, (op, [, named, block]) => {
-  if (named) {
-    let [names, expressions] = named;
-
-    CompilePositional(op, expressions);
-    DynamicScope(op, names, () => {
-      InvokeStaticBlock(op, block);
-    });
-  } else {
-    InvokeStaticBlock(op, block);
-  }
-});
-
-STATEMENTS.add(SexpOpcodes.InvokeComponent, (op, [, expr, positional, named, blocks]) => {
-  if (isGetFreeComponent(expr)) {
-    op(HighLevelResolutionOpcodes.Component, expr, (component: CompileTimeComponent) => {
-      InvokeComponent(op, component, null, positional, hashToArgs(named), blocks);
-    });
-  } else {
-    InvokeDynamicComponent(op, expr, null, positional, named, blocks, false, false);
-  }
-});
+export const STATEMENTS = new Compilers<PushStatementOp, StatementSexpOpcode>();
 
-function hashToArgs(hash: WireFormat.Core.Hash | null): WireFormat.Core.Hash | null {
-  if (hash === null) return null;
-  let names = hash[0].map((key) => `@${key}`);
-  return [names as [string, ...string[]], hash[1]];
-}
+defineDOM(STATEMENTS);
+defineContent(STATEMENTS);
diff --git a/packages/@glimmer/opcode-compiler/lib/template.ts b/packages/@glimmer/opcode-compiler/lib/template.ts
index 382652535a..b61188d1f9 100644
--- a/packages/@glimmer/opcode-compiler/lib/template.ts
+++ b/packages/@glimmer/opcode-compiler/lib/template.ts
@@ -8,7 +8,7 @@ import type {
   Template,
   TemplateFactory,
   TemplateOk,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 import { assign } from '@glimmer/util';
 
 import { compilable } from './compilable-template';
diff --git a/packages/@glimmer/opcode-compiler/lib/wrapped-component.ts b/packages/@glimmer/opcode-compiler/lib/wrapped-component.ts
index 86090376b7..cb407ffdbb 100644
--- a/packages/@glimmer/opcode-compiler/lib/wrapped-component.ts
+++ b/packages/@glimmer/opcode-compiler/lib/wrapped-component.ts
@@ -1,31 +1,41 @@
 import type {
+  BlockMetadata,
   BuilderOp,
   CompilableProgram,
-  CompileTimeCompilationContext,
   HandleResult,
   HighLevelOp,
+  JitContext,
   LayoutWithContext,
   Nullable,
   ProgramSymbolTable,
-} from "@glimmer/interfaces";
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
+} from '@glimmer/interfaces';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
+import { IS_COMPILABLE_TEMPLATE } from '@glimmer/util';
+
+import type {HighLevelStatementOp} from './syntax/compilers';
 
 import { debugCompiler } from './compiler';
 import { templateCompilationContext } from './opcode-builder/context';
 import { encodeOp } from './opcode-builder/encoder';
 import { ATTRS_BLOCK, WrappedComponent } from './opcode-builder/helpers/components';
 import { meta } from './opcode-builder/helpers/shared';
-import type { HighLevelStatementOp } from './syntax/compilers';
+import { definePushOp  } from './syntax/compilers';
 
 export class WrappedBuilder implements CompilableProgram {
   public symbolTable: ProgramSymbolTable;
   private compiled: Nullable<number> = null;
   private attrsBlockNumber: number;
+  readonly meta: BlockMetadata;
+  readonly [IS_COMPILABLE_TEMPLATE] = true;
 
-  constructor(private layout: LayoutWithContext, public moduleName: string) {
+  constructor(
+    private layout: LayoutWithContext,
+    public moduleName: string
+  ) {
     let { block } = layout;
-    let [, symbols, hasEval] = block;
+    let [, symbols, hasDebug] = block;
 
+    this.meta = meta(layout);
     symbols = symbols.slice();
 
     // ensure ATTRS_BLOCK is always included (only once) in the list of symbols
@@ -37,12 +47,12 @@ export class WrappedBuilder implements CompilableProgram {
     }
 
     this.symbolTable = {
-      hasEval,
+      hasDebug,
       symbols,
     };
   }
 
-  compile(syntax: CompileTimeCompilationContext): HandleResult {
+  compile(syntax: JitContext): HandleResult {
     if (this.compiled !== null) return this.compiled;
 
     let m = meta(this.layout);
@@ -57,7 +67,7 @@ export class WrappedBuilder implements CompilableProgram {
       encodeOp(encoder, constants, resolver, m, op as BuilderOp | HighLevelOp);
     }
 
-    WrappedComponent(pushOp, this.layout, this.attrsBlockNumber);
+    WrappedComponent(definePushOp(pushOp), this.layout, this.attrsBlockNumber);
 
     let handle = context.encoder.commit(m.size);
 
@@ -67,7 +77,7 @@ export class WrappedBuilder implements CompilableProgram {
 
     this.compiled = handle;
 
-    if (LOCAL_SHOULD_LOG) {
+    if (LOCAL_TRACE_LOGGING) {
       debugCompiler(context, handle);
     }
 
diff --git a/packages/@glimmer/program/lib/constants.ts b/packages/@glimmer/program/lib/constants.ts
index 68c13a57b3..4f1016d1f9 100644
--- a/packages/@glimmer/program/lib/constants.ts
+++ b/packages/@glimmer/program/lib/constants.ts
@@ -5,11 +5,12 @@ import type {
   ConstantPool,
   HelperDefinitionState,
   ModifierDefinitionState,
+  Nullable,
   ResolutionTimeConstants,
   ResolvedComponentDefinition,
   RuntimeConstants,
   Template,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 import {
   capabilityFlagsFrom,
   getComponentTemplate,
@@ -78,9 +79,11 @@ export class RuntimeConstantsImpl implements RuntimeConstants {
     return this.values[handle] as T;
   }
 
-  getArray<T>(value: number): T[] {
+  getArray<T extends Nullable<unknown[]>>(value: number): T {
     let handles = this.getValue<number[]>(value);
-    let reified: T[] = new Array(handles.length);
+    if (handles === undefined) return null as T;
+
+    let reified = new Array(handles.length) as NonNullable<T>;
 
     for (const [i, n] of enumerate(handles)) {
       reified[i] = this.getValue(n);
@@ -312,21 +315,25 @@ export class ConstantsImpl
     return this.values[index] as T;
   }
 
-  getArray<T>(index: number): T[] {
+  getArray<T extends Nullable<unknown[]>>(index: number): T {
     let reifiedArrs = this.reifiedArrs;
-    let reified = reifiedArrs[index] as T[];
+    const reified = reifiedArrs[index] as T;
+
+    if (reified !== undefined) return reified;
+
+    {
+      let names: Nullable<number[]> = this.getValue(index);
+      if (names === null) return null as T;
 
-    if (reified === undefined) {
-      let names: number[] = this.getValue(index);
-      reified = new Array(names.length);
+      const reified = new Array(names.length) as NonNullable<T>;
 
       for (const [i, name] of enumerate(names)) {
         reified[i] = this.getValue(name);
       }
 
       reifiedArrs[index] = reified;
-    }
 
-    return reified;
+      return reified;
+    }
   }
 }
diff --git a/packages/@glimmer/program/lib/opcode.ts b/packages/@glimmer/program/lib/opcode.ts
index ceb301c709..3a07027a8d 100644
--- a/packages/@glimmer/program/lib/opcode.ts
+++ b/packages/@glimmer/program/lib/opcode.ts
@@ -1,4 +1,4 @@
-import type { OpcodeHeap, RuntimeOp, SomeVmOp } from "@glimmer/interfaces";
+import type { OpcodeHeap, RuntimeOp, VmOp } from '@glimmer/interfaces';
 import { ARG_SHIFT, MACHINE_MASK, OPERAND_LEN_MASK, TYPE_MASK } from '@glimmer/vm';
 
 export class RuntimeOpImpl implements RuntimeOp {
@@ -15,8 +15,8 @@ export class RuntimeOpImpl implements RuntimeOp {
     return rawType & MACHINE_MASK ? 1 : 0;
   }
 
-  get type(): SomeVmOp {
-    return (this.heap.getbyaddr(this.offset) & TYPE_MASK) as SomeVmOp;
+  get type(): VmOp {
+    return (this.heap.getbyaddr(this.offset) & TYPE_MASK) as VmOp;
   }
 
   get op1() {
diff --git a/packages/@glimmer/program/lib/program.ts b/packages/@glimmer/program/lib/program.ts
index 65fc7a503b..201b1ce837 100644
--- a/packages/@glimmer/program/lib/program.ts
+++ b/packages/@glimmer/program/lib/program.ts
@@ -6,7 +6,7 @@ import type {
   RuntimeProgram,
   SerializedHeap,
   StdLibOperand,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 import { expect, unwrap } from '@glimmer/util';
 import { MACHINE_MASK } from '@glimmer/vm';
@@ -47,7 +47,7 @@ export class RuntimeHeapImpl implements RuntimeHeap {
   }
 
   sizeof(handle: number): number {
-    return sizeof(this.table, handle);
+    return sizeof(this.table, handle, this.heap.length);
   }
 }
 
@@ -126,12 +126,13 @@ export class HeapImpl implements CompileTimeHeap, RuntimeHeap {
     return this.handleTable.length - 1;
   }
 
-  finishMalloc(handle: number): void {
+  finishMalloc(handle: number, size: number): void {
     // @TODO: At the moment, garbage collection isn't actually used, so this is
     // wrapped to prevent us from allocating extra space in prod. In the future,
     // if we start using the compact API, we should change this.
     if (LOCAL_DEBUG) {
       this.handleState[handle] = TableSlotState.Allocated;
+      this.handleTable[handle + 1] = size;
     }
   }
 
@@ -147,7 +148,7 @@ export class HeapImpl implements CompileTimeHeap, RuntimeHeap {
   }
 
   sizeof(handle: number): number {
-    return sizeof(this.handleTable, handle);
+    return sizeof(this.handleTable, handle, this.offset - 1);
   }
 
   free(handle: number): void {
@@ -235,9 +236,11 @@ function slice(arr: Int32Array, start: number, end: number): Int32Array {
   return ret;
 }
 
-function sizeof(table: number[], handle: number) {
+function sizeof(table: number[], handle: number, endHeap: number) {
   if (LOCAL_DEBUG) {
-    return unwrap(table[handle + 1]) - unwrap(table[handle]);
+    let end = handle + 2 < table.length ? unwrap(table[handle + 2]) : endHeap;
+    let start = unwrap(table[handle]);
+    return end - start;
   } else {
     return -1;
   }
diff --git a/packages/@glimmer/reference/index.ts b/packages/@glimmer/reference/index.ts
index 176cf42353..f4f7125e4e 100644
--- a/packages/@glimmer/reference/index.ts
+++ b/packages/@glimmer/reference/index.ts
@@ -1,3 +1,4 @@
+export * from './lib/api/index';
 export {
   type AbstractIterator,
   createIteratorItemRef,
@@ -7,26 +8,4 @@ export {
   type OpaqueIterationItem,
   type OpaqueIterator,
 } from './lib/iterable';
-export {
-  childRefFor,
-  childRefFromParts,
-  createComputeRef,
-  createConstRef,
-  createDebugAliasRef,
-  createInvokableRef,
-  createPrimitiveRef,
-  createReadOnlyRef,
-  createUnboundRef,
-  FALSE_REFERENCE,
-  isConstRef,
-  isInvokableRef,
-  isUpdatableRef,
-  NULL_REFERENCE,
-  REFERENCE,
-  type Reference,
-  type ReferenceEnvironment,
-  TRUE_REFERENCE,
-  UNDEFINED_REFERENCE,
-  updateRef,
-  valueForRef,
-} from './lib/reference';
+export type { Reactive } from '@glimmer/interfaces';
diff --git a/packages/@glimmer/reference/lib/api/accessor.ts b/packages/@glimmer/reference/lib/api/accessor.ts
new file mode 100644
index 0000000000..748bc9bbf3
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/accessor.ts
@@ -0,0 +1,104 @@
+import type {
+  DefaultDescriptionFields,
+  DescriptionSpec,
+  Reactive,
+  ReactiveResult,
+} from '@glimmer/interfaces';
+import {
+  devmode,
+  devmodeOr,
+  setDescription,
+  stringifyDebugLabel,
+  toValidatableDescription,
+  UserException,
+} from '@glimmer/util';
+
+import { setError, setFromFallibleCompute, setResult } from './internal/errors';
+import { ACCESSOR, InternalReactive } from './internal/reactive';
+
+const RESULT_ACCESSOR_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'ResultAccessor',
+      read: 'fallible',
+      write: 'fallible',
+      label: [`(ResultAccessor)`],
+    }) satisfies DefaultDescriptionFields
+);
+
+export function ResultAccessor<T = unknown>(
+  options: {
+    get: () => ReactiveResult<T>;
+    set: (val: T) => ReactiveResult<void>;
+  },
+  description?: DescriptionSpec
+): Reactive<T> {
+  const { get, set } = options;
+
+  const internal = new InternalReactive<T>(ACCESSOR);
+
+  internal.compute = () => setResult(internal, get());
+
+  internal.update = (value: T) => {
+    const setResult = set(value);
+
+    if (setResult.type === 'ok') {
+      internal.lastValue = value;
+    } else {
+      setError(internal, setResult.value);
+    }
+  };
+
+  setDescription(
+    internal,
+    devmode(() => toValidatableDescription(description, RESULT_ACCESSOR_DEFAULTS))
+  );
+
+  return internal as Reactive<T>;
+}
+
+const ACCESSOR_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'Accessor',
+      read: 'fallible',
+      write: 'fallible',
+      label: [`(Accessor)`],
+    }) satisfies DefaultDescriptionFields
+);
+
+export function Accessor<T = unknown>(
+  options: { get: () => T; set: (val: T) => void },
+  description?: DescriptionSpec
+): Reactive<T> {
+  const { get, set } = options;
+
+  const internal = new InternalReactive<T>(ACCESSOR);
+
+  internal.compute = () => setFromFallibleCompute(internal, get);
+
+  internal.update = (value: T) => {
+    try {
+      set(value);
+      return value;
+    } catch (e) {
+      setError(
+        internal,
+        UserException.from(
+          e,
+          `An error occured setting ${devmodeOr(
+            () => stringifyDebugLabel(internal),
+            `an accessor`
+          )}`
+        )
+      );
+    }
+  };
+
+  setDescription(
+    internal,
+    devmode(() => toValidatableDescription(description, ACCESSOR_DEFAULTS))
+  );
+
+  return internal as Reactive<T>;
+}
diff --git a/packages/@glimmer/reference/lib/api/cell.ts b/packages/@glimmer/reference/lib/api/cell.ts
new file mode 100644
index 0000000000..8c26eba9ff
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/cell.ts
@@ -0,0 +1,198 @@
+import type {
+  DeeplyConstantReactiveCell,
+  DefaultDescriptionFields,
+  Described,
+  DescriptionSpec,
+  MutableReactiveCell,
+  ReactiveCell,
+  ReferenceDescription,
+  RETURN_TYPE,
+} from '@glimmer/interfaces';
+import { devmode, setDescription, toValidatableDescription } from '@glimmer/util';
+import { CONSTANT_TAG, consumeTag, createTag, dirtyTag } from '@glimmer/validator';
+
+import { unwrapReactive, updateReactive } from './core';
+import {
+  DEEPLY_CONSTANT,
+  InternalReactive,
+  MUTABLE_CELL,
+  READONLY_CELL,
+} from './internal/reactive';
+
+/**
+ * Read the current value of a cell. Since a cell cannot be in an error state, this always
+ * (infallibly) produces the value of the cell.
+ */
+export function readCell<T>(cell: ReactiveCell<T>): T {
+  // this is safe because cells are infallible
+  return unwrapReactive(cell);
+}
+
+/**
+ * Write a value to a *mutable* cell. This operation is infallible.
+ */
+export function writeCell<T>(cell: MutableReactiveCell<T>, value: T): void {
+  updateReactive(cell, value);
+}
+
+const MUTABLE_CELL_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'MutableCell',
+      read: 'infallible',
+      write: 'infallible',
+      label: ['{cell}'],
+    }) satisfies DefaultDescriptionFields
+);
+
+/**
+ * Create a mutable cell.
+ *
+ * A mutable cell is a place to store a single value.
+ *
+ * Reads and writes are infallible.
+ */
+export function MutableCell<T>(value: T, description?: DescriptionSpec): MutableReactiveCell<T> {
+  const ref = new InternalReactive(MUTABLE_CELL);
+
+  const tag = (ref.tag = createTag(toValidatableDescription(description, MUTABLE_CELL_DEFAULTS)));
+  ref.lastValue = value;
+
+  ref.update = (value) => {
+    ref.lastValue = value;
+    dirtyTag(tag);
+  };
+
+  setDescription(
+    ref,
+    devmode(() => toValidatableDescription(description, MUTABLE_CELL_DEFAULTS))
+  );
+
+  return ref as RETURN_TYPE;
+}
+
+const READONLY_CELL_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'ReadonlyCell',
+      read: 'infallible',
+      write: 'none',
+      label: ['{readonly cell}'],
+    }) satisfies DefaultDescriptionFields
+);
+
+/**
+ * Create a readonly cell.
+ *
+ * A readonly cell is a place to store a single value that cannot change.
+ *
+ * Reads are infallible. Properties are not readonly.
+ *
+ * @see {DeeplyReadonlyCell}
+ */
+export function ReadonlyCell<T>(value: T, description?: DescriptionSpec): ReactiveCell<T> {
+  const ref = new InternalReactive(READONLY_CELL);
+
+  ref.tag = CONSTANT_TAG;
+  ref.lastValue = value;
+
+  setDescription(
+    ref,
+    devmode(() => toValidatableDescription(description, READONLY_CELL_DEFAULTS))
+  );
+
+  return ref as RETURN_TYPE;
+}
+
+/**
+ * Create a deeply constant cell.
+ *
+ * A deeply constant cell behaves like a readonly cell, but properties of a deeply constant cell are
+ * also deeply constant.
+ *
+ * Reads are infallible. Properties are readonly.
+ *
+ * @see {ReadonlyCell}
+ *
+ * @remarks
+ *
+ * The concept of a "deeply readonly cell" was previously referred to as an "unbound reference".
+ */
+export function DeeplyReadonlyCell<T>(
+  value: T,
+  debugLabel?: false | string
+): DeeplyConstantReactiveCell<T> {
+  const ref = new InternalReactive(DEEPLY_CONSTANT);
+
+  ref.tag = CONSTANT_TAG;
+  ref.lastValue = value;
+
+  if (import.meta.env.DEV) {
+    ref.description = devmode(
+      () =>
+        ({
+          type: 'DeeplyReadonlyCell',
+          read: 'fallible',
+          write: 'none',
+          label: [debugLabel || `{deeply readonly cell}`],
+        }) satisfies ReferenceDescription
+    );
+  }
+
+  return ref as RETURN_TYPE;
+}
+
+interface Marker extends Described<ReferenceDescription> {
+  updated: () => void;
+  consumed: () => void;
+}
+
+/**
+ * Create an external marker.
+ *
+ * An external marker is an object that allows you to reflect external state into the reactivity
+ * system. It is used to create custom reactive objects that don't use tracked fields to store their
+ * state.
+ *
+ * For example, you could use a marker to implement a reactive wrapper around local storage.
+ *
+ * ```js
+ * class ReactiveLocalStorage {
+ *   #markers: Record<string, Marker>;
+ *
+ *   get(key) {
+ *     this.#initialized(key).consumed();
+ *     return localStorage[key]
+ *   }
+ *
+ *   set(key, value) {
+ *     localStorage[key] = value;
+ *     this.#initialized(key).updated();
+ *   }
+ *
+ *   #initialized(key) {
+ *     return (this.#marker[key] ??= ExternalMarker());
+ *   }
+ * }
+ * ```
+ *
+ * You could use the same technique to implement tracked builtins or other custom reactive objects.
+ * In general, this approach is most useful when you have a source of truth in external data and
+ * want to avoid duplicating it.
+ */
+export function ExternalMarker(debugLabel?: DescriptionSpec): Marker {
+  const description = toValidatableDescription(
+    debugLabel,
+    devmode(() => ({ label: ['{external marker}'] }))
+  );
+  const tag = createTag(description);
+
+  const marker = {
+    mark: () => dirtyTag(tag),
+    consume: () => consumeTag(tag),
+  };
+
+  setDescription(marker, description);
+
+  return marker as RETURN_TYPE;
+}
diff --git a/packages/@glimmer/reference/lib/api/compat.ts b/packages/@glimmer/reference/lib/api/compat.ts
new file mode 100644
index 0000000000..38b43810c4
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/compat.ts
@@ -0,0 +1,11 @@
+import { updateReactive } from './core';
+import { INTERNAL_REFERENCE } from './internal';
+
+/** @category compat */
+export const updateRef = updateReactive;
+
+/**
+ * @category compat
+ * @deprecated Use {@link INTERNAL_REFERENCE}
+ */
+export const REFERENCE = INTERNAL_REFERENCE;
diff --git a/packages/@glimmer/reference/lib/api/core.ts b/packages/@glimmer/reference/lib/api/core.ts
new file mode 100644
index 0000000000..25774403a3
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/core.ts
@@ -0,0 +1,22 @@
+import type { Reactive, ReactiveResult } from '@glimmer/interfaces';
+import { unwrapResult } from '@glimmer/util';
+
+import type { InternalReactive } from './internal/reactive';
+
+import { readInternalReactive, updateInternalReactive } from './internal/operations';
+
+/**
+ * This is generally not what you want, as it rethrows errors. It's useful in testing and console
+ * situations, and as a transitional mechanism away from valueForRef.
+ */
+export function unwrapReactive<T>(reactive: Reactive<T>): T {
+  return unwrapResult(readInternalReactive(reactive as InternalReactive<T>));
+}
+
+export function updateReactive<T>(reactive: Reactive<T>, value: T) {
+  updateInternalReactive(reactive as InternalReactive<T>, value);
+}
+
+export function readReactive<T>(reactive: Reactive<T>): ReactiveResult<T> {
+  return readInternalReactive(reactive as InternalReactive<T>);
+}
diff --git a/packages/@glimmer/reference/lib/api/debug.ts b/packages/@glimmer/reference/lib/api/debug.ts
new file mode 100644
index 0000000000..a06d7c33c5
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/debug.ts
@@ -0,0 +1,37 @@
+import type { DefaultDescriptionFields, Reactive } from '@glimmer/interfaces';
+import { devmode, enhancedDevmode, inDevmode, stringifyDebugLabel } from '@glimmer/util';
+
+import { Accessor } from './accessor';
+import { unwrapReactive, updateReactive } from './core';
+import { Formula } from './formula';
+import { REFERENCE } from './internal/reactive';
+import { isUpdatableRef } from './predicates';
+
+export const createDebugAliasRef = enhancedDevmode(
+  (inner: Reactive) => inner,
+  (inner: Reactive, debugLabel: () => string): Reactive => {
+    const update = isUpdatableRef(inner) ? (value: unknown) => updateReactive(inner, value) : null;
+
+    const ref = update
+      ? Accessor({ get: () => unwrapReactive(inner), set: update }, debugLabel())
+      : Formula(() => unwrapReactive(inner), debugLabel());
+
+    ref[REFERENCE] = inner[REFERENCE];
+
+    const debug = inDevmode(inner.description);
+
+    ref.description = devmode(
+      () =>
+        ({
+          type: 'DebugAlias',
+          read: debug.read,
+          write: debug.write,
+          property: debug.property,
+          reason: 'alias',
+          label: [`{${inDevmode(stringifyDebugLabel(inner))} as ${debugLabel}}`],
+        }) satisfies DefaultDescriptionFields
+    );
+
+    return ref;
+  }
+);
diff --git a/packages/@glimmer/reference/lib/api/errors.ts b/packages/@glimmer/reference/lib/api/errors.ts
new file mode 100644
index 0000000000..37bcd70666
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/errors.ts
@@ -0,0 +1,14 @@
+import type { Reactive } from '@glimmer/interfaces';
+
+import type { InternalReactive } from './internal/reactive';
+
+export function clearError(reactive: Reactive) {
+  const internal = reactive as InternalReactive;
+
+  internal.error = null;
+
+  // clearing the tag will cause the reference to be invalidated.
+  internal.tag = null;
+
+  internal.lastValue = null;
+}
diff --git a/packages/@glimmer/reference/lib/api/formula.ts b/packages/@glimmer/reference/lib/api/formula.ts
new file mode 100644
index 0000000000..5c65e1ec0a
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/formula.ts
@@ -0,0 +1,98 @@
+import type {
+  DefaultDescriptionFields,
+  DescriptionSpec,
+  ReactiveComputedCell,
+  ReactiveFormula,
+  ReactiveResult,
+  RETURN_TYPE,
+} from '@glimmer/interfaces';
+import { devmode, setDescription, toValidatableDescription } from '@glimmer/util';
+
+import { setFromFallibleCompute, setLastValue, setResult } from './internal/errors';
+import { COMPUTED_CELL, FALLIBLE_FORMULA, InternalReactive } from './internal/reactive';
+
+const FALLIBLE_FORMULA_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'FallibleFormula',
+      read: 'fallible',
+      write: 'none',
+      label: ['(FallibleFormula)'],
+    }) satisfies DefaultDescriptionFields
+);
+
+/**
+ * A fallible formula invokes user code. If the user code throws an exception, the formula returns
+ * an error {@linkcode Result}. Otherwise, it returns an ok {@linkcode Result}.
+ */
+export function Formula<T>(compute: () => T, debugLabel?: DescriptionSpec): ReactiveFormula<T> {
+  const ref = new InternalReactive<T>(FALLIBLE_FORMULA);
+
+  ref.compute = () => setFromFallibleCompute(ref, compute);
+
+  setDescription(
+    ref,
+    devmode(() => toValidatableDescription(debugLabel, FALLIBLE_FORMULA_DEFAULTS))
+  );
+
+  return ref as RETURN_TYPE;
+}
+
+const RESULT_FORMULA_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'ResultFormula',
+      read: 'fallible',
+      write: 'none',
+      label: [`{result formula}`],
+    }) satisfies DefaultDescriptionFields
+);
+
+/**
+ * The `compute` function must be infallible and convert any errors to results.
+ */
+export function ResultFormula<T = unknown>(
+  compute: () => ReactiveResult<T>,
+  description?: DescriptionSpec
+): ReactiveFormula<T> {
+  const ref = new InternalReactive<T>(FALLIBLE_FORMULA);
+
+  ref.compute = () => setResult(ref, compute());
+
+  setDescription(
+    ref,
+    devmode(() => toValidatableDescription(description, RESULT_FORMULA_DEFAULTS))
+  );
+
+  return ref as RETURN_TYPE;
+}
+
+const COMPUTED_CELL_DEFAULTS = devmode(
+  () =>
+    ({
+      type: 'InfallibleFormula',
+      read: 'infallible',
+      write: 'none',
+      label: [`{computed cell}`],
+    }) satisfies DefaultDescriptionFields
+);
+
+/**
+ * A computed cell does not invoke user code. If a computed cell's compute function throws an error,
+ * it's a bug and there is no error recovery.
+ */
+export function ComputedCell<T = unknown>(
+  compute: () => T,
+  description?: DescriptionSpec
+): ReactiveComputedCell<T> {
+  const ref = new InternalReactive<T>(COMPUTED_CELL);
+
+  ref.compute = () => setLastValue(ref, compute());
+
+  setDescription(
+    ref,
+    devmode(() => toValidatableDescription(description, COMPUTED_CELL_DEFAULTS))
+  );
+
+  return ref as RETURN_TYPE;
+}
diff --git a/packages/@glimmer/reference/lib/api/index.ts b/packages/@glimmer/reference/lib/api/index.ts
new file mode 100644
index 0000000000..2e3cc8d758
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/index.ts
@@ -0,0 +1,12 @@
+export * from './accessor';
+export * from './cell';
+export * from './compat';
+export * from './core';
+export * from './debug';
+export * from './errors';
+export * from './formula';
+export * from './internal';
+export * from './mutability';
+export * from './predicates';
+export * from './primitives';
+export * from './properties';
diff --git a/packages/@glimmer/reference/lib/api/internal.ts b/packages/@glimmer/reference/lib/api/internal.ts
new file mode 100644
index 0000000000..8532b8ca11
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/internal.ts
@@ -0,0 +1,20 @@
+import type { InternalReactive, Reactive } from './internal/reactive';
+
+import { internalHasError } from './internal/errors';
+import { validateInternalReactive } from './internal/operations';
+
+export { REFERENCE as INTERNAL_REFERENCE } from './internal/reactive';
+
+/**
+ * @internal
+ */
+export function validateReactive(reactive: Reactive): boolean {
+  return validateInternalReactive(reactive as InternalReactive);
+}
+
+/**
+ * @internal
+ */
+export function hasError(reactive: Reactive): boolean {
+  return internalHasError(reactive as InternalReactive);
+}
diff --git a/packages/@glimmer/reference/lib/api/internal/debug.ts b/packages/@glimmer/reference/lib/api/internal/debug.ts
new file mode 100644
index 0000000000..9eb6ade23e
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/internal/debug.ts
@@ -0,0 +1,42 @@
+import type { Described, Description, Reactive } from '@glimmer/interfaces';
+import {
+  devmode,
+  enhancedDevmode,
+  inDevmode,
+  stringifyChildLabel,
+  stringifyDebugLabel,
+} from '@glimmer/util';
+
+export function getChildLabel(parent: Described<Description>, child: PropertyKey) {
+  if (import.meta.env.DEV) {
+    return stringifyChildLabel(...inDevmode(parent.description).label, child as string | symbol);
+  } else {
+    return String(child);
+  }
+}
+
+export const describeReactive = enhancedDevmode(
+  () => {
+    return '{reactive value}';
+  },
+  (reactive: Reactive) => {
+    const description = inDevmode(reactive.description);
+
+    const types = inDevmode(TYPE_NAMES);
+    const desc =
+      description.type in types ? types[description.type as keyof typeof types] : 'reference';
+
+    return description.label ? `${desc} (\`${stringifyDebugLabel(reactive)}\`)` : desc;
+  }
+);
+
+const TYPE_NAMES = devmode(() => ({
+  ReadonlyCell: 'readonly cell',
+  MutableCell: 'mutable cell',
+  DeeplyReadonlyCell: 'deeply readonly cell',
+  InfallibleFormula: 'infallible formula',
+  FallibleFormula: 'fallible formula',
+  Accessor: 'accessor',
+  GetProperty: 'property reference',
+  ConstantError: 'constant error',
+}));
diff --git a/packages/@glimmer/reference/lib/api/internal/errors.ts b/packages/@glimmer/reference/lib/api/internal/errors.ts
new file mode 100644
index 0000000000..aee542bbae
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/internal/errors.ts
@@ -0,0 +1,96 @@
+import type {
+  ConstantReactiveError,
+  ReactiveResult,
+  RETURN_TYPE,
+  UserException as UserExceptionInterface,
+} from '@glimmer/interfaces';
+import {
+  devmode,
+  devmodeOr,
+  setDescription,
+  stringifyDebugLabel,
+  UserException,
+} from '@glimmer/util';
+import { CONSTANT_TAG } from '@glimmer/validator';
+
+import { updateInternalReactive } from './operations';
+import { CONSTANT_ERROR, InternalReactive } from './reactive';
+
+export function setLastValue<T>(reactive: InternalReactive<T>, value: T): T {
+  reactive.lastValue = value;
+  reactive.error = null;
+  return value;
+}
+
+export function setError<T>(reactive: InternalReactive<T>, error: UserExceptionInterface) {
+  reactive.lastValue = null;
+  reactive.error = error;
+
+  // since the setter threw, we want the reference to be invalid so that its consumers will see the
+  // invalidation and handle the error.
+  reactive.tag = null;
+}
+
+export function setResult<T>(internal: InternalReactive<T>, result: ReactiveResult<T>) {
+  switch (result.type) {
+    case 'ok':
+      return setLastValue(internal, result.value);
+    case 'err':
+      setError(internal, result.value);
+  }
+}
+export function setFromFallibleCompute<T>(
+  internal: InternalReactive<T>,
+  compute: () => T
+): T | undefined {
+  try {
+    return setLastValue(internal, compute());
+  } catch (e) {
+    setError(
+      internal,
+      UserException.from(
+        e,
+        `An error occured while computing ${devmodeOr(
+          () => stringifyDebugLabel(internal),
+          'a formula'
+        )}`
+      )
+    );
+  }
+}
+export function updateRefWithResult<T>(internal: InternalReactive<T>, value: ReactiveResult<T>) {
+  switch (value.type) {
+    case 'err':
+      setError(internal as InternalReactive, value.value);
+      break;
+    case 'ok':
+      updateInternalReactive(internal, value.value);
+      break;
+  }
+}
+
+export function internalHasError(reactive: InternalReactive): boolean {
+  return !!reactive.error;
+}
+
+export function Poison(
+  error: UserExceptionInterface,
+  debugLabel?: false | string
+): ConstantReactiveError {
+  const ref = new InternalReactive(CONSTANT_ERROR);
+
+  ref.tag = CONSTANT_TAG;
+  ref.error = error;
+
+  setDescription(
+    ref,
+    devmode(() => ({
+      readonly: true,
+      fallible: true,
+      label: [debugLabel || `(Poison)`],
+      kind: 'poisoned',
+    }))
+  );
+
+  return ref as RETURN_TYPE;
+}
diff --git a/packages/@glimmer/reference/lib/api/internal/operations.ts b/packages/@glimmer/reference/lib/api/internal/operations.ts
new file mode 100644
index 0000000000..7613d12ca1
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/internal/operations.ts
@@ -0,0 +1,62 @@
+import type { Reactive, ReactiveResult, Tag } from '@glimmer/interfaces';
+import { Err, getDescription, Ok } from '@glimmer/util';
+import { consumeTag, track, validateTag, valueForTag } from '@glimmer/validator';
+
+import type { InternalReactive } from './reactive';
+
+import { describeReactive } from './debug';
+
+function getValidResult<T>(ref: InternalReactive<T>): ReactiveResult<T> {
+  return ref.error ? Err(ref.error) : Ok(ref.lastValue as T);
+}
+
+export function readInternalReactive<T>(reactive: InternalReactive<T>): ReactiveResult<T> {
+  const { tag, compute } = reactive;
+
+  if (validateInternalReactive(reactive)) {
+    consumeTag(reactive.tag);
+    return getValidResult(reactive);
+  }
+
+  // a data cell
+  if (compute === null) {
+    if (tag) consumeTag(tag);
+    return getValidResult(reactive);
+  }
+
+  // a formula
+  const newTag = track(compute, getDescription(reactive));
+
+  reactive.tag = newTag;
+  reactive.lastRevision = valueForTag(newTag);
+  consumeTag(newTag);
+  return getValidResult(reactive);
+}
+
+/**
+ * @internal
+ */
+
+export function validateInternalReactive<T>(
+  reactive: Reactive<T> | InternalReactive<T>
+): reactive is Reactive<T> & { tag: Tag } {
+  const { tag, lastRevision } = reactive as InternalReactive<T>;
+
+  // not yet computed
+  if (tag === null) return false;
+
+  return validateTag(tag, lastRevision);
+}
+
+export function updateInternalReactive<T>(
+  reactive: InternalReactive<T>,
+  value: T
+): ReactiveResult<void> {
+  if (reactive.update) {
+    reactive.update(value);
+  } else if (import.meta.env.DEV) {
+    throw Error(`cannot update ${describeReactive(reactive as Reactive)}`);
+  }
+
+  return Ok(undefined);
+}
diff --git a/packages/@glimmer/reference/lib/api/internal/reactive.ts b/packages/@glimmer/reference/lib/api/internal/reactive.ts
new file mode 100644
index 0000000000..def0cea809
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/internal/reactive.ts
@@ -0,0 +1,98 @@
+import type {
+  AccessorType,
+  ComputedCellType,
+  ConstantErrorType,
+  DeeplyConstantType,
+  Described,
+  DevMode,
+  FormulaType,
+  MutableCellType,
+  Nullable,
+  Optional,
+  RawReactive,
+  Reactive,
+  ReactiveType,
+  ReadonlyCellType,
+  ReferenceDescription,
+  ReferenceSymbol,
+  Tag,
+  UserException as UserExceptionInterface,
+} from '@glimmer/interfaces';
+import type { Revision } from '@glimmer/validator';
+import { INITIAL } from '@glimmer/validator';
+
+export const REFERENCE: ReferenceSymbol = Symbol('REFERENCE') as ReferenceSymbol;
+
+export const MUTABLE_CELL: MutableCellType = 0;
+export const READONLY_CELL: ReadonlyCellType = 1;
+export const DEEPLY_CONSTANT: DeeplyConstantType = 2;
+export const FALLIBLE_FORMULA: FormulaType = 3;
+export const COMPUTED_CELL: ComputedCellType = 4;
+export const ACCESSOR: AccessorType = 5;
+export const CONSTANT_ERROR: ConstantErrorType = 6;
+
+export const REACTIVE_DESCRIPTIONS = [
+  'mutable',
+  'readonly',
+  'deeply constant',
+  'fallible formula',
+  'infallible formula',
+  'accessor',
+  'constant error',
+];
+
+export type { Reactive };
+
+//////////
+
+export interface ReferenceEnvironment {
+  getProp(obj: unknown, path: string): unknown;
+  setProp(obj: unknown, path: string, value: unknown): unknown;
+}
+
+export class InternalReactive<T = unknown, K extends ReactiveType = ReactiveType>
+  implements RawReactive<T, K>, Described<ReferenceDescription>
+{
+  readonly [REFERENCE]: K;
+
+  public tag: Nullable<Tag> = null;
+
+  /**
+   * The revision of the reactive the last time it was updated (if it was a cell) or computed (if it
+   * was a formula).
+   */
+  public lastRevision: Revision = INITIAL;
+
+  /**
+   * A reactive is in an error state if its `compute` function produced an error.
+   */
+  public error: Nullable<UserExceptionInterface> = null;
+
+  /**
+   * In a data cell, lastValue is the value of the cell, and `lastValue` or `error` is always set.
+   * In a formula cell, lastValue is the cached result of the formula. If lastValue is null and
+   * error is null, the formula is uninitialized.
+   */
+  public lastValue?: Nullable<T>;
+
+  /**
+   * In a data cell, compute is always null.
+   */
+  public compute: Nullable<() => Optional<T>> = null;
+
+  /**
+   * In an accessor, `update` is the mutator function. Otherwise, `update` is always null.
+   */
+  public update: Nullable<(val: T) => void> = null;
+
+  /**
+   * In any kind of reference, `properties` is a map from property keys to their references.
+   */
+  public properties: Nullable<Map<PropertyKey | RawReactive, RawReactive>> = null;
+
+  declare description: DevMode<ReferenceDescription>;
+
+  constructor(type: K) {
+    this[REFERENCE] = type;
+  }
+}
diff --git a/packages/@glimmer/reference/lib/api/internal/types.ts b/packages/@glimmer/reference/lib/api/internal/types.ts
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/packages/@glimmer/reference/lib/api/mutability.ts b/packages/@glimmer/reference/lib/api/mutability.ts
new file mode 100644
index 0000000000..6b44e64005
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/mutability.ts
@@ -0,0 +1,31 @@
+import type { Reactive,ReactiveFormula } from '@glimmer/interfaces';
+
+import type { InternalReactive } from './internal/reactive';
+
+import { ResultAccessor } from './accessor';
+import { unwrapReactive } from './core';
+import { Formula } from './formula';
+import { readInternalReactive, updateInternalReactive } from './internal/operations';
+import { DEEPLY_CONSTANT, READONLY_CELL, REFERENCE } from './internal/reactive';
+
+export function toReadonly<T>(reactive: Reactive<T>): ReactiveFormula<T> {
+  return Formula(() => unwrapReactive(reactive));
+}
+
+export function toMut<T>(maybeMut: Reactive<T>): Reactive<T> {
+  const reactive = maybeMut as InternalReactive;
+
+  return ResultAccessor({
+    get: () => readInternalReactive(maybeMut as InternalReactive<T>),
+    set: (value: unknown) => updateInternalReactive(reactive, value),
+  });
+}
+export function isConstant(reactive: Reactive) {
+  switch (reactive[REFERENCE]) {
+    case READONLY_CELL:
+    case DEEPLY_CONSTANT:
+      return true;
+    default:
+      return false;
+  }
+}
diff --git a/packages/@glimmer/reference/lib/api/predicates.ts b/packages/@glimmer/reference/lib/api/predicates.ts
new file mode 100644
index 0000000000..c354b637d7
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/predicates.ts
@@ -0,0 +1,27 @@
+import type {
+  ConstantReactiveError,
+  ReactiveFormula,
+  Reactive,
+  ReactiveAccessor,
+} from '@glimmer/interfaces';
+
+import type { InternalReactive } from './internal/reactive';
+
+import { ACCESSOR, CONSTANT_ERROR, FALLIBLE_FORMULA, REFERENCE } from './internal/reactive';
+
+export function isFallibleFormula<T>(_ref: Reactive<T>): _ref is ReactiveFormula<T> {
+  return _ref[REFERENCE] === FALLIBLE_FORMULA;
+}
+
+export function isAccessor<T>(_ref: Reactive<T>): _ref is ReactiveAccessor<T> {
+  return _ref[REFERENCE] === ACCESSOR;
+}
+
+export function isConstantError<T>(_ref: Reactive<T>): _ref is ConstantReactiveError {
+  return _ref[REFERENCE] === CONSTANT_ERROR;
+}
+export function isUpdatableRef(_ref: Reactive) {
+  const ref = _ref as InternalReactive;
+
+  return ref.update !== null;
+}
diff --git a/packages/@glimmer/reference/lib/api/primitives.ts b/packages/@glimmer/reference/lib/api/primitives.ts
new file mode 100644
index 0000000000..bf1318967d
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/primitives.ts
@@ -0,0 +1,42 @@
+import type {
+  DefaultDescriptionFields,
+  ReadonlyReactiveCell,
+  RETURN_TYPE,
+} from '@glimmer/interfaces';
+import { devmode, setDescription } from '@glimmer/util';
+import { CONSTANT_TAG } from '@glimmer/validator';
+
+import { InternalReactive, READONLY_CELL } from './internal/reactive';
+
+export type Primitive = string | number | boolean | null | undefined | bigint | symbol;
+
+export const UNDEFINED_REFERENCE = createPrimitiveCell(undefined);
+export const NULL_REFERENCE = createPrimitiveCell(null);
+export const TRUE_REFERENCE = createPrimitiveCell(true);
+export const FALSE_REFERENCE = createPrimitiveCell(false);
+
+export function createPrimitiveCell<T extends Primitive>(value: T): ReadonlyReactiveCell<T> {
+  const ref = new InternalReactive(READONLY_CELL);
+
+  ref.tag = CONSTANT_TAG;
+  ref.lastValue = value;
+
+  setDescription(
+    ref,
+    devmode(
+      () =>
+        ({
+          type: 'PrimitiveCell',
+          read: 'infallible',
+          write: 'none',
+          property: {
+            read: 'fallible',
+            write: 'none',
+          },
+          label: [value === undefined ? 'undefined' : JSON.stringify(value)],
+        }) satisfies DefaultDescriptionFields
+    )
+  );
+
+  return ref as RETURN_TYPE;
+}
diff --git a/packages/@glimmer/reference/lib/api/properties.ts b/packages/@glimmer/reference/lib/api/properties.ts
new file mode 100644
index 0000000000..d2f23d3e72
--- /dev/null
+++ b/packages/@glimmer/reference/lib/api/properties.ts
@@ -0,0 +1,150 @@
+import type { Reactive, ReactiveResult, RETURN_TYPE } from '@glimmer/interfaces';
+import { getProperty, setProperty } from '@glimmer/global-context';
+import {
+  Err,
+  isDict,
+  isIndexable,
+  isObject,
+  mapDevmode,
+  Ok,
+  setDescription,
+  UserException,
+} from '@glimmer/util';
+import { consumeTag, dirtyTagFor, tagFor } from '@glimmer/validator';
+
+import type { InternalReactive } from './internal/reactive';
+
+import { Accessor } from './accessor';
+import { DeeplyReadonlyCell } from './cell';
+import { unwrapReactive } from './core';
+import { getChildLabel } from './internal/debug';
+import { Poison } from './internal/errors';
+import { readInternalReactive } from './internal/operations';
+import { DEEPLY_CONSTANT, REFERENCE } from './internal/reactive';
+
+export function getReactivePath(reactive: Reactive, path: string[]): Reactive {
+  let current: Reactive = reactive;
+
+  for (const part of path) {
+    current = getReactiveProperty(current, part);
+  }
+
+  return current;
+}
+
+export function getReactiveProperty(parentReactive: Reactive, property: PropertyKey): Reactive {
+  const type = parentReactive[REFERENCE];
+
+  const children = initializeChildren(parentReactive);
+
+  {
+    const child = children.get(property);
+
+    if (child !== undefined) {
+      return child as RETURN_TYPE;
+    }
+  }
+
+  const initialize = (child: Reactive): Reactive => {
+    children.set(property, child);
+
+    setDescription(
+      child,
+      mapDevmode(
+        () => parentReactive.description,
+        (desc) => {
+          return {
+            type: 'GetProperty',
+            read: 'fallible',
+            write: 'fallible',
+            label: [...desc.label, property as string | symbol],
+          };
+        }
+      )
+    );
+
+    return child as RETURN_TYPE;
+  };
+
+  if (type === DEEPLY_CONSTANT) {
+    // We need an extra try/catch here because any reactive value can be turned into a deeply
+    // constant value.
+    try {
+      const parent = readInternalReactive(parentReactive as InternalReactive);
+
+      if (parent.type === 'err') {
+        return initialize(Poison(parent.value));
+      } else {
+        if (isDict(parent.value)) {
+          return initialize(
+            DeeplyReadonlyCell(parent.value[property as keyof typeof parent.value])
+          );
+        }
+      }
+    } catch (e) {
+      return initialize(
+        Poison(
+          UserException.from(
+            e,
+            `An error occured when getting a property from a deeply constant reactive (${getChildLabel(
+              parentReactive,
+              property
+            )})`
+          )
+        )
+      );
+    }
+  }
+
+  const child = Accessor({
+    get: () => {
+      const parent = unwrapReactive(parentReactive);
+      if (isDict(parent)) {
+        if (isObject(parent)) consumeTag(tagFor(parent, property as keyof typeof parent));
+
+        return getProperty(parent, property as keyof typeof parent);
+      }
+    },
+    set: (value: unknown): ReactiveResult<void> => {
+      const parentResult = readInternalReactive(parentReactive as InternalReactive);
+
+      if (parentResult.type === 'err') {
+        return parentResult;
+      } else {
+        const parent = parentResult.value;
+
+        if (isIndexable(parent)) {
+          try {
+            setProperty(parent, property as keyof typeof parent, value);
+
+            if (isObject(parentResult.value))
+              dirtyTagFor(parentResult.value, property as keyof typeof parentResult.value);
+          } catch (e) {
+            return Err(
+              UserException.from(
+                e,
+                `An error occured when setting a property on a deeply constant reactive (${getChildLabel(
+                  parentReactive,
+                  property
+                )})`
+              )
+            );
+          }
+        }
+
+        return Ok(undefined);
+      }
+    },
+  });
+
+  return initialize(child);
+}
+export function initializeChildren(parent: Reactive) {
+  let children = parent.properties;
+
+  if (children === null) {
+    children = parent.properties = new Map();
+  }
+
+  return children;
+}
diff --git a/packages/@glimmer/reference/lib/iterable.ts b/packages/@glimmer/reference/lib/iterable.ts
index 756e216b37..494a6a61d1 100644
--- a/packages/@glimmer/reference/lib/iterable.ts
+++ b/packages/@glimmer/reference/lib/iterable.ts
@@ -1,14 +1,11 @@
+import type { Dict, Nullable, Reactive, TagDescription } from '@glimmer/interfaces';
 import { getPath, toIterator } from '@glimmer/global-context';
-import type { Dict, Nullable } from "@glimmer/interfaces";
-import { EMPTY_ARRAY, isObject } from '@glimmer/util';
+import { devmode, EMPTY_ARRAY, isObject } from '@glimmer/util';
 import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
 
-import {
-  createComputeRef,
-  type Reference,
-  type ReferenceEnvironment,
-  valueForRef,
-} from './reference';
+import type { ReferenceEnvironment } from './api/internal/reactive';
+
+import { Accessor, Formula, unwrapReactive } from './api';
 
 export interface IterationItem<T, U> {
   key: unknown;
@@ -51,8 +48,12 @@ const IDENTITY: KeyFor = (item) => {
 };
 
 function keyForPath(path: string): KeyFor {
-  if (import.meta.env.DEV && path[0] === '@') {
-    throw new Error(`invalid keypath: '${path}', valid keys: @index, @identity, or a path`);
+  if (import.meta.env.DEV) {
+    if (path[0] === '@') {
+      throw new Error(`invalid keypath: '${path}', valid keys: @index, @identity, or a path`);
+    } else if (typeof path !== 'string') {
+      throw new Error(`invalid non-string keypath: valid keys: @index, @identity, or a path`);
+    }
   }
   return uniqueKeyFor((item) => getPath(item as object, path));
 }
@@ -159,9 +160,9 @@ function uniqueKeyFor(keyFor: KeyFor) {
   };
 }
 
-export function createIteratorRef(listRef: Reference, key: string) {
-  return createComputeRef(() => {
-    let iterable = valueForRef(listRef) as { [Symbol.iterator]: any } | null | false;
+export function createIteratorRef(listRef: Reactive, key: string) {
+  return Formula(() => {
+    let iterable = unwrapReactive(listRef) as { [Symbol.iterator]: any } | null | false;
 
     let keyFor = makeKeyFor(key);
 
@@ -181,24 +182,35 @@ export function createIteratorRef(listRef: Reference, key: string) {
 
 export function createIteratorItemRef(_value: unknown) {
   let value = _value;
-  let tag = createTag();
+  let tag = createTag(
+    devmode(
+      () =>
+        ({
+          reason: 'formula',
+          label: ['(iterator)'],
+        }) satisfies TagDescription
+    )
+  );
 
-  return createComputeRef(
-    () => {
+  return Accessor({
+    get: () => {
       consumeTag(tag);
       return value;
     },
-    (newValue) => {
+    set: (newValue) => {
       if (value !== newValue) {
         value = newValue;
         dirtyTag(tag);
       }
-    }
-  );
+    },
+  });
 }
 
 class IteratorWrapper implements OpaqueIterator {
-  constructor(private inner: IteratorDelegate, private keyFor: KeyFor) {}
+  constructor(
+    private inner: IteratorDelegate,
+    private keyFor: KeyFor
+  ) {}
 
   isEmpty() {
     return this.inner.isEmpty();
@@ -219,7 +231,10 @@ class ArrayIterator implements OpaqueIterator {
   private current: { kind: 'empty' } | { kind: 'first'; value: unknown } | { kind: 'progress' };
   private pos = 0;
 
-  constructor(private iterator: unknown[] | readonly unknown[], private keyFor: KeyFor) {
+  constructor(
+    private iterator: unknown[] | readonly unknown[],
+    private keyFor: KeyFor
+  ) {
     if (iterator.length === 0) {
       this.current = { kind: 'empty' };
     } else {
diff --git a/packages/@glimmer/reference/lib/reference.ts b/packages/@glimmer/reference/lib/reference.ts
deleted file mode 100644
index 705692d7a5..0000000000
--- a/packages/@glimmer/reference/lib/reference.ts
+++ /dev/null
@@ -1,272 +0,0 @@
-import { getProp, setProp } from '@glimmer/global-context';
-import type {
-  ComputeReference,
-  ConstantReference,
-  InvokableReference,
-  Nullable,
-  Reference,
-  ReferenceSymbol,
-  ReferenceType,
-  UnboundReference,
-} from "@glimmer/interfaces";
-import { expect, isDict } from '@glimmer/util';
-import {
-  CONSTANT_TAG,
-  consumeTag,
-  INITIAL,
-  type Revision,
-  type Tag,
-  track,
-  validateTag,
-  valueForTag,
-} from '@glimmer/validator';
-
-export const REFERENCE: ReferenceSymbol = Symbol('REFERENCE') as ReferenceSymbol;
-
-const CONSTANT: ConstantReference = 0;
-const COMPUTE: ComputeReference = 1;
-const UNBOUND: UnboundReference = 2;
-const INVOKABLE: InvokableReference = 3;
-
-export type { Reference as default };
-export type { Reference };
-
-//////////
-
-export interface ReferenceEnvironment {
-  getProp(obj: unknown, path: string): unknown;
-  setProp(obj: unknown, path: string, value: unknown): unknown;
-}
-
-class ReferenceImpl<T = unknown> implements Reference<T> {
-  [REFERENCE]: ReferenceType;
-  public tag: Nullable<Tag> = null;
-  public lastRevision: Revision = INITIAL;
-  public lastValue?: T;
-
-  public children: Nullable<Map<string | Reference, Reference>> = null;
-
-  public compute: Nullable<() => T> = null;
-  public update: Nullable<(val: T) => void> = null;
-
-  public debugLabel?: string;
-
-  constructor(type: ReferenceType) {
-    this[REFERENCE] = type;
-  }
-}
-
-export function createPrimitiveRef(value: unknown): Reference {
-  const ref = new ReferenceImpl(UNBOUND);
-
-  ref.tag = CONSTANT_TAG;
-  ref.lastValue = value;
-
-  if (import.meta.env.DEV) {
-    ref.debugLabel = String(value);
-  }
-
-  return ref;
-}
-
-export const UNDEFINED_REFERENCE = createPrimitiveRef(undefined);
-export const NULL_REFERENCE = createPrimitiveRef(null);
-export const TRUE_REFERENCE = createPrimitiveRef(true);
-export const FALSE_REFERENCE = createPrimitiveRef(false);
-
-export function createConstRef(value: unknown, debugLabel: false | string): Reference {
-  const ref = new ReferenceImpl(CONSTANT);
-
-  ref.lastValue = value;
-  ref.tag = CONSTANT_TAG;
-
-  if (import.meta.env.DEV) {
-    ref.debugLabel = debugLabel as string;
-  }
-
-  return ref;
-}
-
-export function createUnboundRef(value: unknown, debugLabel: false | string): Reference {
-  const ref = new ReferenceImpl(UNBOUND);
-
-  ref.lastValue = value;
-  ref.tag = CONSTANT_TAG;
-
-  if (import.meta.env.DEV) {
-    ref.debugLabel = debugLabel as string;
-  }
-
-  return ref;
-}
-
-export function createComputeRef<T = unknown>(
-  compute: () => T,
-  update: Nullable<(value: T) => void> = null,
-  debugLabel: false | string = 'unknown'
-): Reference<T> {
-  const ref = new ReferenceImpl<T>(COMPUTE);
-
-  ref.compute = compute;
-  ref.update = update;
-
-  if (import.meta.env.DEV) {
-    ref.debugLabel = `(result of a \`${debugLabel}\` helper)`;
-  }
-
-  return ref;
-}
-
-export function createReadOnlyRef(ref: Reference): Reference {
-  if (!isUpdatableRef(ref)) return ref;
-
-  return createComputeRef(() => valueForRef(ref), null, ref.debugLabel);
-}
-
-export function isInvokableRef(ref: Reference) {
-  return ref[REFERENCE] === INVOKABLE;
-}
-
-export function createInvokableRef(inner: Reference): Reference {
-  const ref = createComputeRef(
-    () => valueForRef(inner),
-    (value) => updateRef(inner, value)
-  );
-  ref.debugLabel = inner.debugLabel;
-  ref[REFERENCE] = INVOKABLE;
-
-  return ref;
-}
-
-export function isConstRef(_ref: Reference) {
-  const ref = _ref as ReferenceImpl;
-
-  return ref.tag === CONSTANT_TAG;
-}
-
-export function isUpdatableRef(_ref: Reference) {
-  const ref = _ref as ReferenceImpl;
-
-  return ref.update !== null;
-}
-
-export function valueForRef<T>(_ref: Reference<T>): T {
-  const ref = _ref as ReferenceImpl<T>;
-
-  let { tag } = ref;
-
-  if (tag === CONSTANT_TAG) {
-    return ref.lastValue as T;
-  }
-
-  const { lastRevision } = ref;
-  let lastValue;
-
-  if (tag === null || !validateTag(tag, lastRevision)) {
-    const { compute } = ref;
-
-    const newTag = track(() => {
-      lastValue = ref.lastValue = compute!();
-    }, import.meta.env.DEV && ref.debugLabel);
-
-    tag = ref.tag = newTag;
-
-    ref.lastRevision = valueForTag(newTag);
-  } else {
-    lastValue = ref.lastValue;
-  }
-
-  consumeTag(tag);
-
-  return lastValue as T;
-}
-
-export function updateRef(_ref: Reference, value: unknown) {
-  const ref = _ref as ReferenceImpl;
-
-  const update = expect(ref.update, 'called update on a non-updatable reference');
-
-  update(value);
-}
-
-export function childRefFor(_parentRef: Reference, path: string): Reference {
-  const parentRef = _parentRef as ReferenceImpl;
-
-  const type = parentRef[REFERENCE];
-
-  let children = parentRef.children;
-  let child: Reference;
-
-  if (children === null) {
-    children = parentRef.children = new Map();
-  } else {
-    child = children.get(path)!;
-
-    if (child !== undefined) {
-      return child;
-    }
-  }
-
-  if (type === UNBOUND) {
-    const parent = valueForRef(parentRef);
-
-    if (isDict(parent)) {
-      child = createUnboundRef(
-        (parent as Record<string, unknown>)[path],
-        import.meta.env.DEV && `${parentRef.debugLabel}.${path}`
-      );
-    } else {
-      child = UNDEFINED_REFERENCE;
-    }
-  } else {
-    child = createComputeRef(
-      () => {
-        const parent = valueForRef(parentRef);
-
-        if (isDict(parent)) {
-          return getProp(parent, path);
-        }
-      },
-      (val) => {
-        const parent = valueForRef(parentRef);
-
-        if (isDict(parent)) {
-          return setProp(parent, path, val);
-        }
-      }
-    );
-
-    if (import.meta.env.DEV) {
-      child.debugLabel = `${parentRef.debugLabel}.${path}`;
-    }
-  }
-
-  children.set(path, child);
-
-  return child;
-}
-
-export function childRefFromParts(root: Reference, parts: string[]): Reference {
-  let reference = root;
-
-  for (const part of parts) {
-    reference = childRefFor(reference, part);
-  }
-
-  return reference;
-}
-
-export let createDebugAliasRef: undefined | ((debugLabel: string, inner: Reference) => Reference);
-
-if (import.meta.env.DEV) {
-  createDebugAliasRef = (debugLabel: string, inner: Reference) => {
-    const update = isUpdatableRef(inner) ? (value: unknown) => updateRef(inner, value) : null;
-    const ref = createComputeRef(() => valueForRef(inner), update);
-
-    ref[REFERENCE] = inner[REFERENCE];
-
-    ref.debugLabel = debugLabel;
-
-    return ref;
-  };
-}
diff --git a/packages/@glimmer/reference/test/cells-test.ts b/packages/@glimmer/reference/test/cells-test.ts
new file mode 100644
index 0000000000..1c4bb14f7a
--- /dev/null
+++ b/packages/@glimmer/reference/test/cells-test.ts
@@ -0,0 +1,156 @@
+import type { Reactive } from '@glimmer/reference';
+import {
+  ComputedCell,
+  DeeplyReadonlyCell,
+  getReactiveProperty,
+  MutableCell,
+  readCell,
+  ReadonlyCell,
+  updateReactive,
+  writeCell,
+} from '@glimmer/reference';
+import { dirtyTagFor } from '@glimmer/validator';
+
+import { Validate } from './utils/validate';
+
+const { module, test } = QUnit;
+
+module('@glimmer/reference', () => {
+  module('MutableCell', () => {
+    test("it's a reactive value", () => {
+      const cell = MutableCell(0, 'cell');
+
+      const validate = new Validate(cell);
+
+      validate.assertingFresh(0, 'initial');
+
+      updateReactive(cell, 1);
+      validate.assertingStale(1, 'updated');
+    });
+
+    test(`it can produce property references`, () => {
+      const record = { hello: 1 };
+      const cell = MutableCell(record, 'cell');
+
+      testPropertyReferences(record, cell, (value) => {
+        updateReactive(cell, { hello: value });
+      });
+    });
+  });
+
+  module('ReadonlyCell', () => {
+    test(`it's a reactive value`, (assert) => {
+      const counter = ReadonlyCell(0, 'counter');
+
+      const validate = new Validate(counter);
+
+      validate.assertingFresh(0, 'initial');
+
+      assert.throws(
+        () => updateReactive(counter, 1),
+        /^Error: cannot update readonly cell \(`counter`\)$/u
+      );
+    });
+
+    test(`it can produce property references`, () => {
+      const record = { hello: 1 };
+      const cell = ReadonlyCell(record, 'cell');
+
+      const updatedValue = testPropertyReferences(record, cell);
+      testMutablePropertyReferences(cell, updatedValue);
+    });
+  });
+
+  module('DeeplyConstant', () => {
+    test(`it's a reactive value`, (assert) => {
+      const cell = DeeplyReadonlyCell(0, 'cell');
+      const validate = new Validate(cell);
+
+      validate.assertingFresh(0, 'initial');
+
+      assert.throws(
+        () => updateReactive(cell, 1),
+        /^Error: cannot update deeply readonly cell \(`cell`\)$/u
+      );
+    });
+
+    test(`its property references are also deeply constant`, (assert) => {
+      const counterRecord = { count: 1 };
+      const counter = DeeplyReadonlyCell(counterRecord, 'counter');
+
+      const property = getReactiveProperty(counter, 'count');
+
+      const validate = new Validate(property);
+
+      // it's fresh because a deeply constant property is static (not a computation).
+      validate.assertingFresh(1, 'initial');
+
+      assert.throws(
+        () => updateReactive(property, 2),
+        /^Error: cannot update property reference \(`counter.count`\)$/u
+      );
+    });
+  });
+
+  module('ComputedCell', () => {
+    test(`it's a reactive value and behaves like a cell`, (assert) => {
+      const counter = MutableCell(0);
+
+      const incremented = ComputedCell(() => {
+        return readCell(counter) + 1;
+      });
+
+      const validate = new Validate(incremented);
+
+      validate.assertingStale(1, 'initial');
+
+      assert.strictEqual(readCell(incremented), 1, 'incremented');
+
+      writeCell(counter, 1);
+
+      assert.strictEqual(readCell(incremented), 2, 'incremented again');
+      validate.assertingFresh(2, 'updated');
+
+      writeCell(counter, 2);
+
+      validate.assertingStale(3, 'updated again');
+      assert.strictEqual(readCell(incremented), 3, 'incremented again');
+    });
+  });
+});
+
+function testPropertyReferences(
+  record: { hello: number },
+  reactive: Reactive<{ hello: number }>,
+  update?: (value: number) => void
+) {
+  const property = getReactiveProperty(reactive, 'hello');
+  const validate = new Validate(property);
+
+  validate.assertingStale(1, 'initial');
+
+  record.hello = 2;
+  validate.assertingFresh(1, 'untracked update');
+
+  dirtyTagFor(record, 'hello');
+  validate.assertingStale(2, 'tracked update');
+
+  if (update) {
+    update(3);
+    validate.assertingStale(3, 'replacing the entire value');
+    return 3;
+  } else {
+    return 2;
+  }
+}
+
+function testMutablePropertyReferences(reactive: Reactive<{ hello: number }>, initial: number) {
+  const property = getReactiveProperty(reactive, 'hello');
+  const validate = new Validate(property);
+
+  validate.assertingFresh(initial, 'initial after testPropertyReferences');
+
+  updateReactive(property, initial + 1);
+
+  validate.assertingStale(initial + 1, 'updated through the reference');
+}
diff --git a/packages/@glimmer/reference/test/error-test.ts b/packages/@glimmer/reference/test/error-test.ts
new file mode 100644
index 0000000000..ad1fc346ff
--- /dev/null
+++ b/packages/@glimmer/reference/test/error-test.ts
@@ -0,0 +1,100 @@
+import {
+  clearError,
+  Formula,
+  MutableCell,
+  readReactive,
+  unwrapReactive,
+  updateReactive,
+} from '@glimmer/reference';
+
+import { Validate } from './utils/validate';
+
+const { module, test } = QUnit;
+
+module('@glimmer/reference', () => {
+  module('errors', () => {
+    module('FallibleFormula', () => {
+      test(`when the underlying computation becomes stale, there's a chance to recover`, () => {
+        const isError = MutableCell(false, 'isError');
+
+        const child = Formula(() => {
+          if (unwrapReactive(isError)) {
+            throw new Error('womp womp');
+          }
+
+          return true;
+        }, 'child');
+
+        const parent = Formula(() => {
+          return unwrapReactive(child);
+        }, 'parent');
+
+        const validate = new Validate(parent);
+
+        // the reactive value is stale before the first time it is read
+        validate.assertingStale(true, 'initial');
+
+        updateReactive(isError, true);
+        validate.assertingStaleError(/^Error: womp womp$/u);
+
+        updateReactive(isError, false);
+        validate.assertingStale(true, 'updated');
+
+        updateReactive(isError, true);
+        validate.assertingStaleError(/^Error: womp womp$/u);
+      });
+
+      test(`a getter doesn't run again after it happened`, (assert) => {
+        let events: string[] = [];
+
+        const formula = Formula(() => {
+          events.push('formula ran');
+
+          throw Error('womp womp');
+        });
+
+        assert.strictEqual(readReactive(formula).type, 'err', 'the formula is in an error state');
+        assert.deepEqual(events, ['formula ran']);
+
+        events = [];
+
+        assert.strictEqual(readReactive(formula).type, 'err', 'the formula is in an error state');
+        assert.deepEqual(events, []);
+      });
+
+      test(`an externally recoverable error`, () => {
+        // represent state that isn't tracked by the reactivity system, but which we might know has
+        // changed enough to justify recovery.
+        let isError = true;
+
+        // this formula will never invalidate on its own, since it doesn't read from any reactive
+        // state.
+        const formula = Formula(() => {
+          if (isError) {
+            throw new Error('womp womp');
+          }
+
+          return true;
+        }, 'child');
+
+        const validate = new Validate(formula);
+
+        step(`initial state`);
+        validate.assertingStaleError(/^Error: womp womp$/u);
+
+        step(`updating, still an error`);
+        clearError(formula);
+        validate.assertingStaleError(/^Error: womp womp$/u);
+
+        step(`updating, not an error`);
+        isError = false;
+        clearError(formula);
+        validate.assertingStale(true, 'after recovery');
+      });
+    });
+  });
+});
+
+export function step(message: string) {
+  QUnit.assert.ok(true, `>> ${message} <<`);
+}
diff --git a/packages/@glimmer/reference/test/formulas-test.ts b/packages/@glimmer/reference/test/formulas-test.ts
new file mode 100644
index 0000000000..cfdf74a37f
--- /dev/null
+++ b/packages/@glimmer/reference/test/formulas-test.ts
@@ -0,0 +1,105 @@
+import type { MutableReactiveCell, Reactive } from '@glimmer/interfaces';
+import {
+  Accessor,
+  Formula,
+  MutableCell,
+  readCell,
+  ResultFormula,
+  updateReactive,
+  writeCell,
+} from '@glimmer/reference';
+import { Err, Ok, UserException } from '@glimmer/util';
+
+import { step } from './error-test';
+import { Validate } from './utils/validate';
+
+const { module, test } = QUnit;
+
+module('@glimmer/reference', () => {
+  module('FallibleFormula', () => {
+    test(`errors in the formula turn into Err values when the reference is read`, () => {
+      const isError = MutableCell(false, 'isError');
+
+      const formula = Formula(() => {
+        if (readCell(isError)) {
+          throw new Error('womp womp');
+        } else {
+          return true;
+        }
+      });
+
+      testResult(formula, isError);
+    });
+  });
+
+  module('ResultFormula', () => {
+    test('if the formula returns an Err, the reference is in an error state', () => {
+      const isError = MutableCell(false, 'isError');
+
+      const formula = ResultFormula(() => {
+        if (readCell(isError)) {
+          return Err(UserException.from(new Error('womp womp'), `womp womp`));
+        } else {
+          return Ok(true);
+        }
+      });
+
+      testResult(formula, isError);
+    });
+  });
+
+  module('Accessor', () => {
+    test('if the getter throws an error, the reference is in an error state', () => {
+      const getError = MutableCell(false, 'getError');
+      let setError = false;
+      const value = MutableCell(true, 'value');
+
+      const accessor = Accessor({
+        get: () => {
+          if (setError) {
+            throw new Error('set: womp womp');
+          } else if (readCell(getError)) {
+            throw new Error('womp womp');
+          } else {
+            return readCell(value);
+          }
+        },
+        set: (newValue: boolean) => {
+          if (setError) {
+            throw new Error('set: womp womp');
+          } else {
+            writeCell(value, newValue);
+          }
+        },
+      });
+
+      const validate = testResult(accessor, getError);
+
+      step('updating the reactive');
+      updateReactive(accessor, false);
+      validate.assertingStale(false, 'updated');
+
+      setError = true;
+      step('updating the reactive again, but the setter throws');
+      updateReactive(accessor, true);
+
+      validate.assertingStaleError(/^Error: set: womp womp$/u);
+    });
+  });
+});
+
+function testResult(reactive: Reactive<boolean>, isError: MutableReactiveCell<boolean>) {
+  const validate = new Validate(reactive);
+
+  validate.assertingStale(true, 'initial');
+
+  writeCell(isError, true);
+
+  validate.assertingStaleError(/^Error: womp womp$/u);
+
+  writeCell(isError, false);
+
+  validate.assertingStale(true, 'updated');
+
+  return validate;
+}
diff --git a/packages/@glimmer/reference/test/iterable-test.ts b/packages/@glimmer/reference/test/iterable-test.ts
index 10e50d4f85..1e020a6ba1 100644
--- a/packages/@glimmer/reference/test/iterable-test.ts
+++ b/packages/@glimmer/reference/test/iterable-test.ts
@@ -1,23 +1,23 @@
-import { type GlobalContext, testOverrideGlobalContext } from '@glimmer/global-context';
+import type {GlobalContext} from '@glimmer/global-context';
+import type {OpaqueIterationItem, Reactive} from '@glimmer/reference';
+import {  testOverrideGlobalContext } from '@glimmer/global-context';
 import {
-  createComputeRef,
   createIteratorRef,
-  type OpaqueIterationItem,
-  type Reference,
-  valueForRef,
+  Formula,
+  unwrapReactive
 } from '@glimmer/reference';
+import { unwrap } from '@glimmer/util';
 import { consumeTag, VOLATILE_TAG } from '@glimmer/validator';
 
 import objectValues from './utils/platform';
 import { module, test } from './utils/qunit';
 import { TestContext } from './utils/template';
-import { unwrap } from '@glimmer/util';
 
 class IterableWrapper {
-  private iterable: Reference<{ next(): OpaqueIterationItem | null }>;
+  private iterable: Reactive<{ next(): OpaqueIterationItem | null }>;
 
   constructor(obj: unknown, key = '@identity') {
-    let valueRef = createComputeRef(() => {
+    let valueRef = Formula(() => {
       consumeTag(VOLATILE_TAG);
       return obj;
     });
@@ -28,7 +28,7 @@ class IterableWrapper {
     let result: OpaqueIterationItem[] = [];
 
     // bootstrap
-    let iterator = valueForRef(this.iterable);
+    let iterator = unwrapReactive(this.iterable);
     let item = iterator.next();
 
     while (item !== null) {
diff --git a/packages/@glimmer/reference/test/package.json b/packages/@glimmer/reference/test/package.json
index f659ffeaee..fa2e5909e5 100644
--- a/packages/@glimmer/reference/test/package.json
+++ b/packages/@glimmer/reference/test/package.json
@@ -5,6 +5,7 @@
     "@glimmer/reference": "workspace:^",
     "@glimmer/validator": "workspace:^",
     "@glimmer/util": "workspace:^",
-    "@glimmer/global-context": "workspace:^"
+    "@glimmer/global-context": "workspace:^",
+    "@glimmer/interfaces": "workspace:^"
   }
 }
diff --git a/packages/@glimmer/reference/test/references-test.ts b/packages/@glimmer/reference/test/references-test.ts
index 40beb4807b..3645c05bd5 100644
--- a/packages/@glimmer/reference/test/references-test.ts
+++ b/packages/@glimmer/reference/test/references-test.ts
@@ -1,20 +1,24 @@
-import { type GlobalContext, testOverrideGlobalContext } from '@glimmer/global-context';
-import { dict, unwrap } from '@glimmer/util';
-import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
-
+import type { GlobalContext } from '@glimmer/global-context';
+import type { Reactive } from '@glimmer/reference';
+import { testOverrideGlobalContext } from '@glimmer/global-context';
 import {
-  childRefFor,
-  createComputeRef,
-  createConstRef,
+  Accessor,
   createDebugAliasRef,
-  createInvokableRef,
-  createReadOnlyRef,
-  createUnboundRef,
-  isInvokableRef,
+  DeeplyReadonlyCell,
+  Formula,
+  getReactiveProperty,
+  isAccessor,
   isUpdatableRef,
-  updateRef,
-  valueForRef,
+  MutableCell,
+  ReadonlyCell,
+  toMut,
+  toReadonly,
+  unwrapReactive,
+  updateReactive,
 } from '@glimmer/reference';
+import { dict, unwrap } from '@glimmer/util';
+import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
+
 import { tracked } from './support';
 
 const { module, test } = QUnit;
@@ -34,379 +38,514 @@ class TrackedDict<T> {
   }
 }
 
-module('References', (hooks) => {
-  let originalContext: GlobalContext | null;
-  let getCount = 0;
-  let setCount = 0;
-
-  hooks.beforeEach(() => {
-    originalContext = unwrap(testOverrideGlobalContext)({
-      getProp(obj: object, key: string): unknown {
-        getCount++;
-        return (obj as Record<string, unknown>)[key];
-      },
+module('@glimmer/reference', () => {
+  module('References', (hooks) => {
+    let originalContext: GlobalContext | null;
+    let getCount = 0;
+    let setCount = 0;
+
+    hooks.beforeEach(() => {
+      originalContext = unwrap(testOverrideGlobalContext)({
+        getProp(obj: object, key: string): unknown {
+          getCount++;
+          return (obj as Record<string, unknown>)[key];
+        },
+
+        setProp(obj: object, key: string, value: unknown) {
+          setCount++;
+          (obj as Record<string, unknown>)[key] = value;
+        },
+
+        scheduleRevalidate() {},
+      });
+    });
 
-      setProp(obj: object, key: string, value: unknown) {
-        setCount++;
-        (obj as Record<string, unknown>)[key] = value;
-      },
+    hooks.afterEach(() => {
+      unwrap(testOverrideGlobalContext)(originalContext);
+    });
 
-      scheduleRevalidate() {},
+    hooks.beforeEach(() => {
+      getCount = 0;
+      setCount = 0;
     });
-  });
 
-  hooks.afterEach(() => {
-    unwrap(testOverrideGlobalContext)(originalContext);
-  });
+    class Validatable<T> {
+      readonly #reactive: Reactive<T>;
 
-  hooks.beforeEach(() => {
-    getCount = 0;
-    setCount = 0;
-  });
+      constructor(reactive: Reactive<T>) {
+        this.#reactive = reactive;
+      }
+
+      token(): {
+        fresh: () => void;
+        stale: (value: T, message?: string) => void;
+        updated: (value: T, message?: string) => void;
+      } {
+        let lastGetCount = getCount;
+        let lastSetCount = setCount;
+        let lastValue = unwrapReactive(this.#reactive);
+        return {
+          fresh: () => {
+            const actual = unwrapReactive(this.#reactive);
+
+            if (actual === lastValue && getCount === lastGetCount) {
+              QUnit.assert.ok(true, `fresh: the reactive value hasn't changed`);
+              lastValue = actual;
+              this.#noop(actual);
+            } else {
+              if (actual !== lastValue && getCount !== lastGetCount) {
+                QUnit.assert.ok(false, `fresh: the reactive value is not fresh`);
+              } else {
+                QUnit.assert.strictEqual(
+                  actual,
+                  lastValue,
+                  `fresh: the reactive value hasn't changed`
+                );
+                QUnit.assert.strictEqual(
+                  getCount,
+                  lastGetCount,
+                  `fresh: the counter hasn't changed`
+                );
+              }
+
+              lastGetCount = getCount;
+              lastSetCount = setCount;
+            }
+          },
+          updated: (value: T, message?: string) => {
+            const actual = unwrapReactive(this.#reactive);
+
+            if (getCount !== lastGetCount && lastSetCount === setCount + 1) {
+              QUnit.assert.strictEqual(
+                actual,
+                value,
+                `updated: ${message ?? 'the new reactive value'}`
+              );
+            } else {
+              QUnit.assert.deepEqual(
+                { get: getCount, set: setCount },
+                { get: lastGetCount + 1, set: lastSetCount + 1 },
+                `stale: ${message} (get and set were called)`
+              );
+              lastValue = actual;
+              this.#noop(actual);
+            }
+
+            lastGetCount = getCount;
+            lastSetCount = setCount;
+          },
+          stale: (value: T, message?: string) => {
+            const actual = unwrapReactive(this.#reactive);
+
+            if (getCount !== lastGetCount && lastSetCount === setCount) {
+              QUnit.assert.strictEqual(
+                actual,
+                value,
+                `stale: ${message ?? 'the new reactive value'}`
+              );
+              lastValue = actual;
+              this.#noop(actual);
+            } else {
+              QUnit.assert.deepEqual(
+                { get: getCount, set: setCount },
+                { get: lastGetCount + 1, set: lastSetCount },
+                `stale: ${message} (get was called, but set was not)`
+              );
+            }
+
+            lastGetCount = getCount;
+            lastSetCount = setCount;
+          },
+        };
+      }
 
-  module('const ref', () => {
-    test('it works', (assert) => {
-      let value = {};
-      let constRef = createConstRef(value, 'test');
+      #noop(lastValue: T) {
+        const lastGetCount = getCount;
+        const lastSetCount = setCount;
 
-      assert.strictEqual(valueForRef(constRef), value, 'value is correct');
-      assert.notOk(isUpdatableRef(constRef), 'value is not updatable');
-    });
+        const value = unwrapReactive(this.#reactive);
 
-    test('can create children of const refs', (assert) => {
-      class Parent {
-        @tracked child = 123;
+        if (value === lastValue && getCount === lastGetCount && setCount === lastSetCount) {
+          return;
+        } else {
+          QUnit.assert.deepEqual(
+            { get: getCount, set: setCount },
+            { get: lastGetCount, set: lastSetCount },
+            `Expected a second read to the reactive value to make 0 calls and 0 sets`
+          );
+        }
       }
+    }
 
-      let parent = new Parent();
+    module('const ref', () => {
+      test('it works', (assert) => {
+        let value = {};
+        let constRef = ReadonlyCell(value, 'test');
 
-      let constRef = createConstRef(parent, 'test');
-      let childRef = childRefFor(constRef, 'child');
+        assert.strictEqual(unwrapReactive(constRef), value, 'value is correct');
+        assert.notOk(isUpdatableRef(constRef), 'value is not updatable');
+      });
 
-      assert.strictEqual(valueForRef(childRef), 123, 'value is correct');
-      assert.strictEqual(valueForRef(childRef), 123, 'value is correct');
-      assert.strictEqual(getCount, 1, 'get called correct number of times');
+      test('can create children of const refs', (assert) => {
+        class Parent {
+          @tracked child = 123;
+        }
 
-      parent.child = 456;
+        let parent = new Parent();
 
-      assert.strictEqual(valueForRef(childRef), 456, 'value updated correctly');
-      assert.strictEqual(valueForRef(childRef), 456, 'value is correct');
-      assert.strictEqual(getCount, 2, 'get called correct number of times');
+        let constRef = ReadonlyCell(parent, 'test');
+        let childRef = getReactiveProperty(constRef, 'child');
+        const validChild = new Validatable(childRef).token();
 
-      assert.true(isUpdatableRef(childRef), 'childRef is updatable');
+        assert.strictEqual(unwrapReactive(childRef), 123, 'value is correct');
+        assert.strictEqual(unwrapReactive(childRef), 123, 'value is correct');
+        assert.strictEqual(getCount, 1, 'get called correct number of times');
 
-      updateRef(childRef, 789);
+        parent.child = 456;
+        validChild.stale(456, 'value updated correctly');
 
-      assert.strictEqual(valueForRef(childRef), 789, 'value updated correctly');
-      assert.strictEqual(getCount, 3, 'get called correct number of times');
-      assert.strictEqual(setCount, 1, 'set called correct number of times');
+        assert.true(isUpdatableRef(childRef), 'childRef is updatable');
+
+        updateReactive(childRef, 789);
+        validChild.updated(789, 'value updated correctly');
+      });
     });
-  });
 
-  module('compute ref', () => {
-    test('compute reference caches computation', (assert) => {
-      let count = 0;
+    module('compute ref', () => {
+      test('compute reference caches computation', (assert) => {
+        let count = 0;
 
-      let dict = new TrackedDict<string>();
-      let ref = createComputeRef(() => {
-        count++;
-        return dict.get('foo');
-      });
+        let dict = new TrackedDict<string>();
+        let ref = Formula(() => {
+          count++;
+          return dict.get('foo');
+        });
 
-      dict.set('foo', 'bar');
+        dict.set('foo', 'bar');
 
-      assert.strictEqual(count, 0, 'precond');
+        assert.strictEqual(count, 0, 'precond');
 
-      assert.strictEqual(valueForRef(ref), 'bar');
-      assert.strictEqual(valueForRef(ref), 'bar');
-      assert.strictEqual(valueForRef(ref), 'bar');
+        assert.strictEqual(unwrapReactive(ref), 'bar');
+        assert.strictEqual(unwrapReactive(ref), 'bar');
+        assert.strictEqual(unwrapReactive(ref), 'bar');
 
-      assert.strictEqual(count, 1, 'computed');
+        assert.strictEqual(count, 1, 'computed');
 
-      dict.set('foo', 'BAR');
+        dict.set('foo', 'BAR');
 
-      assert.strictEqual(valueForRef(ref), 'BAR');
-      assert.strictEqual(valueForRef(ref), 'BAR');
-      assert.strictEqual(valueForRef(ref), 'BAR');
+        assert.strictEqual(unwrapReactive(ref), 'BAR');
+        assert.strictEqual(unwrapReactive(ref), 'BAR');
+        assert.strictEqual(unwrapReactive(ref), 'BAR');
 
-      assert.strictEqual(count, 2, 'computed');
+        assert.strictEqual(count, 2, 'computed');
 
-      dict.set('baz', 'bat');
+        dict.set('baz', 'bat');
 
-      assert.strictEqual(valueForRef(ref), 'BAR');
-      assert.strictEqual(valueForRef(ref), 'BAR');
-      assert.strictEqual(valueForRef(ref), 'BAR');
+        assert.strictEqual(unwrapReactive(ref), 'BAR');
+        assert.strictEqual(unwrapReactive(ref), 'BAR');
+        assert.strictEqual(unwrapReactive(ref), 'BAR');
 
-      assert.strictEqual(count, 3, 'computed');
+        assert.strictEqual(count, 3, 'computed');
 
-      dict.set('foo', 'bar');
+        dict.set('foo', 'bar');
 
-      assert.strictEqual(valueForRef(ref), 'bar');
-      assert.strictEqual(valueForRef(ref), 'bar');
-      assert.strictEqual(valueForRef(ref), 'bar');
+        assert.strictEqual(unwrapReactive(ref), 'bar');
+        assert.strictEqual(unwrapReactive(ref), 'bar');
+        assert.strictEqual(unwrapReactive(ref), 'bar');
 
-      assert.strictEqual(count, 4, 'computed');
-    });
+        assert.strictEqual(count, 4, 'computed');
+      });
 
-    test('compute refs cache nested computation correctly', (assert) => {
-      let count = 0;
+      test('compute refs cache nested computation correctly', (assert) => {
+        let count = 0;
 
-      let first = new TrackedDict<string>();
-      let second = new TrackedDict<string>();
+        let first = new TrackedDict<string>();
+        let second = new TrackedDict<string>();
 
-      let innerRef = createComputeRef(() => {
-        count++;
-        return first.get('foo');
-      });
-      let outerRef = createComputeRef(() => valueForRef(innerRef));
+        let innerRef = Formula(() => {
+          count++;
+          return first.get('foo');
+        });
+        let outerRef = Formula(() => unwrapReactive(innerRef));
 
-      first.set('foo', 'bar');
+        first.set('foo', 'bar');
 
-      assert.strictEqual(count, 0, 'precond');
+        assert.strictEqual(count, 0, 'precond');
 
-      assert.strictEqual(valueForRef(outerRef), 'bar');
-      assert.strictEqual(valueForRef(outerRef), 'bar');
-      assert.strictEqual(valueForRef(outerRef), 'bar');
+        assert.strictEqual(unwrapReactive(outerRef), 'bar');
+        assert.strictEqual(unwrapReactive(outerRef), 'bar');
+        assert.strictEqual(unwrapReactive(outerRef), 'bar');
 
-      assert.strictEqual(count, 1, 'computed');
+        assert.strictEqual(count, 1, 'computed');
 
-      second.set('foo', 'BAR');
+        second.set('foo', 'BAR');
 
-      assert.strictEqual(valueForRef(outerRef), 'bar');
-      assert.strictEqual(valueForRef(outerRef), 'bar');
-      assert.strictEqual(valueForRef(outerRef), 'bar');
+        assert.strictEqual(unwrapReactive(outerRef), 'bar');
+        assert.strictEqual(unwrapReactive(outerRef), 'bar');
+        assert.strictEqual(unwrapReactive(outerRef), 'bar');
 
-      assert.strictEqual(count, 1, 'computed');
+        assert.strictEqual(count, 1, 'computed');
 
-      first.set('foo', 'BAR');
+        first.set('foo', 'BAR');
 
-      assert.strictEqual(valueForRef(outerRef), 'BAR');
-      assert.strictEqual(valueForRef(outerRef), 'BAR');
-      assert.strictEqual(valueForRef(outerRef), 'BAR');
+        assert.strictEqual(unwrapReactive(outerRef), 'BAR');
+        assert.strictEqual(unwrapReactive(outerRef), 'BAR');
+        assert.strictEqual(unwrapReactive(outerRef), 'BAR');
 
-      assert.strictEqual(count, 2, 'computed');
-    });
+        assert.strictEqual(count, 2, 'computed');
+      });
 
-    test('can create children of compute refs', (assert) => {
-      class Child {
-        @tracked value = 123;
-      }
+      test('can create children of compute refs', (assert) => {
+        class Child {
+          @tracked value = 123;
+        }
 
-      class Parent {
-        @tracked child = new Child();
-      }
+        class Parent {
+          @tracked child = new Child();
+        }
 
-      let parent = new Parent();
+        let parent = new Parent();
 
-      let computeRef = createComputeRef(() => parent.child);
-      let valueRef = childRefFor(computeRef, 'value');
+        let computeRef = Formula(() => parent.child);
+        let valueRef = getReactiveProperty(computeRef, 'value');
 
-      assert.strictEqual(valueForRef(valueRef), 123, 'value is correct');
-      assert.strictEqual(valueForRef(valueRef), 123, 'value is correct');
-      assert.strictEqual(getCount, 1, 'get called correct number of times');
+        assert.strictEqual(unwrapReactive(valueRef), 123, 'value is correct');
+        assert.strictEqual(unwrapReactive(valueRef), 123, 'value is correct');
+        assert.strictEqual(getCount, 1, 'get called correct number of times');
 
-      parent.child.value = 456;
+        parent.child.value = 456;
 
-      assert.strictEqual(valueForRef(valueRef), 456, 'value updated correctly');
-      assert.strictEqual(valueForRef(valueRef), 456, 'value is correct');
-      assert.strictEqual(getCount, 2, 'get called correct number of times');
+        assert.strictEqual(unwrapReactive(valueRef), 456, 'value updated correctly');
+        assert.strictEqual(unwrapReactive(valueRef), 456, 'value is correct');
+        assert.strictEqual(getCount, 2, 'get called correct number of times');
 
-      assert.true(isUpdatableRef(valueRef), 'childRef is updatable');
+        assert.true(isUpdatableRef(valueRef), 'childRef is updatable');
 
-      updateRef(valueRef, 789);
+        updateReactive(valueRef, 789);
 
-      assert.strictEqual(valueForRef(valueRef), 789, 'value updated correctly');
-      assert.strictEqual(getCount, 3, 'get called correct number of times');
-      assert.strictEqual(setCount, 1, 'set called correct number of times');
+        assert.strictEqual(unwrapReactive(valueRef), 789, 'value updated correctly');
+        assert.strictEqual(getCount, 3, 'get called correct number of times');
+        assert.strictEqual(setCount, 1, 'set called correct number of times');
 
-      parent.child = new Child();
+        parent.child = new Child();
 
-      assert.strictEqual(valueForRef(valueRef), 123, 'value updated correctly when parent changes');
-      assert.strictEqual(getCount, 4, 'get called correct number of times');
+        assert.strictEqual(
+          unwrapReactive(valueRef),
+          123,
+          'value updated correctly when parent changes'
+        );
+        assert.strictEqual(getCount, 4, 'get called correct number of times');
+      });
     });
-  });
 
-  module('unbound ref', () => {
-    test('it works', (assert) => {
-      let value = {};
-      let constRef = createUnboundRef(value, 'test');
+    module('deeply constant', () => {
+      test('it works', (assert) => {
+        let value = {};
+        let constRef = DeeplyReadonlyCell(value, 'test');
 
-      assert.strictEqual(valueForRef(constRef), value, 'value is correct');
-      assert.notOk(isUpdatableRef(constRef), 'value is not updatable');
-    });
+        assert.strictEqual(unwrapReactive(constRef), value, 'value is correct');
+        assert.notOk(isUpdatableRef(constRef), 'value is not updatable');
+      });
 
-    test('children of unbound refs are not reactive', (assert) => {
-      class Parent {
-        @tracked child = 123;
-      }
+      test('children of deeply constant values are deeply constant', (assert) => {
+        class Parent {
+          @tracked child = 123;
+        }
 
-      let parent = new Parent();
+        let parent = new Parent();
 
-      let constRef = createUnboundRef(parent, 'test');
-      let childRef = childRefFor(constRef, 'child');
+        let constRef = DeeplyReadonlyCell(parent, 'test');
+        let childRef = getReactiveProperty(constRef, 'child');
 
-      assert.strictEqual(valueForRef(childRef), 123, 'value is correct');
+        assert.strictEqual(unwrapReactive(childRef), 123, 'value is correct');
 
-      parent.child = 456;
+        parent.child = 456;
 
-      assert.strictEqual(valueForRef(childRef), 123, 'value updated correctly');
+        assert.strictEqual(unwrapReactive(childRef), 123, 'value updated correctly');
+      });
     });
-  });
 
-  module('invokable ref', () => {
-    test('can create invokable refs', (assert) => {
-      let ref = createComputeRef(
-        () => {},
-        () => {}
-      );
+    module('accessor', () => {
+      test('can create accessors', (assert) => {
+        // let ref = FallibleFormula(() => {});
 
-      let invokableRef = createInvokableRef(ref);
+        let accessor = Accessor({
+          get: () => {},
+          set: () => {},
+        });
 
-      assert.ok(isInvokableRef(invokableRef));
-    });
+        assert.ok(isAccessor(accessor));
+      });
 
-    test('can create children of invokable refs', (assert) => {
-      class Child {
-        @tracked value = 123;
-      }
+      test('can create children of invokable refs', (assert) => {
+        class Child {
+          @tracked value = 123;
+        }
 
-      class Parent {
-        @tracked child = new Child();
-      }
+        class Parent {
+          @tracked child = new Child();
+        }
 
-      let parent = new Parent();
+        let parent = new Parent();
 
-      let computeRef = createComputeRef(
-        () => parent.child,
-        (value) => (parent.child = value)
-      );
-      let invokableRef = createInvokableRef(computeRef);
-      let valueRef = childRefFor(invokableRef, 'value');
+        let invokableRef = Accessor({
+          get: () => parent.child,
+          set: (value: Child) => (parent.child = value),
+        });
+        // let invokableRef = formulaToAccessor(computeRef);
+        let valueRef = getReactiveProperty(invokableRef, 'value');
 
-      assert.strictEqual(valueForRef(valueRef), 123, 'value is correct');
-      assert.strictEqual(valueForRef(valueRef), 123, 'value is correct');
-      assert.strictEqual(getCount, 1, 'get called correct number of times');
+        assert.strictEqual(unwrapReactive(valueRef), 123, 'value is correct');
+        assert.strictEqual(unwrapReactive(valueRef), 123, 'value is correct');
+        assert.strictEqual(getCount, 1, 'get called correct number of times');
 
-      parent.child.value = 456;
+        parent.child.value = 456;
 
-      assert.strictEqual(valueForRef(valueRef), 456, 'value updated correctly');
-      assert.strictEqual(valueForRef(valueRef), 456, 'value is correct');
-      assert.strictEqual(getCount, 2, 'get called correct number of times');
+        assert.strictEqual(unwrapReactive(valueRef), 456, 'value updated correctly');
+        assert.strictEqual(unwrapReactive(valueRef), 456, 'value is correct');
+        assert.strictEqual(getCount, 2, 'get called correct number of times');
 
-      assert.true(isUpdatableRef(valueRef), 'childRef is updatable');
+        assert.true(isUpdatableRef(valueRef), 'childRef is updatable');
 
-      updateRef(valueRef, 789);
+        updateReactive(valueRef, 789);
 
-      assert.strictEqual(valueForRef(valueRef), 789, 'value updated correctly');
-      assert.strictEqual(getCount, 3, 'get called correct number of times');
-      assert.strictEqual(setCount, 1, 'set called correct number of times');
+        assert.strictEqual(unwrapReactive(valueRef), 789, 'value updated correctly');
+        assert.strictEqual(getCount, 3, 'get called correct number of times');
+        assert.strictEqual(setCount, 1, 'set called correct number of times');
 
-      parent.child = new Child();
+        parent.child = new Child();
 
-      assert.strictEqual(valueForRef(valueRef), 123, 'value updated correctly when parent changes');
-      assert.strictEqual(getCount, 4, 'get called correct number of times');
+        assert.strictEqual(
+          unwrapReactive(valueRef),
+          123,
+          'value updated correctly when parent changes'
+        );
+        assert.strictEqual(getCount, 4, 'get called correct number of times');
+      });
     });
-  });
-
-  module('read only ref', () => {
-    test('can convert an updatable ref to read only', (assert) => {
-      class Parent {
-        @tracked child = 123;
-      }
 
-      let parent = new Parent();
+    module('mut ref', () => {
+      test('can convert a readonly ref to mut', (assert) => {
+        const ref = ReadonlyCell(123);
+        const mutable = toMut(ref);
+        assert.notOk(isUpdatableRef(ref), 'original ref is not updatable');
 
-      let computeRef = createComputeRef(
-        () => parent.child,
-        (value) => (parent.child = value)
-      );
+        assert.ok(isUpdatableRef(mutable), 'mutable ref is updatable');
+      });
 
-      let readOnlyRef = createReadOnlyRef(computeRef);
+      test("can mutate a mut ref's value", (assert) => {
+        const ref = MutableCell(123);
+        const mutable = toMut(ref);
 
-      assert.ok(isUpdatableRef(computeRef), 'original ref is updatable');
-      assert.notOk(isUpdatableRef(readOnlyRef), 'read only ref is not updatable');
+        updateReactive(mutable, 456);
+        assert.strictEqual(unwrapReactive(mutable), 456, 'mut wrapper was updated');
+        assert.strictEqual(unwrapReactive(ref), 456, 'original reactive was updated');
+      });
     });
 
-    test('can create children of read only refs', (assert) => {
-      class Child {
-        @tracked value = 123;
-      }
+    module('read only ref', () => {
+      test('can convert an updatable ref to read only', (assert) => {
+        class Parent {
+          @tracked child = 123;
+        }
 
-      class Parent {
-        @tracked child = new Child();
-      }
+        let parent = new Parent();
+
+        let computeRef = Accessor({
+          get: () => parent.child,
+          set: (value: number) => (parent.child = value),
+        });
 
-      let parent = new Parent();
+        let readOnlyRef = toReadonly(computeRef);
 
-      let computeRef = createComputeRef(
-        () => parent.child,
-        (value) => (parent.child = value)
-      );
-      let readOnlyRef = createReadOnlyRef(computeRef);
-      let valueRef = childRefFor(readOnlyRef, 'value');
+        assert.ok(isUpdatableRef(computeRef), 'original ref is updatable');
+        assert.notOk(isUpdatableRef(readOnlyRef), 'read only ref is not updatable');
+      });
 
-      assert.strictEqual(valueForRef(valueRef), 123, 'value is correct');
-      assert.strictEqual(valueForRef(valueRef), 123, 'value is correct');
-      assert.strictEqual(getCount, 1, 'get called correct number of times');
+      test('can create children of read only refs', (assert) => {
+        class Child {
+          @tracked value = 123;
+        }
 
-      parent.child.value = 456;
+        class Parent {
+          @tracked child = new Child();
+        }
 
-      assert.strictEqual(valueForRef(valueRef), 456, 'value updated correctly');
-      assert.strictEqual(valueForRef(valueRef), 456, 'value is correct');
-      assert.strictEqual(getCount, 2, 'get called correct number of times');
+        let parent = new Parent();
 
-      assert.true(isUpdatableRef(valueRef), 'childRef is updatable');
+        let computeRef = Accessor({
+          get: () => parent.child,
+          set: (value: Child) => (parent.child = value),
+        });
+        let readOnlyRef = toReadonly(computeRef);
+        let valueRef = getReactiveProperty(readOnlyRef, 'value');
 
-      updateRef(valueRef, 789);
+        assert.strictEqual(unwrapReactive(valueRef), 123, 'value is correct');
+        assert.strictEqual(unwrapReactive(valueRef), 123, 'value is correct');
+        assert.strictEqual(getCount, 1, 'get called correct number of times');
 
-      assert.strictEqual(valueForRef(valueRef), 789, 'value updated correctly');
-      assert.strictEqual(getCount, 3, 'get called correct number of times');
-      assert.strictEqual(setCount, 1, 'set called correct number of times');
+        parent.child.value = 456;
 
-      parent.child = new Child();
+        assert.strictEqual(unwrapReactive(valueRef), 456, 'value updated correctly');
+        assert.strictEqual(unwrapReactive(valueRef), 456, 'value is correct');
+        assert.strictEqual(getCount, 2, 'get called correct number of times');
 
-      assert.strictEqual(valueForRef(valueRef), 123, 'value updated correctly when parent changes');
-      assert.strictEqual(getCount, 4, 'get called correct number of times');
-    });
-  });
+        assert.true(isUpdatableRef(valueRef), 'childRef is updatable');
 
-  if (import.meta.env.DEV) {
-    module('debugAliasRef', () => {
-      test('debug alias refs are transparent', (assert) => {
-        class Foo {
-          @tracked value = 123;
-        }
+        updateReactive(valueRef, 789);
 
-        let foo = new Foo();
+        assert.strictEqual(unwrapReactive(valueRef), 789, 'value updated correctly');
+        assert.strictEqual(getCount, 3, 'get called correct number of times');
+        assert.strictEqual(setCount, 1, 'set called correct number of times');
 
-        let original = createComputeRef(
-          () => foo.value,
-          (newValue) => (foo.value = newValue)
+        parent.child = new Child();
+
+        assert.strictEqual(
+          unwrapReactive(valueRef),
+          123,
+          'value updated correctly when parent changes'
         );
+        assert.strictEqual(getCount, 4, 'get called correct number of times');
+      });
+    });
+
+    if (import.meta.env.DEV) {
+      module('debugAliasRef', () => {
+        test('debug alias refs are transparent', (assert) => {
+          class Foo {
+            @tracked value = 123;
+          }
+
+          let foo = new Foo();
 
-        let alias = unwrap(createDebugAliasRef)('@test', original);
+          let original = Accessor({
+            get: () => foo.value,
+            set: (newValue) => (foo.value = newValue),
+          });
 
-        assert.strictEqual(valueForRef(original), 123, 'alias returns correct value');
-        assert.strictEqual(valueForRef(alias), 123, 'alias returns correct value');
-        assert.ok(isUpdatableRef(alias), 'alias is updatable');
+          let alias = createDebugAliasRef(original, () => '@test');
 
-        updateRef(alias, 456);
+          assert.strictEqual(unwrapReactive(original), 123, 'alias returns correct value');
+          assert.strictEqual(unwrapReactive(alias), 123, 'alias returns correct value');
+          assert.ok(isUpdatableRef(alias), 'alias is updatable');
 
-        assert.strictEqual(valueForRef(original), 456, 'alias returns correct value');
-        assert.strictEqual(valueForRef(alias), 456, 'alias returns correct value');
+          updateReactive(alias, 456);
 
-        let readOnly = createReadOnlyRef(original);
-        let readOnlyAlias = unwrap(createDebugAliasRef)('@test', readOnly);
+          assert.strictEqual(unwrapReactive(original), 456, 'alias returns correct value');
+          assert.strictEqual(unwrapReactive(alias), 456, 'alias returns correct value');
 
-        assert.strictEqual(valueForRef(readOnly), 456, 'alias returns correct value');
-        assert.strictEqual(valueForRef(readOnlyAlias), 456, 'alias returns correct value');
-        assert.notOk(isUpdatableRef(readOnly), 'alias is not updatable');
+          let readOnly = toReadonly(original);
+          let readOnlyAlias = createDebugAliasRef(readOnly, () => '@test');
 
-        let invokable = createInvokableRef(original);
-        let invokableAlias = unwrap(createDebugAliasRef)('@test', invokable);
+          assert.strictEqual(unwrapReactive(readOnly), 456, 'alias returns correct value');
+          assert.strictEqual(unwrapReactive(readOnlyAlias), 456, 'alias returns correct value');
+          assert.notOk(isUpdatableRef(readOnly), 'alias is not updatable');
 
-        assert.ok(isInvokableRef(invokableAlias), 'alias is invokable');
+          let invokableAlias = createDebugAliasRef(original, () => '@test');
+
+          assert.ok(isAccessor(invokableAlias), 'alias is invokable');
+        });
       });
-    });
-  }
+    }
+  });
 });
diff --git a/packages/@glimmer/reference/test/utils/template.ts b/packages/@glimmer/reference/test/utils/template.ts
index bdea6b3381..133432b614 100644
--- a/packages/@glimmer/reference/test/utils/template.ts
+++ b/packages/@glimmer/reference/test/utils/template.ts
@@ -1,3 +1,4 @@
+import type { GlobalContext } from '@glimmer/global-context';
 import type { IteratorDelegate } from '@glimmer/reference';
 
 import objectValues from './platform';
@@ -45,7 +46,10 @@ class ObjectIterator extends BoundedIterator {
     return new this(keys, values);
   }
 
-  constructor(private keys: unknown[], private values: unknown[]) {
+  constructor(
+    private keys: unknown[],
+    private values: unknown[]
+  ) {
     super(values.length);
   }
 
@@ -78,4 +82,4 @@ export const TestContext = {
 
     return null;
   },
-};
+} satisfies Partial<GlobalContext>;
diff --git a/packages/@glimmer/reference/test/utils/validate.ts b/packages/@glimmer/reference/test/utils/validate.ts
new file mode 100644
index 0000000000..41e4ef6381
--- /dev/null
+++ b/packages/@glimmer/reference/test/utils/validate.ts
@@ -0,0 +1,70 @@
+import type { Reactive } from '@glimmer/interfaces';
+import { hasError, unwrapReactive, validateReactive } from '@glimmer/reference';
+
+export class Validate<T> {
+  readonly #reference: Reactive<T>;
+
+  constructor(reactive: Reactive<T>) {
+    this.#reference = reactive;
+  }
+
+  assertingStaleError(expected: RegExp): void {
+    this.#assertingStaleError(expected);
+    this.#assertingFreshError(expected, `immediately after throwing`);
+  }
+
+  assertingFreshError(expected: RegExp): void {
+    this.#assertingFreshError(expected);
+    this.#assertingFreshError(expected, `immediately after a fresh error`);
+  }
+
+  #assertingStaleError(expected: RegExp): void {
+    QUnit.assert.ok(this.isStale, `expected reference to be stale`);
+    QUnit.assert.throws(() => this.value, expected, `expected reference to throw`);
+    QUnit.assert.true(hasError(this.#reference), `expected reference to return true from hasError`);
+  }
+
+  #assertingFreshError(expected: RegExp, message?: string): void {
+    QUnit.assert.ok(!this.isStale, `expected reference to be fresh`);
+    QUnit.assert.throws(
+      () => this.value,
+      expected,
+      `${message ? `${message}: ` : ''}expected reference to throw`
+    );
+    QUnit.assert.true(hasError(this.#reference), `expected reference to return true from hasError`);
+  }
+
+  assertingStale(value: T, description: string): void {
+    QUnit.assert.true(this.isStale, `expected reference (${description}) to be stale`);
+    QUnit.assert.strictEqual(
+      this.value,
+      value,
+      `expected value (${description}) to be ${JSON.stringify(value)}`
+    );
+    QUnit.assert.false(
+      hasError(this.#reference),
+      `expected reference (${description}) to return false from hasError`
+    );
+  }
+
+  assertingFresh(value: T, description: string): void {
+    QUnit.assert.false(this.isStale, `expected reference (${description}) to be fresh`);
+    QUnit.assert.strictEqual(
+      this.value,
+      value,
+      `expected value (${description}) to be ${JSON.stringify(value)}}`
+    );
+    QUnit.assert.false(
+      hasError(this.#reference),
+      `expected reference (${description}) to return false from hasError`
+    );
+  }
+
+  get isStale() {
+    return !validateReactive(this.#reference);
+  }
+
+  get value() {
+    return unwrapReactive(this.#reference);
+  }
+}
diff --git a/packages/@glimmer/runtime/index.ts b/packages/@glimmer/runtime/index.ts
index 782461744b..32a79a4cb1 100644
--- a/packages/@glimmer/runtime/index.ts
+++ b/packages/@glimmer/runtime/index.ts
@@ -1,9 +1,10 @@
 /**
  * @deprecated use RichIteratorResult<Tick, Return> or TemplateIterator instead
  */
-import type { RichIteratorResult } from '@glimmer/interfaces';
 import './lib/bootstrap';
 
+import type { RichIteratorResult } from '@glimmer/interfaces';
+
 export { clear, ConcreteBounds, CursorImpl } from './lib/bounds';
 export {
   type DebugCallback,
@@ -55,6 +56,7 @@ export {
   dynamicAttribute,
   SimpleDynamicAttribute,
 } from './lib/vm/attributes/dynamic';
+export { AbstractElementBuilder } from './lib/vm/element-builder';
 export {
   clientBuilder,
   NewElementBuilder,
@@ -67,6 +69,7 @@ export {
   rehydrationBuilder,
   SERIALIZATION_FIRST_NODE_STRING,
 } from './lib/vm/rehydrate-builder';
+export * from './lib/vm/unwind';
 
 // Currently we need to re-export these values for @glimmer/component
 // https://github.com/glimmerjs/glimmer.js/issues/319
diff --git a/packages/@glimmer/runtime/lib/bounds.ts b/packages/@glimmer/runtime/lib/bounds.ts
index 93a936bd95..db580b860e 100644
--- a/packages/@glimmer/runtime/lib/bounds.ts
+++ b/packages/@glimmer/runtime/lib/bounds.ts
@@ -1,17 +1,20 @@
-import type { Bounds, Cursor, Nullable, SimpleElement, SimpleNode } from '@glimmer/interfaces';
+import type { BlockBounds, Cursor, Nullable, SimpleElement, SimpleNode } from '@glimmer/interfaces';
 import { expect } from '@glimmer/util';
 
 export class CursorImpl implements Cursor {
-  constructor(public element: SimpleElement, public nextSibling: Nullable<SimpleNode>) {}
+  constructor(
+    public element: SimpleElement,
+    public nextSibling: Nullable<SimpleNode>
+  ) {}
 }
 
-export type DestroyableBounds = Bounds;
+export type DestroyableBounds = BlockBounds;
 
-export class ConcreteBounds implements Bounds {
+export class ConcreteBounds implements BlockBounds {
   constructor(
     public parentNode: SimpleElement,
-    private first: SimpleNode,
-    private last: SimpleNode
+    readonly first: SimpleNode,
+    readonly last: SimpleNode
   ) {}
 
   parentElement(): SimpleElement {
@@ -27,8 +30,16 @@ export class ConcreteBounds implements Bounds {
   }
 }
 
-export class SingleNodeBounds implements Bounds {
-  constructor(private parentNode: SimpleElement, private node: SimpleNode) {}
+export class SingleNodeBounds implements BlockBounds {
+  readonly first: SimpleNode;
+  readonly last: SimpleNode;
+
+  constructor(
+    private parentNode: SimpleElement,
+    private node: SimpleNode
+  ) {
+    this.first = this.last = node;
+  }
 
   parentElement(): SimpleElement {
     return this.parentNode;
@@ -43,7 +54,7 @@ export class SingleNodeBounds implements Bounds {
   }
 }
 
-export function move(bounds: Bounds, reference: Nullable<SimpleNode>): Nullable<SimpleNode> {
+export function move(bounds: BlockBounds, reference: Nullable<SimpleNode>): Nullable<SimpleNode> {
   let parent = bounds.parentElement();
   let first = bounds.firstNode();
   let last = bounds.lastNode();
@@ -64,16 +75,31 @@ export function move(bounds: Bounds, reference: Nullable<SimpleNode>): Nullable<
   }
 }
 
-export function clear(bounds: Bounds): Nullable<SimpleNode> {
+export function clear(bounds: BlockBounds): Nullable<SimpleNode> {
   let parent = bounds.parentElement();
   let first = bounds.firstNode();
   let last = bounds.lastNode();
 
-  let current: SimpleNode = first;
+  return clearRange({ parent, first, last });
+}
 
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    let next = current.nextSibling;
+export function clearRange({
+  parent,
+  first,
+  last,
+}: {
+  parent: SimpleElement;
+  first: Nullable<SimpleNode>;
+  last: Nullable<SimpleNode>;
+}): Nullable<SimpleNode> {
+  let current: Nullable<SimpleNode> = first ?? parent.firstChild;
+
+  if (!current) {
+    return null;
+  }
+
+  while (current) {
+    const next: Nullable<SimpleNode> = current.nextSibling;
 
     parent.removeChild(current);
 
@@ -81,6 +107,8 @@ export function clear(bounds: Bounds): Nullable<SimpleNode> {
       return next;
     }
 
-    current = expect(next, 'invalid bounds');
+    current = next;
   }
+
+  return null;
 }
diff --git a/packages/@glimmer/runtime/lib/compat/svg-inner-html-fix.ts b/packages/@glimmer/runtime/lib/compat/svg-inner-html-fix.ts
index 4fc42f61a9..2b6e6dfbe7 100644
--- a/packages/@glimmer/runtime/lib/compat/svg-inner-html-fix.ts
+++ b/packages/@glimmer/runtime/lib/compat/svg-inner-html-fix.ts
@@ -1,5 +1,5 @@
 import type {
-  Bounds,
+  BlockBounds,
   Nullable,
   SimpleDocument,
   SimpleElement,
@@ -15,7 +15,9 @@ import {
   unwrap,
 } from '@glimmer/util';
 
-import { type DOMOperations, moveNodesBefore } from '../dom/operations';
+import type {DOMOperations} from '../dom/operations';
+
+import {  moveNodesBefore } from '../dom/operations';
 
 export enum InsertPosition {
   beforebegin = 'beforebegin',
@@ -53,7 +55,7 @@ export function applySVGInnerHTMLFix(
       parent: SimpleElement,
       nextSibling: Nullable<SimpleNode>,
       html: string
-    ): Bounds {
+    ): BlockBounds {
       if (html === '') {
         return super.insertHTMLBefore(parent, nextSibling, html);
       }
@@ -72,7 +74,7 @@ function fixSVG(
   div: SimpleElement,
   html: string,
   reference: Nullable<SimpleNode>
-): Bounds {
+): BlockBounds {
   assert(html !== '', 'html cannot be empty');
 
   let source: SimpleNode;
diff --git a/packages/@glimmer/runtime/lib/compat/text-node-merging-fix.ts b/packages/@glimmer/runtime/lib/compat/text-node-merging-fix.ts
index f42f8dc289..bc05c3f8d9 100644
--- a/packages/@glimmer/runtime/lib/compat/text-node-merging-fix.ts
+++ b/packages/@glimmer/runtime/lib/compat/text-node-merging-fix.ts
@@ -1,5 +1,5 @@
 import type {
-  Bounds,
+  BlockBounds,
   Nullable,
   SimpleComment,
   SimpleDocument,
@@ -44,7 +44,7 @@ export function applyTextNodeMergingFix(
       parent: SimpleElement,
       nextSibling: Nullable<SimpleNode>,
       html: string
-    ): Bounds {
+    ): BlockBounds {
       if (html === '') {
         return super.insertHTMLBefore(parent, nextSibling, html);
       }
diff --git a/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts b/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts
index 76bfc7e9b2..4ade25e519 100644
--- a/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts
+++ b/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts
@@ -1,25 +1,35 @@
-import type { Dict, Maybe } from "@glimmer/interfaces";
-import { createComputeRef, type Reference, valueForRef } from '@glimmer/reference';
-import { enumerate } from '@glimmer/util';
+import type { Dict, Maybe } from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
+import { readReactive, ResultFormula  } from '@glimmer/reference';
+import { enumerate, Ok, stringifyDebugLabel } from '@glimmer/util';
 
-export function createConcatRef(partsRefs: Reference[]) {
-  return createComputeRef(() => {
-    let parts = new Array<string>();
+export function createConcatRef(partsRefs: Reactive[]) {
+  return ResultFormula(
+    () => {
+      let parts = new Array<string>();
 
-    for (const [i, ref] of enumerate(partsRefs)) {
-      let value = valueForRef(ref) as Maybe<Dict>;
+      for (const [i, ref] of enumerate(partsRefs)) {
+        let result = readReactive(ref);
 
-      if (value !== null && value !== undefined) {
-        parts[i] = castToString(value);
+        if (result.type === 'err') {
+          return result;
+        }
+
+        const value = result.value as Maybe<Dict>;
+        if (value !== null && value !== undefined) {
+          parts[i] = castToString(value);
+        }
       }
-    }
 
-    if (parts.length > 0) {
-      return parts.join('');
-    }
+      return Ok(parts.length > 0 ? parts.join('') : null);
+    },
+    import.meta.env.DEV ? concatLabel(partsRefs) : undefined
+  );
+}
 
-    return null;
-  });
+function concatLabel(parts: Reactive[]) {
+  const body = parts.map((reactive) => `{${stringifyDebugLabel(reactive)}}`).join(' + ');
+  return `(concat ${body})`;
 }
 
 function castToString(value: Dict) {
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts
index 81f50f387a..904c665f66 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts
@@ -1,43 +1,44 @@
+import type {Checker} from '@glimmer/debug';
+import type {
+  BlockMetadata,
+  CapabilityMask,
+  CapturedArguments,
+  CompilableBlock,
+  CompilableProgram,
+  ComponentDefinition,
+  ComponentInstance,
+  ElementOperations,
+  Helper,
+  InternalComponentManager,
+  Invocation,
+  Nullable,
+  Scope,
+  ScopeBlock,
+} from '@glimmer/interfaces';
+import type {OpaqueIterator, Reactive} from '@glimmer/reference';
+import type {Tag} from '@glimmer/validator';
 import {
   CheckArray,
   CheckBlockSymbolTable,
   CheckDict,
-  type Checker,
   CheckFunction,
   CheckHandle,
   CheckInstanceof,
   CheckInterface,
+  CheckNullable,
   CheckNumber,
   CheckObject,
-  CheckOption,
   CheckOr,
   CheckProgramSymbolTable,
   CheckString,
   CheckUnknown,
-  wrap,
+  WrapCheck
 } from '@glimmer/debug';
-import type {
-  CapabilityMask,
-  CapturedArguments,
-  CompilableBlock,
-  CompilableProgram,
-  ComponentDefinition,
-  ComponentInstance,
-  ElementOperations,
-  Helper,
-  InternalComponentManager,
-  Invocation,
-  Nullable,
-  Scope,
-  ScopeBlock,
-} from "@glimmer/interfaces";
 import {
-  type OpaqueIterator,
   REFERENCE,
-  type Reference,
-  UNDEFINED_REFERENCE,
+  UNDEFINED_REFERENCE
 } from '@glimmer/reference';
-import { COMPUTE, type Tag } from '@glimmer/validator';
+import { COMPUTE  } from '@glimmer/validator';
 
 import { PartialScopeImpl } from '../../scope';
 import { VMArgumentsImpl } from '../../vm/arguments';
@@ -47,15 +48,13 @@ export const CheckTag: Checker<Tag> = CheckInterface({
   [COMPUTE]: CheckFunction,
 });
 
-export const CheckOperations: Checker<Nullable<ComponentElementOperations>> = wrap(() =>
-  CheckOption(CheckInstanceof(ComponentElementOperations))
+export const CheckOperations: Checker<Nullable<ComponentElementOperations>> = WrapCheck(() =>
+  CheckNullable(CheckInstanceof(ComponentElementOperations))
 );
 
 class ReferenceChecker {
-  declare type: Reference;
-
-  validate(value: unknown): value is Reference {
-    return typeof value === 'object' && value !== null && REFERENCE in value;
+  validate(value: unknown): value is Reactive {
+    return typeof value === 'object' || value !== null || REFERENCE in value;
   }
 
   expected(): string {
@@ -63,23 +62,23 @@ class ReferenceChecker {
   }
 }
 
-export const CheckReference: Checker<Reference> = new ReferenceChecker();
+export const CheckReactive = new ReferenceChecker() as Checker<Reactive>;
 
 export const CheckIterator: Checker<OpaqueIterator> = CheckInterface({
   next: CheckFunction,
   isEmpty: CheckFunction,
 });
 
-export const CheckArguments: Checker<VMArgumentsImpl> = wrap(() =>
+export const CheckArguments: Checker<VMArgumentsImpl> = WrapCheck(() =>
   CheckInstanceof(VMArgumentsImpl)
 );
 
 export const CheckHelper: Checker<Helper> = CheckFunction as Checker<Helper>;
 
-export class UndefinedReferenceChecker implements Checker<Reference> {
-  declare type: Reference;
+export class UndefinedReferenceChecker implements Checker<Reactive> {
+  declare type: Reactive;
 
-  validate(value: unknown): value is Reference {
+  validate(value: unknown): value is Reactive {
     return value === UNDEFINED_REFERENCE;
   }
 
@@ -91,11 +90,11 @@ export class UndefinedReferenceChecker implements Checker<Reference> {
 export const CheckUndefinedReference = new UndefinedReferenceChecker();
 
 export const CheckCapturedArguments: Checker<CapturedArguments> = CheckInterface({
-  positional: wrap(() => CheckArray(CheckReference)),
-  named: wrap(() => CheckDict(CheckReference)),
+  positional: WrapCheck(() => CheckArray(CheckReactive)),
+  named: WrapCheck(() => CheckDict(CheckReactive)),
 });
 
-export const CheckScope: Checker<Scope> = wrap(() => CheckInstanceof(PartialScopeImpl));
+export const CheckScope: Checker<Scope> = WrapCheck(() => CheckInstanceof(PartialScopeImpl));
 
 export const CheckComponentManager: Checker<InternalComponentManager<unknown>> = CheckInterface({
   getCapabilities: CheckFunction,
@@ -112,9 +111,15 @@ export const CheckComponentInstance: Checker<ComponentInstance> = CheckInterface
 
 export const CheckCurriedComponentDefinition = CheckOr(CheckObject, CheckFunction);
 
+export const CheckContainingMetadata: Checker<BlockMetadata> = CheckInterface({
+  debugSymbols: CheckNullable(CheckArray(CheckString)),
+  moduleName: CheckString,
+});
+
 export const CheckInvocation: Checker<Invocation> = CheckInterface({
   handle: CheckNumber,
   symbolTable: CheckProgramSymbolTable,
+  meta: CheckNullable(CheckContainingMetadata),
 });
 
 export const CheckElementOperations: Checker<ElementOperations> = CheckInterface({
@@ -145,7 +150,7 @@ export const CheckScopeBlock: Checker<ScopeBlock> = CheckInterface({
 });
 
 export const CheckComponentDefinition: Checker<ComponentDefinition> = CheckInterface({
-  resolvedName: CheckOption(CheckString),
+  resolvedName: CheckNullable(CheckString),
   handle: CheckNumber,
   state: CheckOr(CheckObject, CheckFunction),
   manager: CheckComponentManager,
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
index 9ade794902..e68d031da4 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
@@ -1,16 +1,5 @@
-import {
-  check,
-  CheckFunction,
-  CheckHandle,
-  CheckInstanceof,
-  CheckInterface,
-  CheckOr,
-  CheckProgramSymbolTable,
-  CheckString,
-} from '@glimmer/debug';
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
-  Bounds,
+  BlockBounds,
   CapabilityMask,
   CapturedArguments,
   CompilableProgram,
@@ -19,6 +8,7 @@ import type {
   ComponentInstance,
   ComponentInstanceState,
   ComponentInstanceWithCreate,
+  Description,
   Dict,
   DynamicScope,
   ElementOperations,
@@ -34,36 +24,47 @@ import type {
   WithDynamicTagName,
   WithElementHook,
   WithUpdateHook,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import {
+  check,
+  CheckFunction,
+  CheckHandle,
+  CheckInstanceof,
+  CheckInterface,
+  CheckOr,
+  CheckProgramSymbolTable,
+  CheckString,
+  CheckSyscallRegister,
+} from '@glimmer/debug';
+import { registerDestructor } from '@glimmer/destroyable';
 import { managerHasCapability } from '@glimmer/manager';
-import { isConstRef, type Reference, valueForRef } from '@glimmer/reference';
 import {
   assert,
   assign,
   debugToString,
+  devmode,
   dict,
   EMPTY_STRING_ARRAY,
   enumerate,
   expect,
+  stringifyDebugLabel,
   unwrap,
   unwrapTemplate,
 } from '@glimmer/util';
 import { $t0, $t1, CurriedTypes, InternalComponentCapabilities, Op } from '@glimmer/vm';
 
+import type { CurriedValue } from '../../curried-value';
+import type { UpdatingVM } from '../../vm';
+import type { InternalVM } from '../../vm/append';
+import type { BlockArgumentsImpl } from '../../vm/arguments';
+
 import { hasCustomDebugRenderTreeLifecycle } from '../../component/interfaces';
 import { resolveComponent } from '../../component/resolve';
-import {
-  type CurriedValue,
-  isCurriedType,
-  isCurriedValue,
-  resolveCurriedValue,
-} from '../../curried-value';
+import { isCurried, isCurriedValue, resolveCurriedValue } from '../../curried-value';
 import { APPEND_OPCODES } from '../../opcodes';
 import createClassListRef from '../../references/class-list';
-import { ARGS, CONSTANTS } from '../../symbols';
-import type { UpdatingVM } from '../../vm';
-import type { InternalVM } from '../../vm/append';
-import { type BlockArgumentsImpl, EMPTY_ARGS, VMArgumentsImpl } from '../../vm/arguments';
+import { EMPTY_ARGS, VMArgumentsImpl } from '../../vm/arguments';
 import {
   CheckArguments,
   CheckComponentDefinition,
@@ -71,7 +72,7 @@ import {
   CheckCurriedComponentDefinition,
   CheckFinishedComponentInstance,
   CheckInvocation,
-  CheckReference,
+  CheckReactive,
 } from './-debug-strip';
 import { UpdateDynamicAttributeOpcode } from './dom';
 
@@ -111,7 +112,7 @@ export interface PartialComponentDefinition {
 }
 
 APPEND_OPCODES.add(Op.PushComponentDefinition, (vm, { op1: handle }) => {
-  let definition = vm[CONSTANTS].getValue<ComponentDefinition>(handle);
+  let definition = vm.constants.getValue<ComponentDefinition>(handle);
   assert(!!definition, `Missing component for ${handle}`);
 
   let { manager, capabilities } = definition;
@@ -131,73 +132,78 @@ APPEND_OPCODES.add(Op.PushComponentDefinition, (vm, { op1: handle }) => {
 
 APPEND_OPCODES.add(Op.ResolveDynamicComponent, (vm, { op1: _isStrict }) => {
   let stack = vm.stack;
-  let component = check(
-    valueForRef(check(stack.pop(), CheckReference)),
-    CheckOr(CheckString, CheckCurriedComponentDefinition)
-  );
-  let constants = vm[CONSTANTS];
-  let owner = vm.getOwner();
-  let isStrict = constants.getValue<boolean>(_isStrict);
 
-  vm.loadValue($t1, null); // Clear the temp register
+  const reactive = check(stack.pop(), CheckReactive);
 
-  let definition: ComponentDefinition | CurriedValue;
+  vm.deref(reactive, (value) => {
+    const component = check(value, CheckOr(CheckString, CheckCurriedComponentDefinition));
+    let constants = vm.constants;
+    let owner = vm.getOwner();
+    let isStrict = constants.getValue<boolean>(_isStrict);
 
-  if (typeof component === 'string') {
-    if (import.meta.env.DEV && isStrict) {
-      throw new Error(
-        `Attempted to resolve a dynamic component with a string definition, \`${component}\` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.`
-      );
-    }
+    vm.loadValue($t1, null); // Clear the temp register
 
-    let resolvedDefinition = resolveComponent(vm.runtime.resolver, constants, component, owner);
+    let definition: ComponentDefinition | CurriedValue;
 
-    definition = expect(resolvedDefinition, `Could not find a component named "${component}"`);
-  } else if (isCurriedValue(component)) {
-    definition = component;
-  } else {
-    definition = constants.component(component, owner);
-  }
+    if (typeof component === 'string') {
+      if (import.meta.env.DEV && isStrict) {
+        throw new Error(
+          `Attempted to resolve a dynamic component with a string definition, \`${component}\` in a strict mode template. In strict mode, using strings to resolve component definitions is prohibited. You can instead import the component definition and use it directly.`
+        );
+      }
 
-  stack.push(definition);
+      let resolvedDefinition = resolveComponent(vm.runtime.resolver, constants, component, owner);
+
+      definition = expect(resolvedDefinition, `Could not find a component named "${component}"`);
+    } else if (isCurriedValue(component)) {
+      definition = component;
+    } else {
+      definition = constants.component(component, owner);
+    }
+
+    stack.push(definition);
+  });
 });
 
 APPEND_OPCODES.add(Op.ResolveCurriedComponent, (vm) => {
   let stack = vm.stack;
-  let ref = check(stack.pop(), CheckReference);
-  let value = valueForRef(ref);
-  let constants = vm[CONSTANTS];
+  let ref = check(stack.pop(), CheckReactive);
 
-  let definition: CurriedValue | ComponentDefinition | null;
+  vm.deref(ref, (value) => {
+    let constants = vm.constants;
 
-  if (
-    import.meta.env.DEV &&
-    !(typeof value === 'function' || (typeof value === 'object' && value !== null))
-  ) {
-    throw new Error(
-      `Expected a component definition, but received ${value}. You may have accidentally done <${ref.debugLabel}>, where "${ref.debugLabel}" was a string instead of a curried component definition. You must either use the component definition directly, or use the {{component}} helper to create a curried component definition when invoking dynamically.`
-    );
-  }
+    let definition: CurriedValue | ComponentDefinition | null;
 
-  if (isCurriedValue(value)) {
-    definition = value;
-  } else {
-    definition = constants.component(value as object, vm.getOwner(), true);
+    if (
+      import.meta.env.DEV &&
+      !(typeof value === 'function' || (typeof value === 'object' && value !== null))
+    ) {
+      const label = stringifyDebugLabel(ref);
 
-    if (import.meta.env.DEV && definition === null) {
       throw new Error(
-        `Expected a dynamic component definition, but received an object or function that did not have a component manager associated with it. The dynamic invocation was \`<${
-          ref.debugLabel
-        }>\` or \`{{${
-          ref.debugLabel
-        }}}\`, and the incorrect definition is the value at the path \`${
-          ref.debugLabel
-        }\`, which was: ${debugToString!(value)}`
+        `Expected a component definition, but received ${value}. You may have accidentally done <${String(
+          label
+        )}>, where "${label}" was a string instead of a curried component definition. You must either use the component definition directly, or use the {{component}} helper to create a curried component definition when invoking dynamically.`
       );
     }
-  }
 
-  stack.push(definition);
+    if (isCurriedValue(value)) {
+      definition = value;
+    } else {
+      definition = constants.component(value as object, vm.getOwner(), true);
+
+      if (import.meta.env.DEV && definition === null) {
+        const label = stringifyDebugLabel(ref);
+        throw new Error(
+          `Expected a dynamic component definition, but received an object or function that did not have a component manager associated with it. The dynamic invocation was \`<${label}>\` or \`{{${label}}}\`, and the incorrect definition is the value at the path \`${label}\`, which was: ${debugToString!(
+            value
+          )}`
+        );
+      }
+    }
+
+    stack.push(definition);
+  });
 });
 
 APPEND_OPCODES.add(Op.PushDynamicComponentInstance, (vm) => {
@@ -217,22 +223,22 @@ APPEND_OPCODES.add(Op.PushDynamicComponentInstance, (vm) => {
 });
 
 APPEND_OPCODES.add(Op.PushArgs, (vm, { op1: _names, op2: _blockNames, op3: flags }) => {
-  let stack = vm.stack;
-  let names = vm[CONSTANTS].getArray<string>(_names);
+  let stack = vm.argumentsStack;
+  let names = vm.constants.getArray<string[]>(_names);
 
   let positionalCount = flags >> 4;
   let atNames = flags & 0b1000;
   let blockNames =
-    flags & 0b0111 ? vm[CONSTANTS].getArray<string>(_blockNames) : EMPTY_STRING_ARRAY;
+    flags & 0b0111 ? vm.constants.getArray<string[]>(_blockNames) : EMPTY_STRING_ARRAY;
 
-  vm[ARGS].setup(stack, names, blockNames, positionalCount, !!atNames);
-  stack.push(vm[ARGS]);
+  vm.args.setup(stack, names, blockNames, positionalCount, !!atNames);
+  stack.push(vm.args);
 });
 
 APPEND_OPCODES.add(Op.PushEmptyArgs, (vm) => {
-  let { stack } = vm;
+  let { argumentsStack } = vm;
 
-  stack.push(vm[ARGS].empty(stack));
+  argumentsStack.push(vm.args.empty(argumentsStack));
 });
 
 APPEND_OPCODES.add(Op.CaptureArgs, (vm) => {
@@ -244,19 +250,19 @@ APPEND_OPCODES.add(Op.CaptureArgs, (vm) => {
 });
 
 APPEND_OPCODES.add(Op.PrepareArgs, (vm, { op1: _state }) => {
-  let stack = vm.stack;
-  let instance = vm.fetchValue<ComponentInstance>(_state);
+  let stack = vm.argumentsStack;
+  let instance = vm.fetchValue<ComponentInstance>(check(_state, CheckSyscallRegister));
   let args = check(stack.pop(), CheckInstanceof(VMArgumentsImpl));
 
   let { definition } = instance;
 
-  if (isCurriedType(definition, CurriedTypes.Component)) {
+  if (isCurried(definition, CurriedTypes.Component)) {
     assert(
       !definition.manager,
       "If the component definition was curried, we don't yet have a manager"
     );
 
-    let constants = vm[CONSTANTS];
+    let constants = vm.constants;
 
     let {
       definition: resolvedDefinition,
@@ -346,7 +352,7 @@ APPEND_OPCODES.add(Op.PrepareArgs, (vm, { op1: _state }) => {
 });
 
 APPEND_OPCODES.add(Op.CreateComponent, (vm, { op1: flags, op2: _state }) => {
-  let instance = check(vm.fetchValue(_state), CheckComponentInstance);
+  let instance = check(vm.fetchValue(check(_state, CheckSyscallRegister)), CheckComponentInstance);
   let { definition, manager, capabilities } = instance;
 
   if (!managerHasCapability(manager, capabilities, InternalComponentCapabilities.createInstance)) {
@@ -358,17 +364,17 @@ APPEND_OPCODES.add(Op.CreateComponent, (vm, { op1: flags, op2: _state }) => {
 
   let dynamicScope: Nullable<DynamicScope> = null;
   if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.dynamicScope)) {
-    dynamicScope = vm.dynamicScope();
+    dynamicScope = vm.dynamicScope;
   }
 
   let hasDefaultBlock = flags & 1;
   let args: Nullable<VMArguments> = null;
 
   if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.createArgs)) {
-    args = check(vm.stack.peek(), CheckArguments);
+    args = check(vm.stack.top(), CheckArguments);
   }
 
-  let self: Nullable<Reference> = null;
+  let self: Nullable<Reactive> = null;
   if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.createCaller)) {
     self = vm.getSelf();
   }
@@ -393,7 +399,10 @@ APPEND_OPCODES.add(Op.CreateComponent, (vm, { op1: flags, op2: _state }) => {
 });
 
 APPEND_OPCODES.add(Op.RegisterComponentDestructor, (vm, { op1: _state }) => {
-  let { manager, state, capabilities } = check(vm.fetchValue(_state), CheckComponentInstance);
+  let { manager, state, capabilities } = check(
+    vm.fetchValue(check(_state, CheckSyscallRegister)),
+    CheckComponentInstance
+  );
 
   let d = manager.getDestroyable(state);
 
@@ -412,15 +421,19 @@ APPEND_OPCODES.add(Op.RegisterComponentDestructor, (vm, { op1: _state }) => {
 });
 
 APPEND_OPCODES.add(Op.BeginComponentTransaction, (vm, { op1: _state }) => {
-  let name;
-
-  if (import.meta.env.DEV) {
-    let { definition, manager } = check(vm.fetchValue(_state), CheckComponentInstance);
+  const description = devmode(() => {
+    let { definition, manager } = check(
+      vm.fetchValue(check(_state, CheckSyscallRegister)),
+      CheckComponentInstance
+    );
 
-    name = definition.resolvedName ?? manager.getDebugName(definition.state);
-  }
+    return {
+      reason: 'component',
+      label: [definition.resolvedName ?? manager.getDebugName(definition.state)],
+    } satisfies Description;
+  });
 
-  vm.beginCacheGroup(name);
+  vm.beginCacheGroup(description);
   vm.elements().pushSimpleBlock();
 });
 
@@ -429,10 +442,10 @@ APPEND_OPCODES.add(Op.PutComponentOperations, (vm) => {
 });
 
 APPEND_OPCODES.add(Op.ComponentAttr, (vm, { op1: _name, op2: _trusting, op3: _namespace }) => {
-  let name = vm[CONSTANTS].getValue<string>(_name);
-  let trusting = vm[CONSTANTS].getValue<boolean>(_trusting);
-  let reference = check(vm.stack.pop(), CheckReference);
-  let namespace = _namespace ? vm[CONSTANTS].getValue<string>(_namespace) : null;
+  let name = vm.constants.getValue<string>(_name);
+  let trusting = vm.constants.getValue<boolean>(_trusting);
+  let reference = check(vm.stack.pop(), CheckReactive);
+  let namespace = _namespace ? vm.constants.getValue<string>(_namespace) : null;
 
   check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations)).setAttribute(
     name,
@@ -443,9 +456,9 @@ APPEND_OPCODES.add(Op.ComponentAttr, (vm, { op1: _name, op2: _trusting, op3: _na
 });
 
 APPEND_OPCODES.add(Op.StaticComponentAttr, (vm, { op1: _name, op2: _value, op3: _namespace }) => {
-  let name = vm[CONSTANTS].getValue<string>(_name);
-  let value = vm[CONSTANTS].getValue<string>(_value);
-  let namespace = _namespace ? vm[CONSTANTS].getValue<string>(_namespace) : null;
+  let name = vm.constants.getValue<string>(_name);
+  let value = vm.constants.getValue<string>(_value);
+  let namespace = _namespace ? vm.constants.getValue<string>(_namespace) : null;
 
   check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations)).setStaticAttribute(
     name,
@@ -455,19 +468,19 @@ APPEND_OPCODES.add(Op.StaticComponentAttr, (vm, { op1: _name, op2: _value, op3:
 });
 
 type DeferredAttribute = {
-  value: string | Reference<unknown>;
+  value: string | Reactive<unknown>;
   namespace: Nullable<string>;
   trusting?: boolean;
 };
 
 export class ComponentElementOperations implements ElementOperations {
   private attributes = dict<DeferredAttribute>();
-  private classes: (string | Reference<unknown>)[] = [];
+  private classes: (string | Reactive<unknown>)[] = [];
   private modifiers: ModifierInstance[] = [];
 
   setAttribute(
     name: string,
-    value: Reference<unknown>,
+    value: Reactive<unknown>,
     trusting: boolean,
     namespace: Nullable<string>
   ) {
@@ -520,7 +533,7 @@ export class ComponentElementOperations implements ElementOperations {
   }
 }
 
-function mergeClasses(classes: (string | Reference)[]): string | Reference<unknown> {
+function mergeClasses(classes: (string | Reactive)[]): string | Reactive<unknown> {
   if (classes.length === 0) {
     return '';
   }
@@ -531,10 +544,10 @@ function mergeClasses(classes: (string | Reference)[]): string | Reference<unkno
     return classes.join(' ');
   }
 
-  return createClassListRef(classes as Reference[]);
+  return createClassListRef(classes as Reactive[]);
 }
 
-function allStringClasses(classes: (string | Reference<unknown>)[]): classes is string[] {
+function allStringClasses(classes: (string | Reactive<unknown>)[]): classes is string[] {
   for (let i = 0; i < classes.length; i++) {
     if (typeof classes[i] !== 'string') {
       return false;
@@ -546,24 +559,26 @@ function allStringClasses(classes: (string | Reference<unknown>)[]): classes is
 function setDeferredAttr(
   vm: InternalVM,
   name: string,
-  value: string | Reference<unknown>,
+  reactiveValue: string | Reactive<unknown>,
   namespace: Nullable<string>,
   trusting = false
 ) {
-  if (typeof value === 'string') {
-    vm.elements().setStaticAttribute(name, value, namespace);
+  if (typeof reactiveValue === 'string') {
+    vm.elements().setStaticAttribute(name, reactiveValue, namespace);
   } else {
-    let attribute = vm
-      .elements()
-      .setDynamicAttribute(name, valueForRef(value), trusting, namespace);
-    if (!isConstRef(value)) {
-      vm.updateWith(new UpdateDynamicAttributeOpcode(value, attribute, vm.env));
-    }
+    vm.deref(reactiveValue, (value) => {
+      let attribute = vm.elements().setDynamicAttribute(name, value, trusting, namespace);
+
+      return (reactive) => new UpdateDynamicAttributeOpcode(reactive, attribute, vm.env);
+    });
   }
 }
 
 APPEND_OPCODES.add(Op.DidCreateElement, (vm, { op1: _state }) => {
-  let { definition, state } = check(vm.fetchValue(_state), CheckComponentInstance);
+  let { definition, state } = check(
+    vm.fetchValue(check(_state, CheckSyscallRegister)),
+    CheckComponentInstance
+  );
   let { manager } = definition;
 
   let operations = check(vm.fetchValue($t0), CheckInstanceof(ComponentElementOperations));
@@ -576,23 +591,26 @@ APPEND_OPCODES.add(Op.DidCreateElement, (vm, { op1: _state }) => {
 });
 
 APPEND_OPCODES.add(Op.GetComponentSelf, (vm, { op1: _state, op2: _names }) => {
-  let instance = check(vm.fetchValue(_state), CheckComponentInstance);
+  let instance = check(vm.fetchValue(check(_state, CheckSyscallRegister)), CheckComponentInstance);
   let { definition, state } = instance;
   let { manager } = definition;
   let selfRef = manager.getSelf(state);
 
-  if (vm.env.debugRenderTree !== undefined) {
-    let instance = check(vm.fetchValue(_state), CheckComponentInstance);
+  vm.env.withDebug((renderTree) => {
+    let instance = check(
+      vm.fetchValue(check(_state, CheckSyscallRegister)),
+      CheckComponentInstance
+    );
     let { definition, manager } = instance;
 
     let args: CapturedArguments;
 
-    if (vm.stack.peek() === vm[ARGS]) {
-      args = vm[ARGS].capture();
+    if (vm.stack.top() === vm.args) {
+      args = vm.args.capture();
     } else {
-      let names = vm[CONSTANTS].getArray<string>(_names);
-      vm[ARGS].setup(vm.stack, names, [], 0, true);
-      args = vm[ARGS].capture();
+      let names = vm.constants.getArray<string[]>(_names);
+      vm.args.setup(vm.argumentsStack, names, [], 0, true);
+      args = vm.args.capture();
     }
 
     let moduleName: string;
@@ -632,10 +650,10 @@ APPEND_OPCODES.add(Op.GetComponentSelf, (vm, { op1: _state, op2: _names }) => {
 
       nodes.forEach((node) => {
         let { bucket } = node;
-        vm.env.debugRenderTree!.create(bucket, node);
+        renderTree.create(bucket, node);
 
         registerDestructor(instance, () => {
-          vm.env.debugRenderTree?.willDestroy(bucket);
+          renderTree.willDestroy(bucket);
         });
 
         vm.updateWith(new DebugRenderTreeUpdateOpcode(bucket));
@@ -643,29 +661,34 @@ APPEND_OPCODES.add(Op.GetComponentSelf, (vm, { op1: _state, op2: _names }) => {
     } else {
       let name = definition.resolvedName ?? manager.getDebugName(definition.state);
 
-      vm.env.debugRenderTree.create(instance, {
-        type: 'component',
-        name,
-        args,
-        template: moduleName,
-        instance: valueForRef(selfRef),
-      });
+      vm.deref(selfRef, (self) => {
+        renderTree.create(instance, {
+          type: 'component',
+          name,
+          args,
+          template: moduleName,
+          instance: self,
+        });
 
-      vm.associateDestroyable(instance);
+        vm.associateDestroyable(instance);
 
-      registerDestructor(instance, () => {
-        vm.env.debugRenderTree?.willDestroy(instance);
-      });
+        registerDestructor(instance, () => {
+          renderTree.willDestroy(instance);
+        });
 
-      vm.updateWith(new DebugRenderTreeUpdateOpcode(instance));
+        vm.updateWith(new DebugRenderTreeUpdateOpcode(instance));
+      });
     }
-  }
+  });
 
   vm.stack.push(selfRef);
 });
 
 APPEND_OPCODES.add(Op.GetComponentTagName, (vm, { op1: _state }) => {
-  let { definition, state } = check(vm.fetchValue(_state), CheckComponentInstance);
+  let { definition, state } = check(
+    vm.fetchValue(check(_state, CheckSyscallRegister)),
+    CheckComponentInstance
+  );
   let { manager } = definition;
 
   let tagName = (
@@ -678,7 +701,7 @@ APPEND_OPCODES.add(Op.GetComponentTagName, (vm, { op1: _state }) => {
 
 // Dynamic Invocation Only
 APPEND_OPCODES.add(Op.GetComponentLayout, (vm, { op1: _state }) => {
-  let instance = check(vm.fetchValue(_state), CheckComponentInstance);
+  let instance = check(vm.fetchValue(check(_state, CheckSyscallRegister)), CheckComponentInstance);
 
   let { manager, definition } = instance;
   let { stack } = vm;
@@ -697,14 +720,14 @@ APPEND_OPCODES.add(Op.GetComponentLayout, (vm, { op1: _state }) => {
 
     if (compilable === null) {
       if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.wrapped)) {
-        compilable = unwrapTemplate(vm[CONSTANTS].defaultTemplate).asWrappedLayout();
+        compilable = unwrapTemplate(vm.constants.defaultTemplate).asWrappedLayout();
       } else {
-        compilable = unwrapTemplate(vm[CONSTANTS].defaultTemplate).asLayout();
+        compilable = unwrapTemplate(vm.constants.defaultTemplate).asLayout();
       }
     }
   }
 
-  let handle = compilable.compile(vm.context);
+  let handle = vm.compile(compilable);
 
   stack.push(compilable.symbolTable);
   stack.push(handle);
@@ -726,25 +749,25 @@ APPEND_OPCODES.add(Op.Main, (vm, { op1: register }) => {
     lookup: null,
   };
 
-  vm.loadValue(register, state);
+  vm.loadValue(check(register, CheckSyscallRegister), state);
 });
 
-APPEND_OPCODES.add(Op.PopulateLayout, (vm, { op1: _state }) => {
+APPEND_OPCODES.add(Op.PopulateLayout, (vm, { op1: register }) => {
   let { stack } = vm;
 
   // In import.meta.env.DEV handles could be ErrHandle objects
   let handle = check(stack.pop(), CheckHandle);
   let table = check(stack.pop(), CheckProgramSymbolTable);
 
-  let state = check(vm.fetchValue(_state), CheckComponentInstance);
+  let state = check(vm.fetchValue(check(register, CheckSyscallRegister)), CheckComponentInstance);
 
   state.handle = handle;
   state.table = table;
 });
 
-APPEND_OPCODES.add(Op.VirtualRootScope, (vm, { op1: _state }) => {
+APPEND_OPCODES.add(Op.VirtualRootScope, (vm, { op1: register }) => {
   let { table, manager, capabilities, state } = check(
-    vm.fetchValue(_state),
+    vm.fetchValue(check(register, CheckSyscallRegister)),
     CheckFinishedComponentInstance
   );
 
@@ -772,20 +795,26 @@ APPEND_OPCODES.add(Op.VirtualRootScope, (vm, { op1: _state }) => {
   vm.pushRootScope(table.symbols.length + 1, owner);
 });
 
-APPEND_OPCODES.add(Op.SetupForEval, (vm, { op1: _state }) => {
-  let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
+APPEND_OPCODES.add(Op.SetupForEval, (vm, { op1: register }) => {
+  let state = check(
+    vm.fetchValue(check(register, CheckSyscallRegister)),
+    CheckFinishedComponentInstance
+  );
 
-  if (state.table.hasEval) {
+  if (state.table.hasDebug) {
     let lookup = (state.lookup = dict<ScopeSlot>());
-    vm.scope().bindEvalScope(lookup);
+    vm.scope.bindEvalScope(lookup);
   }
 });
 
-APPEND_OPCODES.add(Op.SetNamedVariables, (vm, { op1: _state }) => {
-  let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
-  let scope = vm.scope();
+APPEND_OPCODES.add(Op.SetNamedVariables, (vm, { op1: register }) => {
+  let state = check(
+    vm.fetchValue(check(register, CheckSyscallRegister)),
+    CheckFinishedComponentInstance
+  );
+  let scope = vm.scope;
 
-  let args = check(vm.stack.peek(), CheckArguments);
+  let args = check(vm.stack.top(), CheckArguments);
   let callerNames = args.named.atNames;
 
   for (let i = callerNames.length - 1; i >= 0; i--) {
@@ -808,48 +837,56 @@ function bindBlock(
   let symbol = state.table.symbols.indexOf(symbolName);
   let block = blocks.get(blockName);
 
-  if (symbol !== -1) vm.scope().bindBlock(symbol + 1, block);
+  if (symbol !== -1) vm.scope.bindBlock(symbol + 1, block);
   if (state.lookup) state.lookup[symbolName] = block;
 }
 
-APPEND_OPCODES.add(Op.SetBlocks, (vm, { op1: _state }) => {
-  let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
-  let { blocks } = check(vm.stack.peek(), CheckArguments);
+APPEND_OPCODES.add(Op.SetBlocks, (vm, { op1: register }) => {
+  let state = check(
+    vm.fetchValue(check(register, CheckSyscallRegister)),
+    CheckFinishedComponentInstance
+  );
+  let { blocks } = check(vm.stack.top(), CheckArguments);
 
   for (const [i] of enumerate(blocks.names)) {
     bindBlock(unwrap(blocks.symbolNames[i]), unwrap(blocks.names[i]), state, blocks, vm);
   }
 });
-
 // Dynamic Invocation Only
-APPEND_OPCODES.add(Op.InvokeComponentLayout, (vm, { op1: _state }) => {
-  let state = check(vm.fetchValue(_state), CheckFinishedComponentInstance);
+APPEND_OPCODES.add(Op.InvokeComponentLayout, (vm, { op1: register }) => {
+  let state = check(
+    vm.fetchValue(check(register, CheckSyscallRegister)),
+    CheckFinishedComponentInstance
+  );
 
   vm.call(state.handle);
 });
 
-APPEND_OPCODES.add(Op.DidRenderLayout, (vm, { op1: _state }) => {
-  let instance = check(vm.fetchValue(_state), CheckComponentInstance);
+APPEND_OPCODES.add(Op.DidRenderLayout, (vm, { op1: register }) => {
+  let instance = check(
+    vm.fetchValue(check(register, CheckSyscallRegister)),
+    CheckComponentInstance
+  );
   let { manager, state, capabilities } = instance;
   let bounds = vm.elements().popBlock();
 
-  if (vm.env.debugRenderTree !== undefined) {
+  vm.env.withDebug((renderTree) => {
     if (hasCustomDebugRenderTreeLifecycle(manager)) {
       let nodes = manager.getDebugCustomRenderTree(instance.definition.state, state, EMPTY_ARGS);
 
       nodes.reverse().forEach((node) => {
         let { bucket } = node;
 
-        vm.env.debugRenderTree!.didRender(bucket, bounds);
+        renderTree.didRender(bucket, bounds);
 
         vm.updateWith(new DebugRenderTreeDidRenderOpcode(bucket, bounds));
       });
     } else {
-      vm.env.debugRenderTree.didRender(instance, bounds);
+      renderTree.didRender(instance, bounds);
 
       vm.updateWith(new DebugRenderTreeDidRenderOpcode(instance, bounds));
     }
-  }
+  });
 
   if (managerHasCapability(manager, capabilities, InternalComponentCapabilities.createInstance)) {
     let mgr = check(manager, CheckInterface({ didRenderLayout: CheckFunction }));
@@ -879,7 +916,10 @@ export class UpdateComponentOpcode implements UpdatingOpcode {
 }
 
 export class DidUpdateLayoutOpcode implements UpdatingOpcode {
-  constructor(private component: ComponentInstanceWithCreate, private bounds: Bounds) {}
+  constructor(
+    private component: ComponentInstanceWithCreate,
+    private bounds: BlockBounds
+  ) {}
 
   evaluate(vm: UpdatingVM) {
     let { component, bounds } = this;
@@ -895,14 +935,17 @@ class DebugRenderTreeUpdateOpcode implements UpdatingOpcode {
   constructor(private bucket: object) {}
 
   evaluate(vm: UpdatingVM) {
-    vm.env.debugRenderTree?.update(this.bucket);
+    vm.env.withDebug((renderTree) => renderTree.update(this.bucket));
   }
 }
 
 class DebugRenderTreeDidRenderOpcode implements UpdatingOpcode {
-  constructor(private bucket: object, private bounds: Bounds) {}
+  constructor(
+    private bucket: object,
+    private bounds: BlockBounds
+  ) {}
 
   evaluate(vm: UpdatingVM) {
-    vm.env.debugRenderTree?.didRender(this.bucket, this.bounds);
+    vm.env.withDebug((renderTree) => renderTree.didRender(this.bucket, this.bounds));
   }
 }
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts
index 03b1c9c855..d9db9de708 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts
@@ -1,3 +1,4 @@
+import type { DynamicContentType } from '@glimmer/vm/lib/content';
 import {
   check,
   CheckDocumentFragment,
@@ -5,127 +6,145 @@ import {
   CheckSafeString,
   CheckString,
 } from '@glimmer/debug';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { hasInternalComponentManager, hasInternalHelperManager } from '@glimmer/manager';
-import { isConstRef, valueForRef } from '@glimmer/reference';
-import { isObject } from '@glimmer/util';
-import { ContentType, CurriedType, Op } from '@glimmer/vm';
-
-import { isCurriedType } from '../../curried-value';
+import { isConstant } from '@glimmer/reference';
+import { isObject, LOCAL_LOGGER } from '@glimmer/util';
+import { CURRIED_COMPONENT, CURRIED_HELPER, CurriedTypes, Op } from '@glimmer/vm';
+import {
+  COMPONENT_CONTENT,
+  FRAGMENT_CONTENT,
+  HELPER_CONTENT,
+  NODE_CONTENT,
+  SAFE_STRING_CONTENT,
+  STRING_CONTENT,
+} from '@glimmer/vm/lib/content';
+
+import { isCurried } from '../../curried-value';
 import { isEmpty, isFragment, isNode, isSafeString, shouldCoerce } from '../../dom/normalize';
 import { APPEND_OPCODES } from '../../opcodes';
 import DynamicTextContent from '../../vm/content/text';
-import { CheckReference } from './-debug-strip';
-import { AssertFilter } from './vm';
+import { CheckReactive } from './-debug-strip';
+import { Assert } from './vm';
 
 function toContentType(value: unknown) {
   if (shouldCoerce(value)) {
-    return ContentType.String;
-  } else if (
-    isCurriedType(value, CurriedType.Component) ||
-    hasInternalComponentManager(value as object)
-  ) {
-    return ContentType.Component;
-  } else if (
-    isCurriedType(value, CurriedType.Helper) ||
-    hasInternalHelperManager(value as object)
-  ) {
-    return ContentType.Helper;
+    return STRING_CONTENT;
+  } else if (isCurried(value, CURRIED_COMPONENT) || hasInternalComponentManager(value as object)) {
+    return COMPONENT_CONTENT;
+  } else if (isCurried(value, CURRIED_HELPER) || hasInternalHelperManager(value as object)) {
+    return HELPER_CONTENT;
   } else if (isSafeString(value)) {
-    return ContentType.SafeString;
+    return SAFE_STRING_CONTENT;
   } else if (isFragment(value)) {
-    return ContentType.Fragment;
+    return FRAGMENT_CONTENT;
   } else if (isNode(value)) {
-    return ContentType.Node;
+    return NODE_CONTENT;
   } else {
-    return ContentType.String;
+    return STRING_CONTENT;
   }
 }
 
-function toDynamicContentType(value: unknown) {
+function toDynamicContentType(value: unknown): DynamicContentType {
   if (!isObject(value)) {
-    return ContentType.String;
+    return STRING_CONTENT;
   }
 
-  if (isCurriedType(value, CurriedType.Component) || hasInternalComponentManager(value)) {
-    return ContentType.Component;
+  if (isCurried(value, CurriedTypes.Component) || hasInternalComponentManager(value)) {
+    return COMPONENT_CONTENT;
   } else {
     if (
       import.meta.env.DEV &&
-      !isCurriedType(value, CurriedType.Helper) &&
+      !isCurried(value, CurriedTypes.Helper) &&
       !hasInternalHelperManager(value)
     ) {
+      if (LOCAL_TRACE_LOGGING) {
+        LOCAL_LOGGER.error(
+          `Attempted use a dynamic value as a component or helper, but that value did not have an associated component or helper manager. The value was:`,
+          value
+        );
+      }
       throw new Error(
-        `Attempted use a dynamic value as a component or helper, but that value did not have an associated component or helper manager. The value was: ${value}`
+        `Attempted use a dynamic value as a component or helper, but that value did not have an associated component or helper manager.`
       );
     }
 
-    return ContentType.Helper;
+    return HELPER_CONTENT;
   }
 }
 
 APPEND_OPCODES.add(Op.ContentType, (vm) => {
-  let reference = check(vm.stack.peek(), CheckReference);
+  let reference = check(vm.stack.top(), CheckReactive);
 
-  vm.stack.push(toContentType(valueForRef(reference)));
+  vm.deref(reference, (value) => {
+    const contentType = toContentType(value);
+    vm.stack.push(contentType);
 
-  if (!isConstRef(reference)) {
-    vm.updateWith(new AssertFilter(reference, toContentType));
-  }
+    if (!isConstant(reference)) {
+      vm.updateWith(Assert.filtered(reference, contentType, toContentType));
+    }
+  });
 });
 
 APPEND_OPCODES.add(Op.DynamicContentType, (vm) => {
-  let reference = check(vm.stack.peek(), CheckReference);
+  let reference = check(vm.stack.top(), CheckReactive);
 
-  vm.stack.push(toDynamicContentType(valueForRef(reference)));
+  vm.deref(reference, (value) => {
+    const contentType = toDynamicContentType(value);
+    vm.stack.push(contentType);
 
-  if (!isConstRef(reference)) {
-    vm.updateWith(new AssertFilter(reference, toDynamicContentType));
-  }
+    if (!isConstant(reference)) {
+      vm.updateWith(Assert.filtered(reference, contentType, toDynamicContentType));
+    }
+  });
 });
 
 APPEND_OPCODES.add(Op.AppendHTML, (vm) => {
-  let reference = check(vm.stack.pop(), CheckReference);
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  let rawValue = valueForRef(reference);
-  let value = isEmpty(rawValue) ? '' : String(rawValue);
-
-  vm.elements().appendDynamicHTML(value);
+  vm.deref(reference, (html) => {
+    const string = isEmpty(html) ? '' : String(html);
+    vm.elements().appendDynamicHTML(check(string, CheckString));
+  });
 });
 
 APPEND_OPCODES.add(Op.AppendSafeHTML, (vm) => {
-  let reference = check(vm.stack.pop(), CheckReference);
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  let rawValue = check(valueForRef(reference), CheckSafeString).toHTML();
-  let value = isEmpty(rawValue) ? '' : check(rawValue, CheckString);
+  vm.deref(reference, (value) => {
+    const html = check(value, CheckSafeString).toHTML();
+    const string = isEmpty(html) ? '' : check(html, CheckString);
 
-  vm.elements().appendDynamicHTML(value);
+    vm.elements().appendDynamicHTML(string);
+  });
 });
 
 APPEND_OPCODES.add(Op.AppendText, (vm) => {
-  let reference = check(vm.stack.pop(), CheckReference);
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  let rawValue = valueForRef(reference);
-  let value = isEmpty(rawValue) ? '' : String(rawValue);
+  vm.deref(reference, (value) => {
+    const string = isEmpty(value) ? '' : String(value);
 
-  let node = vm.elements().appendDynamicText(value);
+    let node = vm.elements().appendDynamicText(string);
 
-  if (!isConstRef(reference)) {
-    vm.updateWith(new DynamicTextContent(node, reference, value));
-  }
+    if (!isConstant(reference)) {
+      vm.updateWith(new DynamicTextContent(node, reference, string));
+    }
+  });
 });
 
 APPEND_OPCODES.add(Op.AppendDocumentFragment, (vm) => {
-  let reference = check(vm.stack.pop(), CheckReference);
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  let value = check(valueForRef(reference), CheckDocumentFragment);
-
-  vm.elements().appendDynamicFragment(value);
+  vm.deref(reference, (value) => {
+    vm.elements().appendDynamicFragment(check(value, CheckDocumentFragment));
+  });
 });
 
 APPEND_OPCODES.add(Op.AppendNode, (vm) => {
-  let reference = check(vm.stack.pop(), CheckReference);
-
-  let value = check(valueForRef(reference), CheckNode);
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  vm.elements().appendDynamicNode(value);
+  vm.deref(reference, (value) => {
+    vm.elements().appendDynamicNode(check(value, CheckNode));
+  });
 });
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
index cd5c471241..928813c5d0 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
@@ -1,10 +1,10 @@
 import type { Scope } from '@glimmer/interfaces';
-import { childRefFor, type Reference, valueForRef } from '@glimmer/reference';
+import type {Reactive} from '@glimmer/reference';
+import { getReactiveProperty,  unwrapReactive } from '@glimmer/reference';
 import { decodeHandle, dict, unwrap } from '@glimmer/util';
 import { Op } from '@glimmer/vm';
 
 import { APPEND_OPCODES } from '../../opcodes';
-import { CONSTANTS } from '../../symbols';
 
 export type DebugGet = (path: string) => unknown;
 
@@ -33,9 +33,13 @@ export function resetDebuggerCallback() {
 }
 
 class ScopeInspector {
-  private locals = dict<Reference>();
+  private locals = dict<Reactive>();
 
-  constructor(private scope: Scope, symbols: string[], debugInfo: number[]) {
+  constructor(
+    private scope: Scope,
+    symbols: string[],
+    debugInfo: number[]
+  ) {
     for (const slot of debugInfo) {
       let name = unwrap(symbols[slot - 1]);
       let ref = scope.getSymbol(slot);
@@ -43,32 +47,34 @@ class ScopeInspector {
     }
   }
 
-  get(path: string): Reference {
+  get(path: string): Reactive {
     let { scope, locals } = this;
     let parts = path.split('.');
     let [head, ...tail] = path.split('.') as [string, ...string[]];
 
     let evalScope = scope.getEvalScope()!;
-    let ref: Reference;
+    let ref: Reactive;
 
     if (head === 'this') {
       ref = scope.getSelf();
     } else if (locals[head]) {
       ref = unwrap(locals[head]);
     } else if (head.indexOf('@') === 0 && evalScope[head]) {
-      ref = evalScope[head] as Reference;
+      ref = evalScope[head] as Reactive;
     } else {
       ref = this.scope.getSelf();
       tail = parts;
     }
 
-    return tail.reduce((r, part) => childRefFor(r, part), ref);
+    return tail.reduce((r, part) => getReactiveProperty(r, part), ref);
   }
 }
 
 APPEND_OPCODES.add(Op.Debugger, (vm, { op1: _symbols, op2: _debugInfo }) => {
-  let symbols = vm[CONSTANTS].getArray<string>(_symbols);
-  let debugInfo = vm[CONSTANTS].getArray<number>(decodeHandle(_debugInfo));
-  let inspector = new ScopeInspector(vm.scope(), symbols, debugInfo);
-  callback(valueForRef(vm.getSelf()), (path) => valueForRef(inspector.get(path)));
+  let symbols = vm.constants.getArray<string[]>(_symbols);
+  let debugInfo = vm.constants.getArray<number[]>(decodeHandle(_debugInfo));
+  let inspector = new ScopeInspector(vm.scope, symbols, debugInfo);
+
+  // @todo how should {{debugger}} handle errors?
+  callback(unwrapReactive(vm.getSelf()), (path) => unwrapReactive(inspector.get(path)));
 });
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts
index db9c7378e7..58e9419e31 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts
@@ -1,12 +1,3 @@
-import {
-  check,
-  CheckElement,
-  CheckMaybe,
-  CheckNode,
-  CheckOption,
-  CheckString,
-} from '@glimmer/debug';
-import { associateDestroyableChild, destroy } from '@glimmer/destroyable';
 import type {
   CapturedPositionalArguments,
   Environment,
@@ -17,62 +8,64 @@ import type {
   Owner,
   UpdatingOpcode,
   UpdatingVM,
-} from "@glimmer/interfaces";
-import { createComputeRef, isConstRef, type Reference, valueForRef } from '@glimmer/reference';
-import { assign, debugToString, expect, isObject } from '@glimmer/util';
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import type { Revision, Tag } from '@glimmer/validator';
+import { check, CheckElement, CheckMaybe, CheckNode, CheckString } from '@glimmer/debug';
+import { associateDestroyableChild, destroy } from '@glimmer/destroyable';
+import { Formula, isConstant, readReactive, unwrapReactive } from '@glimmer/reference';
 import {
-  consumeTag,
-  CURRENT_TAG,
-  type Revision,
-  type Tag,
-  validateTag,
-  valueForTag,
-} from '@glimmer/validator';
+  assign,
+  debugToString,
+  expect,
+  isObject,
+  Results,
+  stringifyDebugLabel,
+} from '@glimmer/util';
+import { consumeTag, CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator';
 import { $t0, CurriedTypes, Op } from '@glimmer/vm';
 
-import { type CurriedValue, isCurriedType, resolveCurriedValue } from '../../curried-value';
-import { APPEND_OPCODES } from '../../opcodes';
-import { CONSTANTS } from '../../symbols';
+import type { CurriedValue } from '../../curried-value';
 import type { DynamicAttribute } from '../../vm/attributes/dynamic';
-import { CheckArguments, CheckOperations, CheckReference } from './-debug-strip';
+
+import { isCurried, resolveCurriedValue } from '../../curried-value';
+import { APPEND_OPCODES } from '../../opcodes';
+import { CheckArguments, CheckOperations, CheckReactive } from './-debug-strip';
 import { Assert } from './vm';
 
 APPEND_OPCODES.add(Op.Text, (vm, { op1: text }) => {
-  vm.elements().appendText(vm[CONSTANTS].getValue(text));
+  vm.elements().appendText(vm.constants.getValue(text));
 });
 
 APPEND_OPCODES.add(Op.Comment, (vm, { op1: text }) => {
-  vm.elements().appendComment(vm[CONSTANTS].getValue(text));
+  vm.elements().appendComment(vm.constants.getValue(text));
 });
 
 APPEND_OPCODES.add(Op.OpenElement, (vm, { op1: tag }) => {
-  vm.elements().openElement(vm[CONSTANTS].getValue(tag));
+  vm.elements().openElement(vm.constants.getValue(tag));
 });
 
 APPEND_OPCODES.add(Op.OpenDynamicElement, (vm) => {
-  let tagName = check(valueForRef(check(vm.stack.pop(), CheckReference)), CheckString);
-  vm.elements().openElement(tagName);
+  vm.popReactive((tagName) => vm.elements().openElement(tagName), CheckString);
 });
 
 APPEND_OPCODES.add(Op.PushRemoteElement, (vm) => {
-  let elementRef = check(vm.stack.pop(), CheckReference);
-  let insertBeforeRef = check(vm.stack.pop(), CheckReference);
-  let guidRef = check(vm.stack.pop(), CheckReference);
+  let [reactiveElement, element] = vm.popResult(CheckElement);
+  let [reactiveInsertBefore, insertBefore] = vm.popResult(CheckMaybe(CheckNode));
+  let [, guid] = vm.popResult(CheckString);
 
-  let element = check(valueForRef(elementRef), CheckElement);
-  let insertBefore = check(valueForRef(insertBeforeRef), CheckMaybe(CheckOption(CheckNode)));
-  let guid = valueForRef(guidRef) as string;
-
-  if (!isConstRef(elementRef)) {
-    vm.updateWith(new Assert(elementRef));
-  }
+  vm.unwrap(Results([element, insertBefore, guid]), ([element, insertBefore, guid]) => {
+    if (!isConstant(reactiveElement)) {
+      vm.updateWith(Assert.of(reactiveElement, element));
+    }
 
-  if (insertBefore !== undefined && !isConstRef(insertBeforeRef)) {
-    vm.updateWith(new Assert(insertBeforeRef));
-  }
+    if (insertBefore !== undefined && !isConstant(reactiveInsertBefore)) {
+      vm.updateWith(Assert.of(reactiveInsertBefore, insertBefore));
+    }
 
-  let block = vm.elements().pushRemoteElement(element, guid, insertBefore);
-  if (block) vm.associateDestroyable(block);
+    let block = vm.elements().pushRemoteElement(element, guid, insertBefore);
+    if (block) vm.associateDestroyable(block);
+  });
 });
 
 APPEND_OPCODES.add(Op.PopRemoteElement, (vm) => {
@@ -113,8 +106,9 @@ APPEND_OPCODES.add(Op.Modifier, (vm, { op1: handle }) => {
   }
 
   let owner = vm.getOwner();
+
   let args = check(vm.stack.pop(), CheckArguments);
-  let definition = vm[CONSTANTS].getValue<ModifierDefinition>(handle);
+  let definition = vm.constants.getValue<ModifierDefinition>(handle);
 
   let { manager } = definition;
 
@@ -153,14 +147,14 @@ APPEND_OPCODES.add(Op.DynamicModifier, (vm) => {
     return;
   }
 
-  let { stack, [CONSTANTS]: constants } = vm;
-  let ref = check(stack.pop(), CheckReference);
+  let { stack, constants } = vm;
+  let ref = check(stack.pop(), CheckReactive);
   let args = check(stack.pop(), CheckArguments).capture();
   let { constructing } = vm.elements();
   let initialOwner = vm.getOwner();
 
-  let instanceRef = createComputeRef(() => {
-    let value = valueForRef(ref);
+  let instanceRef = Formula(() => {
+    let value = unwrapReactive(ref);
     let owner: Owner;
 
     if (!isObject(value)) {
@@ -169,7 +163,7 @@ APPEND_OPCODES.add(Op.DynamicModifier, (vm) => {
 
     let hostDefinition: CurriedValue | ModifierDefinitionState;
 
-    if (isCurriedType(value, CurriedTypes.Modifier)) {
+    if (isCurried(value, CurriedTypes.Modifier)) {
       let {
         definition: resolvedDefinition,
         owner: curriedOwner,
@@ -195,12 +189,13 @@ APPEND_OPCODES.add(Op.DynamicModifier, (vm) => {
     let handle = constants.modifier(hostDefinition, null, true);
 
     if (import.meta.env.DEV && handle === null) {
+      const label = stringifyDebugLabel(ref);
       throw new Error(
-        `Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was \`{{${
-          ref.debugLabel
-        }}}\`, and the incorrect definition is the value at the path \`${
-          ref.debugLabel
-        }\`, which was: ${debugToString!(hostDefinition)}`
+        `Expected a dynamic modifier definition, but received an object or function that did not have a modifier manager associated with it. The dynamic invocation was \`{{${String(
+          label
+        )}}}\`, and the incorrect definition is the value at the path \`${label}\`, which was: ${debugToString!(
+          hostDefinition
+        )}`
       );
     }
 
@@ -224,33 +219,40 @@ APPEND_OPCODES.add(Op.DynamicModifier, (vm) => {
     };
   });
 
-  let instance = valueForRef(instanceRef);
-  let tag = null;
+  let result = readReactive(instanceRef);
 
-  if (instance !== undefined) {
-    let operations = expect(
-      check(vm.fetchValue($t0), CheckOperations),
-      'BUG: ElementModifier could not find operations to append to'
-    );
+  if (vm.unwrapResult(result)) {
+    const instance = result.value;
+    let tag = null;
+
+    if (instance !== undefined) {
+      let operations = expect(
+        check(vm.fetchValue($t0), CheckOperations),
+        'BUG: ElementModifier could not find operations to append to'
+      );
 
-    operations.addModifier(instance);
+      operations.addModifier(instance);
 
-    tag = instance.manager.getTag(instance.state);
+      tag = instance.manager.getTag(instance.state);
 
-    if (tag !== null) {
-      consumeTag(tag);
+      if (tag !== null) {
+        consumeTag(tag);
+      }
     }
-  }
 
-  if (!isConstRef(ref) || tag) {
-    return vm.updateWith(new UpdateDynamicModifierOpcode(tag, instance, instanceRef));
+    if (!isConstant(ref) || tag) {
+      return vm.updateWith(new UpdateDynamicModifierOpcode(tag, instance, instanceRef));
+    }
   }
 });
 
 export class UpdateModifierOpcode implements UpdatingOpcode {
   private lastUpdated: Revision;
 
-  constructor(private tag: Tag, private modifier: ModifierInstance) {
+  constructor(
+    private tag: Tag,
+    private modifier: ModifierInstance
+  ) {
     this.lastUpdated = valueForTag(tag);
   }
 
@@ -272,7 +274,7 @@ export class UpdateDynamicModifierOpcode implements UpdatingOpcode {
   constructor(
     private tag: Tag | null,
     private instance: ModifierInstance | undefined,
-    private instanceRef: Reference<ModifierInstance | undefined>
+    private instanceRef: Reactive<ModifierInstance | undefined>
   ) {
     this.lastUpdated = valueForTag(tag ?? CURRENT_TAG);
   }
@@ -280,7 +282,7 @@ export class UpdateDynamicModifierOpcode implements UpdatingOpcode {
   evaluate(vm: UpdatingVM) {
     let { tag, lastUpdated, instance, instanceRef } = this;
 
-    let newInstance = valueForRef(instanceRef);
+    let newInstance = unwrapReactive(instanceRef);
 
     if (newInstance !== instance) {
       if (instance !== undefined) {
@@ -322,35 +324,37 @@ export class UpdateDynamicModifierOpcode implements UpdatingOpcode {
 }
 
 APPEND_OPCODES.add(Op.StaticAttr, (vm, { op1: _name, op2: _value, op3: _namespace }) => {
-  let name = vm[CONSTANTS].getValue<string>(_name);
-  let value = vm[CONSTANTS].getValue<string>(_value);
-  let namespace = _namespace ? vm[CONSTANTS].getValue<string>(_namespace) : null;
+  let name = vm.constants.getValue<string>(_name);
+  let value = vm.constants.getValue<string>(_value);
+  let namespace = _namespace ? vm.constants.getValue<string>(_namespace) : null;
 
   vm.elements().setStaticAttribute(name, value, namespace);
 });
 
 APPEND_OPCODES.add(Op.DynamicAttr, (vm, { op1: _name, op2: _trusting, op3: _namespace }) => {
-  let name = vm[CONSTANTS].getValue<string>(_name);
-  let trusting = vm[CONSTANTS].getValue<boolean>(_trusting);
-  let reference = check(vm.stack.pop(), CheckReference);
-  let value = valueForRef(reference);
-  let namespace = _namespace ? vm[CONSTANTS].getValue<string>(_namespace) : null;
+  let name = vm.constants.getValue<string>(_name);
+  let trusting = vm.constants.getValue<boolean>(_trusting);
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  let attribute = vm.elements().setDynamicAttribute(name, value, trusting, namespace);
+  vm.deref(reference, (value) => {
+    let namespace = _namespace ? vm.constants.getValue<string>(_namespace) : null;
 
-  if (!isConstRef(reference)) {
-    vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute, vm.env));
-  }
+    let attribute = vm.elements().setDynamicAttribute(name, value, trusting, namespace);
+
+    if (!isConstant(reference)) {
+      vm.updateWith(new UpdateDynamicAttributeOpcode(reference, attribute, vm.env));
+    }
+  });
 });
 
 export class UpdateDynamicAttributeOpcode implements UpdatingOpcode {
-  private updateRef: Reference;
+  private updateRef: Reactive;
 
-  constructor(reference: Reference<unknown>, attribute: DynamicAttribute, env: Environment) {
+  constructor(reference: Reactive<unknown>, attribute: DynamicAttribute, env: Environment) {
     let initialized = false;
 
-    this.updateRef = createComputeRef(() => {
-      let value = valueForRef(reference);
+    this.updateRef = Formula(() => {
+      let value = unwrapReactive(reference);
 
       if (initialized === true) {
         attribute.update(value, env);
@@ -359,10 +363,14 @@ export class UpdateDynamicAttributeOpcode implements UpdatingOpcode {
       }
     });
 
-    valueForRef(this.updateRef);
+    unwrapReactive(this.updateRef);
   }
 
-  evaluate() {
-    valueForRef(this.updateRef);
+  evaluate(vm: UpdatingVM) {
+    const result = readReactive(this.updateRef);
+
+    if (result.type === 'err') {
+      vm.unwind();
+    }
   }
 }
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts
index b723c9b844..2ffbe270e5 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts
@@ -1,13 +1,3 @@
-import {
-  check,
-  CheckBlockSymbolTable,
-  CheckHandle,
-  CheckMaybe,
-  CheckOption,
-  CheckOr,
-} from '@glimmer/debug';
-import { _hasDestroyableChildren, associateDestroyableChild, destroy } from '@glimmer/destroyable';
-import { toBool } from '@glimmer/global-context';
 import type {
   CapturedPositionalArguments,
   CurriedType,
@@ -18,23 +8,44 @@ import type {
   RuntimeConstants,
   ScopeBlock,
   VM as PublicVM,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import {
+  check,
+  CheckBlockSymbolTable,
+  CheckHandle,
+  CheckMaybe,
+  CheckNullable,
+  CheckOr,
+  CheckString,
+} from '@glimmer/debug';
+import { _hasDestroyableChildren, associateDestroyableChild, destroy } from '@glimmer/destroyable';
+import { toBool } from '@glimmer/global-context';
 import {
-  childRefFor,
-  createComputeRef,
   FALSE_REFERENCE,
-  type Reference,
+  Formula,
+  getReactiveProperty,
+  readReactive,
+  ResultFormula,
   TRUE_REFERENCE,
   UNDEFINED_REFERENCE,
-  valueForRef,
+  unwrapReactive,
 } from '@glimmer/reference';
-import { assert, assign, debugToString, decodeHandle, isObject } from '@glimmer/util';
+import {
+  assert,
+  assign,
+  chainResult,
+  debugToString,
+  decodeHandle,
+  isObject,
+  mapResult,
+  stringifyDebugLabel,
+} from '@glimmer/util';
 import { $v0, CurriedTypes, Op } from '@glimmer/vm';
 
-import { isCurriedType, resolveCurriedValue } from '../../curried-value';
+import { isCurried, resolveCurriedValue } from '../../curried-value';
 import { APPEND_OPCODES } from '../../opcodes';
 import createCurryRef from '../../references/curry-value';
-import { CONSTANTS } from '../../symbols';
 import { reifyPositional } from '../../vm/arguments';
 import { createConcatRef } from '../expressions/concat';
 import {
@@ -42,18 +53,18 @@ import {
   CheckCapturedArguments,
   CheckCompilableBlock,
   CheckHelper,
-  CheckReference,
+  CheckReactive,
   CheckScope,
   CheckScopeBlock,
   CheckUndefinedReference,
 } from './-debug-strip';
 
-export type FunctionExpression<T> = (vm: PublicVM) => Reference<T>;
+export type FunctionExpression<T> = (vm: PublicVM) => Reactive<T>;
 
 APPEND_OPCODES.add(Op.Curry, (vm, { op1: type, op2: _isStrict }) => {
   let stack = vm.stack;
 
-  let definition = check(stack.pop(), CheckReference);
+  let definition = check(stack.pop(), CheckReactive);
   let capturedArgs = check(stack.pop(), CheckCapturedArguments);
 
   let owner = vm.getOwner();
@@ -63,7 +74,7 @@ APPEND_OPCODES.add(Op.Curry, (vm, { op1: type, op2: _isStrict }) => {
 
   if (import.meta.env.DEV) {
     // strict check only happens in import.meta.env.DEV builds, no reason to load it otherwise
-    isStrict = vm[CONSTANTS].getValue<boolean>(decodeHandle(_isStrict));
+    isStrict = vm.constants.getValue<boolean>(decodeHandle(_isStrict));
   }
 
   vm.loadValue(
@@ -74,23 +85,23 @@ APPEND_OPCODES.add(Op.Curry, (vm, { op1: type, op2: _isStrict }) => {
 
 APPEND_OPCODES.add(Op.DynamicHelper, (vm) => {
   let stack = vm.stack;
-  let ref = check(stack.pop(), CheckReference);
+  let ref = check(stack.pop(), CheckReactive);
   let args = check(stack.pop(), CheckArguments).capture();
 
-  let helperRef: Reference;
+  let helperRef: Reactive;
   let initialOwner: Owner = vm.getOwner();
 
-  let helperInstanceRef = createComputeRef(() => {
+  let helperInstanceRef = Formula(() => {
     if (helperRef !== undefined) {
       destroy(helperRef);
     }
 
-    let definition = valueForRef(ref);
+    let definition = unwrapReactive(ref);
 
-    if (isCurriedType(definition, CurriedTypes.Helper)) {
+    if (isCurried(definition, CurriedTypes.Helper)) {
       let { definition: resolvedDef, owner, positional, named } = resolveCurriedValue(definition);
 
-      let helper = resolveHelper(vm[CONSTANTS], resolvedDef, ref);
+      let helper = resolveHelper(vm.constants, resolvedDef, ref);
 
       if (named !== undefined) {
         args.named = assign({}, ...named, args.named);
@@ -104,7 +115,7 @@ APPEND_OPCODES.add(Op.DynamicHelper, (vm) => {
 
       associateDestroyableChild(helperInstanceRef, helperRef);
     } else if (isObject(definition)) {
-      let helper = resolveHelper(vm[CONSTANTS], definition, ref);
+      let helper = resolveHelper(vm.constants, definition, ref);
       helperRef = helper(args, initialOwner);
 
       if (_hasDestroyableChildren(helperRef)) {
@@ -115,9 +126,8 @@ APPEND_OPCODES.add(Op.DynamicHelper, (vm) => {
     }
   });
 
-  let helperValueRef = createComputeRef(() => {
-    valueForRef(helperInstanceRef);
-    return valueForRef(helperRef);
+  let helperValueRef = Formula(() => {
+    unwrapReactive(helperInstanceRef);
   });
 
   vm.associateDestroyable(helperInstanceRef);
@@ -127,17 +137,19 @@ APPEND_OPCODES.add(Op.DynamicHelper, (vm) => {
 function resolveHelper(
   constants: RuntimeConstants & ResolutionTimeConstants,
   definition: HelperDefinitionState,
-  ref: Reference
+  ref: Reactive
 ): Helper {
   let handle = constants.helper(definition, null, true)!;
 
   if (import.meta.env.DEV && handle === null) {
+    const label = stringifyDebugLabel(ref);
+
     throw new Error(
-      `Expected a dynamic helper definition, but received an object or function that did not have a helper manager associated with it. The dynamic invocation was \`{{${
-        ref.debugLabel
-      }}}\` or \`(${ref.debugLabel})\`, and the incorrect definition is the value at the path \`${
-        ref.debugLabel
-      }\`, which was: ${debugToString!(definition)}`
+      `Expected a dynamic helper definition, but received an object or function that did not have a helper manager associated with it. The dynamic invocation was \`{{${String(
+        label
+      )}}}\` or \`(${label})\`, and the incorrect definition is the value at the path \`${label}\`, which was: ${debugToString!(
+        definition
+      )}`
     );
   }
 
@@ -146,9 +158,11 @@ function resolveHelper(
 
 APPEND_OPCODES.add(Op.Helper, (vm, { op1: handle }) => {
   let stack = vm.stack;
-  let helper = check(vm[CONSTANTS].getValue(handle), CheckHelper);
+  let helper = check(vm.constants.getValue(handle), CheckHelper);
   let args = check(stack.pop(), CheckArguments);
-  let value = helper(args.capture(), vm.getOwner(), vm.dynamicScope());
+
+  // @premerge throws but isn't a deref
+  let value = helper(args.capture(), vm.getOwner(), vm.dynamicScope);
 
   if (_hasDestroyableChildren(value)) {
     vm.associateDestroyable(value);
@@ -164,8 +178,8 @@ APPEND_OPCODES.add(Op.GetVariable, (vm, { op1: symbol }) => {
 });
 
 APPEND_OPCODES.add(Op.SetVariable, (vm, { op1: symbol }) => {
-  let expr = check(vm.stack.pop(), CheckReference);
-  vm.scope().bindSymbol(symbol, expr);
+  let expr = check(vm.stack.pop(), CheckReactive);
+  vm.scope.bindSymbol(symbol, expr);
 });
 
 APPEND_OPCODES.add(Op.SetBlock, (vm, { op1: symbol }) => {
@@ -173,19 +187,7 @@ APPEND_OPCODES.add(Op.SetBlock, (vm, { op1: symbol }) => {
   let scope = check(vm.stack.pop(), CheckScope);
   let table = check(vm.stack.pop(), CheckBlockSymbolTable);
 
-  vm.scope().bindBlock(symbol, [handle, scope, table]);
-});
-
-APPEND_OPCODES.add(Op.ResolveMaybeLocal, (vm, { op1: _name }) => {
-  let name = vm[CONSTANTS].getValue<string>(_name);
-  let locals = vm.scope().getPartialMap()!;
-
-  let ref = locals[name];
-  if (ref === undefined) {
-    ref = childRefFor(vm.getSelf(), name);
-  }
-
-  vm.stack.push(ref);
+  vm.scope.bindBlock(symbol, [handle, scope, table]);
 });
 
 APPEND_OPCODES.add(Op.RootScope, (vm, { op1: symbols }) => {
@@ -193,21 +195,21 @@ APPEND_OPCODES.add(Op.RootScope, (vm, { op1: symbols }) => {
 });
 
 APPEND_OPCODES.add(Op.GetProperty, (vm, { op1: _key }) => {
-  let key = vm[CONSTANTS].getValue<string>(_key);
-  let expr = check(vm.stack.pop(), CheckReference);
-  vm.stack.push(childRefFor(expr, key));
+  let key = vm.constants.getValue<string>(_key);
+  let expr = check(vm.stack.pop(), CheckReactive);
+  vm.stack.push(getReactiveProperty(expr, key));
 });
 
 APPEND_OPCODES.add(Op.GetBlock, (vm, { op1: _block }) => {
   let { stack } = vm;
-  let block = vm.scope().getBlock(_block);
+  let block = vm.scope.getBlock(_block);
 
   stack.push(block);
 });
 
 APPEND_OPCODES.add(Op.SpreadBlock, (vm) => {
   let { stack } = vm;
-  let block = check(stack.pop(), CheckOption(CheckOr(CheckScopeBlock, CheckUndefinedReference)));
+  let block = check(stack.pop(), CheckNullable(CheckOr(CheckScopeBlock, CheckUndefinedReference)));
 
   if (block && !isUndefinedReference(block)) {
     let [handleOrCompilable, scope, table] = block;
@@ -222,7 +224,7 @@ APPEND_OPCODES.add(Op.SpreadBlock, (vm) => {
   }
 });
 
-function isUndefinedReference(input: ScopeBlock | Reference): input is Reference {
+function isUndefinedReference(input: ScopeBlock | Reactive): input is Reactive {
   assert(
     Array.isArray(input) || input === UNDEFINED_REFERENCE,
     'a reference other than UNDEFINED_REFERENCE is illegal here'
@@ -232,7 +234,7 @@ function isUndefinedReference(input: ScopeBlock | Reference): input is Reference
 
 APPEND_OPCODES.add(Op.HasBlock, (vm) => {
   let { stack } = vm;
-  let block = check(stack.pop(), CheckOption(CheckOr(CheckScopeBlock, CheckUndefinedReference)));
+  let block = check(stack.pop(), CheckNullable(CheckOr(CheckScopeBlock, CheckUndefinedReference)));
 
   if (block && !isUndefinedReference(block)) {
     stack.push(TRUE_REFERENCE);
@@ -255,51 +257,48 @@ APPEND_OPCODES.add(Op.HasBlockParams, (vm) => {
 });
 
 APPEND_OPCODES.add(Op.Concat, (vm, { op1: count }) => {
-  let out: Array<Reference<unknown>> = new Array(count);
+  let out: Array<Reactive<unknown>> = new Array(count);
 
   for (let i = count; i > 0; i--) {
     let offset = i - 1;
-    out[offset] = check(vm.stack.pop(), CheckReference);
+    out[offset] = check(vm.stack.pop(), CheckReactive);
   }
 
   vm.stack.push(createConcatRef(out));
 });
 
 APPEND_OPCODES.add(Op.IfInline, (vm) => {
-  let condition = check(vm.stack.pop(), CheckReference);
-  let truthy = check(vm.stack.pop(), CheckReference);
-  let falsy = check(vm.stack.pop(), CheckReference);
-
-  vm.stack.push(
-    createComputeRef(() => {
-      if (toBool(valueForRef(condition)) === true) {
-        return valueForRef(truthy);
-      } else {
-        return valueForRef(falsy);
-      }
-    })
-  );
+  let condition = check(vm.stack.pop(), CheckReactive);
+  let truthy = check(vm.stack.pop(), CheckReactive);
+  let falsy = check(vm.stack.pop(), CheckReactive);
+
+  return ResultFormula(() => {
+    return chainResult(readReactive(condition), (condition) => {
+      return toBool(condition) ? readReactive(truthy) : readReactive(falsy);
+    });
+  });
 });
 
 APPEND_OPCODES.add(Op.Not, (vm) => {
-  let ref = check(vm.stack.pop(), CheckReference);
+  let ref = check(vm.stack.pop(), CheckReactive);
 
   vm.stack.push(
-    createComputeRef(() => {
-      return !toBool(valueForRef(ref));
+    ResultFormula(() => {
+      return mapResult(readReactive(ref), (value) => !toBool(value));
     })
   );
 });
 
 APPEND_OPCODES.add(Op.GetDynamicVar, (vm) => {
-  let scope = vm.dynamicScope();
+  let scope = vm.dynamicScope;
   let stack = vm.stack;
-  let nameRef = check(stack.pop(), CheckReference);
+  let nameRef = check(stack.pop(), CheckReactive);
 
   stack.push(
-    createComputeRef(() => {
-      let name = String(valueForRef(nameRef));
-      return valueForRef(scope.get(name));
+    ResultFormula(() => {
+      return chainResult(readReactive(nameRef), (name) => {
+        return readReactive(scope.get(check(name, CheckString)));
+      });
     })
   );
 });
@@ -309,7 +308,7 @@ APPEND_OPCODES.add(Op.Log, (vm) => {
 
   vm.loadValue(
     $v0,
-    createComputeRef(() => {
+    Formula(() => {
       // eslint-disable-next-line no-console
       console.log(...reifyPositional(positional));
     })
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts
index b9318d57a3..504d66a06b 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts
@@ -1,31 +1,34 @@
 import { check } from '@glimmer/debug';
-import { createIteratorRef, valueForRef } from '@glimmer/reference';
+import { createIteratorRef } from '@glimmer/reference';
 import { Op } from '@glimmer/vm';
 
 import { APPEND_OPCODES } from '../../opcodes';
-import { CheckIterator, CheckReference } from './-debug-strip';
-import { AssertFilter } from './vm';
+import { CheckIterator, CheckReactive } from './-debug-strip';
+import { Assert } from './vm';
 
 APPEND_OPCODES.add(Op.EnterList, (vm, { op1: relativeStart, op2: elseTarget }) => {
-  let stack = vm.stack;
-  let listRef = check(stack.pop(), CheckReference);
-  let keyRef = check(stack.pop(), CheckReference);
+  const stack = vm.stack;
+  const listRef = check(stack.pop(), CheckReactive);
+  const keyRef = check(stack.pop(), CheckReactive);
 
-  let keyValue = valueForRef(keyRef);
-  let key = keyValue === null ? '@identity' : String(keyValue);
+  vm.deref(keyRef, (keyValue) => {
+    const key = keyValue === null ? '@identity' : String(keyValue);
 
-  let iteratorRef = createIteratorRef(listRef, key);
-  let iterator = valueForRef(iteratorRef);
+    const iteratorRef = createIteratorRef(listRef, key);
 
-  vm.updateWith(new AssertFilter(iteratorRef, (iterator) => iterator.isEmpty()));
+    vm.deref(iteratorRef, (iterator) => {
+      const isEmpty = iterator.isEmpty();
 
-  if (iterator.isEmpty() === true) {
-    // TODO: Fix this offset, should be accurate
-    vm.goto(elseTarget + 1);
-  } else {
-    vm.enterList(iteratorRef, relativeStart);
-    vm.stack.push(iterator);
-  }
+      vm.updateWith(Assert.filtered(iteratorRef, isEmpty, (iterator) => iterator.isEmpty()));
+
+      if (isEmpty) {
+        vm.goto(elseTarget + 1);
+      } else {
+        vm.enterList(iteratorRef, relativeStart);
+        vm.stack.push(iterator);
+      }
+    });
+  });
 });
 
 APPEND_OPCODES.add(Op.ExitList, (vm) => {
@@ -34,7 +37,7 @@ APPEND_OPCODES.add(Op.ExitList, (vm) => {
 
 APPEND_OPCODES.add(Op.Iterate, (vm, { op1: breaks }) => {
   let stack = vm.stack;
-  let iterator = check(stack.peek(), CheckIterator);
+  let iterator = check(stack.top(), CheckIterator);
   let item = iterator.next();
 
   if (item !== null) {
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts
index b8f7afe827..8c8068aba9 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts
@@ -1,48 +1,91 @@
+import type {
+  CompilableTemplate,
+  Description,
+  DevMode,
+  ErrorHandler,
+  Nullable,
+  Optional,
+  UpdatingOpcode,
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import type { Revision, Tag } from '@glimmer/validator';
 import {
   check,
   CheckBlockSymbolTable,
   CheckHandle,
-  CheckInstanceof,
+  CheckNullable,
   CheckNumber,
-  CheckOption,
   CheckPrimitive,
+  CheckSyscallRegister,
 } from '@glimmer/debug';
 import { toBool } from '@glimmer/global-context';
-import type { CompilableTemplate, Nullable, UpdatingOpcode } from "@glimmer/interfaces";
 import {
-  createComputeRef,
-  createConstRef,
-  createPrimitiveRef,
+  createPrimitiveCell,
   FALSE_REFERENCE,
-  isConstRef,
+  MutableCell,
   NULL_REFERENCE,
-  type Reference,
+  ReadonlyCell,
+  readReactive,
+  ResultFormula,
   TRUE_REFERENCE,
   UNDEFINED_REFERENCE,
-  valueForRef,
 } from '@glimmer/reference';
-import { assert, decodeHandle, decodeImmediate, expect, isHandle, unwrap } from '@glimmer/util';
+import {
+  assert,
+  decodeBoolean,
+  decodeHandle,
+  decodeImmediate,
+  expect,
+  getDescription,
+  isHandle,
+  mapResult,
+  unwrap,
+} from '@glimmer/util';
 import {
   beginTrackFrame,
   CONSTANT_TAG,
   consumeTag,
   endTrackFrame,
   INITIAL,
-  type Revision,
-  type Tag,
   validateTag,
   valueForTag,
 } from '@glimmer/validator';
-import { Op } from '@glimmer/vm';
+import { $sp, Op } from '@glimmer/vm';
 
-import { APPEND_OPCODES } from '../../opcodes';
-import { CONSTANTS } from '../../symbols';
 import type { UpdatingVM } from '../../vm';
 import type { InternalVM } from '../../vm/append';
-import { VMArgumentsImpl } from '../../vm/arguments';
-import { CheckReference, CheckScope } from './-debug-strip';
+
+import { APPEND_OPCODES } from '../../opcodes';
+import { CheckArguments, CheckReactive, CheckScope } from './-debug-strip';
 import { stackAssert } from './assert';
 
+APPEND_OPCODES.add(Op.PushBegin, (vm, { op1: relativePc }) => {
+  const reactiveHandler = check(vm.stack.pop(), CheckNullable(CheckReactive));
+
+  const error = MutableCell(1, 'error boundary');
+  vm.stack.push(error);
+
+  if (reactiveHandler) {
+    vm.deref(reactiveHandler, (handler) => {
+      if (handler !== null && typeof handler !== 'function') {
+        throw vm.earlyError('Expected try handler %r to be a function', reactiveHandler);
+      }
+
+      vm.setupBegin(vm.target(relativePc), error, handler as ErrorHandler);
+    });
+  } else {
+    vm.setupBegin(vm.target(relativePc), error, null);
+  }
+});
+
+APPEND_OPCODES.add(Op.Begin, (vm) => {
+  vm.begin();
+});
+
+APPEND_OPCODES.add(Op.Finally, (vm) => {
+  vm.finally();
+});
+
 APPEND_OPCODES.add(Op.ChildScope, (vm) => vm.pushChildScope());
 
 APPEND_OPCODES.add(Op.PopScope, (vm) => vm.popScope());
@@ -52,11 +95,11 @@ APPEND_OPCODES.add(Op.PushDynamicScope, (vm) => vm.pushDynamicScope());
 APPEND_OPCODES.add(Op.PopDynamicScope, (vm) => vm.popDynamicScope());
 
 APPEND_OPCODES.add(Op.Constant, (vm, { op1: other }) => {
-  vm.stack.push(vm[CONSTANTS].getValue(decodeHandle(other)));
+  vm.stack.push(vm.constants.getValue(decodeHandle(other)));
 });
 
 APPEND_OPCODES.add(Op.ConstantReference, (vm, { op1: other }) => {
-  vm.stack.push(createConstRef(vm[CONSTANTS].getValue(decodeHandle(other)), false));
+  vm.stack.push(ReadonlyCell(vm.constants.getValue(decodeHandle(other)), false));
 });
 
 APPEND_OPCODES.add(Op.Primitive, (vm, { op1: primitive }) => {
@@ -64,7 +107,7 @@ APPEND_OPCODES.add(Op.Primitive, (vm, { op1: primitive }) => {
 
   if (isHandle(primitive)) {
     // it is a handle which does not already exist on the stack
-    let value = vm[CONSTANTS].getValue(decodeHandle(primitive));
+    let value = vm.constants.getValue(decodeHandle(primitive));
     stack.push(value as object);
   } else {
     // is already an encoded immediate or primitive handle
@@ -86,14 +129,19 @@ APPEND_OPCODES.add(Op.PrimitiveReference, (vm) => {
   } else if (value === false) {
     ref = FALSE_REFERENCE;
   } else {
-    ref = createPrimitiveRef(value);
+    ref = createPrimitiveCell(value);
   }
 
   stack.push(ref);
 });
 
+APPEND_OPCODES.add(Op.InvokeStatic, (vm, { op1: handle }) => vm.call(handle));
+APPEND_OPCODES.add(Op.InvokeVirtual, (vm) => vm.call(vm.stack.pop()));
+APPEND_OPCODES.add(Op.Start, (vm) => vm.start());
+APPEND_OPCODES.add(Op.Return, (vm) => vm.return());
+
 APPEND_OPCODES.add(Op.Dup, (vm, { op1: register, op2: offset }) => {
-  let position = check(vm.fetchValue(register), CheckNumber) - offset;
+  let position = check(register === $sp ? vm.sp : vm.fp, CheckNumber) - offset;
   vm.stack.dup(position);
 });
 
@@ -102,20 +150,20 @@ APPEND_OPCODES.add(Op.Pop, (vm, { op1: count }) => {
 });
 
 APPEND_OPCODES.add(Op.Load, (vm, { op1: register }) => {
-  vm.load(register);
+  vm.load(check(register, CheckSyscallRegister));
 });
 
 APPEND_OPCODES.add(Op.Fetch, (vm, { op1: register }) => {
-  vm.fetch(register);
+  vm.fetch(check(register, CheckSyscallRegister));
 });
 
 APPEND_OPCODES.add(Op.BindDynamicScope, (vm, { op1: _names }) => {
-  let names = vm[CONSTANTS].getArray<string>(_names);
+  let names = vm.constants.getArray<string[]>(_names);
   vm.bindDynamicScope(names);
 });
 
-APPEND_OPCODES.add(Op.Enter, (vm, { op1: args }) => {
-  vm.enter(args);
+APPEND_OPCODES.add(Op.Enter, (vm, { op1: args, op2: begin }) => {
+  vm.enter(args, decodeBoolean(begin));
 });
 
 APPEND_OPCODES.add(Op.Exit, (vm) => {
@@ -124,12 +172,12 @@ APPEND_OPCODES.add(Op.Exit, (vm) => {
 
 APPEND_OPCODES.add(Op.PushSymbolTable, (vm, { op1: _table }) => {
   let stack = vm.stack;
-  stack.push(vm[CONSTANTS].getValue(_table));
+  stack.push(vm.constants.getValue(_table));
 });
 
 APPEND_OPCODES.add(Op.PushBlockScope, (vm) => {
   let stack = vm.stack;
-  stack.push(vm.scope());
+  stack.push(vm.scope);
 });
 
 APPEND_OPCODES.add(Op.CompileBlock, (vm: InternalVM) => {
@@ -146,21 +194,25 @@ APPEND_OPCODES.add(Op.CompileBlock, (vm: InternalVM) => {
 APPEND_OPCODES.add(Op.InvokeYield, (vm) => {
   let { stack } = vm;
 
-  let handle = check(stack.pop(), CheckOption(CheckHandle));
-  let scope = check(stack.pop(), CheckOption(CheckScope));
-  let table = check(stack.pop(), CheckOption(CheckBlockSymbolTable));
+  // pop 3
+  let handle = check(stack.pop(), CheckNullable(CheckHandle));
+  let scope = check(stack.pop(), CheckNullable(CheckScope));
+  let table = check(stack.pop(), CheckNullable(CheckBlockSymbolTable));
 
   assert(
     table === null || (table && typeof table === 'object' && Array.isArray(table.parameters)),
     stackAssert('Option<BlockSymbolTable>', table)
   );
 
-  let args = check(stack.pop(), CheckInstanceof(VMArgumentsImpl));
+  // pop 1
+  const args = check(vm.stack.pop(), CheckArguments);
 
+  // To balance the pop{Frame,Scope}
   if (table === null) {
-    // To balance the pop{Frame,Scope}
+    // push 2
     vm.pushFrame();
-    vm.pushScope(scope ?? vm.scope());
+    // push 0
+    vm.pushScope(scope ?? vm.scope);
 
     return;
   }
@@ -181,47 +233,35 @@ APPEND_OPCODES.add(Op.InvokeYield, (vm) => {
     }
   }
 
+  // push 2
   vm.pushFrame();
+  // push 0
   vm.pushScope(invokingScope);
-  vm.call(handle!);
+  vm.call(handle);
 });
 
 APPEND_OPCODES.add(Op.JumpIf, (vm, { op1: target }) => {
-  let reference = check(vm.stack.pop(), CheckReference);
-  let value = Boolean(valueForRef(reference));
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  if (isConstRef(reference)) {
-    if (value === true) {
-      vm.goto(target);
-    }
-  } else {
-    if (value === true) {
-      vm.goto(target);
-    }
+  vm.deref(reference, (value) => {
+    if (value === true) vm.goto(target);
 
-    vm.updateWith(new Assert(reference));
-  }
+    return () => Assert.of(reference, value);
+  });
 });
 
 APPEND_OPCODES.add(Op.JumpUnless, (vm, { op1: target }) => {
-  let reference = check(vm.stack.pop(), CheckReference);
-  let value = Boolean(valueForRef(reference));
+  let reference = check(vm.stack.pop(), CheckReactive);
 
-  if (isConstRef(reference)) {
-    if (value === false) {
-      vm.goto(target);
-    }
-  } else {
-    if (value === false) {
-      vm.goto(target);
-    }
+  vm.deref(reference, (value) => {
+    if (!value) vm.goto(target);
 
-    vm.updateWith(new Assert(reference));
-  }
+    return () => Assert.of(reference, value);
+  });
 });
 
 APPEND_OPCODES.add(Op.JumpEq, (vm, { op1: target, op2: comparison }) => {
-  let other = check(vm.stack.peek(), CheckNumber);
+  let other = check(vm.stack.top(), CheckNumber);
 
   if (other === comparison) {
     vm.goto(target);
@@ -229,51 +269,50 @@ APPEND_OPCODES.add(Op.JumpEq, (vm, { op1: target, op2: comparison }) => {
 });
 
 APPEND_OPCODES.add(Op.AssertSame, (vm) => {
-  let reference = check(vm.stack.peek(), CheckReference);
+  let reference = check(vm.stack.top(), CheckReactive);
 
-  if (isConstRef(reference) === false) {
-    vm.updateWith(new Assert(reference));
-  }
+  vm.deref(reference, (value) => {
+    return () => Assert.of(reference, value);
+  });
 });
 
 APPEND_OPCODES.add(Op.ToBoolean, (vm) => {
   let { stack } = vm;
-  let valueRef = check(stack.pop(), CheckReference);
+  let valueRef = check(stack.pop(), CheckReactive);
 
-  stack.push(createComputeRef(() => toBool(valueForRef(valueRef))));
+  stack.push(ResultFormula(() => mapResult(readReactive(valueRef), toBool)));
 });
 
-export class Assert implements UpdatingOpcode {
-  private last: unknown;
-
-  constructor(private ref: Reference) {
-    this.last = valueForRef(ref);
+export class Assert<T, U> implements UpdatingOpcode {
+  static of<T>(reactive: Reactive<T>, value: T) {
+    return new Assert(reactive, value);
   }
 
-  evaluate(vm: UpdatingVM) {
-    let { last, ref } = this;
-    let current = valueForRef(ref);
-
-    if (last !== current) {
-      vm.throw();
-    }
+  static filtered<T, U>(reactive: Reactive<T>, value: U, filter: (from: T) => U) {
+    return new Assert(reactive, value, filter);
   }
-}
 
-export class AssertFilter<T, U> implements UpdatingOpcode {
-  private last: U;
+  readonly #reactive: Reactive<T>;
+  readonly #filter?: Optional<(from: T) => U>;
+
+  #last: U;
 
-  constructor(private ref: Reference<T>, private filter: (from: T) => U) {
-    this.last = filter(valueForRef(ref));
+  private constructor(reactive: Reactive<T>, value: U, filter?: (from: T) => U) {
+    this.#reactive = reactive;
+    this.#filter = filter;
+    this.#last = value;
   }
 
   evaluate(vm: UpdatingVM) {
-    let { last, ref, filter } = this;
-    let current = filter(valueForRef(ref));
+    vm.deref(this.#reactive, (value) => {
+      const currentValue = this.#filter ? this.#filter(value) : (value as unknown as U);
 
-    if (last !== current) {
-      vm.throw();
-    }
+      if (this.#last !== currentValue) {
+        vm.reset();
+      }
+
+      this.#last = currentValue;
+    });
   }
 }
 
@@ -304,10 +343,12 @@ export class JumpIfNotModifiedOpcode implements UpdatingOpcode {
 }
 
 export class BeginTrackFrameOpcode implements UpdatingOpcode {
-  constructor(private debugLabel?: string) {}
+  declare description: DevMode<Description>;
+
+  constructor() {}
 
   evaluate() {
-    beginTrackFrame(this.debugLabel);
+    beginTrackFrame(getDescription(this));
   }
 }
 
diff --git a/packages/@glimmer/runtime/lib/component/template-only.ts b/packages/@glimmer/runtime/lib/component/template-only.ts
index 303fc5f338..66493e4c94 100644
--- a/packages/@glimmer/runtime/lib/component/template-only.ts
+++ b/packages/@glimmer/runtime/lib/component/template-only.ts
@@ -1,6 +1,7 @@
 import type { InternalComponentCapabilities, InternalComponentManager } from "@glimmer/interfaces";
+import type {Reactive} from '@glimmer/reference';
 import { setInternalComponentManager } from '@glimmer/manager';
-import { NULL_REFERENCE, type Reference } from '@glimmer/reference';
+import { NULL_REFERENCE  } from '@glimmer/reference';
 
 const CAPABILITIES: InternalComponentCapabilities = {
   dynamicLayout: false,
@@ -27,7 +28,7 @@ export class TemplateOnlyComponentManager implements InternalComponentManager {
     return name;
   }
 
-  getSelf(): Reference {
+  getSelf(): Reactive {
     return NULL_REFERENCE;
   }
 
diff --git a/packages/@glimmer/runtime/lib/curried-value.ts b/packages/@glimmer/runtime/lib/curried-value.ts
index 3d6d1c2f0d..9d8d1213e2 100644
--- a/packages/@glimmer/runtime/lib/curried-value.ts
+++ b/packages/@glimmer/runtime/lib/curried-value.ts
@@ -6,7 +6,7 @@ import type {
   CurriedType,
   Owner,
 } from "@glimmer/interfaces";
-import type { Reference } from '@glimmer/reference';
+import type { Reactive } from '@glimmer/reference';
 
 const TYPE: unique symbol = Symbol('TYPE');
 const INNER: unique symbol = Symbol('INNER');
@@ -20,7 +20,7 @@ export function isCurriedValue(value: unknown): value is CurriedValue<CurriedTyp
   return CURRIED_VALUES.has(value as object);
 }
 
-export function isCurriedType<T extends CurriedType>(
+export function isCurried<T extends CurriedType>(
   value: unknown,
   type: T
 ): value is CurriedValue<T> {
@@ -55,8 +55,8 @@ interface ResolvedCurriedValue<T> {
   definition: T;
   owner: Owner;
   resolved: boolean;
-  positional: Reference[] | undefined;
-  named: Record<string, Reference>[] | undefined;
+  positional: Reactive[] | undefined;
+  named: Record<string, Reactive>[] | undefined;
 }
 
 export function resolveCurriedValue(
@@ -69,8 +69,8 @@ export function resolveCurriedValue(
   curriedValue: CurriedValue<CurriedType>
 ): ResolvedCurriedValue<object | string> {
   let currentWrapper = curriedValue;
-  let positional: Reference[] | undefined;
-  let named: Record<string, Reference>[] | undefined;
+  let positional: Reactive[] | undefined;
+  let named: Record<string, Reactive>[] | undefined;
   let definition, owner, resolved;
 
   // eslint-disable-next-line no-constant-condition
diff --git a/packages/@glimmer/runtime/lib/debug-render-tree.ts b/packages/@glimmer/runtime/lib/debug-render-tree.ts
index bacb1fbff6..d1d6c15ec8 100644
--- a/packages/@glimmer/runtime/lib/debug-render-tree.ts
+++ b/packages/@glimmer/runtime/lib/debug-render-tree.ts
@@ -1,16 +1,16 @@
 import type {
-  Bounds,
+  BlockBounds,
   CapturedRenderNode,
   DebugRenderTree,
   Nullable,
   RenderNode,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
 import { assign, expect, Stack } from '@glimmer/util';
 
 import { reifyArgs } from './vm/arguments';
 
 interface InternalRenderNode<T extends object> extends RenderNode {
-  bounds: Nullable<Bounds>;
+  bounds: Nullable<BlockBounds>;
   refs: Set<Ref<T>>;
   parent?: InternalRenderNode<T>;
 }
@@ -44,6 +44,7 @@ export class Ref<T extends object> {
       return `${label} (released)`;
     } else {
       try {
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string -- @todo
         return `${label}: ${this.value}`;
       } catch {
         return label;
@@ -55,14 +56,14 @@ export class Ref<T extends object> {
 export default class DebugRenderTreeImpl<TBucket extends object>
   implements DebugRenderTree<TBucket>
 {
-  private stack = new Stack<TBucket>();
+  private stack = Stack.empty<TBucket>();
 
   private refs = new WeakMap<TBucket, Ref<TBucket>>();
   private roots = new Set<Ref<TBucket>>();
   private nodes = new WeakMap<TBucket, InternalRenderNode<TBucket>>();
 
   begin(): void {
-    this.reset();
+    this.#reset();
   }
 
   create(state: TBucket, node: RenderNode): void {
@@ -71,21 +72,23 @@ export default class DebugRenderTreeImpl<TBucket extends object>
       refs: new Set<Ref<TBucket>>(),
     });
     this.nodes.set(state, internalNode);
-    this.appendChild(internalNode, state);
-    this.enter(state);
+    this.#appendChild(internalNode, state);
+    this.#enter(state);
   }
 
   update(state: TBucket): void {
-    this.enter(state);
+    this.#enter(state);
   }
 
-  didRender(state: TBucket, bounds: Bounds): void {
+  didRender(state: TBucket, bounds: BlockBounds): void {
     if (import.meta.env.DEV && this.stack.current !== state) {
+      // @todo
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
       throw new Error(`BUG: expecting ${this.stack.current}, got ${state}`);
     }
 
-    this.nodeFor(state).bounds = bounds;
-    this.exit();
+    this.#nodeFor(state).bounds = bounds;
+    this.#exit();
   }
 
   willDestroy(state: TBucket): void {
@@ -93,14 +96,14 @@ export default class DebugRenderTreeImpl<TBucket extends object>
   }
 
   commit(): void {
-    this.reset();
+    this.#reset();
   }
 
   capture(): CapturedRenderNode[] {
-    return this.captureRefs(this.roots);
+    return this.#captureRefs(this.roots);
   }
 
-  private reset(): void {
+  #reset(): void {
     if (this.stack.size !== 0) {
       // We probably encountered an error during the rendering loop. This will
       // likely trigger undefined behavior and memory leaks as the error left
@@ -118,17 +121,17 @@ export default class DebugRenderTreeImpl<TBucket extends object>
         this.roots.delete(ref);
       }
 
-      while (!this.stack.isEmpty()) {
+      while (this.stack.size !== 0) {
         this.stack.pop();
       }
     }
   }
 
-  private enter(state: TBucket): void {
+  #enter(state: TBucket): void {
     this.stack.push(state);
   }
 
-  private exit(): void {
+  #exit(): void {
     if (import.meta.env.DEV && this.stack.size === 0) {
       throw new Error('BUG: unbalanced pop');
     }
@@ -136,11 +139,11 @@ export default class DebugRenderTreeImpl<TBucket extends object>
     this.stack.pop();
   }
 
-  private nodeFor(state: TBucket): InternalRenderNode<TBucket> {
+  #nodeFor(state: TBucket): InternalRenderNode<TBucket> {
     return expect(this.nodes.get(state), 'BUG: missing node');
   }
 
-  private appendChild(node: InternalRenderNode<TBucket>, state: TBucket): void {
+  #appendChild(node: InternalRenderNode<TBucket>, state: TBucket): void {
     if (import.meta.env.DEV && this.refs.has(state)) {
       throw new Error('BUG: child already appended');
     }
@@ -151,7 +154,7 @@ export default class DebugRenderTreeImpl<TBucket extends object>
     this.refs.set(state, ref);
 
     if (parent) {
-      let parentNode = this.nodeFor(parent);
+      let parentNode = this.#nodeFor(parent);
       parentNode.refs.add(ref);
       node.parent = parentNode;
     } else {
@@ -159,14 +162,14 @@ export default class DebugRenderTreeImpl<TBucket extends object>
     }
   }
 
-  private captureRefs(refs: Set<Ref<TBucket>>): CapturedRenderNode[] {
+  #captureRefs(refs: Set<Ref<TBucket>>): CapturedRenderNode[] {
     let captured: CapturedRenderNode[] = [];
 
     refs.forEach((ref) => {
       let state = ref.get();
 
       if (state) {
-        captured.push(this.captureNode(`render-node:${ref.id}`, state));
+        captured.push(this.#captureNode(`render-node:${ref.id}`, state));
       } else {
         refs.delete(ref);
       }
@@ -175,20 +178,20 @@ export default class DebugRenderTreeImpl<TBucket extends object>
     return captured;
   }
 
-  private captureNode(id: string, state: TBucket): CapturedRenderNode {
-    let node = this.nodeFor(state);
+  #captureNode(id: string, state: TBucket): CapturedRenderNode {
+    let node = this.#nodeFor(state);
     let { type, name, args, instance, refs } = node;
-    let template = this.captureTemplate(node);
-    let bounds = this.captureBounds(node);
-    let children = this.captureRefs(refs);
+    let template = this.#captureTemplate(node);
+    let bounds = this.#captureBounds(node);
+    let children = this.#captureRefs(refs);
     return { id, type, name, args: reifyArgs(args), instance, template, bounds, children };
   }
 
-  private captureTemplate({ template }: InternalRenderNode<TBucket>): Nullable<string> {
+  #captureTemplate({ template }: InternalRenderNode<TBucket>): Nullable<string> {
     return template || null;
   }
 
-  private captureBounds(node: InternalRenderNode<TBucket>): CapturedRenderNode['bounds'] {
+  #captureBounds(node: InternalRenderNode<TBucket>): CapturedRenderNode['bounds'] {
     let bounds = expect(node.bounds, 'BUG: missing bounds');
     let parentElement = bounds.parentElement();
     let firstNode = bounds.firstNode();
diff --git a/packages/@glimmer/runtime/lib/dom/api.ts b/packages/@glimmer/runtime/lib/dom/api.ts
index d822a6882b..590f1c4c45 100644
--- a/packages/@glimmer/runtime/lib/dom/api.ts
+++ b/packages/@glimmer/runtime/lib/dom/api.ts
@@ -6,10 +6,11 @@ import type {
   SimpleDocument,
   SimpleElement,
 } from '@glimmer/interfaces';
-import { NS_SVG, castToSimple } from '@glimmer/util';
-import { DOMOperations } from './operations';
-import { applyTextNodeMergingFix } from '../compat/text-node-merging-fix';
+import { castToSimple,NS_SVG } from '@glimmer/util';
+
 import { applySVGInnerHTMLFix } from '../compat/svg-inner-html-fix';
+import { applyTextNodeMergingFix } from '../compat/text-node-merging-fix';
+import { DOMOperations } from './operations';
 
 const doc: Nullable<SimpleDocument> =
   typeof document === 'undefined' ? null : castToSimple(document);
diff --git a/packages/@glimmer/runtime/lib/dom/operations.ts b/packages/@glimmer/runtime/lib/dom/operations.ts
index f135c4889d..e6be7eedc6 100644
--- a/packages/@glimmer/runtime/lib/dom/operations.ts
+++ b/packages/@glimmer/runtime/lib/dom/operations.ts
@@ -1,5 +1,5 @@
 import type {
-  Bounds,
+  BlockBounds,
   Dict,
   Nullable,
   SimpleComment,
@@ -66,7 +66,7 @@ export class DOMOperations {
     parent.insertBefore(node, reference);
   }
 
-  insertHTMLBefore(parent: SimpleElement, nextSibling: Nullable<SimpleNode>, html: string): Bounds {
+  insertHTMLBefore(parent: SimpleElement, nextSibling: Nullable<SimpleNode>, html: string): BlockBounds {
     if (html === '') {
       const comment = this.createComment('');
       parent.insertBefore(comment, nextSibling);
@@ -113,7 +113,7 @@ export function moveNodesBefore(
   source: SimpleNode,
   target: SimpleElement,
   nextSibling: Nullable<SimpleNode>
-): Bounds {
+): BlockBounds {
   const first = expect(source.firstChild, 'source is empty');
   let last: SimpleNode = first;
   let current: Nullable<SimpleNode> = first;
diff --git a/packages/@glimmer/runtime/lib/environment.ts b/packages/@glimmer/runtime/lib/environment.ts
index 6b3645804e..21535c23a0 100644
--- a/packages/@glimmer/runtime/lib/environment.ts
+++ b/packages/@glimmer/runtime/lib/environment.ts
@@ -1,5 +1,6 @@
 import type {
   ComponentInstanceWithCreate,
+  Description,
   Environment,
   EnvironmentOptions,
   GlimmerTreeChanges,
@@ -13,7 +14,7 @@ import type {
   TransactionSymbol,
 } from '@glimmer/interfaces';
 import { RuntimeProgramImpl } from '@glimmer/program';
-import { assert, expect } from '@glimmer/util';
+import { assert, devmode, expect } from '@glimmer/util';
 import { track, updateTag } from '@glimmer/validator';
 
 import DebugRenderTree from './debug-render-tree';
@@ -24,6 +25,7 @@ export const TRANSACTION: TransactionSymbol = Symbol('TRANSACTION') as Transacti
 class TransactionImpl implements Transaction {
   public scheduledInstallModifiers: ModifierInstance[] = [];
   public scheduledUpdateModifiers: ModifierInstance[] = [];
+  public scheduledAfterRender: (() => void)[] = [];
   public createdComponents: ComponentInstanceWithCreate[] = [];
   public updatedComponents: ComponentInstanceWithCreate[] = [];
 
@@ -43,6 +45,10 @@ class TransactionImpl implements Transaction {
     this.scheduledUpdateModifiers.push(modifier);
   }
 
+  scheduleAfterRender(callback: () => void) {
+    this.scheduledAfterRender.push(callback);
+  }
+
   commit() {
     let { createdComponents, updatedComponents } = this;
 
@@ -62,10 +68,16 @@ class TransactionImpl implements Transaction {
       if (modifierTag !== null) {
         let tag = track(
           () => manager.install(state),
-          import.meta.env.DEV &&
-            `- While rendering:\n  (instance of a \`${
-              definition.resolvedName || manager.getDebugName(definition.state)
-            }\` modifier)`
+          devmode(() => {
+            return {
+              reason: 'modifier',
+              label: [
+                `- While rendering:\n  (instance of a \`${
+                  definition.resolvedName || manager.getDebugName(definition.state)
+                }\` modifier)`,
+              ],
+            } satisfies Description;
+          })
         );
         updateTag(modifierTag, tag);
       } else {
@@ -79,16 +91,24 @@ class TransactionImpl implements Transaction {
       if (modifierTag !== null) {
         let tag = track(
           () => manager.update(state),
-          import.meta.env.DEV &&
-            `- While rendering:\n  (instance of a \`${
-              definition.resolvedName || manager.getDebugName(definition.state)
-            }\` modifier)`
+          devmode(() => ({
+            kind: 'modifier',
+            label: [
+              `- While rendering:\n  (instance of a \`${
+                definition.resolvedName || manager.getDebugName(definition.state)
+              }\` modifier)`,
+            ],
+          }))
         );
         updateTag(modifierTag, tag);
       } else {
         manager.update(state);
       }
     }
+
+    for (const callback of this.scheduledAfterRender) {
+      callback();
+    }
   }
 }
 
@@ -101,9 +121,12 @@ export class EnvironmentImpl implements Environment {
   // Delegate methods and values
   public isInteractive: boolean;
 
-  debugRenderTree: DebugRenderTree<object> | undefined;
+  readonly debugRenderTree: DebugRenderTree<object> | undefined;
 
-  constructor(options: EnvironmentOptions, private delegate: EnvironmentDelegate) {
+  constructor(
+    options: EnvironmentOptions,
+    private delegate: EnvironmentDelegate
+  ) {
     this.isInteractive = delegate.isInteractive;
     this.debugRenderTree = this.delegate.enableDebugTooling ? new DebugRenderTree() : undefined;
     if (options.appendOperations) {
@@ -117,6 +140,12 @@ export class EnvironmentImpl implements Environment {
     }
   }
 
+  withDebug(debug: (tree: DebugRenderTree<object>) => void): void {
+    if (this.debugRenderTree) {
+      debug(this.debugRenderTree);
+    }
+  }
+
   getAppendOperations(): GlimmerTreeConstruction {
     return this.appendOperations;
   }
@@ -163,6 +192,10 @@ export class EnvironmentImpl implements Environment {
     }
   }
 
+  scheduleAfterRender(callback: () => void) {
+    this.transaction.scheduleAfterRender(callback);
+  }
+
   commit() {
     let transaction = this.transaction;
     this[TRANSACTION] = null;
diff --git a/packages/@glimmer/runtime/lib/helpers/array.ts b/packages/@glimmer/runtime/lib/helpers/array.ts
index 1dac54916c..7e6a7c3739 100644
--- a/packages/@glimmer/runtime/lib/helpers/array.ts
+++ b/packages/@glimmer/runtime/lib/helpers/array.ts
@@ -1,5 +1,6 @@
-import type { CapturedArguments } from "@glimmer/interfaces";
-import { createComputeRef, type Reference } from '@glimmer/reference';
+import type { CapturedArguments } from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
+import { Formula  } from '@glimmer/reference';
 
 import { reifyPositional } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
@@ -38,6 +39,8 @@ import { internalHelper } from './internal-helper';
    @public
  */
 
-export const array = internalHelper(({ positional }: CapturedArguments): Reference<unknown[]> => {
-  return createComputeRef(() => reifyPositional(positional), null, 'array');
-});
+export const array = internalHelper(
+  ({ positional }: CapturedArguments): Reactive<unknown[]> => {
+    return Formula(() => reifyPositional(positional), 'array');
+  }
+);
diff --git a/packages/@glimmer/runtime/lib/helpers/concat.ts b/packages/@glimmer/runtime/lib/helpers/concat.ts
index d70703e268..ea4fb0a5b1 100644
--- a/packages/@glimmer/runtime/lib/helpers/concat.ts
+++ b/packages/@glimmer/runtime/lib/helpers/concat.ts
@@ -1,5 +1,5 @@
-import type { CapturedArguments } from "@glimmer/interfaces";
-import { createComputeRef } from '@glimmer/reference';
+import type { CapturedArguments } from '@glimmer/interfaces';
+import { Formula } from '@glimmer/reference';
 
 import { reifyPositional } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
@@ -36,9 +36,8 @@ const normalizeTextValue = (value: unknown): string => {
   @method concat
 */
 export const concat = internalHelper(({ positional }: CapturedArguments) => {
-  return createComputeRef(
+  return Formula(
     () => reifyPositional(positional).map(normalizeTextValue).join(''),
-    null,
     'concat'
   );
 });
diff --git a/packages/@glimmer/runtime/lib/helpers/fn.ts b/packages/@glimmer/runtime/lib/helpers/fn.ts
index d7096f2d28..6906df92dc 100644
--- a/packages/@glimmer/runtime/lib/helpers/fn.ts
+++ b/packages/@glimmer/runtime/lib/helpers/fn.ts
@@ -1,13 +1,13 @@
+import type { CapturedArguments } from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
 import { check } from '@glimmer/debug';
-import type { CapturedArguments } from "@glimmer/interfaces";
 import {
-  createComputeRef,
-  isInvokableRef,
-  type Reference,
-  updateRef,
-  valueForRef,
+  Formula,
+  isAccessor,
+  unwrapReactive,
+  updateReactive
 } from '@glimmer/reference';
-import { buildUntouchableThis } from '@glimmer/util';
+import { buildUntouchableThis, stringifyDebugLabel } from '@glimmer/util';
 
 import { reifyPositional } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
@@ -81,37 +81,32 @@ const context = buildUntouchableThis('`fn` helper');
 export const fn = internalHelper(({ positional }: CapturedArguments) => {
   let callbackRef = check(positional[0], assertCallbackIsFn);
 
-  return createComputeRef(
-    () => {
-      return (...invocationArgs: unknown[]) => {
-        let [fn, ...args] = reifyPositional(positional);
-
-        if (import.meta.env.DEV) assertCallbackIsFn(callbackRef);
-
-        if (isInvokableRef(callbackRef)) {
-          let value = args.length > 0 ? args[0] : invocationArgs[0];
-          return updateRef(callbackRef, value);
-        } else {
-          return (fn as Function).call(context, ...args, ...invocationArgs);
-        }
-      };
-    },
-    null,
-    'fn'
-  );
+  return Formula(() => {
+    return (...invocationArgs: unknown[]) => {
+      let [fn, ...args] = reifyPositional(positional);
+
+      if (import.meta.env.DEV) assertCallbackIsFn(callbackRef);
+
+      if (isAccessor(callbackRef)) {
+        let value = args.length > 0 ? args[0] : invocationArgs[0];
+        return updateReactive(callbackRef, value);
+      } else {
+        return (fn as Function).call(context, ...args, ...invocationArgs);
+      }
+    };
+  }, 'fn');
 });
 
-function assertCallbackIsFn(callbackRef: Reference | undefined): asserts callbackRef is Reference {
+function assertCallbackIsFn(
+  callbackRef: Reactive | undefined
+): asserts callbackRef is Reactive {
   if (
-    !(
-      callbackRef &&
-      (isInvokableRef(callbackRef) || typeof valueForRef(callbackRef) === 'function')
-    )
+    !(callbackRef && (isAccessor(callbackRef) || typeof unwrapReactive(callbackRef) === 'function'))
   ) {
     throw new Error(
       `You must pass a function as the \`fn\` helper's first argument, you passed ${
-        callbackRef ? valueForRef(callbackRef) : callbackRef
-      }. While rendering:\n\n${callbackRef?.debugLabel}`
+        callbackRef ? unwrapReactive(callbackRef) : callbackRef
+      }. While rendering${callbackRef ? ':\n\n' + stringifyDebugLabel(callbackRef) : ''}`
     );
   }
 }
diff --git a/packages/@glimmer/runtime/lib/helpers/get.ts b/packages/@glimmer/runtime/lib/helpers/get.ts
index d9e82ee69b..3d83ef4aa0 100644
--- a/packages/@glimmer/runtime/lib/helpers/get.ts
+++ b/packages/@glimmer/runtime/lib/helpers/get.ts
@@ -1,6 +1,6 @@
+import type { CapturedArguments } from '@glimmer/interfaces';
 import { getPath, setPath } from '@glimmer/global-context';
-import type { CapturedArguments } from "@glimmer/interfaces";
-import { createComputeRef, UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference';
+import { Accessor, UNDEFINED_REFERENCE, unwrapReactive } from '@glimmer/reference';
 import { isDict } from '@glimmer/util';
 
 import { internalHelper } from './internal-helper';
@@ -86,20 +86,22 @@ export const get = internalHelper(({ positional }: CapturedArguments) => {
   let sourceRef = positional[0] ?? UNDEFINED_REFERENCE;
   let pathRef = positional[1] ?? UNDEFINED_REFERENCE;
 
-  return createComputeRef(
-    () => {
-      let source = valueForRef(sourceRef);
-
-      if (isDict(source)) {
-        return getPath(source, String(valueForRef(pathRef)));
-      }
-    },
-    (value) => {
-      let source = valueForRef(sourceRef);
-
-      if (isDict(source)) {
-        return setPath(source, String(valueForRef(pathRef)), value);
-      }
+  return Accessor(
+    {
+      get: () => {
+        let source = unwrapReactive(sourceRef);
+
+        if (isDict(source)) {
+          return getPath(source, String(unwrapReactive(pathRef)));
+        }
+      },
+      set: (value) => {
+        let source = unwrapReactive(sourceRef);
+
+        if (isDict(source)) {
+          return setPath(source, String(unwrapReactive(pathRef)), value);
+        }
+      },
     },
     'get'
   );
diff --git a/packages/@glimmer/runtime/lib/helpers/hash.ts b/packages/@glimmer/runtime/lib/helpers/hash.ts
index 7e9c10311b..3f7ad60fd1 100644
--- a/packages/@glimmer/runtime/lib/helpers/hash.ts
+++ b/packages/@glimmer/runtime/lib/helpers/hash.ts
@@ -1,6 +1,7 @@
-import { deprecate } from '@glimmer/global-context';
 import type { CapturedArguments, Dict } from '@glimmer/interfaces';
-import { createComputeRef, type Reference } from '@glimmer/reference';
+import type {Reactive} from '@glimmer/reference';
+import { deprecate } from '@glimmer/global-context';
+import { Formula  } from '@glimmer/reference';
 
 import { reifyNamed } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
@@ -63,8 +64,8 @@ if (import.meta.env.DEV) {
    @return {Object} Hash
    @public
  */
-export const hash = internalHelper(({ named }: CapturedArguments): Reference<Dict<unknown>> => {
-  let ref = createComputeRef(
+export const hash = internalHelper(({ named }: CapturedArguments): Reactive<Dict<unknown>> => {
+  let ref = Formula(
     () => {
       let hash = reifyNamed(named);
 
@@ -74,7 +75,7 @@ export const hash = internalHelper(({ named }: CapturedArguments): Reference<Dic
 
       return hash;
     },
-    null,
+
     'hash'
   );
 
@@ -86,7 +87,7 @@ export const hash = internalHelper(({ named }: CapturedArguments): Reference<Dic
     children.set(name, named[name]);
   }
 
-  ref.children = children;
+  ref.properties = children;
 
   return ref;
 });
diff --git a/packages/@glimmer/runtime/lib/helpers/invoke.ts b/packages/@glimmer/runtime/lib/helpers/invoke.ts
index 09bc6b3e8c..30124a8dfd 100644
--- a/packages/@glimmer/runtime/lib/helpers/invoke.ts
+++ b/packages/@glimmer/runtime/lib/helpers/invoke.ts
@@ -1,9 +1,10 @@
-import { associateDestroyableChild, isDestroyed, isDestroying } from '@glimmer/destroyable';
 import type { Arguments, InternalHelperManager } from "@glimmer/interfaces";
+import type {Cache} from '@glimmer/validator';
+import { associateDestroyableChild, isDestroyed, isDestroying } from '@glimmer/destroyable';
 import { getInternalHelperManager, hasDestroyable, hasValue } from '@glimmer/manager';
 import { getOwner } from '@glimmer/owner';
 import { debugToString } from '@glimmer/util';
-import { type Cache, createCache, getValue } from '@glimmer/validator';
+import {  createCache, getValue } from '@glimmer/validator';
 
 import { EMPTY_ARGS, EMPTY_NAMED, EMPTY_POSITIONAL } from '../vm/arguments';
 
diff --git a/packages/@glimmer/runtime/lib/modifiers/on.ts b/packages/@glimmer/runtime/lib/modifiers/on.ts
index 4a609b8807..d113cc41e5 100644
--- a/packages/@glimmer/runtime/lib/modifiers/on.ts
+++ b/packages/@glimmer/runtime/lib/modifiers/on.ts
@@ -1,15 +1,16 @@
-import { check, CheckFunction, CheckString } from '@glimmer/debug';
-import { registerDestructor } from '@glimmer/destroyable';
 import type {
   CapturedArguments,
   InternalModifierManager,
   Owner,
   SimpleElement,
-} from "@glimmer/interfaces";
+} from '@glimmer/interfaces';
+import type {UpdatableTag} from '@glimmer/validator';
+import { check, CheckFunction, CheckString } from '@glimmer/debug';
+import { registerDestructor } from '@glimmer/destroyable';
 import { setInternalModifierManager } from '@glimmer/manager';
-import { valueForRef } from '@glimmer/reference';
-import { buildUntouchableThis, expect } from '@glimmer/util';
-import { createUpdatableTag, type UpdatableTag } from '@glimmer/validator';
+import { unwrapReactive } from '@glimmer/reference';
+import { buildUntouchableThis, devmode, expect, stringifyDebugLabel } from '@glimmer/util';
+import { createUpdatableTag  } from '@glimmer/validator';
 
 import { reifyNamed } from '../vm/arguments';
 
@@ -51,7 +52,9 @@ const SUPPORTS_EVENT_OPTIONS = (() => {
 })();
 
 export class OnModifierState {
-  public tag = createUpdatableTag();
+  public tag = createUpdatableTag(
+    devmode(() => ({ label: ['{{on}}'], fallible: true, readonly: true }))
+  );
   public element: Element;
   public args: CapturedArguments;
   public declare eventName: string;
@@ -102,7 +105,7 @@ export class OnModifierState {
     );
 
     let eventName = check(
-      valueForRef(first),
+      unwrapReactive(first),
       CheckString,
       () => 'You must pass a valid DOM event name as the first argument to the `on` modifier'
     );
@@ -118,12 +121,14 @@ export class OnModifierState {
     );
 
     const userProvidedCallback = check(
-      valueForRef(userProvidedCallbackReference),
+      unwrapReactive(userProvidedCallbackReference),
       CheckFunction,
       (actual) => {
         return `You must pass a function as the second argument to the \`on\` modifier; you passed ${
           actual === null ? 'null' : typeof actual
-        }. While rendering:\n\n${userProvidedCallbackReference.debugLabel ?? `{unlabeled value}`}`;
+        }. While rendering:\n\n${
+          stringifyDebugLabel(userProvidedCallbackReference) ?? `{unlabeled value}`
+        }`;
       }
     ) as EventListener;
 
diff --git a/packages/@glimmer/runtime/lib/opcodes.ts b/packages/@glimmer/runtime/lib/opcodes.ts
index c17c4036e5..35e4be211a 100644
--- a/packages/@glimmer/runtime/lib/opcodes.ts
+++ b/packages/@glimmer/runtime/lib/opcodes.ts
@@ -1,23 +1,10 @@
-import { debug, logOpcode, opcodeMetadata, recordStackSize } from '@glimmer/debug';
-import type {
-  Dict,
-  Maybe,
-  Nullable,
-  RuntimeOp,
-  SomeVmOp,
-  VmMachineOp,
-  VmOp,
-} from "@glimmer/interfaces";
-import { LOCAL_DEBUG, LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
-import { valueForRef } from '@glimmer/reference';
-import { assert, fillNulls, LOCAL_LOGGER, unwrap } from '@glimmer/util';
-import { $fp, $pc, $ra, $sp, Op } from '@glimmer/vm';
+import type { DisassembledOperand } from '@glimmer/debug';
+import type { Dict, Nullable, Optional, RuntimeOp, VmMachineOp, VmOp } from '@glimmer/interfaces';
+import { assert, expect, fillNulls } from '@glimmer/util';
+import { OpSize } from '@glimmer/vm';
 
-import { isScopeReference } from './scope';
-import { CONSTANTS, DESTROYABLE_STACK, INNER_VM, STACKS } from './symbols';
-import type { LowLevelVM, VM } from './vm';
+import type { LowLevelVM,VM } from './vm';
 import type { InternalVM } from './vm/append';
-import { CURSOR_STACK } from './vm/element-builder';
 
 export interface OpcodeJSON {
   type: number | string;
@@ -45,130 +32,25 @@ export type DebugState = {
   type: VmMachineOp | VmOp;
   isMachine: 0 | 1;
   size: number;
-  params?: Maybe<Dict> | undefined;
-  name?: string | undefined;
+  params?: Optional<Dict<DisassembledOperand>>;
+  name?: Optional<string>;
   state: unknown;
 };
 
 export class AppendOpcodes {
-  private evaluateOpcode: Evaluate[] = fillNulls<Evaluate>(Op.Size).slice();
+  private evaluateOpcode: Evaluate[] = fillNulls<Evaluate>(OpSize).slice();
 
   add<Name extends VmOp>(name: Name, evaluate: Syscall): void;
   add<Name extends VmMachineOp>(name: Name, evaluate: MachineOpcode, kind: 'machine'): void;
-  add<Name extends SomeVmOp>(
-    name: Name,
-    evaluate: Syscall | MachineOpcode,
-    kind = 'syscall'
-  ): void {
+  add<Name extends VmOp>(name: Name, evaluate: Syscall | MachineOpcode, kind = 'syscall'): void {
     this.evaluateOpcode[name as number] = {
       syscall: kind !== 'machine',
       evaluate,
     } as Evaluate;
   }
 
-  debugBefore(vm: VM, opcode: RuntimeOp): DebugState {
-    let params: Maybe<Dict> = undefined;
-    let opName: string | undefined = undefined;
-
-    if (LOCAL_SHOULD_LOG) {
-      let pos = vm[INNER_VM].fetchRegister($pc) - opcode.size;
-
-      [opName, params] = debug(vm[CONSTANTS], opcode, opcode.isMachine)!;
-
-      // console.log(`${typePos(vm['pc'])}.`);
-      LOCAL_LOGGER.log(`${pos}. ${logOpcode(opName, params)}`);
-
-      let debugParams = [];
-      for (let prop in params) {
-        debugParams.push(prop, '=', params[prop]);
-      }
-
-      LOCAL_LOGGER.log(...debugParams);
-    }
-
-    let sp: number;
-
-    if (LOCAL_DEBUG) {
-      sp = vm.fetchValue($sp);
-    }
-
-    recordStackSize(vm.fetchValue($sp));
-    return {
-      sp: sp!,
-      pc: vm.fetchValue($pc),
-      name: opName,
-      params,
-      type: opcode.type,
-      isMachine: opcode.isMachine,
-      size: opcode.size,
-      state: undefined,
-    };
-  }
-
-  debugAfter(vm: VM, pre: DebugState) {
-    let { sp, type, isMachine, pc } = pre;
-
-    if (LOCAL_DEBUG) {
-      let meta = opcodeMetadata(type, isMachine);
-      let actualChange = vm.fetchValue($sp) - sp;
-      if (
-        meta &&
-        meta.check &&
-        typeof meta.stackChange! === 'number' &&
-        meta.stackChange !== actualChange
-      ) {
-        throw new Error(
-          `Error in ${pre.name}:\n\n${pc}. ${logOpcode(
-            pre.name!,
-            pre.params
-          )}\n\nStack changed by ${actualChange}, expected ${meta.stackChange}`
-        );
-      }
-
-      if (LOCAL_SHOULD_LOG) {
-        LOCAL_LOGGER.log(
-          '%c -> pc: %d, ra: %d, fp: %d, sp: %d, s0: %O, s1: %O, t0: %O, t1: %O, v0: %O',
-          'color: orange',
-          vm[INNER_VM].registers[$pc],
-          vm[INNER_VM].registers[$ra],
-          vm[INNER_VM].registers[$fp],
-          vm[INNER_VM].registers[$sp],
-          vm['s0'],
-          vm['s1'],
-          vm['t0'],
-          vm['t1'],
-          vm['v0']
-        );
-        LOCAL_LOGGER.log('%c -> eval stack', 'color: red', vm.stack.toArray());
-        LOCAL_LOGGER.log('%c -> block stack', 'color: magenta', vm.elements().debugBlocks());
-        LOCAL_LOGGER.log(
-          '%c -> destructor stack',
-          'color: violet',
-          vm[DESTROYABLE_STACK].toArray()
-        );
-        if (vm[STACKS].scope.current === null) {
-          LOCAL_LOGGER.log('%c -> scope', 'color: green', 'null');
-        } else {
-          LOCAL_LOGGER.log(
-            '%c -> scope',
-            'color: green',
-            vm.scope().slots.map((s) => (isScopeReference(s) ? valueForRef(s) : s))
-          );
-        }
-
-        LOCAL_LOGGER.log(
-          '%c -> elements',
-          'color: blue',
-          vm.elements()[CURSOR_STACK].current!.element
-        );
-
-        LOCAL_LOGGER.log('%c -> constructing', 'color: aqua', vm.elements()['constructing']);
-      }
-    }
-  }
-
   evaluate(vm: VM, opcode: RuntimeOp, type: number) {
-    let operation = unwrap(this.evaluateOpcode[type]);
+    let operation = expect(this.evaluateOpcode[type], `Unknown opcode ${type}`);
 
     if (operation.syscall) {
       assert(
@@ -181,7 +63,7 @@ export class AppendOpcodes {
         opcode.isMachine,
         `BUG: Mismatch between operation.syscall (${operation.syscall}) and opcode.isMachine (${opcode.isMachine}) for ${opcode.type}`
       );
-      operation.evaluate(vm[INNER_VM], opcode);
+      operation.evaluate(vm.lowLevel, opcode);
     }
   }
 }
diff --git a/packages/@glimmer/runtime/lib/references/class-list.ts b/packages/@glimmer/runtime/lib/references/class-list.ts
index 679c8edc21..38490810d6 100644
--- a/packages/@glimmer/runtime/lib/references/class-list.ts
+++ b/packages/@glimmer/runtime/lib/references/class-list.ts
@@ -1,13 +1,14 @@
-import { createComputeRef, type Reference, valueForRef } from '@glimmer/reference';
+import type {Reactive} from '@glimmer/reference';
+import { Formula,  unwrapReactive } from '@glimmer/reference';
 
 import { normalizeStringValue } from '../dom/normalize';
 
-export default function createClassListRef(list: Reference[]) {
-  return createComputeRef(() => {
+export default function createClassListRef(list: Reactive[]) {
+  return Formula(() => {
     let ret: string[] = [];
 
     for (const ref of list) {
-      let value = normalizeStringValue(typeof ref === 'string' ? ref : valueForRef(ref));
+      let value = normalizeStringValue(typeof ref === 'string' ? ref : unwrapReactive(ref));
       if (value) ret.push(value);
     }
 
diff --git a/packages/@glimmer/runtime/lib/references/curry-value.ts b/packages/@glimmer/runtime/lib/references/curry-value.ts
index c090b5a26a..375776c368 100644
--- a/packages/@glimmer/runtime/lib/references/curry-value.ts
+++ b/packages/@glimmer/runtime/lib/references/curry-value.ts
@@ -1,36 +1,36 @@
 import type {
   CapturedArguments,
   CurriedType,
-  Dict,
-  Maybe,
   Nullable,
   Owner,
   RuntimeResolver,
-} from "@glimmer/interfaces";
-import { createComputeRef, type Reference, valueForRef } from '@glimmer/reference';
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import { Formula, unwrapReactive } from '@glimmer/reference';
 import { expect, isObject } from '@glimmer/util';
 import { CurriedTypes } from '@glimmer/vm';
 
-import { curry, isCurriedType } from '../curried-value';
+import { curry, isCurried } from '../curried-value';
 
 export default function createCurryRef(
   type: CurriedType,
-  inner: Reference,
+  inner: Reactive,
   owner: Owner,
   args: Nullable<CapturedArguments>,
   resolver: RuntimeResolver,
   isStrict: boolean
 ) {
-  let lastValue: Maybe<Dict> | string, curriedDefinition: object | string | null;
+  let lastValue: unknown;
+  let curriedDefinition: object | string | null;
 
-  return createComputeRef(() => {
-    let value = valueForRef(inner) as Maybe<Dict> | string;
+  return Formula(() => {
+    let value = unwrapReactive(inner);
 
     if (value === lastValue) {
       return curriedDefinition;
     }
 
-    if (isCurriedType(value, type)) {
+    if (isCurried(value, type)) {
       curriedDefinition = args ? curry(type, value, owner, args) : args;
     } else if (type === CurriedTypes.Component && typeof value === 'string' && value) {
       // Only components should enter this path, as helpers and modifiers do not
diff --git a/packages/@glimmer/runtime/lib/render.ts b/packages/@glimmer/runtime/lib/render.ts
index c1198b6362..2ed05ad0b2 100644
--- a/packages/@glimmer/runtime/lib/render.ts
+++ b/packages/@glimmer/runtime/lib/render.ts
@@ -1,36 +1,48 @@
 import type {
   CompilableProgram,
-  CompileTimeCompilationContext,
   ComponentDefinitionState,
+  Description,
   DynamicScope,
   ElementBuilder,
   Environment,
+  Invocation,
+  JitContext,
   Owner,
   RenderResult,
   RichIteratorResult,
   RuntimeContext,
   TemplateIterator,
 } from '@glimmer/interfaces';
-import { childRefFor, createConstRef, type Reference } from '@glimmer/reference';
+import type { Reactive } from '@glimmer/reference';
+import { getReactiveProperty, ReadonlyCell } from '@glimmer/reference';
 import { expect, unwrapHandle } from '@glimmer/util';
 import { debug } from '@glimmer/validator';
 
+import type { InternalVM } from './vm/append';
+
 import { inTransaction } from './environment';
 import { DynamicScopeImpl } from './scope';
-import { ARGS, CONSTANTS } from './symbols';
-import { VM, type InternalVM } from './vm/append';
+import { VM } from './vm/append';
 
 class TemplateIteratorImpl implements TemplateIterator {
-  constructor(private vm: InternalVM) {}
+  readonly #vm: InternalVM;
+
+  constructor(vm: InternalVM) {
+    this.#vm = vm;
+  }
+
   next(): RichIteratorResult<null, RenderResult> {
-    return this.vm.next();
+    return this.#vm.next();
   }
 
   sync(): RenderResult {
     if (import.meta.env.DEV) {
-      return debug.runInTrackingTransaction!(() => this.vm.execute(), '- While rendering:');
+      return debug.runInTrackingTransaction!(() => this.#vm.execute(), {
+        reason: 'template',
+        label: ['- While rendering:'],
+      } satisfies Description);
     } else {
-      return this.vm.execute();
+      return this.#vm.execute();
     }
   }
 }
@@ -45,9 +57,9 @@ export function renderSync(env: Environment, iterator: TemplateIterator): Render
 
 export function renderMain(
   runtime: RuntimeContext,
-  context: CompileTimeCompilationContext,
+  context: JitContext,
   owner: Owner,
-  self: Reference,
+  self: Reactive,
   treeBuilder: ElementBuilder,
   layout: CompilableProgram,
   dynamicScope: DynamicScope = new DynamicScopeImpl()
@@ -67,20 +79,20 @@ export function renderMain(
 
 function renderInvocation(
   vm: InternalVM,
-  context: CompileTimeCompilationContext,
+  _context: JitContext,
   owner: Owner,
   definition: ComponentDefinitionState,
-  args: Record<string, Reference>
+  args: Record<string, Reactive>
 ): TemplateIterator {
-  // Get a list of tuples of argument names and references, like
-  // [['title', reference], ['name', reference]]
+  // Get a list of tuples of argument names and references, like [['title', reference], ['name',
+  // reference]]
   const argList = Object.keys(args).map((key) => [key, args[key]] as const);
 
   const blockNames = ['main', 'else', 'attrs'];
   // Prefix argument names with `@` symbol
   const argNames = argList.map(([name]) => `@${name}`);
 
-  let reified = vm[CONSTANTS].component(definition, owner);
+  let reified = vm.constants.component(definition, owner);
 
   vm.pushFrame();
 
@@ -97,46 +109,57 @@ function renderInvocation(
   });
 
   // Configure VM based on blocks and args just pushed on to the stack.
-  vm[ARGS].setup(vm.stack, argNames, blockNames, 0, true);
+  vm.args.setup(vm.argumentsStack, argNames, blockNames, 0, true);
 
   const compilable = expect(
     reified.compilable,
     'BUG: Expected the root component rendered with renderComponent to have an associated template, set with setComponentTemplate'
   );
-  const layoutHandle = unwrapHandle(compilable.compile(context));
-  const invocation = { handle: layoutHandle, symbolTable: compilable.symbolTable };
-
-  // Needed for the Op.Main opcode: arguments, component invocation object, and
-  // component definition.
-  vm.stack.push(vm[ARGS]);
+  const layoutHandle = unwrapHandle(vm.compile(compilable));
+  const invocation: Invocation = {
+    handle: layoutHandle,
+    symbolTable: compilable.symbolTable,
+    meta: compilable.meta,
+  };
+
+  // Needed for the Op.Main opcode: arguments, component invocation object, and component
+  // definition.
+  vm.stack.push(vm.args);
   vm.stack.push(invocation);
   vm.stack.push(reified);
 
+  vm.debugWillCall?.(invocation.handle);
+
   return new TemplateIteratorImpl(vm);
 }
 
 export function renderComponent(
   runtime: RuntimeContext,
   treeBuilder: ElementBuilder,
-  context: CompileTimeCompilationContext,
+  context: JitContext,
   owner: Owner,
   definition: ComponentDefinitionState,
   args: Record<string, unknown> = {},
   dynamicScope: DynamicScope = new DynamicScopeImpl()
 ): TemplateIterator {
-  let vm = VM.empty(
-    runtime,
-    { treeBuilder, handle: context.stdlib.main, dynamicScope, owner },
-    context
-  );
+  let vm = VM.initial(runtime, context, {
+    treeBuilder,
+    self: undefined,
+    handle: context.stdlib.main,
+    dynamicScope,
+    owner,
+  });
   return renderInvocation(vm, context, owner, definition, recordToReference(args));
 }
 
-function recordToReference(record: Record<string, unknown>): Record<string, Reference> {
-  const root = createConstRef(record, 'args');
+function recordToReference(record: Record<string, unknown>): Record<string, Reactive> {
+  const root = ReadonlyCell(record, 'args');
 
-  return Object.keys(record).reduce((acc, key) => {
-    acc[key] = childRefFor(root, key);
-    return acc;
-  }, {} as Record<string, Reference>);
+  return Object.keys(record).reduce(
+    (acc, key) => {
+      acc[key] = getReactiveProperty(root, key);
+      return acc;
+    },
+    {} as Record<string, Reactive>
+  );
 }
diff --git a/packages/@glimmer/runtime/lib/scope.ts b/packages/@glimmer/runtime/lib/scope.ts
index 93618bd146..fc5cb215a1 100644
--- a/packages/@glimmer/runtime/lib/scope.ts
+++ b/packages/@glimmer/runtime/lib/scope.ts
@@ -8,13 +8,14 @@ import type {
   ScopeBlock,
   ScopeSlot,
 } from "@glimmer/interfaces";
-import { type Reference, UNDEFINED_REFERENCE } from '@glimmer/reference';
+import type {Reactive} from '@glimmer/reference';
+import {  UNDEFINED_REFERENCE } from '@glimmer/reference';
 import { assign, unwrap } from '@glimmer/util';
 
 export class DynamicScopeImpl implements DynamicScope {
-  private bucket: Dict<Reference>;
+  private bucket: Dict<Reactive>;
 
-  constructor(bucket?: Dict<Reference>) {
+  constructor(bucket?: Dict<Reactive>) {
     if (bucket) {
       this.bucket = assign({}, bucket);
     } else {
@@ -22,11 +23,11 @@ export class DynamicScopeImpl implements DynamicScope {
     }
   }
 
-  get(key: string): Reference {
+  get(key: string): Reactive {
     return unwrap(this.bucket[key]);
   }
 
-  set(key: string, reference: Reference): Reference {
+  set(key: string, reference: Reactive): Reactive {
     return (this.bucket[key] = reference);
   }
 
@@ -35,14 +36,14 @@ export class DynamicScopeImpl implements DynamicScope {
   }
 }
 
-export function isScopeReference(s: ScopeSlot): s is Reference {
+export function isScopeReference(s: ScopeSlot): s is Reactive {
   if (s === null || Array.isArray(s)) return false;
   return true;
 }
 
 export class PartialScopeImpl implements PartialScope {
-  static root(self: Reference<unknown>, size = 0, owner: Owner): PartialScope {
-    let refs: Reference<unknown>[] = new Array(size + 1);
+  static root(self: Reactive<unknown>, size = 0, owner: Owner): PartialScope {
+    let refs: Reactive<unknown>[] = new Array(size + 1);
 
     for (let i = 0; i <= size; i++) {
       refs[i] = UNDEFINED_REFERENCE;
@@ -52,7 +53,7 @@ export class PartialScopeImpl implements PartialScope {
   }
 
   static sized(size = 0, owner: Owner): Scope {
-    let refs: Reference<unknown>[] = new Array(size + 1);
+    let refs: Reactive<unknown>[] = new Array(size + 1);
 
     for (let i = 0; i <= size; i++) {
       refs[i] = UNDEFINED_REFERENCE;
@@ -69,20 +70,20 @@ export class PartialScopeImpl implements PartialScope {
     // named arguments and blocks passed to a layout that uses eval
     private evalScope: Dict<ScopeSlot> | null,
     // locals in scope when the partial was invoked
-    private partialMap: Dict<Reference<unknown>> | null
+    private partialMap: Dict<Reactive<unknown>> | null
   ) {}
 
-  init({ self }: { self: Reference<unknown> }): this {
+  init({ self }: { self: Reactive<unknown> }): this {
     this.slots[0] = self;
     return this;
   }
 
-  getSelf(): Reference<unknown> {
-    return this.get<Reference<unknown>>(0);
+  getSelf(): Reactive<unknown> {
+    return this.get<Reactive<unknown>>(0);
   }
 
-  getSymbol(symbol: number): Reference<unknown> {
-    return this.get<Reference<unknown>>(symbol);
+  getSymbol(symbol: number): Reactive<unknown> {
+    return this.get<Reactive<unknown>>(symbol);
   }
 
   getBlock(symbol: number): Nullable<ScopeBlock> {
@@ -94,7 +95,7 @@ export class PartialScopeImpl implements PartialScope {
     return this.evalScope;
   }
 
-  getPartialMap(): Nullable<Dict<Reference<unknown>>> {
+  getPartialMap(): Nullable<Dict<Reactive<unknown>>> {
     return this.partialMap;
   }
 
@@ -102,11 +103,11 @@ export class PartialScopeImpl implements PartialScope {
     this.set(symbol, value);
   }
 
-  bindSelf(self: Reference<unknown>) {
-    this.set<Reference<unknown>>(0, self);
+  bindSelf(self: Reactive<unknown>) {
+    this.set<Reactive<unknown>>(0, self);
   }
 
-  bindSymbol(symbol: number, value: Reference<unknown>) {
+  bindSymbol(symbol: number, value: Reactive<unknown>) {
     this.set(symbol, value);
   }
 
@@ -118,7 +119,7 @@ export class PartialScopeImpl implements PartialScope {
     this.evalScope = map;
   }
 
-  bindPartialMap(map: Dict<Reference<unknown>>) {
+  bindPartialMap(map: Dict<Reactive<unknown>>) {
     this.partialMap = map;
   }
 
diff --git a/packages/@glimmer/runtime/lib/symbols.ts b/packages/@glimmer/runtime/lib/symbols.ts
index 984ec73c1b..60a4dded06 100644
--- a/packages/@glimmer/runtime/lib/symbols.ts
+++ b/packages/@glimmer/runtime/lib/symbols.ts
@@ -3,7 +3,6 @@
 // Glimmer's API.
 
 export const INNER_VM: unique symbol = Symbol('INNER_VM');
-export const DESTROYABLE_STACK: unique symbol = Symbol('DESTROYABLE_STACK');
 export const STACKS: unique symbol = Symbol('STACKS');
 export const REGISTERS: unique symbol = Symbol('REGISTERS');
 export const HEAP: unique symbol = Symbol('HEAP');
diff --git a/packages/@glimmer/runtime/lib/vm/append.ts b/packages/@glimmer/runtime/lib/vm/append.ts
index 7b459c7685..7309b46dc9 100644
--- a/packages/@glimmer/runtime/lib/vm/append.ts
+++ b/packages/@glimmer/runtime/lib/vm/append.ts
@@ -1,171 +1,362 @@
-import { associateDestroyableChild } from '@glimmer/destroyable';
-import { assertGlobalContextWasSet } from '@glimmer/global-context';
+import type { Checker, SnapshottableVM, VmDebugState } from '@glimmer/debug';
 import type {
+  BlockMetadata,
+  CleanStack,
   CompilableTemplate,
-  CompileTimeCompilationContext,
+  Description,
   Destroyable,
+  DevMode,
   DynamicScope,
   ElementBuilder,
   Environment,
+  ErrorHandler,
+  InternalStack,
+  JitContext,
+  MutableReactiveCell,
   Nullable,
+  OkResult,
   Owner,
   PartialScope,
+  ProgramConstants,
+  ReactiveResult,
   RenderResult,
-  ResolutionTimeConstants,
+  Result,
   RichIteratorResult,
-  RuntimeConstants,
   RuntimeContext,
-  RuntimeHeap,
   RuntimeProgram,
   Scope,
+  TargetState,
   UpdatingOpcode,
   VM as PublicVM,
+  VmStackAspect,
 } from '@glimmer/interfaces';
-import { LOCAL_SHOULD_LOG } from '@glimmer/local-debug-flags';
-import type { RuntimeOpImpl } from '@glimmer/program';
+import type { OpaqueIterationItem, OpaqueIterator, Reactive } from '@glimmer/reference';
+import type { MachineRegister, Register, SyscallRegister } from '@glimmer/vm';
+import { check } from '@glimmer/debug';
+import { associateDestroyableChild } from '@glimmer/destroyable';
+import { assertGlobalContextWasSet } from '@glimmer/global-context';
+import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import {
   createIteratorItemRef,
-  type OpaqueIterationItem,
-  type OpaqueIterator,
-  type Reference,
+  isConstant,
+  MutableCell,
+  readCell,
   UNDEFINED_REFERENCE,
+  writeCell,
 } from '@glimmer/reference';
-import { assert, expect, LOCAL_LOGGER, reverse, Stack, unwrapHandle } from '@glimmer/util';
-import { beginTrackFrame, endTrackFrame, resetTracking } from '@glimmer/validator';
+import { readReactive } from '@glimmer/reference/lib/api/core';
 import {
-  $fp,
-  $pc,
-  $s0,
-  $s1,
-  $sp,
-  $t0,
-  $t1,
-  $v0,
-  isLowLevelRegister,
-  type MachineRegister,
-  type Register,
-  type SyscallRegister,
-} from '@glimmer/vm';
+  assert,
+  BalancedStack,
+  createWithDescription,
+  EarlyError,
+  expect,
+  LOCAL_LOGGER,
+  mapResult,
+  parentDebugFrames,
+  PresentStack,
+  reverse,
+  Stack,
+  unreachable,
+  unwrapHandle,
+} from '@glimmer/util';
+import { beginTrackFrame, endTrackFrame, resetTracking } from '@glimmer/validator';
+import { $s0, $s1, $t0, $t1, $v0, isLowLevelRegister } from '@glimmer/vm';
+
+import type { LiveBlockList } from './element-builder';
+import type { ArgumentsStack } from './low-level';
+import type { BlockOpcode, InitialVmState } from './update';
 
+import { CheckReactive } from '../compiled/opcodes/-debug-strip';
 import {
   BeginTrackFrameOpcode,
   EndTrackFrameOpcode,
   JumpIfNotModifiedOpcode,
 } from '../compiled/opcodes/vm';
-import { APPEND_OPCODES, type DebugState } from '../opcodes';
 import { PartialScopeImpl } from '../scope';
-import { ARGS, CONSTANTS, DESTROYABLE_STACK, HEAP, INNER_VM, REGISTERS, STACKS } from '../symbols';
 import { VMArgumentsImpl } from './arguments';
-import type { LiveBlockList } from './element-builder';
+import { debugInit } from './debug/debug';
 import { LowLevelVM } from './low-level';
 import RenderResultImpl from './render-result';
-import EvaluationStackImpl, { type EvaluationStack } from './stack';
-import {
-  type BlockOpcode,
-  ListBlockOpcode,
-  ListItemOpcode,
-  type ResumableVMState,
-  ResumableVMStateImpl,
-  TryOpcode,
-  type VMState,
-} from './update';
+import EvaluationStackImpl from './stack';
+import { UnwindTarget } from './unwind';
+import { ListBlockOpcode, ListItemOpcode, TryOpcode } from './update';
 
-/**
- * This interface is used by internal opcodes, and is more stable than
- * the implementation of the Append VM itself.
- */
-export interface InternalVM {
-  readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;
-  readonly [ARGS]: VMArgumentsImpl;
+type Handle = number;
 
-  readonly env: Environment;
-  readonly stack: EvaluationStack;
-  readonly runtime: RuntimeContext;
-  readonly context: CompileTimeCompilationContext;
+class TemplateDebug {
+  readonly #templates: Map<Handle, BlockMetadata> = new Map();
+  #active: Handle[] = [];
 
-  loadValue(register: MachineRegister, value: number): void;
-  loadValue(register: Register, value: unknown): void;
-  loadValue(register: Register | MachineRegister, value: unknown): void;
+  willCall(handle: Handle): void {
+    this.#active.push(handle);
+  }
 
-  fetchValue(register: MachineRegister.ra | MachineRegister.pc): number;
-  // TODO: Something better than a type assertion?
-  fetchValue<T>(register: Register): T;
-  fetchValue(register: Register): unknown;
+  return(): void {
+    this.#active.pop();
+  }
 
-  load(register: Register): void;
-  fetch(register: Register): void;
+  get active(): BlockMetadata | null {
+    const current = this.#active.at(-1);
+    return current ? this.#templates.get(current) ?? null : null;
+  }
 
-  compile(block: CompilableTemplate): number;
+  register(handle: Handle, metadata: BlockMetadata): void {
+    this.#templates.set(handle, metadata);
+  }
+}
 
-  scope(): Scope;
-  elements(): ElementBuilder;
+class VMState implements VmStackAspect {
+  static initial(options: { scope: Scope; dynamicScope: DynamicScope }): VMState {
+    return new VMState(
+      PresentStack.initial(options.scope, 'scope stack'),
+      PresentStack.initial(options.dynamicScope, 'dynamic scope stack'),
+      Stack.empty('cache stack'),
+      Stack.empty('list stack'),
+      BalancedStack.empty('updating stack'),
+      BalancedStack.empty('destructor stack')
+    );
+  }
 
-  getOwner(): Owner;
-  getSelf(): Reference;
+  #scope: PresentStack<Scope>;
+  #dynamicScope: PresentStack<DynamicScope>;
+  #cache: Stack<JumpIfNotModifiedOpcode>;
+  #list: Stack<ListBlockOpcode>;
+  #updating: BalancedStack<UpdatingOpcode[]>;
+  #destructors: BalancedStack<Destroyable>;
 
-  updateWith(opcode: UpdatingOpcode): void;
+  constructor(
+    scope: PresentStack<Scope>,
+    dynamicScope: PresentStack<DynamicScope>,
+    cache: Stack<JumpIfNotModifiedOpcode>,
+    list: Stack<ListBlockOpcode>,
+    updating: BalancedStack<UpdatingOpcode[]>,
+    destructors: BalancedStack<Destroyable>
+  ) {
+    this.#scope = scope;
+    this.#dynamicScope = dynamicScope;
+    this.#cache = cache;
+    this.#list = list;
+    this.#updating = updating;
+    this.#destructors = destructors;
 
-  associateDestroyable(d: Destroyable): void;
+    if (import.meta.env.DEV) {
+      Object.defineProperty(this, 'debug', {
+        configurable: true,
+        get: function (this: VMState) {
+          return parentDebugFrames('vm state', {
+            scope: this.#scope,
+            dynamicScope: this.#dynamicScope,
+            cache: this.#cache,
+            list: this.#list,
+            updating: this.#updating,
+            destructors: this.#destructors,
+          });
+        },
+      });
+    }
+  }
 
-  beginCacheGroup(name?: string): void;
-  commitCacheGroup(): void;
+  get scope(): PresentStack<Scope> {
+    return this.#scope;
+  }
 
-  /// Iteration ///
+  get dynamicScope(): PresentStack<DynamicScope> {
+    return this.#dynamicScope;
+  }
 
-  enterList(iterableRef: Reference<OpaqueIterator>, offset: number): void;
-  exitList(): void;
-  enterItem(item: OpaqueIterationItem): ListItemOpcode;
-  registerItem(item: ListItemOpcode): void;
+  get cache(): Stack<JumpIfNotModifiedOpcode> {
+    return this.#cache;
+  }
 
-  pushRootScope(size: number, owner: Owner): PartialScope;
-  pushChildScope(): void;
-  popScope(): void;
-  pushScope(scope: Scope): void;
+  get list(): Stack<ListBlockOpcode> {
+    return this.#list;
+  }
 
-  dynamicScope(): DynamicScope;
-  bindDynamicScope(names: string[]): void;
-  pushDynamicScope(): void;
-  popDynamicScope(): void;
+  get updating(): BalancedStack<UpdatingOpcode[]> {
+    return this.#updating;
+  }
 
-  enter(args: number): void;
-  exit(): void;
+  get destructors(): BalancedStack<Destroyable> {
+    return this.#destructors;
+  }
 
-  goto(pc: number): void;
-  call(handle: number): void;
-  pushFrame(): void;
+  begin(): this {
+    this.#cache = this.#cache.begin();
+    this.#scope = this.#scope.begin();
+    this.#dynamicScope = this.#dynamicScope.begin();
+    this.#list = this.#list.begin();
+    this.#destructors = this.#destructors.begin();
+    this.#updating = this.#updating.begin();
+    return this;
+  }
 
-  referenceForSymbol(symbol: number): Reference;
+  catch(): this {
+    this.#cache = this.#cache.catch();
+    this.#scope = this.#scope.catch();
+    this.#dynamicScope = this.#dynamicScope.catch();
+    this.#list = this.#list.catch();
+    this.#destructors = this.#destructors.catch();
+    this.#updating = this.#updating.catch();
+    return this;
+  }
 
-  execute(initialize?: (vm: this) => void): RenderResult;
-  pushUpdating(list?: UpdatingOpcode[]): void;
-  next(): RichIteratorResult<null, RenderResult>;
+  finally(): this {
+    this.#cache = this.#cache.finally();
+    this.#scope = this.#scope.finally();
+    this.#dynamicScope = this.#dynamicScope.finally();
+    this.#list = this.#list.finally();
+    this.#destructors = this.#destructors.finally();
+    this.#updating = this.#updating.finally();
+    return this;
+  }
 }
 
-class Stacks {
-  readonly scope = new Stack<Scope>();
-  readonly dynamicScope = new Stack<DynamicScope>();
-  readonly updating = new Stack<UpdatingOpcode[]>();
-  readonly cache = new Stack<JumpIfNotModifiedOpcode>();
-  readonly list = new Stack<ListBlockOpcode>();
-}
+export class VM implements PublicVM, SnapshottableVM {
+  static {
+    if (import.meta.env.DEV) {
+      Object.defineProperties(VM.prototype, {
+        debugWillCall: {
+          configurable: true,
+          value: function (this: VM, handle: number) {
+            this.#templates?.willCall(handle);
+          },
+        },
+        debugDidReturn: {
+          enumerable: true,
+          value: function (this: VM) {
+            this.#templates?.return();
+          },
+        },
+      });
+    }
+  }
+
+  readonly #state: VMState;
+  readonly #elements: ElementBuilder;
+  readonly #args: VMArgumentsImpl;
+  readonly #context: JitContext;
+
+  readonly #inner: LowLevelVM;
+  readonly #templates?: TemplateDebug;
+  #block: TryOpcode;
+
+  declare debugWillCall?: (handle: number) => void;
+  declare debugDidReturn?: () => void;
+
+  private constructor(
+    readonly runtime: RuntimeContext,
+    { pc, scope, dynamicScope, stack, unwind, context, destructor, isTryFrame }: InitialVmState,
+    elementStack: ElementBuilder
+  ) {
+    if (import.meta.env.DEV) {
+      assertGlobalContextWasSet!();
+    }
+
+    assert(typeof pc === 'number', 'pc is a number');
+    let evalStack = EvaluationStackImpl.restore(stack, pc, unwind);
+
+    this.#context = context;
+    this.#elements = elementStack;
+    this.#state = VMState.initial({ scope, dynamicScope });
+    this.#args = new VMArgumentsImpl();
+    this.#inner = LowLevelVM.create(
+      evalStack,
+      this.#heap,
+      runtime.program,
+      { debug: this },
+      evalStack.registers
+    );
+
+    this.start(destructor);
+    let block = this.#elements.block;
+    let opcode = new TryOpcode(
+      this.#capture(this.#inner.stack.size, isTryFrame),
+      this.runtime,
+      block,
+      []
+    );
+
+    this.#block = opcode;
+    this.#pushUpdating(opcode.children);
+    this.#pushDestructor(opcode);
+
+    if (import.meta.env.DEV) {
+      this.#templates = new TemplateDebug();
+    }
+  }
+
+  get #heap() {
+    return this.#context.heap;
+  }
+
+  get lowLevel(): LowLevelVM {
+    return this.#inner;
+  }
 
-export class VM implements PublicVM, InternalVM {
-  private readonly [STACKS] = new Stacks();
-  private readonly [HEAP]: RuntimeHeap;
-  private readonly destructor: object;
-  private readonly [DESTROYABLE_STACK] = new Stack<object>();
-  readonly [CONSTANTS]: RuntimeConstants & ResolutionTimeConstants;
-  readonly [ARGS]: VMArgumentsImpl;
-  readonly [INNER_VM]: LowLevelVM;
+  get stack(): CleanStack {
+    return this.#inner.stack;
+  }
 
-  get stack(): EvaluationStack {
-    return this[INNER_VM].stack as EvaluationStack;
+  get internalStack(): InternalStack {
+    return this.#inner.internalStack;
+  }
+
+  get argumentsStack(): ArgumentsStack {
+    return this.#inner.forArguments;
+  }
+
+  get args(): VMArgumentsImpl {
+    return this.#args;
   }
 
   /* Registers */
 
-  get pc(): number {
-    return this[INNER_VM].fetchRegister($pc);
+  get sp(): number {
+    return this.#inner.sp;
+  }
+
+  get fp(): number {
+    return this.#inner.fp;
+  }
+
+  get debug(): VmDebugState {
+    if (import.meta.env.DEV) {
+      let inner = this.#inner;
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const vm = this;
+      const templates = this.#templates!;
+      const currentSlots = this.#state.scope.current.slots;
+      const slots = currentSlots ? [...currentSlots] : [];
+      const registers = inner.debug.registers.debug;
+      const dom = this.elements();
+      // const blocks = this.block
+
+      const evalStack = inner.debug.stack;
+
+      return {
+        ...registers,
+        currentPc: inner.debug.currentPc,
+        constant: {
+          constants: vm.constants,
+          heap: vm.#heap,
+        },
+
+        dom: dom.debug,
+
+        block: {
+          metadata: templates.active,
+        },
+
+        stack: evalStack,
+        scope: slots,
+        updating: this.#state.updating.toArray(),
+        destroyable: this.#state.destructors.toArray(),
+        threw: inner.debug.threw,
+      } satisfies VmDebugState;
+    }
+
+    unreachable(`BUG: Don't call 'vm.debug' without checking import.meta.env.DEV`);
   }
 
   public s0: unknown = null;
@@ -174,6 +365,10 @@ export class VM implements PublicVM, InternalVM {
   public t1: unknown = null;
   public v0: unknown = null;
 
+  earlyError(message: string, from?: Reactive): never {
+    throw new EarlyError(message, from);
+  }
+
   // Fetch a value from a register onto the stack
   fetch(register: SyscallRegister): void {
     let value = this.fetchValue(register);
@@ -188,34 +383,30 @@ export class VM implements PublicVM, InternalVM {
     this.loadValue(register, value);
   }
 
-  // Fetch a value from a register
-  fetchValue(register: MachineRegister): number;
-  fetchValue<T>(register: Register): T;
-  fetchValue(register: Register | MachineRegister): unknown {
-    if (isLowLevelRegister(register)) {
-      return this[INNER_VM].fetchRegister(register);
-    }
-
+  /**
+   * Fetch a value from a high-level register
+   */
+  fetchValue<T>(register: SyscallRegister): T {
     switch (register) {
       case $s0:
-        return this.s0;
+        return this.s0 as T;
       case $s1:
-        return this.s1;
+        return this.s1 as T;
       case $t0:
-        return this.t0;
+        return this.t0 as T;
       case $t1:
-        return this.t1;
+        return this.t1 as T;
       case $v0:
-        return this.v0;
+        return this.v0 as T;
+      default:
+        unreachable(`BUG: Cannot fetch from register ${register}`);
     }
   }
 
   // Load a value into a register
 
   loadValue<T>(register: Register | MachineRegister, value: T): void {
-    if (isLowLevelRegister(register)) {
-      this[INNER_VM].loadRegister(register, value as any as number);
-    }
+    assert(!isLowLevelRegister(register), `BUG: Cannot load into a low-level register`);
 
     switch (register) {
       case $s0:
@@ -242,121 +433,91 @@ export class VM implements PublicVM, InternalVM {
 
   // Start a new frame and save $ra and $fp on the stack
   pushFrame() {
-    this[INNER_VM].pushFrame();
+    this.#inner.pushFrame();
   }
 
   // Restore $ra, $sp and $fp
   popFrame() {
-    this[INNER_VM].popFrame();
+    this.#inner.popFrame();
   }
 
   // Jump to an address in `program`
   goto(offset: number) {
-    this[INNER_VM].goto(offset);
+    this.#inner.goto(offset);
   }
 
   // Save $pc into $ra, then jump to a new address in `program` (jal in MIPS)
-  call(handle: number) {
-    this[INNER_VM].call(handle);
+  call(handle: number | null) {
+    if (handle !== null) {
+      if (import.meta.env.DEV) {
+        this.#templates?.willCall(handle);
+      }
+
+      this.#inner.call(handle);
+    }
   }
 
-  // Put a specific `program` address in $ra
-  returnTo(offset: number) {
-    this[INNER_VM].returnTo(offset);
+  start(destructor = {}) {
+    this.#state.destructors.push(destructor);
   }
 
   // Return to the `program` address stored in $ra
   return() {
-    this[INNER_VM].return();
-  }
-
-  /**
-   * End of migrated.
-   */
-
-  constructor(
-    readonly runtime: RuntimeContext,
-    { pc, scope, dynamicScope, stack }: VMState,
-    private readonly elementStack: ElementBuilder,
-    readonly context: CompileTimeCompilationContext
-  ) {
     if (import.meta.env.DEV) {
-      assertGlobalContextWasSet!();
+      this.#templates?.return();
     }
 
-    this.resume = initVM(context);
-    let evalStack = EvaluationStackImpl.restore(stack);
+    this.#inner.return();
+  }
 
-    assert(typeof pc === 'number', 'pc is a number');
+  static initial(runtime: RuntimeContext, context: JitContext, options: InitOptions) {
+    const { handle, dynamicScope, treeBuilder: elements, owner } = options;
 
-    evalStack[REGISTERS][$pc] = pc;
-    evalStack[REGISTERS][$sp] = stack.length - 1;
-    evalStack[REGISTERS][$fp] = -1;
-
-    this[HEAP] = this.program.heap;
-    this[CONSTANTS] = this.program.constants;
-    this.elementStack = elementStack;
-    this[STACKS].scope.push(scope);
-    this[STACKS].dynamicScope.push(dynamicScope);
-    this[ARGS] = new VMArgumentsImpl();
-    this[INNER_VM] = new LowLevelVM(
-      evalStack,
-      this[HEAP],
-      runtime.program,
-      {
-        debugBefore: (opcode: RuntimeOpImpl): DebugState => {
-          return APPEND_OPCODES.debugBefore(this, opcode);
-        },
+    let scope =
+      'self' in options
+        ? PartialScopeImpl.root(options.self, options.numSymbols, owner)
+        : PartialScopeImpl.root(UNDEFINED_REFERENCE, 0, owner);
 
-        debugAfter: (state: DebugState): void => {
-          APPEND_OPCODES.debugAfter(this, state);
-        },
-      },
-      evalStack[REGISTERS]
-    );
+    const destructor = {};
 
-    this.destructor = {};
-    this[DESTROYABLE_STACK].push(this.destructor);
-  }
+    let vmState: InitialVmState = {
+      pc: runtime.program.heap.getaddr(handle),
+      scope,
+      dynamicScope,
+      stack: [],
+      unwind: UnwindTarget.root(MutableCell(1)),
+      context,
+      isTryFrame: false,
+      destructor,
+    };
 
-  static initial(
-    runtime: RuntimeContext,
-    context: CompileTimeCompilationContext,
-    { handle, self, dynamicScope, treeBuilder, numSymbols, owner }: InitOptions
-  ) {
-    let scope = PartialScopeImpl.root(self, numSymbols, owner);
-    let state = vmState(runtime.program.heap.getaddr(handle), scope, dynamicScope);
-    let vm = initVM(context)(runtime, state, treeBuilder);
-    vm.pushUpdating();
-    return vm;
+    return new VM(runtime, vmState, elements);
   }
 
-  static empty(
-    runtime: RuntimeContext,
-    { handle, treeBuilder, dynamicScope, owner }: MinimalInitOptions,
-    context: CompileTimeCompilationContext
-  ) {
-    let vm = initVM(context)(
-      runtime,
-      vmState(
-        runtime.program.heap.getaddr(handle),
-        PartialScopeImpl.root(UNDEFINED_REFERENCE, 0, owner),
-        dynamicScope
-      ),
-      treeBuilder
-    );
-    vm.pushUpdating();
-    return vm;
-  }
+  static resume(runtime: RuntimeContext, resumeState: InitialVmState, elements: ElementBuilder) {
+    const destructor = {};
+    const state = {
+      ...resumeState,
+      destructor,
+    };
 
-  private resume: VmInitCallback;
+    return new VM(runtime, state, elements);
+  }
 
   compile(block: CompilableTemplate): number {
-    let handle = unwrapHandle(block.compile(this.context));
+    let handle = unwrapHandle(block.compile(this.#context));
+
+    if (import.meta.env.DEV) {
+      this.#templates?.register(handle, block.meta);
+    }
 
     return handle;
   }
 
+  get constants(): ProgramConstants {
+    return this.program.constants;
+  }
+
   get program(): RuntimeProgram {
     return this.runtime.program;
   }
@@ -365,33 +526,35 @@ export class VM implements PublicVM, InternalVM {
     return this.runtime.env;
   }
 
-  captureState(args: number, pc = this[INNER_VM].fetchRegister($pc)): VMState {
+  #capture(args: number, isTryFrame: boolean, pc = this.#inner.pc): InitialVmState {
     return {
       pc,
-      scope: this.scope(),
-      dynamicScope: this.dynamicScope(),
-      stack: this.stack.capture(args),
+      scope: this.scope,
+      dynamicScope: this.dynamicScope,
+      stack: this.argumentsStack.capture(args),
+      ...this.#inner.capture(),
+      destructor: this.#destructor,
+      context: this.#context,
+      isTryFrame,
     };
   }
 
-  capture(args: number, pc = this[INNER_VM].fetchRegister($pc)): ResumableVMState {
-    return new ResumableVMStateImpl(this.captureState(args, pc), this.resume);
-  }
-
-  beginCacheGroup(name?: string) {
-    let opcodes = this.updating();
+  beginCacheGroup(description: DevMode<Description>) {
+    let opcodes = this.#updating();
     let guard = new JumpIfNotModifiedOpcode();
 
     opcodes.push(guard);
-    opcodes.push(new BeginTrackFrameOpcode(name));
-    this[STACKS].cache.push(guard);
 
-    beginTrackFrame(name);
+    opcodes.push(createWithDescription(() => new BeginTrackFrameOpcode(), description));
+
+    this.#state.cache.push(guard);
+
+    beginTrackFrame(description);
   }
 
   commitCacheGroup() {
-    let opcodes = this.updating();
-    let guard = expect(this[STACKS].cache.pop(), 'VM BUG: Expected a cache group');
+    let opcodes = this.#updating();
+    let guard = expect(this.#state.cache.pop(), 'VM BUG: Expected a cache group');
 
     let tag = endTrackFrame();
     opcodes.push(new EndTrackFrameOpcode(guard));
@@ -399,15 +562,131 @@ export class VM implements PublicVM, InternalVM {
     guard.finalize(tag, opcodes.length);
   }
 
-  enter(args: number) {
-    let updating: UpdatingOpcode[] = [];
+  target(pc: number): number {
+    return this.#inner.target(pc);
+  }
 
-    let state = this.capture(args);
+  /**
+   * Set up the $up variable for an error recovery boundary. Once the $up is set up, a block is
+   * {@linkcode enter}ed and {@linkcode begin} is called inside the block.
+   *
+   * The entered block (i.e. the {@linkcode TryOpcode}) will be added to the opcode list whether or
+   * not an error occurs.
+   *
+   * If an error occurs, the {@linkcode TryOpcode} will be in an error state, and it will remain
+   * empty until the error is recovered.
+   *
+   * If no error occurs, the {@linkcode TryOpcode} will have updating opcodes as children and will
+   * update as usual. If any of the descendants opcode throw an error, the {@linkcode TryOpcode}
+   * will become empty and enter an error state. It will remain empty until the error is recovered.
+   */
+  setupBegin(
+    instruction: number,
+    error: MutableReactiveCell<number>,
+    handler: Nullable<ErrorHandler>
+  ) {
+    this.#inner.begin(instruction, error, handler);
+  }
+
+  /**
+   * Open an error recovery boundary.
+   *
+   * This creates a checkpoint for the element builder and the internal VM state.
+   *
+   * If {@linkcode finally} is reached, the work done between here and {@linkcode finally} is
+   * committed.
+   *
+   * If {@linkcode catch} is called, any work done between here and {@linkcode catch} is rolled
+   * back.
+   */
+  begin() {
+    this.elements().begin();
+    this.#state.begin();
+  }
+
+  /**
+   * The work done inside the error recovery boundary reached its conclusion and no error occurred.
+   */
+  finally(): void {
+    this.#state.finally();
+    this.elements().finally();
+    this.#inner.finally();
+  }
+
+  /**
+   * An error occurred inside of an error boundary. Roll back the work done inside the error recovery
+   * boundary and place the {@linkcode TryOpcode} in an error state.
+   */
+  catch(error: unknown): TargetState {
+    this.#state.catch();
+    this.elements().catch();
+    return this.#inner.catch(error);
+  }
+
+  /**
+   * Begin a `Try` block, capturing {@linkcode args} arguments from the stack.
+   *
+   * A `Try` block must contain at least one assertion (such as `Assert` or `AssertSame`). When an
+   * assertion fails, the {@linkcode TryOpcode} will clear its current contents and begin evaluation
+   * from the next instruction.
+   *
+   * A call to {@linkcode enter} always occurs inside of a frame boundary (i.e. its paired
+   * {@linkcode exit} occurs before a call to {@linkcode return}).
+   *
+   * During initial render, the `$ra` register controls what happens once the {@linkcode return} is
+   * reached.
+   *
+   * When a {@linkcode TryOpcode} is *re-evaluated*, its `$ra` will be set to `-1`, which will
+   * result in the VM exiting once the block is done.
+   *
+   * ## Error Recovery
+   *
+   * If `begin` is true, the {@linkcode TryOpcode} will be an error recovery boundary. This means
+   * that errors that occur in descendants of the {@linkcode TryOpcode} will result in clearing the
+   * `TryOpcode` and invoking the boundary's handler.
+   *
+   * Otherwise, the {@linkcode TryOpcode} behaves the same as any other block.
+   *
+   * ## State Changes
+   *
+   * 1. An updatable block is added to the block stack
+   * 2. A {@linkcode TryOpcode} corresponding to the block is added to the current updating opcode list
+   * 3. A new list of updating opcodes is pushed to the updating opcode stack
+   */
+  enter(args: number, isTryFrame: boolean): TryOpcode {
     let block = this.elements().pushUpdatableBlock();
 
-    let tryOpcode = new TryOpcode(state, this.runtime, block, updating);
+    return this.#didEnter(new TryOpcode(this.#capture(args, isTryFrame), this.runtime, block, []));
+  }
+
+  /**
+   *
+   * @returns
+   */
+  exit(): UpdatingOpcode[] {
+    this.elements().popBlock();
+    return this.#closeBlock();
+  }
+
+  #didEnter<B extends BlockOpcode>(opcode: B): B {
+    this.#pushDestructor(opcode);
+    this.#openBlock(opcode);
+    return opcode;
+  }
+
+  #pushDestructor(destructor: object) {
+    this.associateDestroyable(destructor);
+    this.#state.destructors.push(destructor);
+  }
+
+  #openBlock(opcode: BlockOpcode) {
+    this.updateWith(opcode);
+    this.#pushUpdating(opcode.children);
+  }
 
-    this.didEnter(tryOpcode);
+  #closeBlock(): UpdatingOpcode[] {
+    this.#state.destructors.pop();
+    return this.#popUpdating();
   }
 
   enterItem({ key, value, memo }: OpaqueIterationItem): ListItemOpcode {
@@ -419,157 +698,229 @@ export class VM implements PublicVM, InternalVM {
     stack.push(valueRef);
     stack.push(memoRef);
 
-    let state = this.capture(2);
     let block = this.elements().pushUpdatableBlock();
 
-    let opcode = new ListItemOpcode(state, this.runtime, block, key, memoRef, valueRef);
-    this.didEnter(opcode);
+    let opcode = new ListItemOpcode(
+      this.#capture(2, false),
+      this.runtime,
+      block,
+      key,
+      memoRef,
+      valueRef
+    );
+
+    this.#didEnter(opcode);
 
     return opcode;
   }
 
   registerItem(opcode: ListItemOpcode) {
-    this.listBlock().initializeChild(opcode);
+    this.#listBlock().initializeChild(opcode);
   }
 
-  enterList(iterableRef: Reference<OpaqueIterator>, offset: number) {
+  enterList(iterableRef: Reactive<OpaqueIterator>, relativeStart: number) {
     let updating: ListItemOpcode[] = [];
 
-    let addr = this[INNER_VM].target(offset);
-    let state = this.capture(0, addr);
+    let addr = this.#inner.target(relativeStart);
+    let state = this.#capture(0, false, addr);
     let list = this.elements().pushBlockList(updating) as LiveBlockList;
 
     let opcode = new ListBlockOpcode(state, this.runtime, list, updating, iterableRef);
 
-    this[STACKS].list.push(opcode);
-
-    this.didEnter(opcode);
-  }
-
-  private didEnter(opcode: BlockOpcode) {
-    this.associateDestroyable(opcode);
-    this[DESTROYABLE_STACK].push(opcode);
-    this.updateWith(opcode);
-    this.pushUpdating(opcode.children);
-  }
+    this.#state.list.push(opcode);
 
-  exit() {
-    this[DESTROYABLE_STACK].pop();
-    this.elements().popBlock();
-    this.popUpdating();
+    this.#didEnter(opcode);
   }
 
   exitList() {
     this.exit();
-    this[STACKS].list.pop();
+    this.#state.list.pop();
   }
 
-  pushUpdating(list: UpdatingOpcode[] = []): void {
-    this[STACKS].updating.push(list);
+  #pushUpdating(list: UpdatingOpcode[] = []): void {
+    this.#state.updating.push(list);
   }
 
-  popUpdating(): UpdatingOpcode[] {
-    return expect(this[STACKS].updating.pop(), "can't pop an empty stack");
+  #popUpdating(): UpdatingOpcode[] {
+    return expect(this.#state.updating.pop(), "can't pop an empty stack");
   }
 
   updateWith(opcode: UpdatingOpcode) {
-    this.updating().push(opcode);
+    this.#updating().push(opcode);
   }
 
-  listBlock(): ListBlockOpcode {
-    return expect(this[STACKS].list.current, 'expected a list block');
+  #listBlock(): ListBlockOpcode {
+    return expect(this.#state.list.current, 'expected a list block');
   }
 
   associateDestroyable(child: Destroyable): void {
-    let parent = expect(this[DESTROYABLE_STACK].current, 'Expected destructor parent');
-    associateDestroyableChild(parent, child);
+    associateDestroyableChild(this.#destructor, child);
   }
 
-  tryUpdating(): Nullable<UpdatingOpcode[]> {
-    return this[STACKS].updating.current;
+  #updating(): UpdatingOpcode[] {
+    return this.#state.updating.present;
   }
 
-  updating(): UpdatingOpcode[] {
-    return expect(
-      this[STACKS].updating.current,
-      'expected updating opcode on the updating opcode stack'
-    );
+  elements(): ElementBuilder {
+    return this.#elements;
   }
 
-  elements(): ElementBuilder {
-    return this.elementStack;
+  get #destructor(): Destroyable {
+    return this.#state.destructors.present;
   }
 
-  scope(): Scope {
-    return expect(this[STACKS].scope.current, 'expected scope on the scope stack');
+  get scope(): Scope {
+    return this.#state.scope.current;
   }
 
-  dynamicScope(): DynamicScope {
-    return expect(
-      this[STACKS].dynamicScope.current,
-      'expected dynamic scope on the dynamic scope stack'
-    );
+  get dynamicScope(): DynamicScope {
+    return this.#state.dynamicScope.current;
   }
 
   pushChildScope() {
-    this[STACKS].scope.push(this.scope().child());
+    this.#state.scope.push(this.scope.child());
   }
 
   pushDynamicScope(): DynamicScope {
-    let child = this.dynamicScope().child();
-    this[STACKS].dynamicScope.push(child);
+    let child = this.dynamicScope.child();
+    this.#state.dynamicScope.push(child);
     return child;
   }
 
   pushRootScope(size: number, owner: Owner): PartialScope {
     let scope = PartialScopeImpl.sized(size, owner);
-    this[STACKS].scope.push(scope);
+    this.#state.scope.push(scope);
     return scope;
   }
 
   pushScope(scope: Scope) {
-    this[STACKS].scope.push(scope);
+    this.#state.scope.push(scope);
   }
 
   popScope() {
-    this[STACKS].scope.pop();
+    this.#state.scope.pop();
   }
 
   popDynamicScope() {
-    this[STACKS].dynamicScope.pop();
+    this.#state.dynamicScope.pop();
+  }
+
+  bindDynamicScope(names: string[]) {
+    let scope = this.dynamicScope;
+
+    for (const name of reverse(names)) {
+      scope.set(name, this.stack.pop<Reactive<unknown>>());
+    }
   }
 
   /// SCOPE HELPERS
 
   getOwner(): Owner {
-    return this.scope().owner;
+    return this.scope.owner;
+  }
+
+  getSelf(): Reactive<unknown> {
+    return this.scope.getSelf();
+  }
+
+  referenceForSymbol(symbol: number): Reactive {
+    return this.scope.getSymbol(symbol);
+  }
+
+  popResult<T>(checker: Checker<T>): [Reactive<T>, ReactiveResult<T>] {
+    const reactive = check(this.stack.pop(), CheckReactive);
+    const result = readReactive(reactive);
+
+    if (import.meta.env.DEV) {
+      if (result.type === 'ok') {
+        check(result.value, checker);
+      }
+
+      return [reactive as Reactive<T>, result as ReactiveResult<T>];
+    } else {
+      return [reactive as Reactive<T>, result as ReactiveResult<T>];
+    }
+  }
+
+  popReactive<T>(then: (value: T) => void, checker: Checker<T>) {
+    const reactive = check(this.stack.pop(), CheckReactive);
+
+    this.deref(reactive, (value) => {
+      then(check(value, checker));
+    });
+  }
+
+  deref<T>(
+    reactive: Reactive<T>,
+    then: (value: T) => void | ((reactive: Reactive<T>, value: T) => UpdatingOpcode)
+  ): void {
+    const result = this.derefReactive(reactive);
+
+    if (this.unwrapResult(result)) {
+      const update = then(result.value);
+
+      if (update && !isConstant(reactive)) {
+        this.updateWith(update(reactive, result.value));
+      }
+    }
+  }
+
+  derefReactive<T>(reference: Reactive<T>): Result<T>;
+  derefReactive<T, U>(reference: Reactive<T>, map: (value: T) => U): Result<U>;
+  derefReactive(reference: Reactive<unknown>, map?: (value: unknown) => unknown): Result<unknown> {
+    return this.#deref(reference, map);
   }
 
-  getSelf(): Reference<any> {
-    return this.scope().getSelf();
+  #deref(reactive: Reactive, map?: undefined | ((value: unknown) => unknown)): Result<unknown> {
+    const result = readReactive(reactive);
+    return map ? mapResult(result, map) : result;
   }
 
-  referenceForSymbol(symbol: number): Reference {
-    return this.scope().getSymbol(symbol);
+  unwrap<T>(result: Result<T>, then: (value: T) => void): void {
+    if (this.unwrapResult(result)) {
+      return then(result.value);
+    }
+  }
+
+  unwrapResult<T>(result: Result<T>): result is OkResult<T> {
+    if (result.type === 'ok') {
+      return true;
+    }
+
+    const { handler, error } = this.catch(result.value);
+
+    if (handler) {
+      this.env.scheduleAfterRender(() => {
+        handler(result.value, () => {
+          writeCell(error, readCell(error) + 1);
+        });
+      });
+    }
+
+    return false;
   }
 
   /// EXECUTION
 
   execute(initialize?: (vm: this) => void): RenderResult {
     if (import.meta.env.DEV) {
+      if (LOCAL_TRACE_LOGGING) {
+        LOCAL_LOGGER.groupCollapsed(`EXECUTING FROM ${this.#inner.debug.registers.pc}`);
+      }
+
       let hasErrored = true;
       try {
-        let value = this._execute(initialize);
+        let value = this.#execute(initialize);
 
-        // using a boolean here to avoid breaking ergonomics of "pause on uncaught exceptions"
-        // which would happen with a `catch` + `throw`
+        // using a boolean here to avoid breaking ergonomics of "pause on uncaught exceptions" which
+        // would happen with a `catch` + `throw`
         hasErrored = false;
 
         return value;
       } finally {
         if (hasErrored) {
-          // If any existing blocks are open, due to an error or something like
-          // that, we need to close them all and clean things up properly.
+          // If any existing blocks are open, due to an error or something like that, we need to
+          // close them all and clean things up properly.
           let elements = this.elements();
 
           while (elements.hasBlocks) {
@@ -579,68 +930,56 @@ export class VM implements PublicVM, InternalVM {
           // eslint-disable-next-line no-console
           console.error(`\n\nError occurred:\n\n${resetTracking()}\n\n`);
         }
+
+        if (LOCAL_TRACE_LOGGING) {
+          LOCAL_LOGGER.groupEnd();
+        }
       }
     } else {
-      return this._execute(initialize);
+      return this.#execute(initialize);
     }
   }
 
-  private _execute(initialize?: (vm: this) => void): RenderResult {
-    if (LOCAL_SHOULD_LOG) {
-      LOCAL_LOGGER.log(`EXECUTING FROM ${this[INNER_VM].fetchRegister($pc)}`);
-    }
-
+  #execute(initialize?: (vm: this) => void): RenderResult {
     if (initialize) initialize(this);
 
     let result: RichIteratorResult<null, RenderResult>;
 
+    debugInit(this);
+
     do result = this.next();
     while (!result.done);
 
+    if (this.#inner.result.type === 'err') {
+      throw this.#inner.result.value;
+    }
+
     return result.value;
   }
 
   next(): RichIteratorResult<null, RenderResult> {
-    let { env, elementStack } = this;
-    let opcode = this[INNER_VM].nextStatement();
+    let opcode = this.#inner.nextStatement();
     let result: RichIteratorResult<null, RenderResult>;
     if (opcode !== null) {
-      this[INNER_VM].evaluateOuter(opcode, this);
+      this.#inner.evaluateOuter(opcode, this);
       result = { done: false, value: null };
     } else {
       // Unload the stack
-      this.stack.reset();
+      this.internalStack.reset();
+
+      // Close the initial block -- this ensures that closing block serialization occurs
+      this.elements().popBlock();
 
       result = {
         done: true,
-        value: new RenderResultImpl(
-          env,
-          this.popUpdating(),
-          elementStack.popBlock(),
-          this.destructor
-        ),
+        value: new RenderResultImpl(this.env, this.#block),
       };
     }
     return result;
   }
-
-  bindDynamicScope(names: string[]) {
-    let scope = this.dynamicScope();
-
-    for (const name of reverse(names)) {
-      scope.set(name, this.stack.pop<Reference<unknown>>());
-    }
-  }
 }
 
-function vmState(pc: number, scope: Scope, dynamicScope: DynamicScope) {
-  return {
-    pc,
-    scope,
-    dynamicScope,
-    stack: [],
-  };
-}
+export type InternalVM = VM;
 
 export interface MinimalInitOptions {
   handle: number;
@@ -649,18 +988,16 @@ export interface MinimalInitOptions {
   owner: Owner;
 }
 
-export interface InitOptions extends MinimalInitOptions {
-  self: Reference;
+export interface ScopedInitOptions extends MinimalInitOptions {
+  self: Reactive;
   numSymbols: number;
 }
 
+export type InitOptions = ScopedInitOptions | MinimalInitOptions;
+
 export type VmInitCallback = (
   this: void,
   runtime: RuntimeContext,
-  state: VMState,
+  state: InitialVmState,
   builder: ElementBuilder
 ) => InternalVM;
-
-function initVM(context: CompileTimeCompilationContext): VmInitCallback {
-  return (runtime, state, builder) => new VM(runtime, state, builder, context);
-}
diff --git a/packages/@glimmer/runtime/lib/vm/arguments.ts b/packages/@glimmer/runtime/lib/vm/arguments.ts
index 2fb5eea71a..51b99e3339 100644
--- a/packages/@glimmer/runtime/lib/vm/arguments.ts
+++ b/packages/@glimmer/runtime/lib/vm/arguments.ts
@@ -1,4 +1,3 @@
-import { check, CheckBlockSymbolTable, CheckHandle, CheckOption, CheckOr } from '@glimmer/debug';
 import type {
   BlockArguments,
   BlockSymbolTable,
@@ -15,20 +14,17 @@ import type {
   Scope,
   ScopeBlock,
   VMArguments,
-} from "@glimmer/interfaces";
-import {
-  createDebugAliasRef,
-  type Reference,
-  UNDEFINED_REFERENCE,
-  valueForRef,
-} from '@glimmer/reference';
+} from '@glimmer/interfaces';
+import type { Reactive } from '@glimmer/reference';
+import type { Tag } from '@glimmer/validator';
+import { check, CheckBlockSymbolTable, CheckHandle, CheckNullable, CheckOr } from '@glimmer/debug';
+import { createDebugAliasRef, UNDEFINED_REFERENCE, unwrapReactive } from '@glimmer/reference';
 import { dict, EMPTY_STRING_ARRAY, emptyArray, enumerate, unwrap } from '@glimmer/util';
-import { CONSTANT_TAG, type Tag } from '@glimmer/validator';
-import { $sp } from '@glimmer/vm';
+import { CONSTANT_TAG } from '@glimmer/validator';
 
-import { CheckCompilableBlock, CheckReference, CheckScope } from '../compiled/opcodes/-debug-strip';
-import { REGISTERS } from '../symbols';
-import type { EvaluationStack } from './stack';
+import type { ArgumentsStack } from './low-level';
+
+import { CheckCompilableBlock, CheckReactive, CheckScope } from '../compiled/opcodes/-debug-strip';
 
 /*
   The calling convention is:
@@ -39,13 +35,13 @@ import type { EvaluationStack } from './stack';
 */
 
 export class VMArgumentsImpl implements VMArguments {
-  private stack: Nullable<EvaluationStack> = null;
+  private stack: Nullable<ArgumentsStack> = null;
   public positional = new PositionalArgumentsImpl();
   public named = new NamedArgumentsImpl();
   public blocks = new BlockArgumentsImpl();
 
-  empty(stack: EvaluationStack): this {
-    let base = stack[REGISTERS][$sp] + 1;
+  empty(stack: ArgumentsStack): this {
+    let base = stack.registers.sp + 1;
 
     this.named.empty(stack, base);
     this.positional.empty(stack, base);
@@ -55,7 +51,7 @@ export class VMArgumentsImpl implements VMArguments {
   }
 
   setup(
-    stack: EvaluationStack,
+    stack: ArgumentsStack,
     names: readonly string[],
     blockNames: readonly string[],
     positionalCount: number,
@@ -73,7 +69,7 @@ export class VMArgumentsImpl implements VMArguments {
 
     let named = this.named;
     let namedCount = names.length;
-    let namedBase = stack[REGISTERS][$sp] - namedCount + 1;
+    let namedBase = stack.registers.sp - namedCount + 1;
 
     named.setup(stack, namedBase, namedCount, names, atNames);
 
@@ -97,7 +93,7 @@ export class VMArgumentsImpl implements VMArguments {
     return this.positional.length + this.named.length + this.blocks.length * 3;
   }
 
-  at(pos: number): Reference {
+  at(pos: number): Reactive {
     return this.positional.at(pos);
   }
 
@@ -114,7 +110,7 @@ export class VMArgumentsImpl implements VMArguments {
 
       positional.base += offset;
       named.base += offset;
-      stack[REGISTERS][$sp] += offset;
+      stack.registers.advanceSp(offset);
     }
   }
 
@@ -131,17 +127,18 @@ export class VMArgumentsImpl implements VMArguments {
   }
 }
 
-const EMPTY_REFERENCES = emptyArray<Reference>();
+const EMPTY_REFERENCES = emptyArray<Reactive>();
 
 export class PositionalArgumentsImpl implements PositionalArguments {
   public base = 0;
   public length = 0;
 
-  private stack: EvaluationStack = null as any;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private stack: ArgumentsStack = null as any;
 
-  private _references: Nullable<readonly Reference[]> = null;
+  private _references: Nullable<readonly Reactive[]> = null;
 
-  empty(stack: EvaluationStack, base: number) {
+  empty(stack: ArgumentsStack, base: number) {
     this.stack = stack;
     this.base = base;
     this.length = 0;
@@ -149,7 +146,7 @@ export class PositionalArgumentsImpl implements PositionalArguments {
     this._references = EMPTY_REFERENCES;
   }
 
-  setup(stack: EvaluationStack, base: number, length: number) {
+  setup(stack: ArgumentsStack, base: number, length: number) {
     this.stack = stack;
     this.base = base;
     this.length = length;
@@ -161,21 +158,21 @@ export class PositionalArgumentsImpl implements PositionalArguments {
     }
   }
 
-  at(position: number): Reference {
+  at(position: number): Reactive {
     let { base, length, stack } = this;
 
     if (position < 0 || position >= length) {
       return UNDEFINED_REFERENCE;
     }
 
-    return check(stack.get(position, base), CheckReference);
+    return check(stack.get(position, base), CheckReactive);
   }
 
   capture(): CapturedPositionalArguments {
     return this.references as CapturedPositionalArguments;
   }
 
-  prepend(other: Reference[]) {
+  prepend(other: Reactive[]) {
     let additions = other.length;
 
     if (additions > 0) {
@@ -192,12 +189,12 @@ export class PositionalArgumentsImpl implements PositionalArguments {
     }
   }
 
-  private get references(): readonly Reference[] {
+  private get references(): readonly Reactive[] {
     let references = this._references;
 
     if (!references) {
       let { stack, base, length } = this;
-      references = this._references = stack.slice<Reference>(base, base + length);
+      references = this._references = stack.slice<Reactive>(base, base + length);
     }
 
     return references;
@@ -208,14 +205,14 @@ export class NamedArgumentsImpl implements NamedArguments {
   public base = 0;
   public length = 0;
 
-  private declare stack: EvaluationStack;
+  private declare stack: ArgumentsStack;
 
-  private _references: Nullable<readonly Reference[]> = null;
+  private _references: Nullable<readonly Reactive[]> = null;
 
   private _names: Nullable<readonly string[]> = EMPTY_STRING_ARRAY;
   private _atNames: Nullable<readonly string[]> = EMPTY_STRING_ARRAY;
 
-  empty(stack: EvaluationStack, base: number) {
+  empty(stack: ArgumentsStack, base: number) {
     this.stack = stack;
     this.base = base;
     this.length = 0;
@@ -226,7 +223,7 @@ export class NamedArgumentsImpl implements NamedArguments {
   }
 
   setup(
-    stack: EvaluationStack,
+    stack: ArgumentsStack,
     base: number,
     length: number,
     names: readonly string[],
@@ -277,7 +274,7 @@ export class NamedArgumentsImpl implements NamedArguments {
     return this.names.indexOf(name) !== -1;
   }
 
-  get(name: string, atNames = false): Reference {
+  get(name: string, atNames = false): Reactive {
     let { base, stack } = this;
 
     let names = atNames ? this.atNames : this.names;
@@ -288,22 +285,18 @@ export class NamedArgumentsImpl implements NamedArguments {
       return UNDEFINED_REFERENCE;
     }
 
-    let ref = stack.get<Reference>(idx, base);
+    let ref = stack.get<Reactive>(idx, base);
 
-    if (import.meta.env.DEV) {
-      return createDebugAliasRef!(atNames ? name : `@${name}`, ref);
-    } else {
-      return ref;
-    }
+    return createDebugAliasRef(ref, () => (atNames ? name : `@${name}`));
   }
 
   capture(): CapturedNamedArguments {
     let { names, references } = this;
-    let map = dict<Reference>();
+    let map = dict<Reactive>();
 
     for (const [i, name] of enumerate(names)) {
       if (import.meta.env.DEV) {
-        map[name] = createDebugAliasRef!(`@${name}`, unwrap(references[i]));
+        map[name] = createDebugAliasRef(unwrap(references[i]), () => `@${name}`);
       } else {
         map[name] = unwrap(references[i]);
       }
@@ -312,7 +305,7 @@ export class NamedArgumentsImpl implements NamedArguments {
     return map as CapturedNamedArguments;
   }
 
-  merge(other: Record<string, Reference>) {
+  merge(other: Record<string, Reactive>) {
     let keys = Object.keys(other);
 
     if (keys.length > 0) {
@@ -335,12 +328,12 @@ export class NamedArgumentsImpl implements NamedArguments {
     }
   }
 
-  private get references(): readonly Reference[] {
+  private get references(): readonly Reactive[] {
     let references = this._references;
 
     if (!references) {
       let { base, length, stack } = this;
-      references = this._references = stack.slice<Reference>(base, base + length);
+      references = this._references = stack.slice<Reactive>(base, base + length);
     }
 
     return references;
@@ -362,7 +355,7 @@ function toSymbolName(name: string): string {
 const EMPTY_BLOCK_VALUES = emptyArray<BlockValue>();
 
 export class BlockArgumentsImpl implements BlockArguments {
-  private declare stack: EvaluationStack;
+  private declare stack: ArgumentsStack;
   private internalValues: Nullable<readonly BlockValue[]> = null;
   private _symbolNames: Nullable<readonly string[]> = null;
 
@@ -372,7 +365,7 @@ export class BlockArgumentsImpl implements BlockArguments {
   public length = 0;
   public base = 0;
 
-  empty(stack: EvaluationStack, base: number) {
+  empty(stack: ArgumentsStack, base: number) {
     this.stack = stack;
     this.names = EMPTY_STRING_ARRAY;
     this.base = base;
@@ -383,7 +376,7 @@ export class BlockArgumentsImpl implements BlockArguments {
     this.internalValues = EMPTY_BLOCK_VALUES;
   }
 
-  setup(stack: EvaluationStack, base: number, length: number, names: readonly string[]) {
+  setup(stack: ArgumentsStack, base: number, length: number, names: readonly string[]) {
     this.stack = stack;
     this.names = names;
     this.base = base;
@@ -423,11 +416,11 @@ export class BlockArgumentsImpl implements BlockArguments {
 
     let { base, stack } = this;
 
-    let table = check(stack.get(idx * 3, base), CheckOption(CheckBlockSymbolTable));
-    let scope = check(stack.get(idx * 3 + 1, base), CheckOption(CheckScope));
+    let table = check(stack.get(idx * 3, base), CheckNullable(CheckBlockSymbolTable));
+    let scope = check(stack.get(idx * 3 + 1, base), CheckNullable(CheckScope));
     let handle = check(
       stack.get(idx * 3 + 2, base),
-      CheckOption(CheckOr(CheckHandle, CheckCompilableBlock))
+      CheckNullable(CheckOr(CheckHandle, CheckCompilableBlock))
     );
 
     return handle === null ? null : ([handle, scope!, table!] as ScopeBlock);
@@ -451,7 +444,10 @@ export class BlockArgumentsImpl implements BlockArguments {
 class CapturedBlockArgumentsImpl implements CapturedBlockArguments {
   public length: number;
 
-  constructor(public names: readonly string[], public values: readonly Nullable<BlockValue>[]) {
+  constructor(
+    public names: readonly string[],
+    public values: readonly Nullable<BlockValue>[]
+  ) {
     this.length = names.length;
   }
 
@@ -472,28 +468,34 @@ class CapturedBlockArgumentsImpl implements CapturedBlockArguments {
   }
 }
 
-export function createCapturedArgs(named: Dict<Reference>, positional: Reference[]) {
+export function createCapturedArgs(
+  named: Dict<Reactive>,
+  positional: Reactive[]
+): CapturedArguments {
   return {
     named,
     positional,
   } as CapturedArguments;
 }
 
-export function reifyNamed(named: CapturedNamedArguments) {
+export function reifyNamed(named: CapturedNamedArguments): Dict<unknown> {
   let reified = dict();
 
   for (const [key, value] of Object.entries(named)) {
-    reified[key] = valueForRef(value);
+    reified[key] = unwrapReactive(value);
   }
 
   return reified;
 }
 
-export function reifyPositional(positional: CapturedPositionalArguments) {
-  return positional.map(valueForRef);
+export function reifyPositional(positional: CapturedPositionalArguments): unknown[] {
+  return positional.map(unwrapReactive);
 }
 
-export function reifyArgs(args: CapturedArguments) {
+export function reifyArgs(args: CapturedArguments): {
+  named: Dict<unknown>;
+  positional: unknown[];
+} {
   return {
     named: reifyNamed(args.named),
     positional: reifyPositional(args.positional),
diff --git a/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts b/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts
index 0cc86b366a..9141e4badc 100644
--- a/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts
+++ b/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts
@@ -1,4 +1,3 @@
-import { warnIfStyleNotTrusted } from '@glimmer/global-context';
 import type {
   AttributeCursor,
   AttributeOperation,
@@ -9,6 +8,7 @@ import type {
   Nullable,
   SimpleElement,
 } from "@glimmer/interfaces";
+import { warnIfStyleNotTrusted } from '@glimmer/global-context';
 import { castToBrowser, NS_SVG } from '@glimmer/util';
 
 import { normalizeStringValue } from '../../dom/normalize';
diff --git a/packages/@glimmer/runtime/lib/vm/content/text.ts b/packages/@glimmer/runtime/lib/vm/content/text.ts
index 0621364f76..7cb0793281 100644
--- a/packages/@glimmer/runtime/lib/vm/content/text.ts
+++ b/packages/@glimmer/runtime/lib/vm/content/text.ts
@@ -1,17 +1,18 @@
-import type { SimpleText, UpdatingOpcode } from "@glimmer/interfaces";
-import { type Reference, valueForRef } from '@glimmer/reference';
+import type { SimpleText, UpdatingOpcode } from '@glimmer/interfaces';
+import type {Reactive} from '@glimmer/reference';
+import {  unwrapReactive } from '@glimmer/reference';
 
 import { isEmpty, isString } from '../../dom/normalize';
 
 export default class DynamicTextContent implements UpdatingOpcode {
   constructor(
     public node: SimpleText,
-    private reference: Reference<unknown>,
+    private reference: Reactive<unknown>,
     private lastValue: string
   ) {}
 
   evaluate() {
-    let value = valueForRef(this.reference);
+    let value = unwrapReactive(this.reference);
 
     let { lastValue } = this;
 
diff --git a/packages/@glimmer/runtime/lib/vm/debug/debug.ts b/packages/@glimmer/runtime/lib/vm/debug/debug.ts
new file mode 100644
index 0000000000..7eaa176440
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/vm/debug/debug.ts
@@ -0,0 +1,127 @@
+import type { OpSnapshot } from '@glimmer/debug';
+import type { BlockMetadata, DebugVmSnapshot, RuntimeOp } from '@glimmer/interfaces';
+import {
+  as,
+  DebugLogger,
+  DebugOpState,
+  DebugState,
+  DiffState,
+  frag,
+  getOpSnapshot,
+  record,
+  recordStackSize,
+  snapshotVM,
+  value,
+} from '@glimmer/debug';
+import {
+  LOCAL_DEBUG,
+  LOCAL_INTERNALS_LOGGING,
+  LOCAL_SUBTLE_LOGGING,
+  LOCAL_TRACE_LOGGING,
+} from '@glimmer/local-debug-flags';
+import { LOCAL_LOGGER } from "@glimmer/util";
+
+import type { VM } from '../../vm';
+
+let lastState: DebugVmSnapshot;
+
+export function debugInit(vm: VM): void {
+  if (LOCAL_TRACE_LOGGING) {
+    lastState = snapshotVM(vm);
+
+    const options = { showSubtle: LOCAL_SUBTLE_LOGGING } as const;
+    const logger = new DebugLogger(LOCAL_LOGGER, options);
+    const state = new DebugState(lastState);
+    const diff = new DiffState(undefined, undefined, state);
+
+    const done = logger.group(frag`Initial VM State`).expanded();
+    diff.log(logger);
+    done();
+  }
+}
+
+/**
+ * This should code-strip down to inlining `perform` if `import.meta.env.PROD`.
+ * // @active
+ */
+export function debugAround(vm: VM, op: RuntimeOp, perform: () => void): void {
+  if (LOCAL_DEBUG) {
+    const prev = lastState;
+    const after = debugBefore(snapshotVM(vm), prev, getOpSnapshot(op), vm.debug.block.metadata);
+
+    try {
+      perform();
+      lastState = snapshotVM(vm);
+      after(lastState);
+    } finally {
+      // LOCAL_LOGGER.groupEnd();
+    }
+  } else {
+    perform();
+  }
+}
+
+export function debugBefore(
+  currentSnapshot: DebugVmSnapshot,
+  prevSnapshot: DebugVmSnapshot,
+  opSnapshot: OpSnapshot,
+  metadata: BlockMetadata | null
+): (state: DebugVmSnapshot) => void {
+  if (LOCAL_DEBUG) {
+    const options = { showSubtle: LOCAL_SUBTLE_LOGGING } as const;
+    const logger = new DebugLogger(LOCAL_LOGGER, options);
+    const prevState = new DebugState(prevSnapshot);
+    const beforeState = new DebugState(currentSnapshot);
+    const op = new DebugOpState(beforeState.constants, opSnapshot, metadata);
+
+    // [opName, params] = debug(debugState.constants, opcode)!;
+    let done: undefined | (() => void);
+
+    if (LOCAL_TRACE_LOGGING) {
+      // console.log(`${typePos(vm['pc'])}.`);'
+      done = logger.group(frag`${op.pos(beforeState)}. ${op.describe()}`).expanded();
+
+      if (LOCAL_INTERNALS_LOGGING) {
+        logger.internals(record(currentSnapshot, { as: value }));
+      }
+
+      const dynamicParams = op.dynamicParams;
+
+      if (dynamicParams) {
+        logger.log(record(dynamicParams, { as: value }));
+      }
+    }
+
+    recordStackSize(currentSnapshot.$sp);
+
+    return (debugState) => {
+      if (LOCAL_TRACE_LOGGING) {
+        const afterState = new DebugState(debugState);
+        const diff = new DiffState(prevState, beforeState, afterState);
+
+        if (debugState.threw) {
+          logger.log(frag`${as.error('vm threw')}: ${value(debugState.threw)}`);
+        } else {
+          let actualChange = afterState.sp - beforeState.sp;
+          const expectedChange = op.expectedStackDelta(beforeState);
+
+          if (expectedChange !== undefined && expectedChange !== actualChange) {
+            done?.();
+            throw new Error(
+              `Error in ${op.name} (${opSnapshot.type}):\n\n${afterState.nextPc}. ${op
+                .describe()
+                .stringify(
+                  options
+                )}\n\nStack changed by ${actualChange}, expected ${expectedChange}`
+            );
+          }
+        }
+
+        diff.log(logger, op);
+        done?.();
+      }
+    };
+  }
+
+  return () => {};
+}
diff --git a/packages/@glimmer/runtime/lib/vm/element-builder.ts b/packages/@glimmer/runtime/lib/vm/element-builder.ts
index d86edfdf05..b98f293b5b 100644
--- a/packages/@glimmer/runtime/lib/vm/element-builder.ts
+++ b/packages/@glimmer/runtime/lib/vm/element-builder.ts
@@ -1,65 +1,93 @@
-import { destroy, registerDestructor } from '@glimmer/destroyable';
 import type {
   AttrNamespace,
-  Bounds,
+  BlockBounds,
+  BlockBoundsDebug,
   Cursor,
-  CursorStackSymbol,
+  DebugStackAspectFrame,
   ElementBuilder,
   ElementOperations,
   Environment,
+  FirstNode,
   GlimmerTreeChanges,
   GlimmerTreeConstruction,
+  LastNode,
   LiveBlock,
   Maybe,
   ModifierInstance,
   Nullable,
+  PartialBoundsDebug,
   SimpleComment,
   SimpleDocumentFragment,
   SimpleElement,
   SimpleNode,
   SimpleText,
+  SomeBoundsDebug,
   UpdatableBlock,
-} from "@glimmer/interfaces";
-import { assert, expect, Stack } from '@glimmer/util';
+  VmStackAspect,
+} from '@glimmer/interfaces';
+import type { Stack } from '@glimmer/util';
+import { destroy, registerDestructor } from '@glimmer/destroyable';
+import { assert, BalancedStack, expect, parentDebugFrames, PresentStack } from '@glimmer/util';
 
-import { clear, ConcreteBounds, CursorImpl, SingleNodeBounds } from '../bounds';
-import { type DynamicAttribute, dynamicAttribute } from './attributes/dynamic';
+import type { DynamicAttribute } from './attributes/dynamic';
 
-export interface FirstNode {
-  firstNode(): SimpleNode;
-}
+import { clear, clearRange, ConcreteBounds, CursorImpl, SingleNodeBounds } from '../bounds';
+import { dynamicAttribute } from './attributes/dynamic';
 
-export interface LastNode {
-  lastNode(): SimpleNode;
-}
+class First implements FirstNode {
+  readonly first: SimpleNode;
+  readonly debug?: () => PartialBoundsDebug;
+
+  constructor(node: SimpleNode) {
+    this.first = node;
 
-class First {
-  constructor(private node: SimpleNode) {}
+    if (import.meta.env.DEV) {
+      this.debug = () => ({ type: 'first', node: this.first });
+    }
+  }
 
   firstNode(): SimpleNode {
-    return this.node;
+    return this.first;
   }
 }
 
-class Last {
-  constructor(private node: SimpleNode) {}
+class Last implements LastNode {
+  readonly last: SimpleNode;
+  readonly debug?: () => PartialBoundsDebug;
+
+  constructor(node: SimpleNode) {
+    this.last = node;
+
+    if (import.meta.env.DEV) {
+      this.debug = () => ({ type: 'last', node: this.last });
+    }
+  }
 
   lastNode(): SimpleNode {
-    return this.node;
+    return this.last;
   }
 }
 
-export class Fragment implements Bounds {
-  private bounds: Bounds;
+export class Fragment implements BlockBounds {
+  private bounds: BlockBounds;
 
-  constructor(bounds: Bounds) {
+  constructor(bounds: BlockBounds) {
     this.bounds = bounds;
   }
+  debug?: () => SomeBoundsDebug;
 
   parentElement(): SimpleElement {
     return this.bounds.parentElement();
   }
 
+  get first(): Nullable<SimpleNode> {
+    return this.bounds.first;
+  }
+
+  get last(): Nullable<SimpleNode> {
+    return this.bounds.last;
+  }
+
   firstNode(): SimpleNode {
     return this.bounds.firstNode();
   }
@@ -69,69 +97,188 @@ export class Fragment implements Bounds {
   }
 }
 
-export const CURSOR_STACK: CursorStackSymbol = Symbol('CURSOR_STACK') as CursorStackSymbol;
+class ElementBuilderState implements VmStackAspect {
+  static initial(cursor: Cursor) {
+    return new ElementBuilderState({
+      inserting: PresentStack.initial(cursor, 'cursor stack'),
+      modifiers: BalancedStack.empty('modifier stack'),
+      blocks: BalancedStack.empty('block stack'),
+      constructing: BalancedStack.empty('constructing stack'),
+    });
+  }
+
+  readonly debug?: { frames: DebugStackAspectFrame[] };
+
+  #inserting: PresentStack<Cursor>;
+  #modifiers: BalancedStack<ModifierInstance[]>;
+  #blocks: BalancedStack<LiveBlock>;
+  #constructing: BalancedStack<SimpleElement>;
+
+  constructor({
+    inserting,
+    modifiers,
+    blocks,
+    constructing,
+  }: {
+    inserting: PresentStack<Cursor>;
+    modifiers: BalancedStack<ModifierInstance[]>;
+    blocks: BalancedStack<LiveBlock>;
+    constructing: BalancedStack<SimpleElement>;
+  }) {
+    this.#inserting = inserting;
+    this.#modifiers = modifiers;
+    this.#blocks = blocks;
+    this.#constructing = constructing;
+
+    if (import.meta.env.DEV) {
+      Object.defineProperty(this, 'debug', {
+        configurable: true,
+        get: function (this: ElementBuilderState): { frames: DebugStackAspectFrame[] } {
+          return parentDebugFrames('element builder', {
+            inserting: this.#inserting,
+            modifiers: this.#modifiers,
+            blocks: this.#blocks,
+            constructing: this.#constructing,
+          });
+        },
+      });
+    }
+  }
+
+  get inserting(): PresentStack<Cursor> {
+    return this.#inserting;
+  }
+
+  get modifiers(): Stack<Nullable<ModifierInstance[]>> {
+    return this.#modifiers;
+  }
+
+  get blocks(): BalancedStack<LiveBlock> {
+    return this.#blocks;
+  }
 
-export class NewElementBuilder implements ElementBuilder {
+  get block() {
+    return this.#blocks.present;
+  }
+
+  get cursor(): Cursor {
+    return this.#inserting.current;
+  }
+
+  begin(): this {
+    this.#inserting = this.#inserting.begin();
+    this.#modifiers = this.#modifiers.begin();
+    this.#blocks = this.#blocks.begin();
+    this.#constructing = this.#constructing.begin();
+    return this;
+  }
+
+  catch(): this {
+    this.#inserting = this.#inserting.catch();
+    this.#modifiers = this.#modifiers.catch();
+    this.#blocks = this.#blocks.catch();
+    this.#constructing = this.#constructing.catch();
+    return this;
+  }
+
+  finally(): this {
+    this.#inserting = this.#inserting.finally();
+    this.#modifiers = this.#modifiers.finally();
+    this.#blocks = this.#blocks.finally();
+    this.#constructing = this.#constructing.finally();
+    return this;
+  }
+}
+
+export abstract class AbstractElementBuilder implements ElementBuilder {
+  static forInitialRender<
+    This extends new (
+      env: Environment,
+      element: SimpleElement,
+      nextSibling: Nullable<SimpleNode>
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) => any,
+  >(this: This, env: Environment, cursor: Cursor): InstanceType<This> {
+    return new this(env, cursor.element, cursor.nextSibling).initialize() as InstanceType<This>;
+  }
+
+  readonly #state: ElementBuilderState;
   public dom: GlimmerTreeConstruction;
   public updateOperations: GlimmerTreeChanges;
   public constructing: Nullable<SimpleElement> = null;
   public operations: Nullable<ElementOperations> = null;
   private env: Environment;
 
-  [CURSOR_STACK] = new Stack<Cursor>();
-  private modifierStack = new Stack<Nullable<ModifierInstance[]>>();
-  private blockStack = new Stack<LiveBlock>();
+  constructor(env: Environment, parentNode: SimpleElement, nextSibling: Nullable<SimpleNode>) {
+    this.#state = ElementBuilderState.initial(this.createCursor(parentNode, nextSibling));
 
-  static forInitialRender(env: Environment, cursor: CursorImpl) {
-    return new this(env, cursor.element, cursor.nextSibling).initialize();
+    this.env = env;
+    this.dom = env.getAppendOperations();
+    this.updateOperations = env.getDOM();
   }
+  abstract createCursor(element: SimpleElement, nextSibling: Nullable<SimpleNode>): Cursor;
 
-  static resume(env: Environment, block: UpdatableBlock): NewElementBuilder {
-    let parentNode = block.parentElement();
-    let nextSibling = block.reset(env);
+  debugBlocks(): LiveBlock[] {
+    throw new Error('Method not implemented.');
+  }
 
-    let stack = new this(env, parentNode, nextSibling).initialize();
-    stack.pushLiveBlock(block);
+  get currentCursor(): ReturnType<this['createCursor']> {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return this.#state.cursor as any;
+  }
 
-    return stack;
+  begin(): LiveBlock {
+    const block = this.pushUpdatableBlock();
+    this.#state.begin();
+    return block;
   }
 
-  constructor(env: Environment, parentNode: SimpleElement, nextSibling: Nullable<SimpleNode>) {
-    this.pushElement(parentNode, nextSibling);
+  finally(): LiveBlock {
+    this.#state.finally();
+    return this.popBlock();
+  }
 
-    this.env = env;
-    this.dom = env.getAppendOperations();
-    this.updateOperations = env.getDOM();
+  catch(): LiveBlock {
+    this.#state.catch();
+    return this.catchBlock();
+  }
+
+  pushCursor(cursor: ReturnType<this['createCursor']>): void {
+    this.#state.inserting.push(cursor);
   }
 
   protected initialize(): this {
     this.pushSimpleBlock();
+
     return this;
   }
 
-  debugBlocks(): LiveBlock[] {
-    return this.blockStack.toArray();
+  get debug(): ElementBuilder['debug'] {
+    return {
+      blocks: this.#state.blocks.toArray(),
+      constructing: this.constructing,
+      inserting: this.#state.inserting.toArray(),
+    };
   }
 
   get element(): SimpleElement {
-    return this[CURSOR_STACK].current!.element;
+    return this.#state.cursor.element;
   }
 
   get nextSibling(): Nullable<SimpleNode> {
-    return this[CURSOR_STACK].current!.nextSibling;
+    return this.#state.cursor.nextSibling;
   }
 
   get hasBlocks() {
-    return this.blockStack.size > 0;
+    return this.#state.blocks.size > 0;
   }
 
-  protected block(): LiveBlock {
-    return expect(this.blockStack.current, 'Expected a current live block');
+  get block(): LiveBlock {
+    return this.#state.block;
   }
 
   popElement() {
-    this[CURSOR_STACK].pop();
-    expect(this[CURSOR_STACK].current, "can't pop past the last element");
+    this.#state.inserting.pop();
   }
 
   pushSimpleBlock(): LiveBlock {
@@ -146,24 +293,39 @@ export class NewElementBuilder implements ElementBuilder {
     return this.pushLiveBlock(new LiveBlockList(this.element, list));
   }
 
-  protected pushLiveBlock<T extends LiveBlock>(block: T, isRemote = false): T {
-    let current = this.blockStack.current;
+  protected pushLiveBlock<T extends LiveBlock>(block: T, _isRemote?: boolean): T {
+    this.__openBlock();
+    this.#state.blocks.push(block);
+    return block;
+  }
+
+  catchBlock(): LiveBlock {
+    this.block.catch(this);
+    const block = this.#closeBlock();
 
+    const current = this.#state.blocks.current;
     if (current !== null) {
-      if (!isRemote) {
-        current.didAppendBounds(block);
-      }
+      current.didAppendBounds(block);
     }
 
-    this.__openBlock();
-    this.blockStack.push(block);
     return block;
   }
 
   popBlock(): LiveBlock {
-    this.block().finalize(this);
+    this.block.finalize(this);
+    const block = this.#closeBlock();
+
+    const current = this.#state.blocks.current;
+    if (current !== null && !block.isRemote) {
+      current.didAppendBounds(block);
+    }
+
+    return block;
+  }
+
+  #closeBlock(): LiveBlock {
     this.__closeBlock();
-    return expect(this.blockStack.pop(), 'Expected popBlock to return a block');
+    return this.#state.blocks.pop();
   }
 
   __openBlock(): void {}
@@ -240,34 +402,34 @@ export class NewElementBuilder implements ElementBuilder {
   }
 
   protected pushElement(element: SimpleElement, nextSibling: Maybe<SimpleNode> = null) {
-    this[CURSOR_STACK].push(new CursorImpl(element, nextSibling));
+    this.#state.inserting.push(this.createCursor(element, nextSibling));
   }
 
   private pushModifiers(modifiers: Nullable<ModifierInstance[]>): void {
-    this.modifierStack.push(modifiers);
+    this.#state.modifiers.push(modifiers);
   }
 
   private popModifiers(): Nullable<ModifierInstance[]> {
-    return this.modifierStack.pop();
+    return this.#state.modifiers.pop();
   }
 
-  didAppendBounds(bounds: Bounds): Bounds {
-    this.block().didAppendBounds(bounds);
+  didAppendBounds(bounds: BlockBounds): BlockBounds {
+    this.block.didAppendBounds(bounds);
     return bounds;
   }
 
   didAppendNode<T extends SimpleNode>(node: T): T {
-    this.block().didAppendNode(node);
+    this.block.didAppendNode(node);
     return node;
   }
 
   didOpenElement(element: SimpleElement): SimpleElement {
-    this.block().openElement(element);
+    this.block.openElement(element);
     return element;
   }
 
   willCloseElement() {
-    this.block().closeElement();
+    this.block.closeElement();
   }
 
   appendText(string: string): SimpleText {
@@ -286,7 +448,7 @@ export class NewElementBuilder implements ElementBuilder {
     return node;
   }
 
-  __appendFragment(fragment: SimpleDocumentFragment): Bounds {
+  __appendFragment(fragment: SimpleDocumentFragment): BlockBounds {
     let first = fragment.firstChild;
 
     if (first) {
@@ -298,7 +460,7 @@ export class NewElementBuilder implements ElementBuilder {
     }
   }
 
-  __appendHTML(html: string): Bounds {
+  __appendHTML(html: string): BlockBounds {
     return this.dom.insertHTMLBefore(this.element, this.nextSibling, html);
   }
 
@@ -324,7 +486,7 @@ export class NewElementBuilder implements ElementBuilder {
     this.didAppendBounds(bounds);
   }
 
-  private trustedContent(value: string): Bounds {
+  private trustedContent(value: string): BlockBounds {
     return this.__appendHTML(value);
   }
 
@@ -348,7 +510,7 @@ export class NewElementBuilder implements ElementBuilder {
   }
 
   __setProperty(name: string, value: unknown): void {
-    (this.constructing! as any)[name] = value;
+    Reflect.set(this.constructing!, name, value);
   }
 
   setStaticAttribute(name: string, value: string, namespace: Nullable<AttrNamespace>): void {
@@ -368,24 +530,71 @@ export class NewElementBuilder implements ElementBuilder {
   }
 }
 
+export class NewElementBuilder extends AbstractElementBuilder {
+  static resume(env: Environment, block: UpdatableBlock): NewElementBuilder {
+    let parentNode = block.parentElement();
+    let nextSibling = block.reset(env);
+
+    let stack = new this(env, parentNode, nextSibling).initialize();
+    stack.pushLiveBlock(block);
+
+    return stack;
+  }
+
+  createCursor(element: SimpleElement, nextSibling: Nullable<SimpleNode>): Cursor {
+    return new CursorImpl(element, nextSibling);
+  }
+}
+
 export class SimpleLiveBlock implements LiveBlock {
-  protected first: Nullable<FirstNode> = null;
-  protected last: Nullable<LastNode> = null;
+  #first: Nullable<FirstNode> = null;
+  #last: Nullable<LastNode> = null;
+
   protected nesting = 0;
+  declare debug?: () => BlockBoundsDebug;
+
+  constructor(
+    private parent: SimpleElement,
+    readonly isRemote = false
+  ) {
+    ifDev(() => {
+      this.debug = (): BlockBoundsDebug => {
+        return liveBlockDebug('SimpleLiveBlock', this.first, this.last, parent);
+      };
+    });
+  }
 
-  constructor(private parent: SimpleElement) {}
+  get first(): Nullable<SimpleNode> {
+    return this.#first?.first ?? null;
+  }
+
+  set first(first: Nullable<SimpleNode>) {
+    this.#first = first ? new First(first) : null;
+  }
+
+  get last(): Nullable<SimpleNode> {
+    return this.#last?.last ?? null;
+  }
+
+  set last(last: Nullable<SimpleNode>) {
+    this.#last = last ? new Last(last) : null;
+  }
 
   parentElement() {
     return this.parent;
   }
 
+  isEmpty(): boolean {
+    return this.first === null;
+  }
+
   firstNode(): SimpleNode {
     let first = expect(
       this.first,
       'cannot call `firstNode()` while `SimpleLiveBlock` is still initializing'
     );
 
-    return first.firstNode();
+    return first;
   }
 
   lastNode(): SimpleNode {
@@ -394,7 +603,7 @@ export class SimpleLiveBlock implements LiveBlock {
       'cannot call `lastNode()` while `SimpleLiveBlock` is still initializing'
     );
 
-    return last.lastNode();
+    return last;
   }
 
   openElement(element: SimpleElement) {
@@ -410,20 +619,32 @@ export class SimpleLiveBlock implements LiveBlock {
     if (this.nesting !== 0) return;
 
     if (!this.first) {
-      this.first = new First(node);
+      this.#first = new First(node);
     }
 
-    this.last = new Last(node);
+    this.#last = new Last(node);
   }
 
-  didAppendBounds(bounds: Bounds) {
+  didAppendBounds(bounds: BlockBounds) {
     if (this.nesting !== 0) return;
 
+    assert(bounds.last !== null, `only append bounds with content`);
+
     if (!this.first) {
-      this.first = bounds;
+      this.#first = bounds;
     }
 
-    this.last = bounds;
+    this.#last = bounds;
+  }
+
+  catch(stack: ElementBuilder) {
+    const { first, last, parent } = this;
+
+    if (first && last) {
+      clearRange({ parent, first, last });
+    }
+
+    this.first = this.last = stack.appendComment('');
   }
 
   finalize(stack: ElementBuilder) {
@@ -434,42 +655,58 @@ export class SimpleLiveBlock implements LiveBlock {
 }
 
 export class RemoteLiveBlock extends SimpleLiveBlock {
+  override readonly isRemote = true;
+
   constructor(parent: SimpleElement) {
-    super(parent);
+    super(parent, true);
 
     registerDestructor(this, () => {
-      // In general, you only need to clear the root of a hierarchy, and should never
-      // need to clear any child nodes. This is an important constraint that gives us
-      // a strong guarantee that clearing a subtree is a single DOM operation.
+      // In general, you only need to clear the root of a hierarchy, and should never need to clear
+      // any child nodes. This is an important constraint that gives us a strong guarantee that
+      // clearing a subtree is a single DOM operation.
       //
-      // Because remote blocks are not normally physically nested inside of the tree
-      // that they are logically nested inside, we manually clear remote blocks when
-      // a logical parent is cleared.
+      // Because remote blocks are not normally physically nested inside of the tree that they are
+      // logically nested inside, we manually clear remote blocks when a logical parent is cleared.
       //
-      // HOWEVER, it is currently possible for a remote block to be physically nested
-      // inside of the block it is logically contained inside of. This happens when
-      // the remote block is appended to the end of the application's entire element.
+      // HOWEVER, it is currently possible for a remote block to be physically nested inside of the
+      // block it is logically contained inside of. This happens when the remote block is appended
+      // to the end of the application's entire element.
       //
-      // The problem with that scenario is that Glimmer believes that it owns more of
-      // the DOM than it actually does. The code is attempting to write past the end
-      // of the Glimmer-managed root, but Glimmer isn't aware of that.
+      // The problem with that scenario is that Glimmer believes that it owns more of the DOM than
+      // it actually does. The code is attempting to write past the end of the Glimmer-managed root,
+      // but Glimmer isn't aware of that.
       //
-      // The correct solution to that problem is for Glimmer to be aware of the end
-      // of the bounds that it owns, and once we make that change, this check could
-      // be removed.
+      // The correct solution to that problem is for Glimmer to be aware of the end of the bounds
+      // that it owns, and once we make that change, this check could be removed.
       //
-      // For now, a more targeted fix is to check whether the node was already removed
-      // and avoid clearing the node if it was. In most cases this shouldn't happen,
-      // so this might hide bugs where the code clears nested nodes unnecessarily,
-      // so we should eventually try to do the correct fix.
+      // For now, a more targeted fix is to check whether the node was already removed and avoid
+      // clearing the node if it was. In most cases this shouldn't happen, so this might hide bugs
+      // where the code clears nested nodes unnecessarily, so we should eventually try to do the
+      // correct fix.
       if (this.parentElement() === this.firstNode().parentNode) {
         clear(this);
       }
     });
+
+    ifDev(() => {
+      this.debug = () => {
+        return liveBlockDebug('RemoteLiveBlock', this.first, this.last, parent);
+      };
+    });
   }
 }
 
 export class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBlock {
+  constructor(parent: SimpleElement) {
+    super(parent);
+
+    ifDev(() => {
+      this.debug = () => {
+        return liveBlockDebug('UpdatableBlock', this.first, this.last, parent);
+      };
+    });
+  }
+
   reset(): Nullable<SimpleNode> {
     destroy(this);
     let nextSibling = clear(this);
@@ -484,9 +721,50 @@ export class UpdatableBlockImpl extends SimpleLiveBlock implements UpdatableBloc
 
 // FIXME: All the noops in here indicate a modelling problem
 export class LiveBlockList implements LiveBlock {
-  constructor(private readonly parent: SimpleElement, public boundList: LiveBlock[]) {
+  readonly isRemote = false;
+  readonly debug?: () => BlockBoundsDebug;
+
+  constructor(
+    private readonly parent: SimpleElement,
+    public boundList: BlockBounds[]
+  ) {
     this.parent = parent;
     this.boundList = boundList;
+
+    if (import.meta.env.DEV) {
+      this.debug = () => {
+        const bounds = this.boundList;
+        const parent = this.parent;
+
+        return joinRange(
+          'LiveBlockList',
+          this.boundList.at(0)?.debug?.(),
+          bounds.at(-1)?.debug?.(),
+          parent
+        );
+      };
+    }
+  }
+
+  get first(): Nullable<SimpleNode> {
+    const [first] = this.boundList;
+    return first?.first ?? null;
+  }
+
+  get last(): Nullable<SimpleNode> {
+    const last = this.boundList.at(-1);
+    return last?.last ?? null;
+  }
+
+  catch(stack: ElementBuilder): void {
+    let { first, last } = this;
+
+    if (first && last) {
+      clearRange({ parent: this.parent, first, last });
+    }
+
+    const comment = stack.appendComment('');
+    this.boundList = [new SingleNodeBounds(this.parent, comment)];
   }
 
   parentElement() {
@@ -525,7 +803,7 @@ export class LiveBlockList implements LiveBlock {
     assert(false, 'Cannot create a new node directly inside a block list');
   }
 
-  didAppendBounds(_bounds: Bounds) {}
+  didAppendBounds(_bounds: BlockBounds) {}
 
   finalize(_stack: ElementBuilder) {
     assert(this.boundList.length > 0, 'boundsList cannot be empty');
@@ -535,3 +813,74 @@ export class LiveBlockList implements LiveBlock {
 export function clientBuilder(env: Environment, cursor: CursorImpl): ElementBuilder {
   return NewElementBuilder.forInitialRender(env, cursor);
 }
+
+function ifDev<T>(callback: () => T): void {
+  if (import.meta.env.DEV) {
+    callback();
+  }
+}
+
+function getFirstNodeFromDebug(debug: SomeBoundsDebug | undefined): SimpleNode | undefined {
+  switch (debug?.type) {
+    case undefined:
+    case 'empty':
+    case 'last':
+      return;
+    case 'range':
+      return debug.range[0];
+    case 'first':
+      return debug.node;
+  }
+}
+
+function getLastNodeFromDebug(debug: SomeBoundsDebug | undefined): SimpleNode | undefined {
+  switch (debug?.type) {
+    case undefined:
+    case 'empty':
+    case 'first':
+      return;
+    case 'range':
+      return debug.range[1];
+  }
+}
+
+function joinRange(
+  kind: string,
+  firstBlock: SomeBoundsDebug | undefined,
+  lastBlock: SomeBoundsDebug | undefined,
+  parent: SimpleElement
+): BlockBoundsDebug {
+  const firstNode = getFirstNodeFromDebug(firstBlock);
+  const lastNode = getLastNodeFromDebug(lastBlock);
+
+  if (firstNode && lastNode) {
+    return debugRange(kind, [firstNode, lastNode]);
+  } else if (firstBlock?.type === 'range') {
+    return firstBlock;
+  } else if (lastBlock?.type === 'range') {
+    return lastBlock;
+  } else {
+    return empty(kind, parent);
+  }
+}
+
+function empty(kind: string, parent: SimpleElement): BlockBoundsDebug {
+  return { type: 'empty', kind, parent };
+}
+
+function debugRange(kind: string, [first, last]: [SimpleNode, SimpleNode]): BlockBoundsDebug {
+  return { type: 'range', kind, range: [first, last], collapsed: first === last };
+}
+
+function liveBlockDebug(
+  kind: string,
+  first: Nullable<SimpleNode>,
+  last: Nullable<SimpleNode>,
+  parent: SimpleElement
+): BlockBoundsDebug {
+  if (first && last) {
+    return { type: 'range', kind, range: [first, last], collapsed: first === last };
+  } else {
+    return { type: 'empty', kind, parent };
+  }
+}
diff --git a/packages/@glimmer/runtime/lib/vm/low-level.ts b/packages/@glimmer/runtime/lib/vm/low-level.ts
index 3dcb71e4cc..80075dca2c 100644
--- a/packages/@glimmer/runtime/lib/vm/low-level.ts
+++ b/packages/@glimmer/runtime/lib/vm/low-level.ts
@@ -1,118 +1,397 @@
-import type { Nullable, RuntimeHeap, RuntimeOp, RuntimeProgram } from '@glimmer/interfaces';
+import type {
+  CleanStack,
+  DebugStack,
+  ErrorHandler,
+  Expand,
+  InternalStack,
+  MutableReactiveCell,
+  Nullable,
+  Result,
+  RuntimeHeap,
+  RuntimeOp,
+  RuntimeProgram,
+  TargetState,
+} from '@glimmer/interfaces';
+import { check, CheckNumber } from '@glimmer/debug';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { assert } from '@glimmer/util';
-import { $fp, $pc, $ra, $sp, MachineOp, type MachineRegister } from '@glimmer/vm';
+import { assert, expect, UserException } from '@glimmer/util';
+import { $fp, $pc, $ra, $sp, $up, Op } from '@glimmer/vm';
 
-import { APPEND_OPCODES } from '../opcodes';
 import type { VM } from './append';
 
-export interface LowLevelRegisters {
-  [MachineRegister.pc]: number;
-  [MachineRegister.ra]: number;
-  [MachineRegister.sp]: number;
-  [MachineRegister.fp]: number;
+import { APPEND_OPCODES } from '../opcodes';
+import { debugAround } from './debug/debug';
+import { UnwindTarget } from './unwind';
+
+export type PackedRegisters = Expand<
+  [$pc: number, $ra: number, $fp: number, $sp: number, $up: UnwindTarget]
+>;
+
+export function PackedRegisters(...registers: PackedRegisters): PackedRegisters {
+  assert(registers.length === 5, `Invalid registers: ${JSON.stringify(registers)}`);
+  assert(
+    registers.slice(0, -1).every((register) => typeof register === 'number'),
+    `Invalid registers: ${JSON.stringify(registers)} ($pc, $ra, $fp, and $sp should be numbers)`
+  );
+  assert(
+    registers.at(-1) instanceof UnwindTarget,
+    `Invalid $up register: Should be a UnwindTarget`
+  );
+
+  return registers;
 }
 
-export function initializeRegisters(): LowLevelRegisters {
-  return [0, -1, 0, 0];
+export type FrameInfo = Expand<[$ra: number, $fp: number]>;
+
+export class Registers {
+  readonly #packed: PackedRegisters;
+
+  constructor(packed: PackedRegisters) {
+    this.#packed = PackedRegisters(...packed);
+  }
+
+  get debug() {
+    return {
+      pc: this.#packed[$pc],
+      ra: this.#packed[$ra],
+      fp: this.#packed[$fp],
+      sp: this.#packed[$sp],
+      up: this.#packed[$up],
+    };
+  }
+
+  // @premerge consolidate
+  goto(pc: number): void {
+    assert(typeof pc === 'number', `Invalid pc: ${typeof pc}`);
+    assert(!isNaN(pc), `Invalid pc: NaN`);
+
+    this.#packed[$pc] = pc;
+  }
+
+  // @premerge consolidate
+  call(pc: number): void {
+    this.#packed[$ra] = this.#packed[$pc];
+    this.goto(pc);
+  }
+
+  // @premerge consolidate
+  returnTo(pc: number): void {
+    this.#packed[$ra] = check(pc, CheckNumber);
+  }
+
+  // @premerge consolidate
+  return() {
+    this.#packed[$pc] = this.#packed[$ra];
+  }
+
+  // @premerge consolidate
+  advance(size: number) {
+    this.#packed[$pc] += size;
+    check(this.#packed[$pc], CheckNumber);
+    return size;
+  }
+
+  // @premerge consolidate
+  advanceSp(size: number) {
+    this.#packed[$sp] += size;
+    check(this.#packed[$sp], CheckNumber);
+    return size;
+  }
+
+  // @premerge consolidate
+  push(): number {
+    return ++this.#packed[$sp];
+  }
+
+  // @premerge consolidate
+  pop(n = 1): number {
+    return (this.#packed[$sp] -= check(n, CheckNumber));
+  }
+
+  // @premerge consolidate
+  peek(offset = 0): number {
+    return this.#packed[$sp] - check(offset, CheckNumber);
+  }
+
+  // @premerge consolidate
+  /**
+   * Remember the previous $fp, then update $fp to point to $sp. Return the previous $fp so it can
+   * be pushed onto the stack.
+   *
+   * This creates a linked list of $fps on the stack.
+   */
+  pushFp() {
+    let prevFp = this.#packed[$fp];
+    // the current $sp contains the $ra we already pushed, so the $fp will point to the tuple of
+    // $ra and $fp
+    this.#packed[$fp] = this.#packed[$sp];
+    return prevFp;
+  }
+
+  // @premerge consolidate
+  popTo(ra: number, fp: number): void {
+    // when popping a frame, we want to restore the $sp to the position immediately before we pushed
+    // the $ra and $fp onto the stack, which will effectively continue execution at that point.
+    let to = this.#packed[$fp] - 1;
+    this.#packed[$ra] = check(ra, CheckNumber);
+    this.#packed[$fp] = check(fp, CheckNumber);
+    this.#packed[$sp] = check(to, CheckNumber);
+  }
+
+  /**
+   * @deprecated Direct access to .packed will be removed once all use-cases are handled via
+   * semantic methods.
+   */
+  get packed(): PackedRegisters {
+    return this.#packed;
+  }
+
+  get pc(): number {
+    return this.#packed[$pc];
+  }
+
+  get ra(): number {
+    return this.#packed[$ra];
+  }
+
+  get sp(): number {
+    return this.#packed[$sp];
+  }
+
+  get fp(): number {
+    return this.#packed[$fp];
+  }
+
+  get up(): UnwindTarget {
+    return this.#packed[$up];
+  }
+
+  try(catchPc: number, error: MutableReactiveCell<number>, handler: ErrorHandler | null) {
+    this.#packed[$up] = this.#packed[$up].child({
+      ip: catchPc,
+      ra: this.#packed[$ra],
+      fp: this.#packed[$fp],
+      error,
+      handler,
+    });
+  }
+
+  catch(error: unknown): TargetState {
+    return this.#packed[$up].catch(error);
+  }
+
+  finally() {
+    this.#packed[$up] = expect(
+      this.#packed[$up].finally(),
+      "Since the $up starts initialized, and finally() is always paired with try(), it shouldn't be possible to pop the last $up."
+    );
+  }
 }
 
-export function initializeRegistersWithSP(sp: number): LowLevelRegisters {
-  return [0, -1, sp, 0];
+export interface ArgumentsStack extends InternalStack, DebugStack {
+  readonly registers: Registers;
+
+  // @premerge consolidate (these are only used in Arguments)
+  copy(from: number, to: number): void;
+  set(value: unknown, offset: number, base?: number): void;
+  slice<T = unknown>(start: number, end: number): T[];
+  capture(items: number): unknown[];
+  frame(): unknown[];
 }
 
-export function initializeRegistersWithPC(pc: number): LowLevelRegisters {
-  return [pc, -1, 0, 0];
+export interface Externs {
+  debug: VM;
 }
 
-export interface Stack {
-  push(value: unknown): void;
-  get(position: number): number;
-  pop<T>(): T;
+export interface VmDebugState {
+  readonly registers: Registers;
+  readonly currentPc: number;
+  readonly stack: DebugStack;
+  readonly threw: Error | undefined;
 }
 
-export interface Externs {
-  debugBefore(opcode: RuntimeOp): unknown;
-  debugAfter(state: unknown): void;
+let THROWN:
+  | { unset: () => void; set: (value: Error) => void; check: () => Error | undefined }
+  | undefined;
+
+if (import.meta.env.DEV) {
+  let MARKER: Error | undefined = undefined;
+
+  THROWN = {
+    unset: () => {
+      MARKER = undefined;
+    },
+
+    set: (error: Error) => {
+      MARKER = error;
+    },
+
+    check: () => MARKER,
+  };
 }
 
 export class LowLevelVM {
-  public currentOpSize = 0;
+  static create(
+    stack: ArgumentsStack,
+    heap: RuntimeHeap,
+    program: RuntimeProgram,
+    externs: Externs,
+    registers: Registers
+  ): LowLevelVM {
+    return new LowLevelVM(stack, heap, program, externs, registers);
+  }
 
-  constructor(
-    public stack: Stack,
-    public heap: RuntimeHeap,
-    public program: RuntimeProgram,
-    public externs: Externs,
-    readonly registers: LowLevelRegisters
-  ) {}
+  #currentOpSize = 0;
+  readonly #registers: Registers;
+  readonly #heap: RuntimeHeap;
+  readonly #program: RuntimeProgram;
+  readonly #stack: ArgumentsStack;
+
+  declare threw?: () => boolean;
+
+  private constructor(
+    stack: ArgumentsStack,
+    heap: RuntimeHeap,
+    program: RuntimeProgram,
+    readonly externs: Externs,
+    registers: Registers
+  ) {
+    this.#stack = stack;
+    this.#heap = heap;
+    this.#program = program;
+    this.#registers = registers;
+
+    if (import.meta.env.DEV) {
+      Object.defineProperty(this, 'threw', () => THROWN?.check());
+    }
+  }
 
-  fetchRegister(register: MachineRegister): number {
-    return this.registers[register];
+  get result(): Result<void> {
+    return this.#registers.up.unhandled;
   }
 
-  loadRegister(register: MachineRegister, value: number) {
-    this.registers[register] = value;
+  capture(): { unwind: UnwindTarget } {
+    return { unwind: this.#registers.up };
   }
 
-  setPc(pc: number): void {
-    assert(typeof pc === 'number' && !isNaN(pc), 'pc is set to a number');
-    this.registers[$pc] = pc;
+  // @premerge consolidate
+  get stack(): CleanStack {
+    return this.#stack;
   }
 
-  // Start a new frame and save $ra and $fp on the stack
-  pushFrame() {
-    this.stack.push(this.registers[$ra]);
-    this.stack.push(this.registers[$fp]);
-    this.registers[$fp] = this.registers[$sp] - 1;
+  // @premerge consolidate
+  get internalStack(): InternalStack {
+    return this.#stack;
   }
 
-  // Restore $ra, $sp and $fp
-  popFrame() {
-    this.registers[$sp] = this.registers[$fp] - 1;
-    this.registers[$ra] = this.stack.get(0);
-    this.registers[$fp] = this.stack.get(1);
+  // @premerge consolidate
+  get forArguments(): ArgumentsStack {
+    return this.#stack;
+  }
+
+  /**
+   * @mutable
+   */
+  get debug(): VmDebugState {
+    return {
+      currentPc: this.#registers.pc - this.#currentOpSize,
+      registers: this.#registers,
+      stack: this.#stack,
+      threw: THROWN?.check(),
+    };
+  }
+
+  get pc(): number {
+    return this.#registers.pc;
+  }
+
+  get sp(): number {
+    return this.#registers.sp;
+  }
+
+  get fp(): number {
+    return this.#registers.fp;
+  }
+
+  get up(): UnwindTarget {
+    return this.#registers.up;
+  }
+
+  /**
+   * `begin` takes an absolute instruction.
+   */
+  begin(instruction: number, error: MutableReactiveCell<number>, handler: Nullable<ErrorHandler>) {
+    this.#registers.try(instruction, error, handler);
+  }
+
+  catch(error: unknown): TargetState {
+    if (import.meta.env.DEV) {
+      THROWN?.set(UserException.from(error, `A user exception occurred`));
+    }
+
+    const target = this.#registers.catch(error);
+    this.#registers.popTo(target.ra, target.fp);
+    this.#registers.goto(target.ip);
+
+    return target;
   }
 
-  pushSmallFrame() {
-    this.stack.push(this.registers[$ra]);
+  finally() {
+    this.#registers.finally();
   }
 
-  popSmallFrame() {
-    this.registers[$ra] = this.stack.pop();
+  // Start a new frame and save $ra and $fp on the stack
+  pushFrame() {
+    this.#stack.push(this.#registers.ra);
+    this.#stack.push(this.#registers.pushFp());
+  }
+
+  // Restore $ra, $sp and $fp
+  popFrame() {
+    let fp = this.#registers.fp;
+    // get the previous $ra and $fp from the stack (relative to the *current* $fp), and restore them
+    // to the registers.
+    this.#registers.popTo(this.#stack.get(0, fp), this.#stack.get(1, fp));
   }
 
   // Jump to an address in `program`
   goto(offset: number) {
-    this.setPc(this.target(offset));
+    let pc = this.target(offset);
+    assert(typeof pc === 'number', `expected pc to be a number, but it was ${typeof pc}`);
+    assert(!isNaN(pc), 'expected pc to not be NaN, but it was');
+    this.#registers.goto(pc);
   }
 
   target(offset: number) {
-    return this.registers[$pc] + offset - this.currentOpSize;
+    return this.#registers.pc + offset - this.#currentOpSize;
   }
 
   // Save $pc into $ra, then jump to a new address in `program` (jal in MIPS)
   call(handle: number) {
     assert(handle < 0xffffffff, `Jumping to placeholder address`);
 
-    this.registers[$ra] = this.registers[$pc];
-    this.setPc(this.heap.getaddr(handle));
+    this.#registers.call(this.#heap.getaddr(handle));
   }
 
   // Put a specific `program` address in $ra
   returnTo(offset: number) {
-    this.registers[$ra] = this.target(offset);
+    this.#registers.returnTo(this.target(offset));
   }
 
   // Return to the `program` address stored in $ra
   return() {
-    this.setPc(this.registers[$ra]);
+    this.#registers.return();
   }
 
   nextStatement(): Nullable<RuntimeOp> {
-    let { registers, program } = this;
+    if (import.meta.env.DEV) {
+      THROWN?.unset();
+    }
+
+    let program = this.#program;
+    let registers = this.#registers;
 
-    let pc = registers[$pc];
+    let pc = registers.pc;
 
     assert(typeof pc === 'number', 'pc is a number');
 
@@ -126,53 +405,41 @@ export class LowLevelVM {
     // in a jump because we have have already incremented the
     // program counter to the next instruction prior to executing.
     let opcode = program.opcode(pc);
-    let operationSize = (this.currentOpSize = opcode.size);
-    this.registers[$pc] += operationSize;
+    this.#currentOpSize = this.#registers.advance(opcode.size);
 
     return opcode;
   }
 
   evaluateOuter(opcode: RuntimeOp, vm: VM) {
     if (LOCAL_DEBUG) {
-      let {
-        externs: { debugBefore, debugAfter },
-      } = this;
-      let state = debugBefore(opcode);
-      this.evaluateInner(opcode, vm);
-      debugAfter(state);
+      debugAround(vm, opcode, () => this.#evaluateInner(opcode, vm));
     } else {
-      this.evaluateInner(opcode, vm);
+      this.#evaluateInner(opcode, vm);
     }
   }
 
-  evaluateInner(opcode: RuntimeOp, vm: VM) {
+  #evaluateInner(opcode: RuntimeOp, vm: VM) {
     if (opcode.isMachine) {
-      this.evaluateMachine(opcode);
+      this.#evaluateMachine(opcode);
     } else {
-      this.evaluateSyscall(opcode, vm);
+      this.#evaluateSyscall(opcode, vm);
     }
   }
 
-  evaluateMachine(opcode: RuntimeOp) {
+  #evaluateMachine(opcode: RuntimeOp) {
     switch (opcode.type) {
-      case MachineOp.PushFrame:
+      case Op.PushFrame:
         return this.pushFrame();
-      case MachineOp.PopFrame:
+      case Op.PopFrame:
         return this.popFrame();
-      case MachineOp.InvokeStatic:
-        return this.call(opcode.op1);
-      case MachineOp.InvokeVirtual:
-        return this.call(this.stack.pop());
-      case MachineOp.Jump:
+      case Op.Jump:
         return this.goto(opcode.op1);
-      case MachineOp.Return:
-        return this.return();
-      case MachineOp.ReturnTo:
+      case Op.ReturnTo:
         return this.returnTo(opcode.op1);
     }
   }
 
-  evaluateSyscall(opcode: RuntimeOp, vm: VM) {
+  #evaluateSyscall(opcode: RuntimeOp, vm: VM) {
     APPEND_OPCODES.evaluate(vm, opcode, opcode.type);
   }
 }
diff --git a/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts b/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts
index f6a2a99ad3..7c892d797a 100644
--- a/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts
+++ b/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts
@@ -1,6 +1,7 @@
+/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
 import type {
   AttrNamespace,
-  Bounds,
+  BlockBounds,
   ElementBuilder,
   Environment,
   Maybe,
@@ -10,19 +11,12 @@ import type {
   SimpleElement,
   SimpleNode,
   SimpleText,
-} from "@glimmer/interfaces";
-import {
-  assert,
-  castToBrowser,
-  castToSimple,
-  COMMENT_NODE,
-  expect,
-  NS_SVG,
-  type Stack,
-} from '@glimmer/util';
+} from '@glimmer/interfaces';
+import type { PresentStack } from '@glimmer/util';
+import { assert, castToBrowser, castToSimple, COMMENT_NODE, expect, NS_SVG } from '@glimmer/util';
 
 import { ConcreteBounds, CursorImpl } from '../bounds';
-import { CURSOR_STACK, NewElementBuilder, RemoteLiveBlock } from './element-builder';
+import { AbstractElementBuilder, RemoteLiveBlock } from './element-builder';
 
 export const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';
 
@@ -44,9 +38,10 @@ export class RehydratingCursor extends CursorImpl {
   }
 }
 
-export class RehydrateBuilder extends NewElementBuilder implements ElementBuilder {
+export class RehydrateBuilder extends AbstractElementBuilder implements ElementBuilder {
+  declare readonly cursors: PresentStack<RehydratingCursor>;
+
   private unmatchedAttributes: Nullable<SimpleAttr[]> = null;
-  declare [CURSOR_STACK]: Stack<RehydratingCursor>; // Hides property on base class
   blockDepth = 0;
   startingBlockOffset: number;
 
@@ -54,7 +49,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     super(env, parentNode, nextSibling);
     if (nextSibling) throw new Error('Rehydration with nextSibling not supported');
 
-    let node = this.currentCursor!.element.firstChild;
+    let node = this.currentCursor.element.firstChild;
 
     while (node !== null) {
       if (isOpenBlock(node)) {
@@ -92,8 +87,11 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     }
   }
 
-  get currentCursor(): Nullable<RehydratingCursor> {
-    return this[CURSOR_STACK].current;
+  override createCursor(
+    element: SimpleElement,
+    nextSibling: Nullable<SimpleNode>
+  ): RehydratingCursor {
+    return new RehydratingCursor(element, nextSibling, this.blockDepth || 0);
   }
 
   get candidate(): Nullable<SimpleNode> {
@@ -105,13 +103,13 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
   }
 
   set candidate(node: Nullable<SimpleNode>) {
-    const currentCursor = this.currentCursor!;
+    const currentCursor = this.currentCursor;
 
     currentCursor.candidate = node;
   }
 
   disableRehydration(nextSibling: Nullable<SimpleNode>) {
-    const currentCursor = this.currentCursor!;
+    const currentCursor = this.currentCursor;
 
     // rehydration will be disabled until we either:
     // * hit popElement (and return to using the parent elements cursor)
@@ -122,21 +120,15 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
   }
 
   enableRehydration(candidate: Nullable<SimpleNode>) {
-    const currentCursor = this.currentCursor!;
+    const currentCursor = this.currentCursor;
 
     currentCursor.candidate = candidate;
     currentCursor.nextSibling = null;
   }
 
-  override pushElement(
-    /** called from parent constructor before we initialize this */
-    this:
-      | RehydrateBuilder
-      | (NewElementBuilder & Partial<Pick<RehydrateBuilder, 'blockDepth' | 'candidate'>>),
-    element: SimpleElement,
-    nextSibling: Maybe<SimpleNode> = null
-  ) {
-    const cursor = new RehydratingCursor(element, nextSibling, this.blockDepth || 0);
+  /** WARNING: called from parent constructor before we initialize this */
+  override pushElement(element: SimpleElement, nextSibling: Maybe<SimpleNode> = null) {
+    const cursor = this.createCursor(element, nextSibling);
 
     /**
      * <div>   <---------------  currentCursor.element
@@ -153,7 +145,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
       this.candidate = element.nextSibling;
     }
 
-    this[CURSOR_STACK].push(cursor);
+    this.pushCursor(cursor as ReturnType<this['createCursor']>);
   }
 
   // clears until the end of the current container
@@ -277,7 +269,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     }
   }
 
-  override __appendHTML(html: string): Bounds {
+  override __appendHTML(html: string): BlockBounds {
     const candidateBounds = this.markerBounds();
 
     if (candidateBounds) {
@@ -310,7 +302,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     return next;
   }
 
-  private markerBounds(): Nullable<Bounds> {
+  private markerBounds(): Nullable<BlockBounds> {
     const _candidate = this.candidate;
 
     if (_candidate && isMarker(_candidate)) {
@@ -381,7 +373,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     } else if (_candidate) {
       if (isElement(_candidate) && _candidate.tagName === 'TBODY') {
         this.pushElement(_candidate, null);
-        this.currentCursor!.injectedOmittedNode = true;
+        this.currentCursor.injectedOmittedNode = true;
         return this.__openElement(tag);
       }
       this.clearMismatch(_candidate);
@@ -479,7 +471,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     }
 
     const cursor = new RehydratingCursor(element, null, this.blockDepth);
-    this[CURSOR_STACK].push(cursor);
+    this.pushCursor(cursor as ReturnType<this['createCursor']>);
 
     if (marker === null) {
       this.disableRehydration(insertBefore);
@@ -491,7 +483,7 @@ export class RehydrateBuilder extends NewElementBuilder implements ElementBuilde
     return this.pushLiveBlock(block, true);
   }
 
-  override didAppendBounds(bounds: Bounds): Bounds {
+  override didAppendBounds(bounds: BlockBounds): BlockBounds {
     super.didAppendBounds(bounds);
     if (this.candidate) {
       const last = bounds.lastNode();
diff --git a/packages/@glimmer/runtime/lib/vm/render-result.ts b/packages/@glimmer/runtime/lib/vm/render-result.ts
index b8ce63c38b..1f78d2be32 100644
--- a/packages/@glimmer/runtime/lib/vm/render-result.ts
+++ b/packages/@glimmer/runtime/lib/vm/render-result.ts
@@ -1,25 +1,38 @@
-import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
 import type {
   Environment,
-  LiveBlock,
+  Nullable,
   RenderResult,
   SimpleElement,
   SimpleNode,
   UpdatingOpcode,
 } from '@glimmer/interfaces';
+import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
+
+import type { BlockOpcode, TryOpcode } from './update';
 
 import { clear } from '../bounds';
 import { UpdatingVM } from './update';
 
-export default class RenderResultImpl implements RenderResult {
+export default class RenderResultImpl implements BlockOpcode, RenderResult {
+  private updating: UpdatingOpcode[];
+  readonly drop: object;
+
   constructor(
     public env: Environment,
-    private updating: UpdatingOpcode[],
-    private bounds: LiveBlock,
-    readonly drop: object
+    private block: TryOpcode
   ) {
-    associateDestroyableChild(this, drop);
-    registerDestructor(this, () => clear(this.bounds));
+    associateDestroyableChild(this, block);
+    registerDestructor(this, () => clear(block));
+    this.updating = [block];
+    this.drop = block;
+  }
+
+  get children() {
+    return this.updating;
+  }
+
+  evaluate(vm: UpdatingVM): void {
+    vm.execute(this.updating, this);
   }
 
   rerender({ alwaysRevalidate = false } = { alwaysRevalidate: false }) {
@@ -29,18 +42,30 @@ export default class RenderResultImpl implements RenderResult {
   }
 
   parentElement(): SimpleElement {
-    return this.bounds.parentElement();
+    return this.block.parentElement();
+  }
+
+  get first(): Nullable<SimpleNode> {
+    return this.block.first;
   }
 
   firstNode(): SimpleNode {
-    return this.bounds.firstNode();
+    return this.block.firstNode();
+  }
+
+  get last(): Nullable<SimpleNode> {
+    return this.block.last;
   }
 
   lastNode(): SimpleNode {
-    return this.bounds.lastNode();
+    return this.block.lastNode();
+  }
+
+  handleException(): void {
+    // @fixme
   }
 
-  handleException() {
-    throw 'this should never happen';
+  unwind() {
+    return false;
   }
 }
diff --git a/packages/@glimmer/runtime/lib/vm/stack.ts b/packages/@glimmer/runtime/lib/vm/stack.ts
index c947e89916..ada7b379d7 100644
--- a/packages/@glimmer/runtime/lib/vm/stack.ts
+++ b/packages/@glimmer/runtime/lib/vm/stack.ts
@@ -1,47 +1,41 @@
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { $fp, $sp, type MachineRegister } from '@glimmer/vm';
-
-import { REGISTERS } from '../symbols';
-import { initializeRegistersWithSP, type LowLevelRegisters } from './low-level';
-
-export interface EvaluationStack {
-  [REGISTERS]: LowLevelRegisters;
-
-  push(value: unknown): void;
-  dup(position?: MachineRegister): void;
-  copy(from: number, to: number): void;
-  pop<T>(n?: number): T;
-  peek<T>(offset?: number): T;
-  get<T>(offset: number, base?: number): T;
-  set(value: unknown, offset: number, base?: number): void;
-  slice<T = unknown>(start: number, end: number): T[];
-  capture(items: number): unknown[];
-  reset(): void;
-  toArray(): unknown[];
-}
 
-export default class EvaluationStackImpl implements EvaluationStack {
-  static restore(snapshot: unknown[]): EvaluationStackImpl {
-    return new this(snapshot.slice(), initializeRegistersWithSP(snapshot.length - 1));
+import type { ArgumentsStack } from './low-level';
+import type { UnwindTarget } from './unwind';
+
+import { PackedRegisters, Registers } from './low-level';
+
+export default class EvaluationStackImpl implements ArgumentsStack {
+  static restore(snapshot: unknown[], pc: number, unwind: UnwindTarget): EvaluationStackImpl {
+    return new this(snapshot.slice(), PackedRegisters(pc, -1, -1, snapshot.length - 1, unwind));
   }
 
-  readonly [REGISTERS]: LowLevelRegisters;
+  readonly registers: Registers;
 
   // fp -> sp
-  constructor(private stack: unknown[] = [], registers: LowLevelRegisters) {
-    this[REGISTERS] = registers;
+  private constructor(
+    private stack: unknown[] = [],
+    registers: PackedRegisters
+  ) {
+    this.registers = new Registers(registers);
 
     if (LOCAL_DEBUG) {
       Object.seal(this);
     }
   }
 
-  push(value: unknown): void {
-    this.stack[++this[REGISTERS][$sp]] = value;
+  get size(): number {
+    return this.stack.length;
+  }
+
+  push(...values: unknown[]): void {
+    for (let value of values) {
+      this.stack[this.registers.push()] = value;
+    }
   }
 
-  dup(position = this[REGISTERS][$sp]): void {
-    this.stack[++this[REGISTERS][$sp]] = this.stack[position];
+  dup(position = this.registers.sp): void {
+    this.stack[this.registers.push()] = this.stack[position];
   }
 
   copy(from: number, to: number): void {
@@ -49,20 +43,20 @@ export default class EvaluationStackImpl implements EvaluationStack {
   }
 
   pop<T>(n = 1): T {
-    let top = this.stack[this[REGISTERS][$sp]] as T;
-    this[REGISTERS][$sp] -= n;
+    let top = this.stack[this.registers.sp] as T;
+    this.registers.pop(n);
     return top;
   }
 
-  peek<T>(offset = 0): T {
-    return this.stack[this[REGISTERS][$sp] - offset] as T;
+  top<T>(offset = 0): T {
+    return this.stack[this.registers.peek(offset)] as T;
   }
 
-  get<T>(offset: number, base = this[REGISTERS][$fp]): T {
+  get<T>(offset: number, base = this.registers.fp): T {
     return this.stack[base + offset] as T;
   }
 
-  set(value: unknown, offset: number, base = this[REGISTERS][$fp]) {
+  set(value: unknown, offset: number, base = this.registers.fp) {
     this.stack[base + offset] = value;
   }
 
@@ -71,7 +65,7 @@ export default class EvaluationStackImpl implements EvaluationStack {
   }
 
   capture(items: number): unknown[] {
-    let end = this[REGISTERS][$sp] + 1;
+    let end = this.registers.sp + 1;
     let start = end - items;
     return this.stack.slice(start, end);
   }
@@ -80,7 +74,21 @@ export default class EvaluationStackImpl implements EvaluationStack {
     this.stack.length = 0;
   }
 
-  toArray() {
-    return this.stack.slice(this[REGISTERS][$fp], this[REGISTERS][$sp] + 1);
+  /**
+   * @snapshots
+   */
+  frame() {
+    return this.stack.slice(
+      this.registers.fp === -1 ? 0 : this.registers.fp,
+      this.registers.sp + 1
+    );
+  }
+
+  /**
+   * @snapshots
+   */
+  all(): { before: unknown[]; frame: unknown[] } {
+    let before = this.stack.slice(0, this.registers.fp === -1 ? 0 : this.registers.fp);
+    return { before, frame: this.frame() };
   }
 }
diff --git a/packages/@glimmer/runtime/lib/vm/unwind.ts b/packages/@glimmer/runtime/lib/vm/unwind.ts
new file mode 100644
index 0000000000..62852c22d0
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/vm/unwind.ts
@@ -0,0 +1,70 @@
+import type {
+  CatchState,
+  MutableReactiveCell,
+  Result,
+  TargetState,
+  UnwindTarget as UnwindTargetInterface,
+} from '@glimmer/interfaces';
+import { Ok } from '@glimmer/util';
+
+export class UnwindTarget implements UnwindTargetInterface {
+  static root(error: MutableReactiveCell<number>): UnwindTarget {
+    return new UnwindTarget(null, {
+      // initial ra
+      ip: -1,
+      // initial sp
+      ra: -1,
+      // initial fp
+      fp: -1,
+      handler: null,
+      error,
+    });
+  }
+
+  readonly #parent: UnwindTarget | null;
+  readonly #target: TargetState;
+  #error: Result<void> = { type: 'ok', value: undefined };
+
+  constructor(parent: UnwindTarget | null, target: TargetState) {
+    this.#parent = parent;
+    this.#target = target;
+  }
+
+  get error() {
+    return this.#target.error;
+  }
+
+  get handler() {
+    return this.#target.handler;
+  }
+
+  catchState(isTryFrame: boolean): CatchState {
+    return {
+      isTryFrame,
+      handler: this.handler,
+      error: this.error,
+    };
+  }
+
+  child(state: TargetState): UnwindTarget {
+    return new UnwindTarget(this, state);
+  }
+
+  finally(): UnwindTarget | null {
+    return this.#parent;
+  }
+
+  catch(error: unknown): TargetState {
+    this.#error = { type: 'err', value: error };
+    return this.#target;
+  }
+
+  /**
+   * Returns the error caught by the VM, but only if it hasn't been handled.
+   */
+  get unhandled(): Result<void> {
+    // If the error is already handled, don't return it.
+    if (this.#target.handler) return Ok(undefined);
+    return this.#error;
+  }
+}
diff --git a/packages/@glimmer/runtime/lib/vm/update.ts b/packages/@glimmer/runtime/lib/vm/update.ts
index 65eb9b53eb..1c95d7fd3e 100644
--- a/packages/@glimmer/runtime/lib/vm/update.ts
+++ b/packages/@glimmer/runtime/lib/vm/update.ts
@@ -1,41 +1,44 @@
-import { associateDestroyableChild, destroy, destroyChildren } from '@glimmer/destroyable';
 import type {
-  Bounds,
+  BlockBounds,
+  Destroyable,
   DynamicScope,
-  ElementBuilder,
   Environment,
   ExceptionHandler,
   GlimmerTreeChanges,
+  HandleException,
+  JitContext,
   LiveBlock,
   Nullable,
+  Result,
   RuntimeContext,
   Scope,
   SimpleComment,
+  SimpleNode,
+  SomeBoundsDebug,
   UpdatableBlock,
   UpdatingOpcode,
   UpdatingVM as IUpdatingVM,
 } from '@glimmer/interfaces';
+import type { OpaqueIterationItem, OpaqueIterator, Reactive } from '@glimmer/reference';
+import { associateDestroyableChild, destroy, destroyChildren } from '@glimmer/destroyable';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import {
-  type OpaqueIterationItem,
-  type OpaqueIterator,
-  type Reference,
-  updateRef,
-  valueForRef,
-} from '@glimmer/reference';
+import { MutableCell, readReactive, updateReactive } from '@glimmer/reference';
 import { expect, logStep, Stack, unwrap } from '@glimmer/util';
 import { debug, resetTracking } from '@glimmer/validator';
 
+import type { LiveBlockList } from './element-builder';
+import type { UnwindTarget } from './unwind';
+
 import { clear, move as moveBounds } from '../bounds';
-import type { InternalVM, VmInitCallback } from './append';
-import { type LiveBlockList, NewElementBuilder } from './element-builder';
+import { VM } from './append';
+import { NewElementBuilder } from './element-builder';
 
 export class UpdatingVM implements IUpdatingVM {
   public env: Environment;
   public dom: GlimmerTreeChanges;
   public alwaysRevalidate: boolean;
 
-  private frameStack: Stack<UpdatingVMFrame> = new Stack<UpdatingVMFrame>();
+  readonly #frameStack = Stack.empty<UpdatingVMFrame>();
 
   constructor(env: Environment, { alwaysRevalidate = false }) {
     this.env = env;
@@ -44,16 +47,18 @@ export class UpdatingVM implements IUpdatingVM {
   }
 
   execute(opcodes: UpdatingOpcode[], handler: ExceptionHandler) {
-    if (import.meta.env.DEV) {
+    if (import.meta.env.PROD) {
+      this.#execute(opcodes, handler);
+    } else {
       let hasErrored = true;
       try {
-        debug.runInTrackingTransaction!(
-          () => this._execute(opcodes, handler),
-          '- While rendering:'
-        );
+        debug.runInTrackingTransaction!(() => this.#execute(opcodes, handler), {
+          reason: 'updating',
+          label: ['- While rendering:'],
+        });
 
-        // using a boolean here to avoid breaking ergonomics of "pause on uncaught exceptions"
-        // which would happen with a `catch` + `throw`
+        // using a boolean here to avoid breaking ergonomics of "pause on uncaught exceptions" which
+        // would happen with a `catch` + `throw`
         hasErrored = false;
       } finally {
         if (hasErrored) {
@@ -61,18 +66,25 @@ export class UpdatingVM implements IUpdatingVM {
           console.error(`\n\nError occurred:\n\n${resetTracking()}\n\n`);
         }
       }
-    } else {
-      this._execute(opcodes, handler);
     }
   }
 
-  private _execute(opcodes: UpdatingOpcode[], handler: ExceptionHandler) {
-    let { frameStack } = this;
-
-    this.try(opcodes, handler);
+  #execute(opcodes: UpdatingOpcode[], handler: ExceptionHandler) {
+    let frameStack = this.#frameStack;
+
+    this.try(opcodes, {
+      handler,
+      unwind: {
+        isTryFrame: false,
+        error: MutableCell(1),
+        handler: () => {
+          throw Error(`unwind target not found`);
+        },
+      },
+    });
 
-    while (!frameStack.isEmpty()) {
-      let opcode = this.frame.nextStatement();
+    while (frameStack.size !== 0) {
+      let opcode = this.#frame.nextStatement();
 
       if (opcode === undefined) {
         frameStack.pop();
@@ -83,62 +95,117 @@ export class UpdatingVM implements IUpdatingVM {
     }
   }
 
-  private get frame() {
-    return expect(this.frameStack.current, 'bug: expected a frame');
+  get #frame() {
+    return expect(this.#frameStack.current, 'bug: expected a frame');
+  }
+
+  deref<T>(reactive: Reactive<T>, then: (value: T) => void) {
+    const result = readReactive(reactive);
+
+    switch (result.type) {
+      case 'ok':
+        then(result.value);
+        break;
+      case 'err':
+        this.unwind();
+    }
   }
 
   goto(index: number) {
-    this.frame.goto(index);
+    this.#frame.goto(index);
   }
 
-  try(ops: UpdatingOpcode[], handler: Nullable<ExceptionHandler>) {
-    this.frameStack.push(new UpdatingVMFrame(ops, handler));
+  try(ops: UpdatingOpcode[], handle: Nullable<HandleException>) {
+    this.#frameStack.push(new UpdatingVMFrame(ops, handle));
   }
 
-  throw() {
-    this.frame.handleException();
-    this.frameStack.pop();
+  /**
+   * Attempt to unwind the stack until a target is found. This will continue unwinding to the
+   * nearest `TryOpcode` error boundary, which will then handle the error.
+   *
+   * When the `TryOpcode` handles the error, it clears its child DOM, destroys all descendant
+   * destructors, and re-renders itself.
+   */
+  unwind() {
+    while (this.#frameStack.current) {
+      const unwound = this.#frame.unwind();
+      this.#frameStack.pop();
+
+      if (unwound) return;
+    }
+
+    // @fixme something more rationalized here
+    throw Error(`unwind target not found`);
+  }
+
+  reset() {
+    this.#frame.handleException();
+    this.#frameStack.pop();
   }
 }
 
-export interface VMState {
+/**
+ * This state is used to initialize the VM, both on initial render and when resuming due to an
+ * assertion.
+ */
+export interface InitialVmState {
   readonly pc: number;
   readonly scope: Scope;
   readonly dynamicScope: DynamicScope;
   readonly stack: unknown[];
+  readonly unwind: UnwindTarget;
+  readonly context: JitContext;
+  readonly destructor: Destroyable;
+  readonly isTryFrame: boolean;
 }
 
-export interface ResumableVMState {
-  resume(runtime: RuntimeContext, builder: ElementBuilder): InternalVM;
-}
-
-export class ResumableVMStateImpl implements ResumableVMState {
-  constructor(readonly state: VMState, private resumeCallback: VmInitCallback) {}
-
-  resume(runtime: RuntimeContext, builder: ElementBuilder): InternalVM {
-    return this.resumeCallback(runtime, this.state, builder);
-  }
+export interface BlockOpcode extends Omit<UpdatingOpcode & BlockBounds, 'debug'> {
+  readonly children: UpdatingOpcode[];
 }
 
-export abstract class BlockOpcode implements UpdatingOpcode, Bounds {
-  public children: UpdatingOpcode[];
+export abstract class AbstractBlockOpcode<Child extends UpdatingOpcode = UpdatingOpcode>
+  implements BlockOpcode
+{
+  #children: Child[];
 
   protected readonly bounds: LiveBlock;
+  readonly debug?: () => SomeBoundsDebug;
 
   constructor(
-    protected state: ResumableVMState,
+    protected state: InitialVmState,
     protected runtime: RuntimeContext,
     bounds: LiveBlock,
-    children: UpdatingOpcode[]
+    children: Child[] = []
   ) {
-    this.children = children;
+    this.#children = children;
     this.bounds = bounds;
+
+    if (import.meta.env.DEV) {
+      if (bounds.debug) this.debug = bounds.debug;
+    }
+  }
+
+  get children() {
+    return this.#children;
+  }
+
+  protected updateChildren(children: Child[]): Child[] {
+    this.#children = children;
+    return children;
   }
 
   parentElement() {
     return this.bounds.parentElement();
   }
 
+  get first(): Nullable<SimpleNode> {
+    return this.bounds.first;
+  }
+
+  get last(): Nullable<SimpleNode> {
+    return this.bounds.last;
+  }
+
   firstNode() {
     return this.bounds.firstNode();
   }
@@ -152,13 +219,26 @@ export abstract class BlockOpcode implements UpdatingOpcode, Bounds {
   }
 }
 
-export class TryOpcode extends BlockOpcode implements ExceptionHandler {
+export class TryOpcode extends AbstractBlockOpcode implements ExceptionHandler {
   public type = 'try';
 
   protected declare bounds: UpdatableBlock; // Hides property on base class
 
   override evaluate(vm: UpdatingVM) {
-    vm.try(this.children, this);
+    vm.try(this.children, { handler: this, unwind: this.#catchState });
+  }
+
+  get #catchState() {
+    return this.state.unwind.catchState(this.state.isTryFrame);
+  }
+
+  unwind() {
+    if (this.state.isTryFrame) {
+      this.handleException();
+      return true;
+    } else {
+      return false;
+    }
   }
 
   handleException() {
@@ -167,40 +247,40 @@ export class TryOpcode extends BlockOpcode implements ExceptionHandler {
     destroyChildren(this);
 
     let elementStack = NewElementBuilder.resume(runtime.env, bounds);
-    let vm = state.resume(runtime, elementStack);
-
-    let updating: UpdatingOpcode[] = [];
-    let children = (this.children = []);
+    let vm = VM.resume(runtime, state, elementStack);
 
     let result = vm.execute((vm) => {
-      vm.pushUpdating(updating);
-      vm.updateWith(this);
-      vm.pushUpdating(children);
+      if (this.state.isTryFrame) {
+        vm.setupBegin(-1, this.#catchState.error, this.#catchState.handler);
+      }
     });
 
     associateDestroyableChild(this, result.drop);
+    this.updateChildren(result.children);
   }
 }
 
 export class ListItemOpcode extends TryOpcode {
   public retained = false;
   public index = -1;
+  #memo: Reactive;
 
   constructor(
-    state: ResumableVMState,
+    state: InitialVmState,
     runtime: RuntimeContext,
     bounds: UpdatableBlock,
     public key: unknown,
-    public memo: Reference,
-    public value: Reference
+    memo: Reactive,
+    public value: Reactive
   ) {
     super(state, runtime, bounds, []);
+    this.#memo = memo;
   }
 
   updateReferences(item: OpaqueIterationItem) {
     this.retained = true;
-    updateRef(this.value, item.value);
-    updateRef(this.memo, item.memo);
+    updateReactive(this.value, item.value);
+    updateReactive(this.#memo, item.memo);
   }
 
   shouldRemove(): boolean {
@@ -212,64 +292,69 @@ export class ListItemOpcode extends TryOpcode {
   }
 }
 
-export class ListBlockOpcode extends BlockOpcode {
-  public type = 'list-block';
-  public declare children: ListItemOpcode[];
+export class ListBlockOpcode extends AbstractBlockOpcode<ListItemOpcode> {
+  readonly type = 'list-block';
 
-  private opcodeMap = new Map<unknown, ListItemOpcode>();
-  private marker: SimpleComment | null = null;
-  private lastIterator: OpaqueIterator;
+  #opcodeMap = new Map<unknown, ListItemOpcode>();
+  #marker: SimpleComment | null = null;
+  #lastIterator: Result<OpaqueIterator>;
 
   protected declare readonly bounds: LiveBlockList;
 
   constructor(
-    state: ResumableVMState,
+    state: InitialVmState,
     runtime: RuntimeContext,
     bounds: LiveBlockList,
     children: ListItemOpcode[],
-    private iterableRef: Reference<OpaqueIterator>
+    private iterableRef: Reactive<OpaqueIterator>
   ) {
     super(state, runtime, bounds, children);
-    this.lastIterator = valueForRef(iterableRef);
+    this.#lastIterator = readReactive(iterableRef);
   }
 
   initializeChild(opcode: ListItemOpcode) {
     opcode.index = this.children.length - 1;
-    this.opcodeMap.set(opcode.key, opcode);
+    this.#opcodeMap.set(opcode.key, opcode);
   }
 
   override evaluate(vm: UpdatingVM) {
-    let iterator = valueForRef(this.iterableRef);
+    let iterator = readReactive(this.iterableRef);
 
-    if (this.lastIterator !== iterator) {
+    if (this.#lastIterator.type !== iterator.type || this.#lastIterator.value !== iterator.value) {
       let { bounds } = this;
       let { dom } = vm;
 
-      let marker = (this.marker = dom.createComment(''));
+      let marker = (this.#marker = dom.createComment(''));
       dom.insertAfter(
         bounds.parentElement(),
         marker,
         expect(bounds.lastNode(), "can't insert after an empty bounds")
       );
 
-      this.sync(iterator);
+      if (iterator.type === 'err') {
+        // @fixme
+        throw Error('unimplemented: list block iterator error');
+      }
+
+      this.#sync(iterator.value);
 
       this.parentElement().removeChild(marker);
-      this.marker = null;
-      this.lastIterator = iterator;
+      this.#marker = null;
+      this.#lastIterator = iterator;
     }
 
     // Run now-updated updating opcodes
     super.evaluate(vm);
   }
 
-  private sync(iterator: OpaqueIterator) {
-    let { opcodeMap: itemMap, children } = this;
+  #sync(iterator: OpaqueIterator) {
+    const itemMap = this.#opcodeMap;
 
     let currentOpcodeIndex = 0;
     let seenIndex = 0;
 
-    this.children = this.bounds.boundList = [];
+    const children = this.children;
+    this.bounds.boundList = this.updateChildren([]);
 
     // eslint-disable-next-line no-constant-condition
     while (true) {
@@ -280,8 +365,8 @@ export class ListBlockOpcode extends BlockOpcode {
       let opcode = children[currentOpcodeIndex];
       let { key } = item;
 
-      // Items that have already been found and moved will already be retained,
-      // we can continue until we find the next unretained item
+      // Items that have already been found and moved will already be retained, we can continue
+      // until we find the next unretained item
       while (opcode !== undefined && opcode.retained === true) {
         opcode = children[++currentOpcodeIndex];
       }
@@ -296,16 +381,14 @@ export class ListBlockOpcode extends BlockOpcode {
         if (itemOpcode.index < seenIndex) {
           this.moveItem(itemOpcode, item, opcode);
         } else {
-          // Update the seen index, we are going to be moving this item around
-          // so any other items that come before it will likely need to move as
-          // well.
+          // Update the seen index, we are going to be moving this item around so any other items
+          // that come before it will likely need to move as well.
           seenIndex = itemOpcode.index;
 
           let seenUnretained = false;
 
-          // iterate through all of the opcodes between the current position and
-          // the position of the item's opcode, and determine if they are all
-          // retained.
+          // iterate through all of the opcodes between the current position and the position of the
+          // item's opcode, and determine if they are all retained.
           for (let i = currentOpcodeIndex + 1; i < seenIndex; i++) {
             if (unwrap(children[i]).retained === false) {
               seenUnretained = true;
@@ -313,9 +396,9 @@ export class ListBlockOpcode extends BlockOpcode {
             }
           }
 
-          // If we have seen only retained opcodes between this and the matching
-          // opcode, it means that all the opcodes in between have been moved
-          // already, and we can safely retain this item's opcode.
+          // If we have seen only retained opcodes between this and the matching opcode, it means
+          // that all the opcodes in between have been moved already, and we can safely retain this
+          // item's opcode.
           if (seenUnretained === false) {
             this.retainItem(itemOpcode, item);
             currentOpcodeIndex = seenIndex + 1;
@@ -345,9 +428,7 @@ export class ListBlockOpcode extends BlockOpcode {
 
     let { children } = this;
 
-    updateRef(opcode.memo, item.memo);
-    updateRef(opcode.value, item.value);
-    opcode.retained = true;
+    opcode.updateReferences(item);
 
     opcode.index = children.length;
     children.push(opcode);
@@ -358,19 +439,19 @@ export class ListBlockOpcode extends BlockOpcode {
       logStep!('list-updates', ['insert', item.key]);
     }
 
-    let { opcodeMap, bounds, state, runtime, children } = this;
+    const opcodeMap = this.#opcodeMap;
+    let { bounds, state, runtime, children } = this;
     let { key } = item;
-    let nextSibling = before === undefined ? this.marker : before.firstNode();
+    let nextSibling = before === undefined ? this.#marker : before.firstNode();
 
     let elementStack = NewElementBuilder.forInitialRender(runtime.env, {
       element: bounds.parentElement(),
       nextSibling,
     });
 
-    let vm = state.resume(runtime, elementStack);
+    let vm = VM.resume(runtime, state, elementStack);
 
     vm.execute((vm) => {
-      vm.pushUpdating();
       let opcode = vm.enterItem(item);
 
       opcode.index = children.length;
@@ -387,22 +468,19 @@ export class ListBlockOpcode extends BlockOpcode {
   ) {
     let { children } = this;
 
-    updateRef(opcode.memo, item.memo);
-    updateRef(opcode.value, item.value);
-    opcode.retained = true;
+    opcode.updateReferences(item);
 
     let currentSibling, nextSibling;
 
     if (before === undefined) {
-      moveBounds(opcode, this.marker);
+      moveBounds(opcode, this.#marker);
     } else {
       currentSibling = opcode.lastNode().nextSibling;
       nextSibling = before.firstNode();
 
-      // Items are moved throughout the algorithm, so there are cases where the
-      // the items already happen to be siblings (e.g. an item in between was
-      // moved before this move happened). Check to see if they are siblings
-      // first before doing the move.
+      // Items are moved throughout the algorithm, so there are cases where the the items already
+      // happen to be siblings (e.g. an item in between was moved before this move happened). Check
+      // to see if they are siblings first before doing the move.
       if (currentSibling !== nextSibling) {
         moveBounds(opcode, nextSibling);
       }
@@ -424,29 +502,43 @@ export class ListBlockOpcode extends BlockOpcode {
 
     destroy(opcode);
     clear(opcode);
-    this.opcodeMap.delete(opcode.key);
+    this.#opcodeMap.delete(opcode.key);
   }
 }
 
 class UpdatingVMFrame {
-  private current = 0;
+  #current = 0;
+  readonly #ops: readonly UpdatingOpcode[];
+  readonly #error: Nullable<HandleException>;
 
-  constructor(
-    private ops: UpdatingOpcode[],
-    private exceptionHandler: Nullable<ExceptionHandler>
-  ) {}
+  constructor(ops: UpdatingOpcode[], handleException: Nullable<HandleException>) {
+    this.#ops = ops;
+    this.#error = handleException;
+  }
 
   goto(index: number) {
-    this.current = index;
+    this.#current = index;
   }
 
   nextStatement(): UpdatingOpcode | undefined {
-    return this.ops[this.current++];
+    return this.#ops[this.#current++];
   }
 
-  handleException() {
-    if (this.exceptionHandler) {
-      this.exceptionHandler.handleException();
+  /**
+   * unwind returns true if the frame is an unwind target (and therefore unwinding should stop at
+   * this frame).
+   */
+  unwind(): boolean {
+    if (this.#error && this.#error.handler.unwind()) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  handleException(): void {
+    if (this.#error) {
+      this.#error.handler.handleException();
     }
   }
 }
diff --git a/packages/@glimmer/runtime/package.json b/packages/@glimmer/runtime/package.json
index fff50177b0..96adbda0f7 100644
--- a/packages/@glimmer/runtime/package.json
+++ b/packages/@glimmer/runtime/package.json
@@ -34,7 +34,7 @@
     "@glimmer/local-debug-flags": "workspace:^",
     "@glimmer/opcode-compiler": "workspace:^",
     "@glimmer/debug": "workspace:^",
-    "@types/qunit": "^2.19.7",
+    "@types/qunit": "workspace:^",
     "@glimmer-workspace/build-support": "workspace:^"
   },
   "scripts": {
diff --git a/packages/@glimmer/syntax/index.ts b/packages/@glimmer/syntax/index.ts
index e10154b1b2..a48bacdc88 100644
--- a/packages/@glimmer/syntax/index.ts
+++ b/packages/@glimmer/syntax/index.ts
@@ -14,6 +14,7 @@ export {
   type TemplateIdFn,
 } from './lib/parser/tokenizer-event-handlers';
 export * as src from './lib/source/api';
+export { SourceSpan } from './lib/source/loc/span';
 export { SourceSlice } from './lib/source/slice';
 export {
   type HasSourceSpan,
diff --git a/packages/@glimmer/syntax/lib/generation/print.ts b/packages/@glimmer/syntax/lib/generation/print.ts
index a1f8c3d476..1a26f58726 100644
--- a/packages/@glimmer/syntax/lib/generation/print.ts
+++ b/packages/@glimmer/syntax/lib/generation/print.ts
@@ -1,5 +1,7 @@
 import type * as ASTv1 from '../v1/api';
-import Printer, { type PrinterOptions } from './printer';
+import type {PrinterOptions} from './printer';
+
+import Printer from './printer';
 
 export default function build(
   ast: ASTv1.Node,
diff --git a/packages/@glimmer/syntax/lib/generation/printer.ts b/packages/@glimmer/syntax/lib/generation/printer.ts
index 06334ff232..339e65e86f 100644
--- a/packages/@glimmer/syntax/lib/generation/printer.ts
+++ b/packages/@glimmer/syntax/lib/generation/printer.ts
@@ -1,4 +1,5 @@
 import type * as ASTv1 from '../v1/api';
+
 import { escapeAttrValue, escapeText, sortByLoc } from './util';
 
 export const voidMap: {
diff --git a/packages/@glimmer/syntax/lib/get-template-locals.ts b/packages/@glimmer/syntax/lib/get-template-locals.ts
index 210d0389be..149af1f95f 100644
--- a/packages/@glimmer/syntax/lib/get-template-locals.ts
+++ b/packages/@glimmer/syntax/lib/get-template-locals.ts
@@ -1,7 +1,8 @@
+import type * as ASTv1 from './v1/api';
+
 import { isKeyword } from './keywords';
 import { preprocess } from './parser/tokenizer-event-handlers';
 import traverse from './traversal/traverse';
-import type * as ASTv1 from './v1/api';
 
 interface GetTemplateLocalsOptions {
   includeKeywords?: boolean;
diff --git a/packages/@glimmer/syntax/lib/keywords.ts b/packages/@glimmer/syntax/lib/keywords.ts
index 56b8363593..4d8aeaa113 100644
--- a/packages/@glimmer/syntax/lib/keywords.ts
+++ b/packages/@glimmer/syntax/lib/keywords.ts
@@ -31,4 +31,5 @@ export const KEYWORDS_TYPES = {
   unless: ['Call', 'Append', 'Block'],
   with: ['Block'],
   yield: ['Append'],
+  '-try': ['Block'],
 } satisfies Record<string, readonly KeywordType[]>;
diff --git a/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts b/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts
index 8e9f89d413..8336197f84 100644
--- a/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts
+++ b/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts
@@ -1,13 +1,15 @@
 import type { Nullable, Recast } from '@glimmer/interfaces';
-import { getLast, isPresentArray, unwrap } from '@glimmer/util';
 import type { TokenizerState } from 'simple-html-tokenizer';
+import { getLast, isPresentArray, unwrap } from '@glimmer/util';
 
-import { Parser, type ParserNodeBuilder, type Tag } from '../parser';
+import type {ParserNodeBuilder, Tag} from '../parser';
+import type * as ASTv1 from '../v1/api';
+import type * as HBS from '../v1/handlebars-ast';
+
+import { Parser   } from '../parser';
 import { NON_EXISTENT_LOCATION } from '../source/location';
 import { generateSyntaxError } from '../syntax-error';
 import { appendChild, isHBSLiteral, printLiteral } from '../utils';
-import type * as ASTv1 from '../v1/api';
-import type * as HBS from '../v1/handlebars-ast';
 import { PathExpressionImplV1 } from '../v1/legacy-interop';
 import b from '../v1/parser-builders';
 
diff --git a/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts b/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts
index 518ad65c4a..6565b2d220 100644
--- a/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts
+++ b/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts
@@ -3,17 +3,18 @@ import { assertPresentArray, assign, getFirst, getLast, isPresentArray } from '@
 import { parse, parseWithoutProcessing } from '@handlebars/parser';
 import { EntityParser } from 'simple-html-tokenizer';
 
+import type { Tag } from '../parser';
+import type { NodeVisitor } from '../traversal/visitor';
+import type * as ASTv1 from '../v1/api';
+import type * as HBS from '../v1/handlebars-ast';
+
 import print from '../generation/print';
 import { voidMap } from '../generation/printer';
-import type { Tag } from '../parser';
 import * as src from '../source/api';
 import { generateSyntaxError } from '../syntax-error';
 import traverse from '../traversal/traverse';
-import type { NodeVisitor } from '../traversal/visitor';
 import Walker from '../traversal/walker';
 import { appendChild, parseElementBlockParams } from '../utils';
-import type * as ASTv1 from '../v1/api';
-import type * as HBS from '../v1/handlebars-ast';
 import b from '../v1/parser-builders';
 import publicBuilder from '../v1/public-builders';
 import { HandlebarsNodeVisitors } from './handlebars-node-visitors';
diff --git a/packages/@glimmer/syntax/lib/source/loc/match.ts b/packages/@glimmer/syntax/lib/source/loc/match.ts
index 48f1a4afd7..1d725ff60c 100644
--- a/packages/@glimmer/syntax/lib/source/loc/match.ts
+++ b/packages/@glimmer/syntax/lib/source/loc/match.ts
@@ -1,8 +1,9 @@
 import { assert, isPresentArray } from '@glimmer/util';
 
-import { OffsetKind } from './kinds';
 import type { CharPosition, HbsPosition, InvisiblePosition, PositionData } from './offset';
 
+import { OffsetKind } from './kinds';
+
 /**
  * This file implements the DSL used by span and offset in places where they need to exhaustively
  * consider all combinations of states (Handlebars offsets, character offsets and invisible/broken
@@ -177,7 +178,7 @@ class Matcher<Out, M extends Matches = Matches> {
   when(
     left: Pattern,
     right: Pattern,
-     
+
     callback: (left: any, right: any) => Out
   ): Matcher<Out, Matches> | ExhaustiveMatcher<Out> {
     this._whens.get(left, () => new When()).add(right, callback);
diff --git a/packages/@glimmer/syntax/lib/source/loc/offset.ts b/packages/@glimmer/syntax/lib/source/loc/offset.ts
index b23c3ae054..9fbf1697c1 100644
--- a/packages/@glimmer/syntax/lib/source/loc/offset.ts
+++ b/packages/@glimmer/syntax/lib/source/loc/offset.ts
@@ -1,9 +1,12 @@
  
-import { type SourcePosition, UNKNOWN_POSITION } from '../location';
+import type {SourcePosition} from '../location';
 import type { Source } from '../source';
+import type {SourceSpan} from './span';
+
+import {  UNKNOWN_POSITION } from '../location';
 import { OffsetKind } from './kinds';
 import { match, MatchAny } from './match';
-import { type SourceSpan, span } from './span';
+import {  span } from './span';
 
 /**
  * All positions have these details in common. Most notably, all three kinds of positions can
diff --git a/packages/@glimmer/syntax/lib/source/loc/span.ts b/packages/@glimmer/syntax/lib/source/loc/span.ts
index 055ad4a396..73c50a0db2 100644
--- a/packages/@glimmer/syntax/lib/source/loc/span.ts
+++ b/packages/@glimmer/syntax/lib/source/loc/span.ts
@@ -1,26 +1,16 @@
- 
-
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 import { assertNever } from '@glimmer/util';
 
-import {
-  BROKEN_LOCATION,
-  NON_EXISTENT_LOCATION,
-  type SourceLocation,
-  type SourcePosition,
-} from '../location';
-import { SourceSlice } from '../slice';
+import type { SourceLocation, SourcePosition } from '../location';
 import type { Source } from '../source';
+import type { MatchFn } from './match';
+import type { AnyPosition, SourceOffset } from './offset';
+
+import { BROKEN_LOCATION, NON_EXISTENT_LOCATION } from '../location';
+import { SourceSlice } from '../slice';
 import { OffsetKind } from './kinds';
-import { IsInvisible, match, MatchAny, type MatchFn } from './match';
-import {
-  type AnyPosition,
-  BROKEN,
-  CharPosition,
-  HbsPosition,
-  InvisiblePosition,
-  type SourceOffset,
-} from './offset';
+import { IsInvisible, match, MatchAny } from './match';
+import { BROKEN, CharPosition, HbsPosition, InvisiblePosition } from './offset';
 
 /**
  * All spans have these details in common.
diff --git a/packages/@glimmer/syntax/lib/source/source.ts b/packages/@glimmer/syntax/lib/source/source.ts
index c071f0d786..6e9bc5540b 100644
--- a/packages/@glimmer/syntax/lib/source/source.ts
+++ b/packages/@glimmer/syntax/lib/source/source.ts
@@ -3,6 +3,7 @@ import { assert } from '@glimmer/util';
 
 import type { PrecompileOptions } from '../parser/tokenizer-event-handlers';
 import type { SourceLocation, SourcePosition } from './location';
+
 import { SourceOffset, SourceSpan } from './span';
 
 export class Source {
@@ -10,7 +11,7 @@ export class Source {
     return new Source(source, options.meta?.moduleName);
   }
 
-  constructor(readonly source: string, readonly module: string = 'an unknown module') {}
+  constructor(readonly source: string, readonly module = 'an unknown module') {}
 
   /**
    * Validate that the character offset represents a position in the source string.
diff --git a/packages/@glimmer/syntax/lib/source/span-list.ts b/packages/@glimmer/syntax/lib/source/span-list.ts
index 543aa243ee..61ab62245c 100644
--- a/packages/@glimmer/syntax/lib/source/span-list.ts
+++ b/packages/@glimmer/syntax/lib/source/span-list.ts
@@ -1,9 +1,11 @@
- 
+
 import type { PresentArray } from '@glimmer/interfaces';
 import { getFirst, getLast, isPresentArray } from '@glimmer/util';
 
 import type { LocatedWithOptionalSpan, LocatedWithSpan } from './location';
-import { type SourceOffset, SourceSpan } from './span';
+import type {SourceOffset} from './span';
+
+import {  SourceSpan } from './span';
 
 export type HasSpan = SourceSpan | LocatedWithSpan | PresentArray<LocatedWithSpan>;
 export type MaybeHasSpan = SourceSpan | LocatedWithOptionalSpan | LocatedWithOptionalSpan[] | null;
diff --git a/packages/@glimmer/syntax/lib/symbol-table.ts b/packages/@glimmer/syntax/lib/symbol-table.ts
index 790e7eed62..16c7cb8a16 100644
--- a/packages/@glimmer/syntax/lib/symbol-table.ts
+++ b/packages/@glimmer/syntax/lib/symbol-table.ts
@@ -41,7 +41,10 @@ export abstract class SymbolTable {
 }
 
 export class ProgramSymbolTable extends SymbolTable {
-  constructor(private templateLocals: string[], private options: SymbolTableOptions) {
+  constructor(
+    private templateLocals: string[],
+    private options: SymbolTableOptions
+  ) {
     super();
   }
 
@@ -71,7 +74,7 @@ export class ProgramSymbolTable extends SymbolTable {
     this.#hasDebugger = true;
   }
 
-  get hasEval(): boolean {
+  get hasDebug(): boolean {
     return this.#hasDebugger;
   }
 
@@ -151,7 +154,11 @@ export class ProgramSymbolTable extends SymbolTable {
 }
 
 export class BlockSymbolTable extends SymbolTable {
-  constructor(private parent: SymbolTable, public symbols: string[], public slots: number[]) {
+  constructor(
+    private parent: SymbolTable,
+    public symbols: string[],
+    public slots: number[]
+  ) {
     super();
   }
 
diff --git a/packages/@glimmer/syntax/lib/traversal/traverse.ts b/packages/@glimmer/syntax/lib/traversal/traverse.ts
index 5327e95228..21020f0efe 100644
--- a/packages/@glimmer/syntax/lib/traversal/traverse.ts
+++ b/packages/@glimmer/syntax/lib/traversal/traverse.ts
@@ -2,14 +2,16 @@ import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 import { deprecate, unwrap } from '@glimmer/util';
 
 import type * as ASTv1 from '../v1/api';
-import visitorKeys, { type VisitorKey, type VisitorKeys } from '../v1/visitor-keys';
+import type {VisitorKey, VisitorKeys} from '../v1/visitor-keys';
+import type { KeyHandler, KeyTraversal, NodeHandler, NodeTraversal, NodeVisitor } from './visitor';
+
+import visitorKeys from '../v1/visitor-keys';
 import {
   cannotRemoveNode,
   cannotReplaceNode,
   cannotReplaceOrRemoveInKeyHandlerYet,
 } from './errors';
 import WalkerPath from './path';
-import type { KeyHandler, KeyTraversal, NodeHandler, NodeTraversal, NodeVisitor } from './visitor';
 
 function getEnterFunction<N extends ASTv1.Node>(
   handler: NodeTraversal<N>
@@ -183,7 +185,7 @@ function visitKey<N extends ASTv1.Node>(
     if (result !== undefined) {
       // TODO: dynamically check the results by having a table of
       // expected node types in value space, not just type space
-       
+
       assignKey(node, key, value, result as any);
     }
   }
diff --git a/packages/@glimmer/syntax/lib/utils.ts b/packages/@glimmer/syntax/lib/utils.ts
index c716fcb44c..c0c2d1cb1d 100644
--- a/packages/@glimmer/syntax/lib/utils.ts
+++ b/packages/@glimmer/syntax/lib/utils.ts
@@ -1,10 +1,11 @@
 import type { Nullable } from '@glimmer/interfaces';
 import { expect, unwrap } from '@glimmer/util';
 
-import { generateSyntaxError } from './syntax-error';
 import type * as ASTv1 from './v1/api';
 import type * as HBS from './v1/handlebars-ast';
 
+import { generateSyntaxError } from './syntax-error';
+
 // Regex to validate the identifier for block parameters.
 // Based on the ID validation regex in Handlebars.
 
diff --git a/packages/@glimmer/syntax/lib/v1/legacy-interop.ts b/packages/@glimmer/syntax/lib/v1/legacy-interop.ts
index 01d5e6a68f..d0cc436a42 100644
--- a/packages/@glimmer/syntax/lib/v1/legacy-interop.ts
+++ b/packages/@glimmer/syntax/lib/v1/legacy-interop.ts
@@ -2,6 +2,7 @@ import { asPresentArray, assertPresentArray, getFirst } from '@glimmer/util';
 
 import type { SourceSpan } from '../source/span';
 import type { PathExpression, PathHead } from './nodes-v1';
+
 import b from './public-builders';
 
 export class PathExpressionImplV1 implements PathExpression {
diff --git a/packages/@glimmer/syntax/lib/v1/parser-builders.ts b/packages/@glimmer/syntax/lib/v1/parser-builders.ts
index 0a09cf3f5c..2d9b0a72f0 100644
--- a/packages/@glimmer/syntax/lib/v1/parser-builders.ts
+++ b/packages/@glimmer/syntax/lib/v1/parser-builders.ts
@@ -5,6 +5,7 @@ import type { ParserNodeBuilder } from '../parser';
 import type { SourceLocation } from '../source/location';
 import type { SourceOffset, SourceSpan } from '../source/span';
 import type * as ASTv1 from './api';
+
 import { PathExpressionImplV1 } from './legacy-interop';
 
 const DEFAULT_STRIP = {
diff --git a/packages/@glimmer/syntax/lib/v1/public-builders.ts b/packages/@glimmer/syntax/lib/v1/public-builders.ts
index 85d0ddde6e..4c5f133636 100644
--- a/packages/@glimmer/syntax/lib/v1/public-builders.ts
+++ b/packages/@glimmer/syntax/lib/v1/public-builders.ts
@@ -2,10 +2,12 @@ import type { Dict, Nullable } from '@glimmer/interfaces';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 import { asPresentArray, assert, assign, deprecate, isPresentArray } from '@glimmer/util';
 
-import { type SourceLocation, type SourcePosition, SYNTHETIC_LOCATION } from '../source/location';
+import type {SourceLocation, SourcePosition} from '../source/location';
+import type * as ASTv1 from './api';
+
+import {   SYNTHETIC_LOCATION } from '../source/location';
 import { Source } from '../source/source';
 import { SourceSpan } from '../source/span';
-import type * as ASTv1 from './api';
 import { PathExpressionImplV1 } from './legacy-interop';
 
 let _SOURCE: Source | undefined;
diff --git a/packages/@glimmer/syntax/lib/v2/builders.ts b/packages/@glimmer/syntax/lib/v2/builders.ts
index 9298e4635d..007a77ac70 100644
--- a/packages/@glimmer/syntax/lib/v2/builders.ts
+++ b/packages/@glimmer/syntax/lib/v2/builders.ts
@@ -1,10 +1,11 @@
 import type { PresentArray } from '@glimmer/interfaces';
 import { assert, assertPresentArray, assign } from '@glimmer/util';
 
-import { SourceSlice } from '../source/slice';
 import type { SourceSpan } from '../source/span';
-import { SpanList } from '../source/span-list';
 import type { BlockSymbolTable, ProgramSymbolTable, SymbolTable } from '../symbol-table';
+
+import { SourceSlice } from '../source/slice';
+import { SpanList } from '../source/span-list';
 import * as ASTv2 from './api';
 
 export interface CallParts {
diff --git a/packages/@glimmer/syntax/lib/v2/loose-resolution.ts b/packages/@glimmer/syntax/lib/v2/loose-resolution.ts
index 2458d356cb..b7cb1dd888 100644
--- a/packages/@glimmer/syntax/lib/v2/loose-resolution.ts
+++ b/packages/@glimmer/syntax/lib/v2/loose-resolution.ts
@@ -1,4 +1,5 @@
 import type * as ASTv1 from '../v1/api';
+
 import * as ASTv2 from './api';
 
 export interface AstCallParts {
diff --git a/packages/@glimmer/syntax/lib/v2/normalize.ts b/packages/@glimmer/syntax/lib/v2/normalize.ts
index cd83f66fc6..1608370602 100644
--- a/packages/@glimmer/syntax/lib/v2/normalize.ts
+++ b/packages/@glimmer/syntax/lib/v2/normalize.ts
@@ -1,32 +1,34 @@
 import type { PresentArray } from '@glimmer/interfaces';
 import { asPresentArray, assert, assign, isPresentArray } from '@glimmer/util';
 
+import type {PrecompileOptions, PrecompileOptionsWithLexicalScope} from '../parser/tokenizer-event-handlers';
+import type { SourceLocation } from '../source/location';
+import type { Source } from '../source/source';
+import type { SourceSpan } from '../source/span';
+import type {BlockSymbolTable, ProgramSymbolTable} from '../symbol-table';
+import type * as ASTv1 from '../v1/api';
+import type {BuildElement, CallParts} from './builders';
+import type {Resolution} from './loose-resolution';
+
 import Printer from '../generation/printer';
 import {
-  type PrecompileOptions,
-  type PrecompileOptionsWithLexicalScope,
-  preprocess,
+  preprocess
 } from '../parser/tokenizer-event-handlers';
-import type { SourceLocation } from '../source/location';
 import { SourceSlice } from '../source/slice';
-import type { Source } from '../source/source';
-import type { SourceSpan } from '../source/span';
 import { SpanList } from '../source/span-list';
-import { type BlockSymbolTable, type ProgramSymbolTable, SymbolTable } from '../symbol-table';
+import {   SymbolTable } from '../symbol-table';
 import { generateSyntaxError } from '../syntax-error';
 import { isLowerCase, isUpperCase } from '../utils';
-import type * as ASTv1 from '../v1/api';
 import b from '../v1/parser-builders';
 import * as ASTv2 from './api';
-import { type BuildElement, Builder, type CallParts } from './builders';
+import {  Builder  } from './builders';
 import {
   AppendSyntaxContext,
   AttrValueSyntaxContext,
   BlockSyntaxContext,
   ComponentSyntaxContext,
   ModifierSyntaxContext,
-  type Resolution,
-  SexpSyntaxContext,
+  SexpSyntaxContext
 } from './loose-resolution';
 
 export function normalize(
@@ -43,7 +45,7 @@ export function normalize(
 
   let top = SymbolTable.top(
     normalizeOptions.locals,
-     
+
     {
       customizeComponentName: options.customizeComponentName ?? ((name) => name),
       lexicalScope: options.lexicalScope,
diff --git a/packages/@glimmer/syntax/lib/v2/objects/args.ts b/packages/@glimmer/syntax/lib/v2/objects/args.ts
index e7f3726574..e9f4dcd727 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/args.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/args.ts
@@ -1,6 +1,7 @@
 import type { SourceSlice } from '../../source/slice';
 import type { SourceSpan } from '../../source/span';
 import type { ExpressionNode } from './expr';
+
 import { node } from './node';
 
 /**
diff --git a/packages/@glimmer/syntax/lib/v2/objects/attr-block.ts b/packages/@glimmer/syntax/lib/v2/objects/attr-block.ts
index 95eb22b20b..207705ad30 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/attr-block.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/attr-block.ts
@@ -1,7 +1,8 @@
 import type { SourceSlice } from '../../source/slice';
-import { NamedArgument } from './args';
 import type { CallFields } from './base';
 import type { ExpressionNode } from './expr';
+
+import { NamedArgument } from './args';
 import { node } from './node';
 
 /**
diff --git a/packages/@glimmer/syntax/lib/v2/objects/content.ts b/packages/@glimmer/syntax/lib/v2/objects/content.ts
index 7bb2f78a0f..d5d7449cfd 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/content.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/content.ts
@@ -1,12 +1,14 @@
 import type { SourceSlice } from '../../source/slice';
-import { SpanList } from '../../source/span-list';
 import type { SymbolTable } from '../../symbol-table';
-import { Args, NamedArguments } from './args';
 import type { ComponentArg, ElementModifier, HtmlOrSplatAttr } from './attr-block';
 import type { CallFields } from './base';
 import type { ExpressionNode } from './expr';
 import type { NamedBlock, NamedBlocks } from './internal-node';
-import { type BaseNodeFields, node } from './node';
+import type {BaseNodeFields} from './node';
+
+import { SpanList } from '../../source/span-list';
+import { Args, NamedArguments } from './args';
+import {  node } from './node';
 
 /**
  * Content Nodes are allowed in content positions in templates. They correspond to behavior in the
diff --git a/packages/@glimmer/syntax/lib/v2/objects/expr.ts b/packages/@glimmer/syntax/lib/v2/objects/expr.ts
index f62e3fdc7a..92b9b9d8ec 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/expr.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/expr.ts
@@ -1,10 +1,11 @@
 import type { PresentArray } from '@glimmer/interfaces';
 
-import { SourceSlice } from '../../source/slice';
 import type { CallFields } from './base';
-import { node } from './node';
 import type { FreeVarReference, VariableReference } from './refs';
 
+import { SourceSlice } from '../../source/slice';
+import { node } from './node';
+
 /**
  * A Handlebars literal.
  *
diff --git a/packages/@glimmer/syntax/lib/v2/objects/internal-node.ts b/packages/@glimmer/syntax/lib/v2/objects/internal-node.ts
index dc34faa9a9..e19a74af5b 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/internal-node.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/internal-node.ts
@@ -1,10 +1,12 @@
 import type { SourceSlice } from '../../source/slice';
-import { SpanList } from '../../source/span-list';
 import type { BlockSymbolTable, ProgramSymbolTable } from '../../symbol-table';
-import { Args, NamedArguments } from './args';
 import type { ComponentArg, ElementModifier, HtmlOrSplatAttr } from './attr-block';
 import type { GlimmerParentNodeOptions } from './base';
-import { type BaseNodeFields, node } from './node';
+import type {BaseNodeFields} from './node';
+
+import { SpanList } from '../../source/span-list';
+import { Args, NamedArguments } from './args';
+import {  node } from './node';
 
 /**
  * Corresponds to an entire template.
diff --git a/packages/@glimmer/syntax/lib/v2/objects/refs.ts b/packages/@glimmer/syntax/lib/v2/objects/refs.ts
index a1d05e5a71..f44d62258d 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/refs.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/refs.ts
@@ -1,7 +1,8 @@
 import type { SourceSlice } from '../../source/slice';
-import { node } from './node';
 import type { FreeVarResolution } from './resolution';
 
+import { node } from './node';
+
 /**
  * Corresponds to `this` at the head of an expression.
  */
diff --git a/packages/@glimmer/syntax/lib/v2/serialize/serialize.ts b/packages/@glimmer/syntax/lib/v2/serialize/serialize.ts
index 102384aec3..355caef414 100644
--- a/packages/@glimmer/syntax/lib/v2/serialize/serialize.ts
+++ b/packages/@glimmer/syntax/lib/v2/serialize/serialize.ts
@@ -1,6 +1,5 @@
 import type { PresentArray } from '@glimmer/interfaces';
 
-import { SourceSlice } from '../../source/slice';
 import type * as ASTv2 from '../api';
 import type {
   SerializedAppendContent,
@@ -34,6 +33,8 @@ import type {
   SerializedVariableReference,
 } from './types';
 
+import { SourceSlice } from '../../source/slice';
+
 export class RefSerializer {
   arg(ref: ASTv2.ArgReference): SerializedArgReference {
     return {
diff --git a/packages/@glimmer/syntax/package.json b/packages/@glimmer/syntax/package.json
index 15d0b8f043..3f0f59ad12 100644
--- a/packages/@glimmer/syntax/package.json
+++ b/packages/@glimmer/syntax/package.json
@@ -11,7 +11,7 @@
   },
   "devDependencies": {
     "@glimmer/local-debug-flags": "workspace:^",
-    "@types/qunit": "^2.19.7",
+    "@types/qunit": "workspace:^",
     "@glimmer-workspace/build-support": "workspace:^"
   },
   "scripts": {
diff --git a/packages/@glimmer/syntax/test/builders-test.ts b/packages/@glimmer/syntax/test/builders-test.ts
index 8ffefd8bc6..5490f3aedd 100644
--- a/packages/@glimmer/syntax/test/builders-test.ts
+++ b/packages/@glimmer/syntax/test/builders-test.ts
@@ -5,7 +5,7 @@ import { astEqual } from './support';
 
 QUnit.module('[glimmer-syntax] AST Builders');
 
-QUnit.test('element uses comments as loc when comments is not an array', function () {
+QUnit.test('element uses comments as loc when comments is not an array', () => {
   let actual = element('div', ['loc', b.loc(1, 1, 1, 1)]);
   let expected = element('div', ['loc', b.loc(1, 1, 1, 1)]);
 
diff --git a/packages/@glimmer/syntax/test/generation/print-test.ts b/packages/@glimmer/syntax/test/generation/print-test.ts
index fec7dd4773..cd3fa634cf 100644
--- a/packages/@glimmer/syntax/test/generation/print-test.ts
+++ b/packages/@glimmer/syntax/test/generation/print-test.ts
@@ -96,13 +96,13 @@ let templates = [
   '<Foo {{!-- This is a comment --}} attribute></Foo>',
 ];
 
-QUnit.module('[glimmer-syntax] Code generation', function () {
+QUnit.module('[glimmer-syntax] Code generation', () => {
   function printTransform(template: string) {
     return print(parse(template));
   }
 
   templates.forEach((template) => {
-    test(`${template} is stable when printed`, function (assert) {
+    test(`${template} is stable when printed`, (assert) => {
       assert.strictEqual(printTransform(template), template);
     });
   });
@@ -119,7 +119,7 @@ QUnit.module('[glimmer-syntax] Code generation', function () {
   });
 });
 
-QUnit.module('[glimmer-syntax] Code generation - source -> source', function () {
+QUnit.module('[glimmer-syntax] Code generation - source -> source', () => {
   function printTransform(template: string) {
     let ast = parse(template, {
       mode: 'codemod',
@@ -130,7 +130,7 @@ QUnit.module('[glimmer-syntax] Code generation - source -> source', function ()
   }
 
   function buildTest(template: string) {
-    test(`${template} is stable when printed`, function (assert) {
+    test(`${template} is stable when printed`, (assert) => {
       assert.strictEqual(printTransform(template), template);
     });
   }
@@ -155,8 +155,8 @@ QUnit.module('[glimmer-syntax] Code generation - source -> source', function ()
   ].forEach(buildTest);
 });
 
-QUnit.module('[glimmer-syntax] Code generation - override', function () {
-  test('can provide a custom options.override to be used', function (assert) {
+QUnit.module('[glimmer-syntax] Code generation - override', () => {
+  test('can provide a custom options.override to be used', (assert) => {
     let ast = parse(`<FooBar @baz="qux" @derp="qux" />`);
 
     let actual = print(ast, {
@@ -174,7 +174,7 @@ QUnit.module('[glimmer-syntax] Code generation - override', function () {
     assert.strictEqual(actual, `<FooBar @baz="ZOMG!!!!" @derp="qux" />`);
   });
 
-  test('maintains proper spacing when overriding hash', function (assert) {
+  test('maintains proper spacing when overriding hash', (assert) => {
     let ast = parse(`{{foo-bar blah=baz}}`);
 
     let actual = print(ast, {
@@ -192,7 +192,7 @@ QUnit.module('[glimmer-syntax] Code generation - override', function () {
     assert.strictEqual(actual, `{{foo-bar baz="ZOMG!!!!"}}`);
   });
 
-  test('maintains proper spacing when overriding empty hash', function (assert) {
+  test('maintains proper spacing when overriding empty hash', (assert) => {
     let ast = parse(`{{foo-bar derp blah=baz}}`);
 
     let actual = print(ast, {
diff --git a/packages/@glimmer/syntax/test/loc-node-test.ts b/packages/@glimmer/syntax/test/loc-node-test.ts
index 56eb707bdf..ed2186acff 100644
--- a/packages/@glimmer/syntax/test/loc-node-test.ts
+++ b/packages/@glimmer/syntax/test/loc-node-test.ts
@@ -1,4 +1,5 @@
-import { type AST, preprocess as parse, type src } from '@glimmer/syntax';
+import type {AST, src} from '@glimmer/syntax';
+import {  preprocess as parse  } from '@glimmer/syntax';
 import { guardArray } from '@glimmer-workspace/test-utils';
 
 QUnit.module('[glimmer-syntax] Parser - Location Info');
@@ -53,7 +54,7 @@ test('programs', () => {
   }
 });
 
-test('blocks', function () {
+test('blocks', () => {
   let ast = parse(`
   {{#if foo}}
     {{#if bar}}
@@ -76,7 +77,7 @@ test('blocks', function () {
   locEqual(nestedInverse as AST.Node, 5, 16, 7, 2);
 });
 
-test('mustache', function () {
+test('mustache', () => {
   let ast = parse(`
     {{foo}}
     {{#if foo}}
@@ -96,7 +97,7 @@ test('mustache', function () {
   }
 });
 
-test('element modifier', function () {
+test('element modifier', () => {
   let ast = parse(`
     <div {{bind-attr
       foo
@@ -109,7 +110,7 @@ test('element modifier', function () {
   }
 });
 
-test('html elements', function () {
+test('html elements', () => {
   let ast = parse(`
     <section>
       <br>
@@ -175,7 +176,7 @@ test('html elements with nested blocks', (assert) => {
   assert.verifySteps(['inverse block', 'nested inverse block']);
 });
 
-test('block + newline + element ', function () {
+test('block + newline + element ', () => {
   let ast = parse(`
     {{#if stuff}}
     {{/if}}
@@ -188,7 +189,7 @@ test('block + newline + element ', function () {
   locEqual(p, 4, 4, 4, 14, 'p element');
 });
 
-test('mustache + newline + element ', function () {
+test('mustache + newline + element ', () => {
   let ast = parse(`
     {{foo}}
     <p>Hi!</p>
@@ -200,7 +201,7 @@ test('mustache + newline + element ', function () {
   locEqual(p, 3, 4, 3, 14, 'p element');
 });
 
-test('blocks with nested html elements', function () {
+test('blocks with nested html elements', () => {
   let ast = parse(`
     {{#foo-bar}}<div>Foo</div>{{/foo-bar}} <p>Hi!</p>
   `);
@@ -215,7 +216,7 @@ test('blocks with nested html elements', function () {
   locEqual(p, 2, 43, 2, 53, 'p element');
 });
 
-test('html elements after mustache', function () {
+test('html elements after mustache', () => {
   let ast = parse(`
     {{foo-bar}} <p>Hi!</p>
   `);
@@ -226,7 +227,7 @@ test('html elements after mustache', function () {
   locEqual(p, 2, 16, 2, 26, 'div element');
 });
 
-test('text', function () {
+test('text', () => {
   let ast = parse(`
     foo!
     <div>blah</div>
@@ -241,7 +242,7 @@ test('text', function () {
   }
 });
 
-test('comment', function () {
+test('comment', () => {
   let ast = parse(`
     <div><!-- blah blah blah blah -->
       <!-- derp herky --><div></div>
@@ -258,7 +259,7 @@ test('comment', function () {
   }
 });
 
-test('handlebars comment', function () {
+test('handlebars comment', () => {
   let ast = parse(`
     <div>{{!-- blah blah blah blah --}}
       {{!-- derp herky --}}<div></div>
@@ -280,7 +281,7 @@ test('handlebars comment', function () {
   }
 });
 
-test('element attribute', function () {
+test('element attribute', () => {
   let ast = parse(`
     <div data-foo="blah"
       data-derp="lolol"
@@ -313,7 +314,7 @@ data-barf="herpy"
   }
 });
 
-test('element dynamic attribute', function () {
+test('element dynamic attribute', () => {
   let ast = parse(`<img src={{blah}}>`);
 
   let [img] = ast.body;
@@ -325,7 +326,7 @@ test('element dynamic attribute', function () {
   }
 });
 
-test('concat statement', function () {
+test('concat statement', () => {
   let ast = parse(`
     <div data-foo="{{if foo
         "active"
@@ -380,7 +381,7 @@ foo"
   }
 });
 
-test('char references', function () {
+test('char references', () => {
   let ast = parse(`
     &gt;<div>&lt;<p>
       Hi, danmcclain &excl;</p>
@@ -402,7 +403,7 @@ test('char references', function () {
   }
 });
 
-test('whitespace control - trailing', function () {
+test('whitespace control - trailing', () => {
   let ast = parse(`
   {{#if foo~}}
     <div></div>
@@ -419,7 +420,7 @@ test('whitespace control - trailing', function () {
   }
 });
 
-test("whitespace control - 'else if' trailing", function () {
+test("whitespace control - 'else if' trailing", () => {
   let ast = parse(`
   {{#if foo}}
     {{bar}}
@@ -441,7 +442,7 @@ test("whitespace control - 'else if' trailing", function () {
   }
 });
 
-test('whitespace control - leading', function () {
+test('whitespace control - leading', () => {
   let ast = parse(`
   {{~#if foo}}
     <div></div>
diff --git a/packages/@glimmer/syntax/test/parser-node-test.ts b/packages/@glimmer/syntax/test/parser-node-test.ts
index 403666278d..6f1f3ea205 100644
--- a/packages/@glimmer/syntax/test/parser-node-test.ts
+++ b/packages/@glimmer/syntax/test/parser-node-test.ts
@@ -1,53 +1,54 @@
 import type { Dict } from '@glimmer/interfaces';
+import type {ASTv1} from '@glimmer/syntax';
+import {  builders as b, preprocess as parse } from '@glimmer/syntax';
 import { syntaxErrorFor } from '@glimmer-workspace/test-utils';
 
-import { type ASTv1, builders as b, preprocess as parse } from '@glimmer/syntax';
 import { astEqual } from './support';
 
 const { test, skip } = QUnit;
 
 QUnit.module('[glimmer-syntax] Parser - AST');
 
-test('a simple piece of content', function () {
+test('a simple piece of content', () => {
   let t = 'some content';
   astEqual(t, b.program([b.text('some content')]));
 });
 
-test('self-closed element', function () {
+test('self-closed element', () => {
   let t = '<g />';
   astEqual(t, b.program([element('g/')]));
 });
 
-test('elements can have empty attributes', function () {
+test('elements can have empty attributes', () => {
   let t = '<img id="">';
   astEqual(t, b.program([element('img', ['attrs', ['id', '']])]));
 });
 
-test('disallowed quote in element space is rejected', function (assert) {
+test('disallowed quote in element space is rejected', (assert) => {
   let t = '<img foo="bar"" >';
   assert.throws(() => {
     parse(t, { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('" is not a valid character within attribute names', '', 'test-module', 1, 14));
 });
 
-test('disallowed equals sign in element space is rejected', function (assert) {
+test('disallowed equals sign in element space is rejected', (assert) => {
   let t = '<img =foo >';
   assert.throws(() => {
     parse(t, { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('attribute name cannot start with equals sign', '', 'test-module', 1, 5));
 });
 
-test('svg content', function () {
+test('svg content', () => {
   let t = '<svg></svg>';
   astEqual(t, b.program([element('svg')]));
 });
 
-test('html content with html content inline', function () {
+test('html content with html content inline', () => {
   let t = '<div><p></p></div>';
   astEqual(t, b.program([element('div', ['body', element('p')])]));
 });
 
-test('html content with svg content inline', function () {
+test('html content with svg content inline', () => {
   let t = '<div><svg></svg></div>';
   astEqual(t, b.program([element('div', ['body', element('svg')])]));
 });
@@ -70,7 +71,7 @@ for (const integrationPoint of integrationPoints) {
   );
 }
 
-test('svg title with html content', function () {
+test('svg title with html content', () => {
   let t = '<svg><title><div></div></title></svg>';
   astEqual(
     t,
@@ -78,7 +79,7 @@ test('svg title with html content', function () {
   );
 });
 
-test('a piece of content with HTML', function () {
+test('a piece of content with HTML', () => {
   let t = 'some <div>content</div> done';
   astEqual(
     t,
@@ -86,7 +87,7 @@ test('a piece of content with HTML', function () {
   );
 });
 
-test('a piece of Handlebars with HTML', function () {
+test('a piece of Handlebars with HTML', () => {
   let t = 'some <div>{{content}}</div> done';
   astEqual(
     t,
@@ -98,7 +99,7 @@ test('a piece of Handlebars with HTML', function () {
   );
 });
 
-test('Handlebars embedded in an attribute (quoted)', function () {
+test('Handlebars embedded in an attribute (quoted)', () => {
   let t = 'some <div class="{{foo}}">content</div> done';
   astEqual(
     t,
@@ -114,7 +115,7 @@ test('Handlebars embedded in an attribute (quoted)', function () {
   );
 });
 
-test('Handlebars embedded in an attribute (unquoted)', function () {
+test('Handlebars embedded in an attribute (unquoted)', () => {
   let t = 'some <div class={{foo}}>content</div> done';
   astEqual(
     t,
@@ -126,14 +127,14 @@ test('Handlebars embedded in an attribute (unquoted)', function () {
   );
 });
 
-test('Handlebars embedded in an attribute of a self-closing tag (unqouted)', function () {
+test('Handlebars embedded in an attribute of a self-closing tag (unqouted)', () => {
   let t = '<input value={{foo}}/>';
 
   let el = element('input/', ['attrs', ['value', b.mustache(b.path('foo'))]]);
   astEqual(t, b.program([el]));
 });
 
-test('Handlebars embedded in an attribute (sexprs)', function () {
+test('Handlebars embedded in an attribute (sexprs)', () => {
   let t = 'some <div class="{{foo (foo "abc")}}">content</div> done';
   astEqual(
     t,
@@ -155,7 +156,7 @@ test('Handlebars embedded in an attribute (sexprs)', function () {
   );
 });
 
-test('Handlebars embedded in an attribute with other content surrounding it', function () {
+test('Handlebars embedded in an attribute with other content surrounding it', () => {
   let t = 'some <a href="http://{{link}}/">content</a> done';
   astEqual(
     t,
@@ -171,7 +172,7 @@ test('Handlebars embedded in an attribute with other content surrounding it', fu
   );
 });
 
-test('A more complete embedding example', function () {
+test('A more complete embedding example', () => {
   let t =
     "{{embed}} {{some 'content'}} " +
     "<div class='{{foo}} {{bind-class isEnabled truthy='enabled'}}'>{{ content }}</div>" +
@@ -208,7 +209,7 @@ test('A more complete embedding example', function () {
   );
 });
 
-test('Simple embedded block helpers', function () {
+test('Simple embedded block helpers', () => {
   let t = '{{#if foo}}<div>{{content}}</div>{{/if}}';
   astEqual(
     t,
@@ -223,7 +224,7 @@ test('Simple embedded block helpers', function () {
   );
 });
 
-test('Involved block helper', function () {
+test('Involved block helper', () => {
   let t =
     '<p>hi</p> content {{#testing shouldRender}}<p>Appears!</p>{{/testing}} more <em>content</em> here';
   astEqual(
@@ -244,7 +245,7 @@ test('Involved block helper', function () {
   );
 });
 
-test('Element modifiers', function () {
+test('Element modifiers', () => {
   let t = "<p {{action 'boom'}} class='bar'>Some content</p>";
   astEqual(
     t,
@@ -259,32 +260,32 @@ test('Element modifiers', function () {
   );
 });
 
-test('Tokenizer: MustacheStatement encountered in beforeAttributeName state', function () {
+test('Tokenizer: MustacheStatement encountered in beforeAttributeName state', () => {
   let t = '<input {{bar}}>';
   astEqual(t, b.program([element('input', ['modifiers', 'bar'])]));
 });
 
-test('Tokenizer: MustacheStatement encountered in attributeName state', function () {
+test('Tokenizer: MustacheStatement encountered in attributeName state', () => {
   let t = '<input foo{{bar}}>';
   astEqual(t, b.program([element('input', ['attrs', ['foo', '']], ['modifiers', ['bar']])]));
 });
 
-test('Tokenizer: MustacheStatement encountered in afterAttributeName state', function () {
+test('Tokenizer: MustacheStatement encountered in afterAttributeName state', () => {
   let t = '<input foo {{bar}}>';
   astEqual(t, b.program([element('input', ['attrs', ['foo', '']], ['modifiers', 'bar'])]));
 });
 
-test('Tokenizer: MustacheStatement encountered in afterAttributeValue state', function () {
+test('Tokenizer: MustacheStatement encountered in afterAttributeValue state', () => {
   let t = '<input foo=1 {{bar}}>';
   astEqual(t, b.program([element('input', ['attrs', ['foo', '1']], ['modifiers', ['bar']])]));
 });
 
-test('Tokenizer: MustacheStatement encountered in afterAttributeValueQuoted state', function () {
+test('Tokenizer: MustacheStatement encountered in afterAttributeValueQuoted state', () => {
   let t = "<input foo='1'{{bar}}>";
   astEqual(t, b.program([element('input', ['attrs', ['foo', '1']], ['modifiers', 'bar'])]));
 });
 
-test('Stripping - mustaches', function () {
+test('Stripping - mustaches', () => {
   let t = 'foo {{~content}} bar';
   astEqual(
     t,
@@ -312,7 +313,7 @@ test('Stripping - mustaches', function () {
   );
 });
 
-test('Stripping - blocks', function () {
+test('Stripping - blocks', () => {
   let t = 'foo {{~#wat}}{{/wat}} bar';
   astEqual(
     t,
@@ -347,7 +348,7 @@ test('Stripping - blocks', function () {
   );
 });
 
-test('Stripping - programs', function () {
+test('Stripping - programs', () => {
   let t = '{{#wat~}} foo {{else}}{{/wat}}';
   astEqual(
     t,
@@ -417,7 +418,7 @@ test('Stripping - programs', function () {
   );
 });
 
-test('Stripping - removes unnecessary text nodes', function () {
+test('Stripping - removes unnecessary text nodes', () => {
   let t = '{{#each~}}\n  <li> foo </li>\n{{~/each}}';
 
   astEqual(
@@ -438,7 +439,7 @@ test('Stripping - removes unnecessary text nodes', function () {
   );
 });
 
-test('Whitespace control - linebreaks after blocks removed by default', function () {
+test('Whitespace control - linebreaks after blocks removed by default', () => {
   let t = '{{#each}}\n  <li> foo </li>\n{{/each}}';
 
   astEqual(
@@ -455,7 +456,7 @@ test('Whitespace control - linebreaks after blocks removed by default', function
   );
 });
 
-test('Whitespace control - preserve all whitespace if config is set', function () {
+test('Whitespace control - preserve all whitespace if config is set', () => {
   let t = '{{#each}}\n  <li> foo </li>\n{{/each}}';
 
   astEqual(
@@ -477,7 +478,7 @@ test('Whitespace control - preserve all whitespace if config is set', function (
 });
 
 // TODO: Make these throw an error.
-skip('Awkward mustache in unquoted attribute value', function () {
+skip('Awkward mustache in unquoted attribute value', () => {
   let t = '<div class=a{{foo}}></div>';
   astEqual(
     t,
@@ -499,12 +500,12 @@ skip('Awkward mustache in unquoted attribute value', function () {
   );
 });
 
-test('an HTML comment', function () {
+test('an HTML comment', () => {
   let t = 'before <!-- some comment --> after';
   astEqual(t, b.program([b.text('before '), b.comment(' some comment '), b.text(' after')]));
 });
 
-test('a Handlebars comment inside an HTML comment', function () {
+test('a Handlebars comment inside an HTML comment', () => {
   let t = 'before <!-- some {{! nested thing }} comment --> after';
   astEqual(
     t,
@@ -516,7 +517,7 @@ test('a Handlebars comment inside an HTML comment', function () {
   );
 });
 
-test('a Handlebars comment', function () {
+test('a Handlebars comment', () => {
   let t = 'before {{! some comment }} after';
   astEqual(
     t,
@@ -524,7 +525,7 @@ test('a Handlebars comment', function () {
   );
 });
 
-test('a Handlebars comment in proper element space', function () {
+test('a Handlebars comment in proper element space', () => {
   let t = 'before <div {{! some comment }} data-foo="bar" {{! other comment }}></div> after';
   astEqual(
     t,
@@ -540,7 +541,7 @@ test('a Handlebars comment in proper element space', function () {
   );
 });
 
-test('a Handlebars comment after a valueless attribute', function () {
+test('a Handlebars comment after a valueless attribute', () => {
   let t = '<input foo {{! comment }}>';
   astEqual(
     t,
@@ -550,7 +551,7 @@ test('a Handlebars comment after a valueless attribute', function () {
   );
 });
 
-test('a Handlebars comment in invalid element space', function (assert) {
+test('a Handlebars comment in invalid element space', (assert) => {
   assert.throws(() => {
     parse('\nbefore <div \n  a{{! some comment }} data-foo="bar"></div> after', {
       meta: { moduleName: 'test-module' },
@@ -570,55 +571,55 @@ test('a Handlebars comment in invalid element space', function (assert) {
   }, syntaxErrorFor('Using a Handlebars comment when in the `attributeValueDoubleQuoted` state is not supported', '{{! some comment }}', 'test-module', 3, 5));
 });
 
-test('allow {{null}} to be passed as helper name', function () {
+test('allow {{null}} to be passed as helper name', () => {
   let ast = parse('{{null}}');
 
   astEqual(ast, b.program([b.mustache(b.null())]));
 });
 
-test('allow {{null}} to be passed as a param', function () {
+test('allow {{null}} to be passed as a param', () => {
   let ast = parse('{{foo null}}');
 
   astEqual(ast, b.program([b.mustache(b.path('foo'), [b.null()])]));
 });
 
-test('allow {{undefined}} to be passed as helper name', function () {
+test('allow {{undefined}} to be passed as helper name', () => {
   let ast = parse('{{undefined}}');
 
   astEqual(ast, b.program([b.mustache(b.undefined())]));
 });
 
-test('allow {{undefined}} to be passed as a param', function () {
+test('allow {{undefined}} to be passed as a param', () => {
   let ast = parse('{{foo undefined}}');
 
   astEqual(ast, b.program([b.mustache(b.path('foo'), [b.undefined()])]));
 });
 
-test('Handlebars partial should error', function (assert) {
+test('Handlebars partial should error', (assert) => {
   assert.throws(() => {
     parse('{{> foo}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('Handlebars partials are not supported', '{{> foo}}', 'test-module', 1, 0));
 });
 
-test('Handlebars partial block should error', function (assert) {
+test('Handlebars partial block should error', (assert) => {
   assert.throws(() => {
     parse('{{#> foo}}{{/foo}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('Handlebars partial blocks are not supported', '{{#> foo}}{{/foo}}', 'test-module', 1, 0));
 });
 
-test('Handlebars decorator should error', function (assert) {
+test('Handlebars decorator should error', (assert) => {
   assert.throws(() => {
     parse('{{* foo}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('Handlebars decorators are not supported', '{{* foo}}', 'test-module', 1, 0));
 });
 
-test('Handlebars decorator block should error', function (assert) {
+test('Handlebars decorator block should error', (assert) => {
   assert.throws(() => {
     parse('{{#* foo}}{{/foo}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('Handlebars decorator blocks are not supported', '{{#* foo}}{{/foo}}', 'test-module', 1, 0));
 });
 
-test('disallowed mustaches in the tagName space', function (assert) {
+test('disallowed mustaches in the tagName space', (assert) => {
   assert.throws(() => {
     parse('<{{"asdf"}}></{{"asdf"}}>', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor('Cannot use mustaches in an elements tagname', '{{"asdf"}}', 'test-module', 1, 1));
@@ -628,7 +629,7 @@ test('disallowed mustaches in the tagName space', function (assert) {
   }, syntaxErrorFor('Cannot use mustaches in an elements tagname', '{{bar}}', 'test-module', 1, 6));
 });
 
-test('mustache immediately followed by self closing tag does not error', function () {
+test('mustache immediately followed by self closing tag does not error', () => {
   let ast = parse('<FooBar data-foo={{blah}}/>');
   let el = element('FooBar/', ['attrs', ['data-foo', b.mustache('blah')]]);
   astEqual(ast, b.program([el]));
@@ -661,37 +662,37 @@ test('named blocks', () => {
   astEqual(ast, b.program([el]));
 });
 
-test('path expression with "dangling dot" throws error', function (assert) {
+test('path expression with "dangling dot" throws error', (assert) => {
   assert.throws(() => {
     parse('{{if foo. bar baz}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor("'.' is not a supported path in Glimmer; check for a path with a trailing '.'", '.', 'test-module', 1, 8));
 });
 
-test('string literal as path throws error', function (assert) {
+test('string literal as path throws error', (assert) => {
   assert.throws(() => {
     parse('{{("foo-baz")}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor(`StringLiteral "foo-baz" cannot be called as a sub-expression, replace ("foo-baz") with "foo-baz"`, '"foo-baz"', 'test-module', 1, 3));
 });
 
-test('boolean literal as path throws error', function (assert) {
+test('boolean literal as path throws error', (assert) => {
   assert.throws(() => {
     parse('{{(true)}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor(`BooleanLiteral "true" cannot be called as a sub-expression, replace (true) with true`, 'true', 'test-module', 1, 3));
 });
 
-test('undefined literal as path throws error', function (assert) {
+test('undefined literal as path throws error', (assert) => {
   assert.throws(() => {
     parse('{{(undefined)}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor(`UndefinedLiteral "undefined" cannot be called as a sub-expression, replace (undefined) with undefined`, 'undefined', 'test-module', 1, 3));
 });
 
-test('null literal as path throws error', function (assert) {
+test('null literal as path throws error', (assert) => {
   assert.throws(() => {
     parse('{{(null)}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor(`NullLiteral "null" cannot be called as a sub-expression, replace (null) with null`, 'null', 'test-module', 1, 3));
 });
 
-test('number literal as path throws error', function (assert) {
+test('number literal as path throws error', (assert) => {
   assert.throws(() => {
     parse('{{(42)}}', { meta: { moduleName: 'test-module' } });
   }, syntaxErrorFor(`NumberLiteral "42" cannot be called as a sub-expression, replace (42) with 42`, '42', 'test-module', 1, 3));
diff --git a/packages/@glimmer/syntax/test/plugin-node-test.ts b/packages/@glimmer/syntax/test/plugin-node-test.ts
index 13136f3265..ada988bdb4 100644
--- a/packages/@glimmer/syntax/test/plugin-node-test.ts
+++ b/packages/@glimmer/syntax/test/plugin-node-test.ts
@@ -1,10 +1,7 @@
+import type {AST, ASTPluginBuilder, ASTPluginEnvironment, Syntax} from '@glimmer/syntax';
 import {
-  type AST,
-  type ASTPluginBuilder,
-  type ASTPluginEnvironment,
   preprocess,
-  type Syntax,
-  Walker,
+  Walker
 } from '@glimmer/syntax';
 import { expect as expectPresent } from '@glimmer/util';
 
diff --git a/packages/@glimmer/syntax/test/support.ts b/packages/@glimmer/syntax/test/support.ts
index 8e77558807..f2ce287b68 100644
--- a/packages/@glimmer/syntax/test/support.ts
+++ b/packages/@glimmer/syntax/test/support.ts
@@ -1,4 +1,5 @@
-import { type AST, preprocess as parse, type PreprocessOptions } from '@glimmer/syntax';
+import type {AST, PreprocessOptions} from '@glimmer/syntax';
+import {  preprocess as parse  } from '@glimmer/syntax';
 import { entries } from '@glimmer/util';
 
 function normalizeNode(obj: AST.Node | Array<AST.Node>): AST.Node | Array<AST.Node> {
diff --git a/packages/@glimmer/syntax/test/template-locals-test.ts b/packages/@glimmer/syntax/test/template-locals-test.ts
index 9d4c33f058..bb54dfba06 100644
--- a/packages/@glimmer/syntax/test/template-locals-test.ts
+++ b/packages/@glimmer/syntax/test/template-locals-test.ts
@@ -2,7 +2,7 @@ import { getTemplateLocals } from '@glimmer/syntax';
 
 QUnit.module('[glimmer-syntax] getTemplateLocals');
 
-QUnit.test('it works', function (assert) {
+QUnit.test('it works', (assert) => {
   let locals = getTemplateLocals(`
     <Component/>
 
@@ -60,7 +60,7 @@ QUnit.test('it works', function (assert) {
   ]);
 });
 
-QUnit.test('it does not include locals', function (assert) {
+QUnit.test('it does not include locals', (assert) => {
   let locals = getTemplateLocals(
     `
       <SomeComponent as |button|>
@@ -76,7 +76,7 @@ QUnit.test('it does not include locals', function (assert) {
   assert.deepEqual(locals, ['SomeComponent']);
 });
 
-QUnit.test('it excludes object locals', function (assert) {
+QUnit.test('it excludes object locals', (assert) => {
   let locals = getTemplateLocals(
     `
       <SomeComponent as |b|>
@@ -88,7 +88,7 @@ QUnit.test('it excludes object locals', function (assert) {
   assert.deepEqual(locals, ['SomeComponent']);
 });
 
-QUnit.test('it excludes object locals from nested blocks', function (assert) {
+QUnit.test('it excludes object locals from nested blocks', (assert) => {
   let locals = getTemplateLocals(
     `
       <SomeComponent as |some|>
@@ -104,7 +104,7 @@ QUnit.test('it excludes object locals from nested blocks', function (assert) {
   assert.deepEqual(locals, ['SomeComponent']);
 });
 
-QUnit.test('it can include keywords', function (assert) {
+QUnit.test('it can include keywords', (assert) => {
   let locals = getTemplateLocals(
     `
       <Component/>
@@ -155,7 +155,7 @@ QUnit.test('it can include keywords', function (assert) {
   ]);
 });
 
-QUnit.test('it can include html elements', function (assert) {
+QUnit.test('it can include html elements', (assert) => {
   let locals = getTemplateLocals(
     `
       <button></button>
diff --git a/packages/@glimmer/syntax/test/traversal/manipulating-node-test.ts b/packages/@glimmer/syntax/test/traversal/manipulating-node-test.ts
index 3288aab9f0..d611d8ebb3 100644
--- a/packages/@glimmer/syntax/test/traversal/manipulating-node-test.ts
+++ b/packages/@glimmer/syntax/test/traversal/manipulating-node-test.ts
@@ -1,13 +1,13 @@
-import { guardArray } from '@glimmer-workspace/test-utils';
-
+import type {AST} from '@glimmer/syntax';
 import {
-  type AST,
   builders as b,
   cannotRemoveNode,
   cannotReplaceNode,
   preprocess as parse,
-  traverse,
+  traverse
 } from '@glimmer/syntax';
+import { guardArray } from '@glimmer-workspace/test-utils';
+
 import { astEqual } from '../support';
 
 QUnit.module('[glimmer-syntax] Traversal - manipulating');
diff --git a/packages/@glimmer/syntax/test/traversal/visiting-keys-node-test.ts b/packages/@glimmer/syntax/test/traversal/visiting-keys-node-test.ts
index 06c3206d8c..78338a6c45 100644
--- a/packages/@glimmer/syntax/test/traversal/visiting-keys-node-test.ts
+++ b/packages/@glimmer/syntax/test/traversal/visiting-keys-node-test.ts
@@ -1,4 +1,5 @@
-import { type AST, preprocess as parse, traverse } from '@glimmer/syntax';
+import type {AST} from '@glimmer/syntax';
+import {  preprocess as parse, traverse } from '@glimmer/syntax';
 
 function traversalEqual(node: AST.Node, expectedTraversal: Array<[string, AST.Node | undefined]>) {
   let actualTraversal: Array<[string, AST.BaseNode]> = [];
@@ -43,7 +44,7 @@ function traversalEqual(node: AST.Node, expectedTraversal: Array<[string, AST.No
 
 QUnit.module('[glimmer-syntax] Traversal - visiting keys');
 
-QUnit.test('Blocks', function () {
+QUnit.test('Blocks', () => {
   let ast = parse(`{{#block param1 param2 key1=value key2=value}}<b></b><b></b>{{/block}}`);
   let block = ast.body[0] as AST.BlockStatement;
   let program = block.program;
diff --git a/packages/@glimmer/syntax/test/traversal/visiting-node-test.ts b/packages/@glimmer/syntax/test/traversal/visiting-node-test.ts
index c5093edd06..97e29e1115 100644
--- a/packages/@glimmer/syntax/test/traversal/visiting-node-test.ts
+++ b/packages/@glimmer/syntax/test/traversal/visiting-node-test.ts
@@ -1,5 +1,6 @@
 import type { Optional, OptionalArray } from '@glimmer/interfaces';
-import { type AST, preprocess as parse, traverse, type WalkerPath } from '@glimmer/syntax';
+import type {AST, WalkerPath} from '@glimmer/syntax';
+import {  preprocess as parse, traverse  } from '@glimmer/syntax';
 
 const { test } = QUnit;
 
@@ -39,7 +40,7 @@ function traversalEqual(
 
 QUnit.module('[glimmer-syntax] Traversal - visiting');
 
-test('Elements and attributes', function () {
+test('Elements and attributes', () => {
   let ast = parse(
     `<div id="id" class="large {{this.classes}}" value={{this.value}}><b></b><b></b></div>`
   );
@@ -83,7 +84,7 @@ test('Elements and attributes', function () {
   ]);
 });
 
-test('Element modifiers', function () {
+test('Element modifiers', () => {
   let ast = parse(`<div {{modifier}}{{modifier param1 param2 key1=value key2=value}}></div>`);
   let el = ast.body[0] as AST.ElementNode;
   traversalEqual(ast, [
@@ -118,7 +119,7 @@ test('Element modifiers', function () {
   ]);
 });
 
-test('Blocks', function () {
+test('Blocks', () => {
   let ast = parse(
     `{{#block}}{{/block}}` +
       `{{#block param1 param2 key1=value key2=value}}<b></b><b></b>{{/block}}`
@@ -165,7 +166,7 @@ test('Blocks', function () {
   ]);
 });
 
-test('Mustaches', function () {
+test('Mustaches', () => {
   let ast = parse(`{{mustache}}` + `{{mustache param1 param2 key1=value key2=value}}`);
 
   let must1 = ast.body[0] as AST.MustacheStatement;
@@ -201,7 +202,7 @@ test('Mustaches', function () {
   ]);
 });
 
-test('Nested helpers', function () {
+test('Nested helpers', () => {
   let ast = parse(`{{helper
     (helper param1 param2 key1=value key2=value)
     key1=(helper param)
@@ -271,7 +272,7 @@ test('Nested helpers', function () {
   ]);
 });
 
-test('Comments', function () {
+test('Comments', () => {
   let ast = parse(
     `<!-- HTML comment -->{{!-- Handlebars comment --}}<div {{! Other Comment }}></div>`
   );
@@ -292,7 +293,7 @@ test('Comments', function () {
 
 QUnit.module('[glimmer-syntax] Traversal - visiting - paths');
 
-test('Basics', function (assert) {
+test('Basics', (assert) => {
   let ast = parse(`{{#if foo}}<div>bar</div>{{/if}}`);
 
   traverse(ast, {
@@ -313,7 +314,7 @@ test('Basics', function (assert) {
   assert.verifySteps(['TextNode']);
 });
 
-test('Helper', function (assert) {
+test('Helper', (assert) => {
   let ast = parse(`{{#foo (bar this.blah)}}{{/foo}}`);
 
   traverse(ast, {
@@ -335,7 +336,7 @@ test('Helper', function (assert) {
   assert.verifySteps(['PathExpression this.blah']);
 });
 
-test('Modifier', function (assert) {
+test('Modifier', (assert) => {
   let ast = parse(`<div {{foo}}></div>`);
 
   traverse(ast, {
diff --git a/packages/@glimmer/syntax/test/traversal/walker-node-test.ts b/packages/@glimmer/syntax/test/traversal/walker-node-test.ts
index b4801cd1b8..53e2e07c6a 100644
--- a/packages/@glimmer/syntax/test/traversal/walker-node-test.ts
+++ b/packages/@glimmer/syntax/test/traversal/walker-node-test.ts
@@ -5,7 +5,7 @@ function compareWalkedNodes(html: string, expected: string[]) {
   let walker = new Walker();
   let nodes: string[] = [];
 
-  walker.visit(ast, function (node) {
+  walker.visit(ast, (node) => {
     nodes.push(node.type);
   });
 
@@ -14,11 +14,11 @@ function compareWalkedNodes(html: string, expected: string[]) {
 
 QUnit.module('[glimmer-syntax] (Legacy) Traversal - Walker');
 
-QUnit.test('walks elements', function () {
+QUnit.test('walks elements', () => {
   compareWalkedNodes('<div><li></li></div>', ['Template', 'ElementNode', 'ElementNode']);
 });
 
-QUnit.test('walks blocks', function () {
+QUnit.test('walks blocks', () => {
   compareWalkedNodes('{{#foo}}<li></li>{{/foo}}', [
     'Template',
     'BlockStatement',
diff --git a/packages/@glimmer/tsconfig.json b/packages/@glimmer/tsconfig.json
index d478d6443c..93e75ebf81 100644
--- a/packages/@glimmer/tsconfig.json
+++ b/packages/@glimmer/tsconfig.json
@@ -9,12 +9,10 @@
     "declaration": true,
     "declarationMap": true,
     "outDir": "../../ts-dist/packages",
-    "baseUrl": "..",
 
     "verbatimModuleSyntax": true,
 
     // Environment Configuration
-    "experimentalDecorators": true,
     "target": "ESNext",
     "module": "ESNext",
     "moduleResolution": "bundler",
@@ -30,6 +28,11 @@
 
     "types": ["qunit", "node", "vite/client"]
   },
-  "include": ["./**/*", "./**/*.d.ts"],
-  "exclude": ["*/dist", "*/node_modules", "**/fixtures", "*/test"]
+  "include": ["./*/index.ts", "./*/lib/**/*.ts"],
+  "exclude": ["./*/dist", "./*/node_modules", "./**/fixtures", "./*/test"],
+  "references": [
+    {
+      "path": "./tsconfig.test.json"
+    }
+  ]
 }
diff --git a/packages/@glimmer/tsconfig.test.json b/packages/@glimmer/tsconfig.test.json
index 894ef9950d..5cf9e3cc59 100644
--- a/packages/@glimmer/tsconfig.test.json
+++ b/packages/@glimmer/tsconfig.test.json
@@ -8,14 +8,13 @@
     "declaration": true,
     "declarationMap": true,
     "outDir": "../../ts-dist/packages",
-    "baseUrl": "..",
 
     "verbatimModuleSyntax": true,
 
-    "experimentalDecorators": true,
     "target": "ESNext",
     "module": "ESNext",
     "moduleResolution": "bundler",
+    "experimentalDecorators": true,
 
     "strict": true,
     "suppressImplicitAnyIndexErrors": false,
@@ -27,11 +26,6 @@
 
     "types": ["qunit", "node", "vite/client"]
   },
-  "include": ["*/test/**/*"],
-  "exclude": ["*/test/node_modules", "**/fixtures"],
-  "references": [
-    {
-      "path": "../@glimmer-workspace/tsconfig.json"
-    }
-  ]
+  "include": ["./*/test/**/*"],
+  "exclude": ["./*/test/node_modules", "./**/fixtures"]
 }
diff --git a/packages/@glimmer/util/index.ts b/packages/@glimmer/util/index.ts
deleted file mode 100644
index 38c7af3b9c..0000000000
--- a/packages/@glimmer/util/index.ts
+++ /dev/null
@@ -1,53 +0,0 @@
-export * from './lib/array-utils';
-export { default as assert, deprecate } from './lib/assert';
-export { dict, isDict, isObject, StackImpl as Stack } from './lib/collections';
-export { beginTestSteps, endTestSteps, logStep, verifySteps } from './lib/debug-steps';
-export { default as debugToString } from './lib/debug-to-string';
-export * from './lib/dom';
-export * from './lib/dom-utils';
-export * from './lib/immediate';
-export { default as intern } from './lib/intern';
-export {
-  isSerializationFirstNode,
-  SERIALIZATION_FIRST_NODE_STRING,
-} from './lib/is-serialization-first-node';
-export { assign, entries, fillNulls, values } from './lib/object-utils';
-export * from './lib/platform-utils';
-export * from './lib/present';
-export {
-  castToBrowser,
-  castToSimple,
-  checkBrowserNode as checkNode,
-  isElement,
-  isSimpleElement,
-} from './lib/simple-cast';
-export * from './lib/string';
-export * from './lib/template';
-export { default as buildUntouchableThis } from './lib/untouchable-this';
-
-export type FIXME<T, S extends string> = (T & S) | T;
-
-/**
- * This constant exists to make it easier to differentiate normal logs from
- * errant console.logs. LOCAL_LOGGER should only be used inside a
- * LOCAL_SHOULD_LOG check.
- *
- * It does not alleviate the need to check LOCAL_SHOULD_LOG, which is used
- * for stripping.
- */
-export const LOCAL_LOGGER = console;
-
-/**
- * This constant exists to make it easier to differentiate normal logs from
- * errant console.logs. LOGGER can be used outside of LOCAL_SHOULD_LOG checks,
- * and is meant to be used in the rare situation where a console.* call is
- * actually appropriate.
- */
-export const LOGGER = console;
-
-export function assertNever(value: never, desc = 'unexpected unreachable branch'): never {
-  LOGGER.log('unreachable', value);
-  LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`);
-
-  throw new Error(`code reached unreachable`);
-}
diff --git a/packages/@glimmer/util/lib/array-utils.ts b/packages/@glimmer/util/lib/array-utils.ts
index b4923e0f4c..c9c9b6acd8 100644
--- a/packages/@glimmer/util/lib/array-utils.ts
+++ b/packages/@glimmer/util/lib/array-utils.ts
@@ -1,4 +1,12 @@
-export const EMPTY_ARRAY: readonly unknown[] = Object.freeze([]) as readonly unknown[];
+export const EMPTY_ARRAY: readonly unknown[] = readonly([]);
+
+function readonly<T>(value: T): Readonly<T> {
+  if (import.meta.env.DEV) {
+    return Object.freeze(value);
+  }
+
+  return value as Readonly<T>;
+}
 
 export function emptyArray<T>(): T[] {
   return EMPTY_ARRAY as T[];
@@ -15,15 +23,65 @@ export function isEmptyArray(input: unknown[] | readonly unknown[]): boolean {
   return input === EMPTY_ARRAY;
 }
 
+/**
+ * This function does a better job of narrowing values to arrays (including readonly arrays) than
+ * the default Array.isArray.
+ */
+export function isArray<T extends unknown[] | readonly unknown[]>(value: unknown | T): value is T {
+  return Array.isArray(value);
+}
+
+export function* times(count: number) {
+  for (let i = 0; i < count; i++) {
+    yield i;
+  }
+}
+
+/**
+ * Returns an array of numbers from `start` up to `end` (inclusive)
+ */
+export function* range(start: number, end: number): IterableIterator<number> {
+  for (let i = start; i <= end; i++) {
+    yield i;
+  }
+}
+
 export function* reverse<T>(input: T[]): IterableIterator<T> {
   for (let i = input.length - 1; i >= 0; i--) {
     yield input[i]!;
   }
 }
 
+export function enumerate<const T extends unknown[] | readonly unknown[]>(
+  input: T
+): IterableIterator<
+  { [P in keyof T]: P extends `${infer N extends number}` ? [N, T[P]] : [number, T[P]] }[number]
+>;
+export function enumerate<T>(input: Iterable<T>): IterableIterator<[number, T]>;
 export function* enumerate<T>(input: Iterable<T>): IterableIterator<[number, T]> {
   let i = 0;
   for (const item of input) {
     yield [i++, item];
   }
 }
+
+export function* enumerateReverse<T>(input: readonly T[]): IterableIterator<[number, T]> {
+  for (let i = input.length - 1; i >= 0; i--) {
+    yield [i, input[i]!];
+  }
+}
+
+export function* zip<const T>(
+  left: readonly T[],
+  right: readonly T[]
+): IterableIterator<[T, T] | [T | undefined, T] | [T, T | undefined]> {
+  for (const [i, item] of enumerate(left)) {
+    yield [item, right[i]];
+  }
+
+  const excessStart = left.length;
+
+  for (const item of right.slice(excessStart)) {
+    yield [undefined, item];
+  }
+}
diff --git a/packages/@glimmer/util/lib/assert.ts b/packages/@glimmer/util/lib/assert.ts
deleted file mode 100644
index 7836138652..0000000000
--- a/packages/@glimmer/util/lib/assert.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-// import Logger from './logger';
-
-import { LOCAL_LOGGER } from '../index';
-
-// let alreadyWarned = false;
-
-export function debugAssert(test: any, msg: string): asserts test {
-  // if (!alreadyWarned) {
-  //   alreadyWarned = true;
-  //   Logger.warn("Don't leave debug assertions on in public builds");
-  // }
-
-  if (!test) {
-    throw new Error(msg || 'assertion failure');
-  }
-}
-
-export function prodAssert() {}
-
-export function deprecate(desc: string) {
-  LOCAL_LOGGER.warn(`DEPRECATION: ${desc}`);
-}
-
-export default debugAssert;
diff --git a/packages/@glimmer/util/lib/collections.ts b/packages/@glimmer/util/lib/collections.ts
index 93b8216bed..8f2708b6c9 100644
--- a/packages/@glimmer/util/lib/collections.ts
+++ b/packages/@glimmer/util/lib/collections.ts
@@ -1,7 +1,4 @@
-import type { Dict, Nullable, Stack } from '@glimmer/interfaces';
-
-import { unwrap } from './platform-utils';
-import { getLast } from './present';
+import type { Dict, Indexable } from '@glimmer/interfaces';
 
 export function dict<T = unknown>(): Dict<T> {
   return Object.create(null);
@@ -15,40 +12,6 @@ export function isObject<T>(u: T): u is object & T {
   return typeof u === 'function' || (typeof u === 'object' && u !== null);
 }
 
-export class StackImpl<T> implements Stack<T> {
-  private stack: T[];
-  public current: Nullable<T> = null;
-
-  constructor(values: T[] = []) {
-    this.stack = values;
-  }
-
-  public get size() {
-    return this.stack.length;
-  }
-
-  push(item: T) {
-    this.current = item;
-    this.stack.push(item);
-  }
-
-  pop(): Nullable<T> {
-    let item = this.stack.pop();
-    this.current = getLast(this.stack) ?? null;
-
-    return item === undefined ? null : item;
-  }
-
-  nth(from: number): Nullable<T> {
-    let len = this.stack.length;
-    return len < from ? null : unwrap(this.stack[len - from]);
-  }
-
-  isEmpty(): boolean {
-    return this.stack.length === 0;
-  }
-
-  toArray(): T[] {
-    return this.stack;
-  }
+export function isIndexable<T>(u: T): u is Indexable & T {
+  return isObject(u);
 }
diff --git a/packages/@glimmer/util/lib/constants.ts b/packages/@glimmer/util/lib/constants.ts
new file mode 100644
index 0000000000..6f002e61d3
--- /dev/null
+++ b/packages/@glimmer/util/lib/constants.ts
@@ -0,0 +1,11 @@
+import type { CompilableTemplate, IS_COMPILABLE_TEMPLATE_BRAND } from '@glimmer/interfaces';
+
+export const IS_COMPILABLE_TEMPLATE: IS_COMPILABLE_TEMPLATE_BRAND = Symbol(
+  'IS_COMPILABLE_TEMPLATE'
+) as IS_COMPILABLE_TEMPLATE_BRAND;
+
+export type IS_COMPILABLE_TEMPLATE = IS_COMPILABLE_TEMPLATE_BRAND;
+
+export function isCompilable(value: unknown): value is CompilableTemplate {
+  return !!(value && typeof value === 'object' && IS_COMPILABLE_TEMPLATE in value);
+}
diff --git a/packages/@glimmer/util/lib/debug-steps.ts b/packages/@glimmer/util/lib/debug-steps.ts
index bf64fbf6bb..bdf2818813 100644
--- a/packages/@glimmer/util/lib/debug-steps.ts
+++ b/packages/@glimmer/util/lib/debug-steps.ts
@@ -1,9 +1,9 @@
 /// <reference types="qunit" />
 
-import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
+import { LOCAL_DEBUG, LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 
-import assert from './assert';
-import { expect } from './platform-utils';
+import assert, { expect } from './devmode/assert';
+import { LOCAL_LOGGER } from './devmode/logging';
 
 export let beginTestSteps: (() => void) | undefined;
 export let endTestSteps: (() => void) | undefined;
@@ -29,6 +29,10 @@ if (LOCAL_DEBUG) {
   };
 
   logStep = (type: string, step: unknown) => {
+    if (LOCAL_TRACE_LOGGING) {
+      LOCAL_LOGGER.log('STEP', type, step);
+    }
+
     if (LOGGED_STEPS === null) return;
 
     let steps = LOGGED_STEPS[type];
diff --git a/packages/@glimmer/util/lib/devmode/assert.ts b/packages/@glimmer/util/lib/devmode/assert.ts
new file mode 100644
index 0000000000..276e123c09
--- /dev/null
+++ b/packages/@glimmer/util/lib/devmode/assert.ts
@@ -0,0 +1,147 @@
+// import Logger from './logger';
+
+import type { DevMode as DevModeInterface, DevModeClass, Present } from '@glimmer/interfaces';
+
+import type { AnyFunction } from '../types';
+
+import { LOCAL_LOGGER } from './logging';
+
+export function unwrap<T>(value: T): Present<T> {
+  assert(value !== null && value !== undefined, 'expected value to be present');
+  return value as Present<T>;
+}
+
+export function expect<T>(value: T, message: string): Present<T> {
+  assert(value !== null && value !== undefined, message);
+  return value as Present<T>;
+}
+
+export function assert(condition: unknown, msg: string): asserts condition {
+  if (import.meta.env.DEV) {
+    if (!condition) {
+      throw new Error(msg || 'assertion failure');
+    }
+  }
+}
+
+export function deprecate(desc: string) {
+  LOCAL_LOGGER.warn(`DEPRECATION: ${desc}`);
+}
+
+export default assert;
+
+let DevMode: typeof DevModeClass | undefined;
+
+if (import.meta.env.DEV) {
+  DevMode = class DevMode<T> {
+    static value<T>(devmode: DevModeInterface<T>) {
+      expect(devmode, `Expected value to be present in development mode`);
+
+      return (devmode as unknown as DevMode<T>).#value;
+    }
+
+    #value: T;
+
+    constructor(val: T) {
+      assert(val !== undefined, `You cannot put undefined in a DevMode`);
+      this.#value = val;
+    }
+
+    /**
+     * Even though eslint will still yell at us, let's get `String(DevMode<string>)` to produce the
+     * underlying string.
+     */
+    toString(): string {
+      return String(this.#value);
+    }
+  } as unknown as typeof DevModeClass;
+}
+
+export type IntoDevMode<T> = T | DevModeInterface<T>;
+
+/**
+ * This function returns a `DevModeInterface`. It takes an arrow function to ensure that the
+ * expression is stripped in production.
+ */
+export function devmode<const T>(value: () => IntoDevMode<T>): DevModeInterface<T> {
+  if (import.meta.env.DEV) {
+    return intoDevMode(value());
+  }
+
+  return undefined as unknown as DevModeInterface<T>;
+}
+
+/**
+ * This function is useful if the value in question is a function and the prod-mode version of the
+ * function can be successfully inlined.
+ *
+ * The constraint `Prod extends Dev` allows `Prod` to have fewer arguments than `Dev`, but only at
+ * the end.
+ */
+export function enhancedDevmode<const Dev extends AnyFunction, const Prod extends Dev>(
+  prod: Prod,
+  dev: Dev
+): Dev {
+  if (import.meta.env.DEV) {
+    return dev;
+  } else {
+    return prod;
+  }
+}
+
+function intoDevMode<T>(devmodeValue: IntoDevMode<T>): DevModeInterface<T> {
+  return devmodeValue instanceof DevMode!
+    ? (devmodeValue as unknown as DevModeInterface<T>)
+    : new DevMode!(devmodeValue);
+}
+
+/**
+ * The first parameter is an arrow so an expression that pulls out a devmode value is always removed
+ * outside of dev mode.
+ */
+export function mapDevmode<const T, const U = T>(
+  value: () => DevModeInterface<T>,
+  map: (value: T) => IntoDevMode<U>
+): DevModeInterface<U> {
+  if (import.meta.env.DEV) {
+    const devmodeValue = inDevmode(value());
+
+    const innerValue =
+      devmodeValue instanceof DevMode! ? DevMode!.value(devmodeValue) : devmodeValue;
+
+    return intoDevMode(map(innerValue));
+  }
+
+  return undefined as unknown as DevModeInterface<U>;
+}
+
+/**
+ * The first parameter is an arrow so an expression that pulls out a devmode value is always removed
+ * outside of dev mode.
+ */
+export function devmodeOr<const T>(value: () => DevModeInterface<T>, inProd: T): T {
+  if (import.meta.env.DEV) {
+    return inDevmode(value());
+  } else {
+    return inProd;
+  }
+}
+
+/**
+ * A version of unwrap that is meant to be used in development mode (inside an `import.meta.env.DEV`
+ * guard).
+ */
+export function inDevmode<T>(devmode: DevModeInterface<T>): T {
+  if (import.meta.env.DEV) {
+    assert(DevMode, `Expected the DevMode class to be present in development mode`);
+    assert(
+      devmode && devmode instanceof DevMode,
+      `Expected value to be present in development mode`
+    );
+    return DevMode.value(devmode);
+  } else {
+    throw Error(
+      `You shouldn't use devmode values in production mode. This function should even be present in production mode (it should be stripped due to lack of use), so something is wrong.`
+    );
+  }
+}
diff --git a/packages/@glimmer/util/lib/devmode/description.ts b/packages/@glimmer/util/lib/devmode/description.ts
new file mode 100644
index 0000000000..69dd857708
--- /dev/null
+++ b/packages/@glimmer/util/lib/devmode/description.ts
@@ -0,0 +1,127 @@
+import type {
+  DebugLabel,
+  DebugLabelSpec,
+  DefaultDescriptionFields,
+  Described,
+  Description,
+  DescriptionSpec,
+  DevMode,
+  Optional,
+  ValidatableDescription,
+} from '@glimmer/interfaces';
+
+import { isArray } from '../array-utils';
+import { isObject } from '../collections';
+import { assert, devmode, inDevmode, mapDevmode } from './assert';
+
+export function stringifyDebugLabel(described: Described<Description>): DevMode<string> {
+  return mapDevmode(
+    () => described.description,
+    (debug) => {
+      return stringifyChildLabel(...debug.label);
+    }
+  );
+}
+
+export function stringifyChildLabel(...parts: DebugLabel): string {
+  assert(
+    parts.every((part) => typeof part === 'string' || typeof part === 'symbol'),
+    `Expected all parts to be strings or symbols`
+  );
+
+  const [first, ...rest] = parts;
+
+  let out: string = first;
+
+  for (const part of rest) {
+    if (typeof part === 'string') {
+      if (/^\p{XID_Start}\p{XID_Continue}*$/u.test(part)) {
+        out += `.${part}`;
+      } else {
+        out += `[${JSON.stringify(part)}]`;
+      }
+    } else {
+      out += `[${String(part)}]`;
+    }
+  }
+
+  return out;
+}
+
+/**
+ * Using this function ensures that the `object.description` expression always gets stripped.
+ */
+export function getDescription<D extends Description>(object: Described<D>): DevMode<D> {
+  return mapDevmode(
+    () => object.description,
+    (desc) => desc
+  );
+}
+
+export function createWithDescription<O extends Described<D>, D extends Description>(
+  create: () => O,
+  description: DevMode<D>
+): O {
+  const object = create();
+  setDescription(object, description);
+  return object;
+}
+
+/**
+ * Using this function ensures that the `object.description = value` statement always gets stripped.
+ */
+
+export function setDescription<Desc extends Description>(
+  object: Described<Desc>,
+  description: DevMode<Desc>
+): void;
+export function setDescription<Desc extends Description, D>(
+  object: D,
+  description: DevMode<Desc>
+): asserts object is D & { description: DevMode<Desc> };
+export function setDescription(
+  object: { description?: DevMode<Description> },
+  description: DevMode<Description>
+): void {
+  if (import.meta.env.DEV) {
+    object.description = description;
+  }
+}
+
+export function toLabel(
+  spec: Optional<DebugLabelSpec> | false,
+  defaultLabel: DebugLabel
+): DevMode<DebugLabel> {
+  return devmode(() => {
+    if (!spec) return defaultLabel;
+
+    if (typeof spec === 'string') {
+      return [spec];
+    } else {
+      return spec;
+    }
+  });
+}
+
+export function toValidatableDescription<D extends ValidatableDescription>(
+  spec: Optional<DescriptionSpec>,
+  defaults: DevMode<DefaultDescriptionFields<D>>
+): DevMode<D> {
+  return mapDevmode(
+    () => defaults,
+    (defaults): D => {
+      if (!isObject(spec) || isArray(spec)) {
+        return {
+          ...defaults,
+          label: inDevmode(toLabel(spec, defaults.label)),
+        } as D;
+      } else {
+        return {
+          ...defaults,
+          ...spec,
+          label: typeof spec.label === 'string' ? ([spec.label] as const) : spec.label,
+        } as unknown as D;
+      }
+    }
+  );
+}
diff --git a/packages/@glimmer/util/lib/devmode/logging.ts b/packages/@glimmer/util/lib/devmode/logging.ts
new file mode 100644
index 0000000000..3933e42310
--- /dev/null
+++ b/packages/@glimmer/util/lib/devmode/logging.ts
@@ -0,0 +1,25 @@
+/**
+ * This constant exists to make it easier to differentiate normal logs from
+ * errant console.logs. LOCAL_LOGGER should only be used inside a
+ * LOCAL_SHOULD_LOG check.
+ *
+ * It does not alleviate the need to check LOCAL_SHOULD_LOG, which is used
+ * for stripping.
+ */
+
+export const LOCAL_LOGGER = console;
+/**
+ * This constant exists to make it easier to differentiate normal logs from
+ * errant console.logs. LOGGER can be used outside of LOCAL_SHOULD_LOG checks,
+ * and is meant to be used in the rare situation where a console.* call is
+ * actually appropriate.
+ */
+
+export const LOGGER = console;
+
+export function assertNever(value: never, desc = 'unexpected unreachable branch'): never {
+  LOGGER.log('unreachable', value);
+  LOGGER.log(`${desc} :: ${JSON.stringify(value)} (${value})`);
+
+  throw new Error(`code reached unreachable`);
+}
diff --git a/packages/@glimmer/util/lib/dom-utils.ts b/packages/@glimmer/util/lib/dom-utils.ts
index 179c988b37..cd23087205 100644
--- a/packages/@glimmer/util/lib/dom-utils.ts
+++ b/packages/@glimmer/util/lib/dom-utils.ts
@@ -1,12 +1,12 @@
-import type { InsertPosition, Namespace } from '@glimmer/interfaces';
+import type { InsertPosition, Namespace, NodeType } from '@glimmer/interfaces';
 
-export const RAW_NODE = -1;
-export const ELEMENT_NODE = 1;
-export const TEXT_NODE = 3;
-export const COMMENT_NODE = 8;
-export const DOCUMENT_NODE = 9;
-export const DOCUMENT_TYPE_NODE = 10;
-export const DOCUMENT_FRAGMENT_NODE = 11;
+export const RAW_NODE = -1 satisfies NodeType.RAW_NODE;
+export const ELEMENT_NODE = 1 satisfies NodeType.ELEMENT_NODE;
+export const TEXT_NODE = 3 satisfies NodeType.TEXT_NODE;
+export const COMMENT_NODE = 8 satisfies NodeType.COMMENT_NODE;
+export const DOCUMENT_NODE = 9 satisfies NodeType.DOCUMENT_NODE;
+export const DOCUMENT_TYPE_NODE = 10 satisfies NodeType.DOCUMENT_TYPE_NODE;
+export const DOCUMENT_FRAGMENT_NODE = 11 satisfies NodeType.DOCUMENT_FRAGMENT_NODE;
 
 export const NS_HTML = 'http://www.w3.org/1999/xhtml' as Namespace.HTML;
 export const NS_MATHML = 'http://www.w3.org/1998/Math/MathML' as Namespace.MathML;
diff --git a/packages/@glimmer/util/lib/error.ts b/packages/@glimmer/util/lib/error.ts
new file mode 100644
index 0000000000..910e76885f
--- /dev/null
+++ b/packages/@glimmer/util/lib/error.ts
@@ -0,0 +1,70 @@
+import type { Reactive, UserException as UserExceptionInterface } from '@glimmer/interfaces';
+
+import { isObject } from './collections';
+import { stringifyDebugLabel } from './devmode/description';
+
+export function isUserException(error: Error): error is UserException {
+  return error instanceof UserException;
+}
+
+export function isError(value: unknown): value is Error {
+  return isObject(value) && value instanceof Error;
+}
+
+export class EarlyError extends Error {
+  static reactive(message: string, reactive: Reactive) {
+    return new EarlyError(message, reactive);
+  }
+
+  readonly reactive: Reactive | null;
+
+  constructor(message: string, reactive: Reactive | null = null) {
+    super(fullMessage(message, reactive));
+
+    this.reactive = reactive;
+  }
+}
+
+function fullMessage(message: string, reactive: Reactive | null) {
+  const label = reactive ? stringifyDebugLabel(reactive) : null;
+  if (label && message.includes('%r')) {
+    return message.replace('%r', `(${label})`);
+  } else {
+    return message;
+  }
+}
+
+export class UserException extends Error implements UserExceptionInterface {
+  static from(exception: unknown, defaultMessage: string): UserException {
+    if (isObject(exception) && exception instanceof UserException) {
+      return exception;
+    } else {
+      return new UserException(exception, defaultMessage);
+    }
+  }
+
+  readonly #error: Error | undefined;
+  readonly #exception: unknown;
+
+  private constructor(exception: unknown, defaultMessage: string) {
+    const error = isError(exception) ? exception : undefined;
+    const message = error?.message ?? defaultMessage;
+
+    super(message);
+
+    if (error) {
+      this.#error = error;
+      this.cause = error;
+    } else {
+      this.#error = undefined;
+    }
+  }
+
+  get error(): Error | undefined {
+    return this.#error;
+  }
+
+  get exception(): unknown {
+    return this.#exception;
+  }
+}
diff --git a/packages/@glimmer/util/lib/immediate.ts b/packages/@glimmer/util/lib/immediate.ts
index 692c4337a7..1af55193e5 100644
--- a/packages/@glimmer/util/lib/immediate.ts
+++ b/packages/@glimmer/util/lib/immediate.ts
@@ -1,6 +1,6 @@
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 
-import { debugAssert as assert } from './assert';
+import { assert } from './devmode/assert';
 
 /*
   Encoding notes
@@ -38,30 +38,33 @@ import { debugAssert as assert } from './assert';
   strategy.
 */
 
-export enum ImmediateConstants {
-  MAX_SMI = 2 ** 30 - 1,
-  MIN_SMI = ~MAX_SMI,
-  SIGN_BIT = ~(2 ** 29),
-  MAX_INT = ~SIGN_BIT - 1,
-  MIN_INT = ~MAX_INT,
-
-  FALSE_HANDLE = 0,
-  TRUE_HANDLE = 1,
-  NULL_HANDLE = 2,
-  UNDEFINED_HANDLE = 3,
-
-  ENCODED_FALSE_HANDLE = FALSE_HANDLE,
-  ENCODED_TRUE_HANDLE = TRUE_HANDLE,
-  ENCODED_NULL_HANDLE = NULL_HANDLE,
-  ENCODED_UNDEFINED_HANDLE = UNDEFINED_HANDLE,
-}
+export const MAX_SMI = 2 ** 30 - 1;
+export const MIN_SMI = ~MAX_SMI;
+const SIGN_BIT = ~(2 ** 29);
+export const MAX_INT = ~SIGN_BIT - 1;
+export const MIN_INT = ~MAX_INT;
+
+export const FALSE_HANDLE = 0;
+export const TRUE_HANDLE = 1;
+export const NULL_HANDLE = 2;
+export const UNDEFINED_HANDLE = 3;
+
+// @premerge do we need these?
+// eslint-disable-next-line unused-imports/no-unused-vars
+const ENCODED_FALSE_HANDLE = FALSE_HANDLE;
+// eslint-disable-next-line unused-imports/no-unused-vars
+const ENCODED_TRUE_HANDLE = TRUE_HANDLE;
+// eslint-disable-next-line unused-imports/no-unused-vars
+const ENCODED_NULL_HANDLE = NULL_HANDLE;
+
+const ENCODED_UNDEFINED_HANDLE = UNDEFINED_HANDLE;
 
 export function isHandle(value: number) {
   return value >= 0;
 }
 
 export function isNonPrimitiveHandle(value: number) {
-  return value > ImmediateConstants.ENCODED_UNDEFINED_HANDLE;
+  return value > ENCODED_UNDEFINED_HANDLE;
 }
 
 export function constants(...values: unknown[]): unknown[] {
@@ -69,39 +72,28 @@ export function constants(...values: unknown[]): unknown[] {
 }
 
 export function isSmallInt(value: number) {
-  return (
-    value % 1 === 0 && value <= ImmediateConstants.MAX_INT && value >= ImmediateConstants.MIN_INT
-  );
+  return value % 1 === 0 && value <= MAX_INT && value >= MIN_INT;
 }
 
 export function encodeNegative(num: number) {
   if (LOCAL_DEBUG) {
-    assert(
-      num % 1 === 0 && num >= ImmediateConstants.MIN_INT && num < 0,
-      `Could not encode negative: ${num}`
-    );
+    assert(num % 1 === 0 && num >= MIN_INT && num < 0, `Could not encode negative: ${num}`);
   }
 
-  return num & ImmediateConstants.SIGN_BIT;
+  return num & SIGN_BIT;
 }
 
 export function decodeNegative(num: number) {
   if (LOCAL_DEBUG) {
-    assert(
-      num % 1 === 0 && num < ~ImmediateConstants.MAX_INT && num >= ImmediateConstants.MIN_SMI,
-      `Could not decode negative: ${num}`
-    );
+    assert(num % 1 === 0 && num < ~MAX_INT && num >= MIN_SMI, `Could not decode negative: ${num}`);
   }
 
-  return num | ~ImmediateConstants.SIGN_BIT;
+  return num | ~SIGN_BIT;
 }
 
 export function encodePositive(num: number) {
   if (LOCAL_DEBUG) {
-    assert(
-      num % 1 === 0 && num >= 0 && num <= ImmediateConstants.MAX_INT,
-      `Could not encode positive: ${num}`
-    );
+    assert(num % 1 === 0 && num >= 0 && num <= MAX_INT, `Could not encode positive: ${num}`);
   }
 
   return ~num;
@@ -109,21 +101,23 @@ export function encodePositive(num: number) {
 
 export function decodePositive(num: number) {
   if (LOCAL_DEBUG) {
-    assert(
-      num % 1 === 0 && num <= 0 && num >= ~ImmediateConstants.MAX_INT,
-      `Could not decode positive: ${num}`
-    );
+    assert(num % 1 === 0 && num <= 0 && num >= ~MAX_INT, `Could not decode positive: ${num}`);
   }
 
   return ~num;
 }
 
+export function encodeBoolean(bool: boolean): number {
+  return (bool as never) | 0;
+}
+
+export function decodeBoolean(num: number): boolean {
+  return !!num;
+}
+
 export function encodeHandle(num: number) {
   if (LOCAL_DEBUG) {
-    assert(
-      num % 1 === 0 && num >= 0 && num <= ImmediateConstants.MAX_SMI,
-      `Could not encode handle: ${num}`
-    );
+    assert(num % 1 === 0 && num >= 0 && num <= MAX_SMI, `Could not encode handle: ${num}`);
   }
 
   return num;
@@ -131,10 +125,7 @@ export function encodeHandle(num: number) {
 
 export function decodeHandle(num: number) {
   if (LOCAL_DEBUG) {
-    assert(
-      num % 1 === 0 && num <= ImmediateConstants.MAX_SMI && num >= 0,
-      `Could not decode handle: ${num}`
-    );
+    assert(num % 1 === 0 && num <= MAX_SMI && num >= 0, `Could not decode handle: ${num}`);
   }
 
   return num;
@@ -147,7 +138,7 @@ export function encodeImmediate(num: number) {
 
 export function decodeImmediate(num: number) {
   num |= 0;
-  return num > ImmediateConstants.SIGN_BIT ? decodePositive(num) : decodeNegative(num);
+  return num > SIGN_BIT ? decodePositive(num) : decodeNegative(num);
 }
 
 // Warm
diff --git a/packages/@glimmer/util/lib/index.ts b/packages/@glimmer/util/lib/index.ts
new file mode 100644
index 0000000000..133698204f
--- /dev/null
+++ b/packages/@glimmer/util/lib/index.ts
@@ -0,0 +1,47 @@
+import type { NodeType } from '@glimmer/interfaces';
+
+export * from './array-utils';
+export * from './collections';
+export * from './constants';
+export { beginTestSteps, endTestSteps, logStep, verifySteps } from './debug-steps';
+export { default as debugToString } from './debug-to-string';
+export * from './devmode/assert';
+export * from './devmode/description';
+export * from './devmode/logging';
+export * from './dom';
+export * from './dom-utils';
+export * from './error';
+export * from './immediate';
+export { default as intern } from './intern';
+export {
+  isSerializationFirstNode,
+  SERIALIZATION_FIRST_NODE_STRING,
+} from './is-serialization-first-node';
+export { array, assign, entries, fillNulls, type FixedArray, values } from './object-utils';
+export * from './platform-utils';
+export * from './present';
+export * from './result';
+export {
+  castToBrowser,
+  castToSimple,
+  checkBrowserNode as checkNode,
+  isElement,
+  isSimpleElement,
+} from './simple-cast';
+export * from './stack';
+export * from './string';
+export * from './template';
+export * from './types';
+export { default as buildUntouchableThis } from './untouchable-this';
+
+export type FIXME<T, S extends string> = (T & S) | T;
+
+export const NODE_TYPE = {
+  ELEMENT: 1 as NodeType.ELEMENT_NODE,
+  RAW: -1 as NodeType.RAW_NODE,
+  TEXT: 3 as NodeType.TEXT_NODE,
+  COMMENT: 8 as NodeType.COMMENT_NODE,
+  DOCUMENT: 9 as NodeType.DOCUMENT_NODE,
+  DOCUMENT_TYPE: 10 as NodeType.DOCUMENT_TYPE_NODE,
+  DOCUMENT_FRAGMENT: 11 as NodeType.DOCUMENT_FRAGMENT_NODE,
+} as const;
diff --git a/packages/@glimmer/util/lib/object-utils.ts b/packages/@glimmer/util/lib/object-utils.ts
index 3a1bc08b12..56009f3bc2 100644
--- a/packages/@glimmer/util/lib/object-utils.ts
+++ b/packages/@glimmer/util/lib/object-utils.ts
@@ -1,15 +1,35 @@
+import type { Dict, Expand } from '@glimmer/interfaces';
+
 export let assign = Object.assign;
 
-export function fillNulls<T>(count: number): T[] {
+export function fillNulls<T, A = T[]>(count: number): A {
   let arr = new Array(count);
 
   for (let i = 0; i < count; i++) {
     arr[i] = null;
   }
 
-  return arr;
+  return arr as A;
+}
+
+export function array<T>(): {
+  allocate: <N extends number>(size: N) => Expand<FixedArray<T | null, N>>;
+} {
+  return {
+    allocate: <N extends number>(size: N) => fillNulls<T, Expand<FixedArray<T, N>>>(size),
+  };
 }
 
+type Grow<T, A extends Array<T>> = ((x: T, ...xs: A) => void) extends (...a: infer X) => void
+  ? X
+  : never;
+type GrowToSize<T, A extends Array<T>, N extends number> = {
+  0: A;
+  1: GrowToSize<T, Grow<T, A>, N>;
+}[A['length'] extends N ? 0 : 1];
+
+export type FixedArray<T, N extends number> = GrowToSize<T, [], N>;
+
 export function values<T>(obj: { [s: string]: T }): T[] {
   return Object.values(obj);
 }
@@ -19,3 +39,7 @@ export type ObjectEntry<D extends object> = { [P in keyof D]: [P, D[P]] }[keyof
 export function entries<D extends object>(dict: D): ObjectEntry<D>[] {
   return Object.entries(dict) as ObjectEntry<D>[];
 }
+
+export function mapDict<T, U>(dict: Dict<T>, mapper: (value: T) => U): Dict<U> {
+  return Object.fromEntries(entries(dict).map(([k, v]) => [k, mapper(v)])) as Dict<U>;
+}
diff --git a/packages/@glimmer/util/lib/platform-utils.ts b/packages/@glimmer/util/lib/platform-utils.ts
index 289643b6d2..2e0d3d8233 100644
--- a/packages/@glimmer/util/lib/platform-utils.ts
+++ b/packages/@glimmer/util/lib/platform-utils.ts
@@ -1,29 +1,28 @@
-import type { Maybe, Present } from '@glimmer/interfaces';
-
 export type Factory<T> = new (...args: unknown[]) => T;
 
 export function keys<T extends object>(obj: T): Array<keyof T> {
   return Object.keys(obj) as Array<keyof T>;
 }
 
-export function unwrap<T>(val: Maybe<T>): T {
-  if (val === null || val === undefined) throw new Error(`Expected value to be present`);
-  return val as T;
-}
-
-export function expect<T>(val: T, message: string): Present<T> {
-  if (val === null || val === undefined) throw new Error(message);
-  return val as Present<T>;
-}
+export function unreachable(message?: string): never {
+  if (import.meta.env.DEV) {
+    throw new Error(message ?? 'unreachable');
+  }
 
-export function unreachable(message = 'unreachable'): Error {
-  return new Error(message);
+  Never();
 }
 
 export function exhausted(value: never): never {
-  throw new Error(`Exhausted ${String(value)}`);
-}
+  if (import.meta.env.DEV) {
+    throw new Error(`Exhausted ${String(value)}`);
+  }
 
-export type Lit = string | number | boolean | undefined | null | void | {};
+  Never();
+}
 
-export const tuple = <T extends Lit[]>(...args: T) => args;
+/**
+ * https://tiny.katz.zone/EhdPZQ
+ */
+export function Never(): never {
+  return undefined as never;
+}
diff --git a/packages/@glimmer/util/lib/result.ts b/packages/@glimmer/util/lib/result.ts
new file mode 100644
index 0000000000..6ffd60bf5c
--- /dev/null
+++ b/packages/@glimmer/util/lib/result.ts
@@ -0,0 +1,58 @@
+import type { Result } from '@glimmer/interfaces';
+
+export function Ok<const T>(value: T): Result<T, never> {
+  return { type: 'ok', value };
+}
+
+export function Err<E>(value: E): Result<never, E> {
+  return { type: 'err', value };
+}
+
+export function Results<const T extends readonly Result<unknown>[]>(
+  results: T
+): Result<Results<T>> {
+  const values = [];
+
+  for (const result of results) {
+    if (result.type === 'err') {
+      return result;
+    }
+
+    values.push(result.value);
+  }
+
+  return { type: 'ok', value: values as Results<T> };
+}
+
+export function chainResult<const T, const U, const E>(
+  value: Result<T, E>,
+  mapper: (value: T) => Result<U, E>
+): Result<U, E> {
+  return value.type === 'ok' ? mapper(value.value) : value;
+}
+
+export function flattenResult<T>(value: Result<Result<T>>): Result<T> {
+  return value.type === 'ok' ? value.value : value;
+}
+
+export function mapResult<T, E, U>(value: Result<T, E>, mapper: (value: T) => U): Result<U, E> {
+  if (value.type === 'ok') {
+    return { type: 'ok', value: mapper(value.value) };
+  } else {
+    return value;
+  }
+}
+
+// @audit almost all uses of these outside of tests aren't correct
+export function unwrapResult<T>(value: Result<T>): T {
+  switch (value.type) {
+    case 'err':
+      throw value.value;
+    case 'ok':
+      return value.value;
+  }
+}
+
+type Results<T extends readonly Result<unknown>[]> = {
+  [P in keyof T]: T[P] extends Result<infer U> ? U : never;
+};
diff --git a/packages/@glimmer/util/lib/simple-cast.ts b/packages/@glimmer/util/lib/simple-cast.ts
index 948cfa9570..b0759f279f 100644
--- a/packages/@glimmer/util/lib/simple-cast.ts
+++ b/packages/@glimmer/util/lib/simple-cast.ts
@@ -1,4 +1,10 @@
-import type { Maybe, SimpleDocument, SimpleElement, SimpleNode } from '@glimmer/interfaces';
+import type {
+  Maybe,
+  Nullable,
+  SimpleDocument,
+  SimpleElement,
+  SimpleNode,
+} from '@glimmer/interfaces';
 
 import { DOCUMENT_NODE, ELEMENT_NODE } from './dom-utils';
 import { unreachable } from './platform-utils';
@@ -34,11 +40,16 @@ type NodeForSugaryCheck<S extends SugaryNodeCheck<BrowserTag>> = S extends NodeC
 type BrowserNode = Element | Document | DocumentFragment | Text | Comment | Node;
 
 export function castToSimple(doc: Document | SimpleDocument): SimpleDocument;
+export function castToSimple(doc: Nullable<Document | SimpleDocument>): Nullable<SimpleDocument>;
 export function castToSimple(elem: Element | SimpleElement): SimpleElement;
+export function castToSimple(elem: Nullable<Element | SimpleElement>): Nullable<SimpleElement>;
 export function castToSimple(node: Node | SimpleNode): SimpleNode;
+export function castToSimple(node: Nullable<Node | SimpleNode>): Nullable<SimpleNode>;
 export function castToSimple(
-  node: Document | Element | Node | SimpleDocument | SimpleElement | SimpleNode
+  node: Nullable<Document | Element | Node | SimpleDocument | SimpleElement | SimpleNode>
 ) {
+  if (node === null) return null;
+
   if (isDocument(node)) {
     return node as SimpleDocument;
   } else if (isSimpleElement(node)) {
@@ -74,7 +85,7 @@ export function castToBrowser<S extends SugaryNodeCheck>(
     return null;
   }
 
-  if (typeof document === undefined) {
+  if (typeof document === 'undefined') {
     throw new Error('Attempted to cast to a browser node in a non-browser context');
   }
 
diff --git a/packages/@glimmer/util/lib/stack.ts b/packages/@glimmer/util/lib/stack.ts
new file mode 100644
index 0000000000..8525c0b5ef
--- /dev/null
+++ b/packages/@glimmer/util/lib/stack.ts
@@ -0,0 +1,215 @@
+import type {
+  DebugParentStackFrame,
+  LeafStackAspect,
+  Nullable,
+  Stack as StackInterface,
+  VmStackAspect,
+} from '@glimmer/interfaces';
+
+import { enumerate } from './array-utils';
+import { assert, unwrap } from './devmode/assert';
+import { LOCAL_LOGGER } from './devmode/logging';
+import { entries, mapDict } from './object-utils';
+
+abstract class AbstractStack<
+    T extends unknown[],
+    Pop extends Nullable<T[number]>,
+    Current extends Nullable<T[number]>,
+  >
+  implements Stack<T[number]>, Iterable<T[number]>, VmStackAspect
+{
+  readonly #stack: T;
+  readonly #parent: Nullable<this>;
+  declare label?: string | undefined;
+
+  protected constructor(
+    stack: T,
+    parent: Nullable<AbstractStack<T, Pop, Current>>,
+    label?: string | undefined
+  ) {
+    this.#stack = stack;
+    this.#parent = parent as Nullable<this>;
+
+    if (import.meta.env.DEV) {
+      this.label = label;
+    }
+  }
+
+  get debug(): { frames: LeafStackAspect[] } {
+    const parentFrames = this.#parent?.debug.frames ?? [];
+
+    return {
+      frames: [...parentFrames, { label: this.label ?? 'stack', values: this.#stack }],
+    };
+  }
+
+  *[Symbol.iterator](): IterableIterator<T[number]> {
+    yield* this.#stack;
+  }
+
+  get current(): Current {
+    if (this.#stack.length === 0 && this.#parent) {
+      return this.#parent.current;
+    }
+
+    return (this.#stack.at(-1) ?? null) as Current;
+  }
+
+  get size(): T['length'] {
+    return this.#stack.length + (this.#parent ? this.#parent.size : 0);
+  }
+
+  protected get hasParent(): boolean {
+    return !!this.#parent;
+  }
+
+  protected get frameHasItems(): boolean {
+    return this.#stack.length > 0;
+  }
+
+  protected abstract child(): this;
+
+  begin(): this {
+    return this.child();
+  }
+
+  catch(): this {
+    assert(this.#parent, `${this.label ?? 'Stack'}: Expected a parent frame in unwind`);
+    return this.#parent;
+  }
+
+  finally(): this {
+    assert(
+      this.#stack.length === 0,
+      `${this.label ?? 'Stack'}: Expected an empty frame in finally `
+    );
+    assert(this.#parent, `${this.label ?? 'Stack'}: Expected a parent frame in finally`);
+
+    return this.#parent;
+  }
+
+  push(item: T[number]): void {
+    this.#stack.push(item);
+  }
+
+  pop(): Pop {
+    assert(
+      // this is annoying but we need to write it this way to get good errors and get `asserts
+      // condition` to work correctly.
+      !(!this.frameHasItems && this.#parent),
+      `BUG: Unbalanced frame in ${
+        this.label ?? 'stack'
+      }: attempted to pop an item but no item was pushed. Call unwind() or finally() first`
+    );
+
+    assert(
+      this.frameHasItems,
+      `BUG: Unbalanced ${this.label ?? 'stack'}: attempted to pop an item but no item was pushed`
+    );
+    return (this.#stack.pop() ?? null) as Pop;
+  }
+
+  nth(from: number): Current {
+    assert(from < this.size, `Index ${from} is out of bounds`);
+
+    if (from < this.#stack.length) {
+      return this.#stack.at(-from - 1) as Current;
+    } else if (this.#parent) {
+      return this.#parent.nth(from - this.#stack.length);
+    } else {
+      return null as Current;
+    }
+  }
+
+  toArray(): T {
+    const prefix = this.#parent ? [...this.#parent.toArray()] : [];
+    return [...prefix, ...this.#stack] as T;
+  }
+}
+
+export class StackImpl<T> extends AbstractStack<T[], Nullable<T>, Nullable<T>> {
+  static empty<T>(label?: string | undefined): Stack<T> {
+    return new StackImpl([], null, label) as Stack<T>;
+  }
+
+  protected override child(): this {
+    return new StackImpl([], this, this.label) as this;
+  }
+}
+
+/**
+ * A balanced stack is allowed to be empty, but it should never be popped unless there's something
+ * in it.
+ */
+
+export class BalancedStack<T> extends AbstractStack<T[], T, Nullable<T>> implements Stack<T> {
+  static empty<T>(label?: string | undefined): BalancedStack<T> {
+    return import.meta.env.DEV
+      ? new BalancedStack([], null, label ?? 'balanced stack')
+      : new BalancedStack([], null);
+  }
+
+  static initial<T>(value: T, label?: string | undefined): BalancedStack<T> {
+    return import.meta.env.DEV
+      ? new BalancedStack([value], null, label)
+      : new BalancedStack([value], null);
+  }
+
+  child(): this {
+    return new BalancedStack([], this, this.label) as this;
+  }
+
+  get present(): T {
+    assert(this.current, `BUG: Expected an item in the ${this.label ?? 'stack'}`);
+    return this.current;
+  }
+}
+
+export class PresentStack<T> extends AbstractStack<[T, ...T[]], T, T> {
+  static initial<T>(value: T, label?: string | undefined): PresentStack<T> {
+    return import.meta.env.DEV
+      ? new PresentStack([value], null, label ?? 'present stack')
+      : new PresentStack([value], null);
+  }
+
+  child(): this {
+    return new PresentStack([] as any, this, this.label) as this;
+  }
+
+  override pop(): T {
+    try {
+      return super.pop();
+    } finally {
+      assert(
+        super.size > 0,
+        `BUG: You should never pop the last item from a ${this.label ?? 'PresentStack'}`
+      );
+    }
+  }
+}
+
+export type Stack<T> = StackInterface<T>;
+export const Stack = StackImpl;
+
+export function parentDebugFrames(label: string, aspects: Record<string, VmStackAspect>) {
+  const record = mapDict(aspects, (v) => unwrap(v.debug).frames);
+
+  const frames: DebugParentStackFrame[] = [];
+
+  for (const [i, [k, aspectFrames]] of enumerate(entries(record))) {
+    if (i >= frames.length) {
+      frames.push({ label, aspects: {} });
+    }
+
+    const frame = unwrap(frames[i]);
+    const aspectFrame = aspectFrames[i];
+
+    if (aspectFrame) {
+      frame.aspects[k] = aspectFrame;
+    } else {
+      LOCAL_LOGGER.warn(`didn't find frames for ${k}`);
+    }
+  }
+
+  return { label, frames: frames };
+}
diff --git a/packages/@glimmer/util/lib/types.ts b/packages/@glimmer/util/lib/types.ts
new file mode 100644
index 0000000000..7c015ba698
--- /dev/null
+++ b/packages/@glimmer/util/lib/types.ts
@@ -0,0 +1 @@
+export type AnyFunction = (...args: any[]) => any;
diff --git a/packages/@glimmer/util/package.json b/packages/@glimmer/util/package.json
index 0df1c48df7..cb2d952b8d 100644
--- a/packages/@glimmer/util/package.json
+++ b/packages/@glimmer/util/package.json
@@ -1,5 +1,6 @@
 {
   "name": "@glimmer/util",
+  "type": "module",
   "version": "0.85.3",
   "description": "Common utilities used in Glimmer",
   "repository": "https://github.com/tildeio/glimmer/tree/master/packages/@glimmer/util",
@@ -10,11 +11,17 @@
   },
   "devDependencies": {
     "@glimmer/local-debug-flags": "workspace:^",
-    "@types/qunit": "^2.19.7",
+    "@types/qunit": "workspace:^",
     "@glimmer-workspace/build-support": "workspace:^"
   },
-  "main": "index.ts",
-  "types": "index.ts",
+  "main": "lib/index.ts",
+  "types": "lib/index.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.ts",
+      "default": "./lib/index.ts"
+    }
+  },
   "publishConfig": {
     "access": "public",
     "main": "dist/index.js",
@@ -25,6 +32,9 @@
       "default": "./dist/index.js"
     }
   },
+  "files": [
+    "dist"
+  ],
   "scripts": {
     "test:lint": "eslint .",
     "test:types": "tsc --noEmit -p ../tsconfig.json",
diff --git a/packages/@glimmer/util/test/debug-to-string-test.ts b/packages/@glimmer/util/test/debug-to-string-test.ts
index 767f6d157f..2c985dace4 100644
--- a/packages/@glimmer/util/test/debug-to-string-test.ts
+++ b/packages/@glimmer/util/test/debug-to-string-test.ts
@@ -11,44 +11,44 @@ if (import.meta.env.DEV) {
   QUnit.test('[debugToString] should be an function in debug mode', (assert) => {
     assert.deepEqual(typeof maybeDebugToString, 'function');
   });
-  QUnit.test('should return debug name for named [function]', function (assert) {
+  QUnit.test('should return debug name for named [function]', (assert) => {
     function foo() {}
     assert.deepEqual(debugToString(foo), 'foo');
   });
-  QUnit.test('should return debug name for arrow [function]', function (assert) {
+  QUnit.test('should return debug name for arrow [function]', (assert) => {
     let foo = () => {};
     assert.deepEqual(debugToString(foo), 'foo');
   });
-  QUnit.test('should return debug name for primitive [number]', function (assert) {
+  QUnit.test('should return debug name for primitive [number]', (assert) => {
     assert.deepEqual(debugToString(1), '1');
   });
-  QUnit.test('should return debug name for primitive [undefined]', function (assert) {
+  QUnit.test('should return debug name for primitive [undefined]', (assert) => {
     assert.deepEqual(debugToString(undefined), 'undefined');
   });
-  QUnit.test('should return debug name for primitive [string]', function (assert) {
+  QUnit.test('should return debug name for primitive [string]', (assert) => {
     assert.deepEqual(debugToString('foo'), 'foo');
   });
-  QUnit.test('should return debug name for primitive [null]', function (assert) {
+  QUnit.test('should return debug name for primitive [null]', (assert) => {
     assert.deepEqual(debugToString(null), 'null');
   });
-  QUnit.test('should return debug name for primitive [NaN]', function (assert) {
+  QUnit.test('should return debug name for primitive [NaN]', (assert) => {
     assert.deepEqual(debugToString(NaN), 'NaN');
   });
-  QUnit.test('should return debug name for primitive [Infinity]', function (assert) {
+  QUnit.test('should return debug name for primitive [Infinity]', (assert) => {
     assert.deepEqual(debugToString(Infinity), 'Infinity');
   });
   if (!isIE11) {
-    QUnit.test('should return debug name for primitive [Symbol]', function (assert) {
+    QUnit.test('should return debug name for primitive [Symbol]', (assert) => {
       assert.deepEqual(debugToString(Symbol('Foo')), 'Symbol(Foo)');
     });
   }
-  QUnit.test('should return debug name for object', function (assert) {
+  QUnit.test('should return debug name for object', (assert) => {
     assert.deepEqual(debugToString({}), 'Object');
   });
-  QUnit.test('should return debug name for object with constructor property', function (assert) {
+  QUnit.test('should return debug name for object with constructor property', (assert) => {
     assert.deepEqual(debugToString({ constructor: { modelName: 'bar' } }), '(unknown object)');
   });
-  QUnit.test('should return debug name for object with toString function', function (assert) {
+  QUnit.test('should return debug name for object with toString function', (assert) => {
     assert.deepEqual(
       debugToString({
         toString() {
@@ -58,10 +58,10 @@ if (import.meta.env.DEV) {
       '[Glimmer]'
     );
   });
-  QUnit.test('should return debug name for class', function (assert) {
+  QUnit.test('should return debug name for class', (assert) => {
     assert.deepEqual(debugToString(class Foo {}), 'Foo');
   });
-  QUnit.test('should return debug name for ember-like object #1', function (assert) {
+  QUnit.test('should return debug name for ember-like object #1', (assert) => {
     assert.deepEqual(
       debugToString({
         toString() {
@@ -71,7 +71,7 @@ if (import.meta.env.DEV) {
       '<Object:ember205>'
     );
   });
-  QUnit.test('should return debug name for ember-like object #2', function (assert) {
+  QUnit.test('should return debug name for ember-like object #2', (assert) => {
     assert.deepEqual(
       debugToString({
         toString() {
diff --git a/packages/@glimmer/util/test/immediate-test.ts b/packages/@glimmer/util/test/immediate-test.ts
index 43f6d6e8b2..1502fcfb5a 100644
--- a/packages/@glimmer/util/test/immediate-test.ts
+++ b/packages/@glimmer/util/test/immediate-test.ts
@@ -1,20 +1,39 @@
-import { decodeImmediate, encodeImmediate, ImmediateConstants } from '@glimmer/util';
+import {
+  decodeBoolean,
+  decodeImmediate,
+  encodeBoolean,
+  encodeImmediate,
+  MAX_INT,
+  MAX_SMI,
+  MIN_INT,
+  MIN_SMI,
+} from '@glimmer/util';
 
 const { module, test } = QUnit;
 
 module('immediate encoding tests', () => {
-  test('it works', (assert) => {
-    let cases = [ImmediateConstants.MIN_INT, -1, 0, ImmediateConstants.MAX_INT];
+  test('encode correctly', (assert) => {
+    let cases = [MIN_INT, -1, 0, MAX_INT];
 
     for (const val of cases) {
       let encoded = encodeImmediate(val);
 
       assert.strictEqual(val, decodeImmediate(encoded), 'correctly encoded and decoded');
-      const isSMI = encoded >= ImmediateConstants.MIN_SMI && encoded <= ImmediateConstants.MAX_SMI;
+      const isSMI = encoded >= MIN_SMI && encoded <= MAX_SMI;
       assert.true(isSMI, 'encoded as an SMI');
       assert.step(`testing ${val}`);
     }
 
     assert.verifySteps(cases.map((val) => `testing ${val}`));
   });
+
+  test('encode booleans correctly', (assert) => {
+    let cases = [true, false];
+
+    for (const val of cases) {
+      let encoded = encodeBoolean(val);
+
+      assert.strictEqual(val, decodeBoolean(encoded), 'correctly encoded and decoded');
+    }
+  });
 });
diff --git a/packages/@glimmer/util/test/object-utils-test.ts b/packages/@glimmer/util/test/object-utils-test.ts
index 722f9fb64b..16d1862343 100644
--- a/packages/@glimmer/util/test/object-utils-test.ts
+++ b/packages/@glimmer/util/test/object-utils-test.ts
@@ -2,7 +2,7 @@ import { assign } from '@glimmer/util';
 
 QUnit.module('object-utils tests');
 
-QUnit.test('assign should ignore null/undefined arguments', function (assert) {
+QUnit.test('assign should ignore null/undefined arguments', (assert) => {
   let result = assign({}, { foo: 'bar' }, null, undefined, { derp: 'herk' });
 
   assert.deepEqual(result, { foo: 'bar', derp: 'herk' }, 'has correct result');
diff --git a/packages/@glimmer/util/test/stack-test.ts b/packages/@glimmer/util/test/stack-test.ts
new file mode 100644
index 0000000000..5ecef66784
--- /dev/null
+++ b/packages/@glimmer/util/test/stack-test.ts
@@ -0,0 +1,267 @@
+/* eslint-disable qunit/no-assert-logical-expression */
+import {
+  BalancedStack,
+  enumerate,
+  PresentStack,
+  range,
+  reverse,
+  Stack,
+  times,
+} from '@glimmer/util';
+
+const { module, test } = QUnit;
+
+/**
+ * If the stack starts with a value in it, we use this special sentinel value to make test failures
+ * more comprehensible.
+ */
+const INITIAL = Symbol('initial');
+type INITIAL = typeof INITIAL;
+
+/**
+ * Same as {@linkcode INITIAL}, but for the initial value in a guarded stack.
+ */
+const GUARDED_INITIAL = Symbol('guarded initial');
+type GUARDED_INITIAL = typeof GUARDED_INITIAL;
+
+type TestValue = `value${number}` | INITIAL | GUARDED_INITIAL;
+
+module('@glimmer/util - Stack', () => {
+  module('Stack', () => {
+    StackTests({ create: () => Stack.empty(), initial: [] });
+  });
+
+  module('PresentStack', () => {
+    StackTests({
+      create: () => PresentStack.initial(INITIAL),
+      initial: [INITIAL],
+    }).test(`can't pop the last frame`, ({ assert, stack }) => {
+      assert.throws(
+        () => stack.pop(),
+        `BUG: You should never pop the last frame from a PresentStack`
+      );
+    });
+  });
+
+  module('BalancedStack', () => {
+    StackTests({ create: () => BalancedStack.empty<TestValue>(), initial: [] });
+  });
+});
+
+export {};
+
+interface Define {
+  test: (
+    name: string,
+    fn: (state: {
+      assert: Assert;
+      stack: Stack<TestValue>;
+      assertInitial: (stack: Stack<TestValue>, operation: string) => void;
+    }) => void
+  ) => Define;
+  module: (name: string, callback: (define: Define) => void) => Define;
+}
+
+interface TestSpec {
+  create: () => Stack<TestValue>;
+  initial: TestValue[];
+}
+
+function define({ create, initial }: TestSpec, def?: (define: Define) => void) {
+  const define: Define = {
+    test: (name, fn) => {
+      test(name, (assert) => {
+        const assertInitial = (stack: Stack<TestValue>, operation: string) => {
+          assert.strictEqual(
+            stack.size,
+            initial.length,
+            `after ${operation}, the stack size is the same as the initial stack`
+          );
+          assert.strictEqual(
+            stack.current,
+            initial.at(-1) ?? null,
+            `${operation} changes the current item`
+          );
+          assert.deepEqual(
+            stack.toArray(),
+            initial,
+            `after ${operation}, toArray reflects the initial stack`
+          );
+        };
+
+        return fn({ assert, stack: create(), assertInitial });
+      });
+      return define;
+    },
+    module: (name, callback) => {
+      module(name, () => callback(define));
+      return define;
+    },
+  };
+
+  if (def) def(define);
+  return define;
+}
+
+function UnguardedStackTests(
+  { create, initial }: TestSpec,
+  def?: (define: Define) => void
+): Define {
+  const defined = define({ create, initial }, ({ test }) => {
+    test('initial size', ({ assert, stack }) => {
+      assert.strictEqual(stack.size, initial.length, 'the stack has the right initial size');
+    });
+
+    test('push', ({ assert, stack }) => {
+      pushing((number) => {
+        stack.push(number);
+        assert.strictEqual(stack.size, initial.length + 1, 'pushing increments the size');
+        assert.strictEqual(stack.current, number, 'pushing changes the current item');
+        assert.deepEqual(stack.toArray(), [...initial, number], 'toArray reflects the pushed item');
+      });
+    });
+
+    test('nth', ({ assert, stack }) => {
+      for (const count of range(0, 10)) {
+        pushingN(count, (numbers) => {
+          for (const number of numbers) {
+            stack.push(number);
+          }
+
+          for (const [i, number] of enumerate(reverse(numbers))) {
+            assert.strictEqual(
+              stack.nth(i),
+              number,
+              `nth(${i}) of ${JSON.stringify(numbers)} returns the correct item`
+            );
+          }
+        });
+      }
+    });
+
+    test('pop', ({ stack, assertInitial }) => {
+      pushing((number) => {
+        stack.push(number);
+        stack.pop();
+
+        assertInitial(stack, 'balanced pushes and pops');
+      });
+    });
+  });
+
+  if (def) def(defined);
+  return defined;
+}
+
+function StackTests({ create, initial }: TestSpec) {
+  return UnguardedStackTests({ create, initial }, ({ module }) => {
+    module('frames', ({ module }) => {
+      module('guard', ({ test }) => {
+        test('nth can go past the beginning of the transaction', ({
+          stack,
+          assert,
+          assertInitial,
+        }) => {
+          pushing((value) => {
+            stack.push(value);
+            stack = stack.begin();
+            assert.strictEqual(stack.nth(0), value, 'nth(0) returns the correct value');
+
+            pushing((value2) => {
+              stack.push(value2);
+              assert.strictEqual(
+                stack.nth(1),
+                value,
+                'nth(1) returns the value pushed before the transaction'
+              );
+              assert.strictEqual(
+                stack.nth(0),
+                value2,
+                'nth(0) returns the value pushed after the transaction'
+              );
+
+              stack.pop();
+              assert.strictEqual(
+                stack.nth(0),
+                value,
+                'after popping, nth(0) returns the value pushed before the transaction'
+              );
+            });
+
+            stack = stack.finally();
+
+            assert.strictEqual(
+              stack.nth(0),
+              value,
+              'after finally, nth(0) returns the value pushed before the transaction'
+            );
+
+            stack.pop();
+            assertInitial(stack, 'after a transaction');
+          });
+        });
+
+        UnguardedStackTests(
+          {
+            create: () => {
+              const stack = create().begin();
+              return stack;
+            },
+            initial,
+          },
+          ({ test }) => {
+            test('finally', ({ stack, assertInitial }) => {
+              pushing((number) => {
+                stack.push(number);
+                stack.pop();
+                stack = stack.finally();
+                assertInitial(stack, 'calling finally() on an empty guarded frame');
+              });
+            });
+
+            test('unwind', ({ stack, assertInitial }) => {
+              pushing((number) => {
+                stack.push(number);
+                stack = stack.catch();
+                assertInitial(stack, 'calling unwind() on a frame with items in it');
+              });
+            });
+
+            test(`can't call finally when the current treansaction is non-empty`, ({
+              assert,
+              stack,
+            }) => {
+              pushing((number) => {
+                stack.push(number);
+                assert.throws(() => stack.finally(), `Expected an empty frame in finally`);
+              });
+            });
+
+            test(`can't pop from a transaction when it's empty`, ({ assert, stack }) => {
+              assert.throws(
+                () => stack.pop(),
+                'BUG: Unbalanced stack: attempted to pop an item but no item was pushed'
+              );
+            });
+          }
+        );
+      });
+    });
+  });
+}
+
+let stringId = 0;
+
+function pushing<T>(callback: (value: TestValue) => T): T {
+  return callback(`value${stringId++}`);
+}
+
+function pushingN<N extends number, T>(count: N, callback: (values: TestValue[]) => T): T {
+  const values: TestValue[] = [];
+
+  for (const _ of times(count)) {
+    values.push(`value${stringId++}`);
+  }
+
+  return callback(values);
+}
diff --git a/packages/@glimmer/validator/index.ts b/packages/@glimmer/validator/index.ts
index 9150fb7b21..22d1164cd4 100644
--- a/packages/@glimmer/validator/index.ts
+++ b/packages/@glimmer/validator/index.ts
@@ -33,18 +33,24 @@ export {
 export {
   ALLOW_CYCLES,
   bump,
+  COMBINATOR_TAG_ID,
   combine,
   COMPUTE,
   CONSTANT,
   CONSTANT_TAG,
+  CONSTANT_TAG_ID,
   createTag,
   createUpdatableTag,
   CURRENT_TAG,
   CurrentTag,
   DIRTY_TAG as dirtyTag,
+  DIRYTABLE_TAG_ID,
   INITIAL,
+  INVALID_REVISION,
   isConstTag,
   type Revision,
+  TAG_TYPE,
+  UPDATABLE_TAG_ID,
   UPDATE_TAG as updateTag,
   validateTag,
   valueForTag,
@@ -52,4 +58,11 @@ export {
   VOLATILE_TAG,
   VolatileTag,
 } from './lib/validators';
-export type { CombinatorTag, ConstantTag, DirtyableTag, Tag, UpdatableTag } from "@glimmer/interfaces";
+export type {
+  CombinatorTag,
+  ConstantTag,
+  DirtyableTag,
+  SomeTag,
+  Tag,
+  UpdatableTag,
+} from '@glimmer/interfaces';
diff --git a/packages/@glimmer/validator/lib/debug.ts b/packages/@glimmer/validator/lib/debug.ts
index 5b4a207c70..8151429723 100644
--- a/packages/@glimmer/validator/lib/debug.ts
+++ b/packages/@glimmer/validator/lib/debug.ts
@@ -1,13 +1,13 @@
+import type { Description, DevMode, Tag } from '@glimmer/interfaces';
 import { assert } from '@glimmer/global-context';
-import type { Tag } from "@glimmer/interfaces";
-import { asPresentArray, getLast } from '@glimmer/util';
+import { asPresentArray, devmode, getLast, inDevmode, stringifyDebugLabel } from '@glimmer/util';
 
 interface DebugTransaction {
   beginTrackingTransaction?:
     | undefined
-    | ((debuggingContext?: string | false, deprecate?: boolean) => void);
+    | ((debuggingContext: Description, deprecate?: boolean) => void);
   endTrackingTransaction?: undefined | (() => void);
-  runInTrackingTransaction?: undefined | (<T>(fn: () => T, debuggingContext?: string | false) => T);
+  runInTrackingTransaction?: undefined | (<T>(fn: () => T, debuggingContext?: Description) => T);
 
   resetTrackingTransaction?: undefined | (() => string);
   setTrackingTransactionEnv?:
@@ -25,8 +25,8 @@ interface DebugTransaction {
 export const debug: DebugTransaction = {};
 
 interface Transaction {
-  parent: Transaction | null;
-  debugLabel?: string | undefined;
+  readonly parent: Transaction | null;
+  readonly description: DevMode<Description>;
 }
 
 if (import.meta.env.DEV) {
@@ -60,16 +60,14 @@ if (import.meta.env.DEV) {
 
   debug.setTrackingTransactionEnv = (env) => Object.assign(TRANSACTION_ENV, env);
 
-  debug.beginTrackingTransaction = (_debugLabel?: string | false) => {
+  debug.beginTrackingTransaction = (description: Description) => {
     CONSUMED_TAGS = CONSUMED_TAGS || new WeakMap();
 
-    let debugLabel = _debugLabel || undefined;
-
     let parent = TRANSACTION_STACK[TRANSACTION_STACK.length - 1] ?? null;
 
     TRANSACTION_STACK.push({
       parent,
-      debugLabel,
+      description: devmode(() => description),
     });
   };
 
@@ -108,8 +106,11 @@ if (import.meta.env.DEV) {
    *
    * TODO: Only throw an error if the `track` is consumed.
    */
-  debug.runInTrackingTransaction = <T>(fn: () => T, debugLabel?: string | false) => {
-    debug.beginTrackingTransaction!(debugLabel);
+  debug.runInTrackingTransaction = <T>(
+    fn: () => T,
+    description: Description = { reason: 'tracking', label: ['(tracking)'] }
+  ) => {
+    debug.beginTrackingTransaction!(description);
     let didError = true;
 
     try {
@@ -164,15 +165,14 @@ if (import.meta.env.DEV) {
     if (current === undefined) return '';
 
     while (current) {
-      if (current.debugLabel) {
-        trackingStack.unshift(current.debugLabel);
-      }
-
+      trackingStack.unshift(current);
       current = current.parent;
     }
 
     // TODO: Use String.prototype.repeat here once we can drop support for IE11
-    return trackingStack.map((label, index) => Array(2 * index + 1).join(' ') + label).join('\n');
+    return trackingStack
+      .map((label, index) => ' '.repeat(2 * index + 1) + inDevmode(stringifyDebugLabel(label)))
+      .join('\n');
   };
 
   debug.markTagAsConsumed = (_tag: Tag) => {
@@ -213,6 +213,7 @@ if (import.meta.env.DEV) {
         if (updateStackBegin !== -1) {
           let start = nthIndex(e.stack, '\n', 1, updateStackBegin);
           let end = nthIndex(e.stack, '\n', 4, updateStackBegin);
+          // eslint-disable-next-line deprecation/deprecation
           e.stack = e.stack.substr(0, start) + e.stack.substr(end);
         }
       }
diff --git a/packages/@glimmer/validator/lib/meta.ts b/packages/@glimmer/validator/lib/meta.ts
index 1388d2c9bb..862bb0ec11 100644
--- a/packages/@glimmer/validator/lib/meta.ts
+++ b/packages/@glimmer/validator/lib/meta.ts
@@ -1,7 +1,10 @@
-import type { ConstantTag, UpdatableTag } from "@glimmer/interfaces";
+import type { ConstantTag, Optional, TagDescription, UpdatableTag } from '@glimmer/interfaces';
+import { devmode } from '@glimmer/util';
+
+import type {Indexable} from './utils';
 
 import { debug } from './debug';
-import { type Indexable, unwrap } from './utils';
+import {  unwrap } from './utils';
 import { createUpdatableTag, DIRTY_TAG } from './validators';
 
 function isObjectLike<T>(u: T): u is Indexable & T {
@@ -55,13 +58,21 @@ export function tagMetaFor(obj: object): TagMeta {
 export function tagFor<T extends object>(
   obj: T,
   key: keyof T | string | symbol,
-  meta?: TagMeta
+  meta?: Optional<TagMeta>
 ): UpdatableTag | ConstantTag {
   let tags = meta === undefined ? tagMetaFor(obj) : meta;
   let tag = tags.get(key);
 
   if (tag === undefined) {
-    tag = createUpdatableTag();
+    tag = createUpdatableTag(
+      devmode(
+        () =>
+          ({
+            reason: 'property',
+            label: ['(object)', key as string | symbol],
+          }) satisfies TagDescription
+      )
+    );
     tags.set(key, tag);
   }
 
diff --git a/packages/@glimmer/validator/lib/tracking.ts b/packages/@glimmer/validator/lib/tracking.ts
index b6d9421808..ef42842113 100644
--- a/packages/@glimmer/validator/lib/tracking.ts
+++ b/packages/@glimmer/validator/lib/tracking.ts
@@ -1,22 +1,34 @@
-import type { Tag } from "@glimmer/interfaces";
+import type {
+  DefaultDescriptionFields,
+  Described,
+  Description,
+  DescriptionSpec,
+  DevMode,
+  Tag,
+  TagDescription,
+  ValidatableDescription,
+} from '@glimmer/interfaces';
+import {
+  devmode,
+  getDescription,
+  inDevmode,
+  setDescription,
+  toValidatableDescription,
+} from '@glimmer/util';
+
+import type { Revision } from './validators';
 
 import { debug } from './debug';
 import { unwrap } from './utils';
-import {
-  combine,
-  CONSTANT_TAG,
-  isConstTag,
-  type Revision,
-  validateTag,
-  valueForTag,
-} from './validators';
+import { combine, CONSTANT_TAG, isConstTag, validateTag, valueForTag } from './validators';
 
 /**
  * An object that that tracks @tracked properties that were consumed.
  */
-class Tracker {
+class Tracker implements Described<Description> {
   private tags = new Set<Tag>();
   private last: Tag | null = null;
+  declare description: DevMode<Description>;
 
   add(tag: Tag) {
     if (tag === CONSTANT_TAG) return;
@@ -35,12 +47,13 @@ class Tracker {
 
     if (tags.size === 0) {
       return CONSTANT_TAG;
-    } else if (tags.size === 1) {
+    } else if (!import.meta.env.DEV && tags.size === 1) {
       return this.last as Tag;
     } else {
       let tagsArr: Tag[] = [];
       tags.forEach((tag) => tagsArr.push(tag));
-      return combine(tagsArr);
+      const tag = combine(tagsArr, this.description);
+      return tag;
     }
   }
 }
@@ -62,13 +75,22 @@ let CURRENT_TRACKER: Tracker | null = null;
 
 const OPEN_TRACK_FRAMES: (Tracker | null)[] = [];
 
-export function beginTrackFrame(debuggingContext?: string | false): void {
+export function beginTrackFrame(
+  context: DevMode<Description> = devmode(
+    () =>
+      ({
+        reason: 'formula',
+        label: ['(tracking frame)'],
+      }) satisfies Description
+  )
+): void {
   OPEN_TRACK_FRAMES.push(CURRENT_TRACKER);
 
   CURRENT_TRACKER = new Tracker();
+  setDescription(CURRENT_TRACKER, context);
 
   if (import.meta.env.DEV) {
-    unwrap(debug.beginTrackingTransaction)(debuggingContext);
+    unwrap(debug.beginTrackingTransaction)(inDevmode(context));
   }
 }
 
@@ -129,7 +151,7 @@ export function consumeTag(tag: Tag): void {
 const CACHE_KEY = Symbol('CACHE_KEY');
 
 // public interface
-export interface Cache<T = unknown> {
+export interface Cache<T = unknown> extends Described<Description> {
   [CACHE_KEY]: T;
 }
 
@@ -139,7 +161,7 @@ const TAG = Symbol('TAG');
 const SNAPSHOT = Symbol('SNAPSHOT');
 const DEBUG_LABEL = Symbol('DEBUG_LABEL');
 
-interface InternalCache<T = unknown> {
+interface InternalCache<T = unknown> extends Described<TagDescription> {
   [FN]: (...args: unknown[]) => T;
   [LAST_VALUE]: T | undefined;
   [TAG]: Tag | undefined;
@@ -147,23 +169,32 @@ interface InternalCache<T = unknown> {
   [DEBUG_LABEL]?: string | false | undefined;
 }
 
-export function createCache<T>(fn: () => T, debuggingLabel?: string | false): Cache<T> {
+const CACHE_DEFAULTS = devmode(
+  () =>
+    ({
+      reason: 'cache',
+      label: ['(cache)'],
+    }) satisfies DefaultDescriptionFields<ValidatableDescription>
+);
+
+export function createCache<T>(fn: () => T, debuggingLabel?: DescriptionSpec): Cache<T> {
   if (import.meta.env.DEV && !(typeof fn === 'function')) {
     throw new Error(
       `createCache() must be passed a function as its first parameter. Called with: ${String(fn)}`
     );
   }
 
-  let cache: InternalCache<T> = {
+  let cache: Omit<InternalCache<T>, 'description'> = {
     [FN]: fn,
     [LAST_VALUE]: undefined,
     [TAG]: undefined,
     [SNAPSHOT]: -1,
   };
 
-  if (import.meta.env.DEV) {
-    cache[DEBUG_LABEL] = debuggingLabel;
-  }
+  setDescription(
+    cache,
+    devmode(() => toValidatableDescription(debuggingLabel, CACHE_DEFAULTS))
+  );
 
   return cache as unknown as Cache<T>;
 }
@@ -176,7 +207,7 @@ export function getValue<T>(cache: Cache<T>): T | undefined {
   let snapshot = cache[SNAPSHOT];
 
   if (tag === undefined || !validateTag(tag, snapshot)) {
-    beginTrackFrame();
+    beginTrackFrame(getDescription(cache));
 
     try {
       cache[LAST_VALUE] = fn();
@@ -235,8 +266,13 @@ function assertTag(tag: Tag | undefined, cache: InternalCache): asserts tag is T
 // refactors are merged, and we should generally be moving away from it. It may
 // be necessary in Ember for a while longer, but I think we'll be able to drop
 // it in favor of cache sooner rather than later.
-export function track(block: () => void, debugLabel?: string | false): Tag {
-  beginTrackFrame(debugLabel);
+export function track(
+  block: () => void,
+  description: DevMode<Description> = devmode(
+    () => ({ reason: 'tracking', label: ['(track)'] }) satisfies Description
+  )
+): Tag {
+  beginTrackFrame(description);
 
   let tag;
 
diff --git a/packages/@glimmer/validator/lib/utils.ts b/packages/@glimmer/validator/lib/utils.ts
index feecdbb8e7..a9037f4f26 100644
--- a/packages/@glimmer/validator/lib/utils.ts
+++ b/packages/@glimmer/validator/lib/utils.ts
@@ -1,3 +1,4 @@
+
 export type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
   k: infer I
 ) => void
@@ -12,7 +13,6 @@ export function indexable<T extends object>(input: T): T & Indexable {
 }
 
 export function getGlobal(): Indexable {
-  // eslint-disable-next-line n/no-unsupported-features/es-builtins
   if (typeof globalThis !== 'undefined') return indexable(globalThis);
   if (typeof self !== 'undefined') return indexable(self);
   if (typeof window !== 'undefined') return indexable(window);
diff --git a/packages/@glimmer/validator/lib/validators.ts b/packages/@glimmer/validator/lib/validators.ts
index 410e7ec41b..b3489ad692 100644
--- a/packages/@glimmer/validator/lib/validators.ts
+++ b/packages/@glimmer/validator/lib/validators.ts
@@ -1,19 +1,31 @@
-import { scheduleRevalidate } from '@glimmer/global-context';
 import type {
   COMBINATOR_TAG_ID as ICOMBINATOR_TAG_ID,
   CONSTANT_TAG_ID as ICONSTANT_TAG_ID,
   ConstantTag,
   CURRENT_TAG_ID as ICURRENT_TAG_ID,
+  Description,
+  DevMode,
   DIRTYABLE_TAG_ID as IDIRTYABLE_TAG_ID,
   DirtyableTag,
   MonomorphicTagId,
   Tag,
   TagComputeSymbol,
+  TagDescription,
+  TagForId,
   TagTypeSymbol,
   UPDATABLE_TAG_ID as IUPDATABLE_TAG_ID,
   UpdatableTag,
   VOLATILE_TAG_ID as IVOLATILE_TAG_ID,
 } from '@glimmer/interfaces';
+import { scheduleRevalidate } from '@glimmer/global-context';
+import {
+  createWithDescription,
+  devmode,
+  expect,
+  inDevmode,
+  mapDevmode,
+  setDescription,
+} from '@glimmer/util';
 
 import { debug } from './debug';
 import { unwrap } from './utils';
@@ -22,6 +34,13 @@ import { unwrap } from './utils';
 
 export type Revision = number;
 
+/**
+ * The INVALID revision is guaranteed to be invalid, even if the tag is CONSTANT. This makes it
+ * possible for a reference to become invalid temporarily and then become valid again.
+ *
+ * It's meant to be used in cached revisions, so there is no `INVALID_TAG`.
+ */
+export const INVALID_REVISION: Revision = -1;
 export const CONSTANT: Revision = 0;
 export const INITIAL: Revision = 1;
 export const VOLATILE: Revision = NaN;
@@ -34,10 +53,14 @@ export function bump(): void {
 
 //////////
 
-const DIRYTABLE_TAG_ID: IDIRTYABLE_TAG_ID = 0;
-const UPDATABLE_TAG_ID: IUPDATABLE_TAG_ID = 1;
-const COMBINATOR_TAG_ID: ICOMBINATOR_TAG_ID = 2;
-const CONSTANT_TAG_ID: ICONSTANT_TAG_ID = 3;
+/** @internal */
+export const DIRYTABLE_TAG_ID: IDIRTYABLE_TAG_ID = 0;
+/** @internal */
+export const UPDATABLE_TAG_ID: IUPDATABLE_TAG_ID = 1;
+/** @internal */
+export const COMBINATOR_TAG_ID: ICOMBINATOR_TAG_ID = 2;
+/** @internal */
+export const CONSTANT_TAG_ID: ICONSTANT_TAG_ID = 3;
 
 //////////
 
@@ -90,17 +113,27 @@ function allowsCycles(tag: Tag): boolean {
   }
 }
 
-class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
-  static combine(this: void, tags: Tag[]): Tag {
+class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> implements Tag {
+  static combine(
+    this: void,
+    tags: Tag[],
+    description: DevMode<Description> = devmode(() => ({ kind: 'tag', label: ['(combine)'] }))
+  ): Tag {
     switch (tags.length) {
       case 0:
         return CONSTANT_TAG;
       case 1:
-        return tags[0] as Tag;
+        if (!import.meta.env.DEV) {
+          return tags[0] as Tag;
+        }
       default: {
-        let tag: MonomorphicTagImpl = new MonomorphicTagImpl(COMBINATOR_TAG_ID);
-        tag.subtag = tags;
-        return tag;
+        let tag: MonomorphicTagImpl = createWithDescription(
+          () => new MonomorphicTagImpl(COMBINATOR_TAG_ID),
+          description
+        );
+
+        updateSubtags(tag, tags);
+        return tag as Tag;
       }
     }
   }
@@ -110,11 +143,13 @@ class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
   private lastValue = INITIAL;
 
   private isUpdating = false;
-  public subtag: Tag | Tag[] | null = null;
+  public subtags: Tag | Tag[] | null = null;
   private subtagBufferCache: Revision | null = null;
 
   [TYPE]: T;
 
+  declare description: DevMode<TagDescription>;
+
   constructor(type: T) {
     this[TYPE] = type;
   }
@@ -133,16 +168,16 @@ class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
       this.lastChecked = $REVISION;
 
       try {
-        let { subtag, revision } = this;
+        let { subtags, revision } = this;
 
-        if (subtag !== null) {
-          if (Array.isArray(subtag)) {
-            for (const tag of subtag) {
+        if (subtags !== null) {
+          if (Array.isArray(subtags)) {
+            for (const tag of subtags) {
               let value = tag[COMPUTE]();
               revision = Math.max(value, revision);
             }
           } else {
-            let subtagValue = subtag[COMPUTE]();
+            let subtagValue = subtags[COMPUTE]();
 
             if (subtagValue === this.subtagBufferCache) {
               revision = Math.max(revision, this.lastValue);
@@ -173,7 +208,7 @@ class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
     let subtag = _subtag as MonomorphicTagImpl;
 
     if (subtag === CONSTANT_TAG) {
-      tag.subtag = null;
+      emptySubtag(tag);
     } else {
       // There are two different possibilities when updating a subtag:
       //
@@ -194,7 +229,7 @@ class MonomorphicTagImpl<T extends MonomorphicTagId = MonomorphicTagId> {
       // parent's previous value. Once the subtag changes for the first time,
       // we clear the cache and everything is finally in sync with the parent.
       tag.subtagBufferCache = subtag[COMPUTE]();
-      tag.subtag = subtag;
+      updateSubtag(tag, subtag);
     }
   }
 
@@ -227,12 +262,97 @@ export const UPDATE_TAG = MonomorphicTagImpl.updateTag;
 
 //////////
 
-export function createTag(): DirtyableTag {
-  return new MonomorphicTagImpl(DIRYTABLE_TAG_ID);
+export function createTag(label?: DevMode<TagDescription>): DirtyableTag {
+  return createTagWithId(
+    DIRYTABLE_TAG_ID,
+    label ??
+      devmode(
+        () =>
+          ({
+            reason: 'cell',
+            label: ['(dirtyable)'],
+          }) satisfies TagDescription
+      )
+  );
+}
+
+export function createUpdatableTag(label?: DevMode<TagDescription>): UpdatableTag {
+  return createTagWithId(
+    UPDATABLE_TAG_ID,
+    label ??
+      devmode(
+        () =>
+          ({
+            reason: 'cell',
+            label: ['(updatable)'],
+          }) satisfies TagDescription
+      )
+  );
+}
+
+function updateSubtag(tag: MonomorphicTagImpl, subtag: Tag) {
+  tag.subtags = subtag;
+
+  setDescription(
+    tag,
+    devmode(() =>
+      mapDevmode(
+        () => tag.description,
+        (desc) =>
+          ({
+            ...desc,
+            subtags: [inDevmode(subtag.description)],
+          }) satisfies TagDescription
+      )
+    )
+  );
+}
+
+function updateSubtags(tag: MonomorphicTagImpl, subtags: Tag[]) {
+  tag.subtags = subtags;
+
+  if (import.meta.env.DEV) {
+    applyComboLabel(tag, subtags);
+  }
+}
+
+function emptySubtag(tag: MonomorphicTagImpl) {
+  tag.subtags = null;
+
+  if (import.meta.env.DEV) {
+    delete inDevmode(tag.description).subtags;
+  }
 }
 
-export function createUpdatableTag(): UpdatableTag {
-  return new MonomorphicTagImpl(UPDATABLE_TAG_ID);
+function createTagWithId<Id extends MonomorphicTagId>(
+  id: Id,
+  label: DevMode<TagDescription>
+): TagForId<Id> {
+  expect(label, `Expected a tag description`);
+
+  if (import.meta.env.DEV && label) {
+    const tag = new MonomorphicTagImpl(id);
+    setDescription(tag, label);
+    return tag as unknown as TagForId<Id>;
+  } else {
+    return new MonomorphicTagImpl(id) as unknown as TagForId<Id>;
+  }
+}
+
+/**
+ * @category devmode
+ */
+function applyComboLabel(parent: MonomorphicTagImpl, tags: Tag | Tag[]) {
+  const debug = inDevmode(parent.description);
+
+  if (Array.isArray(tags)) {
+    parent.description = devmode(() => ({
+      ...debug,
+      subtags: tags.map((tag) => inDevmode(tag.description)),
+    }));
+  } else {
+    parent.description = devmode(() => ({ ...debug, subtags: [inDevmode(tags.description)] }));
+  }
 }
 
 //////////
@@ -248,6 +368,8 @@ export function isConstTag(tag: Tag): tag is ConstantTag {
 const VOLATILE_TAG_ID: IVOLATILE_TAG_ID = 100;
 
 export class VolatileTag implements Tag {
+  subtag?: Tag | Tag[] | null | undefined;
+  declare description: DevMode<TagDescription>;
   readonly [TYPE] = VOLATILE_TAG_ID;
   [COMPUTE](): Revision {
     return VOLATILE;
@@ -255,12 +377,24 @@ export class VolatileTag implements Tag {
 }
 
 export const VOLATILE_TAG = new VolatileTag();
+setDescription(
+  VOLATILE_TAG,
+  devmode(
+    () =>
+      ({
+        reason: 'cell',
+        label: ['(volatile)'],
+      }) satisfies TagDescription
+  )
+);
 
 //////////
 
 const CURRENT_TAG_ID: ICURRENT_TAG_ID = 101;
 
 export class CurrentTag implements Tag {
+  subtag?: Tag | Tag[] | null | undefined;
+  declare description: DevMode<TagDescription>;
   readonly [TYPE] = CURRENT_TAG_ID;
   [COMPUTE](): Revision {
     return $REVISION;
@@ -268,27 +402,24 @@ export class CurrentTag implements Tag {
 }
 
 export const CURRENT_TAG = new CurrentTag();
+setDescription(
+  CURRENT_TAG,
+  devmode(
+    () =>
+      ({
+        reason: 'cell',
+        label: ['(current)'],
+      }) satisfies TagDescription
+  )
+);
 
 //////////
 
 export const combine = MonomorphicTagImpl.combine;
 
-// Warm
-
-let tag1 = createUpdatableTag();
-let tag2 = createUpdatableTag();
-let tag3 = createUpdatableTag();
-
-valueForTag(tag1);
-DIRTY_TAG(tag1);
-valueForTag(tag1);
-UPDATE_TAG(tag1, combine([tag2, tag3]));
-valueForTag(tag1);
-DIRTY_TAG(tag2);
-valueForTag(tag1);
-DIRTY_TAG(tag3);
-valueForTag(tag1);
-UPDATE_TAG(tag1, tag3);
-valueForTag(tag1);
-DIRTY_TAG(tag3);
-valueForTag(tag1);
+//////////
+
+/**
+ * @internal
+ */
+export const TAG_TYPE: TagTypeSymbol = TYPE;
diff --git a/packages/@glimmer/validator/test/validators-test.ts b/packages/@glimmer/validator/test/validators-test.ts
index ab1de3ccbc..aa29d337b7 100644
--- a/packages/@glimmer/validator/test/validators-test.ts
+++ b/packages/@glimmer/validator/test/validators-test.ts
@@ -1,6 +1,5 @@
-import { testOverrideGlobalContext } from '@glimmer/global-context';
 import type { UpdatableTag } from '@glimmer/interfaces';
-
+import { testOverrideGlobalContext } from '@glimmer/global-context';
 import {
   ALLOW_CYCLES,
   bump,
@@ -15,6 +14,7 @@ import {
   valueForTag,
   VOLATILE_TAG,
 } from '@glimmer/validator';
+
 import { module, test } from './-utils';
 
 function unwrap<T>(value: T | null | undefined): T {
diff --git a/packages/@glimmer/vm/index.ts b/packages/@glimmer/vm/index.ts
index 3c9d22144a..defcd90f1b 100644
--- a/packages/@glimmer/vm/index.ts
+++ b/packages/@glimmer/vm/index.ts
@@ -1,8 +1,10 @@
-export { ContentType } from './lib/content';
+export * from './lib/content';
 export {
   ARG_SHIFT,
-  /** @deprecated */
-  CurriedTypes as CurriedType,
+  CURRIED_COMPONENT,
+  CURRIED_HELPER,
+  CURRIED_MODIFIER,
+  type CurriedInvokable,
   CurriedTypes,
   InternalComponentCapabilities,
   /** @deprecated */
@@ -13,7 +15,7 @@ export {
   TYPE_MASK,
   TYPE_SIZE,
 } from './lib/flags';
-export { isMachineOp, isOp, MachineOp, Op } from './lib/opcodes';
+export * from './lib/opcodes';
 export {
   $fp,
   $pc,
@@ -23,9 +25,10 @@ export {
   $sp,
   $t0,
   $t1,
+  $up,
   $v0,
   isLowLevelRegister,
-  MachineRegister,
+  type MachineRegister,
   type Register,
   SavedRegister,
   type SyscallRegister,
diff --git a/packages/@glimmer/vm/lib/content.ts b/packages/@glimmer/vm/lib/content.ts
index ddbe0290ce..61059a0905 100644
--- a/packages/@glimmer/vm/lib/content.ts
+++ b/packages/@glimmer/vm/lib/content.ts
@@ -1,10 +1,35 @@
-export const ContentType = {
-  Component: 0,
-  Helper: 1,
-  String: 2,
-  Empty: 3,
-  SafeString: 4,
-  Fragment: 5,
-  Node: 6,
-  Other: 8,
-} as const;
+export const COMPONENT_CONTENT = 0;
+export type COMPONENT_CONTENT = typeof COMPONENT_CONTENT;
+export const HELPER_CONTENT = 1;
+export type HELPER_CONTENT = typeof HELPER_CONTENT;
+export const STRING_CONTENT = 2;
+export type STRING_CONTENT = typeof STRING_CONTENT;
+export const EMPTY_CONTENT = 3;
+export type EMPTY_CONTENT = typeof EMPTY_CONTENT;
+export const SAFE_STRING_CONTENT = 4;
+export type SAFE_STRING_CONTENT = typeof SAFE_STRING_CONTENT;
+export const FRAGMENT_CONTENT = 5;
+export type FRAGMENT_CONTENT = typeof FRAGMENT_CONTENT;
+export const NODE_CONTENT = 6;
+export type NODE_CONTENT = typeof NODE_CONTENT;
+export const OTHER_CONTENT = 8;
+export type OTHER_CONTENT = typeof OTHER_CONTENT;
+export const ERROR_CONTENT = 9;
+export type ERROR_CONTENT = typeof ERROR_CONTENT;
+
+interface ContentTypeMap {
+  Component: COMPONENT_CONTENT;
+  Helper: HELPER_CONTENT;
+  String: STRING_CONTENT;
+  Empty: EMPTY_CONTENT;
+  SafeString: SAFE_STRING_CONTENT;
+  Fragment: FRAGMENT_CONTENT;
+  Node: NODE_CONTENT;
+  Other: OTHER_CONTENT;
+  Error: ERROR_CONTENT;
+}
+
+export type ContentTypeName = keyof ContentTypeMap;
+
+export type ContentType<K extends ContentTypeName = ContentTypeName> = ContentTypeMap[K];
+export type DynamicContentType = COMPONENT_CONTENT | HELPER_CONTENT | STRING_CONTENT;
diff --git a/packages/@glimmer/vm/lib/flags.ts b/packages/@glimmer/vm/lib/flags.ts
index 5093bd693c..3573ca08c8 100644
--- a/packages/@glimmer/vm/lib/flags.ts
+++ b/packages/@glimmer/vm/lib/flags.ts
@@ -24,12 +24,21 @@ import type {
   WrappedCapability,
 } from '@glimmer/interfaces';
 
+export const CURRIED_COMPONENT = 0 satisfies CurriedComponent;
+export type CURRIED_COMPONENT = typeof CURRIED_COMPONENT;
+export const CURRIED_HELPER = 1 satisfies CurriedHelper;
+export type CURRIED_HELPER = typeof CURRIED_HELPER;
+export const CURRIED_MODIFIER = 2 satisfies CurriedModifier;
+export type CURRIED_MODIFIER = typeof CURRIED_MODIFIER;
+
 export const CurriedTypes = {
-  Component: 0 satisfies CurriedComponent,
-  Helper: 1 satisfies CurriedHelper,
-  Modifier: 2 satisfies CurriedModifier,
+  Component: CURRIED_COMPONENT,
+  Helper: CURRIED_HELPER,
+  Modifier: CURRIED_MODIFIER,
 } as const;
 
+export type CurriedInvokable = CURRIED_COMPONENT | CURRIED_HELPER | CURRIED_MODIFIER;
+
 export const InternalComponentCapabilities = {
   Empty: 0 satisfies EmptyCapability,
   dynamicLayout: 0b0000000000001 satisfies DynamicLayoutCapability,
diff --git a/packages/@glimmer/vm/lib/generated/opcodes.ts b/packages/@glimmer/vm/lib/generated/opcodes.ts
new file mode 100644
index 0000000000..04c627318a
--- /dev/null
+++ b/packages/@glimmer/vm/lib/generated/opcodes.ts
@@ -0,0 +1,222 @@
+// This code was generated by $root/bin/opcodes.mts.
+// Do not change it manually.
+
+export interface Op {
+  PushFrame: 0;
+  PopFrame: 1;
+  Jump: 2;
+  ReturnTo: 3;
+  UnwindTypeFrame: 4;
+  PushBegin: 16;
+  Begin: 17;
+  Catch: 18;
+  Finally: 19;
+  InvokeVirtual: 20;
+  InvokeStatic: 21;
+  Start: 22;
+  Return: 23;
+  Helper: 24;
+  SetNamedVariables: 25;
+  SetBlocks: 26;
+  SetVariable: 27;
+  SetBlock: 28;
+  GetVariable: 29;
+  GetProperty: 30;
+  GetBlock: 31;
+  SpreadBlock: 32;
+  HasBlock: 33;
+  HasBlockParams: 34;
+  Concat: 35;
+  Constant: 36;
+  ConstantReference: 37;
+  Primitive: 38;
+  PrimitiveReference: 39;
+  ReifyU32: 40;
+  Dup: 41;
+  Pop: 42;
+  Load: 43;
+  Fetch: 44;
+  RootScope: 45;
+  VirtualRootScope: 46;
+  ChildScope: 47;
+  PopScope: 48;
+  Text: 49;
+  Comment: 50;
+  AppendHTML: 51;
+  AppendSafeHTML: 52;
+  AppendDocumentFragment: 53;
+  AppendNode: 54;
+  AppendText: 55;
+  OpenElement: 56;
+  OpenDynamicElement: 57;
+  PushRemoteElement: 58;
+  StaticAttr: 59;
+  DynamicAttr: 60;
+  ComponentAttr: 61;
+  FlushElement: 62;
+  CloseElement: 63;
+  PopRemoteElement: 64;
+  Modifier: 65;
+  BindDynamicScope: 66;
+  PushDynamicScope: 67;
+  PopDynamicScope: 68;
+  CompileBlock: 69;
+  PushBlockScope: 70;
+  PushSymbolTable: 71;
+  InvokeYield: 72;
+  JumpIf: 73;
+  JumpUnless: 74;
+  JumpEq: 75;
+  AssertSame: 76;
+  Enter: 77;
+  Exit: 78;
+  ToBoolean: 79;
+  EnterList: 80;
+  ExitList: 81;
+  Iterate: 82;
+  Main: 83;
+  ContentType: 84;
+  Curry: 85;
+  PushComponentDefinition: 86;
+  PushDynamicComponentInstance: 87;
+  ResolveDynamicComponent: 88;
+  ResolveCurriedComponent: 89;
+  PushArgs: 90;
+  PushEmptyArgs: 91;
+  PrepareArgs: 92;
+  CaptureArgs: 93;
+  CreateComponent: 94;
+  RegisterComponentDestructor: 95;
+  PutComponentOperations: 96;
+  GetComponentSelf: 97;
+  GetComponentTagName: 98;
+  GetComponentLayout: 99;
+  SetupForEval: 100;
+  PopulateLayout: 101;
+  InvokeComponentLayout: 102;
+  BeginComponentTransaction: 103;
+  CommitComponentTransaction: 104;
+  DidCreateElement: 105;
+  DidRenderLayout: 106;
+  Debugger: 107;
+  StaticComponentAttr: 108;
+  DynamicContentType: 109;
+  DynamicHelper: 110;
+  DynamicModifier: 111;
+  IfInline: 112;
+  Not: 113;
+  GetDynamicVar: 114;
+  Log: 115;
+  PushUnwindTarget: 116;
+}
+
+export const Op: Op = {
+  PushFrame: 0,
+  PopFrame: 1,
+  Jump: 2,
+  ReturnTo: 3,
+  UnwindTypeFrame: 4,
+  PushBegin: 16,
+  Begin: 17,
+  Catch: 18,
+  Finally: 19,
+  InvokeVirtual: 20,
+  InvokeStatic: 21,
+  Start: 22,
+  Return: 23,
+  Helper: 24,
+  SetNamedVariables: 25,
+  SetBlocks: 26,
+  SetVariable: 27,
+  SetBlock: 28,
+  GetVariable: 29,
+  GetProperty: 30,
+  GetBlock: 31,
+  SpreadBlock: 32,
+  HasBlock: 33,
+  HasBlockParams: 34,
+  Concat: 35,
+  Constant: 36,
+  ConstantReference: 37,
+  Primitive: 38,
+  PrimitiveReference: 39,
+  ReifyU32: 40,
+  Dup: 41,
+  Pop: 42,
+  Load: 43,
+  Fetch: 44,
+  RootScope: 45,
+  VirtualRootScope: 46,
+  ChildScope: 47,
+  PopScope: 48,
+  Text: 49,
+  Comment: 50,
+  AppendHTML: 51,
+  AppendSafeHTML: 52,
+  AppendDocumentFragment: 53,
+  AppendNode: 54,
+  AppendText: 55,
+  OpenElement: 56,
+  OpenDynamicElement: 57,
+  PushRemoteElement: 58,
+  StaticAttr: 59,
+  DynamicAttr: 60,
+  ComponentAttr: 61,
+  FlushElement: 62,
+  CloseElement: 63,
+  PopRemoteElement: 64,
+  Modifier: 65,
+  BindDynamicScope: 66,
+  PushDynamicScope: 67,
+  PopDynamicScope: 68,
+  CompileBlock: 69,
+  PushBlockScope: 70,
+  PushSymbolTable: 71,
+  InvokeYield: 72,
+  JumpIf: 73,
+  JumpUnless: 74,
+  JumpEq: 75,
+  AssertSame: 76,
+  Enter: 77,
+  Exit: 78,
+  ToBoolean: 79,
+  EnterList: 80,
+  ExitList: 81,
+  Iterate: 82,
+  Main: 83,
+  ContentType: 84,
+  Curry: 85,
+  PushComponentDefinition: 86,
+  PushDynamicComponentInstance: 87,
+  ResolveDynamicComponent: 88,
+  ResolveCurriedComponent: 89,
+  PushArgs: 90,
+  PushEmptyArgs: 91,
+  PrepareArgs: 92,
+  CaptureArgs: 93,
+  CreateComponent: 94,
+  RegisterComponentDestructor: 95,
+  PutComponentOperations: 96,
+  GetComponentSelf: 97,
+  GetComponentTagName: 98,
+  GetComponentLayout: 99,
+  SetupForEval: 100,
+  PopulateLayout: 101,
+  InvokeComponentLayout: 102,
+  BeginComponentTransaction: 103,
+  CommitComponentTransaction: 104,
+  DidCreateElement: 105,
+  DidRenderLayout: 106,
+  Debugger: 107,
+  StaticComponentAttr: 108,
+  DynamicContentType: 109,
+  DynamicHelper: 110,
+  DynamicModifier: 111,
+  IfInline: 112,
+  Not: 113,
+  GetDynamicVar: 114,
+  Log: 115,
+  PushUnwindTarget: 116,
+};
+
+export const OpSize = 117 as const;
diff --git a/packages/@glimmer/vm/lib/opcodes.ts b/packages/@glimmer/vm/lib/opcodes.ts
index 165c041c4b..1559c79d99 100644
--- a/packages/@glimmer/vm/lib/opcodes.ts
+++ b/packages/@glimmer/vm/lib/opcodes.ts
@@ -1,221 +1,8 @@
-import type {
-  VmAppendDocumentFragment,
-  VmAppendHTML,
-  VmAppendNode,
-  VmAppendSafeHTML,
-  VmAppendText,
-  VmAssertSame,
-  VmBeginComponentTransaction,
-  VmBindDynamicScope,
-  VmBindEvalScope,
-  VmCaptureArgs,
-  VmChildScope,
-  VmCloseElement,
-  VmComment,
-  VmCommitComponentTransaction,
-  VmCompileBlock,
-  VmComponentAttr,
-  VmConcat,
-  VmConstant,
-  VmConstantReference,
-  VmContentType,
-  VmCreateComponent,
-  VmCurry,
-  VmDebugger,
-  VmDidCreateElement,
-  VmDidRenderLayout,
-  VmDup,
-  VmDynamicAttr,
-  VmDynamicContentType,
-  VmDynamicHelper,
-  VmDynamicModifier,
-  VmEnter,
-  VmEnterList,
-  VmExit,
-  VmExitList,
-  VmFetch,
-  VmFlushElement,
-  VmGetBlock,
-  VmGetComponentLayout,
-  VmGetComponentSelf,
-  VmGetComponentTagName,
-  VmGetDynamicVar,
-  VmGetProperty,
-  VmGetVariable,
-  VmHasBlock,
-  VmHasBlockParams,
-  VmHelper,
-  VmIfInline,
-  VmInvokeComponentLayout,
-  VmInvokeYield,
-  VmIterate,
-  VmJumpEq,
-  VmJumpIf,
-  VmJumpUnless,
-  VmLoad,
-  VmLog,
-  VmMachineInvokeStatic,
-  VmMachineInvokeVirtual,
-  VmMachineJump,
-  VmMachineOp,
-  VmMachinePopFrame,
-  VmMachinePushFrame,
-  VmMachineReturn,
-  VmMachineReturnTo,
-  VmMachineSize,
-  VmMain,
-  VmModifier,
-  VmNot,
-  VmOp,
-  VmOpenDynamicElement,
-  VmOpenElement,
-  VmPop,
-  VmPopArgs,
-  VmPopDynamicScope,
-  VmPopRemoteElement,
-  VmPopScope,
-  VmPopulateLayout,
-  VmPrepareArgs,
-  VmPrimitive,
-  VmPrimitiveReference,
-  VmPushArgs,
-  VmPushBlockScope,
-  VmPushComponentDefinition,
-  VmPushDynamicComponentInstance,
-  VmPushDynamicScope,
-  VmPushEmptyArgs,
-  VmPushRemoteElement,
-  VmPushSymbolTable,
-  VmPutComponentOperations,
-  VmRegisterComponentDestructor,
-  VmReifyU32,
-  VmResolveCurriedComponent,
-  VmResolveDynamicComponent,
-  VmResolveMaybeLocal,
-  VmRootScope,
-  VmSetBlock,
-  VmSetBlocks,
-  VmSetNamedVariables,
-  VmSetupForEval,
-  VmSetVariable,
-  VmSize,
-  VmSpreadBlock,
-  VmStaticAttr,
-  VmStaticComponentAttr,
-  VmText,
-  VmToBoolean,
-  VmVirtualRootScope,
-} from '@glimmer/interfaces';
+import type { VmMachineOp, VmSyscallOp } from '@glimmer/interfaces';
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+export { Op,OpSize } from './generated/opcodes';
 
-export const MachineOp = {
-  PushFrame: 0 satisfies VmMachinePushFrame,
-  PopFrame: 1 satisfies VmMachinePopFrame,
-  InvokeVirtual: 2 satisfies VmMachineInvokeVirtual,
-  InvokeStatic: 3 satisfies VmMachineInvokeStatic,
-  Jump: 4 satisfies VmMachineJump,
-  Return: 5 satisfies VmMachineReturn,
-  ReturnTo: 6 satisfies VmMachineReturnTo,
-  Size: 7 satisfies VmMachineSize,
-} as const;
-
-export const Op = {
-  Helper: 16 satisfies VmHelper,
-  SetNamedVariables: 17 satisfies VmSetNamedVariables,
-  SetBlocks: 18 satisfies VmSetBlocks,
-  SetVariable: 19 satisfies VmSetVariable,
-  SetBlock: 20 satisfies VmSetBlock,
-  GetVariable: 21 satisfies VmGetVariable,
-  GetProperty: 22 satisfies VmGetProperty,
-  GetBlock: 23 satisfies VmGetBlock,
-  SpreadBlock: 24 satisfies VmSpreadBlock,
-  HasBlock: 25 satisfies VmHasBlock,
-  HasBlockParams: 26 satisfies VmHasBlockParams,
-  Concat: 27 satisfies VmConcat,
-  Constant: 28 satisfies VmConstant,
-  ConstantReference: 29 satisfies VmConstantReference,
-  Primitive: 30 satisfies VmPrimitive,
-  PrimitiveReference: 31 satisfies VmPrimitiveReference,
-  ReifyU32: 32 satisfies VmReifyU32,
-  Dup: 33 satisfies VmDup,
-  Pop: 34 satisfies VmPop,
-  Load: 35 satisfies VmLoad,
-  Fetch: 36 satisfies VmFetch,
-  RootScope: 37 satisfies VmRootScope,
-  VirtualRootScope: 38 satisfies VmVirtualRootScope,
-  ChildScope: 39 satisfies VmChildScope,
-  PopScope: 40 satisfies VmPopScope,
-  Text: 41 satisfies VmText,
-  Comment: 42 satisfies VmComment,
-  AppendHTML: 43 satisfies VmAppendHTML,
-  AppendSafeHTML: 44 satisfies VmAppendSafeHTML,
-  AppendDocumentFragment: 45 satisfies VmAppendDocumentFragment,
-  AppendNode: 46 satisfies VmAppendNode,
-  AppendText: 47 satisfies VmAppendText,
-  OpenElement: 48 satisfies VmOpenElement,
-  OpenDynamicElement: 49 satisfies VmOpenDynamicElement,
-  PushRemoteElement: 50 satisfies VmPushRemoteElement,
-  StaticAttr: 51 satisfies VmStaticAttr,
-  DynamicAttr: 52 satisfies VmDynamicAttr,
-  ComponentAttr: 53 satisfies VmComponentAttr,
-  FlushElement: 54 satisfies VmFlushElement,
-  CloseElement: 55 satisfies VmCloseElement,
-  PopRemoteElement: 56 satisfies VmPopRemoteElement,
-  Modifier: 57 satisfies VmModifier,
-  BindDynamicScope: 58 satisfies VmBindDynamicScope,
-  PushDynamicScope: 59 satisfies VmPushDynamicScope,
-  PopDynamicScope: 60 satisfies VmPopDynamicScope,
-  CompileBlock: 61 satisfies VmCompileBlock,
-  PushBlockScope: 62 satisfies VmPushBlockScope,
-  PushSymbolTable: 63 satisfies VmPushSymbolTable,
-  InvokeYield: 64 satisfies VmInvokeYield,
-  JumpIf: 65 satisfies VmJumpIf,
-  JumpUnless: 66 satisfies VmJumpUnless,
-  JumpEq: 67 satisfies VmJumpEq,
-  AssertSame: 68 satisfies VmAssertSame,
-  Enter: 69 satisfies VmEnter,
-  Exit: 70 satisfies VmExit,
-  ToBoolean: 71 satisfies VmToBoolean,
-  EnterList: 72 satisfies VmEnterList,
-  ExitList: 73 satisfies VmExitList,
-  Iterate: 74 satisfies VmIterate,
-  Main: 75 satisfies VmMain,
-  ContentType: 76 satisfies VmContentType,
-  Curry: 77 satisfies VmCurry,
-  PushComponentDefinition: 78 satisfies VmPushComponentDefinition,
-  PushDynamicComponentInstance: 79 satisfies VmPushDynamicComponentInstance,
-  ResolveDynamicComponent: 80 satisfies VmResolveDynamicComponent,
-  ResolveCurriedComponent: 81 satisfies VmResolveCurriedComponent,
-  PushArgs: 82 satisfies VmPushArgs,
-  PushEmptyArgs: 83 satisfies VmPushEmptyArgs,
-  PopArgs: 84 satisfies VmPopArgs,
-  PrepareArgs: 85 satisfies VmPrepareArgs,
-  CaptureArgs: 86 satisfies VmCaptureArgs,
-  CreateComponent: 87 satisfies VmCreateComponent,
-  RegisterComponentDestructor: 88 satisfies VmRegisterComponentDestructor,
-  PutComponentOperations: 89 satisfies VmPutComponentOperations,
-  GetComponentSelf: 90 satisfies VmGetComponentSelf,
-  GetComponentTagName: 91 satisfies VmGetComponentTagName,
-  GetComponentLayout: 92 satisfies VmGetComponentLayout,
-  BindEvalScope: 93 satisfies VmBindEvalScope,
-  SetupForEval: 94 satisfies VmSetupForEval,
-  PopulateLayout: 95 satisfies VmPopulateLayout,
-  InvokeComponentLayout: 96 satisfies VmInvokeComponentLayout,
-  BeginComponentTransaction: 97 satisfies VmBeginComponentTransaction,
-  CommitComponentTransaction: 98 satisfies VmCommitComponentTransaction,
-  DidCreateElement: 99 satisfies VmDidCreateElement,
-  DidRenderLayout: 100 satisfies VmDidRenderLayout,
-  ResolveMaybeLocal: 102 satisfies VmResolveMaybeLocal,
-  Debugger: 103 satisfies VmDebugger,
-  Size: 104 satisfies VmSize,
-  StaticComponentAttr: 105 satisfies VmStaticComponentAttr,
-  DynamicContentType: 106 satisfies VmDynamicContentType,
-  DynamicHelper: 107 satisfies VmDynamicHelper,
-  DynamicModifier: 108 satisfies VmDynamicModifier,
-  IfInline: 109 satisfies VmIfInline,
-  Not: 110 satisfies VmNot,
-  GetDynamicVar: 111 satisfies VmGetDynamicVar,
-  Log: 112 satisfies VmLog,
-} as const;
+export type VmOp = VmMachineOp | VmSyscallOp;
 
 export function isMachineOp(value: number): value is VmMachineOp {
   return value >= 0 && value <= 15;
diff --git a/packages/@glimmer/vm/lib/registers.ts b/packages/@glimmer/vm/lib/registers.ts
index 14257d23a6..782984b2d3 100644
--- a/packages/@glimmer/vm/lib/registers.ts
+++ b/packages/@glimmer/vm/lib/registers.ts
@@ -6,31 +6,41 @@
  */
 
 // $0 or $pc (program counter): pointer into `program` for the next insturction; -1 means exit
-export const $pc: MachineRegister.pc = 0;
+export const $pc = 0;
+export type $pc = 0;
 // $1 or $ra (return address): pointer into `program` for the return
-export const $ra: MachineRegister.ra = 1;
+export const $ra = 1;
+export type $ra = 1;
 // $2 or $fp (frame pointer): pointer into the `evalStack` for the base of the stack
-export const $fp: MachineRegister.fp = 2;
+export const $fp = 2;
+export type $fp = 2;
 // $3 or $sp (stack pointer): pointer into the `evalStack` for the top of the stack
-export const $sp: MachineRegister.sp = 3;
-// $4-$5 or $s0-$s1 (saved): callee saved general-purpose registers
-export const $s0: SavedRegister.s0 = 4;
-export const $s1: SavedRegister.s1 = 5;
-// $6-$7 or $t0-$t1 (temporaries): caller saved general-purpose registers
-export const $t0: TemporaryRegister.t0 = 6;
-export const $t1: TemporaryRegister.t1 = 7;
-// $8 or $v0 (return value)
-export const $v0 = 8;
-
-export enum MachineRegister {
-  // These must be in sync with the computed values
-  // above, but TypeScript doesn't like it
-
-  'pc' = 0,
-  'ra' = 1,
-  'fp' = 2,
-  'sp' = 3,
-}
+export const $sp = 3;
+export type $sp = 3;
+// $4 or $up (unwind pointer): pointer into the `evalStack` for the unwind base of the stack
+// The layout of the stack after the $up is:
+// - the previous $up
+// - the 'catch' pc
+// - the previous $ra
+// - the previous $fp
+export const $up = 4;
+export type $up = 4;
+
+// $5-$6 or $s0-$s1 (saved): callee saved general-purpose registers
+export const $s0: $s0 = 5;
+export type $s0 = 5;
+export const $s1: $s1 = 6;
+export type $s1 = 6;
+// $7-$8 or $t0-$t1 (temporaries): caller saved general-purpose registers
+export const $t0: $t0 = 7;
+export type $t0 = 7;
+export const $t1: $t1 = 8;
+export type $t1 = 8;
+// $9 or $v0 (return value)
+export const $v0 = 9;
+export type $v0 = 9;
+
+export type MachineRegister = typeof $pc | typeof $ra | typeof $fp | typeof $sp;
 
 export function isLowLevelRegister(
   register: Register | MachineRegister
@@ -38,15 +48,23 @@ export function isLowLevelRegister(
   return (register as number) <= $sp;
 }
 
-export enum SavedRegister {
-  's0' = 4,
-  's1' = 5,
-}
+export const SavedRegister = {
+  s0: $s0,
+  s1: $s1,
+};
 
-export enum TemporaryRegister {
-  't0' = 6,
-  't1' = 7,
-}
+export type SavedRegister = $s0 | $s1;
 
-export type Register = MachineRegister | SavedRegister | TemporaryRegister | typeof $v0;
+export const TemporaryRegister = {
+  t0: $t0,
+  t1: $t1,
+};
+
+export type TemporaryRegister = $t0 | $t1;
+
+export type Register = MachineRegister | SavedRegister | TemporaryRegister | $v0;
+
+/**
+ * All of the registers except the machine registers.
+ */
 export type SyscallRegister = SavedRegister | TemporaryRegister | typeof $v0;
diff --git a/packages/@glimmer/wire-format/lib/opcodes.ts b/packages/@glimmer/wire-format/lib/opcodes.ts
index 9214151f9d..f58cb3b66a 100644
--- a/packages/@glimmer/wire-format/lib/opcodes.ts
+++ b/packages/@glimmer/wire-format/lib/opcodes.ts
@@ -1,107 +1,53 @@
-import type {
-  AppendOpcode,
-  AttrSplatOpcode,
-  BlockOpcode,
-  CallOpcode,
-  CloseElementOpcode,
-  CommentOpcode,
-  ComponentAttrOpcode,
-  ComponentOpcode,
-  ConcatOpcode,
-  CurryOpcode,
-  DebuggerOpcode,
-  DynamicArgOpcode,
-  DynamicAttrOpcode,
-  EachOpcode,
-  FlushElementOpcode,
-  GetDynamicVarOpcode,
-  GetFreeAsComponentHeadOpcode,
-  GetFreeAsComponentOrHelperHeadOpcode,
-  GetFreeAsComponentOrHelperHeadOrThisFallbackOpcode,
-  GetFreeAsDeprecatedHelperHeadOrThisFallbackOpcode,
-  GetFreeAsHelperHeadOpcode,
-  GetFreeAsHelperHeadOrThisFallbackOpcode,
-  GetFreeAsModifierHeadOpcode,
-  GetLexicalSymbolOpcode,
-  GetStrictKeywordOpcode,
-  GetSymbolOpcode,
-  HasBlockOpcode,
-  HasBlockParamsOpcode,
-  IfInlineOpcode,
-  IfOpcode,
-  InElementOpcode,
-  InvokeComponentOpcode,
-  LetOpcode,
-  LogOpcode,
-  ModifierOpcode,
-  NotOpcode,
-  OpenElementOpcode,
-  OpenElementWithSplatOpcode,
-  StaticArgOpcode,
-  StaticAttrOpcode,
-  StaticComponentAttrOpcode,
-  StrictBlockOpcode,
-  StrictModifierOpcode,
-  TrustingAppendOpcode,
-  TrustingComponentAttrOpcode,
-  TrustingDynamicAttrOpcode,
-  UndefinedOpcode,
-  WithDynamicVarsOpcode,
-  WithOpcode,
-  YieldOpcode,
-} from '@glimmer/interfaces';
-
-export const opcodes = {
-  Append: 1 satisfies AppendOpcode,
-  TrustingAppend: 2 satisfies TrustingAppendOpcode,
-  Comment: 3 satisfies CommentOpcode,
-  Modifier: 4 satisfies ModifierOpcode,
-  StrictModifier: 5 satisfies StrictModifierOpcode,
-  Block: 6 satisfies BlockOpcode,
-  StrictBlock: 7 satisfies StrictBlockOpcode,
-  Component: 8 satisfies ComponentOpcode,
-  OpenElement: 10 satisfies OpenElementOpcode,
-  OpenElementWithSplat: 11 satisfies OpenElementWithSplatOpcode,
-  FlushElement: 12 satisfies FlushElementOpcode,
-  CloseElement: 13 satisfies CloseElementOpcode,
-  StaticAttr: 14 satisfies StaticAttrOpcode,
-  DynamicAttr: 15 satisfies DynamicAttrOpcode,
-  ComponentAttr: 16 satisfies ComponentAttrOpcode,
-  AttrSplat: 17 satisfies AttrSplatOpcode,
-  Yield: 18 satisfies YieldOpcode,
-  DynamicArg: 20 satisfies DynamicArgOpcode,
-  StaticArg: 21 satisfies StaticArgOpcode,
-  TrustingDynamicAttr: 22 satisfies TrustingDynamicAttrOpcode,
-  TrustingComponentAttr: 23 satisfies TrustingComponentAttrOpcode,
-  StaticComponentAttr: 24 satisfies StaticComponentAttrOpcode,
-  Debugger: 26 satisfies DebuggerOpcode,
-  Undefined: 27 satisfies UndefinedOpcode,
-  Call: 28 satisfies CallOpcode,
-  Concat: 29 satisfies ConcatOpcode,
-  GetSymbol: 30 satisfies GetSymbolOpcode,
-  GetLexicalSymbol: 32 satisfies GetLexicalSymbolOpcode,
-  GetStrictKeyword: 31 satisfies GetStrictKeywordOpcode,
-  GetFreeAsComponentOrHelperHeadOrThisFallback:
-    34 satisfies GetFreeAsComponentOrHelperHeadOrThisFallbackOpcode,
-  GetFreeAsComponentOrHelperHead: 35 satisfies GetFreeAsComponentOrHelperHeadOpcode,
-  GetFreeAsHelperHeadOrThisFallback: 36 satisfies GetFreeAsHelperHeadOrThisFallbackOpcode,
-  GetFreeAsDeprecatedHelperHeadOrThisFallback:
-    99 satisfies GetFreeAsDeprecatedHelperHeadOrThisFallbackOpcode,
-  GetFreeAsHelperHead: 37 satisfies GetFreeAsHelperHeadOpcode,
-  GetFreeAsModifierHead: 38 satisfies GetFreeAsModifierHeadOpcode,
-  GetFreeAsComponentHead: 39 satisfies GetFreeAsComponentHeadOpcode,
-  InElement: 40 satisfies InElementOpcode,
-  If: 41 satisfies IfOpcode,
-  Each: 42 satisfies EachOpcode,
-  With: 43 satisfies WithOpcode,
-  Let: 44 satisfies LetOpcode,
-  WithDynamicVars: 45 satisfies WithDynamicVarsOpcode,
-  InvokeComponent: 46 satisfies InvokeComponentOpcode,
-  HasBlock: 48 satisfies HasBlockOpcode,
-  HasBlockParams: 49 satisfies HasBlockParamsOpcode,
-  Curry: 50 satisfies CurryOpcode,
-  Not: 51 satisfies NotOpcode,
-  IfInline: 52 satisfies IfInlineOpcode,
-  GetDynamicVar: 53 satisfies GetDynamicVarOpcode,
-  Log: 54 satisfies LogOpcode,
+export const  opcodes = {
+  Append: 1,
+  TrustingAppend: 2,
+  Comment: 3,
+  Modifier: 4,
+  StrictModifier: 5,
+  Block: 6,
+  StrictBlock: 7,
+  Component: 8,
+  OpenElement: 10,
+  OpenElementWithSplat: 11,
+  FlushElement: 12,
+  CloseElement: 13,
+  StaticAttr: 14,
+  DynamicAttr: 15,
+  ComponentAttr: 16,
+  AttrSplat: 17,
+  Yield: 18,
+  DynamicArg: 20,
+  StaticArg: 21,
+  TrustingDynamicAttr: 22,
+  TrustingComponentAttr: 23,
+  StaticComponentAttr: 24,
+  Debugger: 26,
+  Undefined: 27,
+  Call: 28,
+  Concat: 29,
+  GetSymbol: 30,
+  GetLexicalSymbol: 32,
+  GetStrictKeyword: 31,
+  GetFreeAsComponentOrHelperHeadOrThisFallback: 34,
+  GetFreeAsComponentOrHelperHead: 35,
+  GetFreeAsHelperHeadOrThisFallback: 36,
+  GetFreeAsDeprecatedHelperHeadOrThisFallback: 99,
+  GetFreeAsHelperHead: 37,
+  GetFreeAsModifierHead: 38,
+  GetFreeAsComponentHead: 39,
+  InElement: 40,
+  If: 41,
+  Each: 42,
+  With: 43,
+  Let: 44,
+  WithDynamicVars: 45,
+  InvokeComponent: 46,
+  HasBlock: 48,
+  HasBlockParams: 49,
+  Curry: 50,
+  Not: 51,
+  IfInline: 52,
+  GetDynamicVar: 53,
+  Log: 54,
+  HandleError: 55,
 } as const;
diff --git a/packages/@types/qunit/index.d.ts b/packages/@types/qunit/index.d.ts
new file mode 100644
index 0000000000..006ca10be5
--- /dev/null
+++ b/packages/@types/qunit/index.d.ts
@@ -0,0 +1,891 @@
+import type { Runner } from 'js-reporters';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+declare global {
+  interface Assert {
+    /**
+     * Instruct QUnit to wait for an asynchronous operation.
+     *
+     * `assert.async()` returns a callback function and pauses test processing until the
+     * callback function is called. The callback will throw an `Error` if it is invoked more
+     * often than the required call count.
+     *
+     * @param {number} [count=1] Number of expected calls
+     */
+    async(count?: number): () => void;
+
+    /**
+     * A recursive and strict comparison, considering all own and inherited properties.
+     *
+     * For primitive values, a strict comparison is used. For objects, the object identity is
+     * disregarded and instead a recursive comparison of all own and inherited properties is
+     * performed. This means arrays, plain objects, and arbitrary class instance objects can
+     * all be compared in this way.
+     *
+     * The deep comparison includes built-in support for Date objects, regular expressions,
+     * NaN, as well as ES6 features such as Symbol, Set, and Map objects.
+     *
+     * To assert strict equality on own properties only, refer to `assert.propEqual()`.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparision value
+     * @param {string} [message] Short description of the actual expression
+     */
+    deepEqual<T>(actual: T, expected: T, message?: string): void;
+
+    /**
+     * A non-strict comparison of two values.
+     *
+     * The `equal` assertion uses the simple comparison operator (`==`) to compare the actual
+     * and expected arguments. When they are equal, the assertion passes; otherwise, it fails.
+     *
+     * When it fails, both actual and expected values are displayed in the test result, in
+     * addition to a given message.
+     *
+     * To test for strict equality, use `assert.strictEqual()`.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description of the actual expression
+     */
+    equal(actual: any, expected: any, message?: string): void;
+
+    /**
+     * Specify how many assertions are expected in a test.
+     *
+     * This is most commonly used as `assert.expect(0)`, which indicates that a test may pass
+     * without making any assertions. This means the test is only used to verify that the code
+     * runs to completion, without any uncaught errors. This is is essentially the inverse of
+     * `assert.throws()`.
+     *
+     * This can also be used to explicitly require a certain number of assertions to be
+     * recorded in a given test. If afterwards the number of assertions does not match the
+     * expected count, the test will fail.
+     *
+     * It is recommended to test asynchronous code with `assert.step()` or `assert.async()`
+     * instead.
+     *
+     * @param {number} amount Number of expected assertions in this test
+     */
+    expect(amount: number): void;
+
+    /**
+     * A strict comparison that passes if the first argument is boolean `false`.
+     *
+     * If the argument evaluates to false, the assertion passes; otherwise, it fails.
+     *
+     * @param state Expression being tested
+     * @param {string} [message] Short description
+     */
+    false(state: any, message?: string): void;
+
+    /**
+     * An inverted deep equal comparison.
+     *
+     * This assertion fails if the actual and expected values are recursively equal by strict
+     * comparison, considering both own and inherited properties.
+     *
+     * The assertion passes if there are structural differences, type differences, or even a
+     * subtle difference in a particular property value.
+     *
+     * This is the inverse of `assert.deepEqual()`.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description
+     */
+    notDeepEqual(actual: any, expected: any, message?: string): void;
+
+    /**
+     * A loose inequality comparison, checking for non-strict differences between two values.
+     *
+     * The `notEqual` assertion uses the simple inverted comparison operator (`!=`) to compare
+     * the actual and expected values. When they aren't equal, the assertion passes;
+     * otherwise, it fails. When it fails, both actual and expected values are displayed in
+     * the test result, in addition to a given message.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description
+     */
+    notEqual(actual: any, expected: any, message?: string): void;
+
+    /**
+     * A boolean check that passes when the first argument is falsy.
+     *
+     * If the argument evaluates to false, the assertion passes; otherwise, it fails.
+     *
+     * To strictly compare against boolean false, use `assert.false()`.
+     *
+     * @param state Expression being tested
+     * @param {string} [message] Short description
+     */
+    notOk(state: any, message?: string): void;
+
+    /**
+     * Check that an object does not contain certain properties.
+     *
+     * The `notPropContains` assertion compares the subset of properties
+     * in the expected object, and tests that these keys are either absent
+     * or hold a value that is different according to a strict equality comparison.
+     *
+     * This method is recursive and allows partial comparison of nested objects as well.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description
+     */
+    notPropContains(actual: any, expected: any, message?: string): void;
+
+    /**
+     * Compare an object's own properties using a strict inequality comparison.
+     *
+     * The `notPropEqual` assertion compares only an object's own properties,
+     * using the strict inquality operator (`!==`).
+     *
+     * The test passes if there are properties with different values, or extra properties
+     * or missing properties.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description
+     */
+    notPropEqual(actual: any, expected: any, message?: string): void;
+
+    /**
+     * A strict comparison, checking for inequality.
+     *
+     * The `notStrictEqual` assertion uses the strict inverted comparison
+     * operator (`!==`) to compare the actual and expected arguments. When they
+     * aren't equal, the assertion passes; otherwise, it fails. When it fails,
+     * both actual and expected values are displayed in the test result, in
+     * addition to a given message.
+     *
+     * `assert.equal()` can be used to test equality.
+     *
+     * `assert.strictEqual()` can be used to test strict equality.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description
+     */
+    notStrictEqual(actual: any, expected: any, message?: string): void;
+
+    /**
+     * A boolean check that passes when the first argument is truthy.
+     *
+     * If the argument evaluates to true, the assertion passes; otherwise, it fails.
+     *
+     * To strictly compare against boolean true, use `assert.true()`.
+     *
+     * @param state Expression being tested
+     * @param {string} [message] Short description
+     */
+    ok(state: any, message?: string): void;
+
+    /**
+     * Check that an object contains certain properties.
+     *
+     * The `propContains` assertion compares only the subset of properties
+     * in the expected object, and tests that these keys exist as own properties
+     * with strictly equal values.
+     *
+     * This method is recursive and allows partial comparison of nested objects as well.
+     *
+     * Use `assert.propEqual()` to compare all properties.
+     * Use `assert.notPropContains()` to test for the absence or inequality of properties.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description of the actual expression
+     */
+    propContains(actual: any, expected: any, message?: string): void;
+
+    /**
+     * Compare an object's own properties using a strict comparison.
+     *
+     * The `propEqual` assertion only compares an object's own properties. This means the
+     * expected value does not need to be an instance of the same class or otherwise inherit
+     * the same prototype. This is in contrast with `assert.deepEqual()`.
+     *
+     * This assertion fails if the values differ, or if there are extra properties, or if
+     * some properties are missing.
+     *
+     * This method is recursive and can compare any nested or complex object via a plain object.
+     *
+     * Use `assert.propContains()` to only check a subset of properties.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description of the actual expression
+     */
+    propEqual(actual: any, expected: any, message?: string): void;
+
+    /**
+     * Report the result of a custom assertion.
+     *
+     * If you need to express an expectation that is not abstracted by a built-in assertion,
+     * you can perform your own logic ad-hoc in an expression, and then pass two directly
+     * comparable values top `assert.strictEqual()` or `assert.true()`.
+     *
+     * If you opt to create your own assertion method instead, use `pushResult` to
+     * save the result.
+     *
+     * Example:
+     *
+     * ```
+     * QUnit.assert.between = function (actual, from, to, message) {
+     *   const isBetween = (actual >= from && actual <= to);
+     *
+     *   this.pushResult({
+     *     result: isBetween,
+     *     actual: actual,
+     *     expected: `between ${from} and ${to} inclusive`,
+     *     message: message
+     *   });
+     * };
+     * ```
+     *
+     * @param assertionResult The assertion result
+     */
+    pushResult(assertResult: {
+      result: boolean;
+      actual: any;
+      expected: any;
+      message?: string | undefined;
+      source?: string | undefined;
+    }): void;
+
+    /**
+     * Test if the provided promise rejects, and optionally compare the rejection value.
+     *
+     * When testing code that is expected to return a rejected promise based on a
+     * specific set of circumstances, use `assert.rejects()` for testing and comparison.
+     *
+     * The expectedMatcher argument can be:
+     *      A function that returns true when the assertion should be considered passing.
+     *      An Error object.
+     *      A base constructor to use ala rejectionValue instanceof expectedMatcher.
+     *      A RegExp that matches (or partially matches) rejectionValue.toString().
+     *
+     * Note: in order to avoid confusion between the message and the expectedMatcher,
+     * the expectedMatcher can not be a string.
+     *
+     * @param promise Promise to test for rejection
+     * @param expectedMatcher Rejection value matcher
+     * @param message Short description of the assertion
+     */
+    rejects(promise: Promise<any>, message?: string): Promise<void>;
+    rejects(promise: Promise<any>, expectedMatcher?: any, message?: string): Promise<void>;
+
+    /**
+     * Set how long to wait for async operations to finish.
+     *
+     * This assertion defines how long to wait (at most) in the current test. It overrides QUnit.config.testTimeout on a per-test basis.
+     *
+     * The timeout length only applies when a test actually involves asynchronous functions or promises. If 0 is passed, then awaiting or returning any Promise may fail the test.
+     *
+     * If assert.timeout() is called after a different timeout is already set, the old timeout will be cleared and the new duration will be used to start a new timer.
+     *
+     * @param duration The length of time to wait, in milleseconds.
+     */
+    timeout(duration: number): void;
+
+    /**
+     * Record a step for later verification.
+     *
+     * This assertion registers a passing assertion with the provided string. This and any
+     * other steps should be verified later in the test via `assert.verifySteps()`.
+     *
+     * @param value Relevant string value, or short description, to mark this step.
+     */
+    step(value: string): void;
+
+    /**
+     * A strict type and value comparison.
+     *
+     * The `strictEqual()` assertion provides the most rigid comparison of type
+     * and value with the strict equality operator (`===`).
+     *
+     * `assert.equal()` can be used to test non-strict equality.
+     *
+     * @param actual Expression being tested
+     * @param expected Known comparison value
+     * @param {string} [message] Short description of the assertion
+     */
+    strictEqual<T>(actual: T, expected: T, message?: string): void;
+
+    /**
+     * Test if a callback throws an exception, and optionally compare the thrown error.
+     *
+     * When testing code that is expected to throw an exception based on a
+     * specific set of circumstances, use `assert.throws()` to catch the error
+     * object for testing and comparison.
+     *
+     * The expectedMatcher argument can be:
+     *      An Error object.
+     *      An Error constructor to use ala `errorValue instanceof expectedMatcher`.
+     *      A RegExp that matches (or partially matches) the string representation.
+     *      A callback Function that must return `true` to pass the assertion check.
+     */
+    throws(block: () => void, expected?: any, message?: any): void;
+    raises(block: () => void, expected?: any, message?: any): void;
+
+    /**
+     * A strict comparison that passes if the first argument is boolean `true`.
+     *
+     * If the argument evaluates to true, the assertion passes; otherwise, it fails.
+     *
+     * @param state Expression being tested
+     * @param {string} [message] Short description of the actual expression
+     */
+    true(state: any, message?: string): void;
+
+    /**
+     * Verify the presence and exact order of previously marked steps in a test.
+     *
+     * The Step API provides an easy way to verify execution logic to a high degree of
+     * accuracy and precision, whether for asynchronous code, event-driven code, or
+     * callback-driven code.
+     *
+     * For example, you can mark steps to observe and validate whether parts of your code are
+     * reached correctly, or to check the frequency (how often) an asynchronous code path is
+     * executed. You can also capture any unexpected steps, which are automatically detected
+     * and shown as part of the test failure.
+     *
+     * This assertion compares a given array of string values to a list of previously recorded
+     * steps, as marked via previous calls to `assert.step()`.
+     *
+     * @param steps List of strings
+     * @param message Short description of the assertion
+     */
+    verifySteps(steps: string[], message?: string): void;
+  }
+
+  interface Config {
+    altertitle: boolean;
+    autostart: boolean;
+    collapse: boolean;
+    current: any;
+    failOnZeroTests: boolean;
+    filter: string | RegExp;
+    fixture: string;
+    hidepassed: boolean;
+    maxDepth: number;
+    module: string;
+    moduleId: string[];
+    noglobals: boolean;
+    notrycatch: boolean;
+    reorder: boolean;
+    requireExpects: boolean;
+    scrolltop: boolean;
+    seed: string;
+    testId: string[];
+    testTimeout?: number | null;
+    urlConfig: {
+      id?: string | undefined;
+      label?: string | undefined;
+      tooltip?: string | undefined;
+      value?: string | string[] | { [key: string]: string } | undefined;
+    }[];
+  }
+
+  interface GlobalHooks {
+    /**
+     * Runs after each test.
+     */
+    afterEach(fn: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Runs before each test.
+     */
+    beforeEach(fn: (assert: Assert) => void | Promise<void>): void;
+  }
+
+  interface Hooks {
+    /**
+     * Runs after the last test. If additional tests are defined after the
+     * module's queue has emptied, it will not run this hook again.
+     */
+    after?: ((assert: Assert) => void | Promise<void>) | undefined;
+
+    /**
+     * Runs after each test.
+     */
+    afterEach?: ((assert: Assert) => void | Promise<void>) | undefined;
+
+    /**
+     * Runs before the first test.
+     */
+    before?: ((assert: Assert) => void | Promise<void>) | undefined;
+
+    /**
+     * Runs before each test.
+     */
+    beforeEach?: ((assert: Assert) => void | Promise<void>) | undefined;
+  }
+
+  interface NestedHooks {
+    /**
+     * Runs after the last test. If additional tests are defined after the
+     * module's queue has emptied, it will not run this hook again.
+     */
+    after(fn: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Runs after each test.
+     */
+    afterEach(fn: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Runs before the first test.
+     */
+    before(fn: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Runs before each test.
+     */
+    beforeEach(fn: (assert: Assert) => void | Promise<void>): void;
+  }
+
+  type ModuleFunc1 = (name: string, hooks?: Hooks, nested?: (hooks: NestedHooks) => void) => void;
+  type ModuleFunc2 = (name: string, nested?: (hooks: NestedHooks) => void) => void;
+  type ModuleOnly = { only: ModuleFunc1 & ModuleFunc2 };
+  type ModuleSkip = { skip: ModuleFunc1 & ModuleFunc2 };
+  type ModuleTodo = { todo: ModuleFunc1 & ModuleFunc2 };
+
+  namespace QUnit {
+    interface BeginDetails {
+      /** Number of registered tests */
+      totalTests: number;
+      /** List of registered modules, */
+      modules: Array<{ name: string; moduleId: string }>;
+    }
+    interface DoneDetails {
+      failed: number;
+      passed: number;
+      total: number;
+      runtime: number;
+    }
+    interface LogDetails {
+      result: boolean;
+      actual: any;
+      expected: any;
+      message: string;
+      source: string;
+      module: string;
+      name: string;
+      runtime: number;
+    }
+    interface ModuleDoneDetails {
+      name: string;
+      failed: number;
+      passed: number;
+      total: number;
+      runtime: number;
+    }
+    interface ModuleStartDetails {
+      name: string;
+    }
+    interface TestDoneDetails {
+      name: string;
+      module: string;
+      failed: number;
+      passed: number;
+      total: number;
+      runtime: number;
+    }
+    interface TestStartDetails {
+      name: string;
+      module: string;
+    }
+
+    interface Module {
+      name: string;
+      // tests: Array<{ name: string; id: string; skip: boolean }>;
+      // childModules: Module[];
+      // testsRun: number;
+      // testsIgnored: number;
+      // hooks: Hooks;
+      // skip?: boolean;
+      // ignored?: boolean;
+    }
+
+    interface TestBase {
+      testId: string;
+      testName: string;
+      expected: null | number;
+      // assertions: Array<{ result: boolean; message: string }>;
+      module: Module;
+      // steps: unknown[];
+      // timeout: undefined;
+      // data: unknown;
+      // withData: boolean;
+      // pauses: Map<string, unknown>;
+      // nextPauseId: 1;
+      // stackOffset: 0 | 1 | 2 | 3 | 5;
+      // errorForStack: Error;
+      // testReport: unknown;
+      // stack: string;
+      // before: () => unknown;
+      // run: () => unknown;
+      // after: () => void;
+      // queueGlobalHook: (hook: unknown, hookName: unknown) => () => unknown;
+      // queueHook: (
+      //   hook: unknown,
+      //   hookName: unknown,
+      //   hookOwner: unknown
+      // ) => () => unknown;
+      // hooks: (handler: unknown) => unknown;
+      finish: () => unknown;
+      // preserveTestEnvironment: () => unknown;
+      // queue: () => void;
+      // pushResult: (resultInfo: unknown) => void;
+      pushFailure: (message: string, source: string, actual: unknown) => void;
+      skip?: true;
+      // callback: ((assert: Assert) => void) | ((assert: Assert) => Promise<void>);
+      todo?: boolean;
+      async?: boolean;
+    }
+
+    interface AssertionTest extends TestBase {
+      assert: Assert;
+    }
+
+    interface SkipTest extends TestBase {
+      skip: true;
+      async: false;
+    }
+
+    interface TodoTest extends TestBase {
+      todo: true;
+      assert: Assert;
+    }
+
+    type Test = AssertionTest | SkipTest | TodoTest;
+  }
+
+  interface Reporter {
+    init(runner: Runner, options: { log: Console['log'] }): void;
+  }
+
+  interface QUnit {
+    reporters: {
+      tap: Reporter;
+    };
+
+    /**
+     * Namespace for QUnit assertions
+     *
+     * QUnit's built-in assertions are defined on the `QUnit.assert` object. An
+     * instance of this object is passed as the only argument to the `QUnit.test`
+     * function callback.
+     *
+     * This object has properties for each of QUnit's built-in assertion methods.
+     */
+    assert: Assert;
+
+    /**
+     * Register a callback to fire whenever the test suite begins.
+     *
+     * `QUnit.begin()` is called once before running any tests.
+     *
+     * callback Callback to execute.
+     */
+    begin(callback: (details: QUnit.BeginDetails) => void | Promise<void>): void;
+
+    /**
+     * Configuration for QUnit
+     *
+     * QUnit has a bunch of internal configuration defaults, some of which are
+     * useful to override. Check the description for each option for details.
+     */
+    config: Config;
+
+    /**
+     * Register a callback to fire whenever the test suite ends.
+     *
+     * @param callback Callback to execute
+     */
+    done(callback: (details: QUnit.DoneDetails) => void | Promise<void>): void;
+
+    /**
+     * Advanced and extensible data dumping for JavaScript.
+     *
+     * This method does string serialization by parsing data structures and
+     * objects. It parses DOM elements to a string representation of their outer
+     * HTML. By default, nested structures will be displayed up to five levels
+     * deep. Anything beyond that is replaced by `[object Object]` and
+     * `[object Array]` placeholders.
+     *
+     * If you need more or less output, change the value of `QUnit.dump.maxDepth`,
+     * representing how deep the elements should be parsed.
+     *
+     * Note: This method used to be in QUnit.jsDump, which was changed to
+     * QUnit.dump. The old property will be removed in QUnit 3.0.
+     */
+    dump: {
+      maxDepth: number;
+      parse(data: any): string;
+    };
+
+    /**
+     * Copy the properties defined by the `mixin` object into the `target` object.
+     *
+     * This method will modify the `target` object to contain the "own" properties
+     * defined by the `mixin`. If the `mixin` object specifies the value of any
+     * attribute as undefined, this property will instead be removed from the
+     * `target` object.
+     *
+     * @param target An object whose properties are to be modified
+     * @param mixin An object describing which properties should be modified
+     */
+    extend(target: any, mixin: any): void;
+
+    /**
+     * Register a global callback to run before or after each test.
+     *
+     * This is the equivalent of applying a QUnit.module() hook to all modules
+     * and all tests, including global tests that are not associated with any module.
+     *
+     * Similar to module hooks, global hooks support async functions or
+     * returning a Promise, which will be waited for before QUnit continues executing tests.
+     * Each global hook also has access to the same assert object and
+     * test context as the QUnit.test that the hook is running for.
+     *
+     * For more details about hooks, refer to QUnit.module § Hooks.
+     */
+    hooks: GlobalHooks;
+
+    /**
+     * Register a callback to fire whenever an assertion completes.
+     *
+     * This is one of several callbacks QUnit provides. Its intended for
+     * integration scenarios like PhantomJS or Jenkins. The properties of the
+     * details argument are listed below as options.
+     *
+     * @param callback Callback to execute
+     */
+    log(callback: (details: QUnit.LogDetails) => void): void;
+
+    /**
+     * Group related tests under a single label.
+     *
+     * You can use the module name to organize, select, and filter tests to run.
+     *
+     * All tests inside a module callback function will be grouped into that
+     * module. The test names will all be preceded by the module name in the
+     * test results. Other modules can be nested inside this callback function,
+     * where their tests' names will be labeled by their names recursively
+     * prefixed by their parent modules.
+     *
+     * If `QUnit.module` is defined without a `nested` callback argument, all
+     * subsequently defined tests will be grouped into the module until another
+     * module is defined.
+     *
+     * Modules with test group functions allow you to define nested modules, and
+     * QUnit will run tests on the parent module before going deep on the nested
+     * ones, even if they're declared first. Additionally, any hook callbacks on
+     * a parent module will wrap the hooks on a nested module. In other words,
+     * `before` and `beforeEach` callbacks will form a queue while the
+     * `afterEach` and `after` callbacks will form a stack.
+     *
+     * You can specify code to run before and after tests using the hooks
+     * argument, and also to create properties that will be shared on the
+     * testing context. Any additional properties on the `hooks` object will be
+     * added to that context. The `hooks` argument is still optional if you call
+     * `QUnit.module` with a callback argument.
+     *
+     * The module's callback is invoked with the test environment as its `this`
+     * context, with the environment's properties copied to the module's tests,
+     * hooks, and nested modules. Note that changes on tests' `this` are not
+     * preserved between sibling tests, where `this` will be reset to the initial
+     * value for each test.
+     *
+     * @param {string} name Label for this group of tests
+     * @param hookds Callbacks to run during test execution
+     * @param nested A callback with grouped tests and nested modules to run under the current module label
+     */
+    module: ModuleFunc1 & ModuleFunc2 & ModuleOnly & ModuleSkip & ModuleTodo;
+
+    /**
+     * Register a callback to fire whenever a module ends.
+     *
+     * @param callback Callback to execute
+     */
+    moduleDone(callback: (details: QUnit.ModuleDoneDetails) => void | Promise<void>): void;
+
+    /**
+     * Register a callback to fire whenever a module begins.
+     *
+     * @param callback Callback to execute
+     */
+    moduleStart(callback: (details: QUnit.ModuleStartDetails) => void | Promise<void>): void;
+
+    /**
+     * Adds a test to exclusively run, preventing all other tests from running.
+     *
+     * Use this method to focus your test suite on a specific test. QUnit.only
+     * will cause any other tests in your suite to be ignored.
+     *
+     * Note, that if more than one QUnit.only is present only the first instance
+     * will run.
+     *
+     * This is an alternative to filtering tests to run in the HTML reporter. It
+     * is especially useful when you use a console reporter or in a codebase
+     * with a large set of long running tests.
+     *
+     * @param {string} name Title of unit being tested
+     * @param callback Function to close over assertions
+     */
+    only(name: string, callback: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Handle a global error that should result in a failed test run.
+     *
+     * @since 2.17.0
+     * @param {Error|any} error
+     */
+    onUncaughtException: (error: unknown) => void;
+
+    /**
+     * DEPRECATED: Report the result of a custom assertion.
+     *
+     * This method is deprecated and it's recommended to use pushResult on its
+     * direct reference in the assertion context.
+     *
+     * QUnit.push reflects to the current running test, and it may leak
+     * assertions in asynchronous mode. Checkout assert.pushResult() to set a
+     * proper custom assertion.
+     *
+     * Invoking QUnit.push allows to create a readable expectation that is not
+     * defined by any of QUnit's built-in assertions.
+     *
+     * @deprecated
+     */
+    push(result: boolean, actual: any, expected: any, message: string): void;
+
+    /**
+     * Adds a test like object to be skipped.
+     *
+     * Use this method to replace QUnit.test() instead of commenting out entire
+     * tests.
+     *
+     * This test's prototype will be listed on the suite as a skipped test,
+     * ignoring the callback argument and the respective global and module's
+     * hooks.
+     *
+     * @param {string} Title of unit being tested
+     */
+    skip(name: string, callback?: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Returns a single line string representing the stacktrace (call stack).
+     *
+     * This method returns a single line string representing the stacktrace from
+     * where it was called. According to its offset argument, `QUnit.stack()` will
+     * return the correspondent line from the call stack.
+     *
+     * The default `offset` is `0` and will return the current location where it
+     * was called.
+     *
+     * Not all browsers support retrieving stracktraces. In those, `QUnit.stack()`
+     * will return undefined.
+     *
+     * @param {number} offset Set the stacktrace line offset.
+     */
+    stack(offset?: number): string;
+
+    /**
+     * `QUnit.start()` must be used to start a test run that has
+     * `QUnit.config.autostart` set to `false`.
+     *
+     * This method was previously used to control async tests on text contexts
+     * along with QUnit.stop. For asynchronous tests, use assert.async instead.
+     *
+     * When your async test has multiple exit points, call `QUnit.start()` for the
+     * corresponding number of `QUnit.stop()` increments.
+     */
+    start(): void;
+
+    /**
+     * Add a test to run.
+     *
+     * Add a test to run using `QUnit.test()`.
+     *
+     * The `assert` argument to the callback contains all of QUnit's assertion
+     * methods. Use this argument to call your test assertions.
+     *
+     * `QUnit.test()` can automatically handle the asynchronous resolution of a
+     * Promise on your behalf if you return a thenable Promise as the result of
+     * your callback function.
+     *
+     * @param {string} Title of unit being tested
+     * @param callback Function to close over assertions
+     */
+    test(this: void, name: string, callback: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Register a callback to fire whenever a test ends.
+     *
+     * @param callback Callback to execute
+     */
+    testDone(
+      callback: (details: {
+        name: string;
+        module: string;
+        failed: number;
+        passed: number;
+        total: number;
+        runtime: number;
+      }) => void | Promise<void>
+    ): void;
+
+    /**
+     * Register a callback to fire whenever a test begins.
+     *
+     * @param callback Callback to execute
+     */
+    testStart(callback: (details: QUnit.TestStartDetails) => void | Promise<void>): void;
+
+    /**
+     * Adds a test which expects at least one failing assertion during its run.
+     *
+     * Use this method to test a unit of code which is still under development
+     * (in a “todo” state). The test will pass as long as one failing assertion
+     * is present.
+     *
+     * If all assertions pass, then the test will fail signaling that QUnit.todo
+     * should be replaced by QUnit.test.
+     *
+     * @param {string} Title of unit being tested
+     * @param callback Function to close over assertions
+     */
+    todo(name: string, callback?: (assert: Assert) => void | Promise<void>): void;
+
+    /**
+     * Compares two values. Returns true if they are equivalent.
+     *
+     * @param a The first value
+     * @param b The second value
+     */
+    equiv<T>(a: T, b: T): boolean;
+
+    /**
+     * Are the test running from the server or not.
+     */
+    isLocal: boolean;
+
+    /**
+     * QUnit version
+     */
+    version: string;
+
+    urlParams: Record<string, unknown>;
+  }
+
+  /* QUnit */
+  const QUnit: QUnit;
+}
+
+export = QUnit;
diff --git a/packages/@types/qunit/package.json b/packages/@types/qunit/package.json
new file mode 100644
index 0000000000..97ed97c5b2
--- /dev/null
+++ b/packages/@types/qunit/package.json
@@ -0,0 +1,6 @@
+{
+  "name": "@types/qunit",
+  "version": "2.19.7",
+  "type": "module",
+  "types": "index.d.ts"
+}
diff --git a/packages/@types/tsconfig.json b/packages/@types/tsconfig.json
index a3ccd3190b..32f8600125 100644
--- a/packages/@types/tsconfig.json
+++ b/packages/@types/tsconfig.json
@@ -4,6 +4,7 @@
     // Compilation Configuration
     "lib": ["esnext", "DOM", "DOM.Iterable"],
     "allowJs": true,
+    "checkJs": true,
     "inlineSources": true,
     "inlineSourceMap": true,
     "declaration": true,
@@ -15,9 +16,8 @@
     "verbatimModuleSyntax": true,
 
     // Environment Configuration
-    "experimentalDecorators": true,
-    "target": "es2020",
-    "module": "ESNext",
+    "target": "esnext",
+    "module": "esnext",
     "moduleResolution": "bundler",
 
     // Enhance Strictness
diff --git a/packages/package.json b/packages/package.json
index 7e88769d55..048694ac71 100644
--- a/packages/package.json
+++ b/packages/package.json
@@ -1,7 +1,7 @@
 {
   "private": true,
-  "dependencies": {
-    "@types/qunit": "^2.19.7",
+  "devDependencies": {
+    "@types/qunit": "workspace:^",
     "vite": "^4.3.9"
   }
 }
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index b738156ae2..5671c233dc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -1,9 +1,13 @@
 lockfileVersion: '6.0'
 
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
 overrides:
-  typescript: ^5.0.4
+  typescript: ^5.2.2
   '@rollup/pluginutils': ^5.0.2
-  '@types/node': ^18.16.6
+  '@types/node': ^20.8.10
 
 patchedDependencies:
   '@release-it-plugins/workspaces@4.0.0':
@@ -14,30 +18,33 @@ importers:
 
   .:
     devDependencies:
+      '@babel/plugin-proposal-decorators':
+        specifier: ^7.23.2
+        version: 7.23.2(@babel/core@7.23.2)
       '@babel/plugin-syntax-dynamic-import':
         specifier: ^7.8.3
         version: 7.8.3(@babel/core@7.23.2)
       '@babel/plugin-transform-modules-commonjs':
-        specifier: ^7.21.5
-        version: 7.21.5(@babel/core@7.23.2)
+        specifier: ^7.23.0
+        version: 7.23.0(@babel/core@7.23.2)
       '@babel/plugin-transform-runtime':
-        specifier: ^7.21.4
-        version: 7.21.4(@babel/core@7.23.2)
+        specifier: ^7.23.2
+        version: 7.23.2(@babel/core@7.23.2)
       '@babel/preset-env':
-        specifier: ^7.21.5
-        version: 7.21.5(@babel/core@7.23.2)
+        specifier: ^7.23.2
+        version: 7.23.2(@babel/core@7.23.2)
       '@babel/preset-typescript':
-        specifier: ^7.21.5
-        version: 7.21.5(@babel/core@7.23.2)
+        specifier: ^7.23.2
+        version: 7.23.2(@babel/core@7.23.2)
       '@babel/runtime':
-        specifier: ^7.21.5
-        version: 7.21.5
+        specifier: ^7.23.2
+        version: 7.23.2
       '@babel/traverse':
-        specifier: ^7.21.5
-        version: 7.21.5
+        specifier: ^7.23.2
+        version: 7.23.2
       '@babel/types':
-        specifier: ^7.21.5
-        version: 7.21.5
+        specifier: ^7.23.0
+        version: 7.23.0
       '@glimmer-workspace/build-support':
         specifier: workspace:^
         version: link:packages/@glimmer-workspace/build
@@ -57,35 +64,38 @@ importers:
         specifier: ^4.0.0
         version: 4.0.0(patch_hash=lhefrznz336tkf55irfqm4hld4)(release-it@16.2.1)
       '@rollup/plugin-terser':
-        specifier: ^0.4.1
-        version: 0.4.1(rollup@3.21.6)
+        specifier: ^0.4.4
+        version: 0.4.4(rollup@4.3.0)
       '@types/babel-plugin-macros':
-        specifier: ^3.1.0
-        version: 3.1.0
+        specifier: ^3.1.2
+        version: 3.1.2
       '@types/babel__core':
-        specifier: ^7.20.0
-        version: 7.20.0
+        specifier: ^7.20.3
+        version: 7.20.3
       '@types/babel__traverse':
-        specifier: ^7.18.5
-        version: 7.18.5
+        specifier: ^7.20.3
+        version: 7.20.3
       '@types/eslint':
-        specifier: ^8.37.0
-        version: 8.37.0
+        specifier: ^8.44.6
+        version: 8.44.6
       '@types/node':
-        specifier: ^18.16.6
-        version: 18.16.6
-      '@types/preval.macro':
-        specifier: ^3.0.0
-        version: 3.0.0
+        specifier: ^20.8.10
+        version: 20.8.10
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:packages/@types/qunit
       '@typescript-eslint/eslint-plugin':
-        specifier: ^5.59.5
-        version: 5.59.5(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4)
+        specifier: ^6.9.1
+        version: 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2)
       '@typescript-eslint/parser':
-        specifier: ^5.59.5
-        version: 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+        specifier: ^6.9.1
+        version: 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      '@vitejs/plugin-react':
+        specifier: ^4.1.1
+        version: 4.1.1(vite@4.5.0)
+      '@vitejs/plugin-react-swc':
+        specifier: ^3.4.1
+        version: 3.4.1(vite@4.5.0)
       amd-name-resolver:
         specifier: ^1.3.1
         version: 1.3.1
@@ -99,17 +109,14 @@ importers:
         specifier: ^0.1.1
         version: 0.1.1
       chalk:
-        specifier: ^5.2.0
-        version: 5.2.0
+        specifier: ^5.3.0
+        version: 5.3.0
       dag-map:
         specifier: ^2.0.2
         version: 2.0.2
       dotenv-cli:
-        specifier: ^7.2.1
-        version: 7.2.1
-      ember-cli:
-        specifier: ~4.12.1
-        version: 4.12.1
+        specifier: ^7.3.0
+        version: 7.3.0
       ember-cli-browserstack:
         specifier: ^2.0.1
         version: 2.0.1
@@ -117,38 +124,41 @@ importers:
         specifier: ^1.1.1
         version: 1.1.1
       eslint:
-        specifier: ^8.40.0
-        version: 8.40.0
+        specifier: ^8.53.0
+        version: 8.53.0
       eslint-config-prettier:
-        specifier: ^8.8.0
-        version: 8.8.0(eslint@8.40.0)
+        specifier: ^9.0.0
+        version: 9.0.0(eslint@8.53.0)
       eslint-import-resolver-typescript:
-        specifier: ^3.5.5
-        version: 3.5.5(@typescript-eslint/parser@5.59.5)(eslint-plugin-import@2.27.5)(eslint@8.40.0)
+        specifier: ^3.6.1
+        version: 3.6.1(@typescript-eslint/parser@6.9.1)(eslint-plugin-i@2.28.1)(eslint@8.53.0)
       eslint-plugin-import:
-        specifier: ^2.27.5
-        version: 2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
+        specifier: npm:eslint-plugin-i@^2.28.1
+        version: /eslint-plugin-i@2.28.1(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint@8.53.0)
       eslint-plugin-n:
-        specifier: ^15.7.0
-        version: 15.7.0(eslint@8.40.0)
+        specifier: ^16.2.0
+        version: 16.2.0(eslint@8.53.0)
       eslint-plugin-qunit:
-        specifier: ^7.3.4
-        version: 7.3.4(eslint@8.40.0)
+        specifier: ^8.0.1
+        version: 8.0.1(eslint@8.53.0)
       eslint-plugin-simple-import-sort:
         specifier: ^10.0.0
-        version: 10.0.0(eslint@8.40.0)
+        version: 10.0.0(eslint@8.53.0)
       eslint-plugin-unused-imports:
-        specifier: ^2.0.0
-        version: 2.0.0(@typescript-eslint/eslint-plugin@5.59.5)(eslint@8.40.0)
+        specifier: ^3.0.0
+        version: 3.0.0(@typescript-eslint/eslint-plugin@6.9.1)(eslint@8.53.0)
+      esyes:
+        specifier: ^1.0.1
+        version: 1.0.1
       execa:
-        specifier: ^7.1.1
-        version: 7.1.1
+        specifier: ^8.0.1
+        version: 8.0.1
       fast-glob:
-        specifier: ^3.2.12
-        version: 3.2.12
+        specifier: ^3.3.1
+        version: 3.3.1
       glob:
-        specifier: ^10.2.3
-        version: 10.2.3
+        specifier: ^10.3.10
+        version: 10.3.10
       js-yaml:
         specifier: ^4.1.0
         version: 4.1.0
@@ -162,32 +172,32 @@ importers:
         specifier: ^4.1.5
         version: 4.1.5
       prettier:
-        specifier: ^2.8.8
-        version: 2.8.8
-      preval.macro:
-        specifier: ^5.0.0
-        version: 5.0.0
+        specifier: ^3.0.3
+        version: 3.0.3
+      prettier-plugin-organize-imports:
+        specifier: ^3.2.3
+        version: 3.2.3(prettier@3.0.3)(typescript@5.2.2)
       puppeteer:
-        specifier: ^20.1.2
-        version: 20.1.2(typescript@5.0.4)
+        specifier: ^21.5.0
+        version: 21.5.0(typescript@5.2.2)
       puppeteer-chromium-resolver:
-        specifier: ^20.0.0
-        version: 20.0.0(typescript@5.0.4)
+        specifier: ^21.0.0
+        version: 21.0.0
       qunit:
-        specifier: ^2.19.4
-        version: 2.19.4
+        specifier: ^2.20.0
+        version: 2.20.0
       release-it:
         specifier: ^16.2.1
-        version: 16.2.1(typescript@5.0.4)
+        version: 16.2.1(typescript@5.2.2)
       rimraf:
-        specifier: ^5.0.0
-        version: 5.0.0
+        specifier: ^5.0.5
+        version: 5.0.5
       rollup:
-        specifier: ^3.21.6
-        version: 3.21.6
+        specifier: ^4.3.0
+        version: 4.3.0
       semver:
-        specifier: ^7.5.2
-        version: 7.5.2
+        specifier: ^7.5.4
+        version: 7.5.4
       testem-failure-only-reporter:
         specifier: ^1.0.0
         version: 1.0.0
@@ -196,19 +206,22 @@ importers:
         version: 3.0.0
       ts-node:
         specifier: ^10.9.1
-        version: 10.9.1(@types/node@18.16.6)(typescript@5.0.4)
+        version: 10.9.1(@types/node@20.8.10)(typescript@5.2.2)
       turbo:
-        specifier: ^1.9.3
-        version: 1.9.3
+        specifier: ^1.10.16
+        version: 1.10.16
       typescript:
-        specifier: ^5.0.4
-        version: 5.0.4
+        specifier: ^5.2.2
+        version: 5.2.2
       vite:
-        specifier: ^4.3.9
-        version: 4.3.9(@types/node@18.16.6)
+        specifier: ^4.5.0
+        version: 4.5.0(@types/node@20.8.10)
+      vite-plugin-babel:
+        specifier: ^1.1.3
+        version: 1.1.3(@babel/core@7.23.2)(vite@4.5.0)
       xo:
-        specifier: ^0.54.2
-        version: 0.54.2(eslint-import-resolver-typescript@3.5.5)(webpack@5.88.2)
+        specifier: ^0.56.0
+        version: 0.56.0(@types/eslint@8.44.6)(eslint-import-resolver-typescript@3.6.1)(webpack@5.82.1)
 
   benchmark:
     dependencies:
@@ -254,7 +267,7 @@ importers:
         version: 3.21.6
       rollup-plugin-sourcemaps:
         specifier: ^0.6.3
-        version: 0.6.3(@types/node@18.16.6)(rollup@3.21.6)
+        version: 0.6.3(@types/node@20.8.10)(rollup@3.21.6)
       symlink-or-copy:
         specifier: ^1.3.1
         version: 1.3.1
@@ -281,11 +294,11 @@ importers:
         version: 1.4.0
     devDependencies:
       '@types/node':
-        specifier: ^18.16.6
-        version: 18.16.6
+        specifier: ^20.8.10
+        version: 20.8.10
       vite:
         specifier: ^4.3.9
-        version: 4.3.9(@types/node@18.16.6)
+        version: 4.3.9(@types/node@20.8.10)
 
   bin:
     dependencies:
@@ -296,8 +309,8 @@ importers:
         specifier: ^4.0.5
         version: 4.0.5
       '@types/node':
-        specifier: ^18.16.6
-        version: 18.16.6
+        specifier: ^20.8.10
+        version: 20.8.10
       '@types/puppeteer-chromium-resolver':
         specifier: workspace:^
         version: link:../packages/@types/puppeteer-chromium-resolver
@@ -315,7 +328,7 @@ importers:
         version: 4.1.0
       puppeteer-chromium-resolver:
         specifier: ^20.0.0
-        version: 20.0.0(typescript@5.0.4)
+        version: 20.0.0(typescript@5.2.2)
     devDependencies:
       esno:
         specifier: ^0.16.3
@@ -325,7 +338,7 @@ importers:
     dependencies:
       fs-extra:
         specifier: '*'
-        version: 11.1.1
+        version: 9.0.0
       glimmer-benchmark:
         specifier: '*'
         version: link:../../benchmark
@@ -335,13 +348,13 @@ importers:
 
   packages:
 
-    dependencies:
+    devDependencies:
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:@types/qunit
       vite:
         specifier: ^4.3.9
-        version: 4.3.9(@types/node@18.16.6)
+        version: 4.3.9(@types/node@20.8.10)
 
   packages/@glimmer-workspace/benchmark-env:
     dependencies:
@@ -376,100 +389,115 @@ importers:
   packages/@glimmer-workspace/build:
     dependencies:
       '@rollup/plugin-commonjs':
-        specifier: ^24.1.0
-        version: 24.1.0(rollup@3.21.6)
+        specifier: ^25.0.4
+        version: 25.0.7(rollup@3.28.0)
       '@rollup/plugin-node-resolve':
-        specifier: ^15.0.2
-        version: 15.0.2(rollup@3.21.6)
+        specifier: ^15.2.0
+        version: 15.2.0(rollup@3.28.0)
       eslint:
         specifier: ^8.40.0
-        version: 8.40.0
+        version: 8.47.0
       eslint-plugin-import:
         specifier: ^2.27.5
-        version: 2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
+        version: 2.28.1(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint@8.47.0)
       eslint-plugin-json:
         specifier: ^3.1.0
         version: 3.1.0
       eslint-plugin-prettier:
         specifier: ^4.2.1
-        version: 4.2.1(eslint-config-prettier@8.8.0)(eslint@8.40.0)(prettier@2.8.8)
+        version: 4.2.1(eslint-config-prettier@9.0.0)(eslint@8.47.0)(prettier@3.0.3)
       eslint-plugin-simple-import-sort:
         specifier: ^10.0.0
-        version: 10.0.0(eslint@8.40.0)
+        version: 10.0.0(eslint@8.47.0)
       eslint-plugin-unused-imports:
-        specifier: ^2.0.0
-        version: 2.0.0(@typescript-eslint/eslint-plugin@5.59.5)(eslint@8.40.0)
+        specifier: ^3.0.0
+        version: 3.0.0(@typescript-eslint/eslint-plugin@6.9.1)(eslint@8.47.0)
       magic-string:
-        specifier: ^0.30.0
-        version: 0.30.0
+        specifier: ^0.30.3
+        version: 0.30.3
       postcss:
         specifier: ^8.4.31
         version: 8.4.31
       rollup:
-        specifier: ^3.21.6
-        version: 3.21.6
+        specifier: ^3.28.0
+        version: 3.28.0
       rollup-plugin-polyfill-node:
         specifier: ^0.12.0
-        version: 0.12.0(rollup@3.21.6)
+        version: 0.12.0(rollup@3.28.0)
       rollup-plugin-postcss:
         specifier: ^4.0.2
         version: 4.0.2(postcss@8.4.31)(ts-node@10.9.1)
       rollup-plugin-ts:
-        specifier: ^3.2.0
-        version: 3.2.0(@babel/core@7.23.2)(@babel/plugin-transform-runtime@7.21.4)(@babel/preset-env@7.21.5)(@babel/preset-typescript@7.21.5)(@babel/runtime@7.21.5)(rollup@3.21.6)(typescript@5.0.4)
+        specifier: ^3.4.4
+        version: 3.4.4(@babel/core@7.23.2)(@babel/plugin-transform-runtime@7.23.2)(@babel/preset-env@7.23.2)(@babel/preset-typescript@7.23.2)(@babel/runtime@7.23.2)(rollup@3.28.0)(typescript@5.2.2)
       unplugin-fonts:
         specifier: ^1.0.3
-        version: 1.0.3(vite@4.3.9)
+        version: 1.0.3(vite@4.4.9)
       vite:
-        specifier: 4.3.9
-        version: 4.3.9(@types/node@18.16.6)
+        specifier: 4.4.9
+        version: 4.4.9(@types/node@20.8.10)
     devDependencies:
       '@types/node':
-        specifier: ^18.16.6
-        version: 18.16.6
+        specifier: ^20.8.10
+        version: 20.8.10
       typescript:
-        specifier: ^5.0.4
-        version: 5.0.4
+        specifier: ^5.2.2
+        version: 5.2.2
 
   packages/@glimmer-workspace/eslint-plugin:
     dependencies:
       '@typescript-eslint/eslint-plugin':
-        specifier: ^5.59.5
-        version: 5.59.5(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4)
+        specifier: ^6.4.0
+        version: 6.9.0(@typescript-eslint/parser@6.9.0)(eslint@8.47.0)(typescript@5.2.2)
       '@typescript-eslint/parser':
-        specifier: ^5.59.5
-        version: 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+        specifier: ^6.4.0
+        version: 6.9.0(eslint@8.47.0)(typescript@5.2.2)
       eslint-config-prettier:
-        specifier: ^8.8.0
-        version: 8.8.0(eslint@8.40.0)
+        specifier: ^9.0.0
+        version: 9.0.0(eslint@8.47.0)
       eslint-import-resolver-typescript:
-        specifier: ^3.5.5
-        version: 3.5.5(@typescript-eslint/parser@5.59.5)(eslint-plugin-import@2.27.5)(eslint@8.40.0)
+        specifier: ^3.6.0
+        version: 3.6.0(@typescript-eslint/parser@6.9.0)(eslint-plugin-import@2.28.1)(eslint@8.47.0)
+      eslint-plugin-deprecation:
+        specifier: ^1.5.0
+        version: 1.6.0(eslint@8.47.0)(typescript@5.2.2)
       eslint-plugin-import:
-        specifier: ^2.27.5
-        version: 2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
+        specifier: ^2.28.0
+        version: 2.28.1(@typescript-eslint/parser@6.9.0)(eslint-import-resolver-typescript@3.6.0)(eslint@8.47.0)
       eslint-plugin-n:
-        specifier: ^15.7.0
-        version: 15.7.0(eslint@8.40.0)
+        specifier: ^16.0.1
+        version: 16.2.0(eslint@8.47.0)
       eslint-plugin-qunit:
-        specifier: ^7.3.4
-        version: 7.3.4(eslint@8.40.0)
+        specifier: ^8.0.0
+        version: 8.0.1(eslint@8.47.0)
       eslint-plugin-regexp:
         specifier: ^1.15.0
-        version: 1.15.0(eslint@8.40.0)
+        version: 1.15.0(eslint@8.47.0)
       eslint-plugin-simple-import-sort:
         specifier: ^10.0.0
-        version: 10.0.0(eslint@8.40.0)
+        version: 10.0.0(eslint@8.47.0)
       eslint-plugin-unused-imports:
-        specifier: ^2.0.0
-        version: 2.0.0(@typescript-eslint/eslint-plugin@5.59.5)(eslint@8.40.0)
+        specifier: ^3.0.0
+        version: 3.0.0(@typescript-eslint/eslint-plugin@6.9.0)(eslint@8.47.0)
+      eslint-utils:
+        specifier: ^3.0.0
+        version: 3.0.0(eslint@8.47.0)
+      ignore:
+        specifier: ^5.2.4
+        version: 5.2.4
     devDependencies:
       '@types/eslint':
-        specifier: ^8.37.0
-        version: 8.37.0
+        specifier: ^8.44.2
+        version: 8.44.2
+      '@types/eslint-utils':
+        specifier: ^3.0.4
+        version: 3.0.4
+      '@types/node':
+        specifier: ^20.8.10
+        version: 20.8.10
       eslint:
-        specifier: ^8.40.0
-        version: 8.40.0
+        specifier: ^8.47.0
+        version: 8.47.0
 
   packages/@glimmer-workspace/integration-tests:
     dependencies:
@@ -550,8 +578,53 @@ importers:
         specifier: workspace:^
         version: link:../../@types/js-reporters
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:../../@types/qunit
+
+  packages/@glimmer-workspace/integration-tests/test:
+    dependencies:
+      '@glimmer-workspace/integration-tests':
+        specifier: workspace:^
+        version: link:..
+      '@glimmer/compiler':
+        specifier: workspace:^
+        version: link:../../../@glimmer/compiler
+      '@glimmer/destroyable':
+        specifier: workspace:^
+        version: link:../../../@glimmer/destroyable
+      '@glimmer/global-context':
+        specifier: workspace:^
+        version: link:../../../@glimmer/global-context
+      '@glimmer/interfaces':
+        specifier: workspace:^
+        version: link:../../../@glimmer/interfaces
+      '@glimmer/local-debug-flags':
+        specifier: workspace:^
+        version: link:../../../@glimmer/local-debug-flags
+      '@glimmer/manager':
+        specifier: workspace:^
+        version: link:../../../@glimmer/manager
+      '@glimmer/opcode-compiler':
+        specifier: workspace:^
+        version: link:../../../@glimmer/opcode-compiler
+      '@glimmer/reference':
+        specifier: workspace:^
+        version: link:../../../@glimmer/reference
+      '@glimmer/runtime':
+        specifier: workspace:^
+        version: link:../../../@glimmer/runtime
+      '@glimmer/syntax':
+        specifier: workspace:^
+        version: link:../../../@glimmer/syntax
+      '@glimmer/util':
+        specifier: workspace:^
+        version: link:../../../@glimmer/util
+      '@glimmer/validator':
+        specifier: workspace:^
+        version: link:../../../@glimmer/validator
+      '@glimmer/wire-format':
+        specifier: workspace:^
+        version: link:../../../@glimmer/wire-format
 
   packages/@glimmer-workspace/test-utils:
     dependencies:
@@ -587,8 +660,8 @@ importers:
         specifier: workspace:^
         version: link:../local-debug-flags
       '@types/node':
-        specifier: ^18.16.6
-        version: 18.16.6
+        specifier: ^20.8.10
+        version: 20.8.10
 
   packages/@glimmer/compiler/test:
     dependencies:
@@ -610,6 +683,9 @@ importers:
       '@glimmer/interfaces':
         specifier: workspace:^
         version: link:../interfaces
+      '@glimmer/reference':
+        specifier: workspace:^
+        version: link:../reference
       '@glimmer/util':
         specifier: workspace:^
         version: link:../util
@@ -806,8 +882,8 @@ importers:
         specifier: workspace:^
         version: link:../compiler
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:../../@types/qunit
 
   packages/@glimmer/opcode-compiler:
     dependencies:
@@ -938,6 +1014,9 @@ importers:
       '@glimmer/global-context':
         specifier: workspace:^
         version: link:../../global-context
+      '@glimmer/interfaces':
+        specifier: workspace:^
+        version: link:../../interfaces
       '@glimmer/reference':
         specifier: workspace:^
         version: link:..
@@ -1003,8 +1082,8 @@ importers:
         specifier: workspace:^
         version: link:../opcode-compiler
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:../../@types/qunit
 
   packages/@glimmer/syntax:
     dependencies:
@@ -1031,8 +1110,8 @@ importers:
         specifier: workspace:^
         version: link:../local-debug-flags
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:../../@types/qunit
 
   packages/@glimmer/syntax/test:
     dependencies:
@@ -1068,8 +1147,8 @@ importers:
         specifier: workspace:^
         version: link:../local-debug-flags
       '@types/qunit':
-        specifier: ^2.19.7
-        version: 2.19.7
+        specifier: workspace:^
+        version: link:../../@types/qunit
 
   packages/@glimmer/util/test:
     dependencies:
@@ -1159,16 +1238,29 @@ importers:
     dependencies:
       puppeteer:
         specifier: ^20.1.2
-        version: 20.1.2(typescript@5.0.4)
+        version: 20.1.2(typescript@5.2.2)
+
+  packages/@types/qunit: {}
 
 packages:
 
+  /@aashutoshrathi/word-wrap@1.2.6:
+    resolution: {integrity: sha512-1Yjs2SvM8TflER/OD3cOjhWWOZb58A2t7wpE2S9XfBYTiIl+XFhQG2bjy4Pu1I+EAlCNUzRDYDdFwFYUKvXcIA==}
+    engines: {node: '>=0.10.0'}
+
   /@ampproject/remapping@2.2.1:
     resolution: {integrity: sha512-lFMjJTrFL3j7L9yBxwYfCq2k6qqwHyzuUl/XBnif78PWTJYyL/dfowQHWE3sp6U6ZzqWiiIZnpTMO96zhkjwtg==}
     engines: {node: '>=6.0.0'}
     dependencies:
       '@jridgewell/gen-mapping': 0.3.3
-      '@jridgewell/trace-mapping': 0.3.19
+      '@jridgewell/trace-mapping': 0.3.18
+
+  /@babel/code-frame@7.22.10:
+    resolution: {integrity: sha512-/KKIMG4UEL35WmI9OlvMhurwtytjvXoFcGNrOvyG9zIzA8YmPjVtIZUf7b05+TPO7G7/GEmLHDaoCgACHl9hhA==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/highlight': 7.22.10
+      chalk: 2.4.2
 
   /@babel/code-frame@7.22.13:
     resolution: {integrity: sha512-XktuhWlJ5g+3TJXc5upd9Ks1HutSArik6jf2eAjYFyIOf4ej3RN+184cZbzDvbPnuTJIUhPKKJE3cIsYTiAT3w==}
@@ -1177,6 +1269,10 @@ packages:
       '@babel/highlight': 7.22.20
       chalk: 2.4.2
 
+  /@babel/compat-data@7.22.9:
+    resolution: {integrity: sha512-5UamI7xkUcJ3i9qVDS+KFDEK8/7oJ55/sJMB1Ge7IEapr7KfdfV/HErR+koZwOfd+SgtFKOKRhRakdg++DcJpQ==}
+    engines: {node: '>=6.9.0'}
+
   /@babel/compat-data@7.23.2:
     resolution: {integrity: sha512-0S9TQMmDHlqAZ2ITT95irXKfxN9bncq8ZCoJhun3nHL/lLUxd2NKBJYoNGWH7S0hz6fRQwWlAWn/ILM0C70KZQ==}
     engines: {node: '>=6.9.0'}
@@ -1209,73 +1305,97 @@ packages:
     dependencies:
       '@babel/types': 7.23.0
       '@jridgewell/gen-mapping': 0.3.3
-      '@jridgewell/trace-mapping': 0.3.19
+      '@jridgewell/trace-mapping': 0.3.18
       jsesc: 2.5.2
 
-  /@babel/helper-annotate-as-pure@7.18.6:
-    resolution: {integrity: sha512-duORpUiYrEpzKIop6iNbjnwKLAKnJ47csTyRACyEmWj0QdUrm5aqNJGHSSEQSUAvNW0ojX0dOmK9dZduvkfeXA==}
+  /@babel/helper-annotate-as-pure@7.22.5:
+    resolution: {integrity: sha512-LvBTxu8bQSQkcyKOU+a1btnNFQ1dMAd0R6PyW3arXes06F6QLWLIrd681bxRPIXlrMGR3XYnW9JyML7dP3qgxg==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.23.0
 
-  /@babel/helper-builder-binary-assignment-operator-visitor@7.21.5:
-    resolution: {integrity: sha512-uNrjKztPLkUk7bpCNC0jEKDJzzkvel/W+HguzbN8krA+LPfC1CEobJEvAvGka2A/M+ViOqXdcRL0GqPUJSjx9g==}
+  /@babel/helper-builder-binary-assignment-operator-visitor@7.22.10:
+    resolution: {integrity: sha512-Av0qubwDQxC56DoUReVDeLfMEjYYSN1nZrTUrWkXd7hpU73ymRANkbuDm3yni9npkn+RXy9nNbEJZEzXr7xrfQ==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.23.0
 
+  /@babel/helper-compilation-targets@7.22.10:
+    resolution: {integrity: sha512-JMSwHD4J7SLod0idLq5PKgI+6g/hLD/iuWBq08ZX49xE14VpVEojJ5rHWptpirV2j020MvypRLAXAO50igCJ5Q==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/compat-data': 7.22.9
+      '@babel/helper-validator-option': 7.22.5
+      browserslist: 4.21.10
+      lru-cache: 5.1.1
+      semver: 6.3.1
+
   /@babel/helper-compilation-targets@7.22.15:
     resolution: {integrity: sha512-y6EEzULok0Qvz8yyLkCvVX+02ic+By2UdOhylwUOvOn9dvYc9mKICJuuU1n1XBI02YWsNsnrY1kc6DVbjcXbtw==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/compat-data': 7.23.2
       '@babel/helper-validator-option': 7.22.15
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       lru-cache: 5.1.1
       semver: 6.3.1
 
-  /@babel/helper-create-class-features-plugin@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-yNSEck9SuDvPTEUYm4BSXl6ZVC7yO5ZLEMAhG3v3zi7RDxyL/nQDemWWZmw4L0stPWwhpnznRRyJHPRcbXR2jw==}
+  /@babel/helper-create-class-features-plugin@7.22.10(@babel/core@7.23.2):
+    resolution: {integrity: sha512-5IBb77txKYQPpOEdUdIhBx8VrZyDCQ+H82H0+5dX1TmuscP5vJKEE3cKurjtIw/vFwzbVH48VweE78kVDBrqjA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-annotate-as-pure': 7.18.6
+      '@babel/helper-annotate-as-pure': 7.22.5
+      '@babel/helper-environment-visitor': 7.22.20
+      '@babel/helper-function-name': 7.22.5
+      '@babel/helper-member-expression-to-functions': 7.23.0
+      '@babel/helper-optimise-call-expression': 7.22.5
+      '@babel/helper-replace-supers': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.22.5
+      '@babel/helper-split-export-declaration': 7.22.6
+      semver: 6.3.1
+
+  /@babel/helper-create-class-features-plugin@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-jKkwA59IXcvSaiK2UN45kKwSC9o+KuoXsBDvHvU/7BecYIp8GQ2UwrVvFgJASUT+hBnwJx6MhvMCuMzwZZ7jlg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-annotate-as-pure': 7.22.5
       '@babel/helper-environment-visitor': 7.22.20
       '@babel/helper-function-name': 7.23.0
-      '@babel/helper-member-expression-to-functions': 7.21.5
-      '@babel/helper-optimise-call-expression': 7.18.6
-      '@babel/helper-replace-supers': 7.21.5
-      '@babel/helper-skip-transparent-expression-wrappers': 7.20.0
+      '@babel/helper-member-expression-to-functions': 7.23.0
+      '@babel/helper-optimise-call-expression': 7.22.5
+      '@babel/helper-replace-supers': 7.22.20(@babel/core@7.23.2)
+      '@babel/helper-skip-transparent-expression-wrappers': 7.22.5
       '@babel/helper-split-export-declaration': 7.22.6
       semver: 6.3.1
-    transitivePeerDependencies:
-      - supports-color
 
-  /@babel/helper-create-regexp-features-plugin@7.21.8(@babel/core@7.23.2):
-    resolution: {integrity: sha512-zGuSdedkFtsFHGbexAvNuipg1hbtitDLo2XE8/uf6Y9sOQV1xsYX/2pNbtedp/X0eU1pIt+kGvaqHCowkRbS5g==}
+  /@babel/helper-create-regexp-features-plugin@7.22.9(@babel/core@7.23.2):
+    resolution: {integrity: sha512-+svjVa/tFwsNSG4NEy1h85+HQ5imbT92Q5/bgtS7P0GTQlP8WuFdqsiABmQouhiFGyV66oGxZFpeYHza1rNsKw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-annotate-as-pure': 7.18.6
+      '@babel/helper-annotate-as-pure': 7.22.5
       regexpu-core: 5.3.2
       semver: 6.3.1
 
-  /@babel/helper-define-polyfill-provider@0.3.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-z5aQKU4IzbqCC1XH0nAqfsFLMVSo22SBKUc0BxGrLkolTdPTructy0ToNnlO2zA4j9Q/7pjMZf0DSY+DSTYzww==}
+  /@babel/helper-define-polyfill-provider@0.4.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-WBrLmuPP47n7PNwsZ57pqam6G/RGo1vw/87b0Blc53tZNGZ4x7YvZ6HgQe2vo1W/FR20OgjeZuGXzudPiXHFug==}
     peerDependencies:
-      '@babel/core': ^7.4.0-0
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-compilation-targets': 7.22.15
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-compilation-targets': 7.22.10
+      '@babel/helper-plugin-utils': 7.22.5
       debug: 4.3.4(supports-color@8.1.1)
       lodash.debounce: 4.0.8
-      resolve: 1.22.8
-      semver: 6.3.1
+      resolve: 1.22.4
     transitivePeerDependencies:
       - supports-color
 
@@ -1283,6 +1403,17 @@ packages:
     resolution: {integrity: sha512-zfedSIzFhat/gFhWfHtgWvlec0nqB9YEIVrpuwjruLlXfUSnA8cJB0miHKwqDnQ7d32aKo2xt88/xZptwxbfhA==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-environment-visitor@7.22.5:
+    resolution: {integrity: sha512-XGmhECfVA/5sAt+H+xpSg0mfrHq6FzNr9Oxh7PSEBBRUb/mL7Kz3NICXb194rCqAEdxkhPT1a88teizAFyvk8Q==}
+    engines: {node: '>=6.9.0'}
+
+  /@babel/helper-function-name@7.22.5:
+    resolution: {integrity: sha512-wtHSq6jMRE3uF2otvfuD3DIvVhOsSNshQl0Qrd7qC9oQJzHvOL4qQXlQn2916+CXGywIjpGuIkoyZRRxHPiNQQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/template': 7.22.5
+      '@babel/types': 7.23.0
+
   /@babel/helper-function-name@7.23.0:
     resolution: {integrity: sha512-OErEqsrxjZTJciZ4Oo+eoZqeW9UIiOcuYKRJA4ZAgV9myA+pOXhhmpfNCKjEH/auVfEYVFJ6y1Tc4r0eIApqiw==}
     engines: {node: '>=6.9.0'}
@@ -1296,8 +1427,8 @@ packages:
     dependencies:
       '@babel/types': 7.23.0
 
-  /@babel/helper-member-expression-to-functions@7.21.5:
-    resolution: {integrity: sha512-nIcGfgwpH2u4n9GG1HpStW5Ogx7x7ekiFHbjjFRKXbn5zUvqO9ZgotCO4x1aNbKn/x/xOUaXEhyNHCwtFCpxWg==}
+  /@babel/helper-member-expression-to-functions@7.23.0:
+    resolution: {integrity: sha512-6gfrPwh7OuT6gZyJZvd6WbTfrqAo7vm4xCzAXOusKqq/vWdKXphTpj5klHKNmRUU6/QRGlBsyU9mAIPaWHlqJA==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.23.0
@@ -1308,6 +1439,25 @@ packages:
     dependencies:
       '@babel/types': 7.23.0
 
+  /@babel/helper-module-imports@7.22.5:
+    resolution: {integrity: sha512-8Dl6+HD/cKifutF5qGd/8ZJi84QeAKh+CEe1sBzz8UayBBGg1dAIJrdHOcOM5b2MpzWL2yuotJTtGjETq0qjXg==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/types': 7.23.0
+
+  /@babel/helper-module-transforms@7.22.9(@babel/core@7.23.2):
+    resolution: {integrity: sha512-t+WA2Xn5K+rTeGtC8jCsdAH52bjggG5TKRuRrAGNM/mjIbO4GxvlLMFOEz9wXY5I2XQ60PMFsAG2WIcG82dQMQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-environment-visitor': 7.22.20
+      '@babel/helper-module-imports': 7.22.5
+      '@babel/helper-simple-access': 7.22.5
+      '@babel/helper-split-export-declaration': 7.22.6
+      '@babel/helper-validator-identifier': 7.22.5
+
   /@babel/helper-module-transforms@7.23.0(@babel/core@7.23.2):
     resolution: {integrity: sha512-WhDWw1tdrlT0gMgUJSlX0IQvoO1eN279zrAUbVB+KpV2c3Tylz8+GnKOLllCS6Z/iZQEyVYxhZVUdPTqs2YYPw==}
     engines: {node: '>=6.9.0'}
@@ -1321,8 +1471,8 @@ packages:
       '@babel/helper-split-export-declaration': 7.22.6
       '@babel/helper-validator-identifier': 7.22.20
 
-  /@babel/helper-optimise-call-expression@7.18.6:
-    resolution: {integrity: sha512-HP59oD9/fEHQkdcbgFCnbmgH5vIQTJbxh2yf+CdM89/glUNnuzr87Q8GIjGEnOktTROemO0Pe0iPAYbqZuOUiA==}
+  /@babel/helper-optimise-call-expression@7.22.5:
+    resolution: {integrity: sha512-HBwaojN0xFRx4yIvpwGqxiV2tUfl7401jlok564NgB9EHS1y6QT17FmKWm4ztqjeVdXLuC4fSvHc5ePpQjoTbw==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.23.0
@@ -1331,32 +1481,53 @@ packages:
     resolution: {integrity: sha512-0WDaIlXKOX/3KfBK/dwP1oQGiPh6rjMkT7HIRv7i5RR2VUMwrx5ZL0dwBkKx7+SW1zwNdgjHd34IMk5ZjTeHVg==}
     engines: {node: '>=6.9.0'}
 
-  /@babel/helper-remap-async-to-generator@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-dI7q50YKd8BAv3VEfgg7PS7yD3Rtbi2J1XMXaalXO0W0164hYLnh8zpjRS0mte9MfVp/tltvr/cfdXPvJr1opA==}
+  /@babel/helper-plugin-utils@7.22.5:
+    resolution: {integrity: sha512-uLls06UVKgFG9QD4OeFYLEGteMIAa5kpTPcFL28yuCIIzsf6ZyKZMllKVOCZFhiZ5ptnwX4mtKdWCBE/uT4amg==}
+    engines: {node: '>=6.9.0'}
+
+  /@babel/helper-remap-async-to-generator@7.22.20(@babel/core@7.23.2):
+    resolution: {integrity: sha512-pBGyV4uBqOns+0UvhsTO8qgl8hO89PmiDYv+/COyp1aeMcmfrfruz+/nCMFiYyFF/Knn0yfrC85ZzNFjembFTw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-annotate-as-pure': 7.18.6
+      '@babel/helper-annotate-as-pure': 7.22.5
       '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-wrap-function': 7.20.5
-      '@babel/types': 7.23.0
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-wrap-function': 7.22.20
 
-  /@babel/helper-replace-supers@7.21.5:
-    resolution: {integrity: sha512-/y7vBgsr9Idu4M6MprbOVUfH3vs7tsIfnVWv/Ml2xgwvyH6LTngdfbf5AdsKwkJy4zgy1X/kuNrEKvhhK28Yrg==}
+  /@babel/helper-remap-async-to-generator@7.22.9(@babel/core@7.23.2):
+    resolution: {integrity: sha512-8WWC4oR4Px+tr+Fp0X3RHDVfINGpF3ad1HIbrc8A77epiR6eMMc6jsgozkzT2uDiOOdoS9cLIQ+XD2XvI2WSmQ==}
     engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
     dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-annotate-as-pure': 7.22.5
       '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-member-expression-to-functions': 7.21.5
-      '@babel/helper-optimise-call-expression': 7.18.6
-      '@babel/template': 7.22.15
-      '@babel/traverse': 7.23.2
-      '@babel/types': 7.23.0
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-wrap-function': 7.22.10
+
+  /@babel/helper-replace-supers@7.22.20(@babel/core@7.23.2):
+    resolution: {integrity: sha512-qsW0In3dbwQUbK8kejJ4R7IHVGwHJlV6lpG6UA7a9hSa2YEiAib+N1T2kr6PEeUT+Fl7najmSOS6SmAwCHK6Tw==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-environment-visitor': 7.22.20
+      '@babel/helper-member-expression-to-functions': 7.23.0
+      '@babel/helper-optimise-call-expression': 7.22.5
+
+  /@babel/helper-replace-supers@7.22.9(@babel/core@7.23.2):
+    resolution: {integrity: sha512-LJIKvvpgPOPUThdYqcX6IXRuIcTkcAub0IaDRGCZH0p5GPUp7PhRU9QVgFcDDd51BaPkk77ZjqFwh6DZTAEmGg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-environment-visitor': 7.22.20
+      '@babel/helper-member-expression-to-functions': 7.23.0
+      '@babel/helper-optimise-call-expression': 7.22.5
 
   /@babel/helper-simple-access@7.22.5:
     resolution: {integrity: sha512-n0H99E/K+Bika3++WNL17POvo4rKWZ7lZEp1Q+fStVbUi8nxPQEBOlTmCOxW/0JsS56SKKQ+ojAe2pHKJHN35w==}
@@ -1364,8 +1535,8 @@ packages:
     dependencies:
       '@babel/types': 7.23.0
 
-  /@babel/helper-skip-transparent-expression-wrappers@7.20.0:
-    resolution: {integrity: sha512-5y1JYeNKfvnT8sZcK9DVRtpTbGiomYIHviSP3OQWmDPU3DeH4a1ZlT/N2lyQ5P8egjcRaT/Y9aNqUxK0WsnIIg==}
+  /@babel/helper-skip-transparent-expression-wrappers@7.22.5:
+    resolution: {integrity: sha512-tK14r66JZKiC43p8Ki33yLBVJKlQDFoA8GYN67lWCDCqoL6EMMSuM9b+Iff2jHaM/RRFYl7K+iiru7hbRqNx8Q==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/types': 7.23.0
@@ -1384,20 +1555,33 @@ packages:
     resolution: {integrity: sha512-Y4OZ+ytlatR8AI+8KZfKuL5urKp7qey08ha31L8b3BwewJAoJamTzyvxPR/5D+KkdJCGPq/+8TukHBlY10FX9A==}
     engines: {node: '>=6.9.0'}
 
+  /@babel/helper-validator-identifier@7.22.5:
+    resolution: {integrity: sha512-aJXu+6lErq8ltp+JhkJUfk1MTGyuA4v7f3pA+BJ5HLfNC6nAQ0Cpi9uOquUj8Hehg0aUiHzWQbOVJGao6ztBAQ==}
+    engines: {node: '>=6.9.0'}
+
   /@babel/helper-validator-option@7.22.15:
     resolution: {integrity: sha512-bMn7RmyFjY/mdECUbgn9eoSY4vqvacUnS9i9vGAGttgFWesO6B4CYWA7XlpbWgBt71iv/hfbPlynohStqnu5hA==}
     engines: {node: '>=6.9.0'}
 
-  /@babel/helper-wrap-function@7.20.5:
-    resolution: {integrity: sha512-bYMxIWK5mh+TgXGVqAtnu5Yn1un+v8DDZtqyzKRLUzrh70Eal2O3aZ7aPYiMADO4uKlkzOiRiZ6GX5q3qxvW9Q==}
+  /@babel/helper-validator-option@7.22.5:
+    resolution: {integrity: sha512-R3oB6xlIVKUnxNUxbmgq7pKjxpru24zlimpE8WK47fACIlM0II/Hm1RS8IaOI7NgCr6LNS+jl5l75m20npAziw==}
+    engines: {node: '>=6.9.0'}
+
+  /@babel/helper-wrap-function@7.22.10:
+    resolution: {integrity: sha512-OnMhjWjuGYtdoO3FmsEFWvBStBAe2QOgwOLsLNDjN+aaiMD8InJk1/O3HSD8lkqTjCgg5YI34Tz15KNNA3p+nQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-function-name': 7.23.0
+      '@babel/template': 7.22.5
+      '@babel/types': 7.23.0
+
+  /@babel/helper-wrap-function@7.22.20:
+    resolution: {integrity: sha512-pms/UwkOpnQe/PDAEdV/d7dVCoBbB+R4FvYoHGZz+4VPcg7RtYy2KP7S2lbuWM6FCSgob5wshfGESbC/hzNXZw==}
     engines: {node: '>=6.9.0'}
     dependencies:
       '@babel/helper-function-name': 7.23.0
       '@babel/template': 7.22.15
-      '@babel/traverse': 7.23.2
       '@babel/types': 7.23.0
-    transitivePeerDependencies:
-      - supports-color
 
   /@babel/helpers@7.23.2:
     resolution: {integrity: sha512-lzchcp8SjTSVe/fPmLwtWVBFC7+Tbn8LGHDVfDp9JGxpAY5opSaEFgt8UQvrnECWOTdji2mOWMz1rOhkHscmGQ==}
@@ -1409,6 +1593,14 @@ packages:
     transitivePeerDependencies:
       - supports-color
 
+  /@babel/highlight@7.22.10:
+    resolution: {integrity: sha512-78aUtVcT7MUscr0K5mIEnkwxPE0MaxkR5RxRwuHaQ+JuU5AmTPhY+do2mdzVTnIJJpyBglql2pehuBIWHug+WQ==}
+    engines: {node: '>=6.9.0'}
+    dependencies:
+      '@babel/helper-validator-identifier': 7.22.5
+      chalk: 2.4.2
+      js-tokens: 4.0.0
+
   /@babel/highlight@7.22.20:
     resolution: {integrity: sha512-dkdMCN3py0+ksCgYmGG8jKeGA/8Tk+gJwSYYlFGxG5lmhfKNoAy004YpLxpS1W2J8m/EK2Ew+yOs9pVRwO89mg==}
     engines: {node: '>=6.9.0'}
@@ -1417,6 +1609,13 @@ packages:
       chalk: 2.4.2
       js-tokens: 4.0.0
 
+  /@babel/parser@7.22.10:
+    resolution: {integrity: sha512-lNbdGsQb9ekfsnjFGhEiF4hfFqGgfOP3H3d27re3n+CGhNuTSUEQdfWk556sTLNTloczcdM5TYF2LhzmDQKyvQ==}
+    engines: {node: '>=6.0.0'}
+    hasBin: true
+    dependencies:
+      '@babel/types': 7.23.0
+
   /@babel/parser@7.23.0:
     resolution: {integrity: sha512-vvPKKdMemU85V9WE/l5wZEmImpCtLqbnTvqDS2U1fJ96KrxoW7KrXhNsNCblQlg8Ck4b85yxdTyelsMUgFUXiw==}
     engines: {node: '>=6.0.0'}
@@ -1424,731 +1623,761 @@ packages:
     dependencies:
       '@babel/types': 7.23.0
 
-  /@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-Dgxsyg54Fx1d4Nge8UnvTrED63vrwOdPmyvPzlNN/boaliRP54pm3pGzZD1SJUwrBA+Cs/xdG8kXX6Mn/RfISQ==}
+  /@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-FB9iYlz7rURmRJyXRKEnalYPPdn87H5no108cyuQQyMwlpJ2SJtpIUBI27kdTin956pz+LPypkPVPUTlxOmrsg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.20.7(@babel/core@7.23.2):
-    resolution: {integrity: sha512-sbr9+wNE5aXMBBFBICk01tt7sBf2Oc9ikRFEcem/ZORup9IMUdNhW7/wVLEbbtlWOsEubJet46mHAL2C8+2jKQ==}
+  /@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-Hyph9LseGvAeeXzikV88bczhsrLrIZqDPxO+sSmAunMPaGrBGhfMWzCPYTtiW9t+HzSE2wtV8e5cc5P6r1xMDQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.13.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-skip-transparent-expression-wrappers': 7.20.0
-      '@babel/plugin-proposal-optional-chaining': 7.21.0(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-skip-transparent-expression-wrappers': 7.22.5
+      '@babel/plugin-transform-optional-chaining': 7.23.0(@babel/core@7.23.2)
 
-  /@babel/plugin-proposal-async-generator-functions@7.20.7(@babel/core@7.23.2):
-    resolution: {integrity: sha512-xMbiLsn/8RK7Wq7VeVytytS2L6qE69bXPB10YCmMdDZbKF4okCqY74pI/jJQ/8U0b/F6NrT2+14b8/P9/3AMGA==}
+  /@babel/plugin-proposal-decorators@7.23.2(@babel/core@7.23.2):
+    resolution: {integrity: sha512-eR0gJQc830fJVGz37oKLvt9W9uUIQSAovUl0e9sJ3YeO09dlcoBVYD3CLrjCj4qHdXmfiyTyFt8yeQYSN5fxLg==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-async-generator-functions instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-remap-async-to-generator': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.23.2)
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-create-class-features-plugin': 7.22.15(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-replace-supers': 7.22.20(@babel/core@7.23.2)
+      '@babel/helper-split-export-declaration': 7.22.6
+      '@babel/plugin-syntax-decorators': 7.22.10(@babel/core@7.23.2)
+    dev: true
 
-  /@babel/plugin-proposal-class-properties@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-cumfXOF0+nzZrrN8Rf0t7M+tF6sZc7vhQwYQck9q1/5w2OExlD+b4v4RpMJFaV1Z7WcDRgO6FqvxqxGlwo+RHQ==}
+  /@babel/plugin-proposal-private-property-in-object@7.21.0-placeholder-for-preset-env.2(@babel/core@7.23.2):
+    resolution: {integrity: sha512-SOSkfJDddaM7mak6cPEpswyTRnuRltl429hMraQEglW+OkovnCzsiszTmsrlY//qLFjCpQDFRvjdm2wA5pPm9w==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-class-properties instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-class-features-plugin': 7.21.5(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-    transitivePeerDependencies:
-      - supports-color
 
-  /@babel/plugin-proposal-class-static-block@7.21.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-XP5G9MWNUskFuP30IfFSEFB0Z6HzLIUcjYM4bYOPHXl7eiJ9HFv8tWj6TXTN5QODiEhDZAeI4hLok2iHFFV4hw==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-class-static-block instead.
+  /@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.23.2):
+    resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
     peerDependencies:
-      '@babel/core': ^7.12.0
+      '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-class-features-plugin': 7.21.5(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.23.2)
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-dynamic-import@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-1auuwmK+Rz13SJj36R+jqFPMJWyKEDd7lLSdOj4oJK0UTgGueSAtkrCvz9ewmgyU/P941Rv2fQwZJN8s6QruXw==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-dynamic-import instead.
+  /@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.23.2):
+    resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-export-namespace-from@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-k1NtHyOMvlDDFeb9G5PhUXuGj8m/wiwojgQVEhJ/fsVsMCpLyOP4h0uGEjYJKrRI+EVPlb5Jk+Gt9P97lOGwtA==}
+  /@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-export-namespace-from instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-json-strings@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-lr1peyn9kOdbYc0xr0OdHTZ5FMqS6Di+H0Fz2I/JwMzGmzJETNeOFq2pBySw6X/KFL5EWDjlJuMsUGRFb8fQgQ==}
+  /@babel/plugin-syntax-decorators@7.22.10(@babel/core@7.23.2):
+    resolution: {integrity: sha512-z1KTVemBjnz+kSEilAsI4lbkPOl5TvJH7YDSY1CTIzvLWJ+KHXp+mRe8VPmfnyvqOPqar1V2gid2PleKzRUstQ==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-json-strings instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+    dev: true
 
-  /@babel/plugin-proposal-logical-assignment-operators@7.20.7(@babel/core@7.23.2):
-    resolution: {integrity: sha512-y7C7cZgpMIjWlKE5T7eJwp+tnRYM89HmRvWM5EQuB5BoHEONjmQ8lSNmBUwOyy/GFRsohJED51YBF79hE1djug==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-logical-assignment-operators instead.
+  /@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
       '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.23.2)
 
-  /@babel/plugin-proposal-nullish-coalescing-operator@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-wQxQzxYeJqHcfppzBDnm1yAY0jSRkUXR2z8RePZYrKwMKgMlE8+Z6LUno+bd6LvbGh8Gltvy74+9pIYkr+XkKA==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-nullish-coalescing-operator instead.
+  /@babel/plugin-syntax-export-namespace-from@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-numeric-separator@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==}
+  /@babel/plugin-syntax-import-assertions@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-rdV97N7KqsRzeNGoWUOK6yUsWarLjE5Su/Snk9IYPU9CwkWHs4t+rTGOvffTR8XGkJMTAdLfO0xVnXm8wugIJg==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-numeric-separator instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-object-rest-spread@7.20.7(@babel/core@7.23.2):
-    resolution: {integrity: sha512-d2S98yCiLxDVmBmE8UjGcfPvNEUbA1U5q5WxaWFUGRzJSVAZqm5W6MbPct0jxnegUZ0niLeNX+IOzEs7wYg9Dg==}
+  /@babel/plugin-syntax-import-attributes@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-KwvoWDeNKPETmozyFE0P2rOLqh39EoQHNjqizrI5B8Vt0ZNS7M56s7dAiAqbYfiAYOuIzIh96z3iR2ktgu3tEg==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-object-rest-spread instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
-      '@babel/compat-data': 7.23.2
       '@babel/core': 7.23.2
-      '@babel/helper-compilation-targets': 7.22.15
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-transform-parameters': 7.21.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-optional-catch-binding@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-Q40HEhs9DJQyaZfUjjn6vE8Cv4GmMHCYuMGIWUnlxH6400VGxOuwWsPt4FxXxJkC/5eOzgn0z21M9gMT4MOhbw==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-optional-catch-binding instead.
+  /@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.23.2):
+    resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-optional-chaining@7.21.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-p4zeefM72gpmEe2fkUr/OnOXpWEf8nAgk7ZYVqqfFiyIG7oFfVZcCrU64hWn5xp4tQ9LkV4bTIa5rD0KANpKNA==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-optional-chaining instead.
+  /@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-skip-transparent-expression-wrappers': 7.20.0
-      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-private-methods@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-nutsvktDItsNn4rpGItSNV2sz1XwS+nfU0Rg8aCx3W3NOKVzdMjJRu0O5OkgDp3ZGICSTbgRpxZoWsxoKRvbeA==}
+  /@babel/plugin-syntax-jsx@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-gvyP4hZrgrs/wWMaocvxZ44Hw0b3W8Pe+cMxc8V1ULQ07oh8VNbIRaoD1LRZVTvD+0nieDKjfgKg89sD7rrKrg==}
     engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-private-methods instead.
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-class-features-plugin': 7.21.5(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-private-property-in-object@7.21.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-ha4zfehbJjc5MmXBlHec1igel5TJXXLDDRbuJ4+XT2TJcyD9/V1919BA8gMvsdHcNMBy4WBUBiRb3nw/EQUtBw==}
-    engines: {node: '>=6.9.0'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-private-property-in-object instead.
+  /@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.23.2):
+    resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-annotate-as-pure': 7.18.6
-      '@babel/helper-create-class-features-plugin': 7.21.5(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.23.2)
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-proposal-unicode-property-regex@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-2BShG/d5yoZyXZfVePH91urL5wTG6ASZU9M4o03lKK8u8UW1y08OMttBSOADTcJrnPMpvDXRG3G8fyLh4ovs8w==}
-    engines: {node: '>=4'}
-    deprecated: This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-unicode-property-regex instead.
+  /@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-regexp-features-plugin': 7.21.8(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-async-generators@7.8.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-tycmZxkGfZaxhMRbXlPXuVFpdWlXpir2W4AMhSJgRKzk/eDlIXOhb2LHWoLpDF7TEHylV5zNhykX6KAgHJmTNw==}
+  /@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.23.2):
+    resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-class-properties@7.12.13(@babel/core@7.23.2):
-    resolution: {integrity: sha512-fm4idjKla0YahUNgFNLCB0qySdsoPiZP3iQE3rky0mBUtMZ23yDJ9SJdg6dXTSDnulOVqiF3Hgr9nbXvXTQZYA==}
+  /@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-class-static-block@7.14.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-b+YyPmr6ldyNnM6sqYeMWE+bgJcJpO6yS4QD7ymxgH34GBPNDM/THBh8iunyvKIZztiwLH4CJZ0RxTk9emgpjw==}
+  /@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-plugin-utils': 7.22.5
+
+  /@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-plugin-utils': 7.22.5
+
+  /@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-decorators@7.21.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-tIoPpGBR8UuM4++ccWN3gifhVvQu7ZizuR1fklhRJrd5ewgbkUS+0KVFeWWxELtn18NTLoW32XV7zyOgIAiz+w==}
+  /@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-    dev: true
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-dynamic-import@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-5gdGbFon+PszYzqs83S3E5mpi7/y/8M9eC90MRTZfduQOYW76ig6SOSPNe41IG5LoP3FGBn2N0RjVDSQiS94kQ==}
+  /@babel/plugin-syntax-typescript@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-1mS2o03i7t1c6VzH6fdQ3OA8tcEIxwG18zIPRp+UY1Ihv6W+XZzBCVxExF9upussPXJ0xE9XRHwMoNs1ep/nRQ==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-export-namespace-from@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-MXf5laXo6c1IbEbegDmzGPwGNTsHZmEy6QGznu5Sh2UCWvueywb2ee+CCE4zQiZstxU9BMoQO9i6zUFSY0Kj0Q==}
+  /@babel/plugin-syntax-unicode-sets-regex@7.18.6(@babel/core@7.23.2):
+    resolution: {integrity: sha512-727YkEAPwSIQTv5im8QHz3upqp92JTWhidIC81Tdx4VJYIte/VndKf1qKrfnnhPLiPghStWfvC/iFaMCQu7Nqg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-create-regexp-features-plugin': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+
+  /@babel/plugin-transform-arrow-functions@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-26lTNXoVRdAnsaDXPpvCNUq+OVWEVC6bx7Vvz9rC53F2bagUWW4u4ii2+h8Fejfh7RYqPxn+libeFBBck9muEw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-import-assertions@7.20.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-IUh1vakzNoWalR8ch/areW7qFopR2AEw03JlG7BbrDqmQ4X3q9uuipQwSGrUn7oGiemKjtSLDhNtQHzMHr1JdQ==}
+  /@babel/plugin-transform-async-generator-functions@7.23.2(@babel/core@7.23.2):
+    resolution: {integrity: sha512-BBYVGxbDVHfoeXbOwcagAkOQAm9NxoTdMGfTqghu1GrvadSaw6iW3Je6IcL5PNOw8VwjxqBECXy50/iCQSY/lQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-environment-visitor': 7.22.20
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-remap-async-to-generator': 7.22.20(@babel/core@7.23.2)
+      '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.23.2)
 
-  /@babel/plugin-syntax-import-meta@7.10.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-Yqfm+XDx0+Prh3VSeEQCPU81yC+JWZ2pDPFSS4ZdpfZhp4MkFMaDC1UqseovEKwSUpnIL7+vK+Clp7bfh0iD7g==}
+  /@babel/plugin-transform-async-to-generator@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-b1A8D8ZzE/VhNDoV1MSJTnpKkCG5bJo+19R4o4oy03zM7ws8yEMK755j61Dc3EyvdysbqH5BOOTquJ7ZX9C6vQ==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-module-imports': 7.22.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-remap-async-to-generator': 7.22.9(@babel/core@7.23.2)
 
-  /@babel/plugin-syntax-json-strings@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-lY6kdGpWHvjoe2vk4WrAapEuBR69EMxZl+RoGRhrFGNYVK8mOPAW8VfbT/ZgrFbXlDNiiaxQnAtgVCZ6jv30EA==}
+  /@babel/plugin-transform-block-scoped-functions@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-tdXZ2UdknEKQWKJP1KMNmuF5Lx3MymtMN/pvA+p/VEkhK8jVcQ1fzSy8KM9qRYhAf2/lV33hoMPKI/xaI9sADA==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-jsx@7.21.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-5hewiLct5OKyh6PLKEYaFclcqtIgCb6bmELouxjF6up5q3Sov7rOayW4RwhbaBL0dit8rA80GNfY+UuDp2mBbQ==}
+  /@babel/plugin-transform-block-scoping@7.23.0(@babel/core@7.23.2):
+    resolution: {integrity: sha512-cOsrbmIOXmf+5YbL99/S49Y3j46k/T16b9ml8bm9lP6N9US5iQ2yBK7gpui1pg0V/WMcXdkfKbTb7HXq9u+v4g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-logical-assignment-operators@7.10.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-d8waShlpFDinQ5MtvGU9xDAOzKH47+FFoney2baFIoMr952hKOLp1HR7VszoZvOsV/4+RRszNY7D17ba0te0ig==}
+  /@babel/plugin-transform-class-properties@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-nDkQ0NfkOhPTq8YCLiWNxp1+f9fCobEjCb0n8WdbNUBc4IB5V7P1QnX9IjpSoquKrXF5SKojHleVNs2vGeHCHQ==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-create-class-features-plugin': 7.22.10(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-nullish-coalescing-operator@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-aSff4zPII1u2QD7y+F8oDsz19ew4IGEJg9SVW+bqwpwtfFleiQDMdzA/R+UlWDzfnHFCxxleFT0PMIrR36XLNQ==}
+  /@babel/plugin-transform-class-static-block@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-GMM8gGmqI7guS/llMFk1bJDkKfn3v3C4KHK9Yg1ey5qcHcOlKb0QvcMrgzvxo+T03/4szNh5lghY+fEC98Kq9g==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.12.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-create-class-features-plugin': 7.22.15(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.23.2)
+
+  /@babel/plugin-transform-classes@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-VbbC3PGjBdE0wAWDdHM9G8Gm977pnYI0XpqMd6LrKISj8/DJXEsWqgRuTYaNE9Bv0JGhTZUzHDlMk18IpOuoqw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-annotate-as-pure': 7.22.5
+      '@babel/helper-compilation-targets': 7.22.15
+      '@babel/helper-environment-visitor': 7.22.5
+      '@babel/helper-function-name': 7.22.5
+      '@babel/helper-optimise-call-expression': 7.22.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-replace-supers': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-split-export-declaration': 7.22.6
+      globals: 11.12.0
 
-  /@babel/plugin-syntax-numeric-separator@7.10.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-9H6YdfkcK/uOnY/K7/aA2xpzaAgkQn37yzWUMRK7OaPOqOpGS1+n0H5hxT9AUw9EsSjPW8SVyMJwYRtWs3X3ug==}
+  /@babel/plugin-transform-computed-properties@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-4GHWBgRf0krxPX+AaPtgBAlTgTeZmqDynokHOX7aqqAB4tHs3U2Y02zH6ETFdLZGcg9UQSD1WCmkVrE9ErHeOg==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/template': 7.22.5
 
-  /@babel/plugin-syntax-object-rest-spread@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-XoqMijGZb9y3y2XskN+P1wUGiVwWZ5JmoDRwx5+3GmEplNyVM2s2Dg8ILFQm8rWM48orGy5YpI5Bl8U1y7ydlA==}
+  /@babel/plugin-transform-destructuring@7.23.0(@babel/core@7.23.2):
+    resolution: {integrity: sha512-vaMdgNXFkYrB+8lbgniSYWHsgqK5gjaMNcc84bMIOMRLH0L9AqYq3hwMdvnyqj1OPqea8UtjPEuS/DCenah1wg==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-optional-catch-binding@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-6VPD0Pc1lpTqw0aKoeRTMiB+kWhAoT24PA+ksWSBrFtl5SIRVpZlwN3NNPQjehA2E/91FV3RjLWoVTglWcSV3Q==}
+  /@babel/plugin-transform-dotall-regex@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-5/Yk9QxCQCl+sOIB1WelKnVRxTJDSAIxtJLL2/pqL14ZVlbH0fUQUZa/T5/UnQtBNgghR7mfB8ERBKyKPCi7Vw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-create-regexp-features-plugin': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-optional-chaining@7.8.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-KoK9ErH1MBlCPxV0VANkXW2/dw4vlbGDrFgz8bmUsBGYkFRcbRwMh6cIJubdPrkxRwuGdtCk0v/wPTKbQgBjkg==}
+  /@babel/plugin-transform-duplicate-keys@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-dEnYD+9BBgld5VBXHnF/DbYGp3fqGMsyxKbtD1mDyIA7AkTSpKXFhCVuj/oQVOoALfBs77DudA0BE4d5mcpmqw==}
+    engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-private-property-in-object@7.14.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-0wVnp9dxJ72ZUJDV27ZfbSj6iHLoytYZmh3rFcxNnvsJF3ktkzLDZPy/mA17HGsaQT3/DQsWYX1f1QGWkCoVUg==}
+  /@babel/plugin-transform-dynamic-import@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-g/21plo58sfteWjaO0ZNVb+uEOkJNjAaHhbejrnBmu011l/eNDScmkbjCC3l4FKb10ViaGU4aOkFznSu2zRHgA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.23.2)
 
-  /@babel/plugin-syntax-top-level-await@7.14.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-hx++upLv5U1rgYfwe1xBQUhRmU41NEvpUvrp8jkrSCdvGSnM5/qdRMtylJ6PG5OFkBaHkbTAKTnd3/YyESRHFw==}
+  /@babel/plugin-transform-exponentiation-operator@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-vIpJFNM/FjZ4rh1myqIya9jXwrwwgFRHPjT3DkUA9ZLHuzox8jiXkOLvwm1H+PQIP3CqfC++WPKeuDi0Sjdj1g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-builder-binary-assignment-operator-visitor': 7.22.10
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-syntax-typescript@7.21.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-xz0D39NvhQn4t4RNsHmDnnsaQizIlUkdtYvLs8La1BlfjQ6JEwxkJGeqJMW2tAXx+q6H+WFuUTXNdYVpEya0YA==}
+  /@babel/plugin-transform-export-namespace-from@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-xa7aad7q7OiT8oNZ1mU7NrISjlSkVdMbNxn9IuLZyL9AJEhs1Apba3I+u5riX1dIkdptP5EKDG5XDPByWxtehw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-arrow-functions@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-wb1mhwGOCaXHDTcsRYMKF9e5bbMgqwxtqa2Y1ifH96dXJPwbuLX9qHy3clhrxVqgMz7nyNXs8VkxdH8UBcjKqA==}
+  /@babel/plugin-transform-for-of@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-me6VGeHsx30+xh9fbDLLPi0J1HzmeIIyenoOQHuw2D4m2SAU3NrspX5XxJLBpqn5yrLzrlw2Iy3RA//Bx27iOA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-async-to-generator@7.20.7(@babel/core@7.23.2):
-    resolution: {integrity: sha512-Uo5gwHPT9vgnSXQxqGtpdufUiWp96gk7yiP4Mp5bm1QMkEmLXBO7PAGYbKoJ6DhAwiNkcHFBol/x5zZZkL/t0Q==}
+  /@babel/plugin-transform-function-name@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-UIzQNMS0p0HHiQm3oelztj+ECwFnj+ZRV4KnguvlsD2of1whUeM6o7wGNj6oLwcDoAXQ8gEqfgC24D+VdIcevg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-module-imports': 7.22.15
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-remap-async-to-generator': 7.18.9(@babel/core@7.23.2)
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-compilation-targets': 7.22.15
+      '@babel/helper-function-name': 7.22.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-block-scoped-functions@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-ExUcOqpPWnliRcPqves5HJcJOvHvIIWfuS4sroBUenPuMdmW+SMHDakmtS7qOo13sVppmUijqeTv7qqGsvURpQ==}
+  /@babel/plugin-transform-json-strings@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-CxT5tCqpA9/jXFlme9xIBCc5RPtdDq3JpkkhgHQqtDdiTnTI0jtZ0QzXhr5DILeYifDPp2wvY2ad+7+hLMW5Pw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-block-scoping@7.21.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-Mdrbunoh9SxwFZapeHVrwFmri16+oYotcZysSzhNIVDwIAb1UV+kvnxULSYq9J3/q5MDG+4X6w8QVgD1zhBXNQ==}
+  /@babel/plugin-transform-literals@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-fTLj4D79M+mepcw3dgFBTIDYpbcB9Sm0bpm4ppXPaO+U+PKFFyV9MGRvS0gvGw62sd10kT5lRMKXAADb9pWy8g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-classes@7.21.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-RZhbYTCEUAe6ntPehC4hlslPWosNHDox+vAs4On/mCLRLfoDVHf6hVEd7kuxr1RnHwJmxFfUM3cZiZRmPxJPXQ==}
+  /@babel/plugin-transform-logical-assignment-operators@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-qQwRTP4+6xFCDV5k7gZBF3C31K34ut0tbEcTKxlX/0KXxm9GLcO14p570aWxFvVzx6QAfPgq7gaeIHXJC8LswQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-annotate-as-pure': 7.18.6
-      '@babel/helper-compilation-targets': 7.22.15
-      '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-function-name': 7.23.0
-      '@babel/helper-optimise-call-expression': 7.18.6
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-replace-supers': 7.21.5
-      '@babel/helper-split-export-declaration': 7.22.6
-      globals: 11.12.0
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-computed-properties@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-TR653Ki3pAwxBxUe8srfF3e4Pe3FTA46uaNHYyQwIoM4oWKSoOZiDNyHJ0oIoDIUPSRQbQG7jzgVBX3FPVne1Q==}
+  /@babel/plugin-transform-member-expression-literals@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-RZEdkNtzzYCFl9SE9ATaUMTj2hqMb4StarOJLrZRbqqU4HSBE7UlBw9WBWQiDzrJZJdUWiMTVDI6Gv/8DPvfew==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/template': 7.22.15
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-destructuring@7.21.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-bp6hwMFzuiE4HqYEyoGJ/V2LeIWn+hLVKc4pnj++E5XQptwhtcGmSayM029d/j2X1bPKGTlsyPwAubuU22KhMA==}
+  /@babel/plugin-transform-modules-amd@7.23.0(@babel/core@7.23.2):
+    resolution: {integrity: sha512-xWT5gefv2HGSm4QHtgc1sYPbseOyf+FFDo2JbpE25GWl5BqTGO9IMwTYJRoIdjsF85GE+VegHxSCUt5EvoYTAw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-dotall-regex@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-6S3jpun1eEbAxq7TdjLotAsl4WpQI9DxfkycRcKrjhQYzU87qpXdknpBg/e+TdcMehqGnLFi7tnFUBR02Vq6wg==}
+  /@babel/plugin-transform-modules-commonjs@7.23.0(@babel/core@7.23.2):
+    resolution: {integrity: sha512-32Xzss14/UVc7k9g775yMIvkVK8xwKE0DPdP5JTapr3+Z9w4tzeOuLNY6BXDQR6BdnzIlXnCGAzsk/ICHBLVWQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-regexp-features-plugin': 7.21.8(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-simple-access': 7.22.5
 
-  /@babel/plugin-transform-duplicate-keys@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-d2bmXCtZXYc59/0SanQKbiWINadaJXqtvIQIzd4+hNwkWBgyCd5F/2t1kXoUdvPMrxzPvhK6EMQRROxsue+mfw==}
+  /@babel/plugin-transform-modules-systemjs@7.23.0(@babel/core@7.23.2):
+    resolution: {integrity: sha512-qBej6ctXZD2f+DhlOC9yO47yEYgUh5CZNz/aBoH4j/3NOlRfJXJbY7xDQCqQVf9KbrqGzIWER1f23doHGrIHFg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-hoist-variables': 7.22.5
+      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-validator-identifier': 7.22.20
 
-  /@babel/plugin-transform-exponentiation-operator@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-wzEtc0+2c88FVR34aQmiz56dxEkxr2g8DQb/KfaFa1JYXOFVsbhvAonFN6PwVWj++fKmku8NP80plJ5Et4wqHw==}
+  /@babel/plugin-transform-modules-umd@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-+S6kzefN/E1vkSsKx8kmQuqeQsvCKCd1fraCM7zXm4SFoggI099Tr4G8U81+5gtMdUeMQ4ipdQffbKLX0/7dBQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-builder-binary-assignment-operator-visitor': 7.21.5
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-module-transforms': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+
+  /@babel/plugin-transform-named-capturing-groups-regex@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-YgLLKmS3aUBhHaxp5hi1WJTgOUb/NCuDHzGT9z9WTt3YG+CPRhJs6nprbStx6DnWM4dh6gt7SU3sZodbZ08adQ==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-create-regexp-features-plugin': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-for-of@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-nYWpjKW/7j/I/mZkGVgHJXh4bA1sfdFnJoOXwJuj4m3Q2EraO/8ZyrkCau9P5tbHQk01RMSt6KYLCsW7730SXQ==}
+  /@babel/plugin-transform-new-target@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-AsF7K0Fx/cNKVyk3a+DW0JLo+Ua598/NxMRvxDnkpCIGFh43+h/v2xyhRUYf6oD8gE4QtL83C7zZVghMjHd+iw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-function-name@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-WvIBoRPaJQ5yVHzcnJFor7oS5Ls0PYixlTYE63lCj2RtdQEl15M68FXQlxnG6wdraJIXRdR7KI+hQ7q/9QjrCQ==}
+  /@babel/plugin-transform-nullish-coalescing-operator@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-YZWOw4HxXrotb5xsjMJUDlLgcDXSfO9eCmdl1bgW4+/lAGdkjaEvOnQ4p5WKKdUgSzO39dgPl0pTnfxm0OAXcg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-compilation-targets': 7.22.15
-      '@babel/helper-function-name': 7.23.0
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-nullish-coalescing-operator': 7.8.3(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-literals@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-IFQDSRoTPnrAIrI5zoZv73IFeZu2dhu6irxQjY9rNjTT53VmKg9fenjvoiOWOkJ6mm4jKVPtdMzBY98Fp4Z4cg==}
+  /@babel/plugin-transform-numeric-separator@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-3dzU4QGPsILdJbASKhF/V2TVP+gJya1PsueQCxIPCEcerqF21oEcrob4mzjsp2Py/1nLfF5m+xYNMDpmA8vffg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-numeric-separator': 7.10.4(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-member-expression-literals@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-qSF1ihLGO3q+/g48k85tUjD033C29TNTVB2paCwZPVmOsjn9pClvYYrM2VeJpBY2bcNkuny0YUyTNRyRxJ54KA==}
+  /@babel/plugin-transform-object-rest-spread@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-fEB+I1+gAmfAyxZcX1+ZUwLeAuuf8VIg67CTznZE0MqVFumWkh8xWtn58I4dxdVf080wn7gzWoF8vndOViJe9Q==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
+      '@babel/compat-data': 7.23.2
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-compilation-targets': 7.22.15
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-object-rest-spread': 7.8.3(@babel/core@7.23.2)
+      '@babel/plugin-transform-parameters': 7.22.15(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-modules-amd@7.20.11(@babel/core@7.23.2):
-    resolution: {integrity: sha512-NuzCt5IIYOW0O30UvqktzHYR2ud5bOWbY0yaxWZ6G+aFzOMJvrs5YHNikrbdaT15+KNO31nPOy5Fim3ku6Zb5g==}
+  /@babel/plugin-transform-object-super@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-klXqyaT9trSjIUrcsYIfETAzmOEZL3cBYqOYLJxBHfMFFggmXOv+NYSX/Jbs9mzMVESw/WycLFPRx8ba/b2Ipw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-replace-supers': 7.22.9(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-modules-commonjs@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-OVryBEgKUbtqMoB7eG2rs6UFexJi6Zj6FDXx+esBLPTCxCNxAY9o+8Di7IsUGJ+AVhp5ncK0fxWUBd0/1gPhrQ==}
+  /@babel/plugin-transform-optional-catch-binding@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-rli0WxesXUeCJnMYhzAglEjLWVDF6ahb45HuprcmQuLidBJFWjNnOzssk2kuc6e33FlLaiZhG/kUIzUMWdBKaQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-simple-access': 7.22.5
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-optional-catch-binding': 7.8.3(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-modules-systemjs@7.20.11(@babel/core@7.23.2):
-    resolution: {integrity: sha512-vVu5g9BPQKSFEmvt2TA4Da5N+QVS66EX21d8uoOihC+OCpUoGvzVsXeqFdtAEfVa5BILAeFt+U7yVmLbQnAJmw==}
+  /@babel/plugin-transform-optional-chaining@7.23.0(@babel/core@7.23.2):
+    resolution: {integrity: sha512-sBBGXbLJjxTzLBF5rFWaikMnOGOk/BmK6vVByIdEggZ7Vn6CvWXZyRkkLFK6WE0IF8jSliyOkUN6SScFgzCM0g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-hoist-variables': 7.22.5
-      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-validator-identifier': 7.22.20
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-skip-transparent-expression-wrappers': 7.22.5
+      '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-modules-umd@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-dcegErExVeXcRqNtkRU/z8WlBLnvD4MRnHgNs3MytRO1Mn1sHRyhbcpYbVMGclAqOjdW+9cfkdZno9dFdfKLfQ==}
+  /@babel/plugin-transform-parameters@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-hjk7qKIqhyzhhUvRT683TYQOFa/4cQKwQy7ALvTpODswN40MljzNDa0YldevS6tGbxwaEKVn502JmY0dP7qEtQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-module-transforms': 7.23.0(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-named-capturing-groups-regex@7.20.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-mOW4tTzi5iTLnw+78iEq3gr8Aoq4WNRGpmSlrogqaiCBoR1HFhpU4JkpQFOHfeYx3ReVIFWOQJS4aZBRvuZ6mA==}
+  /@babel/plugin-transform-private-methods@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-PPjh4gyrQnGe97JTalgRGMuU4icsZFnWkzicB/fUtzlKUqvsWBKEpPPfr5a2JiyirZkHxnAqkQMO5Z5B2kK3fA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
-      '@babel/core': ^7.0.0
+      '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-regexp-features-plugin': 7.21.8(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-create-class-features-plugin': 7.22.10(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-new-target@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-DjwFA/9Iu3Z+vrAn+8pBUGcjhxKguSMlsFqeCKbhb9BAV756v0krzVK04CRDi/4aqmk8BsHb4a/gFcaA5joXRw==}
+  /@babel/plugin-transform-private-property-in-object@7.22.11(@babel/core@7.23.2):
+    resolution: {integrity: sha512-sSCbqZDBKHetvjSwpyWzhuHkmW5RummxJBVbYLkGkaiTOWGxml7SXt0iWa03bzxFIx7wOj3g/ILRd0RcJKBeSQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-annotate-as-pure': 7.22.5
+      '@babel/helper-create-class-features-plugin': 7.22.15(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-object-super@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-uvGz6zk+pZoS1aTZrOvrbj6Pp/kK2mp45t2B+bTDre2UgsZZ8EZLSJtUg7m/no0zOJUWgFONpB7Zv9W2tSaFlA==}
+  /@babel/plugin-transform-property-literals@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-TiOArgddK3mK/x1Qwf5hay2pxI6wCZnvQqrFSqbtg1GLl2JcNMitVH/YnqjP+M31pLUeTfzY1HAXFDnUBV30rQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-replace-supers': 7.21.5
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-parameters@7.21.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-Wxc+TvppQG9xWFYatvCGPvZ6+SIUxQ2ZdiBP+PHYMIjnPXD+uThCshaz4NZOnODAtBjjcVQQ/3OKs9LW28purQ==}
+  /@babel/plugin-transform-react-jsx-self@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-nTh2ogNUtxbiSbxaT4Ds6aXnXEipHweN9YRgOX/oNXdf0cCrGn/+2LozFa3lnPV5D90MkjhgckCPBrsoSc1a7g==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+    dev: true
 
-  /@babel/plugin-transform-property-literals@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-cYcs6qlgafTud3PAzrrRNbQtfpQ8+y/+M5tKmksS9+M1ckbH6kzY8MrexEM9mcA6JDsukE19iIRvAyYl463sMg==}
+  /@babel/plugin-transform-react-jsx-source@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-yIiRO6yobeEIaI0RTbIr8iAK9FcBHLtZq0S89ZPjDLQXBA4xvghaKqI0etp/tF3htTM0sazJKKLz9oEiGRtu7w==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
+    dev: true
 
-  /@babel/plugin-transform-regenerator@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-ZoYBKDb6LyMi5yCsByQ5jmXsHAQDDYeexT1Szvlmui+lADvfSecr5Dxd/PkrTC3pAD182Fcju1VQkB4oCp9M+w==}
+  /@babel/plugin-transform-regenerator@7.22.10(@babel/core@7.23.2):
+    resolution: {integrity: sha512-F28b1mDt8KcT5bUyJc/U9nwzw6cV+UmTeRlXYIl2TNqMMJif0Jeey9/RQ3C4NOd2zp0/TRsDns9ttj2L523rsw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      regenerator-transform: 0.15.1
+      '@babel/helper-plugin-utils': 7.22.5
+      regenerator-transform: 0.15.2
 
-  /@babel/plugin-transform-reserved-words@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-oX/4MyMoypzHjFrT1CdivfKZ+XvIPMFXwwxHp/r0Ddy2Vuomt4HDFGmft1TAY2yiTKiNSsh3kjBAzcM8kSdsjA==}
+  /@babel/plugin-transform-reserved-words@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-DTtGKFRQUDm8svigJzZHzb/2xatPc6TzNvAIJ5GqOKDsGFYgAskjRulbR/vGsPKq3OPqtexnz327qYpP57RFyA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-runtime@7.21.4(@babel/core@7.23.2):
-    resolution: {integrity: sha512-1J4dhrw1h1PqnNNpzwxQ2UBymJUF8KuPjAAnlLwZcGhHAIqUigFW7cdK6GHoB64ubY4qXQNYknoUeks4Wz7CUA==}
+  /@babel/plugin-transform-runtime@7.23.2(@babel/core@7.23.2):
+    resolution: {integrity: sha512-XOntj6icgzMS58jPVtQpiuF6ZFWxQiJavISGx5KGjRj+3gqZr8+N6Kx+N9BApWzgS+DOjIZfXXj0ZesenOWDyA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
       '@babel/helper-module-imports': 7.22.15
-      '@babel/helper-plugin-utils': 7.21.5
-      babel-plugin-polyfill-corejs2: 0.3.3(@babel/core@7.23.2)
-      babel-plugin-polyfill-corejs3: 0.6.0(@babel/core@7.23.2)
-      babel-plugin-polyfill-regenerator: 0.4.1(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      babel-plugin-polyfill-corejs2: 0.4.6(@babel/core@7.23.2)
+      babel-plugin-polyfill-corejs3: 0.8.6(@babel/core@7.23.2)
+      babel-plugin-polyfill-regenerator: 0.5.3(@babel/core@7.23.2)
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  /@babel/plugin-transform-shorthand-properties@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-eCLXXJqv8okzg86ywZJbRn19YJHU4XUa55oz2wbHhaQVn/MM+XhukiT7SYqp/7o00dg52Rj51Ny+Ecw4oyoygw==}
+  /@babel/plugin-transform-shorthand-properties@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-vM4fq9IXHscXVKzDv5itkO1X52SmdFBFcMIBZ2FRn2nqVYqw6dBexUgMvAjHW+KXpPPViD/Yo3GrDEBaRC0QYA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-spread@7.20.7(@babel/core@7.23.2):
-    resolution: {integrity: sha512-ewBbHQ+1U/VnH1fxltbJqDeWBU1oNLG8Dj11uIv3xVf7nrQu0bPGe5Rf716r7K5Qz+SqtAOVswoVunoiBtGhxw==}
+  /@babel/plugin-transform-spread@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-5ZzDQIGyvN4w8+dMmpohL6MBo+l2G7tfC/O2Dg7/hjpgeWvUx8FzfeOKxGog9IimPa4YekaQ9PlDqTLOljkcxg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/helper-skip-transparent-expression-wrappers': 7.20.0
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/helper-skip-transparent-expression-wrappers': 7.22.5
 
-  /@babel/plugin-transform-sticky-regex@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-kfiDrDQ+PBsQDO85yj1icueWMfGfJFKN1KCkndygtu/C9+XUfydLC8Iv5UYJqRwy4zk8EcplRxEOeLyjq1gm6Q==}
+  /@babel/plugin-transform-sticky-regex@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-zf7LuNpHG0iEeiyCNwX4j3gDg1jgt1k3ZdXBKbZSoA3BbGQGvMiSvfbZRR3Dr3aeJe3ooWFZxOOG3IRStYp2Bw==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-template-literals@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-S8cOWfT82gTezpYOiVaGHrCbhlHgKhQt8XH5ES46P2XWmX92yisoZywf5km75wv5sYcXDUCLMmMxOLCtthDgMA==}
+  /@babel/plugin-transform-template-literals@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-5ciOehRNf+EyUeewo8NkbQiUs4d6ZxiHo6BcBcnFlgiJfu16q0bQUw9Jvo0b0gBKFG1SMhDSjeKXSYuJLeFSMA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-typeof-symbol@7.18.9(@babel/core@7.23.2):
-    resolution: {integrity: sha512-SRfwTtF11G2aemAZWivL7PD+C9z52v9EvMqH9BuYbabyPuKUvSWks3oCg6041pT925L4zVFqaVBeECwsmlguEw==}
+  /@babel/plugin-transform-typeof-symbol@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-bYkI5lMzL4kPii4HHEEChkD0rkc+nvnlR6+o/qdqR6zrm0Sv/nodmyLhlq2DO0YKLUNd2VePmPRjJXSBh9OIdA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-typescript@7.21.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-RQxPz6Iqt8T0uw/WsJNReuBpWpBqs/n7mNo18sKLoTbMp+UrEekhH+pKSVC7gWz+DNjo9gryfV8YzCiT45RgMw==}
+  /@babel/plugin-transform-typescript@7.22.15(@babel/core@7.23.2):
+    resolution: {integrity: sha512-1uirS0TnijxvQLnlv5wQBwOX3E1wCFX7ITv+9pBV2wKEk4K+M5tqDaoNXnTH8tjEIYHLO98MwiTWO04Ggz4XuA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-annotate-as-pure': 7.18.6
-      '@babel/helper-create-class-features-plugin': 7.21.5(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-syntax-typescript': 7.21.4(@babel/core@7.23.2)
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/helper-annotate-as-pure': 7.22.5
+      '@babel/helper-create-class-features-plugin': 7.22.15(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+      '@babel/plugin-syntax-typescript': 7.22.5(@babel/core@7.23.2)
 
-  /@babel/plugin-transform-unicode-escapes@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-LYm/gTOwZqsYohlvFUe/8Tujz75LqqVC2w+2qPHLR+WyWHGCZPN1KBpJCJn+4Bk4gOkQy/IXKIge6az5MqwlOg==}
+  /@babel/plugin-transform-unicode-escapes@7.22.10(@babel/core@7.23.2):
+    resolution: {integrity: sha512-lRfaRKGZCBqDlRU3UIFovdp9c9mEvlylmpod0/OatICsSfuQ9YFthRo1tpTkGsklEefZdqlEFdY4A2dwTb6ohg==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/plugin-transform-unicode-regex@7.18.6(@babel/core@7.23.2):
-    resolution: {integrity: sha512-gE7A6Lt7YLnNOL3Pb9BNeZvi+d8l7tcRrG4+pwJjK9hD2xX4mEvjlQW60G9EEmfXVYRPv9VRQcyegIVHCql/AA==}
+  /@babel/plugin-transform-unicode-property-regex@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-HCCIb+CbJIAE6sXn5CjFQXMwkCClcOfPCzTlilJ8cUatfzwHlWQkbtV0zD338u9dZskwvuOYTuuaMaA8J5EI5A==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-create-regexp-features-plugin': 7.21.8(@babel/core@7.23.2)
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-create-regexp-features-plugin': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
+
+  /@babel/plugin-transform-unicode-regex@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-028laaOKptN5vHJf9/Arr/HiJekMd41hOEZYvNsrsXqJ7YPYuX2bQxh31fkZzGmq3YqHRJzYFFAVYvKfMPKqyg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0-0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/helper-create-regexp-features-plugin': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/polyfill@7.12.1:
-    resolution: {integrity: sha512-X0pi0V6gxLi6lFZpGmeNa4zxtwEmCs42isWLNjZZDE0Y8yVfgu0T2OAHlzBbdYlqbW/YXVvoBHpATEM+goCj8g==}
-    deprecated: 🚨 This package has been deprecated in favor of separate inclusion of a polyfill and regenerator-runtime (when needed). See the @babel/polyfill docs (https://babeljs.io/docs/en/babel-polyfill) for more information.
+  /@babel/plugin-transform-unicode-sets-regex@7.22.5(@babel/core@7.23.2):
+    resolution: {integrity: sha512-lhMfi4FC15j13eKrh3DnYHjpGj6UKQHtNKTbtc1igvAhRy4+kLhV07OpLcsN0VgDEw/MjAvJO4BdMJsHwMhzCg==}
+    engines: {node: '>=6.9.0'}
+    peerDependencies:
+      '@babel/core': ^7.0.0
     dependencies:
-      core-js: 2.6.12
-      regenerator-runtime: 0.13.11
-    dev: true
+      '@babel/core': 7.23.2
+      '@babel/helper-create-regexp-features-plugin': 7.22.9(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
 
-  /@babel/preset-env@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-wH00QnTTldTbf/IefEVyChtRdw5RJvODT/Vb4Vcxq1AZvtXj6T0YeX0cAcXhI6/BdGuiP3GcNIL4OQbI2DVNxg==}
+  /@babel/preset-env@7.23.2(@babel/core@7.23.2):
+    resolution: {integrity: sha512-BW3gsuDD+rvHL2VO2SjAUNTBe5YrjsTiDyqamPDWY723na3/yPQ65X5oQkFVJZ0o50/2d+svm1rkPoJeR1KxVQ==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
@@ -2156,31 +2385,18 @@ packages:
       '@babel/compat-data': 7.23.2
       '@babel/core': 7.23.2
       '@babel/helper-compilation-targets': 7.22.15
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
       '@babel/helper-validator-option': 7.22.15
-      '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.20.7(@babel/core@7.23.2)
-      '@babel/plugin-proposal-async-generator-functions': 7.20.7(@babel/core@7.23.2)
-      '@babel/plugin-proposal-class-properties': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-class-static-block': 7.21.0(@babel/core@7.23.2)
-      '@babel/plugin-proposal-dynamic-import': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-export-namespace-from': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-proposal-json-strings': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-logical-assignment-operators': 7.20.7(@babel/core@7.23.2)
-      '@babel/plugin-proposal-nullish-coalescing-operator': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-numeric-separator': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-object-rest-spread': 7.20.7(@babel/core@7.23.2)
-      '@babel/plugin-proposal-optional-catch-binding': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-optional-chaining': 7.21.0(@babel/core@7.23.2)
-      '@babel/plugin-proposal-private-methods': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-proposal-private-property-in-object': 7.21.0(@babel/core@7.23.2)
-      '@babel/plugin-proposal-unicode-property-regex': 7.18.6(@babel/core@7.23.2)
+      '@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression': 7.22.15(@babel/core@7.23.2)
+      '@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining': 7.22.15(@babel/core@7.23.2)
+      '@babel/plugin-proposal-private-property-in-object': 7.21.0-placeholder-for-preset-env.2(@babel/core@7.23.2)
       '@babel/plugin-syntax-async-generators': 7.8.4(@babel/core@7.23.2)
       '@babel/plugin-syntax-class-properties': 7.12.13(@babel/core@7.23.2)
       '@babel/plugin-syntax-class-static-block': 7.14.5(@babel/core@7.23.2)
       '@babel/plugin-syntax-dynamic-import': 7.8.3(@babel/core@7.23.2)
       '@babel/plugin-syntax-export-namespace-from': 7.8.3(@babel/core@7.23.2)
-      '@babel/plugin-syntax-import-assertions': 7.20.0(@babel/core@7.23.2)
+      '@babel/plugin-syntax-import-assertions': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-syntax-import-attributes': 7.22.5(@babel/core@7.23.2)
       '@babel/plugin-syntax-import-meta': 7.10.4(@babel/core@7.23.2)
       '@babel/plugin-syntax-json-strings': 7.8.3(@babel/core@7.23.2)
       '@babel/plugin-syntax-logical-assignment-operators': 7.10.4(@babel/core@7.23.2)
@@ -2191,83 +2407,96 @@ packages:
       '@babel/plugin-syntax-optional-chaining': 7.8.3(@babel/core@7.23.2)
       '@babel/plugin-syntax-private-property-in-object': 7.14.5(@babel/core@7.23.2)
       '@babel/plugin-syntax-top-level-await': 7.14.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-arrow-functions': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-async-to-generator': 7.20.7(@babel/core@7.23.2)
-      '@babel/plugin-transform-block-scoped-functions': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-block-scoping': 7.21.0(@babel/core@7.23.2)
-      '@babel/plugin-transform-classes': 7.21.0(@babel/core@7.23.2)
-      '@babel/plugin-transform-computed-properties': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-destructuring': 7.21.3(@babel/core@7.23.2)
-      '@babel/plugin-transform-dotall-regex': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-duplicate-keys': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-transform-exponentiation-operator': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-for-of': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-function-name': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-transform-literals': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-transform-member-expression-literals': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-modules-amd': 7.20.11(@babel/core@7.23.2)
-      '@babel/plugin-transform-modules-commonjs': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-modules-systemjs': 7.20.11(@babel/core@7.23.2)
-      '@babel/plugin-transform-modules-umd': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-named-capturing-groups-regex': 7.20.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-new-target': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-object-super': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-parameters': 7.21.3(@babel/core@7.23.2)
-      '@babel/plugin-transform-property-literals': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-regenerator': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-reserved-words': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-shorthand-properties': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-spread': 7.20.7(@babel/core@7.23.2)
-      '@babel/plugin-transform-sticky-regex': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-template-literals': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-transform-typeof-symbol': 7.18.9(@babel/core@7.23.2)
-      '@babel/plugin-transform-unicode-escapes': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-unicode-regex': 7.18.6(@babel/core@7.23.2)
-      '@babel/preset-modules': 0.1.5(@babel/core@7.23.2)
+      '@babel/plugin-syntax-unicode-sets-regex': 7.18.6(@babel/core@7.23.2)
+      '@babel/plugin-transform-arrow-functions': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-async-generator-functions': 7.23.2(@babel/core@7.23.2)
+      '@babel/plugin-transform-async-to-generator': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-block-scoped-functions': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-block-scoping': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-class-properties': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-class-static-block': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-classes': 7.22.15(@babel/core@7.23.2)
+      '@babel/plugin-transform-computed-properties': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-destructuring': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-dotall-regex': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-duplicate-keys': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-dynamic-import': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-exponentiation-operator': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-export-namespace-from': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-for-of': 7.22.15(@babel/core@7.23.2)
+      '@babel/plugin-transform-function-name': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-json-strings': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-literals': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-logical-assignment-operators': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-member-expression-literals': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-modules-amd': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-modules-commonjs': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-modules-systemjs': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-modules-umd': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-named-capturing-groups-regex': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-new-target': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-nullish-coalescing-operator': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-numeric-separator': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-object-rest-spread': 7.22.15(@babel/core@7.23.2)
+      '@babel/plugin-transform-object-super': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-optional-catch-binding': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-optional-chaining': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-parameters': 7.22.15(@babel/core@7.23.2)
+      '@babel/plugin-transform-private-methods': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-private-property-in-object': 7.22.11(@babel/core@7.23.2)
+      '@babel/plugin-transform-property-literals': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-regenerator': 7.22.10(@babel/core@7.23.2)
+      '@babel/plugin-transform-reserved-words': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-shorthand-properties': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-spread': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-sticky-regex': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-template-literals': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-typeof-symbol': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-unicode-escapes': 7.22.10(@babel/core@7.23.2)
+      '@babel/plugin-transform-unicode-property-regex': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-unicode-regex': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-unicode-sets-regex': 7.22.5(@babel/core@7.23.2)
+      '@babel/preset-modules': 0.1.6-no-external-plugins(@babel/core@7.23.2)
       '@babel/types': 7.23.0
-      babel-plugin-polyfill-corejs2: 0.3.3(@babel/core@7.23.2)
-      babel-plugin-polyfill-corejs3: 0.6.0(@babel/core@7.23.2)
-      babel-plugin-polyfill-regenerator: 0.4.1(@babel/core@7.23.2)
-      core-js-compat: 3.30.1
+      babel-plugin-polyfill-corejs2: 0.4.6(@babel/core@7.23.2)
+      babel-plugin-polyfill-corejs3: 0.8.6(@babel/core@7.23.2)
+      babel-plugin-polyfill-regenerator: 0.5.3(@babel/core@7.23.2)
+      core-js-compat: 3.32.0
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  /@babel/preset-modules@0.1.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-A57th6YRG7oR3cq/yt/Y84MvGgE0eJG2F1JLhKuyG+jFxEgrd/HAMJatiFtmOiZurz+0DkrvbheCLaV5f2JfjA==}
+  /@babel/preset-modules@0.1.6-no-external-plugins(@babel/core@7.23.2):
+    resolution: {integrity: sha512-HrcgcIESLm9aIR842yhJ5RWan/gebQUJ6E/E5+rf0y9o6oj7w0Br+sWuL6kEQ/o/AdfvR1Je9jG18/gnpwjEyA==}
     peerDependencies:
-      '@babel/core': ^7.0.0-0
+      '@babel/core': ^7.0.0-0 || ^8.0.0-0 <8.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
-      '@babel/plugin-proposal-unicode-property-regex': 7.18.6(@babel/core@7.23.2)
-      '@babel/plugin-transform-dotall-regex': 7.18.6(@babel/core@7.23.2)
+      '@babel/helper-plugin-utils': 7.22.5
       '@babel/types': 7.23.0
       esutils: 2.0.3
 
-  /@babel/preset-typescript@7.21.5(@babel/core@7.23.2):
-    resolution: {integrity: sha512-iqe3sETat5EOrORXiQ6rWfoOg2y68Cs75B9wNxdPW4kixJxh7aXQE1KPdWLDniC24T/6dSnguF33W9j/ZZQcmA==}
+  /@babel/preset-typescript@7.23.2(@babel/core@7.23.2):
+    resolution: {integrity: sha512-u4UJc1XsS1GhIGteM8rnGiIvf9rJpiVgMEeCnwlLA7WJPC+jcXWJAGxYmeqs5hOZD8BbAfnV5ezBOxQbb4OUxA==}
     engines: {node: '>=6.9.0'}
     peerDependencies:
       '@babel/core': ^7.0.0-0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-plugin-utils': 7.21.5
+      '@babel/helper-plugin-utils': 7.22.5
       '@babel/helper-validator-option': 7.22.15
-      '@babel/plugin-syntax-jsx': 7.21.4(@babel/core@7.23.2)
-      '@babel/plugin-transform-modules-commonjs': 7.21.5(@babel/core@7.23.2)
-      '@babel/plugin-transform-typescript': 7.21.3(@babel/core@7.23.2)
-    transitivePeerDependencies:
-      - supports-color
+      '@babel/plugin-syntax-jsx': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-modules-commonjs': 7.23.0(@babel/core@7.23.2)
+      '@babel/plugin-transform-typescript': 7.22.15(@babel/core@7.23.2)
 
   /@babel/regjsgen@0.8.0:
     resolution: {integrity: sha512-x/rqGMdzj+fWZvCOYForTghzbtqPDZ5gPwaoNGHdgDfF2QA/XZbCBp4Moo5scrkAMPhB7z26XM/AaHuIJdgauA==}
 
-  /@babel/runtime@7.21.5:
-    resolution: {integrity: sha512-8jI69toZqqcsnqGGqwGS4Qb1VwLOEp4hz+CXPywcvjs60u3B4Pom/U/7rm4W8tMOYEB+E9wgD0mW1l3r8qlI9Q==}
+  /@babel/runtime@7.23.2:
+    resolution: {integrity: sha512-mM8eg4yl5D6i3lu2QKPuPH4FArvJ8KhTofbE7jwMUv9KX5mBvwPAqnV3MlyBNqdp9RyRKP6Yck8TrfYrPvX3bg==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      regenerator-runtime: 0.13.11
+      regenerator-runtime: 0.14.0
 
   /@babel/template@7.22.15:
     resolution: {integrity: sha512-QPErUVm4uyJa60rkI73qneDacvdvzxshT3kksGqlGWYdOTIUOwJ7RDUL8sGqslY1uXWSL6xMFKEXDS3ox2uF0w==}
@@ -2277,23 +2506,13 @@ packages:
       '@babel/parser': 7.23.0
       '@babel/types': 7.23.0
 
-  /@babel/traverse@7.21.5:
-    resolution: {integrity: sha512-AhQoI3YjWi6u/y/ntv7k48mcrCXmus0t79J9qPNlk/lAsFlCiJ047RmbfMOawySTHtywXhbXgpx/8nXMYd+oFw==}
+  /@babel/template@7.22.5:
+    resolution: {integrity: sha512-X7yV7eiwAxdj9k94NEylvbVHLiVG1nvzCV2EAowhxLTwODV1jl9UzZ48leOC0sH7OnuHrIkllaBgneUykIcZaw==}
     engines: {node: '>=6.9.0'}
     dependencies:
-      '@babel/code-frame': 7.22.13
-      '@babel/generator': 7.23.0
-      '@babel/helper-environment-visitor': 7.22.20
-      '@babel/helper-function-name': 7.23.0
-      '@babel/helper-hoist-variables': 7.22.5
-      '@babel/helper-split-export-declaration': 7.22.6
-      '@babel/parser': 7.23.0
+      '@babel/code-frame': 7.22.10
+      '@babel/parser': 7.22.10
       '@babel/types': 7.23.0
-      debug: 4.3.4(supports-color@8.1.1)
-      globals: 11.12.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
 
   /@babel/traverse@7.23.2:
     resolution: {integrity: sha512-azpe59SQ48qG6nu2CzcMLbxUudtN+dOM9kDbUqGq3HXUJRlo7i8fvPoxQUzYgLZ4cMVmuZgm8vvBpNeRhd6XSw==}
@@ -2312,15 +2531,6 @@ packages:
     transitivePeerDependencies:
       - supports-color
 
-  /@babel/types@7.21.5:
-    resolution: {integrity: sha512-m4AfNvVF2mVC/F7fDEdH2El3HzUg9It/XsCxZiOTTA3m3qYfcSVSbTfM6Q9xG+hYDniZssYhlXKKUMD5m8tF4Q==}
-    engines: {node: '>=6.9.0'}
-    dependencies:
-      '@babel/helper-string-parser': 7.22.5
-      '@babel/helper-validator-identifier': 7.22.20
-      to-fast-properties: 2.0.0
-    dev: true
-
   /@babel/types@7.23.0:
     resolution: {integrity: sha512-0oIyUfKoI3mSqMvsxBdclDwxXKXAUA8v/apZbc+iSyARYou1o8ZGDxbUYyLFoW2arqS2jDGqJuZvv1d/io1axg==}
     engines: {node: '>=6.9.0'}
@@ -2329,15 +2539,6 @@ packages:
       '@babel/helper-validator-identifier': 7.22.20
       to-fast-properties: 2.0.0
 
-  /@cnakazawa/watch@1.0.4:
-    resolution: {integrity: sha512-v9kIhKwjeZThiWrLmj0y17CWoyddASLj9O2yvbZkbvw/N3rWOYy9zkV66ursAoVr0mV15bL8g0c4QZUE6cdDoQ==}
-    engines: {node: '>=0.1.95'}
-    hasBin: true
-    dependencies:
-      exec-sh: 0.3.6
-      minimist: 1.2.8
-    dev: true
-
   /@cspotcode/source-map-support@0.8.1:
     resolution: {integrity: sha512-IchNf6dN4tHoMFIn/7OE8LWZ19Y6q/67Bmf6vnGREv8RSbBVb9LPJxEcnwrcwX6ixSvaiGoomAUvu4YSxXrVgw==}
     engines: {node: '>=12'}
@@ -2348,7 +2549,7 @@ packages:
     resolution: {integrity: sha512-BDXFbYOJzT/NBEtp71cvsrGPwGAMGRB/349rwKuoxNSiKjPraNNnlK6MIIabViCjqZugu6j+xeMDlEkWdHHJSg==}
     dependencies:
       '@esbuild-kit/core-utils': 3.1.0
-      get-tsconfig: 4.5.0
+      get-tsconfig: 4.7.2
     dev: true
 
   /@esbuild-kit/core-utils@3.1.0:
@@ -2362,7 +2563,7 @@ packages:
     resolution: {integrity: sha512-Qwfvj/qoPbClxCRNuac1Du01r9gvNOT+pMYtJDapfB1eoGN1YlJ1BixLyL9WVENRx5RXgNLdfYdx/CuswlGhMw==}
     dependencies:
       '@esbuild-kit/core-utils': 3.1.0
-      get-tsconfig: 4.5.0
+      get-tsconfig: 4.7.2
     dev: true
 
   /@esbuild/android-arm64@0.17.18:
@@ -2371,6 +2572,15 @@ packages:
     cpu: [arm64]
     os: [android]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/android-arm64@0.18.20:
+    resolution: {integrity: sha512-Nz4rJcchGDtENV0eMKUNa6L12zz2zBDXuhj/Vjh18zGqB44Bi7MBMSXjgunJgjRhCmKOjnPuZp4Mb6OKqtMHLQ==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [android]
+    requiresBuild: true
     optional: true
 
   /@esbuild/android-arm@0.17.18:
@@ -2379,6 +2589,15 @@ packages:
     cpu: [arm]
     os: [android]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/android-arm@0.18.20:
+    resolution: {integrity: sha512-fyi7TDI/ijKKNZTUJAQqiG5T7YjJXgnzkURqmGj13C6dCqckZBLdl4h7bkhHt/t0WP+zO9/zwroDvANaOqO5Sw==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [android]
+    requiresBuild: true
     optional: true
 
   /@esbuild/android-x64@0.17.18:
@@ -2387,6 +2606,15 @@ packages:
     cpu: [x64]
     os: [android]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/android-x64@0.18.20:
+    resolution: {integrity: sha512-8GDdlePJA8D6zlZYJV/jnrRAi6rOiNaCC/JclcXpB+KIuvfBN4owLtgzY2bsxnx666XjJx2kDPUmnTtR8qKQUg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [android]
+    requiresBuild: true
     optional: true
 
   /@esbuild/darwin-arm64@0.17.18:
@@ -2395,6 +2623,15 @@ packages:
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/darwin-arm64@0.18.20:
+    resolution: {integrity: sha512-bxRHW5kHU38zS2lPTPOyuyTm+S+eobPUnTNkdJEfAddYgEcll4xkT8DB9d2008DtTbl7uJag2HuE5NZAZgnNEA==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
     optional: true
 
   /@esbuild/darwin-x64@0.17.18:
@@ -2403,14 +2640,32 @@ packages:
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
+    dev: true
     optional: true
 
-  /@esbuild/freebsd-arm64@0.17.18:
-    resolution: {integrity: sha512-fw/ZfxfAzuHfaQeMDhbzxp9mc+mHn1Y94VDHFHjGvt2Uxl10mT4CDavHm+/L9KG441t1QdABqkVYwakMUeyLRA==}
+  /@esbuild/darwin-x64@0.18.20:
+    resolution: {integrity: sha512-pc5gxlMDxzm513qPGbCbDukOdsGtKhfxD1zJKXjCCcU7ju50O7MeAZ8c4krSJcOIJGFR+qx21yMMVYwiQvyTyQ==}
     engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [freebsd]
-    requiresBuild: true
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    optional: true
+
+  /@esbuild/freebsd-arm64@0.17.18:
+    resolution: {integrity: sha512-fw/ZfxfAzuHfaQeMDhbzxp9mc+mHn1Y94VDHFHjGvt2Uxl10mT4CDavHm+/L9KG441t1QdABqkVYwakMUeyLRA==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/freebsd-arm64@0.18.20:
+    resolution: {integrity: sha512-yqDQHy4QHevpMAaxhhIwYPMv1NECwOvIpGCZkECn8w2WFHXjEwrBn3CeNIYsibZ/iZEUemj++M26W3cNR5h+Tw==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [freebsd]
+    requiresBuild: true
     optional: true
 
   /@esbuild/freebsd-x64@0.17.18:
@@ -2419,6 +2674,15 @@ packages:
     cpu: [x64]
     os: [freebsd]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/freebsd-x64@0.18.20:
+    resolution: {integrity: sha512-tgWRPPuQsd3RmBZwarGVHZQvtzfEBOreNuxEMKFcd5DaDn2PbBxfwLcj4+aenoh7ctXcbXmOQIn8HI6mCSw5MQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [freebsd]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-arm64@0.17.18:
@@ -2427,6 +2691,15 @@ packages:
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-arm64@0.18.20:
+    resolution: {integrity: sha512-2YbscF+UL7SQAVIpnWvYwM+3LskyDmPhe31pE7/aoTMFKKzIc9lLbyGUpmmb8a8AixOL61sQ/mFh3jEjHYFvdA==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-arm@0.17.18:
@@ -2435,6 +2708,15 @@ packages:
     cpu: [arm]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-arm@0.18.20:
+    resolution: {integrity: sha512-/5bHkMWnq1EgKr1V+Ybz3s1hWXok7mDFUMQ4cG10AfW3wL02PSZi5kFpYKrptDsgb2WAJIvRcDm+qIvXf/apvg==}
+    engines: {node: '>=12'}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-ia32@0.17.18:
@@ -2443,6 +2725,15 @@ packages:
     cpu: [ia32]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-ia32@0.18.20:
+    resolution: {integrity: sha512-P4etWwq6IsReT0E1KHU40bOnzMHoH73aXp96Fs8TIT6z9Hu8G6+0SHSw9i2isWrD2nbx2qo5yUqACgdfVGx7TA==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-loong64@0.17.18:
@@ -2451,6 +2742,15 @@ packages:
     cpu: [loong64]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-loong64@0.18.20:
+    resolution: {integrity: sha512-nXW8nqBTrOpDLPgPY9uV+/1DjxoQ7DoB2N8eocyq8I9XuqJ7BiAMDMf9n1xZM9TgW0J8zrquIb/A7s3BJv7rjg==}
+    engines: {node: '>=12'}
+    cpu: [loong64]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-mips64el@0.17.18:
@@ -2459,6 +2759,15 @@ packages:
     cpu: [mips64el]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-mips64el@0.18.20:
+    resolution: {integrity: sha512-d5NeaXZcHp8PzYy5VnXV3VSd2D328Zb+9dEq5HE6bw6+N86JVPExrA6O68OPwobntbNJ0pzCpUFZTo3w0GyetQ==}
+    engines: {node: '>=12'}
+    cpu: [mips64el]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-ppc64@0.17.18:
@@ -2467,6 +2776,15 @@ packages:
     cpu: [ppc64]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-ppc64@0.18.20:
+    resolution: {integrity: sha512-WHPyeScRNcmANnLQkq6AfyXRFr5D6N2sKgkFo2FqguP44Nw2eyDlbTdZwd9GYk98DZG9QItIiTlFLHJHjxP3FA==}
+    engines: {node: '>=12'}
+    cpu: [ppc64]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-riscv64@0.17.18:
@@ -2475,6 +2793,15 @@ packages:
     cpu: [riscv64]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-riscv64@0.18.20:
+    resolution: {integrity: sha512-WSxo6h5ecI5XH34KC7w5veNnKkju3zBRLEQNY7mv5mtBmrP/MjNBCAlsM2u5hDBlS3NGcTQpoBvRzqBcRtpq1A==}
+    engines: {node: '>=12'}
+    cpu: [riscv64]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-s390x@0.17.18:
@@ -2483,6 +2810,15 @@ packages:
     cpu: [s390x]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-s390x@0.18.20:
+    resolution: {integrity: sha512-+8231GMs3mAEth6Ja1iK0a1sQ3ohfcpzpRLH8uuc5/KVDFneH6jtAJLFGafpzpMRO6DzJ6AvXKze9LfFMrIHVQ==}
+    engines: {node: '>=12'}
+    cpu: [s390x]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/linux-x64@0.17.18:
@@ -2491,6 +2827,15 @@ packages:
     cpu: [x64]
     os: [linux]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/linux-x64@0.18.20:
+    resolution: {integrity: sha512-UYqiqemphJcNsFEskc73jQ7B9jgwjWrSayxawS6UVFZGWrAAtkzjxSqnoclCXxWtfwLdzU+vTpcNYhpn43uP1w==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
     optional: true
 
   /@esbuild/netbsd-x64@0.17.18:
@@ -2499,6 +2844,15 @@ packages:
     cpu: [x64]
     os: [netbsd]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/netbsd-x64@0.18.20:
+    resolution: {integrity: sha512-iO1c++VP6xUBUmltHZoMtCUdPlnPGdBom6IrO4gyKPFFVBKioIImVooR5I83nTew5UOYrk3gIJhbZh8X44y06A==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [netbsd]
+    requiresBuild: true
     optional: true
 
   /@esbuild/openbsd-x64@0.17.18:
@@ -2507,6 +2861,15 @@ packages:
     cpu: [x64]
     os: [openbsd]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/openbsd-x64@0.18.20:
+    resolution: {integrity: sha512-e5e4YSsuQfX4cxcygw/UCPIEP6wbIL+se3sxPdCiMbFLBWu0eiZOJ7WoD+ptCLrmjZBK1Wk7I6D/I3NglUGOxg==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [openbsd]
+    requiresBuild: true
     optional: true
 
   /@esbuild/sunos-x64@0.17.18:
@@ -2515,6 +2878,15 @@ packages:
     cpu: [x64]
     os: [sunos]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/sunos-x64@0.18.20:
+    resolution: {integrity: sha512-kDbFRFp0YpTQVVrqUd5FTYmWo45zGaXe0X8E1G/LKFC0v8x0vWrhOWSLITcCn63lmZIxfOMXtCfti/RxN/0wnQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [sunos]
+    requiresBuild: true
     optional: true
 
   /@esbuild/win32-arm64@0.17.18:
@@ -2523,6 +2895,15 @@ packages:
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/win32-arm64@0.18.20:
+    resolution: {integrity: sha512-ddYFR6ItYgoaq4v4JmQQaAI5s7npztfV4Ag6NrhiaW0RrnOXqBkgwZLofVTlq1daVTQNhtI5oieTvkRPfZrePg==}
+    engines: {node: '>=12'}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
     optional: true
 
   /@esbuild/win32-ia32@0.17.18:
@@ -2531,6 +2912,15 @@ packages:
     cpu: [ia32]
     os: [win32]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/win32-ia32@0.18.20:
+    resolution: {integrity: sha512-Wv7QBi3ID/rROT08SABTS7eV4hX26sVduqDOTe1MvGMjNd3EjOz4b7zeexIR62GTIEKrfJXKL9LFxTYgkyeu7g==}
+    engines: {node: '>=12'}
+    cpu: [ia32]
+    os: [win32]
+    requiresBuild: true
     optional: true
 
   /@esbuild/win32-x64@0.17.18:
@@ -2539,28 +2929,51 @@ packages:
     cpu: [x64]
     os: [win32]
     requiresBuild: true
+    dev: true
+    optional: true
+
+  /@esbuild/win32-x64@0.18.20:
+    resolution: {integrity: sha512-kTdfRcSiDfQca/y9QIkng02avJ+NCaQvrMejlsB3RRv5sE9rRoeBPISaZpKxHELzRxZyLvNts1P27W3wV+8geQ==}
+    engines: {node: '>=12'}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
     optional: true
 
-  /@eslint-community/eslint-utils@4.4.0(eslint@8.40.0):
+  /@eslint-community/eslint-utils@4.4.0(eslint@8.47.0):
+    resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
+    dependencies:
+      eslint: 8.47.0
+      eslint-visitor-keys: 3.4.3
+
+  /@eslint-community/eslint-utils@4.4.0(eslint@8.53.0):
     resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
     dependencies:
-      eslint: 8.40.0
-      eslint-visitor-keys: 3.4.1
+      eslint: 8.53.0
+      eslint-visitor-keys: 3.4.3
 
   /@eslint-community/regexpp@4.5.1:
     resolution: {integrity: sha512-Z5ba73P98O1KUYCCJTUeVpja9RcGoMdncZ6T49FCUl2lN38JtCJ+3WgIDBv0AuY4WChU5PmtJmOCTlN6FZTFKQ==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
+    dev: false
+
+  /@eslint-community/regexpp@4.6.2:
+    resolution: {integrity: sha512-pPTNuaAG3QMH+buKyBIGJs3g/S5y0caxw0ygM3YyE6yJFySwiGGSzA+mM3KJ8QQvzeLh3blwgSonkFjgQdxzMw==}
+    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
 
-  /@eslint/eslintrc@1.4.1:
-    resolution: {integrity: sha512-XXrH9Uarn0stsyldqDYq8r++mROmWRI1xKMXa640Bb//SY1+ECYX6VzT6Lcx5frD0V30XieqJ0oX9I2Xj5aoMA==}
+  /@eslint/eslintrc@2.1.2:
+    resolution: {integrity: sha512-+wvgpDsrB1YqAMdEUCcnTlpfVBH7Vqn6A/NT3D8WVXFIaKMlErPIZT3oCIAVCOtarRpMtelZLqJeU3t7WY6X6g==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       ajv: 6.12.6
       debug: 4.3.4(supports-color@8.1.1)
-      espree: 9.5.2
+      espree: 9.6.1
       globals: 13.20.0
       ignore: 5.2.4
       import-fresh: 3.3.0
@@ -2569,15 +2982,14 @@ packages:
       strip-json-comments: 3.1.1
     transitivePeerDependencies:
       - supports-color
-    dev: true
 
-  /@eslint/eslintrc@2.0.3:
-    resolution: {integrity: sha512-+5gy6OQfk+xx3q0d6jGZZC3f3KzAkXc/IanVxd1is/VIIziRqqt3ongQz0FiTUXqTk0c7aDB3OaFuKnuSoJicQ==}
+  /@eslint/eslintrc@2.1.3:
+    resolution: {integrity: sha512-yZzuIG+jnVu6hNSzFEN07e8BxF3uAzYtQb6uDkaYZLo6oYZDCq454c5kB8zxnzfCYyP4MIuyBn10L0DqwujTmA==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       ajv: 6.12.6
       debug: 4.3.4(supports-color@8.1.1)
-      espree: 9.5.2
+      espree: 9.6.1
       globals: 13.20.0
       ignore: 5.2.4
       import-fresh: 3.3.0
@@ -2587,8 +2999,12 @@ packages:
     transitivePeerDependencies:
       - supports-color
 
-  /@eslint/js@8.40.0:
-    resolution: {integrity: sha512-ElyB54bJIhXQYVKjDSvCkPO1iU1tSAeVQJbllWJq1XQSmmA4dgFk8CbiBGpiOPxleE48vDogxCtmMYku4HSVLA==}
+  /@eslint/js@8.47.0:
+    resolution: {integrity: sha512-P6omY1zv5MItm93kLM8s2vr1HICJH8v0dvddDhysbIuZ+vcjOHg5Zbkf1mTkcmi2JA9oBG2anOkRnW8WJTS8Og==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  /@eslint/js@8.53.0:
+    resolution: {integrity: sha512-Kn7K8dx/5U6+cT1yEhpX1w4PCSg0M+XyRILPgvwcEBjerFWCwQj5sbr3/VmxqV0JGHCBCzyd6LxypEuehypY1w==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
 
   /@gar/promisify@1.1.3:
@@ -2606,8 +3022,8 @@ packages:
     resolution: {integrity: sha512-EP9uEDZv/L5Qh9IWuMUGJRfwhXJ4h1dqKTT4/3+tY0eu7sPis7xh23j61SYUnNF4vqCQvvUXpDo9Bh/+q1zASA==}
     dev: false
 
-  /@humanwhocodes/config-array@0.11.8:
-    resolution: {integrity: sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==}
+  /@humanwhocodes/config-array@0.11.10:
+    resolution: {integrity: sha512-KVVjQmNUepDVGXNuoRRdmmEjruj0KfiGSbS8LVc12LMsWDQzRXJ0qdhN8L8uUigKpfEHRhlaQFY0ib1tnUbNeQ==}
     engines: {node: '>=10.10.0'}
     dependencies:
       '@humanwhocodes/object-schema': 1.2.1
@@ -2616,6 +3032,16 @@ packages:
     transitivePeerDependencies:
       - supports-color
 
+  /@humanwhocodes/config-array@0.11.13:
+    resolution: {integrity: sha512-JSBDMiDKSzQVngfRjOdFXgFfklaXI4K9nLF49Auh21lmBWRLIK3+xTErTWD4KU54pb6coM6ESE7Awz/FNU3zgQ==}
+    engines: {node: '>=10.10.0'}
+    dependencies:
+      '@humanwhocodes/object-schema': 2.0.1
+      debug: 4.3.4(supports-color@8.1.1)
+      minimatch: 3.1.2
+    transitivePeerDependencies:
+      - supports-color
+
   /@humanwhocodes/module-importer@1.0.1:
     resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
     engines: {node: '>=12.22'}
@@ -2623,6 +3049,9 @@ packages:
   /@humanwhocodes/object-schema@1.2.1:
     resolution: {integrity: sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==}
 
+  /@humanwhocodes/object-schema@2.0.1:
+    resolution: {integrity: sha512-dvuCeX5fC9dXgJn9t+X5atfmgQAzUOWqS1254Gh0m6i8wKd10ebXkfNKiRK+1GWi/yTvvLDHpoxLr0xxxeslWw==}
+
   /@iarna/toml@2.2.5:
     resolution: {integrity: sha512-trnsAYxU3xnS1gPHPyU961coFyLkh4gAD/0zQ5mymY4yOZ+CYvsPqUbOFSw0aDM4y0tV7tiFxL/1XfXPNC6IPg==}
     dev: true
@@ -2644,46 +3073,49 @@ packages:
     dependencies:
       '@jridgewell/set-array': 1.1.2
       '@jridgewell/sourcemap-codec': 1.4.15
-      '@jridgewell/trace-mapping': 0.3.19
+      '@jridgewell/trace-mapping': 0.3.18
 
-  /@jridgewell/resolve-uri@3.1.1:
-    resolution: {integrity: sha512-dSYZh7HhCDtCKm4QakX0xFpsRDqjjtZf/kjI/v3T3Nwt5r8/qz/M19F9ySyOqU94SXBmeG9ttTul+YnR4LOxFA==}
+  /@jridgewell/resolve-uri@3.1.0:
+    resolution: {integrity: sha512-F2msla3tad+Mfht5cJq7LSXcdudKTWCVYUgw6pLFOOHSTtZlj6SWNYAp+AhuqLmWdBO2X5hPrLcu8cVP8fy28w==}
     engines: {node: '>=6.0.0'}
 
   /@jridgewell/set-array@1.1.2:
     resolution: {integrity: sha512-xnkseuNADM0gt2bs+BvhO0p78Mk762YnZdsuzFV018NoG1Sj1SCQvpSqa7XUaTam5vAGasABV9qXASMKnFMwMw==}
     engines: {node: '>=6.0.0'}
 
-  /@jridgewell/source-map@0.3.5:
-    resolution: {integrity: sha512-UTYAUj/wviwdsMfzoSJspJxbkH5o1snzwX0//0ENX1u/55kkZZkcTZP6u9bwKGkv+dkk9at4m1Cpt0uY80kcpQ==}
+  /@jridgewell/source-map@0.3.3:
+    resolution: {integrity: sha512-b+fsZXeLYi9fEULmfBrhxn4IrPlINf8fiNarzTof004v3lFdntdwa9PF7vFJqm3mg7s+ScJMxXaE3Acp1irZcg==}
     dependencies:
       '@jridgewell/gen-mapping': 0.3.3
-      '@jridgewell/trace-mapping': 0.3.19
+      '@jridgewell/trace-mapping': 0.3.18
+
+  /@jridgewell/sourcemap-codec@1.4.14:
+    resolution: {integrity: sha512-XPSJHWmi394fuUuzDnGz1wiKqWfo1yXecHQMRf2l6hztTO+nPru658AyDngaBe7isIxEkRsPR3FZh+s7iVa4Uw==}
 
   /@jridgewell/sourcemap-codec@1.4.15:
     resolution: {integrity: sha512-eF2rxCRulEKXHTRiDrDy6erMYWqNw4LPdQ8UQA4huuxaQsVeRPFl2oM8oDGxMFhJUWZf9McpLtJasDDZb/Bpeg==}
 
-  /@jridgewell/trace-mapping@0.3.19:
-    resolution: {integrity: sha512-kf37QtfW+Hwx/buWGMPcR60iF9ziHa6r/CZJIHbmcm4+0qrXiVdxegAH0F6yddEVQ7zdkjcGCgCzUu+BcbhQxw==}
+  /@jridgewell/trace-mapping@0.3.18:
+    resolution: {integrity: sha512-w+niJYzMHdd7USdiH2U6869nqhD2nbfZXND5Yp93qIbEmnDNk7PD48o+YchRVpzMU7M6jVCbenTR7PA1FLQ9pA==}
     dependencies:
-      '@jridgewell/resolve-uri': 3.1.1
-      '@jridgewell/sourcemap-codec': 1.4.15
+      '@jridgewell/resolve-uri': 3.1.0
+      '@jridgewell/sourcemap-codec': 1.4.14
 
   /@jridgewell/trace-mapping@0.3.9:
     resolution: {integrity: sha512-3Belt6tdc8bPgAtbcmdtNJlirVoTmEb5e2gC94PnkwEW9jI6CAHUeoG85tjWP5WquqfavoMtMwiG4P926ZKKuQ==}
     dependencies:
-      '@jridgewell/resolve-uri': 3.1.1
+      '@jridgewell/resolve-uri': 3.1.0
       '@jridgewell/sourcemap-codec': 1.4.15
 
   /@ljharb/through@2.3.11:
     resolution: {integrity: sha512-ccfcIDlogiXNq5KcbAwbaO7lMh3Tm1i3khMPYpxlK8hH/W53zN81KM9coerRLOnTGu3nfXIniAmQbRI9OxbC0w==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
     dev: true
 
-  /@mdn/browser-compat-data@5.2.56:
-    resolution: {integrity: sha512-1Pu6qcdJ1tQApjhWONtf8XtXH4bG9qnRyry+mYzNgZhfawoO2ODJWasvDf4pgEPlaHbxxFuZFL5l3UeKCdS3Xg==}
+  /@mdn/browser-compat-data@5.3.11:
+    resolution: {integrity: sha512-jczDSsCfDeAdGAaUPA/r7G2lFjVz/oE1qClHkM5zw8fw+Vod1RMlwlF//UMgbe/V8G57RYe7UXGpTmiWjFg3Cg==}
     dev: false
 
   /@nodelib/fs.scandir@2.1.5:
@@ -2810,7 +3242,7 @@ packages:
       '@octokit/request-error': 3.0.3
       '@octokit/types': 9.3.2
       is-plain-object: 5.0.0
-      node-fetch: 2.7.0
+      node-fetch: 2.6.12
       universal-user-agent: 6.0.0
     transitivePeerDependencies:
       - encoding
@@ -2850,8 +3282,8 @@ packages:
     requiresBuild: true
     optional: true
 
-  /@pkgr/utils@2.4.0:
-    resolution: {integrity: sha512-2OCURAmRtdlL8iUDTypMrrxfwe8frXTeXaxGsVOaYtc/wrUyk8Z/0OBetM7cdlsy7ZFWlMX72VogKeh+A4Xcjw==}
+  /@pkgr/utils@2.4.2:
+    resolution: {integrity: sha512-POgTXhjrTfbTV63DiFXav4lBHiICLKKwDeaKn9Nphwj7WH6m0hMMCaJkMyRWjgtPFyRKRVoMXXjczsTQRDEhYw==}
     engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
     dependencies:
       cross-spawn: 7.0.3
@@ -2860,6 +3292,7 @@ packages:
       open: 9.1.0
       picocolors: 1.0.0
       tslib: 2.6.2
+    dev: true
 
   /@pnpm/config.env-replace@1.1.0:
     resolution: {integrity: sha512-htyl8TWnKL7K/ESFa1oW2UB5lVDxuF5DpM7tBi6Hu2LNL3mWkIzNLG6N4zoCUP1lCKNxWy/3iu8mS8MvToGd6w==}
@@ -2882,12 +3315,12 @@ packages:
       config-chain: 1.1.13
     dev: true
 
-  /@puppeteer/browsers@1.1.0(typescript@5.0.4):
+  /@puppeteer/browsers@1.1.0(typescript@5.2.2):
     resolution: {integrity: sha512-+Nfk52G9cRAKq/V2LEaOlKIMsIuERSofk8hXEy6kMQtjg9Te1iuKymWOR+iKwwzj1RCkZU0fuOoSIclR839MNw==}
     engines: {node: '>=16.0.0'}
     hasBin: true
     peerDependencies:
-      typescript: '>= 4.7.4 || 5'
+      typescript: ^5.2.2 || 5
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -2899,11 +3332,28 @@ packages:
       progress: 2.0.3
       proxy-from-env: 1.1.0
       tar-fs: 2.1.1
-      typescript: 5.0.4
+      typescript: 5.2.2
       unbzip2-stream: 1.4.3
       yargs: 17.7.1
     transitivePeerDependencies:
       - supports-color
+    dev: false
+
+  /@puppeteer/browsers@1.8.0:
+    resolution: {integrity: sha512-TkRHIV6k2D8OlUe8RtG+5jgOF/H98Myx0M6AOafC8DdNVOFiBSFa5cpRDtpm8LXOa9sVwe0+e6Q3FC56X/DZfg==}
+    engines: {node: '>=16.3.0'}
+    hasBin: true
+    dependencies:
+      debug: 4.3.4(supports-color@8.1.1)
+      extract-zip: 2.0.1
+      progress: 2.0.3
+      proxy-agent: 6.3.1
+      tar-fs: 3.0.4
+      unbzip2-stream: 1.4.3
+      yargs: 17.7.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
 
   /@release-it-plugins/lerna-changelog@6.0.0(release-it@16.2.1):
     resolution: {integrity: sha512-/1xNLriHKKTdM+/LSQIng5V25gipw0brAXtWVQcOBR63NmW/Ftnd2IJpnM5WzFkOCcL9hoqc8rcIMMv1EOcaIg==}
@@ -2915,7 +3365,7 @@ packages:
       lerna-changelog: 2.2.0
       lodash.template: 4.5.0
       mdast-util-from-markdown: 1.3.1
-      release-it: 16.2.1(typescript@5.0.4)
+      release-it: 16.2.1(typescript@5.2.2)
       tmp: 0.2.1
       validate-peer-dependencies: 2.2.0
       which: 2.0.2
@@ -2932,34 +3382,34 @@ packages:
     dependencies:
       detect-indent: 6.1.0
       detect-newline: 3.1.0
-      release-it: 16.2.1(typescript@5.0.4)
+      release-it: 16.2.1(typescript@5.2.2)
       semver: 7.5.4
       url-join: 4.0.1
       validate-peer-dependencies: 1.2.0
       walk-sync: 2.2.0
-      yaml: 2.3.2
+      yaml: 2.3.3
     dev: true
     patched: true
 
-  /@rollup/plugin-commonjs@24.1.0(rollup@3.21.6):
-    resolution: {integrity: sha512-eSL45hjhCWI0jCCXcNtLVqM5N1JlBGvlFfY0m6oOYnLCJ6N0qEXoZql4sY2MOUArzhH4SA/qBpTxvvZp2Sc+DQ==}
+  /@rollup/plugin-commonjs@25.0.7(rollup@3.28.0):
+    resolution: {integrity: sha512-nEvcR+LRjEjsaSsc4x3XZfCCvZIaSMenZu/OiwOKGN2UhQpAYI7ru7czFvyWbErlpoGjnSX3D5Ch5FcMA3kRWQ==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
-      rollup: ^2.68.0 || ^3.0.0 || 3
+      rollup: ^2.68.0 || ^3.0.0 || ^4.0.0 || 3
     peerDependenciesMeta:
       rollup:
         optional: true
     dependencies:
-      '@rollup/pluginutils': 5.0.2(rollup@3.21.6)
+      '@rollup/pluginutils': 5.0.2(rollup@3.28.0)
       commondir: 1.0.1
       estree-walker: 2.0.2
       glob: 8.1.0
       is-reference: 1.2.1
-      magic-string: 0.27.0
-      rollup: 3.21.6
+      magic-string: 0.30.3
+      rollup: 3.28.0
     dev: false
 
-  /@rollup/plugin-inject@5.0.3(rollup@3.21.6):
+  /@rollup/plugin-inject@5.0.3(rollup@3.28.0):
     resolution: {integrity: sha512-411QlbL+z2yXpRWFXSmw/teQRMkXcAAC8aYTemc15gwJRpvEVDQwoe+N/HTFD8RFG8+88Bme9DK2V9CVm7hJdA==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
@@ -2968,14 +3418,14 @@ packages:
       rollup:
         optional: true
     dependencies:
-      '@rollup/pluginutils': 5.0.2(rollup@3.21.6)
+      '@rollup/pluginutils': 5.0.2(rollup@3.28.0)
       estree-walker: 2.0.2
       magic-string: 0.27.0
-      rollup: 3.21.6
+      rollup: 3.28.0
     dev: false
 
-  /@rollup/plugin-node-resolve@15.0.2(rollup@3.21.6):
-    resolution: {integrity: sha512-Y35fRGUjC3FaurG722uhUuG8YHOJRJQbI6/CkbRkdPotSpDj9NtIN85z1zrcyDcCQIW4qp5mgG72U+gJ0TAFEg==}
+  /@rollup/plugin-node-resolve@15.2.0(rollup@3.28.0):
+    resolution: {integrity: sha512-mKur03xNGT8O9ODO6FtT43ITGqHWZbKPdVJHZb+iV9QYcdlhUUB0wgknvA4KCUmC5oHJF6O2W1EgmyOQyVUI4Q==}
     engines: {node: '>=14.0.0'}
     peerDependencies:
       rollup: ^2.78.0 || ^3.0.0 || 3
@@ -2983,13 +3433,13 @@ packages:
       rollup:
         optional: true
     dependencies:
-      '@rollup/pluginutils': 5.0.2(rollup@3.21.6)
+      '@rollup/pluginutils': 5.0.2(rollup@3.28.0)
       '@types/resolve': 1.20.2
       deepmerge: 4.3.1
       is-builtin-module: 3.2.1
       is-module: 1.0.0
-      resolve: 1.22.8
-      rollup: 3.21.6
+      resolve: 1.22.4
+      rollup: 3.28.0
     dev: false
 
   /@rollup/plugin-strip@3.0.2(rollup@3.21.6):
@@ -3019,7 +3469,22 @@ packages:
       rollup: 3.21.6
       serialize-javascript: 6.0.1
       smob: 0.0.6
-      terser: 5.21.0
+      terser: 5.17.1
+    dev: true
+
+  /@rollup/plugin-terser@0.4.4(rollup@4.3.0):
+    resolution: {integrity: sha512-XHeJC5Bgvs8LfukDwWZp7yeqin6ns8RTl2B9avbejt6tZqsqvVoWI7ZTQrcNsfKEDWBTnTxM8nMDkO2IFFbd0A==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^2.0.0 || ^3.0.0 || ^4.0.0 || 3
+    peerDependenciesMeta:
+      rollup:
+        optional: true
+    dependencies:
+      rollup: 4.3.0
+      serialize-javascript: 6.0.1
+      smob: 1.4.0
+      terser: 5.19.2
     dev: true
 
   /@rollup/pluginutils@5.0.2(rollup@3.21.6):
@@ -3031,67 +3496,303 @@ packages:
       rollup:
         optional: true
     dependencies:
-      '@types/estree': 1.0.2
+      '@types/estree': 1.0.1
       estree-walker: 2.0.2
       picomatch: 2.3.1
       rollup: 3.21.6
+    dev: true
 
-  /@simple-dom/document@1.4.0:
-    resolution: {integrity: sha512-/RUeVH4kuD3rzo5/91+h4Z1meLSLP66eXqpVAw/4aZmYozkeqUkMprq0znL4psX/adEed5cBgiNJcfMz/eKZLg==}
-    dependencies:
-      '@simple-dom/interface': 1.4.0
-    dev: false
-
-  /@simple-dom/interface@1.4.0:
-    resolution: {integrity: sha512-l5qumKFWU0S+4ZzMaLXFU8tQZsicHEMEyAxI5kDFGhJsRqDwe0a7/iPA/GdxlGyDKseQQAgIz5kzU7eXTrlSpA==}
-    dev: false
-
-  /@simple-dom/serializer@1.4.0:
-    resolution: {integrity: sha512-mI1yRahsVs8atXLiQksineDsFEFqeG7RHwnnBTDOK6inbzl4tZQgjR+Z7edjgIJq5j5RhZvwPI6EuCji9B3eQw==}
+  /@rollup/pluginutils@5.0.2(rollup@3.28.0):
+    resolution: {integrity: sha512-pTd9rIsP92h+B6wWwFbW8RkZv4hiR/xKsqre4SIuAOaOEQRxi0lqLke9k2/7WegC85GgUs9pjmOjCUi3In4vwA==}
+    engines: {node: '>=14.0.0'}
+    peerDependencies:
+      rollup: ^1.20.0 || ^2.0.0 || ^3.0.0 || 3
+    peerDependenciesMeta:
+      rollup:
+        optional: true
     dependencies:
-      '@simple-dom/interface': 1.4.0
-    dev: false
-
-  /@simple-dom/void-map@1.4.0:
-    resolution: {integrity: sha512-VDhLEyVCbuhOBBgHol9ShzIv9O8UCzdXeH4FoXu2DOcu/nnvTjLTck+BgXsCLv5ynDiUdoqsREEVFnoyPpFKVw==}
+      '@types/estree': 1.0.1
+      estree-walker: 2.0.2
+      picomatch: 2.3.1
+      rollup: 3.28.0
     dev: false
 
-  /@sindresorhus/is@0.14.0:
-    resolution: {integrity: sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==}
-    engines: {node: '>=6'}
+  /@rollup/rollup-android-arm-eabi@4.3.0:
+    resolution: {integrity: sha512-/4pns6BYi8MXdwnXM44yoGAcFYVHL/BYlB2q1HXZ6AzH++LaiEVWFpBWQ/glXhbMbv3E3o09igrHFbP/snhAvA==}
+    cpu: [arm]
+    os: [android]
+    requiresBuild: true
     dev: true
+    optional: true
 
-  /@sindresorhus/is@5.6.0:
-    resolution: {integrity: sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==}
-    engines: {node: '>=14.16'}
+  /@rollup/rollup-android-arm64@4.3.0:
+    resolution: {integrity: sha512-nLO/JsL9idr416vzi3lHm3Xm+QZh4qHij8k3Er13kZr5YhL7/+kBAx84kDmPc7HMexLmwisjDCeDIKNFp8mDlQ==}
+    cpu: [arm64]
+    os: [android]
+    requiresBuild: true
     dev: true
+    optional: true
 
-  /@socket.io/component-emitter@3.1.0:
-    resolution: {integrity: sha512-+9jVqKhRSpsc591z5vX+X5Yyw+he/HCB4iQ/RYxw35CEPaY1gnsNE43nf9n9AaYjAQrTiI/mOwKUKdUs9vf7Xg==}
+  /@rollup/rollup-darwin-arm64@4.3.0:
+    resolution: {integrity: sha512-dGhVBlllt4iHwTGy21IEoMOTN5wZoid19zEIxsdY29xcEiOEHqzDa7Sqrkh5OE7LKCowL61eFJXxYe/+pYa7ZQ==}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
     dev: true
+    optional: true
 
-  /@szmarczak/http-timer@1.1.2:
-    resolution: {integrity: sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==}
-    engines: {node: '>=6'}
-    dependencies:
-      defer-to-connect: 1.1.3
+  /@rollup/rollup-darwin-x64@4.3.0:
+    resolution: {integrity: sha512-h8wRfHeLEbU3NzaP1Oku7BYXCJQiTRr+8U0lklyOQXxXiEpHLL8tk1hFl+tezoRKLcPJD7joKaK74ASsqt3Ekg==}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
     dev: true
+    optional: true
 
-  /@szmarczak/http-timer@5.0.1:
-    resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==}
-    engines: {node: '>=14.16'}
-    dependencies:
-      defer-to-connect: 2.0.1
+  /@rollup/rollup-linux-arm-gnueabihf@4.3.0:
+    resolution: {integrity: sha512-wP4VgR/gfV18sylTuym3sxRTkAgUR2vh6YLeX/GEznk5jCYcYSlx585XlcUcl0c8UffIZlRJ09raWSX3JDb4GA==}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
     dev: true
+    optional: true
 
-  /@tootallnate/once@1.1.2:
-    resolution: {integrity: sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==}
-    engines: {node: '>= 6'}
+  /@rollup/rollup-linux-arm64-gnu@4.3.0:
+    resolution: {integrity: sha512-v/14JCYVkqRSJeQbxFx4oUkwVQQw6lFMN7bd4vuARBc3X2lmomkxBsc+BFiIDL/BK+CTx5AOh/k9XmqDnKWRVg==}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
     dev: true
+    optional: true
 
-  /@tootallnate/once@2.0.0:
+  /@rollup/rollup-linux-arm64-musl@4.3.0:
+    resolution: {integrity: sha512-tNhfYqFH5OxtRzfkTOKdgFYlPSZnlDLNW4+leNEvQZhwTJxoTwsZAAhR97l3qVry/kkLyJPBK+Q8EAJLPinDIg==}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-linux-x64-gnu@4.3.0:
+    resolution: {integrity: sha512-pw77m8QywdsoFdFOgmc8roF1inBI0rciqzO8ffRUgLoq7+ee9o5eFqtEcS6hHOOplgifAUUisP8cAnwl9nUYPw==}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-linux-x64-musl@4.3.0:
+    resolution: {integrity: sha512-tJs7v2MnV2F8w6X1UpPHl/43OfxjUy9SuJ2ZPoxn79v9vYteChVYO/ueLHCpRMmyTUIVML3N9z4azl9ENH8Xxg==}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-win32-arm64-msvc@4.3.0:
+    resolution: {integrity: sha512-OKGxp6kATQdTyI2DF+e9s+hB3/QZB45b6e+dzcfW1SUqiF6CviWyevhmT4USsMEdP3mlpC9zxLz3Oh+WaTMOSw==}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-win32-ia32-msvc@4.3.0:
+    resolution: {integrity: sha512-DDZ5AH68JJ2ClQFEA1aNnfA7Ybqyeh0644rGbrLOdNehTmzfICHiWSn0OprzYi9HAshTPQvlwrM+bi2kuaIOjQ==}
+    cpu: [ia32]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@rollup/rollup-win32-x64-msvc@4.3.0:
+    resolution: {integrity: sha512-dMvGV8p92GQ8jhNlGIKpyhVZPzJlT258pPrM5q2F8lKcc9Iv9BbfdnhX1OfinYWnb9ms5zLw6MlaMnqLfUkKnQ==}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@simple-dom/document@1.4.0:
+    resolution: {integrity: sha512-/RUeVH4kuD3rzo5/91+h4Z1meLSLP66eXqpVAw/4aZmYozkeqUkMprq0znL4psX/adEed5cBgiNJcfMz/eKZLg==}
+    dependencies:
+      '@simple-dom/interface': 1.4.0
+    dev: false
+
+  /@simple-dom/interface@1.4.0:
+    resolution: {integrity: sha512-l5qumKFWU0S+4ZzMaLXFU8tQZsicHEMEyAxI5kDFGhJsRqDwe0a7/iPA/GdxlGyDKseQQAgIz5kzU7eXTrlSpA==}
+    dev: false
+
+  /@simple-dom/serializer@1.4.0:
+    resolution: {integrity: sha512-mI1yRahsVs8atXLiQksineDsFEFqeG7RHwnnBTDOK6inbzl4tZQgjR+Z7edjgIJq5j5RhZvwPI6EuCji9B3eQw==}
+    dependencies:
+      '@simple-dom/interface': 1.4.0
+    dev: false
+
+  /@simple-dom/void-map@1.4.0:
+    resolution: {integrity: sha512-VDhLEyVCbuhOBBgHol9ShzIv9O8UCzdXeH4FoXu2DOcu/nnvTjLTck+BgXsCLv5ynDiUdoqsREEVFnoyPpFKVw==}
+    dev: false
+
+  /@sindresorhus/is@0.14.0:
+    resolution: {integrity: sha512-9NET910DNaIPngYnLLPeg+Ogzqsi9uM4mSboU5y6p8S5DzMTVEsJZrawi+BoDNUVBa2DhJqQYUFvMDfgU062LQ==}
+    engines: {node: '>=6'}
+    dev: true
+
+  /@sindresorhus/is@5.6.0:
+    resolution: {integrity: sha512-TV7t8GKYaJWsn00tFDqBw8+Uqmr8A0fRU1tvTQhyZzGv0sJCGRQL3JGMI3ucuKo3XIZdUP+Lx7/gh2t3lewy7g==}
+    engines: {node: '>=14.16'}
+    dev: true
+
+  /@socket.io/component-emitter@3.1.0:
+    resolution: {integrity: sha512-+9jVqKhRSpsc591z5vX+X5Yyw+he/HCB4iQ/RYxw35CEPaY1gnsNE43nf9n9AaYjAQrTiI/mOwKUKdUs9vf7Xg==}
+    dev: true
+
+  /@swc/core-darwin-arm64@1.3.95:
+    resolution: {integrity: sha512-VAuBAP3MNetO/yBIBzvorUXq7lUBwhfpJxYViSxyluMwtoQDhE/XWN598TWMwMl1ZuImb56d7eUsuFdjgY7pJw==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-darwin-x64@1.3.95:
+    resolution: {integrity: sha512-20vF2rvUsN98zGLZc+dsEdHvLoCuiYq/1B+TDeE4oolgTFDmI1jKO+m44PzWjYtKGU9QR95sZ6r/uec0QC5O4Q==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-linux-arm-gnueabihf@1.3.95:
+    resolution: {integrity: sha512-oEudEM8PST1MRNGs+zu0cx5i9uP8TsLE4/L9HHrS07Ck0RJ3DCj3O2fU832nmLe2QxnAGPwBpSO9FntLfOiWEQ==}
+    engines: {node: '>=10'}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-linux-arm64-gnu@1.3.95:
+    resolution: {integrity: sha512-pIhFI+cuC1aYg+0NAPxwT/VRb32f2ia8oGxUjQR6aJg65gLkUYQzdwuUmpMtFR2WVf7WVFYxUnjo4UyMuyh3ng==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-linux-arm64-musl@1.3.95:
+    resolution: {integrity: sha512-ZpbTr+QZDT4OPJfjPAmScqdKKaT+wGurvMU5AhxLaf85DuL8HwUwwlL0n1oLieLc47DwIJEMuKQkYhXMqmJHlg==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-linux-x64-gnu@1.3.95:
+    resolution: {integrity: sha512-n9SuHEFtdfSJ+sHdNXNRuIOVprB8nbsz+08apKfdo4lEKq6IIPBBAk5kVhPhkjmg2dFVHVo4Tr/OHXM1tzWCCw==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-linux-x64-musl@1.3.95:
+    resolution: {integrity: sha512-L1JrVlsXU3LC0WwmVnMK9HrOT2uhHahAoPNMJnZQpc18a0paO9fqifPG8M/HjNRffMUXR199G/phJsf326UvVg==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-win32-arm64-msvc@1.3.95:
+    resolution: {integrity: sha512-YaP4x/aZbUyNdqCBpC2zL8b8n58MEpOUpmOIZK6G1SxGi+2ENht7gs7+iXpWPc0sy7X3YPKmSWMAuui0h8lgAA==}
+    engines: {node: '>=10'}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-win32-ia32-msvc@1.3.95:
+    resolution: {integrity: sha512-w0u3HI916zT4BC/57gOd+AwAEjXeUlQbGJ9H4p/gzs1zkSHtoDQghVUNy3n/ZKp9KFod/95cA8mbVF9t1+6epQ==}
+    engines: {node: '>=10'}
+    cpu: [ia32]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core-win32-x64-msvc@1.3.95:
+    resolution: {integrity: sha512-5RGnMt0S6gg4Gc6QtPUJ3Qs9Un4sKqccEzgH/tj7V/DVTJwKdnBKxFZfgQ34OR2Zpz7zGOn889xwsFVXspVWNA==}
+    engines: {node: '>=10'}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@swc/core@1.3.95:
+    resolution: {integrity: sha512-PMrNeuqIusq9DPDooV3FfNEbZuTu5jKAc04N3Hm6Uk2Fl49cqElLFQ4xvl4qDmVDz97n3n/C1RE0/f6WyGPEiA==}
+    engines: {node: '>=10'}
+    requiresBuild: true
+    peerDependencies:
+      '@swc/helpers': ^0.5.0
+    peerDependenciesMeta:
+      '@swc/helpers':
+        optional: true
+    dependencies:
+      '@swc/counter': 0.1.2
+      '@swc/types': 0.1.5
+    optionalDependencies:
+      '@swc/core-darwin-arm64': 1.3.95
+      '@swc/core-darwin-x64': 1.3.95
+      '@swc/core-linux-arm-gnueabihf': 1.3.95
+      '@swc/core-linux-arm64-gnu': 1.3.95
+      '@swc/core-linux-arm64-musl': 1.3.95
+      '@swc/core-linux-x64-gnu': 1.3.95
+      '@swc/core-linux-x64-musl': 1.3.95
+      '@swc/core-win32-arm64-msvc': 1.3.95
+      '@swc/core-win32-ia32-msvc': 1.3.95
+      '@swc/core-win32-x64-msvc': 1.3.95
+    dev: true
+
+  /@swc/counter@0.1.2:
+    resolution: {integrity: sha512-9F4ys4C74eSTEUNndnER3VJ15oru2NumfQxS8geE+f3eB5xvfxpWyqE5XlVnxb/R14uoXi6SLbBwwiDSkv+XEw==}
+    dev: true
+
+  /@swc/types@0.1.5:
+    resolution: {integrity: sha512-myfUej5naTBWnqOCc/MdVOLVjXUXtIA+NpDrDBKJtLLg2shUjBu3cZmB/85RyitKc55+lUUyl7oRfLOvkr2hsw==}
+    dev: true
+
+  /@szmarczak/http-timer@1.1.2:
+    resolution: {integrity: sha512-XIB2XbzHTN6ieIjfIMV9hlVcfPU26s2vafYWQcZHWXHOxiaRZYEDKEwdl129Zyg50+foYV2jCgtrqSA6qNuNSA==}
+    engines: {node: '>=6'}
+    dependencies:
+      defer-to-connect: 1.1.3
+    dev: true
+
+  /@szmarczak/http-timer@5.0.1:
+    resolution: {integrity: sha512-+PmQX0PiAYPMeVYe237LJAYvOMYW1j2rH5YROyS3b4CTVJum34HfRvKvAzozHAQG0TnHNdUfY9nCeUyRAs//cw==}
+    engines: {node: '>=14.16'}
+    dependencies:
+      defer-to-connect: 2.0.1
+    dev: true
+
+  /@tootallnate/once@1.1.2:
+    resolution: {integrity: sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==}
+    engines: {node: '>= 6'}
+    dev: true
+
+  /@tootallnate/once@2.0.0:
     resolution: {integrity: sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A==}
     engines: {node: '>= 10'}
+    dev: false
 
   /@tootallnate/quickjs-emscripten@0.23.0:
     resolution: {integrity: sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==}
@@ -3114,20 +3815,20 @@ packages:
   /@tsconfig/node16@1.0.3:
     resolution: {integrity: sha512-yOlFc+7UtL/89t2ZhjPvvB/DeAr3r+Dq58IgzsFkOAvVC6NMJXmCGjbptdXdR9qsX7pKcTL+s87FtYREi2dEEQ==}
 
-  /@types/babel-plugin-macros@3.1.0:
-    resolution: {integrity: sha512-kxYWx+NISzy46KMgnXUthHJNbcGw9w1jn6e1LZAciTv8KKO5z9z1LakHnXCj5aYrwydZ5dGE3MAgEu4X/MdWkA==}
+  /@types/babel-plugin-macros@3.1.2:
+    resolution: {integrity: sha512-reO/Op5+rVgMPajMQslgFtoBtUMkkVVUkcXmsz8hLEHq1A2gr3JyHmrs+s2rJjhPKJIi2S2p/fj0q6BYP111Uw==}
     dependencies:
-      '@types/babel__core': 7.20.0
+      '@types/babel__core': 7.20.3
     dev: true
 
-  /@types/babel__core@7.20.0:
-    resolution: {integrity: sha512-+n8dL/9GWblDO0iU6eZAwEIJVr5DWigtle+Q6HLOrh/pdbXOhOtqzq8VPPE2zvNJzSKY4vH/z3iT3tn0A3ypiQ==}
+  /@types/babel__core@7.20.3:
+    resolution: {integrity: sha512-54fjTSeSHwfan8AyHWrKbfBWiEUrNTZsUwPTDSNaaP1QDQIZbeNUg3a59E9D+375MzUw/x1vx2/0F5LBz+AeYA==}
     dependencies:
-      '@babel/parser': 7.23.0
+      '@babel/parser': 7.22.10
       '@babel/types': 7.23.0
       '@types/babel__generator': 7.6.4
       '@types/babel__template': 7.4.1
-      '@types/babel__traverse': 7.18.5
+      '@types/babel__traverse': 7.20.3
     dev: true
 
   /@types/babel__generator@7.6.4:
@@ -3139,12 +3840,12 @@ packages:
   /@types/babel__template@7.4.1:
     resolution: {integrity: sha512-azBFKemX6kMg5Io+/rdGT0dkGreboUVR0Cdm3fz9QJWpaQGJRQXl7C+6hOTCZcMll7KFyEQpgbYI2lHdsS4U7g==}
     dependencies:
-      '@babel/parser': 7.23.0
+      '@babel/parser': 7.22.10
       '@babel/types': 7.23.0
     dev: true
 
-  /@types/babel__traverse@7.18.5:
-    resolution: {integrity: sha512-enCvTL8m/EHS/zIvJno9nE+ndYPh1/oNFzRYRmtUqJICG2VnCSBzMLW5VN2KCQU91f23tsNKR8v7VJJQMatl7Q==}
+  /@types/babel__traverse@7.20.3:
+    resolution: {integrity: sha512-Lsh766rGEFbaxMIDH7Qa+Yha8cMVI3qAK6CHt3OR0YfxOIn5Z54iHiyDRycHrBqeIiqGa20Kpsv1cavfBKkRSw==}
     dependencies:
       '@babel/types': 7.23.0
     dev: true
@@ -3153,23 +3854,13 @@ packages:
     resolution: {integrity: sha512-ALYone6pm6QmwZoAgeyNksccT9Q4AWZQ6PvfwR37GT6r6FWUPguq6sUmNGSMV2Wr761oQoBxwGGa6DR5o1DC9g==}
     dependencies:
       '@types/connect': 3.4.35
-      '@types/node': 18.16.6
-    dev: true
-
-  /@types/chai-as-promised@7.1.5:
-    resolution: {integrity: sha512-jStwss93SITGBwt/niYrkf2C+/1KTeZCZl1LaeezTlqppAKeoQC7jxyqYuP72sxBGKCIbw7oHgbYssIRzT5FCQ==}
-    dependencies:
-      '@types/chai': 4.3.5
-    dev: true
-
-  /@types/chai@4.3.5:
-    resolution: {integrity: sha512-mEo1sAde+UCE6b2hxn332f1g1E8WfYRu6p5SvTKr2ZKC1f7gFJXk4h5PyGP9Dt6gCaG8y8XhwnXWC6Iy2cmBng==}
+      '@types/node': 20.8.10
     dev: true
 
   /@types/connect@3.4.35:
     resolution: {integrity: sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
   /@types/cookie@0.4.1:
@@ -3179,34 +3870,48 @@ packages:
   /@types/cors@2.8.13:
     resolution: {integrity: sha512-RG8AStHlUiV5ysZQKq97copd2UmVYw3/pRMLefISZ3S1hK104Cwm7iLQ3fTKx+lsUH2CE8FlLaYeEA2LSeqYUA==}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
+    dev: true
+
+  /@types/debug@4.1.10:
+    resolution: {integrity: sha512-tOSCru6s732pofZ+sMv9o4o3Zc+Sa8l3bxd/tweTQudFn06vAzb13ZX46Zi6m6EJ+RUbRTHvgQJ1gBtSgkaUYA==}
+    dependencies:
+      '@types/ms': 0.7.33
     dev: true
 
-  /@types/debug@4.1.9:
-    resolution: {integrity: sha512-8Hz50m2eoS56ldRlepxSBa6PWEVCtzUo/92HgLc2qTMnotJNIm7xP+UZhyWoYsyOdd5dxZ+NZLb24rsKyFs2ow==}
+  /@types/eslint-scope@3.7.4:
+    resolution: {integrity: sha512-9K4zoImiZc3HlIp6AVUDE4CWYx22a+lhSZMYNpbjW04+YF0KWj4pJXnEMjdnFTiQibFFmElcsasJXDbdI/EPhA==}
+    dependencies:
+      '@types/eslint': 8.44.6
+      '@types/estree': 1.0.1
+
+  /@types/eslint-utils@3.0.4:
+    resolution: {integrity: sha512-UBwDhLhIW39LHAbSmDLEepR5+8EFv6M/+lKxVRzQO9fugzvMWW3noBkxXuAONFVuHQ2KGS0X9Js2MET0Xlc47A==}
     dependencies:
-      '@types/ms': 0.7.32
+      '@types/eslint': 8.44.6
+      '@types/estree': 1.0.1
     dev: true
 
-  /@types/eslint-scope@3.7.5:
-    resolution: {integrity: sha512-JNvhIEyxVW6EoMIFIvj93ZOywYFatlpu9deeH6eSx6PE3WHYvHaQtmHmQeNw7aA81bYGBPPQqdtBm6b1SsQMmA==}
+  /@types/eslint@8.44.2:
+    resolution: {integrity: sha512-sdPRb9K6iL5XZOmBubg8yiFp5yS/JdUDQsq5e6h95km91MCYMuvp7mh1fjPEYUhvHepKpZOjnEaMBR4PxjWDzg==}
     dependencies:
-      '@types/eslint': 8.37.0
-      '@types/estree': 1.0.2
+      '@types/estree': 1.0.1
+      '@types/json-schema': 7.0.12
+    dev: true
 
-  /@types/eslint@8.37.0:
-    resolution: {integrity: sha512-Piet7dG2JBuDIfohBngQ3rCt7MgO9xCO4xIMKxBThCq5PNRB91IjlJ10eJVwfoNtvTErmxLzwBZ7rHZtbOMmFQ==}
+  /@types/eslint@8.44.6:
+    resolution: {integrity: sha512-P6bY56TVmX8y9J87jHNgQh43h6VVU+6H7oN7hgvivV81K2XY8qJZ5vqPy/HdUoVIelii2kChYVzQanlswPWVFw==}
     dependencies:
-      '@types/estree': 1.0.2
-      '@types/json-schema': 7.0.13
+      '@types/estree': 1.0.1
+      '@types/json-schema': 7.0.12
 
-  /@types/estree@1.0.2:
-    resolution: {integrity: sha512-VeiPZ9MMwXjO32/Xu7+OwflfmeoRwkE/qzndw42gGtgJwZopBnzy2gD//NN1+go1mADzkDcqf/KnFRSjTJ8xJA==}
+  /@types/estree@1.0.1:
+    resolution: {integrity: sha512-LG4opVs2ANWZ1TJoKc937iMmNstM/d0ae1vNbnBvBhqCSezgVUOzcLCqbI5elV8Vy6WKwKjaqR+zO9VKirBBCA==}
 
   /@types/express-serve-static-core@4.17.34:
     resolution: {integrity: sha512-fvr49XlCGoUj2Pp730AItckfjat4WNb0lb3kfrLWffd+RLeoGAMsq7UOy04PAPtoL01uKwcp6u8nhzpgpDYr3w==}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
       '@types/qs': 6.9.7
       '@types/range-parser': 1.2.4
       '@types/send': 0.17.1
@@ -3225,38 +3930,26 @@ packages:
     resolution: {integrity: sha512-MxObHvNl4A69ofaTRU8DFqvgzzv8s9yRtaPPm5gud9HDNvpB3GPQFvNuTWAI59B9huVGV5jXYJwbCsmBsOGYWA==}
     dependencies:
       '@types/jsonfile': 6.1.1
-      '@types/node': 18.16.6
-    dev: true
-
-  /@types/fs-extra@8.1.2:
-    resolution: {integrity: sha512-SvSrYXfWSc7R4eqnOzbQF4TZmfpNSM9FrSWLU3EUnWBuyZqNBOrv1B1JA3byUDPUl9z4Ab3jeZG2eDdySlgNMg==}
-    dependencies:
-      '@types/node': 18.16.6
-    dev: true
-
-  /@types/glob@7.2.0:
-    resolution: {integrity: sha512-ZUxbzKl0IfJILTS6t7ip5fQQM/J3TJYubDm3nMbgubNNYS62eXeUpoLUC8/7fJNiFYHTrGPQn7hspDUzIHX3UA==}
-    dependencies:
-      '@types/minimatch': 5.1.2
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
   /@types/glob@8.1.0:
     resolution: {integrity: sha512-IO+MJPVhoqz+28h1qLAcBEH2+xHMK6MTyHJc7MTnnYb6wsoLR29POVGJ7LycmVXIqyy/4/2ShP5sUwTXuOwb/w==}
     dependencies:
       '@types/minimatch': 5.1.2
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
+    dev: false
 
-  /@types/http-cache-semantics@4.0.2:
-    resolution: {integrity: sha512-FD+nQWA2zJjh4L9+pFXqWOi0Hs1ryBCfI+985NjluQ1p8EYtoLvjLOKidXBtZ4/IcxDX4o8/E8qDS3540tNliw==}
+  /@types/http-cache-semantics@4.0.3:
+    resolution: {integrity: sha512-V46MYLFp08Wf2mmaBhvgjStM3tPa+2GAdy/iqoX+noX1//zje2x4XmrIU0cAwyClATsTmahbtoQ2EwP7I5WSiA==}
     dev: true
 
   /@types/js-yaml@4.0.5:
     resolution: {integrity: sha512-FhpRzf927MNQdRZP0J5DLIdTXhjLYzeUTmLAu69mnVksLH9CJY3IuSeEgbKUki7GQZm0WqDkGzyxju2EZGD2wA==}
     dev: false
 
-  /@types/json-schema@7.0.13:
-    resolution: {integrity: sha512-RbSSoHliUbnXj3ny0CNFOoxrIDV6SUGyStHsvDqosw6CkdPV8TtWGlfecuK4ToyMEAql6pzNxgCFKanovUzlgQ==}
+  /@types/json-schema@7.0.12:
+    resolution: {integrity: sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==}
 
   /@types/json5@0.0.29:
     resolution: {integrity: sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ==}
@@ -3264,19 +3957,19 @@ packages:
   /@types/jsonfile@6.1.1:
     resolution: {integrity: sha512-GSgiRCVeapDN+3pqA35IkQwasaCh/0YFH5dEF6S88iDvEn901DjOeH3/QPY+XYP1DFzDZPvIvfeEgk+7br5png==}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
   /@types/keyv@3.1.4:
     resolution: {integrity: sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
-  /@types/mdast@3.0.13:
-    resolution: {integrity: sha512-HjiGiWedR0DVFkeNljpa6Lv4/IZU1+30VY5d747K7lBudFc3R0Ibr6yJ9lN3BE28VnZyDfLF/VB1Ql1ZIbKrmg==}
+  /@types/mdast@3.0.14:
+    resolution: {integrity: sha512-gVZ04PGgw1qLZKsnWnyFv4ORnaJ+DXLdHTVSFbU8yX6xZ34Bjg4Q32yPkmveUP1yItXReKfB0Aknlh/3zxTKAw==}
     dependencies:
-      '@types/unist': 2.0.8
+      '@types/unist': 2.0.9
     dev: true
 
   /@types/mime@1.3.2:
@@ -3293,17 +3986,20 @@ packages:
 
   /@types/minimatch@5.1.2:
     resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==}
+    dev: false
 
   /@types/minimist@1.2.2:
     resolution: {integrity: sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==}
     dev: true
 
-  /@types/ms@0.7.32:
-    resolution: {integrity: sha512-xPSg0jm4mqgEkNhowKgZFBNtwoEwF6gJ4Dhww+GFpm3IgtNseHQZ5IqdNwnquZEoANxyDAKDRAdVo4Z72VvD/g==}
+  /@types/ms@0.7.33:
+    resolution: {integrity: sha512-AuHIyzR5Hea7ij0P9q7vx7xu4z0C28ucwjAZC0ja7JhINyCnOw8/DnvAPQQ9TfOlCtZAmCERKQX9+o1mgQhuOQ==}
     dev: true
 
-  /@types/node@18.16.6:
-    resolution: {integrity: sha512-N7KINmeB8IN3vRR8dhgHEp+YpWvGFcpDoh5XZ8jB5a00AdFKCKEyyGTOPTddUf4JqU1ZKTVxkOxakDvchNVI2Q==}
+  /@types/node@20.8.10:
+    resolution: {integrity: sha512-TlgT8JntpcbmKUFzjhsyhGfP2fsiz1Mv56im6enJ905xG1DAYesxJaeSbGqQmAw8OWPdhyJGhGSQGKRNJ45u9w==}
+    dependencies:
+      undici-types: 5.26.5
 
   /@types/normalize-package-data@2.4.1:
     resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
@@ -3317,17 +4013,10 @@ packages:
     resolution: {integrity: sha512-//oorEZjL6sbPcKUaCdIGlIUeH26mgzimjBB77G6XRgnDl/L5wOnpyBGRe/Mmf5CVW3PwEBE1NjiMZ/ssFh4wA==}
     dev: true
 
-  /@types/preval.macro@3.0.0:
-    resolution: {integrity: sha512-mm7qx+Aj9bhMcK9Y3UHNy6zCQneRj+GBFlCi+cxtx66iLU4yarOupVLrFadlG+Cd4TEsdo4og0REhzUQQ7m3fg==}
-    dev: true
-
   /@types/qs@6.9.7:
     resolution: {integrity: sha512-FGa1F62FT09qcrueBA6qYTrJPVDzah9a+493+o2PCXsesWHIn27G98TsSMs3WPNbZIEj4+VJf6saSFpvD+3Zsw==}
     dev: true
 
-  /@types/qunit@2.19.7:
-    resolution: {integrity: sha512-Vf1+zHCOhMyDqZqM6zlB++6n5mkMe1+pWH1l3fzbzakQ2VImMNeAKSQD++RAjpGTqPUio8Tre2a6kmq6O1tK/A==}
-
   /@types/range-parser@1.2.4:
     resolution: {integrity: sha512-EEhsLsD6UsDM1yFhAvy0Cjr6VwmpMWqFBCb9w07wVugF7w9nfajxLuVmngTIpgS6svCnm6Vaw+MZhoDCKnOfsw==}
     dev: true
@@ -3339,31 +4028,24 @@ packages:
   /@types/responselike@1.0.0:
     resolution: {integrity: sha512-85Y2BjiufFzaMIlvJDvTTB8Fxl2xfLo4HgmHzVBz08w4wDePCTjYw66PdrolO0kzli3yam/YCgRufyo1DdQVTA==}
     dependencies:
-      '@types/node': 18.16.6
-    dev: true
-
-  /@types/rimraf@2.0.5:
-    resolution: {integrity: sha512-YyP+VfeaqAyFmXoTh3HChxOQMyjByRMsHU7kc5KOJkSlXudhMhQIALbYV7rHh/l8d2lX3VUQzprrcAgWdRuU8g==}
-    dependencies:
-      '@types/glob': 8.1.0
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
-  /@types/semver@7.3.13:
-    resolution: {integrity: sha512-21cFJr9z3g5dW8B0CVI9g2O9beqaThGQ6ZFBqHfwhzLDKUxaqTIy3vnfah/UPkfOiF2pLq+tGz+W8RyCskuslw==}
+  /@types/semver@7.5.0:
+    resolution: {integrity: sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==}
 
   /@types/send@0.17.1:
     resolution: {integrity: sha512-Cwo8LE/0rnvX7kIIa3QHCkcuF21c05Ayb0ZfxPiv0W8VRiZiNW/WuRupHKpqqGVGf7SUA44QSOUKaEd9lIrd/Q==}
     dependencies:
       '@types/mime': 1.3.2
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
   /@types/serve-static@1.15.1:
     resolution: {integrity: sha512-NUo5XNiAdULrJENtJXZZ3fHtfMolzZwczzBbnAeBbqBwG+LaG6YaJtuwzwGSQZ2wsCrxjEhNNjAkKigy3n8teQ==}
     dependencies:
       '@types/mime': 3.0.1
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: true
 
   /@types/symlink-or-copy@1.2.0:
@@ -3374,149 +4056,311 @@ packages:
     resolution: {integrity: sha512-N1rW+njavs70y2cApeIw1vLMYXRwfBy+7trgavGuuTfOd7j1Yh7QTRc/yqsPl6ncokt72ZXuxEU0PiCp9bSwNQ==}
     dev: false
 
-  /@types/unist@2.0.8:
-    resolution: {integrity: sha512-d0XxK3YTObnWVp6rZuev3c49+j4Lo8g4L1ZRm9z5L0xpoZycUPshHgczK5gsUMaZOstjVYYi09p5gYvUtfChYw==}
+  /@types/unist@2.0.9:
+    resolution: {integrity: sha512-zC0iXxAv1C1ERURduJueYzkzZ2zaGyc+P2c95hgkikHPr3z8EdUZOlgEQ5X0DRmwDZn+hekycQnoeiiRVrmilQ==}
     dev: true
 
-  /@types/yauzl@2.10.1:
-    resolution: {integrity: sha512-CHzgNU3qYBnp/O4S3yv2tXPlvMTq0YWSTVg2/JYLqWZGHwwgJGAwd00poay/11asPq8wLFwHzubyInqHIFmmiw==}
+  /@types/yauzl@2.10.0:
+    resolution: {integrity: sha512-Cn6WYCm0tXv8p6k+A8PvbDG763EDpBoTzHdA+Q/MF6H3sapGjCm9NzoaJncJS9tUKSuCoDs9XHxYYsQDgxR6kw==}
     requiresBuild: true
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     optional: true
 
-  /@typescript-eslint/eslint-plugin@5.59.5(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-feA9xbVRWJZor+AnLNAr7A8JRWeZqHUf4T9tlP+TN04b05pFVhO5eN7/O93Y/1OUlLMHKbnJisgDURs/qvtqdg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/eslint-plugin@6.9.0(@typescript-eslint/parser@6.9.0)(eslint@8.47.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-lgX7F0azQwRPB7t7WAyeHWVfW1YJ9NIgd9mvGhfQpRY56X6AVf8mwM8Wol+0z4liE7XX3QOt8MN1rUKCfSjRIA==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      '@typescript-eslint/parser': ^5.0.0
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@eslint-community/regexpp': 4.5.1
-      '@typescript-eslint/parser': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
-      '@typescript-eslint/scope-manager': 5.59.5
-      '@typescript-eslint/type-utils': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
-      '@typescript-eslint/utils': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+      '@eslint-community/regexpp': 4.6.2
+      '@typescript-eslint/parser': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
+      '@typescript-eslint/scope-manager': 6.9.0
+      '@typescript-eslint/type-utils': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
+      '@typescript-eslint/utils': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
+      '@typescript-eslint/visitor-keys': 6.9.0
       debug: 4.3.4(supports-color@8.1.1)
-      eslint: 8.40.0
-      grapheme-splitter: 1.0.4
+      eslint: 8.47.0
+      graphemer: 1.4.0
       ignore: 5.2.4
-      natural-compare-lite: 1.4.0
+      natural-compare: 1.4.0
       semver: 7.5.4
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2
     transitivePeerDependencies:
       - supports-color
+    dev: false
 
-  /@typescript-eslint/parser@5.59.5(eslint@8.40.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-NJXQC4MRnF9N9yWqQE2/KLRSOLvrrlZb48NGVfBa+RuPMN6B7ZcK5jZOvhuygv4D64fRKnZI4L4p8+M+rfeQuw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/eslint-plugin@6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-w0tiiRc9I4S5XSXXrMHOWgHgxbrBn1Ro+PmiYhSg2ZVdxrAJtQgzU5o2m1BfP6UOn7Vxcc6152vFjQfmZR4xEg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      '@typescript-eslint/parser': ^6.0.0 || ^6.0.0-alpha
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 5.59.5
-      '@typescript-eslint/types': 5.59.5
-      '@typescript-eslint/typescript-estree': 5.59.5(typescript@5.0.4)
+      '@eslint-community/regexpp': 4.6.2
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      '@typescript-eslint/scope-manager': 6.9.1
+      '@typescript-eslint/type-utils': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      '@typescript-eslint/utils': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      '@typescript-eslint/visitor-keys': 6.9.1
       debug: 4.3.4(supports-color@8.1.1)
-      eslint: 8.40.0
-      typescript: 5.0.4
+      eslint: 8.53.0
+      graphemer: 1.4.0
+      ignore: 5.2.4
+      natural-compare: 1.4.0
+      semver: 7.5.4
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2
     transitivePeerDependencies:
       - supports-color
 
-  /@typescript-eslint/scope-manager@5.59.5:
-    resolution: {integrity: sha512-jVecWwnkX6ZgutF+DovbBJirZcAxgxC0EOHYt/niMROf8p4PwxxG32Qdhj/iIQQIuOflLjNkxoXyArkcIP7C3A==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/parser@6.9.0(eslint@8.47.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-GZmjMh4AJ/5gaH4XF2eXA8tMnHWP+Pm1mjQR2QN4Iz+j/zO04b9TOvJYOX2sCNIQHtRStKTxRY1FX7LhpJT4Gw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    peerDependencies:
+      eslint: ^7.0.0 || ^8.0.0
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
     dependencies:
-      '@typescript-eslint/types': 5.59.5
-      '@typescript-eslint/visitor-keys': 5.59.5
+      '@typescript-eslint/scope-manager': 6.9.0
+      '@typescript-eslint/types': 6.9.0
+      '@typescript-eslint/typescript-estree': 6.9.0(typescript@5.2.2)
+      '@typescript-eslint/visitor-keys': 6.9.0
+      debug: 4.3.4(supports-color@8.1.1)
+      eslint: 8.47.0
+      typescript: 5.2.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
 
-  /@typescript-eslint/type-utils@5.59.5(eslint@8.40.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-4eyhS7oGym67/pSxA2mmNq7X164oqDYNnZCUayBwJZIRVvKpBCMBzFnFxjeoDeShjtO6RQBHBuwybuX3POnDqg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/parser@6.9.1(eslint@8.53.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-C7AK2wn43GSaCUZ9do6Ksgi2g3mwFkMO3Cis96kzmgudoVaKyt62yNzJOktP0HDLb/iO2O0n2lBOzJgr6Q/cyg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: '*'
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/typescript-estree': 5.59.5(typescript@5.0.4)
-      '@typescript-eslint/utils': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+      '@typescript-eslint/scope-manager': 6.9.1
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/typescript-estree': 6.9.1(typescript@5.2.2)
+      '@typescript-eslint/visitor-keys': 6.9.1
       debug: 4.3.4(supports-color@8.1.1)
-      eslint: 8.40.0
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
+      eslint: 8.53.0
+      typescript: 5.2.2
     transitivePeerDependencies:
       - supports-color
 
-  /@typescript-eslint/types@5.59.5:
-    resolution: {integrity: sha512-xkfRPHbqSH4Ggx4eHRIO/eGL8XL4Ysb4woL8c87YuAo8Md7AUjyWKa9YMwTL519SyDPrfEgKdewjkxNCVeJW7w==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/scope-manager@6.9.0:
+    resolution: {integrity: sha512-1R8A9Mc39n4pCCz9o79qRO31HGNDvC7UhPhv26TovDsWPBDx+Sg3rOZdCELIA3ZmNoWAuxaMOT7aWtGRSYkQxw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dependencies:
+      '@typescript-eslint/types': 6.9.0
+      '@typescript-eslint/visitor-keys': 6.9.0
+    dev: false
 
-  /@typescript-eslint/typescript-estree@5.59.5(typescript@5.0.4):
-    resolution: {integrity: sha512-+XXdLN2CZLZcD/mO7mQtJMvCkzRfmODbeSKuMY/yXbGkzvA9rJyDY5qDYNoiz2kP/dmyAxXquL2BvLQLJFPQIg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/scope-manager@6.9.1:
+    resolution: {integrity: sha512-38IxvKB6NAne3g/+MyXMs2Cda/Sz+CEpmm+KLGEM8hx/CvnSRuw51i8ukfwB/B/sESdeTGet1NH1Wj7I0YXswg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dependencies:
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/visitor-keys': 6.9.1
+
+  /@typescript-eslint/type-utils@6.9.0(eslint@8.47.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-XXeahmfbpuhVbhSOROIzJ+b13krFmgtc4GlEuu1WBT+RpyGPIA4Y/eGnXzjbDj5gZLzpAXO/sj+IF/x2GtTMjQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/types': 5.59.5
-      '@typescript-eslint/visitor-keys': 5.59.5
+      '@typescript-eslint/typescript-estree': 6.9.0(typescript@5.2.2)
+      '@typescript-eslint/utils': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
       debug: 4.3.4(supports-color@8.1.1)
-      globby: 11.1.0
-      is-glob: 4.0.3
-      semver: 7.5.4
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
+      eslint: 8.47.0
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2
     transitivePeerDependencies:
       - supports-color
+    dev: false
 
-  /@typescript-eslint/utils@5.59.5(eslint@8.40.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-sCEHOiw+RbyTii9c3/qN74hYDPNORb8yWCoPLmB7BIflhplJ65u2PBpdRla12e3SSTJ2erRkPjz7ngLHhUegxA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/type-utils@6.9.1(eslint@8.53.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-eh2oHaUKCK58qIeYp19F5V5TbpM52680sB4zNSz29VBQPTWIlE/hCj5P5B1AChxECe/fmZlspAWFuRniep1Skg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      eslint: ^7.0.0 || ^8.0.0
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.40.0)
-      '@types/json-schema': 7.0.13
-      '@types/semver': 7.3.13
-      '@typescript-eslint/scope-manager': 5.59.5
-      '@typescript-eslint/types': 5.59.5
-      '@typescript-eslint/typescript-estree': 5.59.5(typescript@5.0.4)
-      eslint: 8.40.0
-      eslint-scope: 5.1.1
-      semver: 7.5.4
+      '@typescript-eslint/typescript-estree': 6.9.1(typescript@5.2.2)
+      '@typescript-eslint/utils': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      debug: 4.3.4(supports-color@8.1.1)
+      eslint: 8.53.0
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2
     transitivePeerDependencies:
       - supports-color
-      - typescript
 
-  /@typescript-eslint/visitor-keys@5.59.5:
-    resolution: {integrity: sha512-qL+Oz+dbeBRTeyJTIy0eniD3uvqU7x+y1QceBismZ41hd4aBSRh8UAw4pZP0+XzLuPZmx4raNMq/I+59W2lXKA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.59.5
-      eslint-visitor-keys: 3.4.1
-
-  /@webassemblyjs/ast@1.11.6:
-    resolution: {integrity: sha512-IN1xI7PwOvLPgjcf180gC1bqn3q/QaOCwYUahIOhbYUu8KA/3tw2RT/T0Gidi1l7Hhj5D/INhJxiICObqpMu4Q==}
-    dependencies:
-      '@webassemblyjs/helper-numbers': 1.11.6
-      '@webassemblyjs/helper-wasm-bytecode': 1.11.6
+  /@typescript-eslint/types@6.9.0:
+    resolution: {integrity: sha512-+KB0lbkpxBkBSiVCuQvduqMJy+I1FyDbdwSpM3IoBS7APl4Bu15lStPjgBIdykdRqQNYqYNMa8Kuidax6phaEw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dev: false
 
-  /@webassemblyjs/floating-point-hex-parser@1.11.6:
-    resolution: {integrity: sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==}
+  /@typescript-eslint/types@6.9.1:
+    resolution: {integrity: sha512-BUGslGOb14zUHOUmDB2FfT6SI1CcZEJYfF3qFwBeUrU6srJfzANonwRYHDpLBuzbq3HaoF2XL2hcr01c8f8OaQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
 
-  /@webassemblyjs/helper-api-error@1.11.6:
+  /@typescript-eslint/typescript-estree@6.9.0(typescript@5.2.2):
+    resolution: {integrity: sha512-NJM2BnJFZBEAbCfBP00zONKXvMqihZCrmwCaik0UhLr0vAgb6oguXxLX1k00oQyD+vZZ+CJn3kocvv2yxm4awQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/types': 6.9.0
+      '@typescript-eslint/visitor-keys': 6.9.0
+      debug: 4.3.4(supports-color@8.1.1)
+      globby: 11.1.0
+      is-glob: 4.0.3
+      semver: 7.5.4
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /@typescript-eslint/typescript-estree@6.9.1(typescript@5.2.2):
+    resolution: {integrity: sha512-U+mUylTHfcqeO7mLWVQ5W/tMLXqVpRv61wm9ZtfE5egz7gtnmqVIw9ryh0mgIlkKk9rZLY3UHygsBSdB9/ftyw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    peerDependencies:
+      typescript: '*'
+    peerDependenciesMeta:
+      typescript:
+        optional: true
+    dependencies:
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/visitor-keys': 6.9.1
+      debug: 4.3.4(supports-color@8.1.1)
+      globby: 11.1.0
+      is-glob: 4.0.3
+      semver: 7.5.4
+      ts-api-utils: 1.0.3(typescript@5.2.2)
+      typescript: 5.2.2
+    transitivePeerDependencies:
+      - supports-color
+
+  /@typescript-eslint/utils@6.9.0(eslint@8.47.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-5Wf+Jsqya7WcCO8me504FBigeQKVLAMPmUzYgDbWchINNh1KJbxCgVya3EQ2MjvJMVeXl3pofRmprqX6mfQkjQ==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    peerDependencies:
+      eslint: ^7.0.0 || ^8.0.0
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
+      '@types/json-schema': 7.0.12
+      '@types/semver': 7.5.0
+      '@typescript-eslint/scope-manager': 6.9.0
+      '@typescript-eslint/types': 6.9.0
+      '@typescript-eslint/typescript-estree': 6.9.0(typescript@5.2.2)
+      eslint: 8.47.0
+      semver: 7.5.4
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+    dev: false
+
+  /@typescript-eslint/utils@6.9.1(eslint@8.53.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-L1T0A5nFdQrMVunpZgzqPL6y2wVreSyHhKGZryS6jrEN7bD9NplVAyMryUhXsQ4TWLnZmxc2ekar/lSGIlprCA==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    peerDependencies:
+      eslint: ^7.0.0 || ^8.0.0
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.53.0)
+      '@types/json-schema': 7.0.12
+      '@types/semver': 7.5.0
+      '@typescript-eslint/scope-manager': 6.9.1
+      '@typescript-eslint/types': 6.9.1
+      '@typescript-eslint/typescript-estree': 6.9.1(typescript@5.2.2)
+      eslint: 8.53.0
+      semver: 7.5.4
+    transitivePeerDependencies:
+      - supports-color
+      - typescript
+
+  /@typescript-eslint/visitor-keys@6.9.0:
+    resolution: {integrity: sha512-dGtAfqjV6RFOtIP8I0B4ZTBRrlTT8NHHlZZSchQx3qReaoDeXhYM++M4So2AgFK9ZB0emRPA6JI1HkafzA2Ibg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dependencies:
+      '@typescript-eslint/types': 6.9.0
+      eslint-visitor-keys: 3.4.3
+    dev: false
+
+  /@typescript-eslint/visitor-keys@6.9.1:
+    resolution: {integrity: sha512-MUaPUe/QRLEffARsmNfmpghuQkW436DvESW+h+M52w0coICHRfD6Np9/K6PdACwnrq1HmuLl+cSPZaJmeVPkSw==}
+    engines: {node: ^16.0.0 || >=18.0.0}
+    dependencies:
+      '@typescript-eslint/types': 6.9.1
+      eslint-visitor-keys: 3.4.3
+
+  /@ungap/structured-clone@1.2.0:
+    resolution: {integrity: sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==}
+
+  /@vitejs/plugin-react-swc@3.4.1(vite@4.5.0):
+    resolution: {integrity: sha512-7YQOQcVV5x1luD8nkbCDdyYygFvn1hjqJk68UvNAzY2QG4o4N5EwAhLLFNOcd1HrdMwDl0VElP8VutoWf9IvJg==}
+    peerDependencies:
+      vite: ^4
+    dependencies:
+      '@swc/core': 1.3.95
+      vite: 4.5.0(@types/node@20.8.10)
+    transitivePeerDependencies:
+      - '@swc/helpers'
+    dev: true
+
+  /@vitejs/plugin-react@4.1.1(vite@4.5.0):
+    resolution: {integrity: sha512-Jie2HERK+uh27e+ORXXwEP5h0Y2lS9T2PRGbfebiHGlwzDO0dEnd2aNtOR/qjBlPb1YgxwAONeblL1xqLikLag==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      vite: ^4.2.0
+    dependencies:
+      '@babel/core': 7.23.2
+      '@babel/plugin-transform-react-jsx-self': 7.22.5(@babel/core@7.23.2)
+      '@babel/plugin-transform-react-jsx-source': 7.22.5(@babel/core@7.23.2)
+      '@types/babel__core': 7.20.3
+      react-refresh: 0.14.0
+      vite: 4.5.0(@types/node@20.8.10)
+    transitivePeerDependencies:
+      - supports-color
+    dev: true
+
+  /@webassemblyjs/ast@1.11.6:
+    resolution: {integrity: sha512-IN1xI7PwOvLPgjcf180gC1bqn3q/QaOCwYUahIOhbYUu8KA/3tw2RT/T0Gidi1l7Hhj5D/INhJxiICObqpMu4Q==}
+    dependencies:
+      '@webassemblyjs/helper-numbers': 1.11.6
+      '@webassemblyjs/helper-wasm-bytecode': 1.11.6
+
+  /@webassemblyjs/floating-point-hex-parser@1.11.6:
+    resolution: {integrity: sha512-ejAj9hfRJ2XMsNHk/v6Fu2dGS+i4UaXBXGemOfQ/JfQ6mdQg/WXtwleQRLLS4OvfDhv8rYnVwH27YJLMyYsxhw==}
+
+  /@webassemblyjs/helper-api-error@1.11.6:
     resolution: {integrity: sha512-o0YkoP4pVu4rN8aTJgAyj9hC2Sv5UlkzCHhxqWj8butaLvnpdc2jOwh4ewE6CX0txSfLn/UYaV/pheS2Txg//Q==}
 
   /@webassemblyjs/helper-buffer@1.11.6:
@@ -3614,10 +4458,6 @@ packages:
   /@xtuc/long@4.2.2:
     resolution: {integrity: sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==}
 
-  /abbrev@1.1.1:
-    resolution: {integrity: sha512-nne9/IiQ/hzIhY6pdDnbBtz7DjPTKrY00P/zvPSm5pOFkl6xuGrGnXn/VtTNNfNtAfZ9/1RtehkszU9qcTii0Q==}
-    dev: true
-
   /accepts@1.3.8:
     resolution: {integrity: sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==}
     engines: {node: '>= 0.6'}
@@ -3626,8 +4466,8 @@ packages:
       negotiator: 0.6.3
     dev: true
 
-  /acorn-import-assertions@1.9.0(acorn@8.10.0):
-    resolution: {integrity: sha512-cmMwop9x+8KFhxvKrKfPYmN6/pKTYYHBqLa0DfvVZcKMJWNyWLnaqND7dx/qn66R7ewM1UX5XMaDVP5wlVTaVA==}
+  /acorn-import-assertions@1.8.0(acorn@8.10.0):
+    resolution: {integrity: sha512-m7VZ3jwz4eK6A4Vtt8Ew1/mNbP24u0FhdyfA7fSvnJR6LMdfOYnmuIrrJAgrYfYJ10F/otaHTtrtrtmHdMNzEw==}
     peerDependencies:
       acorn: ^8
     dependencies:
@@ -3649,6 +4489,10 @@ packages:
     engines: {node: '>=0.4.0'}
     hasBin: true
 
+  /acorn@8.8.2:
+    resolution: {integrity: sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==}
+    engines: {node: '>=0.4.0'}
+
   /agent-base@4.3.0:
     resolution: {integrity: sha512-salcGninV0nPrwpGNn4VTXBb1SOuXQBiqbrNXoeizJsHrsL6ERFM2Ne3JUSBWRE6aeNJI2ROP/WEEIDUiDe3cg==}
     engines: {node: '>= 4.0.0'}
@@ -3711,11 +4555,6 @@ packages:
       object-hash: 1.3.1
     dev: true
 
-  /amdefine@1.0.1:
-    resolution: {integrity: sha512-S2Hw0TtNkMJhIabBwIojKL9YHO5T0n5eNqWJ7Lrlel/zDbftQpxpapi8tZs3X1HWa+u+QeydGmzzNU0m09+Rcg==}
-    engines: {node: '>=0.4.2'}
-    dev: true
-
   /ansi-align@3.0.1:
     resolution: {integrity: sha512-IOfwwBF5iczOjp/WeY4YxyjqAFMQoZufdQWDd19SEExbVLNXqvpzSJ/M7Za4/sCPmQ0+GRquoA7bGcINcxew6w==}
     dependencies:
@@ -3732,11 +4571,6 @@ packages:
     engines: {node: '>=6'}
     dev: false
 
-  /ansi-escapes@3.2.0:
-    resolution: {integrity: sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==}
-    engines: {node: '>=4'}
-    dev: true
-
   /ansi-escapes@4.3.2:
     resolution: {integrity: sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==}
     engines: {node: '>=8'}
@@ -3744,27 +4578,6 @@ packages:
       type-fest: 0.21.3
     dev: true
 
-  /ansi-html@0.0.7:
-    resolution: {integrity: sha512-JoAxEa1DfP9m2xfB/y2r/aKcwXNlltr4+0QSBC4TrLfcxyvepX2Pv0t/xpgGV5bGsDzCYV8SzjWgyCW0T9yYbA==}
-    engines: {'0': node >= 0.8.0}
-    hasBin: true
-    dev: true
-
-  /ansi-regex@2.1.1:
-    resolution: {integrity: sha512-TIGnTpdo+E3+pCyAluZvtED5p5wCqLdezCyhPZzKPcxvFplEt4i+W7OONCKgeZFT3+y5NZZfOOS/Bdcanm1MYA==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /ansi-regex@3.0.1:
-    resolution: {integrity: sha512-+O9Jct8wf++lXxxFc4hc8LsjaSq0HFzzL7cVsw8pRDIPdjKD2mT4ytDZlLuSBZ4cLKZFXIrMGO7DbQCtMJJMKw==}
-    engines: {node: '>=4'}
-    dev: true
-
-  /ansi-regex@4.1.1:
-    resolution: {integrity: sha512-ILlv4k/3f6vfQ4OoP2AGvirOktlQ98ZEL1k9FaQjxa3L1abBgbuTDAdPOpvbGncC0BTVQrl+OM8xZGK6tWXt7g==}
-    engines: {node: '>=6'}
-    dev: true
-
   /ansi-regex@5.0.1:
     resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
     engines: {node: '>=8'}
@@ -3773,11 +4586,6 @@ packages:
     resolution: {integrity: sha512-n5M855fKb2SsfMIiFFoVrABHJC8QtHwVx+mHWP3QcEqBHYienj5dHSgjbxtC0WEZXYt4wcD6zrQElDPhFuZgfA==}
     engines: {node: '>=12'}
 
-  /ansi-styles@2.2.1:
-    resolution: {integrity: sha512-kmCevFghRiWM7HB5zTPULl4r9bVFSWjz62MhqizDGUrq2NWuNMQyuv4tHHoKJHs69M/MF64lEcHdYIocrdWQYA==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /ansi-styles@3.2.1:
     resolution: {integrity: sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==}
     engines: {node: '>=4'}
@@ -3794,23 +4602,10 @@ packages:
     resolution: {integrity: sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==}
     engines: {node: '>=12'}
 
-  /ansicolors@0.2.1:
-    resolution: {integrity: sha512-tOIuy1/SK/dr94ZA0ckDohKXNeBNqZ4us6PjMVLs5h1w2GBB6uPtOknp2+VF4F/zcy9LI70W+Z+pE2Soajky1w==}
-    dev: true
-
   /any-promise@1.3.0:
     resolution: {integrity: sha512-7UvmKalWRt1wgjL1RrGxoSJW/0QZFIegpeGvZG9kjp8vrRu55XTHbwnqq2GpXm9uLbcuhxm3IqX9OB4MZR1b2A==}
     dev: true
 
-  /anymatch@2.0.0:
-    resolution: {integrity: sha512-5teOsQWABXHHBFP9y3skS5P3d/WfWXpv3FUpy+LorMrNYaT9pI4oLMQX7jzQ2KklNpGpWHzdCXTDT2Y3XGlZBw==}
-    dependencies:
-      micromatch: 3.1.10
-      normalize-path: 2.1.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /anymatch@3.1.3:
     resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
     engines: {node: '>= 8'}
@@ -3841,31 +4636,12 @@ packages:
   /argparse@2.0.1:
     resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
 
-  /arr-diff@4.0.0:
-    resolution: {integrity: sha512-YVIQ82gZPGBebQV/a8dar4AitzCQs0jjXwMPZllpXMaGjXPYVUawSxQrRsjhjupyVxEvbHgUmIhKVlND+j02kA==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /arr-flatten@1.1.0:
-    resolution: {integrity: sha512-L3hKV5R/p5o81R7O02IGnwpDmkp6E982XhtbuwSe3O4qOtMMMtodicASA1Cny2U+aCXcNpml+m4dPsvsJ3jatg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /arr-union@3.1.0:
-    resolution: {integrity: sha512-sKpyeERZ02v1FeCZT8lrfJq5u6goHCtpTAzPwJYe7c8SPFOboNjNg1vz2L4VTn9T4PQxEx13TbXLmYUcS6Ug7Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /array-buffer-byte-length@1.0.0:
     resolution: {integrity: sha512-LPuwb2P+NrQw3XhxGc36+XSvuBPopovXYTR9Ew++Du9Yb/bx5AzBfrIsBoj0EZUifjQU+sHL21sseZ3jerWO/A==}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       is-array-buffer: 3.0.2
 
-  /array-equal@1.0.0:
-    resolution: {integrity: sha512-H3LU5RLiSsGXPhN+Nipar0iR0IofH+8r89G2y1tBKxQ/agagKyAjhkAFDRBfodP2caPrNKHpAWNIM/c9yeL7uA==}
-    dev: true
-
   /array-find@1.0.0:
     resolution: {integrity: sha512-kO/vVCacW9mnpn3WPWbTVlEnOabK2L7LWi2HViURtCM46y1zb6I8UMjx4LgbiqadTgHnLInUronwn3ampNTJtQ==}
 
@@ -3877,47 +4653,43 @@ packages:
     resolution: {integrity: sha512-sgTbLvL6cNnw24FnbaDyjmvddQ2ML8arZsgaJhoABMoplz/4QRhtrYS+alr1BUM1Bwp6dhx8vVCBSLG+StwOFw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+      get-intrinsic: 1.2.2
       is-string: 1.0.7
 
-  /array-to-error@1.1.1:
-    resolution: {integrity: sha512-kqcQ8s7uQfg3UViYON3kCMcck3A9exxgq+riVuKy08Mx00VN4EJhK30L2VpjE58LQHKhcE/GRpvbVUhqTvqzGQ==}
-    dependencies:
-      array-to-sentence: 1.1.0
-    dev: true
-
-  /array-to-sentence@1.1.0:
-    resolution: {integrity: sha512-YkwkMmPA2+GSGvXj1s9NZ6cc2LBtR+uSeWTy2IGi5MR1Wag4DdrcjTxA/YV/Fw+qKlBeXomneZgThEbm/wvZbw==}
-    dev: true
-
   /array-union@2.1.0:
     resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
     engines: {node: '>=8'}
 
-  /array-unique@0.3.2:
-    resolution: {integrity: sha512-SleRWjh9JUud2wH1hPs9rZBZ33H6T9HOiL0uwGnGx9FpE6wKGyfWugmbkEOIs6qWrZhg0LWeLziLrEwQJhs5mQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
+  /array.prototype.findlastindex@1.2.2:
+    resolution: {integrity: sha512-tb5thFFlUcp7NdNF6/MpDk/1r/4awWG1FIz3YqDf+/zJSTezBb+/5WViH41obXULHVpDzoiCLpJ/ZO9YbJMsdw==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+      es-shim-unscopables: 1.0.0
+      get-intrinsic: 1.2.2
+    dev: false
 
   /array.prototype.flat@1.3.1:
     resolution: {integrity: sha512-roTU0KWIOmJ4DRLmwKd19Otg0/mT3qPNt0Qb3GWW8iObuZXxrjB/pzn0R3hqpRSWg4HCwqx+0vwOnWnvlOyeIA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
       es-shim-unscopables: 1.0.0
 
   /array.prototype.flatmap@1.3.1:
     resolution: {integrity: sha512-8UGn9O1FDVvMNB0UlLv4voxRMze7+FpHyF5mSMRjWHUMlpoDViniy05870VlxhfgTnLbpuwTzvD76MTtWxB/mQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
       es-shim-unscopables: 1.0.0
 
   /array.prototype.map@1.0.6:
@@ -3925,8 +4697,8 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
       es-array-method-boxes-properly: 1.0.0
       is-string: 1.0.7
     dev: true
@@ -3936,10 +4708,10 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       array-buffer-byte-length: 1.0.0
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+      get-intrinsic: 1.2.2
       is-array-buffer: 3.0.2
       is-shared-array-buffer: 1.0.2
 
@@ -3953,11 +4725,6 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /assign-symbols@1.0.0:
-    resolution: {integrity: sha512-Q+JC7Whu8HhmTdBph/Tq59IoRtoy6KAm5zzPv00WdujX82lbAL8K7WVjne7vdCsAmbF4AYaDOPyO3k0kl8qIrw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /ast-types@0.13.4:
     resolution: {integrity: sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==}
     engines: {node: '>=4'}
@@ -3965,29 +4732,6 @@ packages:
       tslib: 2.6.2
     dev: true
 
-  /async-disk-cache@1.3.5:
-    resolution: {integrity: sha512-VZpqfR0R7CEOJZ/0FOTgWq70lCrZyS1rkI8PXugDUkTKyyAUgZ2zQ09gLhMkEn+wN8LYeUTPxZdXtlX/kmbXKQ==}
-    dependencies:
-      debug: 2.6.9
-      heimdalljs: 0.2.6
-      istextorbinary: 2.1.0
-      mkdirp: 0.5.6
-      rimraf: 2.7.1
-      rsvp: 3.6.2
-      username-sync: 1.0.3
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /async-promise-queue@1.0.5:
-    resolution: {integrity: sha512-xi0aQ1rrjPWYmqbwr18rrSKbSaXIeIwSd1J4KAgVfkq8utNbdZoht7GfvfY6swFUAMJ9obkc4WPJmtGwl+B8dw==}
-    dependencies:
-      async: 2.6.4
-      debug: 2.6.9
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /async-retry@1.3.3:
     resolution: {integrity: sha512-wfr/jstw9xNi/0teMHrRW7dsz3Lt5ARhYNZ2ewpadnhaIp5mbALhOAP+EAdsC7t4Z6wqsDVv9+W6gm1Dk9mEyw==}
     dependencies:
@@ -3998,27 +4742,18 @@ packages:
     resolution: {integrity: sha512-eAkdoKxU6/LkKDBzLpT+t6Ff5EtfSF4wx1WfJiPEEV7WNLnDaRXk0oVysiEPm262roaachGexwUv94WhSgN5TQ==}
     dev: true
 
-  /async@2.6.4:
-    resolution: {integrity: sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==}
-    dependencies:
-      lodash: 4.17.21
-    dev: true
-
   /at-least-node@1.0.0:
     resolution: {integrity: sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==}
     engines: {node: '>= 4.0.0'}
-    dev: true
 
   /atob@2.1.2:
     resolution: {integrity: sha512-Wm6ukoaOGJi/73p/cl2GvLjTI5JM1k/O14isD73YML8StrH/7/lRFgmg8nICZgD3bZZvjwCGxtMOD3wWNAu8cg==}
     engines: {node: '>= 4.5.0'}
-    hasBin: true
     dev: true
 
   /auto-dist-tag@2.1.1:
     resolution: {integrity: sha512-w3aUbxMesY8VpJCW26F8enOvJnegb4fDtjDttc1UpBVEzRidEmMHzVI9J9cbeTh92vDfoxVeQezJbnqtAz20iw==}
     engines: {node: '>=10'}
-    hasBin: true
     dependencies:
       debug: 4.3.4(supports-color@8.1.1)
       fs-extra: 9.0.0
@@ -4034,6 +4769,10 @@ packages:
     resolution: {integrity: sha512-DMD0KiN46eipeziST1LPP/STfDU0sufISXmjSgvVsoU2tqxctQeASejWcfNtxYKqETM1UxQ8sp2OrSBWpHY6sw==}
     engines: {node: '>= 0.4'}
 
+  /b4a@1.6.4:
+    resolution: {integrity: sha512-fpWrvyVHEKyeEvbKZTVOeZF3VSKKWtJxFIxX/jaVPf+cLbGUSitjb49pHLqPV2BUNNZ0LcoeEGfE/YCpyDYHIw==}
+    dev: true
+
   /babel-plugin-debug-macros@0.3.4(@babel/core@7.23.2):
     resolution: {integrity: sha512-wfel/vb3pXfwIDZUrkoDrn5FHmlWI96PCJ3UCDv2a86poJ3EQrnArNW5KfHSVJ9IOgxHbo748cQt7sDU+0KCEw==}
     engines: {node: '>=6'}
@@ -4041,72 +4780,51 @@ packages:
       '@babel/core': ^7.0.0
     dependencies:
       '@babel/core': 7.23.2
-      semver: 5.7.2
+      semver: 5.7.1
     dev: false
 
   /babel-plugin-macros@3.1.0:
     resolution: {integrity: sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==}
     engines: {node: '>=10', npm: '>=6'}
     dependencies:
-      '@babel/runtime': 7.21.5
+      '@babel/runtime': 7.23.2
       cosmiconfig: 7.1.0
-      resolve: 1.22.8
-    dev: true
-
-  /babel-plugin-module-resolver@4.1.0:
-    resolution: {integrity: sha512-MlX10UDheRr3lb3P0WcaIdtCSRlxdQsB1sBqL7W0raF070bGl1HQQq5K3T2vf2XAYie+ww+5AKC/WrkjRO2knA==}
-    engines: {node: '>= 8.0.0'}
-    dependencies:
-      find-babel-config: 1.2.0
-      glob: 7.2.3
-      pkg-up: 3.1.0
-      reselect: 4.1.8
-      resolve: 1.22.8
+      resolve: 1.22.2
     dev: true
 
-  /babel-plugin-polyfill-corejs2@0.3.3(@babel/core@7.23.2):
-    resolution: {integrity: sha512-8hOdmFYFSZhqg2C/JgLUQ+t52o5nirNwaWM2B9LWteozwIvM14VSwdsCAUET10qT+kmySAlseadmfeeSWFCy+Q==}
+  /babel-plugin-polyfill-corejs2@0.4.6(@babel/core@7.23.2):
+    resolution: {integrity: sha512-jhHiWVZIlnPbEUKSSNb9YoWcQGdlTLq7z1GHL4AjFxaoOUMuuEVJ+Y4pAaQUGOGk93YsVCKPbqbfw3m0SM6H8Q==}
     peerDependencies:
-      '@babel/core': ^7.0.0-0
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
     dependencies:
-      '@babel/compat-data': 7.23.2
+      '@babel/compat-data': 7.22.9
       '@babel/core': 7.23.2
-      '@babel/helper-define-polyfill-provider': 0.3.3(@babel/core@7.23.2)
+      '@babel/helper-define-polyfill-provider': 0.4.3(@babel/core@7.23.2)
       semver: 6.3.1
     transitivePeerDependencies:
       - supports-color
 
-  /babel-plugin-polyfill-corejs3@0.6.0(@babel/core@7.23.2):
-    resolution: {integrity: sha512-+eHqR6OPcBhJOGgsIar7xoAB1GcSwVUA3XjAd7HJNzOXT4wv6/H7KIdA/Nc60cvUlDbKApmqNvD1B1bzOt4nyA==}
+  /babel-plugin-polyfill-corejs3@0.8.6(@babel/core@7.23.2):
+    resolution: {integrity: sha512-leDIc4l4tUgU7str5BWLS2h8q2N4Nf6lGZP6UrNDxdtfF2g69eJ5L0H7S8A5Ln/arfFAfHor5InAdZuIOwZdgQ==}
     peerDependencies:
-      '@babel/core': ^7.0.0-0
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-define-polyfill-provider': 0.3.3(@babel/core@7.23.2)
-      core-js-compat: 3.30.1
+      '@babel/helper-define-polyfill-provider': 0.4.3(@babel/core@7.23.2)
+      core-js-compat: 3.33.1
     transitivePeerDependencies:
       - supports-color
 
-  /babel-plugin-polyfill-regenerator@0.4.1(@babel/core@7.23.2):
-    resolution: {integrity: sha512-NtQGmyQDXjQqQ+IzRkBVwEOz9lQ4zxAQZgoAYEtU9dJjnl1Oc98qnN7jcp+bE7O7aYzVpavXE3/VKXNzUbh7aw==}
+  /babel-plugin-polyfill-regenerator@0.5.3(@babel/core@7.23.2):
+    resolution: {integrity: sha512-8sHeDOmXC8csczMrYEOf0UTNa4yE2SxV5JGeT/LP1n0OYVDUUFPxG9vdk2AlDlIit4t+Kf0xCtpgXPBwnn/9pw==}
     peerDependencies:
-      '@babel/core': ^7.0.0-0
+      '@babel/core': ^7.4.0 || ^8.0.0-0 <8.0.0
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/helper-define-polyfill-provider': 0.3.3(@babel/core@7.23.2)
+      '@babel/helper-define-polyfill-provider': 0.4.3(@babel/core@7.23.2)
     transitivePeerDependencies:
       - supports-color
 
-  /babel-plugin-preval@5.1.0:
-    resolution: {integrity: sha512-G5R+xmo5LS41A4UyZjOjV0mp9AvkuCyUOAJ6TOv/jTZS+VKh7L7HUDRcCSOb0YCM/u0fFarh7Diz0wjY8rFNFg==}
-    engines: {node: '>=10', npm: '>=6'}
-    dependencies:
-      '@babel/runtime': 7.21.5
-      '@types/babel__core': 7.20.0
-      babel-plugin-macros: 3.1.0
-      require-from-string: 2.0.2
-    dev: true
-
   /babel-plugin-strip-glimmer-utils@0.1.1:
     resolution: {integrity: sha512-swQqYIjUQQppAEnaRH2Kuo6N6zIw6uEAPbELvmFgmzwJPt0vqe5wHESPqBk/OepsWfGkv9KQILNd5BKRIDuDtA==}
     dev: true
@@ -4144,26 +4862,6 @@ packages:
     engines: {node: ^4.5.0 || >= 5.9}
     dev: true
 
-  /base@0.11.2:
-    resolution: {integrity: sha512-5T6P4xPgpp0YDFvSWwEZ4NoE3aM4QBQXDzmVbraCkFj8zHM+mba8SyqB5DbZWyR7mYHo6Y7BdQo3MoA4m0TeQg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      cache-base: 1.0.1
-      class-utils: 0.3.6
-      component-emitter: 1.3.0
-      define-property: 1.0.0
-      isobject: 3.0.1
-      mixin-deep: 1.3.2
-      pascalcase: 0.1.1
-    dev: true
-
-  /basic-auth@2.0.1:
-    resolution: {integrity: sha512-NF+epuEdnUYVlGuhaxbbq+dvJttwLnGY+YixlXlME5KpQ5W3CnXA5cVTneY3SPbPDRkcjMbifrwmFYcClgOZeg==}
-    engines: {node: '>= 0.8'}
-    dependencies:
-      safe-buffer: 5.1.2
-    dev: true
-
   /basic-ftp@5.0.3:
     resolution: {integrity: sha512-QHX8HLlncOLpy54mh+k/sWIFd0ThmRqwe9ZjELybGZK+tZ8rUb9VO0saKJUROTbE+KhzDUT7xziGpGrW8Kmd+g==}
     engines: {node: '>=10.0.0'}
@@ -4176,16 +4874,12 @@ packages:
   /big-integer@1.6.51:
     resolution: {integrity: sha512-GPEid2Y9QU1Exl1rpO9B2IPJGHPSupF5GnVIP0blYvNOMer2bTvSWs1jGOUg04hTmu67nmLsQ9TBo1puaotBHg==}
     engines: {node: '>=0.6'}
+    dev: true
 
   /binary-extensions@2.2.0:
     resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==}
     engines: {node: '>=8'}
 
-  /binaryextensions@2.3.0:
-    resolution: {integrity: sha512-nAihlQsYGyc5Bwq6+EsubvANYGExeJKHDO3RjnvwU042fawQTQfM3Kxn7IHUXQOz4bzfwsGYYHGSvXyW4zOGLg==}
-    engines: {node: '>=0.8'}
-    dev: true
-
   /bl@4.1.0:
     resolution: {integrity: sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==}
     dependencies:
@@ -4201,10 +4895,6 @@ packages:
       readable-stream: 3.6.2
     dev: true
 
-  /blank-object@1.0.2:
-    resolution: {integrity: sha512-kXQ19Xhoghiyw66CUiGypnuRpWlbHAzY/+NyvqTEdTfhfQGH1/dbEMYiXju7fYKIFePpzp/y9dsu5Cu/PkmawQ==}
-    dev: true
-
   /bluebird@3.7.2:
     resolution: {integrity: sha512-XpNj6GDQzdfW+r2Wnn7xiSAd7TM3jzkxGXBGTtWKuSXv1xUV+azxAm8jdWZN06QTQk+2N2XB9jRDkvbmQmcRtg==}
     dev: true
@@ -4229,36 +4919,10 @@ packages:
       - supports-color
     dev: true
 
-  /body@5.1.0:
-    resolution: {integrity: sha512-chUsBxGRtuElD6fmw1gHLpvnKdVLK302peeFa9ZqAEk8TyzZ3fygLyUEDDPTJvL9+Bor0dIwn6ePOsRM2y0zQQ==}
-    dependencies:
-      continuable-cache: 0.3.1
-      error: 7.2.1
-      raw-body: 1.1.7
-      safe-json-parse: 1.0.1
-    dev: true
-
   /boolbase@1.0.0:
     resolution: {integrity: sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==}
     dev: false
 
-  /bower-config@1.4.3:
-    resolution: {integrity: sha512-MVyyUk3d1S7d2cl6YISViwJBc2VXCkxF5AUFykvN0PQj5FsUiMNSgAYTso18oRFfyZ6XEtjrgg9MAaufHbOwNw==}
-    engines: {node: '>=0.8.0'}
-    dependencies:
-      graceful-fs: 4.2.11
-      minimist: 0.2.4
-      mout: 1.2.4
-      osenv: 0.1.5
-      untildify: 2.1.0
-      wordwrap: 0.0.3
-    dev: true
-
-  /bower-endpoint-parser@0.2.2:
-    resolution: {integrity: sha512-YWZHhWkPdXtIfH3VRu3QIV95sa75O9vrQWBOHjexWCLBCTy5qJvRr36LXTqFwTchSXVlzy5piYJOjzHr7qhsNg==}
-    engines: {node: '>=0.8.0'}
-    dev: true
-
   /boxen@7.1.1:
     resolution: {integrity: sha512-2hCgjEmP8YLWQ130n2FerGv7rYpfBmnmp9Uy2Le1vge6X3gZIfSmEzP5QTDElFxcvVcXlEn8Aq6MU/PZygIOog==}
     engines: {node: '>=14.16'}
@@ -4278,6 +4942,7 @@ packages:
     engines: {node: '>= 5.10.0'}
     dependencies:
       big-integer: 1.6.51
+    dev: true
 
   /brace-expansion@1.1.11:
     resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
@@ -4290,451 +4955,74 @@ packages:
     dependencies:
       balanced-match: 1.0.2
 
-  /braces@2.3.2:
-    resolution: {integrity: sha512-aNdbnj9P8PjdXU4ybaWLK2IF3jc/EoDYbC7AazW6to3TRsfXxscC9UXOB5iDiEQrkyIbWp2SLQda4+QAa7nc3w==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      arr-flatten: 1.1.0
-      array-unique: 0.3.2
-      extend-shallow: 2.0.1
-      fill-range: 4.0.0
-      isobject: 3.0.1
-      repeat-element: 1.1.4
-      snapdragon: 0.8.2
-      snapdragon-node: 2.1.1
-      split-string: 3.1.0
-      to-regex: 3.0.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /braces@3.0.2:
     resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}
     engines: {node: '>=8'}
     dependencies:
       fill-range: 7.0.1
 
-  /broccoli-amd-funnel@2.0.1:
-    resolution: {integrity: sha512-VRE+0PYAN4jQfkIq3GKRj4U/4UV9rVpLan5ll6fVYV4ziVg4OEfR5GUnILEg++QtR4xSaugRxCPU5XJLDy3bNQ==}
-    engines: {node: '>=6'}
-    dependencies:
-      broccoli-plugin: 1.3.1
-      symlink-or-copy: 1.3.1
+  /browser-stdout@1.3.1:
+    resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==}
     dev: true
 
-  /broccoli-babel-transpiler@7.8.1:
-    resolution: {integrity: sha512-6IXBgfRt7HZ61g67ssBc6lBb3Smw3DPZ9dEYirgtvXWpRZ2A9M22nxy6opEwJDgDJzlu/bB7ToppW33OFkA1gA==}
-    engines: {node: '>= 6'}
+  /browserslist-generator@2.1.0:
+    resolution: {integrity: sha512-ZFz4mAOgqm0cbwKaZsfJbYDbTXGoPANlte7qRsRJOfjB9KmmISQrXJxAVrnXG8C8v/QHNzXyeJt0Cfcks6zZvQ==}
+    engines: {node: '>=16.15.1', npm: '>=7.0.0', pnpm: '>=3.2.0', yarn: '>=1.13'}
     dependencies:
-      '@babel/core': 7.23.2
-      '@babel/polyfill': 7.12.1
-      broccoli-funnel: 2.0.2
-      broccoli-merge-trees: 3.0.2
-      broccoli-persistent-filter: 2.3.1
-      clone: 2.1.2
-      hash-for-dep: 1.5.1
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      json-stable-stringify: 1.0.2
-      rsvp: 4.8.5
-      workerpool: 3.1.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
+      '@mdn/browser-compat-data': 5.3.11
+      '@types/object-path': 0.11.1
+      '@types/semver': 7.5.0
+      '@types/ua-parser-js': 0.7.36
+      browserslist: 4.21.10
+      caniuse-lite: 1.0.30001521
+      isbot: 3.6.13
+      object-path: 0.11.8
+      semver: 7.5.4
+      ua-parser-js: 1.0.35
+    dev: false
 
-  /broccoli-builder@0.18.14:
-    resolution: {integrity: sha512-YoUHeKnPi4xIGZ2XDVN9oHNA9k3xF5f5vlA+1wvrxIIDXqQU97gp2FxVAF503Zxdtt0C5CRB5n+47k2hlkaBzA==}
-    engines: {node: '>= 0.10.0'}
+  /browserslist@4.21.10:
+    resolution: {integrity: sha512-bipEBdZfVH5/pwrvqc+Ub0kUPVfGUhlKxbvfD+z1BDnPEO/X98ruXGA1WP5ASpAFKan7Qr6j736IacbZQuAlKQ==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
     dependencies:
-      broccoli-node-info: 1.1.0
-      heimdalljs: 0.2.6
-      promise-map-series: 0.2.3
-      quick-temp: 0.1.8
-      rimraf: 2.7.1
-      rsvp: 3.6.2
-      silent-error: 1.1.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
+      caniuse-lite: 1.0.30001521
+      electron-to-chromium: 1.4.495
+      node-releases: 2.0.13
+      update-browserslist-db: 1.0.11(browserslist@4.21.10)
 
-  /broccoli-caching-writer@3.0.3:
-    resolution: {integrity: sha512-g644Kb5uBPsy+6e2DvO3sOc+/cXZQQNgQt64QQzjA9TSdP0dl5qvetpoNIx4sy/XIjrPYG1smEidq9Z9r61INw==}
+  /browserslist@4.22.1:
+    resolution: {integrity: sha512-FEVc202+2iuClEhZhrWy6ZiAcRLvNMyYcxZ8raemul1DYVOVdFsbqckWLdsixQZCpJlwe77Z3UTalE7jsjnKfQ==}
+    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
+    hasBin: true
     dependencies:
-      broccoli-kitchen-sink-helpers: 0.3.1
-      broccoli-plugin: 1.3.1
-      debug: 2.6.9
-      rimraf: 2.7.1
-      rsvp: 3.6.2
-      walk-sync: 0.3.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
+      caniuse-lite: 1.0.30001553
+      electron-to-chromium: 1.4.566
+      node-releases: 2.0.13
+      update-browserslist-db: 1.0.13(browserslist@4.22.1)
 
-  /broccoli-clean-css@1.1.0:
-    resolution: {integrity: sha512-S7/RWWX+lL42aGc5+fXVLnwDdMtS0QEWUFalDp03gJ9Na7zj1rWa351N2HZ687E2crM9g+eDWXKzD17cbcTepg==}
+  /browserstack-local@1.5.2:
+    resolution: {integrity: sha512-qdsVGk5ndnVgjm5ekpaOfFYQoU/WOK1WFDrlzk9J7xzA+gnD1Vge2w1TFwvc2M0LW6VZePSk6y0Q1CPGyT/9HQ==}
     dependencies:
-      broccoli-persistent-filter: 1.4.6
-      clean-css-promise: 0.1.1
-      inline-source-map-comment: 1.0.5
-      json-stable-stringify: 1.0.2
+      agent-base: 6.0.2
+      https-proxy-agent: 5.0.1
+      is-running: 2.1.0
+      ps-tree: 1.2.0
+      temp-fs: 0.9.9
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /broccoli-concat@4.2.5:
-    resolution: {integrity: sha512-dFB5ATPwOyV8S2I7a07HxCoutoq23oY//LhM6Mou86cWUTB174rND5aQLR7Fu8FjFFLxoTbkk7y0VPITJ1IQrw==}
-    engines: {node: 10.* || >= 12.*}
+  /browserstack@1.6.1:
+    resolution: {integrity: sha512-GxtFjpIaKdbAyzHfFDKixKO8IBT7wR3NjbzrGc78nNs/Ciys9wU3/nBtsqsWv5nDSrdI5tz0peKuzCPuNXNUiw==}
     dependencies:
-      broccoli-debug: 0.6.5
-      broccoli-kitchen-sink-helpers: 0.3.1
-      broccoli-plugin: 4.0.7
-      ensure-posix-path: 1.1.1
-      fast-sourcemap-concat: 2.1.0
-      find-index: 1.1.1
-      fs-extra: 8.1.0
-      fs-tree-diff: 2.0.1
-      lodash.merge: 4.6.2
-      lodash.omit: 4.5.0
-      lodash.uniq: 4.5.0
+      https-proxy-agent: 2.2.4
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /broccoli-config-loader@1.0.1:
-    resolution: {integrity: sha512-MDKYQ50rxhn+g17DYdfzfEM9DjTuSGu42Db37A8TQHQe8geYEcUZ4SQqZRgzdAI3aRQNlA1yBHJfOeGmOjhLIg==}
-    dependencies:
-      broccoli-caching-writer: 3.0.3
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-config-replace@1.1.2:
-    resolution: {integrity: sha512-qLlEY3V7p3ZWJNRPdPgwIM77iau1qR03S9BupMMFngjzBr7S6RSzcg96HbCYXmW9gfTbjRm9FC4CQT81SBusZg==}
-    dependencies:
-      broccoli-kitchen-sink-helpers: 0.3.1
-      broccoli-plugin: 1.3.1
-      debug: 2.6.9
-      fs-extra: 0.24.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-debug@0.6.5:
-    resolution: {integrity: sha512-RIVjHvNar9EMCLDW/FggxFRXqpjhncM/3qq87bn/y+/zR9tqEkHvTqbyOc4QnB97NO2m6342w4wGkemkaeOuWg==}
-    dependencies:
-      broccoli-plugin: 1.3.1
-      fs-tree-diff: 0.5.9
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      symlink-or-copy: 1.3.1
-      tree-sync: 1.4.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-funnel-reducer@1.0.0:
-    resolution: {integrity: sha512-SaOCEdh+wnt2jFUV2Qb32m7LXyElvFwW3NKNaEJyi5PGQNwxfqpkc0KI6AbQANKgdj/40U2UC0WuGThFwuEUaA==}
-    dev: true
-
-  /broccoli-funnel@2.0.2:
-    resolution: {integrity: sha512-/vDTqtv7ipjEZQOVqO4vGDVAOZyuYzQ/EgGoyewfOgh1M7IQAToBKZI0oAQPgMBeFPPlIbfMuAngk+ohPBuaHQ==}
-    engines: {node: ^4.5 || 6.* || >= 7.*}
-    dependencies:
-      array-equal: 1.0.0
-      blank-object: 1.0.2
-      broccoli-plugin: 1.3.1
-      debug: 2.6.9
-      fast-ordered-set: 1.0.3
-      fs-tree-diff: 0.5.9
-      heimdalljs: 0.2.6
-      minimatch: 3.1.2
-      mkdirp: 0.5.6
-      path-posix: 1.0.0
-      rimraf: 2.7.1
-      symlink-or-copy: 1.3.1
-      walk-sync: 0.3.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-funnel@3.0.8:
-    resolution: {integrity: sha512-ng4eIhPYiXqMw6SyGoxPHR3YAwEd2lr9FgBI1CyTbspl4txZovOsmzFkMkGAlu88xyvYXJqHiM2crfLa65T1BQ==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      array-equal: 1.0.0
-      broccoli-plugin: 4.0.7
-      debug: 4.3.4(supports-color@8.1.1)
-      fs-tree-diff: 2.0.1
-      heimdalljs: 0.2.6
-      minimatch: 3.1.2
-      walk-sync: 2.2.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-kitchen-sink-helpers@0.3.1:
-    resolution: {integrity: sha512-gqYnKSJxBSjj/uJqeuRAzYVbmjWhG0mOZ8jrp6+fnUIOgLN6MvI7XxBECDHkYMIFPJ8Smf4xaI066Q2FqQDnXg==}
-    dependencies:
-      glob: 5.0.15
-      mkdirp: 0.5.6
-    dev: true
-
-  /broccoli-merge-trees@3.0.2:
-    resolution: {integrity: sha512-ZyPAwrOdlCddduFbsMyyFzJUrvW6b04pMvDiAQZrCwghlvgowJDY+EfoXn+eR1RRA5nmGHJ+B68T63VnpRiT1A==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      broccoli-plugin: 1.3.1
-      merge-trees: 2.0.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-merge-trees@4.2.0:
-    resolution: {integrity: sha512-nTrQe5AQtCrW4enLRvbD/vTLHqyW2tz+vsLXQe4IEaUhepuMGVKJJr+I8n34Vu6fPjmPLwTjzNC8izMIDMtHPw==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      broccoli-plugin: 4.0.7
-      merge-trees: 2.0.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-middleware@2.1.1:
-    resolution: {integrity: sha512-BK8aPhQpOLsHWiftrqXQr84XsvzUqeaN4PlCQOYg5yM0M+WKAHtX2WFXmicSQZOVgKDyh5aeoNTFkHjBAEBzwQ==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dependencies:
-      ansi-html: 0.0.7
-      handlebars: 4.7.7
-      has-ansi: 3.0.0
-      mime-types: 2.1.35
-    dev: true
-
-  /broccoli-node-api@1.7.0:
-    resolution: {integrity: sha512-QIqLSVJWJUVOhclmkmypJJH9u9s/aWH4+FH6Q6Ju5l+Io4dtwqdPUNmDfw40o6sxhbZHhqGujDJuHTML1wG8Yw==}
-    dev: true
-
-  /broccoli-node-info@1.1.0:
-    resolution: {integrity: sha512-DUohSZCdfXli/3iN6SmxPbck1OVG8xCkrLx47R25his06xVc1ZmmrOsrThiM8BsCWirwyocODiYJqNP5W2Hg1A==}
-    engines: {node: '>= 0.10.0'}
-    dev: true
-
-  /broccoli-node-info@2.2.0:
-    resolution: {integrity: sha512-VabSGRpKIzpmC+r+tJueCE5h8k6vON7EIMMWu6d/FyPdtijwLQ7QvzShEw+m3mHoDzUaj/kiZsDYrS8X2adsBg==}
-    engines: {node: 8.* || >= 10.*}
-    dev: true
-
-  /broccoli-output-wrapper@3.2.5:
-    resolution: {integrity: sha512-bQAtwjSrF4Nu0CK0JOy5OZqw9t5U0zzv2555EA/cF8/a8SLDTIetk9UgrtMVw7qKLKdSpOZ2liZNeZZDaKgayw==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      fs-extra: 8.1.0
-      heimdalljs-logger: 0.1.10
-      symlink-or-copy: 1.3.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-persistent-filter@1.4.6:
-    resolution: {integrity: sha512-0RejLwoC95kv4kta8KAa+FmECJCK78Qgm8SRDEK7YyU0N9Cx6KpY3UCDy9WELl3mCXLN8TokNxc7/hp3lL4lfw==}
-    dependencies:
-      async-disk-cache: 1.3.5
-      async-promise-queue: 1.0.5
-      broccoli-plugin: 1.3.1
-      fs-tree-diff: 0.5.9
-      hash-for-dep: 1.5.1
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      mkdirp: 0.5.6
-      promise-map-series: 0.2.3
-      rimraf: 2.7.1
-      rsvp: 3.6.2
-      symlink-or-copy: 1.3.1
-      walk-sync: 0.3.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-persistent-filter@2.3.1:
-    resolution: {integrity: sha512-hVsmIgCDrl2NFM+3Gs4Cr2TA6UPaIZip99hN8mtkaUPgM8UeVnCbxelCvBjUBHo0oaaqP5jzqqnRVvb568Yu5g==}
-    engines: {node: 6.* || >= 8.*}
-    dependencies:
-      async-disk-cache: 1.3.5
-      async-promise-queue: 1.0.5
-      broccoli-plugin: 1.3.1
-      fs-tree-diff: 2.0.1
-      hash-for-dep: 1.5.1
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      mkdirp: 0.5.6
-      promise-map-series: 0.2.3
-      rimraf: 2.7.1
-      rsvp: 4.8.5
-      symlink-or-copy: 1.3.1
-      sync-disk-cache: 1.3.4
-      walk-sync: 1.1.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-plugin@1.3.1:
-    resolution: {integrity: sha512-DW8XASZkmorp+q7J4EeDEZz+LoyKLAd2XZULXyD9l4m9/hAKV3vjHmB1kiUshcWAYMgTP1m2i4NnqCE/23h6AQ==}
-    dependencies:
-      promise-map-series: 0.2.3
-      quick-temp: 0.1.8
-      rimraf: 2.7.1
-      symlink-or-copy: 1.3.1
-    dev: true
-
-  /broccoli-plugin@2.1.0:
-    resolution: {integrity: sha512-ElE4caljW4slapyEhSD9jU9Uayc8SoSABWdmY9SqbV8DHNxU6xg1jJsPcMm+cXOvggR3+G+OXAYQeFjWVnznaw==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dependencies:
-      promise-map-series: 0.2.3
-      quick-temp: 0.1.8
-      rimraf: 2.7.1
-      symlink-or-copy: 1.3.1
-    dev: true
-
-  /broccoli-plugin@4.0.7:
-    resolution: {integrity: sha512-a4zUsWtA1uns1K7p9rExYVYG99rdKeGRymW0qOCNkvDPHQxVi3yVyJHhQbM3EZwdt2E0mnhr5e0c/bPpJ7p3Wg==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      broccoli-node-api: 1.7.0
-      broccoli-output-wrapper: 3.2.5
-      fs-merger: 3.2.1
-      promise-map-series: 0.3.0
-      quick-temp: 0.1.8
-      rimraf: 3.0.2
-      symlink-or-copy: 1.3.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli-slow-trees@3.1.0:
-    resolution: {integrity: sha512-FRI7mRTk2wjIDrdNJd6znS7Kmmne4VkAkl8Ix1R/VoePFMD0g0tEl671xswzFqaRjpT9Qu+CC4hdXDLDJBuzMw==}
-    dependencies:
-      heimdalljs: 0.2.6
-    dev: true
-
-  /broccoli-source@3.0.1:
-    resolution: {integrity: sha512-ZbGVQjivWi0k220fEeIUioN6Y68xjMy0xiLAc0LdieHI99gw+tafU8w0CggBDYVNsJMKUr006AZaM7gNEwCxEg==}
-    engines: {node: 8.* || 10.* || >= 12.*}
-    dependencies:
-      broccoli-node-api: 1.7.0
-    dev: true
-
-  /broccoli-stew@3.0.0:
-    resolution: {integrity: sha512-NXfi+Vas24n3Ivo21GvENTI55qxKu7OwKRnCLWXld8MiLiQKQlWIq28eoARaFj0lTUFwUa4jKZeA7fW9PiWQeg==}
-    engines: {node: 8.* || >= 10.*}
-    dependencies:
-      broccoli-debug: 0.6.5
-      broccoli-funnel: 2.0.2
-      broccoli-merge-trees: 3.0.2
-      broccoli-persistent-filter: 2.3.1
-      broccoli-plugin: 2.1.0
-      chalk: 2.4.2
-      debug: 4.3.4(supports-color@8.1.1)
-      ensure-posix-path: 1.1.1
-      fs-extra: 8.1.0
-      minimatch: 3.1.2
-      resolve: 1.22.8
-      rsvp: 4.8.5
-      symlink-or-copy: 1.3.1
-      walk-sync: 1.1.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /broccoli@3.5.2:
-    resolution: {integrity: sha512-sWi3b3fTUSVPDsz5KsQ5eCQNVAtLgkIE/HYFkEZXR/07clqmd4E/gFiuwSaqa9b+QTXc1Uemfb7TVWbEIURWDg==}
-    engines: {node: 8.* || >= 10.*}
-    dependencies:
-      '@types/chai': 4.3.5
-      '@types/chai-as-promised': 7.1.5
-      '@types/express': 4.17.17
-      ansi-html: 0.0.7
-      broccoli-node-info: 2.2.0
-      broccoli-slow-trees: 3.1.0
-      broccoli-source: 3.0.1
-      commander: 4.1.1
-      connect: 3.7.0
-      console-ui: 3.1.2
-      esm: 3.2.25
-      findup-sync: 4.0.0
-      handlebars: 4.7.7
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      https: 1.0.0
-      mime-types: 2.1.35
-      resolve-path: 1.4.0
-      rimraf: 3.0.2
-      sane: 4.1.0
-      tmp: 0.0.33
-      tree-sync: 2.1.0
-      underscore.string: 3.3.6
-      watch-detector: 1.0.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /browser-stdout@1.3.1:
-    resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==}
-    dev: true
-
-  /browserslist-generator@2.0.3:
-    resolution: {integrity: sha512-3j8ogwvlBpOEDR3f5n1H2n5BWXqHPWi/Xm8EC1DPJy5BWl4WkSFisatBygH/L9AEmg0MtOfcR1QnMuM9XL28jA==}
-    engines: {node: '>=16.15.1', npm: '>=7.0.0', pnpm: '>=3.2.0', yarn: '>=1.13'}
-    dependencies:
-      '@mdn/browser-compat-data': 5.2.56
-      '@types/object-path': 0.11.1
-      '@types/semver': 7.3.13
-      '@types/ua-parser-js': 0.7.36
-      browserslist: 4.22.1
-      caniuse-lite: 1.0.30001547
-      isbot: 3.6.10
-      object-path: 0.11.8
-      semver: 7.5.4
-      ua-parser-js: 1.0.35
-    dev: false
-
-  /browserslist@4.22.1:
-    resolution: {integrity: sha512-FEVc202+2iuClEhZhrWy6ZiAcRLvNMyYcxZ8raemul1DYVOVdFsbqckWLdsixQZCpJlwe77Z3UTalE7jsjnKfQ==}
-    engines: {node: ^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7}
-    hasBin: true
-    dependencies:
-      caniuse-lite: 1.0.30001547
-      electron-to-chromium: 1.4.553
-      node-releases: 2.0.13
-      update-browserslist-db: 1.0.13(browserslist@4.22.1)
-
-  /browserstack-local@1.5.2:
-    resolution: {integrity: sha512-qdsVGk5ndnVgjm5ekpaOfFYQoU/WOK1WFDrlzk9J7xzA+gnD1Vge2w1TFwvc2M0LW6VZePSk6y0Q1CPGyT/9HQ==}
-    dependencies:
-      agent-base: 6.0.2
-      https-proxy-agent: 5.0.1
-      is-running: 2.1.0
-      ps-tree: 1.2.0
-      temp-fs: 0.9.9
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /browserstack@1.6.1:
-    resolution: {integrity: sha512-GxtFjpIaKdbAyzHfFDKixKO8IBT7wR3NjbzrGc78nNs/Ciys9wU3/nBtsqsWv5nDSrdI5tz0peKuzCPuNXNUiw==}
-    dependencies:
-      https-proxy-agent: 2.2.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /bser@2.1.1:
-    resolution: {integrity: sha512-gQxTNE/GAfIIrmHLUE3oJyp5FO6HRBfhjnw4/wMmA63ZGDJnWBmgY/lyQBpnDUkGmAhbSe39tx2d/iTOAfglwQ==}
-    dependencies:
-      node-int64: 0.4.0
-    dev: true
-
-  /buffer-crc32@0.2.13:
-    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
+  /buffer-crc32@0.2.13:
+    resolution: {integrity: sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==}
 
   /buffer-from@1.1.2:
     resolution: {integrity: sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==}
@@ -4766,9 +5054,6 @@ packages:
     engines: {node: '>=12'}
     dependencies:
       run-applescript: 5.0.0
-
-  /bytes@1.0.0:
-    resolution: {integrity: sha512-/x68VkHLeTl3/Ll8IvxdwzhrT+IyKc52e/oyHhA2RwqPqswSnjVbSddfPRwAsJtbilMAPSRWwAlpxdYsSWOTKQ==}
     dev: true
 
   /bytes@3.0.0:
@@ -4807,21 +5092,6 @@ packages:
       - bluebird
     dev: true
 
-  /cache-base@1.0.1:
-    resolution: {integrity: sha512-AKcdTnFSWATd5/GCPRxr2ChwIJ85CeyrEyjRHlKxQ56d4XJMGym0uAiKn0xbLOGOl3+yRpOTi484dVCEc5AUzQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      collection-visit: 1.0.0
-      component-emitter: 1.3.0
-      get-value: 2.0.6
-      has-value: 1.0.0
-      isobject: 3.0.1
-      set-value: 2.0.1
-      to-object-path: 0.3.0
-      union-value: 1.0.1
-      unset-value: 1.0.0
-    dev: true
-
   /cacheable-lookup@7.0.0:
     resolution: {integrity: sha512-+qJyx4xiKra8mZrcwhjMRMUhD5NR1R8esPkzIYxX96JiecFoxAXFuz/GpR3+ev4PE1WamHip78wV0vcmPQtp8w==}
     engines: {node: '>=14.16'}
@@ -4831,7 +5101,7 @@ packages:
     resolution: {integrity: sha512-zkDT5WAF4hSSoUgyfg5tFIxz8XQK+25W/TLVojJTMKBaxevLBBtLxgqguAuVQB8PVW79FVjHcU+GJ9tVbDZ9mQ==}
     engines: {node: '>=14.16'}
     dependencies:
-      '@types/http-cache-semantics': 4.0.2
+      '@types/http-cache-semantics': 4.0.3
       get-stream: 6.0.1
       http-cache-semantics: 4.1.1
       keyv: 4.5.4
@@ -4847,25 +5117,25 @@ packages:
       clone-response: 1.0.2
       get-stream: 5.2.0
       http-cache-semantics: 4.1.1
-      keyv: 3.1.0
+      keyv: 3.0.0
       lowercase-keys: 2.0.0
       normalize-url: 4.5.1
       responselike: 1.0.2
     dev: true
 
-  /calculate-cache-key-for-tree@2.0.0:
-    resolution: {integrity: sha512-Quw8a6y8CPmRd6eU+mwypktYCwUcf8yVFIRbNZ6tPQEckX9yd+EBVEPC/GSZZrMWH9e7Vz4pT7XhpmyApRByLQ==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dependencies:
-      json-stable-stringify: 1.0.2
-    dev: true
-
   /call-bind@1.0.2:
     resolution: {integrity: sha512-7O+FbCihrB5WGbFYesctwmTKae6rOiIzmz1icreWJ+0aA7LJfuqhEso2T9ncpcFtzMQtzXf2QGGueWJGTYsqrA==}
     dependencies:
-      function-bind: 1.1.2
+      function-bind: 1.1.1
       get-intrinsic: 1.2.1
 
+  /call-bind@1.0.5:
+    resolution: {integrity: sha512-C3nQxfFZxFRVoJoGKKI8y3MOEo129NQ+FgQ08iye+Mk4zNZZGdjfs06bVTr+DBSlA66Q2VEcMki/cUCP4SercQ==}
+    dependencies:
+      function-bind: 1.1.2
+      get-intrinsic: 1.2.2
+      set-function-length: 1.1.1
+
   /callsites@3.1.0:
     resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
     engines: {node: '>=6'}
@@ -4879,16 +5149,6 @@ packages:
       quick-lru: 4.0.1
     dev: true
 
-  /camelcase-keys@8.0.2:
-    resolution: {integrity: sha512-qMKdlOfsjlezMqxkUGGMaWWs17i2HoL15tM+wtx8ld4nLrUwU58TFdvyGOz/piNP842KeO8yXvggVQSdQ828NA==}
-    engines: {node: '>=14.16'}
-    dependencies:
-      camelcase: 7.0.1
-      map-obj: 4.3.0
-      quick-lru: 6.1.1
-      type-fest: 2.19.0
-    dev: true
-
   /camelcase@5.3.1:
     resolution: {integrity: sha512-L28STB170nwWS63UjtlEOE3dldQApaJXZkOI1uMFfzf3rRuPegHaHesyee+YxQ+W6SvRDQV6UrdOdRiR153wJg==}
     engines: {node: '>=6'}
@@ -4904,50 +5164,20 @@ packages:
     engines: {node: '>=14.16'}
     dev: true
 
-  /can-symlink@1.0.0:
-    resolution: {integrity: sha512-RbsNrFyhwkx+6psk/0fK/Q9orOUr9VMxohGd8vTa4djf4TGLfblBgUfqZChrZuW0Q+mz2eBPFLusw9Jfukzmhg==}
-    hasBin: true
-    dependencies:
-      tmp: 0.0.28
-    dev: true
-
   /caniuse-api@3.0.0:
     resolution: {integrity: sha512-bsTwuIg/BZZK/vreVTYYbSWoe2F+71P7K5QGEX+pT250DZbfU1MQ5prOKpPR+LL6uWKK3KMwMCAS74QB3Um1uw==}
     dependencies:
-      browserslist: 4.22.1
-      caniuse-lite: 1.0.30001547
+      browserslist: 4.21.10
+      caniuse-lite: 1.0.30001521
       lodash.memoize: 4.1.2
       lodash.uniq: 4.5.0
     dev: false
 
-  /caniuse-lite@1.0.30001547:
-    resolution: {integrity: sha512-W7CrtIModMAxobGhz8iXmDfuJiiKg1WADMO/9x7/CLNin5cpSbuBjooyoIUVB5eyCc36QuTVlkVa1iB2S5+/eA==}
-
-  /capture-exit@2.0.0:
-    resolution: {integrity: sha512-PiT/hQmTonHhl/HFGN+Lx3JJUznrVYJ3+AQsnthneZbvW7x+f08Tk7yLJTLEOUvBTbduLeeBkxEaYXUOUrRq6g==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dependencies:
-      rsvp: 4.8.5
-    dev: true
-
-  /cardinal@1.0.0:
-    resolution: {integrity: sha512-INsuF4GyiFLk8C91FPokbKTc/rwHqV4JnfatVZ6GPhguP1qmkRWX2dp5tepYboYdPpGWisLVLI+KsXoXFPRSMg==}
-    hasBin: true
-    dependencies:
-      ansicolors: 0.2.1
-      redeyed: 1.0.1
-    dev: true
+  /caniuse-lite@1.0.30001521:
+    resolution: {integrity: sha512-fnx1grfpEOvDGH+V17eccmNjucGUnCbP6KL+l5KqBIerp26WK/+RQ7CIDE37KGJjaPyqWXXlFUyKiWmvdNNKmQ==}
 
-  /chalk@1.1.3:
-    resolution: {integrity: sha512-U3lRVLMSlsCfjqYPbLyVv11M9CPW4I728d6TCKMAOJueEeB9/8o+eSsMnxPJD+Q+K909sdESg7C+tIkoH6on1A==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      ansi-styles: 2.2.1
-      escape-string-regexp: 1.0.5
-      has-ansi: 2.0.0
-      strip-ansi: 3.0.1
-      supports-color: 2.0.0
-    dev: true
+  /caniuse-lite@1.0.30001553:
+    resolution: {integrity: sha512-N0ttd6TrFfuqKNi+pMgWJTb9qrdJu4JSpgPFLe/lrD19ugC6fZgF0pUewRowDwzdDnb9V41mFcdlYgl/PyKf4A==}
 
   /chalk@2.4.2:
     resolution: {integrity: sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==}
@@ -4967,6 +5197,7 @@ packages:
   /chalk@5.2.0:
     resolution: {integrity: sha512-ree3Gqw/nazQAPuJJEy+avdl7QfZMcUvmHIKgEZkGL+xOBzRvup5Hxo6LHuMceSxOabuJLJm5Yp/92R9eMmMvA==}
     engines: {node: ^12.17.0 || ^14.13 || >=16.0.0}
+    dev: false
 
   /chalk@5.3.0:
     resolution: {integrity: sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==}
@@ -5003,6 +5234,7 @@ packages:
 
   /chownr@1.1.4:
     resolution: {integrity: sha512-jJ0bqzaylmJtVnNgzTeSOs8DPavpbYgEr/b0YL8/2GO3xJEhInFmhKMUnEJQjZumK7KXGFhUy89PrsJWlakBVg==}
+    dev: false
 
   /chownr@2.0.0:
     resolution: {integrity: sha512-bIomtDF5KGpdogkLd9VspvFzk9KfpyyGlS8YFVZl7TGPBHL5snIOnxeshwVgPteQ9b4Eydl+pVbIyE1DcvCWgQ==}
@@ -5013,48 +5245,38 @@ packages:
     resolution: {integrity: sha512-p3KULyQg4S7NIHixdwbGX+nFHkoBiA4YQmyWtjb8XngSKV124nJmRysgAeujbUVb15vh+RvFUfCPqU7rXk+hZg==}
     engines: {node: '>=6.0'}
 
-  /chromium-bidi@0.4.7(devtools-protocol@0.0.1120988):
-    resolution: {integrity: sha512-6+mJuFXwTMU6I3vYLs6IL8A1DyQTPjCfIL971X0aMPVGRbGnNfl6i6Cl0NMbxi2bRYLGESt9T2ZIMRM5PAEcIQ==}
+  /chromium-bidi@0.4.32(devtools-protocol@0.0.1191157):
+    resolution: {integrity: sha512-RJnw0PW3sNdx1WclINVfVVx8JUH+tWTHZNpnEzlcM+Qgvf40dUH34U7gJq+cc/0LE+rbPxeT6ldqWrCbUf4jeg==}
     peerDependencies:
       devtools-protocol: '*'
     dependencies:
-      devtools-protocol: 0.0.1120988
-      mitt: 3.0.0
-
-  /ci-info@3.9.0:
-    resolution: {integrity: sha512-NIxF55hv4nSqQswkAeiOi1r83xy8JldOFDTWiug55KBu9Jnblncd2U6ViHmYgHf01TPZS77NJBhBMKdWj9HQMQ==}
-    engines: {node: '>=8'}
+      devtools-protocol: 0.0.1191157
+      mitt: 3.0.1
+      urlpattern-polyfill: 9.0.0
     dev: true
 
-  /class-utils@0.3.6:
-    resolution: {integrity: sha512-qOhPa/Fj7s6TY8H8esGu5QNpMMQxz79h+urzrNYN6mn+9BnxlDGf5QZ+XeCDsxSjPqsSR56XOZOJmpeurnLMeg==}
-    engines: {node: '>=0.10.0'}
+  /chromium-bidi@0.4.33(devtools-protocol@0.0.1203626):
+    resolution: {integrity: sha512-IxoFM5WGQOIAd95qrSXzJUv4eXIrh+RvU3rwwqIiwYuvfE7U/Llj4fejbsJnjJMUYCuGtVQsY2gv7oGl4aTNSQ==}
+    peerDependencies:
+      devtools-protocol: '*'
     dependencies:
-      arr-union: 3.1.0
-      define-property: 0.2.5
-      isobject: 3.0.1
-      static-extend: 0.1.2
-    dev: true
-
-  /clean-base-url@1.0.0:
-    resolution: {integrity: sha512-9q6ZvUAhbKOSRFY7A/irCQ/rF0KIpa3uXpx6izm8+fp7b2H4hLeUJ+F1YYk9+gDQ/X8Q0MEyYs+tG3cht//HTg==}
+      devtools-protocol: 0.0.1203626
+      mitt: 3.0.1
+      urlpattern-polyfill: 9.0.0
     dev: true
 
-  /clean-css-promise@0.1.1:
-    resolution: {integrity: sha512-tzWkANXMD70ETa/wAu2TXAAxYWS0ZjVUFM2dVik8RQBoAbGMFJv4iVluz3RpcoEbo++fX4RV/BXfgGoOjp8o3Q==}
+  /chromium-bidi@0.4.7(devtools-protocol@0.0.1120988):
+    resolution: {integrity: sha512-6+mJuFXwTMU6I3vYLs6IL8A1DyQTPjCfIL971X0aMPVGRbGnNfl6i6Cl0NMbxi2bRYLGESt9T2ZIMRM5PAEcIQ==}
+    peerDependencies:
+      devtools-protocol: '*'
     dependencies:
-      array-to-error: 1.1.1
-      clean-css: 3.4.28
-      pinkie-promise: 2.0.1
-    dev: true
+      devtools-protocol: 0.0.1120988
+      mitt: 3.0.0
+    dev: false
 
-  /clean-css@3.4.28:
-    resolution: {integrity: sha512-aTWyttSdI2mYi07kWqHi24NUU9YlELFKGOAgFzZjDN1064DMAOy2FBuoyGmkKRlXkbpXd0EVHmiVkbKhKoirTw==}
-    engines: {node: '>=0.10.0'}
-    hasBin: true
-    dependencies:
-      commander: 2.8.1
-      source-map: 0.4.4
+  /ci-info@3.8.0:
+    resolution: {integrity: sha512-eXTggHWSooYhq49F2opQhuHWgzucfF2YgODK4e1566GQs5BIfP30B0oenwBJHfWxAs2fyPB1s7Mg949zLf61Yw==}
+    engines: {node: '>=8'}
     dev: true
 
   /clean-regexp@1.0.0:
@@ -5069,22 +5291,11 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /clean-up-path@1.0.0:
-    resolution: {integrity: sha512-PHGlEF0Z6976qQyN6gM7kKH6EH0RdfZcc8V+QhFe36eRxV0SMH5OUBZG7Bxa9YcreNzyNbK63cGiZxdSZgosRw==}
-    dev: true
-
   /cli-boxes@3.0.0:
     resolution: {integrity: sha512-/lzGpEWL/8PfI0BmBOPRwp0c/wFNX1RdUML3jK/RcSBA9T8mZDdQpqYBKtCFTOfQbwPqWEOpjqW+Fnayc0969g==}
     engines: {node: '>=10'}
     dev: true
 
-  /cli-cursor@2.1.0:
-    resolution: {integrity: sha512-8lgKz8LmCRYZZQDpRyT2m5rKJ08TnU4tR9FFFW2rxpxR1FzWi4PQ/NfyODchAatHaUgnSPVcx/R5w6NuTBzFiw==}
-    engines: {node: '>=4'}
-    dependencies:
-      restore-cursor: 2.0.0
-    dev: true
-
   /cli-cursor@3.1.0:
     resolution: {integrity: sha512-I/zHAwsKf9FqGoXM4WWRACob9+SNukZTd94DWF57E4toouRulbCxcUh6RKUEOQlYTHJnzkPMySvPNaaSLNfLZw==}
     engines: {node: '>=8'}
@@ -5117,22 +5328,6 @@ packages:
     engines: {node: '>=6'}
     dev: true
 
-  /cli-table@0.3.11:
-    resolution: {integrity: sha512-IqLQi4lO0nIB4tcdTpN4LCB9FI3uqrJZK7RC515EnhZ6qBaglkIgICb1wjeAqpdoOabm1+SuQtkXIPdYC93jhQ==}
-    engines: {node: '>= 0.2.0'}
-    dependencies:
-      colors: 1.0.3
-    dev: true
-
-  /cli-width@2.2.1:
-    resolution: {integrity: sha512-GRMWDxpOB6Dgk2E5Uo+3eEBvtOOlimMmpbFiKuLFnQzYDavtLFY3K5ona41jgN/WdRZtG7utuVSVTL4HbZHGkw==}
-    dev: true
-
-  /cli-width@3.0.0:
-    resolution: {integrity: sha512-FxqpkPPwu1HjuN93Omfm4h8uIanXofW0RxVEW3k5RKx+mJJYSthzNhp32Kzxxy3YAEZ/Dc/EWN1vZRY0+kOhbw==}
-    engines: {node: '>= 10'}
-    dev: true
-
   /cli-width@4.1.0:
     resolution: {integrity: sha512-ouuZd4/dm2Sw5Gmqy6bGyNNNe1qt9RpmxveLSO7KcgsTnU7RXfsw+/bukWGo1abgBiMAic068rclZsO4IWmmxQ==}
     engines: {node: '>= 12'}
@@ -5165,19 +5360,6 @@ packages:
     engines: {node: '>=0.8'}
     dev: true
 
-  /clone@2.1.2:
-    resolution: {integrity: sha512-3Pe/CF1Nn94hyhIYpjtiLhdCoEoz0DqQ+988E9gmeEdQZlojxnOb74wctFyuwWQHzqyf9X7C7MG8juUpqBJT8w==}
-    engines: {node: '>=0.8'}
-    dev: true
-
-  /collection-visit@1.0.0:
-    resolution: {integrity: sha512-lNkKvzEeMBBjUGHZ+q6z9pSJla0KWAQPvtzhEV9+iGyQYG+pBpl7xKDhxoNSOZH2hhv0v5k0y2yAM4o4SjoSkw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      map-visit: 1.0.0
-      object-visit: 1.0.1
-    dev: true
-
   /color-convert@1.9.3:
     resolution: {integrity: sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==}
     dependencies:
@@ -5197,32 +5379,14 @@ packages:
 
   /color-support@1.1.3:
     resolution: {integrity: sha512-qiBjkpbMLO/HL68y+lh4q0/O1MZFj2RX6X/KmMa3+gJD3z+WwI1ZzDHysvqHGS3mP6mznPckpXmw1nI9cJjyRg==}
-    hasBin: true
 
   /colord@2.9.3:
     resolution: {integrity: sha512-jeC1axXpnb0/2nn/Y1LPuLdgXBLH7aDcHu4KEKfqw3CUhX7ZpfBSlPKyqXE6btIgEzfWtrX3/tyBCaCvXvMkOw==}
     dev: false
 
-  /colors@1.0.3:
-    resolution: {integrity: sha512-pFGrxThWcWQ2MsAz6RtgeWe4NK2kUE1WfsrvvlctdII745EW9I0yflqhe7++M5LEc7bV2c/9/5zc8sFcpL0Drw==}
-    engines: {node: '>=0.1.90'}
-    dev: true
-
   /commander@2.20.3:
     resolution: {integrity: sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==}
 
-  /commander@2.8.1:
-    resolution: {integrity: sha512-+pJLBFVk+9ZZdlAOB5WuIElVPPth47hILFkmGym57aq8kwxsowvByvB0DHs1vQAhyMZzdcpTtF0VDKGkSDR4ZQ==}
-    engines: {node: '>= 0.6.x'}
-    dependencies:
-      graceful-readlink: 1.0.1
-    dev: true
-
-  /commander@4.1.1:
-    resolution: {integrity: sha512-NOKm8xhkzAjzFx8B2v5OAHT+u5pRQc2UCa2Vq9jYL/31o2wi9mxBA7LIFs3sV5VSC49z6pEhfbMULvShKj26WA==}
-    engines: {node: '>= 6'}
-    dev: true
-
   /commander@7.2.0:
     resolution: {integrity: sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==}
     engines: {node: '>= 10'}
@@ -5240,20 +5404,16 @@ packages:
     resolution: {integrity: sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==}
     dev: false
 
-  /compatfactory@2.0.9(typescript@5.0.4):
-    resolution: {integrity: sha512-fvO+AWcmbO7P1S+A3mwm3IGr74eHMeq5ZLhNhyNQc9mVDNHT4oe0Gg0ksdIFFNXLK7k7Z/TYcLAUSQdRgh1bsA==}
+  /compatfactory@3.0.0(typescript@5.2.2):
+    resolution: {integrity: sha512-WD5kF7koPwVoyKL8p0LlrmIZtilrD46sQStyzzxzTFinMKN2Dxk1hN+sddLSQU1mGIZvQfU8c+ONSghvvM40jg==}
     engines: {node: '>=14.9.0'}
     peerDependencies:
-      typescript: '>=3.x || >= 4.x || 5'
+      typescript: ^5.2.2 || 5
     dependencies:
       helpertypes: 0.0.19
-      typescript: 5.0.4
+      typescript: 5.2.2
     dev: false
 
-  /component-emitter@1.3.0:
-    resolution: {integrity: sha512-Rd3se6QB+sO1TwqZjscQrurpEPIfO0/yYnSin6Q/rD3mOutHvUrCAhJub3r90uNb+SESBuE0QYoB90YdfatsRg==}
-    dev: true
-
   /compressible@2.0.18:
     resolution: {integrity: sha512-AF3r7P5dWxL8MxyITRMlORQNaOA2IkAFaTr4k7BUumjPtRpGDTZpl0Pb1XCO6JeDCBdp126Cgs9sMxqSjgYyRg==}
     engines: {node: '>= 0.6'}
@@ -5292,18 +5452,6 @@ packages:
       proto-list: 1.2.4
     dev: true
 
-  /configstore@5.0.1:
-    resolution: {integrity: sha512-aMKprgk5YhBNyH25hj8wGt2+D52Sw1DRRIzqBwLp2Ya9mFmY8KPvvtvmna8SxVR9JMZ4kzMD68N22vlaRpkeFA==}
-    engines: {node: '>=8'}
-    dependencies:
-      dot-prop: 5.3.0
-      graceful-fs: 4.2.11
-      make-dir: 3.1.0
-      unique-string: 2.0.0
-      write-file-atomic: 3.0.3
-      xdg-basedir: 4.0.0
-    dev: true
-
   /configstore@6.0.0:
     resolution: {integrity: sha512-cD31W1v3GqUlQvbBCGcXmd2Nj9SvLDOP1oQ0YFuLETufzSPaKp11rYBsSOm7rCsW3OnIRAFM3OxRhceaXNYHkA==}
     engines: {node: '>=12'}
@@ -5319,36 +5467,12 @@ packages:
     resolution: {integrity: sha512-JsPKdmh8ZkmnHxDk55FZ1TqVLvEQTvoByJZRN9jzI0UjxK/QgAmsphz7PGtqgPieQZ/CQcHWXCR7ATDNhGe+YA==}
     dev: true
 
-  /connect@3.7.0:
-    resolution: {integrity: sha512-ZqRXc+tZukToSNmh5C2iWMSoV3X1YUcPbqEM4DkEG5tNQXrQUZCNVGGv3IuicnkMtPfGf3Xtp8WCXs295iQ1pQ==}
-    engines: {node: '>= 0.10.0'}
-    dependencies:
-      debug: 2.6.9
-      finalhandler: 1.1.2
-      parseurl: 1.3.3
-      utils-merge: 1.0.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /console-control-strings@1.1.0:
     resolution: {integrity: sha512-ty/fTekppD2fIwRvnZAVdeOiGd1c7YXEixbgJTNzqcxJWKQnjJ/V1bNEEE6hygpM3WjwHFUVK6HTjWSzV4a8sQ==}
 
-  /console-ui@3.1.2:
-    resolution: {integrity: sha512-+5j3R4wZJcEYZeXk30whc4ZU/+fWW9JMTNntVuMYpjZJ9n26Cxr0tUBXco1NRjVZRpRVvZ4DDKKKIHNYeUG9Dw==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dependencies:
-      chalk: 2.4.2
-      inquirer: 6.5.2
-      json-stable-stringify: 1.0.2
-      ora: 3.4.0
-      through2: 3.0.2
-    dev: true
-
   /consolidate@0.16.0(mustache@4.2.0):
     resolution: {integrity: sha512-Nhl1wzCslqXYTJVDyJCu3ODohy9OfBMB5uD2BiBTzd7w+QY0lBzafkR8y8755yMYHAaMD4NuzbAw03/xzfw+eQ==}
     engines: {node: '>= 0.10.0'}
-    deprecated: Please upgrade to consolidate v1.0.0+ as it has been modernized with several long-awaited fixes implemented. Maintenance is supported by Forward Email at https://forwardemail.net ; follow/watch https://github.com/ladjs/consolidate for updates and release changelog
     peerDependencies:
       arc-templates: ^0.5.3
       atpl: '>=0.7.6'
@@ -5527,10 +5651,6 @@ packages:
     engines: {node: '>= 0.6'}
     dev: true
 
-  /continuable-cache@0.3.1:
-    resolution: {integrity: sha512-TF30kpKhTH8AGCG3dut0rdd/19B7Z+qCnrMoBLpyQu/2drZdNrrpcjPEoJeSVsQM+8KmWG5O56oPDjSSUsuTyA==}
-    dev: true
-
   /convert-source-map@2.0.0:
     resolution: {integrity: sha512-Kvp459HrV2FEJ1CAsi1Ku+MY3kasH19TFykTz2xWmMeq6bk2NU3XXvfJ+Q61m0xktWwt+1HSYf3JZsTms3aRJg==}
 
@@ -5548,34 +5668,21 @@ packages:
     engines: {node: '>= 0.6'}
     dev: true
 
-  /copy-descriptor@0.1.1:
-    resolution: {integrity: sha512-XgZ0pFcakEUlbwQEVNg3+QAis1FyTL3Qel9FYy8pSkQqoG3PNoT0bOCQtOXcOkur21r2Eq2kI+IE+gsmAEVlYw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
+  /core-js-compat@3.32.0:
+    resolution: {integrity: sha512-7a9a3D1k4UCVKnLhrgALyFcP7YCsLOQIxPd0dKjf/6GuPcgyiGP70ewWdCGrSK7evyhymi0qO4EqCmSJofDeYw==}
+    dependencies:
+      browserslist: 4.21.10
 
-  /core-js-compat@3.30.1:
-    resolution: {integrity: sha512-d690npR7MC6P0gq4npTl5n2VQeNAmUrJ90n+MHiKS7W2+xno4o3F5GDEuylSdi6EJ3VssibSGXOa1r3YXD3Mhw==}
+  /core-js-compat@3.33.1:
+    resolution: {integrity: sha512-6pYKNOgD/j/bkC5xS5IIg6bncid3rfrI42oBH1SQJbsmYPKF7rhzcFzYCcxYMmNQQ0rCEB8WqpW7QHndOggaeQ==}
     dependencies:
       browserslist: 4.22.1
 
-  /core-js@2.6.12:
-    resolution: {integrity: sha512-Kb2wC0fvsWfQrgk8HU5lW6U/Lcs8+9aaYcy4ZFc6DDlo4nZ7n70dEgE5rtR0oG6ufKDUnrwfWL1mXR5ljDatrQ==}
-    deprecated: core-js@<3.23.3 is no longer maintained and not recommended for usage due to the number of issues. Because of the V8 engine whims, feature detection in old core-js versions could cause a slowdown up to 100x even if nothing is polyfilled. Some versions have web compatibility issues. Please, upgrade your dependencies to the actual version of core-js.
-    requiresBuild: true
-    dev: true
-
   /core-js@3.30.2:
     resolution: {integrity: sha512-uBJiDmwqsbJCWHAwjrx3cvjbMXP7xD72Dmsn5LOJpiRmE3WbBbN5rCqQ2Qh6Ek6/eOrjlWngEynBWo4VxerQhg==}
     requiresBuild: true
     dev: true
 
-  /core-object@3.1.5:
-    resolution: {integrity: sha512-sA2/4+/PZ/KV6CKgjrVrrUVBKCkdDO02CUlQ0YKTQoYUwPYNOtOAcWlbYhd5v/1JqYaA6oZ4sDlOU4ppVw6Wbg==}
-    engines: {node: '>= 4'}
-    dependencies:
-      chalk: 2.4.2
-    dev: true
-
   /core-util-is@1.0.3:
     resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
     dev: true
@@ -5607,12 +5714,13 @@ packages:
       js-yaml: 4.1.0
       parse-json: 5.2.0
       path-type: 4.0.0
+    dev: false
 
-  /cosmiconfig@8.3.6(typescript@5.0.4):
+  /cosmiconfig@8.3.6(typescript@5.2.2):
     resolution: {integrity: sha512-kcZ6+W5QzcJ3P1Mt+83OUv/oHFqZHIx8DuxG6eZ5RGMERoLqp4BuGjhHLYGK+Kf5XVkQvqBSmAy/nGWN3qDgEA==}
     engines: {node: '>=14'}
     peerDependencies:
-      typescript: '>=4.9.5 || 5'
+      typescript: ^5.2.2 || 5
     peerDependenciesMeta:
       typescript:
         optional: true
@@ -5621,7 +5729,7 @@ packages:
       js-yaml: 4.1.0
       parse-json: 5.2.0
       path-type: 4.0.0
-      typescript: 5.0.4
+      typescript: 5.2.2
     dev: true
 
   /create-require@1.1.1:
@@ -5633,6 +5741,15 @@ packages:
       node-fetch: 2.6.7
     transitivePeerDependencies:
       - encoding
+    dev: false
+
+  /cross-fetch@4.0.0:
+    resolution: {integrity: sha512-e4a5N8lVvuLgAWgnCrLr2PP0YyDOTHa9H/Rj54dirp61qXnNq46m82bRhNqIA5VccJtWBvPTFRV3TtvHUKPB1g==}
+    dependencies:
+      node-fetch: 2.6.12
+    transitivePeerDependencies:
+      - encoding
+    dev: true
 
   /cross-spawn@6.0.5:
     resolution: {integrity: sha512-eTVLrBSt7fjbDygz805pMnstIs2VTBNkRm0qxZd+M7A5XDdxVRWO5MxGBXZhjY4cqLYLdtrGqRf8mBPmzwSpWQ==}
@@ -5640,7 +5757,7 @@ packages:
     dependencies:
       nice-try: 1.0.5
       path-key: 2.0.1
-      semver: 5.7.2
+      semver: 5.7.1
       shebang-command: 1.2.0
       which: 1.3.1
     dev: true
@@ -5657,14 +5774,9 @@ packages:
     resolution: {integrity: sha512-ju88BYCQ2uvjO2bR+SsgLSTwTSctU+6Vp2ePbKPgSCZyy4MWZxYsT738DlKVRE5utUjobjPRm1MkTYKJxCmpTA==}
     engines: {node: '>=14.9.0'}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
     dev: false
 
-  /crypto-random-string@2.0.0:
-    resolution: {integrity: sha512-v1plID3y9r/lPhviJ1wrXpLeyUIGAZ2SHNYTEapm7/8A9nLPoyvVp3RK/EPFqn5kEznyWgYZNsRtYYIWbuG8KA==}
-    engines: {node: '>=8'}
-    dev: true
-
   /crypto-random-string@4.0.0:
     resolution: {integrity: sha512-x8dy3RnvYdlUcPOjkEHqozhiwzKNSq7GcPuXFbnyMOCHxX8V3OgIg/pYuabl2sbUPfIJaeAQB7PMOK8DFIdoRA==}
     engines: {node: '>=12'}
@@ -5707,7 +5819,6 @@ packages:
   /cssesc@3.0.0:
     resolution: {integrity: sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==}
     engines: {node: '>=4'}
-    hasBin: true
     dev: false
 
   /cssnano-preset-default@5.2.14(postcss@8.4.31):
@@ -5785,8 +5896,8 @@ packages:
     engines: {node: '>= 12'}
     dev: true
 
-  /data-uri-to-buffer@6.0.1:
-    resolution: {integrity: sha512-MZd3VlchQkp8rdend6vrx7MmVDJzSNTBvghvKjirLkD+WTChA3KUf0jkE68Q4UyctNqI11zZO9/x2Yx+ub5Cvg==}
+  /data-uri-to-buffer@5.0.1:
+    resolution: {integrity: sha512-a9l6T1qqDogvvnw0nKlfZzqsyikEBZBClF39V3TFoKhDtGBqHu2HkuomJc02j5zft8zrUaXEuoicLeW54RkzPg==}
     engines: {node: '>= 14'}
     dev: true
 
@@ -5841,11 +5952,6 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /decamelize@6.0.0:
-    resolution: {integrity: sha512-Fv96DCsdOgB6mdGl67MT5JaTNKRzrzill5OH5s8bjYJXVlcXyPYGyPsUkWyGV5p1TXI5esYIYMMeDJL0hEIwaA==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dev: true
-
   /decode-named-character-reference@1.0.2:
     resolution: {integrity: sha512-O8x12RzrUF8xyVcY0KJowWsmaJxQbmy0/EtnNtHRpsOcT7dFk5W598coHqBVpmWo1oQQfsCqfCmkZN5DJrZVdg==}
     dependencies:
@@ -5890,6 +5996,7 @@ packages:
     dependencies:
       bplist-parser: 0.2.0
       untildify: 4.0.0
+    dev: true
 
   /default-browser@4.0.0:
     resolution: {integrity: sha512-wX5pXO1+BrhMkSbROFsyxUm0i/cJEScyNhA4PPxc41ICuv05ZZB/MX28s8aZx6xjmatvebIapF6hLEKEcpneUA==}
@@ -5899,6 +6006,7 @@ packages:
       default-browser-id: 3.0.0
       execa: 7.2.0
       titleize: 3.0.0
+    dev: true
 
   /defaults@1.0.4:
     resolution: {integrity: sha512-eFuaLoy/Rxalv2kr+lqMlUnrDWV+3j4pljOIJgLIhI058IQfWJ7vXhyEIHu+HtC738klGALYxOKDO0bQP3tg8A==}
@@ -5915,11 +6023,11 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /define-data-property@1.1.0:
-    resolution: {integrity: sha512-UzGwzcjyv3OtAvolTj1GoyNYzfFR+iqbGjcnBEENZVCpM4/Ng1yhGNvS3lR/xDS74Tb2wGG9WzNSNIOS9UVb2g==}
+  /define-data-property@1.1.1:
+    resolution: {integrity: sha512-E7uGkTzkk1d0ByLeSc6ZsFS79Axg+m1P/VsgYsxHgiuc3tFSj+MjMIwe90FC4lOAZzNBdY7kkO2P2wKdsQ1vgQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.1
+      get-intrinsic: 1.2.2
       gopd: 1.0.1
       has-property-descriptors: 1.0.0
 
@@ -5931,37 +6039,15 @@ packages:
   /define-lazy-prop@3.0.0:
     resolution: {integrity: sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg==}
     engines: {node: '>=12'}
+    dev: true
 
-  /define-properties@1.2.1:
-    resolution: {integrity: sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==}
+  /define-properties@1.2.0:
+    resolution: {integrity: sha512-xvqAVKGfT1+UAvPwKTVw/njhdQ8ZhXK4lI0bCIuCMrp2up9nPnaDftrLtmpTazqd1o+UY4zgzU+avtMbDP+ldA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      define-data-property: 1.1.0
       has-property-descriptors: 1.0.0
       object-keys: 1.1.1
 
-  /define-property@0.2.5:
-    resolution: {integrity: sha512-Rr7ADjQZenceVOAKop6ALkkRAmH1A4Gx9hV/7ZujPUN2rkATqFO0JZLZInbAjpZYoJ1gUx8MRMQVkYemcbMSTA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-descriptor: 0.1.6
-    dev: true
-
-  /define-property@1.0.0:
-    resolution: {integrity: sha512-cZTYKFWspt9jZsMscWo8sc/5lbPC9Q0N5nBLgb+Yd915iL3udB1uFgS3B8YCx66UVHq018DAVFoee7x+gxggeA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-descriptor: 1.0.2
-    dev: true
-
-  /define-property@2.0.2:
-    resolution: {integrity: sha512-jwK2UV4cnPpbcG7+VRARKTZPUWowwXA8bzH5NP6ud0oeAxyYPuGZUAC7hMugpCdz4BeSZl2Dl9k66CHJ/46ZYQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-descriptor: 1.0.2
-      isobject: 3.0.1
-    dev: true
-
   /degenerator@5.0.1:
     resolution: {integrity: sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==}
     engines: {node: '>= 14'}
@@ -5975,11 +6061,6 @@ packages:
     resolution: {integrity: sha512-bd2L678uiWATM6m5Z1VzNCErI3jiGzt6HGY8OVICs40JQq/HALfbyNJmp0UDakEY4pMMaN0Ly5om/B1VI/+xfQ==}
     dev: true
 
-  /depd@1.1.2:
-    resolution: {integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==}
-    engines: {node: '>= 0.6'}
-    dev: true
-
   /depd@2.0.0:
     resolution: {integrity: sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==}
     engines: {node: '>= 0.8'}
@@ -5999,11 +6080,6 @@ packages:
     engines: {node: '>= 0.8', npm: 1.2.8000 || >= 1.4.16}
     dev: true
 
-  /detect-file@1.0.0:
-    resolution: {integrity: sha512-DtCOLG98P007x7wiiOmfI0fi3eIKyWiLTGJ2MDnVi/E04lWGbf+JzrRHMm0rgIIZJGtHpKpbVgLWHrv8xXpc3Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /detect-indent@6.1.0:
     resolution: {integrity: sha512-reYkTUJAZb9gUuZ2RvVCNhVHdg62RHnJ7WJl8ftMi4diZ6NWlciOzQN88pUhSELEwflJht4oQDv0F0BMlwaYtA==}
     engines: {node: '>=8'}
@@ -6016,6 +6092,15 @@ packages:
 
   /devtools-protocol@0.0.1120988:
     resolution: {integrity: sha512-39fCpE3Z78IaIPChJsP6Lhmkbf4dWXOmzLk/KFTdRkNk/0JymRIfUynDVRndV9HoDz8PyalK1UH21ST/ivwW5Q==}
+    dev: false
+
+  /devtools-protocol@0.0.1191157:
+    resolution: {integrity: sha512-Fu2mUhX7zkzLHMJZk5wQTiHdl1eJrhK0GypUoSzogUt51MmYEv/46pCz4PtGGFlr0f2ZyYDzzx5CPtbEkuvcTA==}
+    dev: true
+
+  /devtools-protocol@0.0.1203626:
+    resolution: {integrity: sha512-nEzHZteIUZfGCZtTiS1fRpC8UZmsfD1SiyPvaUNvS13dvKf666OAm8YTi0+Ca3n1nLEyu49Cy4+dPWpaHFJk9g==}
+    dev: true
 
   /diff@4.0.2:
     resolution: {integrity: sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==}
@@ -6026,11 +6111,6 @@ packages:
     engines: {node: '>=0.3.1'}
     dev: true
 
-  /diff@5.1.0:
-    resolution: {integrity: sha512-D+mk+qE8VC/PAUrlAU34N+VfXev0ghe5ywmpqrawphmVZc1bEfn56uo9qpyGp1p4xpzOHkSW4ztBd6L7Xx4ACw==}
-    engines: {node: '>=0.3.1'}
-    dev: true
-
   /dir-glob@3.0.1:
     resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
     engines: {node: '>=8'}
@@ -6076,13 +6156,6 @@ packages:
       domhandler: 4.3.1
     dev: false
 
-  /dot-prop@5.3.0:
-    resolution: {integrity: sha512-QM8q3zDe58hqUqjraQOmzZ1LIH9SWQJTlEKCH4kJ2oQvLZk7RbQXvtDM2XEq3fwkV9CCvvH4LA0AV+ogFsBM2Q==}
-    engines: {node: '>=8'}
-    dependencies:
-      is-obj: 2.0.0
-    dev: true
-
   /dot-prop@6.0.1:
     resolution: {integrity: sha512-tE7ztYzXHIeyvc7N+hR3oi7FIbf/NIjVP9hmAt3yMXzrQ072/fpjGLx2GxNxGxUl5V73MEqYzioOMoVhGMJ5cA==}
     engines: {node: '>=10'}
@@ -6090,12 +6163,12 @@ packages:
       is-obj: 2.0.0
     dev: true
 
-  /dotenv-cli@7.2.1:
-    resolution: {integrity: sha512-ODHbGTskqRtXAzZapDPvgNuDVQApu4oKX8lZW7Y0+9hKA6le1ZJlyRS687oU9FXjOVEDU/VFV6zI125HzhM1UQ==}
+  /dotenv-cli@7.3.0:
+    resolution: {integrity: sha512-314CA4TyK34YEJ6ntBf80eUY+t1XaFLyem1k9P0sX1gn30qThZ5qZr/ZwE318gEnzyYP9yj9HJk6SqwE0upkfw==}
     hasBin: true
     dependencies:
       cross-spawn: 7.0.3
-      dotenv: 16.0.3
+      dotenv: 16.3.1
       dotenv-expand: 10.0.0
       minimist: 1.2.8
     dev: true
@@ -6105,8 +6178,8 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /dotenv@16.0.3:
-    resolution: {integrity: sha512-7GO6HghkA5fYG9TYnNxi14/7K9f5occMlp3zXAuSxn7CKCxt9xbNWG7yF8hTCSUchlfWSe3uLmlPfigevRItzQ==}
+  /dotenv@16.3.1:
+    resolution: {integrity: sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==}
     engines: {node: '>=12'}
     dev: true
 
@@ -6121,11 +6194,6 @@ packages:
   /eastasianwidth@0.2.0:
     resolution: {integrity: sha512-I88TYZWc9XiYHRQ4/3c5rjjfgkjhLyW2luGIheGERbNQ6OY7yTybanSpDXZa8y7VUP9YmDcYa+eyq4ca7iLqWA==}
 
-  /editions@1.3.4:
-    resolution: {integrity: sha512-gzao+mxnYDzIysXKMQi/+M1mjy/rjestjg6OPoYTtI+3Izp23oiGZitsl9lPDPiTGXbcSIk1iJWhliSaglxnUg==}
-    engines: {node: '>=0.8'}
-    dev: true
-
   /ee-first@1.1.1:
     resolution: {integrity: sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==}
     dev: true
@@ -6133,13 +6201,15 @@ packages:
   /eight-colors@1.0.3:
     resolution: {integrity: sha512-x6JCcDbcpZq78oWP5cFqhhM5kIBeGcGTKNkWzRcJnNgxfUKaj3EsWhFi0f4UQxhYhgtqPXVF++Q4hEd0ZX/taw==}
 
-  /electron-to-chromium@1.4.553:
-    resolution: {integrity: sha512-HiRdtyKS2+VhiXvjhMvvxiMC33FJJqTA5EB2YHgFZW6v7HkK4Q9Ahv2V7O2ZPgAjw+MyCJVMQvigj13H8t+wvA==}
+  /electron-to-chromium@1.4.495:
+    resolution: {integrity: sha512-mwknuemBZnoOCths4GtpU/SDuVMp3uQHKa2UNJT9/aVD6WVRjGpXOxRGX7lm6ILIenTdGXPSTCTDaWos5tEU8Q==}
+
+  /electron-to-chromium@1.4.566:
+    resolution: {integrity: sha512-mv+fAy27uOmTVlUULy15U3DVJ+jg+8iyKH1bpwboCRhtDC69GKf1PPTZvEIhCyDr81RFqfxZJYrbgp933a1vtg==}
 
   /ember-cli-browserstack@2.0.1:
     resolution: {integrity: sha512-8Ki6570dTSpvYLdNZ7VvJm4Gku4ZNfF78/4BeOD2IqH/vGo80hwBNqDqRINcy8et562uEWe8gUGyeYBZ2ohhkw==}
     engines: {node: 10.* || >= 12}
-    hasBin: true
     dependencies:
       browserstack: 1.6.1
       browserstack-local: 1.5.2
@@ -6149,197 +6219,8 @@ packages:
       - supports-color
     dev: true
 
-  /ember-cli-is-package-missing@1.0.0:
-    resolution: {integrity: sha512-9hEoZj6Au5onlSDdcoBqYEPT8ehlYntZPxH8pBKV0GO7LNel88otSAQsCfXvbi2eKE+MaSeLG/gNaCI5UdWm9g==}
-    dev: true
-
-  /ember-cli-lodash-subset@2.0.1:
-    resolution: {integrity: sha512-QkLGcYv1WRK35g4MWu/uIeJ5Suk2eJXKtZ+8s+qE7C9INmpCPyPxzaqZABquYzcWNzIdw6kYwz3NWAFdKYFxwg==}
-    engines: {node: ^4.5 || 6.* || >= 7.*}
-    dev: true
-
-  /ember-cli-normalize-entity-name@1.0.0:
-    resolution: {integrity: sha512-rF4P1rW2P1gVX1ynZYPmuIf7TnAFDiJmIUFI1Xz16VYykUAyiOCme0Y22LeZq8rTzwBMiwBwoE3RO4GYWehXZA==}
-    dependencies:
-      silent-error: 1.1.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /ember-cli-preprocess-registry@3.3.0:
-    resolution: {integrity: sha512-60GYpw7VPeB7TvzTLZTuLTlHdOXvayxjAQ+IxM2T04Xkfyu75O2ItbWlftQW7NZVGkaCsXSRAmn22PG03VpLMA==}
-    dependencies:
-      broccoli-clean-css: 1.1.0
-      broccoli-funnel: 2.0.2
-      debug: 3.2.7
-      process-relative-require: 1.0.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /ember-cli-string-utils@1.1.0:
-    resolution: {integrity: sha512-PlJt4fUDyBrC/0X+4cOpaGCiMawaaB//qD85AXmDRikxhxVzfVdpuoec02HSiTGTTB85qCIzWBIh8lDOiMyyFg==}
-    dev: true
-
-  /ember-cli@4.12.1:
-    resolution: {integrity: sha512-O4QqvbvyyAvIC5SlYNOOocEhX/co7wKOSEGf8M+ipU/zgzA5ElyKMAQly9wf1QJ/RbSD1j2cFVUBIdVH/OuJHg==}
-    engines: {node: '>= 14'}
-    hasBin: true
-    dependencies:
-      '@babel/core': 7.23.2
-      '@babel/plugin-transform-modules-amd': 7.20.11(@babel/core@7.23.2)
-      amd-name-resolver: 1.3.1
-      babel-plugin-module-resolver: 4.1.0
-      bower-config: 1.4.3
-      bower-endpoint-parser: 0.2.2
-      broccoli: 3.5.2
-      broccoli-amd-funnel: 2.0.1
-      broccoli-babel-transpiler: 7.8.1
-      broccoli-builder: 0.18.14
-      broccoli-concat: 4.2.5
-      broccoli-config-loader: 1.0.1
-      broccoli-config-replace: 1.1.2
-      broccoli-debug: 0.6.5
-      broccoli-funnel: 3.0.8
-      broccoli-funnel-reducer: 1.0.0
-      broccoli-merge-trees: 4.2.0
-      broccoli-middleware: 2.1.1
-      broccoli-slow-trees: 3.1.0
-      broccoli-source: 3.0.1
-      broccoli-stew: 3.0.0
-      calculate-cache-key-for-tree: 2.0.0
-      capture-exit: 2.0.0
-      chalk: 4.1.2
-      ci-info: 3.9.0
-      clean-base-url: 1.0.0
-      compression: 1.7.4
-      configstore: 5.0.1
-      console-ui: 3.1.2
-      core-object: 3.1.5
-      dag-map: 2.0.2
-      diff: 5.1.0
-      ember-cli-is-package-missing: 1.0.0
-      ember-cli-lodash-subset: 2.0.1
-      ember-cli-normalize-entity-name: 1.0.0
-      ember-cli-preprocess-registry: 3.3.0
-      ember-cli-string-utils: 1.1.0
-      ensure-posix-path: 1.1.1
-      execa: 5.1.1
-      exit: 0.1.2
-      express: 4.18.2
-      filesize: 10.0.7
-      find-up: 5.0.0
-      find-yarn-workspace-root: 2.0.0
-      fixturify-project: 2.1.1
-      fs-extra: 11.1.1
-      fs-tree-diff: 2.0.1
-      get-caller-file: 2.0.5
-      git-repo-info: 2.1.1
-      glob: 8.1.0
-      heimdalljs: 0.2.6
-      heimdalljs-fs-monitor: 1.1.1
-      heimdalljs-graph: 1.0.0
-      heimdalljs-logger: 0.1.10
-      http-proxy: 1.18.1
-      inflection: 2.0.1
-      inquirer: 8.2.5
-      is-git-url: 1.0.0
-      is-language-code: 3.1.0
-      isbinaryfile: 5.0.0
-      js-yaml: 4.1.0
-      leek: 0.0.24
-      lodash.template: 4.5.0
-      markdown-it: 13.0.1
-      markdown-it-terminal: 0.4.0(markdown-it@13.0.1)
-      minimatch: 7.4.6
-      morgan: 1.10.0
-      nopt: 3.0.6
-      npm-package-arg: 10.1.0
-      os-locale: 5.0.0
-      p-defer: 3.0.0
-      portfinder: 1.0.32
-      promise-map-series: 0.3.0
-      promise.hash.helper: 1.0.8
-      quick-temp: 0.1.8
-      remove-types: 1.0.0
-      resolve: 1.22.8
-      resolve-package-path: 4.0.3
-      safe-stable-stringify: 2.4.3
-      sane: 5.0.1
-      semver: 7.5.4
-      silent-error: 1.1.1
-      sort-package-json: 1.57.0
-      symlink-or-copy: 1.3.1
-      temp: 0.9.4
-      testem: 3.10.1
-      tiny-lr: 2.0.0
-      tree-sync: 2.1.0
-      uuid: 9.0.0
-      walk-sync: 3.0.0
-      watch-detector: 1.0.2
-      workerpool: 6.4.0
-      yam: 1.0.0
-    transitivePeerDependencies:
-      - arc-templates
-      - atpl
-      - babel-core
-      - bracket-template
-      - bufferutil
-      - coffee-script
-      - debug
-      - dot
-      - dust
-      - dustjs-helpers
-      - dustjs-linkedin
-      - eco
-      - ect
-      - ejs
-      - haml-coffee
-      - hamlet
-      - hamljs
-      - handlebars
-      - hogan.js
-      - htmling
-      - jade
-      - jazz
-      - jqtpl
-      - just
-      - liquid-node
-      - liquor
-      - lodash
-      - marko
-      - mote
-      - nunjucks
-      - plates
-      - pug
-      - qejs
-      - ractive
-      - razor-tmpl
-      - react
-      - react-dom
-      - slm
-      - squirrelly
-      - supports-color
-      - swig
-      - swig-templates
-      - teacup
-      - templayed
-      - then-jade
-      - then-pug
-      - tinyliquid
-      - toffee
-      - twig
-      - twing
-      - underscore
-      - utf-8-validate
-      - vash
-      - velocityjs
-      - walrus
-      - whiskers
-    dev: true
-
-  /emoji-regex@10.2.1:
-    resolution: {integrity: sha512-97g6QgOk8zlDRdgq1WxwgTMgEWGVAQvB5Fdpgc1MkNy56la5SKP9GsMXKDOdqwn90/41a8yPwIGk1Y6WVbeMQA==}
+  /emoji-regex@10.3.0:
+    resolution: {integrity: sha512-QpLs9D9v9kArv4lfDEgg1X/gN5XLnf/A6l9cs8SPZLRZR3ZkY9+kwIQTxm+fsSej5UMYGE8fdoaZVIBlqG0XTw==}
     dev: true
 
   /emoji-regex@8.0.0:
@@ -6377,7 +6258,7 @@ packages:
     dependencies:
       '@types/cookie': 0.4.1
       '@types/cors': 2.8.13
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
       accepts: 1.3.8
       base64id: 2.0.0
       cookie: 0.4.2
@@ -6406,8 +6287,8 @@ packages:
       memory-fs: 0.2.0
       tapable: 0.1.10
 
-  /enhanced-resolve@5.15.0:
-    resolution: {integrity: sha512-LXYT42KJ7lpIKECr2mAXIaMldcNCh/7E0KBKOu4KSfkHmP+mZmSs+8V5gBAqisWBy0OO4W5Oyys0GO1Y8KtdKg==}
+  /enhanced-resolve@5.14.0:
+    resolution: {integrity: sha512-+DCows0XNwLDcUhbFJPdlQEVnT2zXlCv7hPxemTz86/O+B/hCQ+mb7ydkPKiflpVraqLPCAfu7lDy+hBXueojw==}
     engines: {node: '>=10.13.0'}
     dependencies:
       graceful-fs: 4.2.11
@@ -6421,11 +6302,6 @@ packages:
     resolution: {integrity: sha512-p92if5Nz619I0w+akJrLZH0MX0Pb5DX39XOwQTtXSdQQOaYH03S1uIQp4mhOZtAXrxq4ViO67YTiLBo2638o9A==}
     dev: false
 
-  /entities@3.0.1:
-    resolution: {integrity: sha512-WiyBqoomrwMdFG1e0kqvASYfnlb0lp8M5o5Fw2OFq1hNZxxcNk8Ik0Xm7LxzBhuidnZB/UtBqVCgUz3kBOP51Q==}
-    engines: {node: '>=0.12'}
-    dev: true
-
   /env-editor@1.1.0:
     resolution: {integrity: sha512-7AXskzN6T7Q9TFcKAGJprUbpQa4i1VsAetO9rdBqbGMGlragTziBgWt4pVYJMBWHQlLoX0buy6WFikzPH4Qjpw==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -6440,31 +6316,65 @@ packages:
     dependencies:
       is-arrayish: 0.2.1
 
-  /error@7.2.1:
-    resolution: {integrity: sha512-fo9HBvWnx3NGUKMvMwB/CBCMMrfEJgbDTVDEkPygA3Bdd3lM1OyCd+rbQ8BwnpF6GdVeOLDNmyL4N5Bg80ZvdA==}
+  /es-abstract@1.21.2:
+    resolution: {integrity: sha512-y/B5POM2iBnIxCiernH1G7rC9qQoM77lLIMQLuob0zhp8C56Po81+2Nj0WFKnd0pNReDTnkYryc+zhOzpEIROg==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      string-template: 0.2.1
+      array-buffer-byte-length: 1.0.0
+      available-typed-arrays: 1.0.5
+      call-bind: 1.0.2
+      es-set-tostringtag: 2.0.1
+      es-to-primitive: 1.2.1
+      function.prototype.name: 1.1.5
+      get-intrinsic: 1.2.1
+      get-symbol-description: 1.0.0
+      globalthis: 1.0.3
+      gopd: 1.0.1
+      has: 1.0.3
+      has-property-descriptors: 1.0.0
+      has-proto: 1.0.1
+      has-symbols: 1.0.3
+      internal-slot: 1.0.5
+      is-array-buffer: 3.0.2
+      is-callable: 1.2.7
+      is-negative-zero: 2.0.2
+      is-regex: 1.1.4
+      is-shared-array-buffer: 1.0.2
+      is-string: 1.0.7
+      is-typed-array: 1.1.10
+      is-weakref: 1.0.2
+      object-inspect: 1.12.3
+      object-keys: 1.1.1
+      object.assign: 4.1.4
+      regexp.prototype.flags: 1.5.0
+      safe-regex-test: 1.0.0
+      string.prototype.trim: 1.2.7
+      string.prototype.trimend: 1.0.6
+      string.prototype.trimstart: 1.0.6
+      typed-array-length: 1.0.4
+      unbox-primitive: 1.0.2
+      which-typed-array: 1.1.9
     dev: true
 
-  /es-abstract@1.22.2:
-    resolution: {integrity: sha512-YoxfFcDmhjOgWPWsV13+2RNjq1F6UQnfs+8TftwNqtzlmFzEXvlUwdrNrYeaizfjQzRMxkZ6ElWMOJIFKdVqwA==}
+  /es-abstract@1.22.3:
+    resolution: {integrity: sha512-eiiY8HQeYfYH2Con2berK+To6GrK2RxbPawDkGq4UiCQQfZHb6wX9qQqkbpPqaxQFcl8d9QzZqo0tGE0VcrdwA==}
     engines: {node: '>= 0.4'}
     dependencies:
       array-buffer-byte-length: 1.0.0
       arraybuffer.prototype.slice: 1.0.2
       available-typed-arrays: 1.0.5
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       es-set-tostringtag: 2.0.1
       es-to-primitive: 1.2.1
       function.prototype.name: 1.1.6
-      get-intrinsic: 1.2.1
+      get-intrinsic: 1.2.2
       get-symbol-description: 1.0.0
       globalthis: 1.0.3
       gopd: 1.0.1
-      has: 1.0.4
       has-property-descriptors: 1.0.0
       has-proto: 1.0.1
       has-symbols: 1.0.3
+      hasown: 2.0.0
       internal-slot: 1.0.5
       is-array-buffer: 3.0.2
       is-callable: 1.2.7
@@ -6474,7 +6384,7 @@ packages:
       is-string: 1.0.7
       is-typed-array: 1.1.12
       is-weakref: 1.0.2
-      object-inspect: 1.12.3
+      object-inspect: 1.13.1
       object-keys: 1.1.1
       object.assign: 4.1.4
       regexp.prototype.flags: 1.5.1
@@ -6488,7 +6398,7 @@ packages:
       typed-array-byte-offset: 1.0.0
       typed-array-length: 1.0.4
       unbox-primitive: 1.0.2
-      which-typed-array: 1.1.11
+      which-typed-array: 1.1.13
 
   /es-array-method-boxes-properly@1.0.0:
     resolution: {integrity: sha512-wd6JXUmyHmt8T5a2xreUwKcGPq6f1f+WwIJkijUqiGcJz1qqnZgP6XIK+QyIWU5lT7imeNxUll48bziG+TSYcA==}
@@ -6508,21 +6418,21 @@ packages:
       stop-iteration-iterator: 1.0.0
     dev: true
 
-  /es-module-lexer@1.3.1:
-    resolution: {integrity: sha512-JUFAyicQV9mXc3YRxPnDlrfBKpqt6hUYzz9/boprUJHs4e4KVr3XwOF70doO6gwXUor6EWZJAyWAfKki84t20Q==}
+  /es-module-lexer@1.2.1:
+    resolution: {integrity: sha512-9978wrXM50Y4rTMmW5kXIC09ZdXQZqkE4mxhwkd8VbzsGkXGPgV4zWuqQJgCEzYngdo2dYDa0l8xhX4fkSwJSg==}
 
   /es-set-tostringtag@2.0.1:
     resolution: {integrity: sha512-g3OMbtlwY3QewlqAiMLI47KywjWZoEytKr8pf6iTC8uJq5bIAH52Z9pnQ8pVL6whrCto53JZDuUIsifGeLorTg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.1
-      has: 1.0.4
+      get-intrinsic: 1.2.2
+      has: 1.0.3
       has-tostringtag: 1.0.0
 
   /es-shim-unscopables@1.0.0:
     resolution: {integrity: sha512-Jm6GPcCdC30eMLbZ2x8z2WuRwAws3zTBBKuusffYVUrNj/GVSUAZ+xKMaUpfNDR5IbyNA5LJbaecoUVbmUcB1w==}
     dependencies:
-      has: 1.0.4
+      has: 1.0.3
 
   /es-to-primitive@1.2.1:
     resolution: {integrity: sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==}
@@ -6570,6 +6480,36 @@ packages:
       '@esbuild/win32-arm64': 0.17.18
       '@esbuild/win32-ia32': 0.17.18
       '@esbuild/win32-x64': 0.17.18
+    dev: true
+
+  /esbuild@0.18.20:
+    resolution: {integrity: sha512-ceqxoedUrcayh7Y7ZX6NdbbDzGROiyVBgC4PriJThBKSVPWnnFHZAkfI1lJT8QFkOwH4qOS2SJkS4wvpGl8BpA==}
+    engines: {node: '>=12'}
+    hasBin: true
+    requiresBuild: true
+    optionalDependencies:
+      '@esbuild/android-arm': 0.18.20
+      '@esbuild/android-arm64': 0.18.20
+      '@esbuild/android-x64': 0.18.20
+      '@esbuild/darwin-arm64': 0.18.20
+      '@esbuild/darwin-x64': 0.18.20
+      '@esbuild/freebsd-arm64': 0.18.20
+      '@esbuild/freebsd-x64': 0.18.20
+      '@esbuild/linux-arm': 0.18.20
+      '@esbuild/linux-arm64': 0.18.20
+      '@esbuild/linux-ia32': 0.18.20
+      '@esbuild/linux-loong64': 0.18.20
+      '@esbuild/linux-mips64el': 0.18.20
+      '@esbuild/linux-ppc64': 0.18.20
+      '@esbuild/linux-riscv64': 0.18.20
+      '@esbuild/linux-s390x': 0.18.20
+      '@esbuild/linux-x64': 0.18.20
+      '@esbuild/netbsd-x64': 0.18.20
+      '@esbuild/openbsd-x64': 0.18.20
+      '@esbuild/sunos-x64': 0.18.20
+      '@esbuild/win32-arm64': 0.18.20
+      '@esbuild/win32-ia32': 0.18.20
+      '@esbuild/win32-x64': 0.18.20
 
   /escalade@3.1.1:
     resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==}
@@ -6609,44 +6549,62 @@ packages:
       source-map: 0.6.1
     dev: true
 
-  /eslint-config-prettier@8.8.0(eslint@8.40.0):
+  /eslint-config-prettier@8.8.0(eslint@8.53.0):
     resolution: {integrity: sha512-wLbQiFre3tdGgpDv67NQKnJuTlcUVYHas3k+DZCc2U2BadthoEY4B7hLPvAxaqdyOGCzuLfii2fqGph10va7oA==}
     hasBin: true
     peerDependencies:
       eslint: '>=7.0.0'
     dependencies:
-      eslint: 8.40.0
+      eslint: 8.53.0
+    dev: true
 
-  /eslint-config-xo-typescript@0.57.0(@typescript-eslint/eslint-plugin@5.59.5)(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-u+qcTaADHn2/+hbDqZHRWiAps8JS6BcRsJKAADFxYHIPpYqQeQv9mXuhRe/1+ikfZAIz9hlG1V+Lkj8J7nf34A==}
-    engines: {node: '>=12'}
+  /eslint-config-prettier@9.0.0(eslint@8.47.0):
+    resolution: {integrity: sha512-IcJsTkJae2S35pRsRAwoCE+925rJJStOdkKnLVgtE+tEpqU0EVVM7OqrwxqgptKdX29NUwC82I5pXsGFIgSevw==}
+    hasBin: true
+    peerDependencies:
+      eslint: '>=7.0.0'
+    dependencies:
+      eslint: 8.47.0
+    dev: false
+
+  /eslint-config-prettier@9.0.0(eslint@8.53.0):
+    resolution: {integrity: sha512-IcJsTkJae2S35pRsRAwoCE+925rJJStOdkKnLVgtE+tEpqU0EVVM7OqrwxqgptKdX29NUwC82I5pXsGFIgSevw==}
+    hasBin: true
+    peerDependencies:
+      eslint: '>=7.0.0'
+    dependencies:
+      eslint: 8.53.0
+
+  /eslint-config-xo-typescript@1.0.1(@typescript-eslint/eslint-plugin@6.9.1)(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-vPQssnRSUgBFOEfB/KY12CXwltwFSn4RSCfa+w7gjBC2PFQ7Yfgmyei+1XUZ3K+8LRGef2NMJUcxts7PldhDjg==}
+    engines: {node: '>=16'}
     peerDependencies:
-      '@typescript-eslint/eslint-plugin': '>=5.57.0'
-      '@typescript-eslint/parser': '>=5.57.0'
+      '@typescript-eslint/eslint-plugin': '>=6.0.0'
+      '@typescript-eslint/parser': '>=6.0.0'
       eslint: '>=8.0.0'
-      typescript: '>=4.4 || 5'
+      typescript: ^5.2.2 || 5
     dependencies:
-      '@typescript-eslint/eslint-plugin': 5.59.5(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4)
-      '@typescript-eslint/parser': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
-      eslint: 8.40.0
-      typescript: 5.0.4
+      '@typescript-eslint/eslint-plugin': 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2)
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      eslint: 8.53.0
+      typescript: 5.2.2
     dev: true
 
-  /eslint-config-xo@0.43.1(eslint@8.40.0):
+  /eslint-config-xo@0.43.1(eslint@8.53.0):
     resolution: {integrity: sha512-azv1L2PysRA0NkZOgbndUpN+581L7wPqkgJOgxxw3hxwXAbJgD6Hqb/SjHRiACifXt/AvxCzE/jIKFAlI7XjvQ==}
     engines: {node: '>=12'}
     peerDependencies:
       eslint: '>=8.27.0'
     dependencies:
       confusing-browser-globals: 1.0.11
-      eslint: 8.40.0
+      eslint: 8.53.0
     dev: true
 
   /eslint-formatter-pretty@5.0.0:
     resolution: {integrity: sha512-Uick451FoL22/wXqyScX3inW8ZlD/GQO7eFXj3bqb6N/ZtuuF00/CwSNIKLbFCJPrX5V4EdQBSgJ/UVnmLRnug==}
     engines: {node: '>=14.16'}
     dependencies:
-      '@types/eslint': 8.37.0
+      '@types/eslint': 8.44.6
       ansi-escapes: 4.3.2
       chalk: 4.1.2
       eslint-rule-docs: 1.1.235
@@ -6661,34 +6619,66 @@ packages:
     dependencies:
       debug: 3.2.7
       is-core-module: 2.13.0
-      resolve: 1.22.8
+      resolve: 1.22.4
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /eslint-import-resolver-node@0.3.9:
+    resolution: {integrity: sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g==}
+    dependencies:
+      debug: 3.2.7
+      is-core-module: 2.13.1
+      resolve: 1.22.4
     transitivePeerDependencies:
       - supports-color
 
-  /eslint-import-resolver-typescript@3.5.5(@typescript-eslint/parser@5.59.5)(eslint-plugin-import@2.27.5)(eslint@8.40.0):
-    resolution: {integrity: sha512-TdJqPHs2lW5J9Zpe17DZNQuDnox4xo2o+0tE7Pggain9Rbc19ik8kFtXdxZ250FVx2kF4vlt2RSf4qlUpG7bhw==}
+  /eslint-import-resolver-typescript@3.6.0(@typescript-eslint/parser@6.9.0)(eslint-plugin-import@2.28.1)(eslint@8.47.0):
+    resolution: {integrity: sha512-QTHR9ddNnn35RTxlaEnx2gCxqFlF2SEN0SE2d17SqwyM7YOSI2GHWRYp5BiRkObTUNYPupC/3Fq2a0PpT+EKpg==}
     engines: {node: ^14.18.0 || >=16.0.0}
     peerDependencies:
       eslint: '*'
       eslint-plugin-import: '*'
     dependencies:
       debug: 4.3.4(supports-color@8.1.1)
-      enhanced-resolve: 5.15.0
-      eslint: 8.40.0
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
-      eslint-plugin-import: 2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
-      get-tsconfig: 4.5.0
-      globby: 13.2.2
+      enhanced-resolve: 5.14.0
+      eslint: 8.47.0
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.0)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.6.0)(eslint@8.47.0)
+      eslint-plugin-import: 2.28.1(@typescript-eslint/parser@6.9.0)(eslint-import-resolver-typescript@3.6.0)(eslint@8.47.0)
+      fast-glob: 3.3.1
+      get-tsconfig: 4.7.0
+      is-core-module: 2.13.0
+      is-glob: 4.0.3
+    transitivePeerDependencies:
+      - '@typescript-eslint/parser'
+      - eslint-import-resolver-node
+      - eslint-import-resolver-webpack
+      - supports-color
+    dev: false
+
+  /eslint-import-resolver-typescript@3.6.1(@typescript-eslint/parser@6.9.1)(eslint-plugin-i@2.28.1)(eslint@8.53.0):
+    resolution: {integrity: sha512-xgdptdoi5W3niYeuQxKmzVDTATvLYqhpwmykwsh7f6HIOStGWEIL9iqZgQDF9u9OEzrRwR8no5q2VT+bjAujTg==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      eslint: '*'
+      eslint-plugin-import: '*'
+    dependencies:
+      debug: 4.3.4(supports-color@8.1.1)
+      enhanced-resolve: 5.14.0
+      eslint: 8.53.0
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0)
+      eslint-plugin-import: /eslint-plugin-i@2.28.1(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint@8.53.0)
+      fast-glob: 3.3.1
+      get-tsconfig: 4.7.0
       is-core-module: 2.13.0
       is-glob: 4.0.3
-      synckit: 0.8.5
     transitivePeerDependencies:
       - '@typescript-eslint/parser'
       - eslint-import-resolver-node
       - eslint-import-resolver-webpack
       - supports-color
 
-  /eslint-import-resolver-webpack@0.13.2(eslint-plugin-import@2.27.5)(webpack@5.88.2):
+  /eslint-import-resolver-webpack@0.13.2(eslint-plugin-import@2.27.5)(webpack@5.82.1):
     resolution: {integrity: sha512-XodIPyg1OgE2h5BDErz3WJoK7lawxKTJNhgPNafRST6csC/MZC+L5P6kKqsZGRInpbgc02s/WZMrb4uGJzcuRg==}
     engines: {node: '>= 6'}
     peerDependencies:
@@ -6698,20 +6688,50 @@ packages:
       array-find: 1.0.0
       debug: 3.2.7
       enhanced-resolve: 0.9.1
-      eslint-plugin-import: 2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
+      eslint-plugin-import: 2.27.5(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0)
       find-root: 1.1.0
-      has: 1.0.4
+      has: 1.0.3
       interpret: 1.4.0
       is-core-module: 2.13.0
       is-regex: 1.1.4
       lodash: 4.17.21
-      resolve: 1.22.8
-      semver: 5.7.2
-      webpack: 5.88.2
+      resolve: 1.22.4
+      semver: 5.7.1
+      webpack: 5.82.1
+    transitivePeerDependencies:
+      - supports-color
+
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.9.0)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.6.0)(eslint@8.47.0):
+    resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@typescript-eslint/parser': '*'
+      eslint: '*'
+      eslint-import-resolver-node: '*'
+      eslint-import-resolver-typescript: '*'
+      eslint-import-resolver-webpack: '*'
+    peerDependenciesMeta:
+      '@typescript-eslint/parser':
+        optional: true
+      eslint:
+        optional: true
+      eslint-import-resolver-node:
+        optional: true
+      eslint-import-resolver-typescript:
+        optional: true
+      eslint-import-resolver-webpack:
+        optional: true
+    dependencies:
+      '@typescript-eslint/parser': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
+      debug: 3.2.7
+      eslint: 8.47.0
+      eslint-import-resolver-node: 0.3.7
+      eslint-import-resolver-typescript: 3.6.0(@typescript-eslint/parser@6.9.0)(eslint-plugin-import@2.28.1)(eslint@8.47.0)
     transitivePeerDependencies:
       - supports-color
+    dev: false
 
-  /eslint-module-utils@2.8.0(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0):
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.6.1)(eslint@8.47.0):
     resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -6732,25 +6752,55 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
       debug: 3.2.7
-      eslint: 8.40.0
+      eslint: 8.47.0
       eslint-import-resolver-node: 0.3.7
-      eslint-import-resolver-typescript: 3.5.5(@typescript-eslint/parser@5.59.5)(eslint-plugin-import@2.27.5)(eslint@8.40.0)
-      eslint-import-resolver-webpack: 0.13.2(eslint-plugin-import@2.27.5)(webpack@5.88.2)
+      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@6.9.1)(eslint-plugin-i@2.28.1)(eslint@8.53.0)
     transitivePeerDependencies:
       - supports-color
+    dev: false
 
-  /eslint-plugin-ava@14.0.0(eslint@8.40.0):
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0):
+    resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@typescript-eslint/parser': '*'
+      eslint: '*'
+      eslint-import-resolver-node: '*'
+      eslint-import-resolver-typescript: '*'
+      eslint-import-resolver-webpack: '*'
+    peerDependenciesMeta:
+      '@typescript-eslint/parser':
+        optional: true
+      eslint:
+        optional: true
+      eslint-import-resolver-node:
+        optional: true
+      eslint-import-resolver-typescript:
+        optional: true
+      eslint-import-resolver-webpack:
+        optional: true
+    dependencies:
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      debug: 3.2.7
+      eslint: 8.53.0
+      eslint-import-resolver-node: 0.3.9
+      eslint-import-resolver-typescript: 3.6.1(@typescript-eslint/parser@6.9.1)(eslint-plugin-i@2.28.1)(eslint@8.53.0)
+      eslint-import-resolver-webpack: 0.13.2(eslint-plugin-import@2.27.5)(webpack@5.82.1)
+    transitivePeerDependencies:
+      - supports-color
+
+  /eslint-plugin-ava@14.0.0(eslint@8.53.0):
     resolution: {integrity: sha512-XmKT6hppaipwwnLVwwvQliSU6AF1QMHiNoLD5JQfzhUhf0jY7CO0O624fQrE+Y/fTb9vbW8r77nKf7M/oHulxw==}
     engines: {node: '>=14.17 <15 || >=16.4'}
     peerDependencies:
       eslint: '>=8.26.0'
     dependencies:
       enhance-visitors: 1.0.0
-      eslint: 8.40.0
-      eslint-utils: 3.0.0(eslint@8.40.0)
-      espree: 9.5.2
+      eslint: 8.53.0
+      eslint-utils: 3.0.0(eslint@8.53.0)
+      espree: 9.6.1
       espurify: 2.1.1
       import-modules: 2.1.0
       micro-spelling-correcter: 1.1.1
@@ -6758,28 +6808,78 @@ packages:
       resolve-from: 5.0.0
     dev: true
 
-  /eslint-plugin-es@4.1.0(eslint@8.40.0):
-    resolution: {integrity: sha512-GILhQTnjYE2WorX5Jyi5i4dz5ALWxBIdQECVQavL6s7cI76IZTDWleTHkxz/QT3kvcs2QlGHvKLYsSlPOlPXnQ==}
-    engines: {node: '>=8.10.0'}
+  /eslint-plugin-deprecation@1.6.0(eslint@8.47.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-rld+Vrneh/NXRtDB0vQifOvgUy0HJYoejaxWlVnsk/LK7iij2tCWQIFcCKG4uzQb+Ef86bDke39w1lh4wnon4Q==}
+    deprecated: this package has been deprecated, please use v2.0.0
     peerDependencies:
-      eslint: '>=4.19.1'
+      eslint: ^7.0.0 || ^8.0.0
+      typescript: ^5.2.2 || 5
+    dependencies:
+      '@typescript-eslint/utils': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
+      eslint: 8.47.0
+      tslib: 2.6.2
+      tsutils: 3.21.0(typescript@5.2.2)
+      typescript: 5.2.2
+    transitivePeerDependencies:
+      - supports-color
+    dev: false
+
+  /eslint-plugin-es-x@7.2.0(eslint@8.47.0):
+    resolution: {integrity: sha512-9dvv5CcvNjSJPqnS5uZkqb3xmbeqRLnvXKK7iI5+oK/yTusyc46zbBZKENGsOfojm/mKfszyZb+wNqNPAPeGXA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      eslint: '>=8'
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
+      '@eslint-community/regexpp': 4.6.2
+      eslint: 8.47.0
+    dev: false
+
+  /eslint-plugin-es-x@7.2.0(eslint@8.53.0):
+    resolution: {integrity: sha512-9dvv5CcvNjSJPqnS5uZkqb3xmbeqRLnvXKK7iI5+oK/yTusyc46zbBZKENGsOfojm/mKfszyZb+wNqNPAPeGXA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      eslint: '>=8'
     dependencies:
-      eslint: 8.40.0
-      eslint-utils: 2.1.0
-      regexpp: 3.2.0
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.53.0)
+      '@eslint-community/regexpp': 4.6.2
+      eslint: 8.53.0
+    dev: true
 
-  /eslint-plugin-eslint-comments@3.2.0(eslint@8.40.0):
+  /eslint-plugin-eslint-comments@3.2.0(eslint@8.53.0):
     resolution: {integrity: sha512-0jkOl0hfojIHHmEHgmNdqv4fmh7300NdpA9FFpF7zaoLvB/QeXOGNLIo86oAveJFrfB1p05kC8hpEMHM8DwWVQ==}
     engines: {node: '>=6.5.0'}
     peerDependencies:
       eslint: '>=4.19.1'
     dependencies:
       escape-string-regexp: 1.0.5
-      eslint: 8.40.0
+      eslint: 8.53.0
       ignore: 5.2.4
     dev: true
 
-  /eslint-plugin-import@2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0):
+  /eslint-plugin-i@2.28.1(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint@8.53.0):
+    resolution: {integrity: sha512-a4oVt0j3ixNhGhvV4XF6NS7OWRFK2rrJ0Q5C4S2dSRb8FxZi31J0uUd5WJLL58wnVJ/OiQ1BxiXnFA4dWQO1Cg==}
+    engines: {node: '>=12'}
+    peerDependencies:
+      eslint: ^7.2.0 || ^8
+    dependencies:
+      debug: 3.2.7
+      doctrine: 2.1.0
+      eslint: 8.53.0
+      eslint-import-resolver-node: 0.3.9
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0)
+      get-tsconfig: 4.7.2
+      is-glob: 4.0.3
+      minimatch: 3.1.2
+      resolve: 1.22.4
+      semver: 7.5.4
+    transitivePeerDependencies:
+      - '@typescript-eslint/parser'
+      - eslint-import-resolver-typescript
+      - eslint-import-resolver-webpack
+      - supports-color
+
+  /eslint-plugin-import@2.27.5(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0):
     resolution: {integrity: sha512-LmEt3GVofgiGuiE+ORpnvP+kAm3h6MLZJ4Q5HCyHADofsb4VzXFsRiWj3c0OFiV+3DWFh0qg3v9gcPlfc3zRow==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -6789,27 +6889,97 @@ packages:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      array-includes: 3.1.6
+      array.prototype.flat: 1.3.1
+      array.prototype.flatmap: 1.3.1
+      debug: 3.2.7
+      doctrine: 2.1.0
+      eslint: 8.53.0
+      eslint-import-resolver-node: 0.3.9
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.9)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0)
+      has: 1.0.3
+      is-core-module: 2.13.0
+      is-glob: 4.0.3
+      minimatch: 3.1.2
+      object.values: 1.1.6
+      resolve: 1.22.4
+      semver: 6.3.1
+      tsconfig-paths: 3.14.2
+    transitivePeerDependencies:
+      - eslint-import-resolver-typescript
+      - eslint-import-resolver-webpack
+      - supports-color
+
+  /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.9.0)(eslint-import-resolver-typescript@3.6.0)(eslint@8.47.0):
+    resolution: {integrity: sha512-9I9hFlITvOV55alzoKBI+K9q74kv0iKMeY6av5+umsNwayt59fz692daGyjR+oStBQgx6nwR9rXldDev3Clw+A==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@typescript-eslint/parser': '*'
+      eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8
+    peerDependenciesMeta:
+      '@typescript-eslint/parser':
+        optional: true
+    dependencies:
+      '@typescript-eslint/parser': 6.9.0(eslint@8.47.0)(typescript@5.2.2)
       array-includes: 3.1.6
+      array.prototype.findlastindex: 1.2.2
       array.prototype.flat: 1.3.1
       array.prototype.flatmap: 1.3.1
       debug: 3.2.7
       doctrine: 2.1.0
-      eslint: 8.40.0
+      eslint: 8.47.0
       eslint-import-resolver-node: 0.3.7
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
-      has: 1.0.4
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.0)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.6.0)(eslint@8.47.0)
+      has: 1.0.3
       is-core-module: 2.13.0
       is-glob: 4.0.3
       minimatch: 3.1.2
+      object.fromentries: 2.0.6
+      object.groupby: 1.0.0
       object.values: 1.1.6
-      resolve: 1.22.8
       semver: 6.3.1
       tsconfig-paths: 3.14.2
     transitivePeerDependencies:
       - eslint-import-resolver-typescript
       - eslint-import-resolver-webpack
       - supports-color
+    dev: false
+
+  /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint@8.47.0):
+    resolution: {integrity: sha512-9I9hFlITvOV55alzoKBI+K9q74kv0iKMeY6av5+umsNwayt59fz692daGyjR+oStBQgx6nwR9rXldDev3Clw+A==}
+    engines: {node: '>=4'}
+    peerDependencies:
+      '@typescript-eslint/parser': '*'
+      eslint: ^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8
+    peerDependenciesMeta:
+      '@typescript-eslint/parser':
+        optional: true
+    dependencies:
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
+      array-includes: 3.1.6
+      array.prototype.findlastindex: 1.2.2
+      array.prototype.flat: 1.3.1
+      array.prototype.flatmap: 1.3.1
+      debug: 3.2.7
+      doctrine: 2.1.0
+      eslint: 8.47.0
+      eslint-import-resolver-node: 0.3.7
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-node@0.3.7)(eslint-import-resolver-typescript@3.6.1)(eslint@8.47.0)
+      has: 1.0.3
+      is-core-module: 2.13.0
+      is-glob: 4.0.3
+      minimatch: 3.1.2
+      object.fromentries: 2.0.6
+      object.groupby: 1.0.0
+      object.values: 1.1.6
+      semver: 6.3.1
+      tsconfig-paths: 3.14.2
+    transitivePeerDependencies:
+      - eslint-import-resolver-typescript
+      - eslint-import-resolver-webpack
+      - supports-color
+    dev: false
 
   /eslint-plugin-json@3.1.0:
     resolution: {integrity: sha512-MrlG2ynFEHe7wDGwbUuFPsaT2b1uhuEFhJ+W1f1u+1C2EkXmTYJp4B1aAdQQ8M+CC3t//N/oRKiIVw14L2HR1g==}
@@ -6819,21 +6989,41 @@ packages:
       vscode-json-languageservice: 4.2.1
     dev: false
 
-  /eslint-plugin-n@15.7.0(eslint@8.40.0):
-    resolution: {integrity: sha512-jDex9s7D/Qial8AGVIHq4W7NswpUD5DPDL2RH8Lzd9EloWUuvUkHfv4FRLMipH5q2UtyurorBkPeNi1wVWNh3Q==}
-    engines: {node: '>=12.22.0'}
+  /eslint-plugin-n@16.2.0(eslint@8.47.0):
+    resolution: {integrity: sha512-AQER2jEyQOt1LG6JkGJCCIFotzmlcCZFur2wdKrp1JX2cNotC7Ae0BcD/4lLv3lUAArM9uNS8z/fsvXTd0L71g==}
+    engines: {node: '>=16.0.0'}
+    peerDependencies:
+      eslint: '>=7.0.0'
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
+      builtins: 5.0.1
+      eslint: 8.47.0
+      eslint-plugin-es-x: 7.2.0(eslint@8.47.0)
+      get-tsconfig: 4.7.0
+      ignore: 5.2.4
+      is-core-module: 2.13.0
+      minimatch: 3.1.2
+      resolve: 1.22.4
+      semver: 7.5.4
+    dev: false
+
+  /eslint-plugin-n@16.2.0(eslint@8.53.0):
+    resolution: {integrity: sha512-AQER2jEyQOt1LG6JkGJCCIFotzmlcCZFur2wdKrp1JX2cNotC7Ae0BcD/4lLv3lUAArM9uNS8z/fsvXTd0L71g==}
+    engines: {node: '>=16.0.0'}
     peerDependencies:
       eslint: '>=7.0.0'
     dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.53.0)
       builtins: 5.0.1
-      eslint: 8.40.0
-      eslint-plugin-es: 4.1.0(eslint@8.40.0)
-      eslint-utils: 3.0.0(eslint@8.40.0)
+      eslint: 8.53.0
+      eslint-plugin-es-x: 7.2.0(eslint@8.53.0)
+      get-tsconfig: 4.7.0
       ignore: 5.2.4
       is-core-module: 2.13.0
       minimatch: 3.1.2
-      resolve: 1.22.8
+      resolve: 1.22.4
       semver: 7.5.4
+    dev: true
 
   /eslint-plugin-no-use-extend-native@0.5.0:
     resolution: {integrity: sha512-dBNjs8hor8rJgeXLH4HTut5eD3RGWf9JUsadIfuL7UosVQ/dnvOKwxEcRrXrFxrMZ8llUVWT+hOimxJABsAUzQ==}
@@ -6845,7 +7035,7 @@ packages:
       is-proto-prop: 2.0.0
     dev: true
 
-  /eslint-plugin-prettier@4.2.1(eslint-config-prettier@8.8.0)(eslint@8.40.0)(prettier@2.8.8):
+  /eslint-plugin-prettier@4.2.1(eslint-config-prettier@9.0.0)(eslint@8.47.0)(prettier@3.0.3):
     resolution: {integrity: sha512-f/0rXLXUt0oFYs8ra4w49wYZBG5GKZpAYsJSm6rnYL5uVDjd+zowwMwVZHnAjf4edNrKpCDYfXDgmRE/Ak7QyQ==}
     engines: {node: '>=12.0.0'}
     peerDependencies:
@@ -6856,30 +7046,64 @@ packages:
       eslint-config-prettier:
         optional: true
     dependencies:
-      eslint: 8.40.0
-      eslint-config-prettier: 8.8.0(eslint@8.40.0)
-      prettier: 2.8.8
+      eslint: 8.47.0
+      eslint-config-prettier: 9.0.0(eslint@8.53.0)
+      prettier: 3.0.3
       prettier-linter-helpers: 1.0.0
+    dev: false
 
-  /eslint-plugin-qunit@7.3.4(eslint@8.40.0):
-    resolution: {integrity: sha512-EbDM0zJerH9zVdUswMJpcFF7wrrpvsGuYfNexUpa5hZkkdFhaFcX+yD+RSK4Nrauw4psMGlcqeWUMhaVo+Manw==}
-    engines: {node: 12.x || 14.x || >=16.0.0}
+  /eslint-plugin-prettier@5.0.1(@types/eslint@8.44.6)(eslint-config-prettier@8.8.0)(eslint@8.53.0)(prettier@3.0.3):
+    resolution: {integrity: sha512-m3u5RnR56asrwV/lDC4GHorlW75DsFfmUcjfCYylTUs85dBRnB7VM6xG8eCMJdeDRnppzmxZVf1GEPJvl1JmNg==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    peerDependencies:
+      '@types/eslint': '>=8.0.0'
+      eslint: '>=8.0.0'
+      eslint-config-prettier: '*'
+      prettier: '>=3.0.0'
+    peerDependenciesMeta:
+      '@types/eslint':
+        optional: true
+      eslint-config-prettier:
+        optional: true
     dependencies:
-      eslint-utils: 3.0.0(eslint@8.40.0)
+      '@types/eslint': 8.44.6
+      eslint: 8.53.0
+      eslint-config-prettier: 8.8.0(eslint@8.53.0)
+      prettier: 3.0.3
+      prettier-linter-helpers: 1.0.0
+      synckit: 0.8.5
+    dev: true
+
+  /eslint-plugin-qunit@8.0.1(eslint@8.47.0):
+    resolution: {integrity: sha512-3bFOPryXoQOez95oP/JfWTxHBc/bgDQQZqTuv9uYTwH5sdIvSM2TES1iHDcy/F/LvqiqIpscDAOPAjlqSCnNPg==}
+    engines: {node: ^16.0.0 || ^18.0.0 || >=20.0.0}
+    dependencies:
+      eslint-utils: 3.0.0(eslint@8.47.0)
+      requireindex: 1.2.0
+    transitivePeerDependencies:
+      - eslint
+    dev: false
+
+  /eslint-plugin-qunit@8.0.1(eslint@8.53.0):
+    resolution: {integrity: sha512-3bFOPryXoQOez95oP/JfWTxHBc/bgDQQZqTuv9uYTwH5sdIvSM2TES1iHDcy/F/LvqiqIpscDAOPAjlqSCnNPg==}
+    engines: {node: ^16.0.0 || ^18.0.0 || >=20.0.0}
+    dependencies:
+      eslint-utils: 3.0.0(eslint@8.53.0)
       requireindex: 1.2.0
     transitivePeerDependencies:
       - eslint
+    dev: true
 
-  /eslint-plugin-regexp@1.15.0(eslint@8.40.0):
+  /eslint-plugin-regexp@1.15.0(eslint@8.47.0):
     resolution: {integrity: sha512-YEtQPfdudafU7RBIFci81R/Q1yErm0mVh3BkGnXD2Dk8DLwTFdc2ITYH1wCnHKim2gnHfPFgrkh+b2ozyyU7ag==}
     engines: {node: ^12 || >=14}
     peerDependencies:
       eslint: '>=6.0.0'
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.40.0)
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
       '@eslint-community/regexpp': 4.5.1
       comment-parser: 1.3.1
-      eslint: 8.40.0
+      eslint: 8.47.0
       grapheme-splitter: 1.0.4
       jsdoctypeparser: 9.0.0
       refa: 0.11.0
@@ -6887,24 +7111,33 @@ packages:
       scslre: 0.2.0
     dev: false
 
-  /eslint-plugin-simple-import-sort@10.0.0(eslint@8.40.0):
+  /eslint-plugin-simple-import-sort@10.0.0(eslint@8.47.0):
     resolution: {integrity: sha512-AeTvO9UCMSNzIHRkg8S6c3RPy5YEwKWSQPx3DYghLedo2ZQxowPFLGDN1AZ2evfg6r6mjBSZSLxLFsWSu3acsw==}
     peerDependencies:
       eslint: '>=5.0.0'
     dependencies:
-      eslint: 8.40.0
+      eslint: 8.47.0
+    dev: false
 
-  /eslint-plugin-unicorn@46.0.1(eslint@8.40.0):
-    resolution: {integrity: sha512-setGhMTiLAddg1asdwjZ3hekIN5zLznNa5zll7pBPwFOka6greCKDQydfqy4fqyUhndi74wpDzClSQMEcmOaew==}
-    engines: {node: '>=14.18'}
+  /eslint-plugin-simple-import-sort@10.0.0(eslint@8.53.0):
+    resolution: {integrity: sha512-AeTvO9UCMSNzIHRkg8S6c3RPy5YEwKWSQPx3DYghLedo2ZQxowPFLGDN1AZ2evfg6r6mjBSZSLxLFsWSu3acsw==}
     peerDependencies:
-      eslint: '>=8.28.0'
+      eslint: '>=5.0.0'
     dependencies:
-      '@babel/helper-validator-identifier': 7.22.20
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.40.0)
-      ci-info: 3.9.0
+      eslint: 8.53.0
+    dev: true
+
+  /eslint-plugin-unicorn@48.0.1(eslint@8.53.0):
+    resolution: {integrity: sha512-FW+4r20myG/DqFcCSzoumaddKBicIPeFnTrifon2mWIzlfyvzwyqZjqVP7m4Cqr/ZYisS2aiLghkUWaPg6vtCw==}
+    engines: {node: '>=16'}
+    peerDependencies:
+      eslint: '>=8.44.0'
+    dependencies:
+      '@babel/helper-validator-identifier': 7.22.5
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.53.0)
+      ci-info: 3.8.0
       clean-regexp: 1.0.0
-      eslint: 8.40.0
+      eslint: 8.53.0
       esquery: 1.5.0
       indent-string: 4.0.0
       is-builtin-module: 3.2.1
@@ -6913,25 +7146,55 @@ packages:
       pluralize: 8.0.0
       read-pkg-up: 7.0.1
       regexp-tree: 0.1.27
-      regjsparser: 0.9.1
-      safe-regex: 2.1.1
+      regjsparser: 0.10.0
       semver: 7.5.4
       strip-indent: 3.0.0
     dev: true
 
-  /eslint-plugin-unused-imports@2.0.0(@typescript-eslint/eslint-plugin@5.59.5)(eslint@8.40.0):
-    resolution: {integrity: sha512-3APeS/tQlTrFa167ThtP0Zm0vctjr4M44HMpeg1P4bK6wItarumq0Ma82xorMKdFsWpphQBlRPzw/pxiVELX1A==}
+  /eslint-plugin-unused-imports@3.0.0(@typescript-eslint/eslint-plugin@6.9.0)(eslint@8.47.0):
+    resolution: {integrity: sha512-sduiswLJfZHeeBJ+MQaG+xYzSWdRXoSw61DpU13mzWumCkR0ufD0HmO4kdNokjrkluMHpj/7PJeN35pgbhW3kw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      '@typescript-eslint/eslint-plugin': ^6.0.0
+      eslint: ^8.0.0
+    peerDependenciesMeta:
+      '@typescript-eslint/eslint-plugin':
+        optional: true
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 6.9.0(@typescript-eslint/parser@6.9.0)(eslint@8.47.0)(typescript@5.2.2)
+      eslint: 8.47.0
+      eslint-rule-composer: 0.3.0
+    dev: false
+
+  /eslint-plugin-unused-imports@3.0.0(@typescript-eslint/eslint-plugin@6.9.1)(eslint@8.47.0):
+    resolution: {integrity: sha512-sduiswLJfZHeeBJ+MQaG+xYzSWdRXoSw61DpU13mzWumCkR0ufD0HmO4kdNokjrkluMHpj/7PJeN35pgbhW3kw==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
-      '@typescript-eslint/eslint-plugin': ^5.0.0
+      '@typescript-eslint/eslint-plugin': ^6.0.0
       eslint: ^8.0.0
     peerDependenciesMeta:
       '@typescript-eslint/eslint-plugin':
         optional: true
     dependencies:
-      '@typescript-eslint/eslint-plugin': 5.59.5(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4)
-      eslint: 8.40.0
+      '@typescript-eslint/eslint-plugin': 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2)
+      eslint: 8.47.0
       eslint-rule-composer: 0.3.0
+    dev: false
+
+  /eslint-plugin-unused-imports@3.0.0(@typescript-eslint/eslint-plugin@6.9.1)(eslint@8.53.0):
+    resolution: {integrity: sha512-sduiswLJfZHeeBJ+MQaG+xYzSWdRXoSw61DpU13mzWumCkR0ufD0HmO4kdNokjrkluMHpj/7PJeN35pgbhW3kw==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    peerDependencies:
+      '@typescript-eslint/eslint-plugin': ^6.0.0
+      eslint: ^8.0.0
+    peerDependenciesMeta:
+      '@typescript-eslint/eslint-plugin':
+        optional: true
+    dependencies:
+      '@typescript-eslint/eslint-plugin': 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2)
+      eslint: 8.53.0
+      eslint-rule-composer: 0.3.0
+    dev: true
 
   /eslint-rule-composer@0.3.0:
     resolution: {integrity: sha512-bt+Sh8CtDmn2OajxvNO+BX7Wn4CIWMpTRm3MaiKPCQcnnlm0CS2mhui6QaoeQugs+3Kj2ESKEEGJUdVafwhiCg==}
@@ -6948,61 +7211,108 @@ packages:
       esrecurse: 4.3.0
       estraverse: 4.3.0
 
-  /eslint-scope@7.2.0:
-    resolution: {integrity: sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw==}
+  /eslint-scope@7.2.2:
+    resolution: {integrity: sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       esrecurse: 4.3.0
       estraverse: 5.3.0
 
-  /eslint-utils@2.1.0:
-    resolution: {integrity: sha512-w94dQYoauyvlDc43XnGB8lU3Zt713vNChgt4EWwhXAP2XkBvndfxF0AgIqKOOasjPIPzj9JqgwkwbCYD0/V3Zg==}
-    engines: {node: '>=6'}
+  /eslint-utils@3.0.0(eslint@8.47.0):
+    resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==}
+    engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0}
+    peerDependencies:
+      eslint: '>=5'
     dependencies:
-      eslint-visitor-keys: 1.3.0
+      eslint: 8.47.0
+      eslint-visitor-keys: 2.1.0
+    dev: false
 
-  /eslint-utils@3.0.0(eslint@8.40.0):
+  /eslint-utils@3.0.0(eslint@8.53.0):
     resolution: {integrity: sha512-uuQC43IGctw68pJA1RgbQS8/NP7rch6Cwd4j3ZBtgo4/8Flj4eGE7ZYSZRN3iq5pVUv6GPdW5Z1RFleo84uLDA==}
     engines: {node: ^10.0.0 || ^12.0.0 || >= 14.0.0}
     peerDependencies:
       eslint: '>=5'
     dependencies:
-      eslint: 8.40.0
+      eslint: 8.53.0
       eslint-visitor-keys: 2.1.0
-
-  /eslint-visitor-keys@1.3.0:
-    resolution: {integrity: sha512-6J72N8UNa462wa/KFODt/PJ3IU60SDpC3QXC1Hjc1BXXpfL2C9R5+AU7jhe0F6GREqVMh4Juu+NY7xn+6dipUQ==}
-    engines: {node: '>=4'}
+    dev: true
 
   /eslint-visitor-keys@2.1.0:
     resolution: {integrity: sha512-0rSmRBzXgDzIsD6mGdJgevzgezI534Cer5L/vyMX0kHzT/jiB43jRhd9YUlMGYLQy2zprNmoT8qasCGtY+QaKw==}
     engines: {node: '>=10'}
 
-  /eslint-visitor-keys@3.4.1:
-    resolution: {integrity: sha512-pZnmmLwYzf+kWaM/Qgrvpen51upAktaaiI01nsJD/Yr3lMOdNtq0cxkrrg16w64VtisN6okbs7Q8AfGqj4c9fA==}
+  /eslint-visitor-keys@3.4.3:
+    resolution: {integrity: sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag==}
+    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+
+  /eslint@8.47.0:
+    resolution: {integrity: sha512-spUQWrdPt+pRVP1TTJLmfRNJJHHZryFmptzcafwSvHsceV81djHOdnEeDmkdotZyLNjDhrOasNK8nikkoG1O8Q==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+    hasBin: true
+    dependencies:
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.47.0)
+      '@eslint-community/regexpp': 4.6.2
+      '@eslint/eslintrc': 2.1.2
+      '@eslint/js': 8.47.0
+      '@humanwhocodes/config-array': 0.11.10
+      '@humanwhocodes/module-importer': 1.0.1
+      '@nodelib/fs.walk': 1.2.8
+      ajv: 6.12.6
+      chalk: 4.1.2
+      cross-spawn: 7.0.3
+      debug: 4.3.4(supports-color@8.1.1)
+      doctrine: 3.0.0
+      escape-string-regexp: 4.0.0
+      eslint-scope: 7.2.2
+      eslint-visitor-keys: 3.4.3
+      espree: 9.6.1
+      esquery: 1.5.0
+      esutils: 2.0.3
+      fast-deep-equal: 3.1.3
+      file-entry-cache: 6.0.1
+      find-up: 5.0.0
+      glob-parent: 6.0.2
+      globals: 13.20.0
+      graphemer: 1.4.0
+      ignore: 5.2.4
+      imurmurhash: 0.1.4
+      is-glob: 4.0.3
+      is-path-inside: 3.0.3
+      js-yaml: 4.1.0
+      json-stable-stringify-without-jsonify: 1.0.1
+      levn: 0.4.1
+      lodash.merge: 4.6.2
+      minimatch: 3.1.2
+      natural-compare: 1.4.0
+      optionator: 0.9.3
+      strip-ansi: 6.0.1
+      text-table: 0.2.0
+    transitivePeerDependencies:
+      - supports-color
 
-  /eslint@8.40.0:
-    resolution: {integrity: sha512-bvR+TsP9EHL3TqNtj9sCNJVAFK3fBN8Q7g5waghxyRsPLIMwL73XSKnZFK0hk/O2ANC+iAoq6PWMQ+IfBAJIiQ==}
+  /eslint@8.53.0:
+    resolution: {integrity: sha512-N4VuiPjXDUa4xVeV/GC/RV3hQW9Nw+Y463lkWaKKXKYMvmRiRDAtfpuPFLN+E1/6ZhyR8J2ig+eVREnYgUsiag==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     hasBin: true
     dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.40.0)
-      '@eslint-community/regexpp': 4.5.1
-      '@eslint/eslintrc': 2.0.3
-      '@eslint/js': 8.40.0
-      '@humanwhocodes/config-array': 0.11.8
+      '@eslint-community/eslint-utils': 4.4.0(eslint@8.53.0)
+      '@eslint-community/regexpp': 4.6.2
+      '@eslint/eslintrc': 2.1.3
+      '@eslint/js': 8.53.0
+      '@humanwhocodes/config-array': 0.11.13
       '@humanwhocodes/module-importer': 1.0.1
       '@nodelib/fs.walk': 1.2.8
+      '@ungap/structured-clone': 1.2.0
       ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.3
       debug: 4.3.4(supports-color@8.1.1)
       doctrine: 3.0.0
       escape-string-regexp: 4.0.0
-      eslint-scope: 7.2.0
-      eslint-visitor-keys: 3.4.1
-      espree: 9.5.2
+      eslint-scope: 7.2.2
+      eslint-visitor-keys: 3.4.3
+      espree: 9.6.1
       esquery: 1.5.0
       esutils: 2.0.3
       fast-deep-equal: 3.1.3
@@ -7010,22 +7320,19 @@ packages:
       find-up: 5.0.0
       glob-parent: 6.0.2
       globals: 13.20.0
-      grapheme-splitter: 1.0.4
+      graphemer: 1.4.0
       ignore: 5.2.4
-      import-fresh: 3.3.0
       imurmurhash: 0.1.4
       is-glob: 4.0.3
       is-path-inside: 3.0.3
-      js-sdsl: 4.4.0
       js-yaml: 4.1.0
       json-stable-stringify-without-jsonify: 1.0.1
       levn: 0.4.1
       lodash.merge: 4.6.2
       minimatch: 3.1.2
       natural-compare: 1.4.0
-      optionator: 0.9.1
+      optionator: 0.9.3
       strip-ansi: 6.0.1
-      strip-json-comments: 3.1.1
       text-table: 0.2.0
     transitivePeerDependencies:
       - supports-color
@@ -7037,31 +7344,19 @@ packages:
       url-or-path: 2.1.0
     dev: true
 
-  /esm@3.2.25:
-    resolution: {integrity: sha512-U1suiZ2oDVWv4zPO56S0NcR5QriEahGtdN2OR6FiOG4WJvcjBVFB0qI4+eKoWFH483PKGuLuu6V8Z4T5g63UVA==}
-    engines: {node: '>=6'}
-    dev: true
-
   /esno@0.16.3:
     resolution: {integrity: sha512-6slSBEV1lMKcX13DBifvnDFpNno5WXhw4j/ff7RI0y51BZiDqEe5dNhhjhIQ3iCOQuzsm2MbVzmwqbN78BBhPg==}
-    hasBin: true
     dependencies:
       tsx: 3.12.7
     dev: true
 
-  /espree@9.5.2:
-    resolution: {integrity: sha512-7OASN1Wma5fum5SrNhFMAMJxOUAbhyfQ8dQ//PJaJbNw0URTPWqIghHWt1MmAANKhHZIYOHruW4Kw4ruUWOdGw==}
+  /espree@9.6.1:
+    resolution: {integrity: sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     dependencies:
       acorn: 8.10.0
       acorn-jsx: 5.3.2(acorn@8.10.0)
-      eslint-visitor-keys: 3.4.1
-
-  /esprima@3.0.0:
-    resolution: {integrity: sha512-xoBq/MIShSydNZOkjkoCEjqod963yHNXTLC40ypBhop6yPqflPz/vTinmCfSrGcywVLnSftRf6a0kJLdFdzemw==}
-    engines: {node: '>=0.10.0'}
-    hasBin: true
-    dev: true
+      eslint-visitor-keys: 3.4.3
 
   /esprima@4.0.1:
     resolution: {integrity: sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==}
@@ -7104,6 +7399,17 @@ packages:
     resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
     engines: {node: '>=0.10.0'}
 
+  /esyes@1.0.1:
+    resolution: {integrity: sha512-Rg7wkxjXrbCG6EbxzgsGeaqCoZK7AxsMl9KhazyQnws5R9iO1jnvbXmpKk0jd7tUsYqOq+sNChigUU2WnfHqQA==}
+    hasBin: true
+    dependencies:
+      convert-source-map: 2.0.0
+      execa: 8.0.1
+      magic-string: 0.30.5
+      source-map: 0.7.4
+      tsx: 3.14.0
+    dev: true
+
   /etag@1.8.1:
     resolution: {integrity: sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==}
     engines: {node: '>= 0.6'}
@@ -7132,10 +7438,6 @@ packages:
     resolution: {integrity: sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==}
     engines: {node: '>=0.8.x'}
 
-  /exec-sh@0.3.6:
-    resolution: {integrity: sha512-nQn+hI3yp+oD0huYhKwvYI32+JFeq+XkNcD1GAo3Y/MjxsfVGmrrzrnzjWiNY6f+pUCP440fThsFh5gZrRAU/w==}
-    dev: true
-
   /execa@1.0.0:
     resolution: {integrity: sha512-adbxcyWV46qiHyvSp50TKt05tB4tK3HcmF7/nxfAdhnox83seTDbwnaqKO4sXRy7roHAIFqJP/Rw/AuEbX61LA==}
     engines: {node: '>=6'}
@@ -7149,21 +7451,6 @@ packages:
       strip-eof: 1.0.0
     dev: true
 
-  /execa@4.1.0:
-    resolution: {integrity: sha512-j5W0//W7f8UxAn8hXVnwG8tLwdiUy4FJLcSupCg6maBYZDpyBvTApK7KyuI4bKj8KOh1r2YH+6ucuYtJv1bTZA==}
-    engines: {node: '>=10'}
-    dependencies:
-      cross-spawn: 7.0.3
-      get-stream: 5.2.0
-      human-signals: 1.1.1
-      is-stream: 2.0.1
-      merge-stream: 2.0.0
-      npm-run-path: 4.0.1
-      onetime: 5.1.2
-      signal-exit: 3.0.7
-      strip-final-newline: 2.0.0
-    dev: true
-
   /execa@5.1.1:
     resolution: {integrity: sha512-8uSpZZocAZRBAPIEINJj3Lo9HyGitllczc27Eh5YYojjMFMn8yHMDMaUHE2Jqfq05D/wucwI4JGURyXt1vchyg==}
     engines: {node: '>=10'}
@@ -7177,6 +7464,7 @@ packages:
       onetime: 5.1.2
       signal-exit: 3.0.7
       strip-final-newline: 2.0.0
+    dev: true
 
   /execa@7.1.1:
     resolution: {integrity: sha512-wH0eMf/UXckdUYnO21+HDztteVv05rq2GXksxT4fCGeHkBhw1DROXh40wcjMcRqDOWE7iPJ4n3M7e2+YFP+76Q==}
@@ -7191,6 +7479,7 @@ packages:
       onetime: 6.0.0
       signal-exit: 3.0.7
       strip-final-newline: 3.0.0
+    dev: false
 
   /execa@7.2.0:
     resolution: {integrity: sha512-UduyVP7TLB5IcAQl+OzLyLcS/l32W/GLg+AhHJ+ow40FOk2U3SAllPwR44v4vmdFwIWqpdwxxpQbF1n5ta9seA==}
@@ -7205,32 +7494,21 @@ packages:
       onetime: 6.0.0
       signal-exit: 3.0.7
       strip-final-newline: 3.0.0
-
-  /exit@0.1.2:
-    resolution: {integrity: sha512-Zk/eNKV2zbjpKzrsQ+n1G6poVbErQxJ0LBOJXaKZ1EViLzH+hrLu9cdXI4zw9dBQJslwBEpbQ2P1oS7nDxs6jQ==}
-    engines: {node: '>= 0.8.0'}
-    dev: true
-
-  /expand-brackets@2.1.4:
-    resolution: {integrity: sha512-w/ozOKR9Obk3qoWeY/WDi6MFta9AoMR+zud60mdnbniMcBxRuFJyDt2LdX/14A1UABeqk+Uk+LDfUpvoGKppZA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      debug: 2.6.9
-      define-property: 0.2.5
-      extend-shallow: 2.0.1
-      posix-character-classes: 0.1.1
-      regex-not: 1.0.2
-      snapdragon: 0.8.2
-      to-regex: 3.0.2
-    transitivePeerDependencies:
-      - supports-color
     dev: true
 
-  /expand-tilde@2.0.2:
-    resolution: {integrity: sha512-A5EmesHW6rfnZ9ysHQjPdJRni0SRar0tjtG5MNtm9n5TUvsYU8oozprtRD4AqHxcZWWlVuAmQo2nWKfN9oyjTw==}
-    engines: {node: '>=0.10.0'}
+  /execa@8.0.1:
+    resolution: {integrity: sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==}
+    engines: {node: '>=16.17'}
     dependencies:
-      homedir-polyfill: 1.0.3
+      cross-spawn: 7.0.3
+      get-stream: 8.0.1
+      human-signals: 5.0.0
+      is-stream: 3.0.0
+      merge-stream: 2.0.0
+      npm-run-path: 5.1.0
+      onetime: 6.0.0
+      signal-exit: 4.1.0
+      strip-final-newline: 3.0.0
     dev: true
 
   /express@4.18.2:
@@ -7272,21 +7550,6 @@ packages:
       - supports-color
     dev: true
 
-  /extend-shallow@2.0.1:
-    resolution: {integrity: sha512-zCnTtlxNoAiDc3gqY2aYAWFx7XWWiasuF2K8Me5WbN8otHKTUKBwjPtNpRs/rbUZm7KxWAaNj7P1a/p52GbVug==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-extendable: 0.1.1
-    dev: true
-
-  /extend-shallow@3.0.2:
-    resolution: {integrity: sha512-BwY5b5Ql4+qZoefgMj2NUmx+tehVTH/Kf4k1ZEtOHNFcm2wSxMRo992l6X3TIgni2eZVTZ85xMOjF31fwZAj6Q==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      assign-symbols: 1.0.0
-      is-extendable: 1.0.1
-    dev: true
-
   /external-editor@3.1.0:
     resolution: {integrity: sha512-hMQ4CX1p1izmuLYyZqLMO/qGNw10wSv9QDCPfzXfyFrOaCSSoRfqE1Kf1s5an66J5JZC62NewG+mK49jOCtQew==}
     engines: {node: '>=4'}
@@ -7296,27 +7559,6 @@ packages:
       tmp: 0.0.33
     dev: true
 
-  /extglob@2.0.4:
-    resolution: {integrity: sha512-Nmb6QXkELsuBr24CJSkilo6UHHgbekK5UiZgfE6UHD3Eb27YC6oD+bhcT+tJ6cl8dmsgdQxnWlcry8ksBIBLpw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      array-unique: 0.3.2
-      define-property: 1.0.0
-      expand-brackets: 2.1.4
-      extend-shallow: 2.0.1
-      fragment-cache: 0.2.1
-      regex-not: 1.0.2
-      snapdragon: 0.8.2
-      to-regex: 3.0.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /extract-stack@2.0.0:
-    resolution: {integrity: sha512-AEo4zm+TenK7zQorGK1f9mJ8L14hnTDi2ZQPR+Mub1NX8zimka1mXpV5LpH8x9HoUmFSHZCfLHqWvp0Y4FxxzQ==}
-    engines: {node: '>=8'}
-    dev: true
-
   /extract-zip@2.0.1:
     resolution: {integrity: sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==}
     engines: {node: '>= 10.17.0'}
@@ -7326,7 +7568,7 @@ packages:
       get-stream: 5.2.0
       yauzl: 2.10.0
     optionalDependencies:
-      '@types/yauzl': 2.10.1
+      '@types/yauzl': 2.10.0
     transitivePeerDependencies:
       - supports-color
 
@@ -7336,15 +7578,8 @@ packages:
   /fast-diff@1.2.0:
     resolution: {integrity: sha512-xJuoT5+L99XlZ8twedaRf6Ax2TgQVxvgZOYoPKqZufmJib0tL2tegPBOZb1pVNgIhlqDlA0eO0c3wBvQcmzx4w==}
 
-  /fast-glob@3.2.12:
-    resolution: {integrity: sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==}
-    engines: {node: '>=8.6.0'}
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      '@nodelib/fs.walk': 1.2.8
-      glob-parent: 5.1.2
-      merge2: 1.4.1
-      micromatch: 4.0.5
+  /fast-fifo@1.3.2:
+    resolution: {integrity: sha512-/d9sfos4yxzpwkDkuN7k2SqFKtYNmCTzgfEpz82x34IM9/zc8KGxQoXg1liNC/izpRM/MBdt44Nmx41ZWqk+FQ==}
     dev: true
 
   /fast-glob@3.3.1:
@@ -7363,46 +7598,11 @@ packages:
   /fast-levenshtein@2.0.6:
     resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
 
-  /fast-ordered-set@1.0.3:
-    resolution: {integrity: sha512-MxBW4URybFszOx1YlACEoK52P6lE3xiFcPaGCUZ7QQOZ6uJXKo++Se8wa31SjcZ+NC/fdAWX7UtKEfaGgHS2Vg==}
-    dependencies:
-      blank-object: 1.0.2
-    dev: true
-
-  /fast-sourcemap-concat@2.1.0:
-    resolution: {integrity: sha512-L9uADEnnHOeF4U5Kc3gzEs3oFpNCFkiTJXvT+nKmR0zcFqHZJJbszWT7dv4t9558FJRGpCj8UxUpTgz2zwiIZA==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      chalk: 2.4.2
-      fs-extra: 5.0.0
-      heimdalljs-logger: 0.1.10
-      memory-streams: 0.1.3
-      mkdirp: 0.5.6
-      source-map: 0.4.4
-      source-map-url: 0.3.0
-      sourcemap-validator: 1.1.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /fastq@1.15.0:
     resolution: {integrity: sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==}
     dependencies:
       reusify: 1.0.4
 
-  /faye-websocket@0.11.4:
-    resolution: {integrity: sha512-CzbClwlXAuiRQAlUyfqPgvPoNKTckTPGfwZV4ZdAhVcP2lh9KUxJg2b5GkE7XbjKQ3YJnQ9z6D9ntLAlB+tP8g==}
-    engines: {node: '>=0.8.0'}
-    dependencies:
-      websocket-driver: 0.7.4
-    dev: true
-
-  /fb-watchman@2.0.2:
-    resolution: {integrity: sha512-p5161BqbuCaSnB8jIbzQHOlpgsPmK5rJVDfDKO91Axs5NC1uu3HRQm6wt9cd9/+GtQQIO53JdGXXoyDpTAsgYA==}
-    dependencies:
-      bser: 2.1.1
-    dev: true
-
   /fd-slicer@1.1.0:
     resolution: {integrity: sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==}
     dependencies:
@@ -7416,20 +7616,6 @@ packages:
       web-streams-polyfill: 3.2.1
     dev: true
 
-  /figures@2.0.0:
-    resolution: {integrity: sha512-Oa2M9atig69ZkfwiApY8F2Yy+tzMbazyvqv21R0NsSC8floSOC09BbT1ITWAdoMGQvJ/aZnR1KMwdx9tvHnTNA==}
-    engines: {node: '>=4'}
-    dependencies:
-      escape-string-regexp: 1.0.5
-    dev: true
-
-  /figures@3.2.0:
-    resolution: {integrity: sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==}
-    engines: {node: '>=8'}
-    dependencies:
-      escape-string-regexp: 1.0.5
-    dev: true
-
   /figures@5.0.0:
     resolution: {integrity: sha512-ej8ksPF4x6e5wvK9yevct0UCXh8TTFlWGVLlgjZuoBH1HwjIfKE/IdL5mq89sFA7zELi1VhKpmtDnrs7zWyeyg==}
     engines: {node: '>=14'}
@@ -7444,42 +7630,12 @@ packages:
     dependencies:
       flat-cache: 3.0.4
 
-  /filesize@10.0.7:
-    resolution: {integrity: sha512-iMRG7Qo9nayLoU3PNCiLizYtsy4W1ClrapeCwEgtiQelOAOuRJiw4QaLI+sSr8xr901dgHv+EYP2bCusGZgoiA==}
-    engines: {node: '>= 10.4.0'}
-    dev: true
-
-  /fill-range@4.0.0:
-    resolution: {integrity: sha512-VcpLTWqWDiTerugjj8e3+esbg+skS3M9e54UuR3iCeIDMXCLTsAH8hTSzDQU/X6/6t3eYkOKoZSef2PlU6U1XQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      extend-shallow: 2.0.1
-      is-number: 3.0.0
-      repeat-string: 1.6.1
-      to-regex-range: 2.1.1
-    dev: true
-
   /fill-range@7.0.1:
     resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==}
     engines: {node: '>=8'}
     dependencies:
       to-regex-range: 5.0.1
 
-  /finalhandler@1.1.2:
-    resolution: {integrity: sha512-aAWcW57uxVNrQZqFXjITpW3sIUQmHGG3qSb9mUah9MgMC4NeWhNOlNjXEYq3HjRAvL6arUviZGGJsBg6z0zsWA==}
-    engines: {node: '>= 0.8'}
-    dependencies:
-      debug: 2.6.9
-      encodeurl: 1.0.2
-      escape-html: 1.0.3
-      on-finished: 2.3.0
-      parseurl: 1.3.3
-      statuses: 1.5.0
-      unpipe: 1.0.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /finalhandler@1.2.0:
     resolution: {integrity: sha512-5uXcUVftlQMFnWC9qu/svkWv3GTd2PfUhK/3PLkYNAe7FbqJMt3515HaxE6eRL74GdsriiwujiawdaB1BpEISg==}
     engines: {node: '>= 0.8'}
@@ -7495,14 +7651,6 @@ packages:
       - supports-color
     dev: true
 
-  /find-babel-config@1.2.0:
-    resolution: {integrity: sha512-jB2CHJeqy6a820ssiqwrKMeyC6nNdmrcgkKWJWmpoxpE8RKciYJXCcXRq1h2AzCo5I5BJeN2tkGEO3hLTuePRA==}
-    engines: {node: '>=4.0.0'}
-    dependencies:
-      json5: 0.5.1
-      path-exists: 3.0.0
-    dev: true
-
   /find-cache-dir@4.0.0:
     resolution: {integrity: sha512-9ZonPT4ZAK4a+1pUPVPZJapbi7O5qbbJPdYw/NOQWZZbVLdDTYM3A4R9z/DpAM08IDaFGsvPgiGZ82WEwUDWjg==}
     engines: {node: '>=14.16'}
@@ -7511,10 +7659,6 @@ packages:
       pkg-dir: 7.0.0
     dev: true
 
-  /find-index@1.1.1:
-    resolution: {integrity: sha512-XYKutXMrIK99YMUPf91KX5QVJoG31/OsgftD6YoTPAObfQIxM4ziA9f0J1AsqKhJmo+IeaIPP0CFopTD4bdUBw==}
-    dev: true
-
   /find-root@1.1.0:
     resolution: {integrity: sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==}
 
@@ -7548,22 +7692,6 @@ packages:
       path-exists: 5.0.0
     dev: true
 
-  /find-yarn-workspace-root@2.0.0:
-    resolution: {integrity: sha512-1IMnbjt4KzsQfnhnzNd8wUEgXZ44IzZaZmnLYx7D5FZlaHt2gW20Cri8Q+E/t5tIj4+epTBub+2Zxu/vNILzqQ==}
-    dependencies:
-      micromatch: 4.0.5
-    dev: true
-
-  /findup-sync@4.0.0:
-    resolution: {integrity: sha512-6jvvn/12IC4quLBL1KNokxC7wWTvYncaVUYSoxWw7YykPLuRrnv4qdHcSOywOI5RpkOVGeQRtWM8/q+G6W6qfQ==}
-    engines: {node: '>= 8'}
-    dependencies:
-      detect-file: 1.0.0
-      is-glob: 4.0.3
-      micromatch: 4.0.5
-      resolve-dir: 1.0.1
-    dev: true
-
   /fireworm@0.7.2:
     resolution: {integrity: sha512-GjebTzq+NKKhfmDxjKq3RXwQcN9xRmZWhnnuC9L+/x5wBQtR0aaQM50HsjrzJ2wc28v1vSdfOpELok0TKR4ddg==}
     dependencies:
@@ -7574,27 +7702,6 @@ packages:
       minimatch: 3.1.2
     dev: true
 
-  /fixturify-project@2.1.1:
-    resolution: {integrity: sha512-sP0gGMTr4iQ8Kdq5Ez0CVJOZOGWqzP5dv/veOTdFNywioKjkNWCHBi1q65DMpcNGUGeoOUWehyji274Q2wRgxA==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      fixturify: 2.1.1
-      tmp: 0.0.33
-      type-fest: 0.11.0
-    dev: true
-
-  /fixturify@2.1.1:
-    resolution: {integrity: sha512-SRgwIMXlxkb6AUgaVjIX+jCEqdhyXu9hah7mcK+lWynjKtX73Ux1TDv71B7XyaQ+LJxkYRHl5yCL8IycAvQRUw==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      '@types/fs-extra': 8.1.2
-      '@types/minimatch': 3.0.5
-      '@types/rimraf': 2.0.5
-      fs-extra: 8.1.0
-      matcher-collection: 2.0.1
-      walk-sync: 2.2.0
-    dev: true
-
   /flat-cache@3.0.4:
     resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==}
     engines: {node: ^10.12.0 || >=12.0.0}
@@ -7604,7 +7711,6 @@ packages:
 
   /flat@5.0.2:
     resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==}
-    hasBin: true
     dev: true
 
   /flatted@3.2.7:
@@ -7625,11 +7731,6 @@ packages:
     dependencies:
       is-callable: 1.2.7
 
-  /for-in@1.0.2:
-    resolution: {integrity: sha512-7EwmXrOjyL+ChxMhmG5lnW9MPt1aIeZEwKhQzoBUdTV0N3zuwWDZYVJatDvZ2OyzPUvdIAZDsCetk3coyMfcnQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /foreground-child@3.1.1:
     resolution: {integrity: sha512-TMKDUnIte6bfb5nWv7V/caI169OHgvwjb7V4WkeUvbQQdjr5rWKqHFiKWb/fcOwB+CzBT+qbWjvj+DVwRskpIg==}
     engines: {node: '>=14'}
@@ -7654,13 +7755,6 @@ packages:
     engines: {node: '>= 0.6'}
     dev: true
 
-  /fragment-cache@0.2.1:
-    resolution: {integrity: sha512-GMBAbW9antB8iZRHLoGw0b3HANt57diZYFO/HL1JGIC1MjKrdmhxvrJbupnVvpys0zsz7yBApXdQyfepKly2kA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      map-cache: 0.2.2
-    dev: true
-
   /fresh@0.5.2:
     resolution: {integrity: sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==}
     engines: {node: '>= 0.6'}
@@ -7672,15 +7766,7 @@ packages:
 
   /fs-constants@1.0.0:
     resolution: {integrity: sha512-y6OAwoSIf7FyjMIv94u+b5rdheZEjzR63GTyZJm5qh4Bi+2YgwLCcI/fPFZkL5PSixOt6ZNKm+w+Hfp/Bciwow==}
-
-  /fs-extra@0.24.0:
-    resolution: {integrity: sha512-w1RvhdLZdU9V3vQdL+RooGlo6b9R9WVoBanOfoJvosWlqSKvrjFlci2oVhwvLwZXBtM7khyPvZ8r3fwsim3o0A==}
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 2.4.0
-      path-is-absolute: 1.0.1
-      rimraf: 2.7.1
-    dev: true
+    dev: false
 
   /fs-extra@11.1.1:
     resolution: {integrity: sha512-MGIE4HOvQCeUCzmlHs0vXpih4ysz4wg9qiSAu6cd42lVwPbTM1TjV7RusoyQqMmk/95gdQZX72u+YW+c3eEpFQ==}
@@ -7689,21 +7775,6 @@ packages:
       graceful-fs: 4.2.11
       jsonfile: 6.1.0
       universalify: 2.0.0
-
-  /fs-extra@4.0.3:
-    resolution: {integrity: sha512-q6rbdDd1o2mAnQreO7YADIxf/Whx4AHBiRf6d+/cVT8h44ss+lHgxf1FemcqDnQt9X3ct4McHr+JMGlYSsK7Cg==}
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 4.0.0
-      universalify: 0.1.2
-    dev: true
-
-  /fs-extra@5.0.0:
-    resolution: {integrity: sha512-66Pm4RYbjzdyeuqudYqhFiNBbCIuI9kgRqLPSHIlXHidW8NIQtVdkM1yeZ4lXwuhbTETv3EUGMNHAAw6hiundQ==}
-    dependencies:
-      graceful-fs: 4.2.11
-      jsonfile: 4.0.0
-      universalify: 0.1.2
     dev: true
 
   /fs-extra@8.1.0:
@@ -7723,19 +7794,6 @@ packages:
       graceful-fs: 4.2.11
       jsonfile: 6.1.0
       universalify: 1.0.0
-    dev: true
-
-  /fs-merger@3.2.1:
-    resolution: {integrity: sha512-AN6sX12liy0JE7C2evclwoo0aCG3PFulLjrTLsJpWh/2mM+DinhpSGqYLbHBBbIW1PLRNcFhJG8Axtz8mQW3ug==}
-    dependencies:
-      broccoli-node-api: 1.7.0
-      broccoli-node-info: 2.2.0
-      fs-extra: 8.1.0
-      fs-tree-diff: 2.0.1
-      walk-sync: 2.2.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
 
   /fs-minipass@2.1.0:
     resolution: {integrity: sha512-V/JgOLFCS+R6Vcq0slCuaeWEdNC3ouDlJMNIsacH2VtALiu9mV4LPrHc5cDl8k5aw6J8jwgWWpiTo5RYhmIzvg==}
@@ -7744,43 +7802,6 @@ packages:
       minipass: 3.3.6
     dev: true
 
-  /fs-tree-diff@0.5.9:
-    resolution: {integrity: sha512-872G8ax0kHh01m9n/2KDzgYwouKza0Ad9iFltBpNykvROvf2AGtoOzPJgGx125aolGPER3JuC7uZFrQ7bG1AZw==}
-    dependencies:
-      heimdalljs-logger: 0.1.10
-      object-assign: 4.1.1
-      path-posix: 1.0.0
-      symlink-or-copy: 1.3.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /fs-tree-diff@2.0.1:
-    resolution: {integrity: sha512-x+CfAZ/lJHQqwlD64pYM5QxWjzWhSjroaVsr8PW831zOApL55qPibed0c+xebaLWVr2BnHFoHdrwOv8pzt8R5A==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dependencies:
-      '@types/symlink-or-copy': 1.2.0
-      heimdalljs-logger: 0.1.10
-      object-assign: 4.1.1
-      path-posix: 1.0.0
-      symlink-or-copy: 1.3.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /fs-updater@1.0.4:
-    resolution: {integrity: sha512-0pJX4mJF/qLsNEwTct8CdnnRdagfb+LmjRPJ8sO+nCnAZLW0cTmz4rTgU25n+RvTuWSITiLKrGVJceJPBIPlKg==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      can-symlink: 1.0.0
-      clean-up-path: 1.0.0
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      rimraf: 2.7.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /fs.realpath@1.0.0:
     resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
 
@@ -7791,16 +7812,29 @@ packages:
     requiresBuild: true
     optional: true
 
+  /function-bind@1.1.1:
+    resolution: {integrity: sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==}
+
   /function-bind@1.1.2:
     resolution: {integrity: sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==}
 
+  /function.prototype.name@1.1.5:
+    resolution: {integrity: sha512-uN7m/BzVKQnCUF/iW8jYea67v++2u7m5UgENbHRtdDVclOUP+FMPlCNdmk0h/ysGyo2tavMJEDqJAkJdRa1vMA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+      functions-have-names: 1.2.3
+    dev: true
+
   /function.prototype.name@1.1.6:
     resolution: {integrity: sha512-Z5kx79swU5P27WEayXM1tBi5Ze/lbIyiNgU3qyXUOf9b2rgXYyF9Dy9Cx+IQv/Lc8WCG6L82zwUPpSS9hGehIg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
       functions-have-names: 1.2.3
 
   /functions-have-names@1.2.3:
@@ -7849,22 +7883,25 @@ packages:
 
   /get-intrinsic@1.2.1:
     resolution: {integrity: sha512-2DcsyfABl+gVHEfCOaTrWgyt+tb6MSEGmKq+kI5HwLbIYgjgmMcV8KQ41uaKz1xxUcn9tJtgFbQUEVcEbd0FYw==}
+    dependencies:
+      function-bind: 1.1.1
+      has: 1.0.3
+      has-proto: 1.0.1
+      has-symbols: 1.0.3
+
+  /get-intrinsic@1.2.2:
+    resolution: {integrity: sha512-0gSo4ml/0j98Y3lngkFEot/zhiCeWsbYIlZ+uZOVgzLyLaUw7wxUL+nCTP0XJvJg1AXulJRI3UJi8GsbDuxdGA==}
     dependencies:
       function-bind: 1.1.2
-      has: 1.0.4
       has-proto: 1.0.1
       has-symbols: 1.0.3
+      hasown: 2.0.0
 
   /get-set-props@0.1.0:
     resolution: {integrity: sha512-7oKuKzAGKj0ag+eWZwcGw2fjiZ78tXnXQoBgY0aU7ZOxTu4bB7hSuQSDgtKy978EDH062P5FmD2EWiDpQS9K9Q==}
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /get-stdin@4.0.1:
-    resolution: {integrity: sha512-F5aQMywwJ2n85s4hJPTT9RPxGmubonuB10MNYo17/xph174n2MIR33HRguhzVag10O/npM7SPk73LMZNP+FaWw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /get-stdin@9.0.0:
     resolution: {integrity: sha512-dVKBjfWisLAicarI2Sf+JuBE/DghV4UzNAVe9yhEJuzeREd3JhOTE9cUaJTeSa77fsbQUK3pcOpJfM59+VKZaA==}
     engines: {node: '>=12'}
@@ -7887,42 +7924,40 @@ packages:
     resolution: {integrity: sha512-ts6Wi+2j3jQjqi70w5AlN8DFnkSwC+MqmxEzdEALB2qXZYV3X/b1CTfgPLGJNMeAWxdPfU8FO1ms3NUfaHCPYg==}
     engines: {node: '>=10'}
 
+  /get-stream@8.0.1:
+    resolution: {integrity: sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==}
+    engines: {node: '>=16'}
+    dev: true
+
   /get-symbol-description@1.0.0:
     resolution: {integrity: sha512-2EmdH1YvIQiZpltCNgkuiUnyukzxM/R6NDJX31Ke3BG1Nq5b0S2PhX59UKi9vZpPDQVdqn+1IcaAwnzTT5vCjw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      get-intrinsic: 1.2.2
+
+  /get-tsconfig@4.7.0:
+    resolution: {integrity: sha512-pmjiZ7xtB8URYm74PlGJozDNyhvsVLUcpBa8DZBG3bWHwaHa9bPiRpiSfovw+fjhwONSCWKRyk+JQHEGZmMrzw==}
+    dependencies:
+      resolve-pkg-maps: 1.0.0
 
-  /get-tsconfig@4.5.0:
-    resolution: {integrity: sha512-MjhiaIWCJ1sAU4pIQ5i5OfOuHHxVo1oYeNsWTON7jxYkod8pHocXeh+SSbmu5OZZZK73B6cbJ2XADzXehLyovQ==}
+  /get-tsconfig@4.7.2:
+    resolution: {integrity: sha512-wuMsz4leaj5hbGgg4IvDU0bqJagpftG5l5cXIAvo8uZrqn0NJqwtfupTN00VnkQJPcIRrxYrm1Ue24btpCha2A==}
+    dependencies:
+      resolve-pkg-maps: 1.0.0
 
-  /get-uri@6.0.2:
-    resolution: {integrity: sha512-5KLucCJobh8vBY1K07EFV4+cPZH3mrV9YeAruUseCQKHB58SGjjT2l9/eA9LD082IiuMjSlFJEcdJ27TXvbZNw==}
+  /get-uri@6.0.1:
+    resolution: {integrity: sha512-7ZqONUVqaabogsYNWlYj0t3YZaL6dhuEueZXGF+/YVmf6dHmaFg8/6psJKqhx9QykIDKzpGcy2cn4oV4YC7V/Q==}
     engines: {node: '>= 14'}
     dependencies:
       basic-ftp: 5.0.3
-      data-uri-to-buffer: 6.0.1
+      data-uri-to-buffer: 5.0.1
       debug: 4.3.4(supports-color@8.1.1)
       fs-extra: 8.1.0
     transitivePeerDependencies:
       - supports-color
     dev: true
 
-  /get-value@2.0.6:
-    resolution: {integrity: sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /git-hooks-list@1.0.3:
-    resolution: {integrity: sha512-Y7wLWcrLUXwk2noSka166byGCvhMtDRpgHdzCno1UQv/n/Hegp++a2xBWJL1lJarnKD3SWaljD+0z1ztqxuKyQ==}
-    dev: true
-
-  /git-repo-info@2.1.1:
-    resolution: {integrity: sha512-8aCohiDo4jwjOwma4FmYFd3i97urZulL8XL24nIPxuE+GZnfsAyy/g2Shqx6OjUiFKUXZM+Yy+KHnOmmA3FVcg==}
-    engines: {node: '>= 4.0'}
-    dev: true
-
   /git-up@7.0.0:
     resolution: {integrity: sha512-ONdIrbBCFusq1Oy0sC71F5azx8bVkvtZtMJAsv+a6lz5YAmbNnLD6HAB4gptHZVLPR8S2/kVN6Gab7lryq5+lQ==}
     dependencies:
@@ -7954,22 +7989,24 @@ packages:
   /glob@10.2.3:
     resolution: {integrity: sha512-Kb4rfmBVE3eQTAimgmeqc2LwSnN0wIOkkUL6HmxEFxNJ4fHghYHVbFba/HcGcRjE6s9KoMNK3rSOwkL4PioZjg==}
     engines: {node: '>=16 || 14 >=14.17'}
-    hasBin: true
     dependencies:
       foreground-child: 3.1.1
       jackspeak: 2.2.0
       minimatch: 9.0.0
       minipass: 5.0.0
       path-scurry: 1.7.0
+    dev: false
 
-  /glob@5.0.15:
-    resolution: {integrity: sha512-c9IPMazfRITpmAAKi22dK1VKxGDX9ehhqfABDriL/lzO92xcUKEJPQHrVA/2YHSNFB4iFlykVmWvwo48nr3OxA==}
+  /glob@10.3.10:
+    resolution: {integrity: sha512-fa46+tv1Ak0UPK1TOy/pZrIybNNt4HCv7SDzwyfiOZkvZLEbjsZkJBPtDHVshZjbecAoAGSC20MjLDG/qr679g==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    hasBin: true
     dependencies:
-      inflight: 1.0.6
-      inherits: 2.0.4
-      minimatch: 3.1.2
-      once: 1.4.0
-      path-is-absolute: 1.0.1
+      foreground-child: 3.1.1
+      jackspeak: 2.3.6
+      minimatch: 9.0.3
+      minipass: 5.0.0
+      path-scurry: 1.10.1
     dev: true
 
   /glob@7.2.0:
@@ -8002,32 +8039,13 @@ packages:
       inherits: 2.0.4
       minimatch: 5.1.6
       once: 1.4.0
+    dev: false
 
   /global-dirs@3.0.1:
     resolution: {integrity: sha512-NBcGGFbBA9s1VzD41QXDG+3++t9Mn5t1FpLdhESY6oKY4gYTFpX4wO3sqGUa0Srjtbfj3szX0RnemmrVRUdULA==}
     engines: {node: '>=10'}
     dependencies:
-      ini: 2.0.0
-    dev: true
-
-  /global-modules@1.0.0:
-    resolution: {integrity: sha512-sKzpEkf11GpOFuw0Zzjzmt4B4UZwjOcG757PPvrfhxcLFbq0wpsgpOqxpxtxFiCG4DtG93M6XRVbF2oGdev7bg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      global-prefix: 1.0.2
-      is-windows: 1.0.2
-      resolve-dir: 1.0.1
-    dev: true
-
-  /global-prefix@1.0.2:
-    resolution: {integrity: sha512-5lsx1NUDHtSjfg0eHlmYvZKv8/nVqX4ckFbM+FrGcQ+04KWcWFo9P5MxPZYSzUvyzmdTbI7Eix8Q4IbELDqzKg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      expand-tilde: 2.0.2
-      homedir-polyfill: 1.0.3
-      ini: 1.3.8
-      is-windows: 1.0.2
-      which: 1.3.1
+      ini: 2.0.0
     dev: true
 
   /globals@11.12.0:
@@ -8044,25 +8062,11 @@ packages:
     resolution: {integrity: sha512-sFdI5LyBiNTHjRd7cGPWapiHWMOXKyuBNX/cWJ3NfzrZQVa8GI/8cofCl74AOVqq9W5kNmguTIzJ/1s2gyI9wA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      define-properties: 1.2.1
+      define-properties: 1.2.0
 
   /globalyzer@0.1.0:
     resolution: {integrity: sha512-40oNTM9UfG6aBmuKxk/giHn5nQ8RVz/SS4Ir6zgzOv9/qC3kKZ9v4etGTcJbEl/NyVQH7FGU7d+X1egr57Md2Q==}
 
-  /globby@10.0.0:
-    resolution: {integrity: sha512-3LifW9M4joGZasyYPz2A1U74zbC/45fvpXUvO/9KbSa+VV0aGZarWkfdgKyR9sExNP0t0x0ss/UMJpNpcaTspw==}
-    engines: {node: '>=8'}
-    dependencies:
-      '@types/glob': 7.2.0
-      array-union: 2.1.0
-      dir-glob: 3.0.1
-      fast-glob: 3.3.1
-      glob: 7.2.3
-      ignore: 5.2.4
-      merge2: 1.4.1
-      slash: 3.0.0
-    dev: true
-
   /globby@11.1.0:
     resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
     engines: {node: '>=10'}
@@ -8083,6 +8087,7 @@ packages:
       ignore: 5.2.4
       merge2: 1.4.1
       slash: 4.0.0
+    dev: true
 
   /globrex@0.1.2:
     resolution: {integrity: sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==}
@@ -8090,7 +8095,7 @@ packages:
   /gopd@1.0.1:
     resolution: {integrity: sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==}
     dependencies:
-      get-intrinsic: 1.2.1
+      get-intrinsic: 1.2.2
 
   /got@12.6.1:
     resolution: {integrity: sha512-mThBblvlAF1d4O5oqyvN+ZxLAYwIJK7bpMxgYqPD9okW0C3qm5FFn7k811QrcuEBwaogR3ngOFoCfs6mRv7teQ==}
@@ -8152,49 +8157,22 @@ packages:
   /graceful-fs@4.2.11:
     resolution: {integrity: sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==}
 
-  /graceful-readlink@1.0.1:
-    resolution: {integrity: sha512-8tLu60LgxF6XpdbK8OW3FA+IfTNBn1ZHGHKF4KQbEeSkajYw5PlYJcKluntgegDPTg8UkHjpet1T82vk6TQ68w==}
-    dev: true
-
   /grapheme-splitter@1.0.4:
     resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==}
+    dev: false
+
+  /graphemer@1.4.0:
+    resolution: {integrity: sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag==}
 
   /growly@1.3.0:
     resolution: {integrity: sha512-+xGQY0YyAWCnqy7Cd++hc2JqMYzlm0dG30Jd0beaA64sROr8C4nt8Yc9V5Ro3avlSUDTN0ulqP/VBKi1/lLygw==}
     dev: true
 
-  /handlebars@4.7.7:
-    resolution: {integrity: sha512-aAcXm5OAfE/8IXkcZvCepKU3VzW1/39Fb5ZuqMtgI/hT8X2YgoMvBY5dLhq/cpOvw7Lk1nK/UF71aLG/ZnVYRA==}
-    engines: {node: '>=0.4.7'}
-    hasBin: true
-    dependencies:
-      minimist: 1.2.8
-      neo-async: 2.6.2
-      source-map: 0.6.1
-      wordwrap: 1.0.0
-    optionalDependencies:
-      uglify-js: 3.17.4
-    dev: true
-
   /hard-rejection@2.1.0:
     resolution: {integrity: sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==}
     engines: {node: '>=6'}
     dev: true
 
-  /has-ansi@2.0.0:
-    resolution: {integrity: sha512-C8vBJ8DwUCx19vhm7urhTuUsr4/IyP6l4VzNQDv+ryHQObW3TTTp9yB68WpYgRe2bbaGuZ/se74IqFeVnMnLZg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      ansi-regex: 2.1.1
-    dev: true
-
-  /has-ansi@3.0.0:
-    resolution: {integrity: sha512-5JRDTvNq6mVkaMHQVXrGnaCXHD6JfqxwCy8LA/DQSqLLqePR9uaJVm2u3Ek/UziJFQz+d1ul99RtfIhE2aorkQ==}
-    engines: {node: '>=4'}
-    dependencies:
-      ansi-regex: 3.0.1
-    dev: true
-
   /has-bigints@1.0.2:
     resolution: {integrity: sha512-tSvCKtBr9lkF0Ex0aQiP9N+OpV4zi2r/Nee5VkRDbaqv35RLYMzbwQfFSZZH0kR+Rd6302UJZ2p/bJCEoR3VoQ==}
 
@@ -8228,94 +8206,25 @@ packages:
   /has-unicode@2.0.1:
     resolution: {integrity: sha512-8Rf9Y83NBReMnx0gFzA8JImQACstCYWUplepDa9xprwwtmgEZUF0h/i5xSA625zB/I37EtrswSST6OXxwaaIJQ==}
 
-  /has-value@0.3.1:
-    resolution: {integrity: sha512-gpG936j8/MzaeID5Yif+577c17TxaDmhuyVgSwtnL/q8UUTySg8Mecb+8Cf1otgLoD7DDH75axp86ER7LFsf3Q==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      get-value: 2.0.6
-      has-values: 0.1.4
-      isobject: 2.1.0
-    dev: true
-
-  /has-value@1.0.0:
-    resolution: {integrity: sha512-IBXk4GTsLYdQ7Rvt+GRBrFSVEkmuOUy4re0Xjd9kJSUQpnTrWR4/y9RpfexN9vkAPMFuQoeWKwqzPozRTlasGw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      get-value: 2.0.6
-      has-values: 1.0.0
-      isobject: 3.0.1
-    dev: true
-
-  /has-values@0.1.4:
-    resolution: {integrity: sha512-J8S0cEdWuQbqD9//tlZxiMuMNmxB8PlEwvYwuxsTmR1G5RXUePEX/SJn7aD0GMLieuZYSwNH0cQuJGwnYunXRQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /has-values@1.0.0:
-    resolution: {integrity: sha512-ODYZC64uqzmtfGMEAX/FvZiRyWLpAC3vYnNunURUnkGVTS+mI0smVsWaPydRBsE3g+ok7h960jChO8mFcWlHaQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-number: 3.0.0
-      kind-of: 4.0.0
-    dev: true
-
   /has-yarn@3.0.0:
     resolution: {integrity: sha512-IrsVwUHhEULx3R8f/aA8AHuEzAorplsab/v8HBzEiIukwq5i/EC+xmOW+HfP1OaDP+2JkgT1yILHN2O3UFIbcA==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     dev: true
 
-  /has@1.0.4:
-    resolution: {integrity: sha512-qdSAmqLF6209RFj4VVItywPMbm3vWylknmB3nvNiUIs72xAimcM8nVYxYr7ncvZq5qzk9MKIZR8ijqD/1QuYjQ==}
+  /has@1.0.3:
+    resolution: {integrity: sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==}
     engines: {node: '>= 0.4.0'}
+    dependencies:
+      function-bind: 1.1.1
 
-  /hash-for-dep@1.5.1:
-    resolution: {integrity: sha512-/dQ/A2cl7FBPI2pO0CANkvuuVi/IFS5oTyJ0PsOb6jW6WbVW1js5qJXMJTNbWHXBIPdFTWFbabjB+mE0d+gelw==}
+  /hasown@2.0.0:
+    resolution: {integrity: sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      broccoli-kitchen-sink-helpers: 0.3.1
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-      path-root: 0.1.1
-      resolve: 1.22.8
-      resolve-package-path: 1.2.7
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
+      function-bind: 1.1.2
 
   /he@1.2.0:
     resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
-    hasBin: true
-    dev: true
-
-  /heimdalljs-fs-monitor@1.1.1:
-    resolution: {integrity: sha512-BHB8oOXLRlrIaON0MqJSEjGVPDyqt2Y6gu+w2PaEZjrCxeVtZG7etEZp7M4ZQ80HNvnr66KIQ2lot2qdeG8HgQ==}
-    dependencies:
-      callsites: 3.1.0
-      clean-stack: 2.2.0
-      extract-stack: 2.0.0
-      heimdalljs: 0.2.6
-      heimdalljs-logger: 0.1.10
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /heimdalljs-graph@1.0.0:
-    resolution: {integrity: sha512-v2AsTERBss0ukm/Qv4BmXrkwsT5x6M1V5Om6E8NcDQ/ruGkERsfsuLi5T8jx8qWzKMGYlwzAd7c/idymxRaPzA==}
-    engines: {node: 8.* || >= 10.*}
-    dev: true
-
-  /heimdalljs-logger@0.1.10:
-    resolution: {integrity: sha512-pO++cJbhIufVI/fmB/u2Yty3KJD0TqNPecehFae0/eps0hkZ3b4Zc/PezUMOpYuHFQbA7FxHZxa305EhmjLj4g==}
-    dependencies:
-      debug: 2.6.9
-      heimdalljs: 0.2.6
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /heimdalljs@0.2.6:
-    resolution: {integrity: sha512-o9bd30+5vLBvBtzCPwwGqpry2+n0Hi6H1+qwt6y+0kwRHGGF8TFIhJPmnuM0xO97zaKrDZMwO/V56fAnn8m/tA==}
-    dependencies:
-      rsvp: 3.2.1
     dev: true
 
   /helpertypes@0.0.19:
@@ -8327,13 +8236,6 @@ packages:
     resolution: {integrity: sha512-tzcUFauisWKNHaRkN4Wjl/ZA07gENAjFl3J/c480dprkGTg5EQstgaNFqBfUqCq54kZRIEcreTsAgF/m2quD7A==}
     dev: true
 
-  /homedir-polyfill@1.0.3:
-    resolution: {integrity: sha512-eSmmWE5bZTK2Nou4g0AI3zZ9rswp7GRKoKXS1BLUkvPviOqs4YTN1djQIqrXy9k5gEtdLPy86JjRwsNM9tnDcA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      parse-passwd: 1.0.0
-    dev: true
-
   /hosted-git-info@2.8.9:
     resolution: {integrity: sha512-mxIDAb9Lsm6DoOJ7xH+5+X4y1LU/4Hi50L9C5sIswK3JzULS4bwk1FvjdBgvYR4bzT4tuUQiC15FE2f5HbLvYw==}
     dev: true
@@ -8345,34 +8247,10 @@ packages:
       lru-cache: 6.0.0
     dev: true
 
-  /hosted-git-info@5.2.1:
-    resolution: {integrity: sha512-xIcQYMnhcx2Nr4JTjsFmwwnr9vldugPy9uVm0o87bjqqWMv9GaqsTeT+i99wTl0mk1uLxJtHxLb8kymqTENQsw==}
-    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
-    dependencies:
-      lru-cache: 7.18.3
-    dev: true
-
-  /hosted-git-info@6.1.1:
-    resolution: {integrity: sha512-r0EI+HBMcXadMrugk0GCQ+6BQV39PiWAZVfq7oIckeGiN7sjRGyQxPdft3nQekFTCQbYxLBH+/axZMeH8UX6+w==}
-    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
-    dependencies:
-      lru-cache: 7.18.3
-    dev: true
-
   /http-cache-semantics@4.1.1:
     resolution: {integrity: sha512-er295DKPVsV82j5kw1Gjt+ADA/XYHsajl82cGNQG2eyoPkvgUhX+nDIyelzhIWbbsXP39EHcI6l5tYs2FYqYXQ==}
     dev: true
 
-  /http-errors@1.6.3:
-    resolution: {integrity: sha512-lks+lVC8dgGyh97jxvxeYTWQFvh4uw4yC12gVl63Cg30sjPX4wuGcdkICVXDAESr6OJGjqGA8Iz5mkeN6zlD7A==}
-    engines: {node: '>= 0.6'}
-    dependencies:
-      depd: 1.1.2
-      inherits: 2.0.3
-      setprototypeof: 1.1.0
-      statuses: 1.5.0
-    dev: true
-
   /http-errors@2.0.0:
     resolution: {integrity: sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==}
     engines: {node: '>= 0.8'}
@@ -8384,10 +8262,6 @@ packages:
       toidentifier: 1.0.1
     dev: true
 
-  /http-parser-js@0.5.8:
-    resolution: {integrity: sha512-SGeBX54F94Wgu5RH3X5jsDtf4eHyRogWX1XGT3b4HuW3tQPM4AaBzoUji/4AAJNXCEOWZ5O0DgZmJw1947gD5Q==}
-    dev: true
-
   /http-proxy-agent@4.0.1:
     resolution: {integrity: sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==}
     engines: {node: '>= 6'}
@@ -8408,6 +8282,7 @@ packages:
       debug: 4.3.4(supports-color@8.1.1)
     transitivePeerDependencies:
       - supports-color
+    dev: false
 
   /http-proxy-agent@7.0.0:
     resolution: {integrity: sha512-+ZT+iBxVUQ1asugqnD6oWoRiS25AkjNfG085dKJGtGxkdwLQrMKU5wJr2bOOFAXzKcTuqq+7fZlTMgG3SRfIYQ==}
@@ -8467,23 +8342,20 @@ packages:
       - supports-color
     dev: true
 
-  /https@1.0.0:
-    resolution: {integrity: sha512-4EC57ddXrkaF0x83Oj8sM6SLQHAWXw90Skqu2M4AEWENZ3F02dFJE/GARA8igO79tcgYqGrD7ae4f5L3um2lgg==}
-    dev: true
-
-  /human-signals@1.1.1:
-    resolution: {integrity: sha512-SEQu7vl8KjNL2eoGBLF3+wAjpsNfA9XMlXAYj/3EdaNfAlxKthD1xjEQfGOUhllCGGJVNY34bRr6lPINhNjyZw==}
-    engines: {node: '>=8.12.0'}
-    dev: true
-
   /human-signals@2.1.0:
     resolution: {integrity: sha512-B4FFZ6q/T2jhhksgkbEW3HBvWIfDW85snkQgawt07S7J5QXTk6BkNV+0yAeZrM5QpMAdYlocGoljn0sJ/WQkFw==}
     engines: {node: '>=10.17.0'}
+    dev: true
 
   /human-signals@4.3.1:
     resolution: {integrity: sha512-nZXjEF2nbo7lIw3mgYjItAfgQXog3OjJogSbKa2CQIIvSGWcKgeJnQlNXip6NglNzYH45nSRiEVimMvYL8DDqQ==}
     engines: {node: '>=14.18.0'}
 
+  /human-signals@5.0.0:
+    resolution: {integrity: sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==}
+    engines: {node: '>=16.17.0'}
+    dev: true
+
   /humanize-ms@1.2.1:
     resolution: {integrity: sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ==}
     dependencies:
@@ -8500,6 +8372,7 @@ packages:
   /iconv-lite@0.6.3:
     resolution: {integrity: sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==}
     engines: {node: '>=0.10.0'}
+    requiresBuild: true
     dependencies:
       safer-buffer: 2.1.2
     dev: true
@@ -8569,30 +8442,16 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /indent-string@5.0.0:
-    resolution: {integrity: sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==}
-    engines: {node: '>=12'}
-    dev: true
-
   /infer-owner@1.0.4:
     resolution: {integrity: sha512-IClj+Xz94+d7irH5qRyfJonOdfTzuDaifE6ZPWfx0N0+/ATZCbuTPq2prFl526urkQd90WyUKIh1DfBQ2hMz9A==}
     dev: true
 
-  /inflection@2.0.1:
-    resolution: {integrity: sha512-wzkZHqpb4eGrOKBl34xy3umnYHx8Si5R1U4fwmdxLo5gdH6mEK8gclckTj/qWqy4Je0bsDYe/qazZYuO7xe3XQ==}
-    engines: {node: '>=14.0.0'}
-    dev: true
-
   /inflight@1.0.6:
     resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
     dependencies:
       once: 1.4.0
       wrappy: 1.0.2
 
-  /inherits@2.0.3:
-    resolution: {integrity: sha512-x00IRNXNy63jwGkJmzPigoySHbaqpNuzKbBOmzK+g2OdZpQ9w+sxCN+VSB3ja7IAge2OP2qpfxTjeNcyjmW1uw==}
-    dev: true
-
   /inherits@2.0.4:
     resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
 
@@ -8605,57 +8464,6 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /inline-source-map-comment@1.0.5:
-    resolution: {integrity: sha512-a3/m6XgooVCXkZCduOb7pkuvUtNKt4DaqaggKKJrMQHQsqt6JcJXEreExeZiiK4vWL/cM/uF6+chH05pz2/TdQ==}
-    hasBin: true
-    dependencies:
-      chalk: 1.1.3
-      get-stdin: 4.0.1
-      minimist: 1.2.8
-      sum-up: 1.0.3
-      xtend: 4.0.2
-    dev: true
-
-  /inquirer@6.5.2:
-    resolution: {integrity: sha512-cntlB5ghuB0iuO65Ovoi8ogLHiWGs/5yNrtUcKjFhSSiVeAIVpD7koaSU9RM8mpXw5YDi9RdYXGQMaOURB7ycQ==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      ansi-escapes: 3.2.0
-      chalk: 2.4.2
-      cli-cursor: 2.1.0
-      cli-width: 2.2.1
-      external-editor: 3.1.0
-      figures: 2.0.0
-      lodash: 4.17.21
-      mute-stream: 0.0.7
-      run-async: 2.4.1
-      rxjs: 6.6.7
-      string-width: 2.1.1
-      strip-ansi: 5.2.0
-      through: 2.3.8
-    dev: true
-
-  /inquirer@8.2.5:
-    resolution: {integrity: sha512-QAgPDQMEgrDssk1XiwwHoOGYF9BAbUcc1+j+FhEvaOt8/cKRqyLn0U5qA6F74fGhTMGxf92pOvPBeh29jQJDTQ==}
-    engines: {node: '>=12.0.0'}
-    dependencies:
-      ansi-escapes: 4.3.2
-      chalk: 4.1.2
-      cli-cursor: 3.1.0
-      cli-width: 3.0.0
-      external-editor: 3.1.0
-      figures: 3.2.0
-      lodash: 4.17.21
-      mute-stream: 0.0.8
-      ora: 5.4.1
-      run-async: 2.4.1
-      rxjs: 7.8.1
-      string-width: 4.2.3
-      strip-ansi: 6.0.1
-      through: 2.3.8
-      wrap-ansi: 7.0.0
-    dev: true
-
   /inquirer@9.2.11:
     resolution: {integrity: sha512-B2LafrnnhbRzCWfAdOXisUzL89Kg8cVJlYmhqoi3flSiV/TveO+nsXwgKr9h9PIo+J1hz7nBSk6gegRIMBBf7g==}
     engines: {node: '>=14.18.0'}
@@ -8681,19 +8489,14 @@ packages:
     resolution: {integrity: sha512-Y+R5hJrzs52QCG2laLn4udYVnxsfny9CpOhNhUvk/SSSVyF6T27FzRbF0sroPidSu3X8oEAkOn2K804mjpt6UQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      get-intrinsic: 1.2.1
-      has: 1.0.4
+      get-intrinsic: 1.2.2
+      has: 1.0.3
       side-channel: 1.0.4
 
   /interpret@1.4.0:
     resolution: {integrity: sha512-agE4QfB2Lkp9uICn7BAqoscw4SZP9kTE2hxiFI3jBPmXJfdqiahTbUuKGsMoN2GtqL9AxhYioAcVvgsb1HvRbA==}
     engines: {node: '>= 0.10'}
 
-  /invert-kv@3.0.1:
-    resolution: {integrity: sha512-CYdFeFexxhv/Bcny+Q0BfOV+ltRlJcd4BBZBYFX/O0u4npJrgZtIcjokegtiSMAvlMTJ+Koq0GBCc//3bueQxw==}
-    engines: {node: '>=8'}
-    dev: true
-
   /ip@1.1.8:
     resolution: {integrity: sha512-PuExPYUiu6qMBQb4l06ecm6T6ujzhmh+MeJcW9wa89PoAz5pvd4zPgN5WJV104mb6S2T1AwNIAaB70JNrLQWhg==}
     dev: true
@@ -8720,20 +8523,6 @@ packages:
       is-windows: 1.0.2
     dev: true
 
-  /is-accessor-descriptor@0.1.6:
-    resolution: {integrity: sha512-e1BM1qnDbMRG3ll2U9dSK0UMHuWOs3pY3AtcFsmvwPtKL3MML/Q86i+GilLfvqEs4GW+ExB91tQ3Ig9noDIZ+A==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      kind-of: 3.2.2
-    dev: true
-
-  /is-accessor-descriptor@1.0.0:
-    resolution: {integrity: sha512-m5hnHTkcVsPfqx3AKlyttIPb7J+XykHvJP2B9bZDjlhLIoEq4XoK64Vg7boZlVWYK6LUY94dYPEE7Lh0ZkZKcQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      kind-of: 6.0.3
-    dev: true
-
   /is-arguments@1.1.1:
     resolution: {integrity: sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==}
     engines: {node: '>= 0.4'}
@@ -8745,8 +8534,8 @@ packages:
   /is-array-buffer@3.0.2:
     resolution: {integrity: sha512-y+FyyR/w8vfIRq4eQcM1EYgSTnmHXPqaF+IgzgraytCFq5Xh8lllDVmAZolPJiZttZLeFSINPYMaEJ7/vWUa1w==}
     dependencies:
-      call-bind: 1.0.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      get-intrinsic: 1.2.2
       is-typed-array: 1.1.12
 
   /is-arrayish@0.2.1:
@@ -8767,13 +8556,9 @@ packages:
     resolution: {integrity: sha512-gDYaKHJmnj4aWxyj6YHyXVpdQawtVLHU5cb+eztPGczf6cjuTdwve5ZIEfgXqH4e57An1D1AKf8CZ3kYrQRqYA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       has-tostringtag: 1.0.0
 
-  /is-buffer@1.1.6:
-    resolution: {integrity: sha512-NcdALwpXkTm5Zvvbk7owOUSvVvBKDgKP5/ewfXEznmQFfs4ZRmanOeKBTjRVjka3QFoN6XJ+9F3USqfHqTaU5w==}
-    dev: true
-
   /is-builtin-module@3.2.1:
     resolution: {integrity: sha512-BSLE3HnV2syZ0FK0iMA/yUGplUeMmNz4AW5fnTunbCIqZi4vG3WjJT9FHMy5D69xmAYBHXQhJdALdpwVxV501A==}
     engines: {node: '>=6'}
@@ -8788,27 +8573,18 @@ packages:
     resolution: {integrity: sha512-ZYvCgrefwqoQ6yTyYUbQu64HsITZ3NfKX1lzaEYdkTDcfKzzCI/wthRRYKkdjHKFVgNiXKAKm65Zo1pk2as/QQ==}
     hasBin: true
     dependencies:
-      ci-info: 3.9.0
+      ci-info: 3.8.0
     dev: true
 
   /is-core-module@2.13.0:
     resolution: {integrity: sha512-Z7dk6Qo8pOCp3l4tsX2C5ZVas4V+UxwQodwZhLopL91TX8UyyHEXafPcyoeeWuLrwzHcr3igO78wNLwHJHsMCQ==}
     dependencies:
-      has: 1.0.4
-
-  /is-data-descriptor@0.1.4:
-    resolution: {integrity: sha512-+w9D5ulSoBNlmw9OHn3U2v51SyoCd0he+bB3xMl62oijhrspxowjU+AIcDY0N3iEJbUEkB15IlMASQsxYigvXg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      kind-of: 3.2.2
-    dev: true
+      has: 1.0.3
 
-  /is-data-descriptor@1.0.0:
-    resolution: {integrity: sha512-jbRXy1FmtAoCjQkVmIVYwuuqDFUbaOeDjmed1tOGPrsMhtJA4rD9tkgA0F1qJ3gRFRXcHYVkdeaP50Q5rE/jLQ==}
-    engines: {node: '>=0.10.0'}
+  /is-core-module@2.13.1:
+    resolution: {integrity: sha512-hHrIjvZsftOsvKSn2TRYl63zvxsgE0K+0mYMoH6gD4omR5IWB2KynivBQczo3+wF1cCkjzvptnI9Q0sPU66ilw==}
     dependencies:
-      kind-of: 6.0.3
-    dev: true
+      hasown: 2.0.0
 
   /is-date-object@1.0.5:
     resolution: {integrity: sha512-9YQaSxsAiSwcvS33MBk3wTCVnWK+HhF8VZR2jRxehM16QcVOdHqPn4VPHmRK4lSr38n9JriurInLcP90xsYNfQ==}
@@ -8816,55 +8592,21 @@ packages:
     dependencies:
       has-tostringtag: 1.0.0
 
-  /is-descriptor@0.1.6:
-    resolution: {integrity: sha512-avDYr0SB3DwO9zsMov0gKCESFYqCnE4hq/4z3TdUlukEy5t9C0YRq7HLrsN52NAcqXKaepeCD0n+B0arnVG3Hg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-accessor-descriptor: 0.1.6
-      is-data-descriptor: 0.1.4
-      kind-of: 5.1.0
-    dev: true
-
-  /is-descriptor@1.0.2:
-    resolution: {integrity: sha512-2eis5WqQGV7peooDyLmNEPUrps9+SXX5c9pL3xEB+4e9HnGuDa7mB7kHxHw4CbqS9k1T2hOH3miL8n8WtiYVtg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-accessor-descriptor: 1.0.0
-      is-data-descriptor: 1.0.0
-      kind-of: 6.0.3
-    dev: true
-
   /is-docker@2.2.1:
     resolution: {integrity: sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ==}
     engines: {node: '>=8'}
-    hasBin: true
+    dev: true
 
   /is-docker@3.0.0:
     resolution: {integrity: sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
     hasBin: true
-
-  /is-extendable@0.1.1:
-    resolution: {integrity: sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /is-extendable@1.0.1:
-    resolution: {integrity: sha512-arnXMxT1hhoKo9k1LZdmlNyJdDDfy2v0fXjFlmok4+i8ul/6WlbVge9bhM74OpNPQPMGUToDtz+KXa1PneJxOA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-plain-object: 2.0.4
     dev: true
 
   /is-extglob@2.1.1:
     resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
     engines: {node: '>=0.10.0'}
 
-  /is-fullwidth-code-point@2.0.0:
-    resolution: {integrity: sha512-VHskAKYM8RfSFXwee5t5cbN5PZeq1Wrh6qd5bkyiXIf6UQcN6w/A0eXM9r6t8d+GYOh+o6ZhiEnb88LN/Y8m2w==}
-    engines: {node: '>=4'}
-    dev: true
-
   /is-fullwidth-code-point@3.0.0:
     resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
     engines: {node: '>=8'}
@@ -8876,11 +8618,6 @@ packages:
       lowercase-keys: 1.0.1
     dev: true
 
-  /is-git-url@1.0.0:
-    resolution: {integrity: sha512-UCFta9F9rWFSavp9H3zHEHrARUfZbdJvmHKeEpds4BK3v7W2LdXoNypMtXXi5w5YBDEBCTYmbI+vsSwI8LYJaQ==}
-    engines: {node: '>=0.8'}
-    dev: true
-
   /is-glob@4.0.3:
     resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
     engines: {node: '>=0.10.0'}
@@ -8893,6 +8630,7 @@ packages:
     hasBin: true
     dependencies:
       is-docker: 3.0.0
+    dev: true
 
   /is-installed-globally@0.4.0:
     resolution: {integrity: sha512-iwGqO3J21aaSkC7jWnHP/difazwS7SFeIqxv6wEtLU8Y5KlzFTjyqcSIT0d8s4+dDhKytsk9PJZ2BkS5eZwQRQ==}
@@ -8922,12 +8660,6 @@ packages:
     resolution: {integrity: sha512-z7CMFGNrENq5iFB9Bqo64Xk6Y9sg+epq1myIcdHaGnbMTYOxvzsEtdYqQUylB7LxfkvgrrjP32T6Ywciio9UIQ==}
     dev: true
 
-  /is-language-code@3.1.0:
-    resolution: {integrity: sha512-zJdQ3QTeLye+iphMeK3wks+vXSRFKh68/Pnlw7aOfApFSEIOhYa8P9vwwa6QrImNNBMJTiL1PpYF0f4BxDuEgA==}
-    dependencies:
-      '@babel/runtime': 7.21.5
-    dev: true
-
   /is-map@2.0.2:
     resolution: {integrity: sha512-cOZFQQozTha1f4MxLFzlgKYPTyj26picdZTx82hbc/Xf4K/tZOOXSCkMvU4pKioRXGDLJRn0GM7Upe7kR721yg==}
     dev: true
@@ -8956,13 +8688,6 @@ packages:
     dependencies:
       has-tostringtag: 1.0.0
 
-  /is-number@3.0.0:
-    resolution: {integrity: sha512-4cboCqIpliH+mAvFNegjZQ4kgKc3ZUhQVr3HvWbSh5q3WH2v82ct+T2Y1hdU5Gdtorx/cLifQjqCbL7bpznLTg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      kind-of: 3.2.2
-    dev: true
-
   /is-number@7.0.0:
     resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
     engines: {node: '>=0.12.0'}
@@ -8993,13 +8718,6 @@ packages:
     engines: {node: '>=8'}
     dev: true
 
-  /is-plain-object@2.0.4:
-    resolution: {integrity: sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      isobject: 3.0.1
-    dev: true
-
   /is-plain-object@5.0.0:
     resolution: {integrity: sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==}
     engines: {node: '>=0.10.0'}
@@ -9015,14 +8733,14 @@ packages:
   /is-reference@1.2.1:
     resolution: {integrity: sha512-U82MsXXiFIrjCK4otLT+o2NA2Cd2g5MLoOVXUZjIOhLurrRxpEXzI8O0KZHr3IjLvlAH1kTPYSuqer5T9ZVBKQ==}
     dependencies:
-      '@types/estree': 1.0.2
+      '@types/estree': 1.0.1
     dev: false
 
   /is-regex@1.1.4:
     resolution: {integrity: sha512-kvRdxDsxZjhzUX07ZnLydzS1TU/TJlTUHHY4YLL87e37oUA49DfkLqgy+VjFocowy29cKvcSiu+kIv728jTTVg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       has-tostringtag: 1.0.0
 
   /is-relative@1.0.0:
@@ -9043,7 +8761,7 @@ packages:
   /is-shared-array-buffer@1.0.2:
     resolution: {integrity: sha512-sqN2UDu1/0y6uvXyStCOzyhAjCSlHceFoMKJW8W9EU9cvic/QdsZ0kEU93HEy3IUEFZIiH/3w+AH/UQbPHNdhA==}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
 
   /is-ssh@1.4.0:
     resolution: {integrity: sha512-x7+VxdxOdlV3CYpjvRLBv5Lo9OJerlYanjwFrPR9fuGPjCiNiCzFgAWpiLAohSbsnH4ZAys3SBh+hq5rJosxUQ==}
@@ -9059,6 +8777,7 @@ packages:
   /is-stream@2.0.1:
     resolution: {integrity: sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg==}
     engines: {node: '>=8'}
+    dev: true
 
   /is-stream@3.0.0:
     resolution: {integrity: sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==}
@@ -9082,11 +8801,22 @@ packages:
       core-util-is: 1.0.3
     dev: true
 
+  /is-typed-array@1.1.10:
+    resolution: {integrity: sha512-PJqgEHiWZvMpaFZ3uTc8kHPM4+4ADTlDniuQL7cU/UDA0Ql7F70yGfHph3cLNe+c9toaigv+DFzTJKhc2CtO6A==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      available-typed-arrays: 1.0.5
+      call-bind: 1.0.5
+      for-each: 0.3.3
+      gopd: 1.0.1
+      has-tostringtag: 1.0.0
+    dev: true
+
   /is-typed-array@1.1.12:
     resolution: {integrity: sha512-Z14TF2JNG8Lss5/HMqt0//T9JeHXttXy5pH/DBU4vi98ozO2btxzq9MwYDZYnKwU8nRsz/+GVFVRDq3DkVuSPg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      which-typed-array: 1.1.11
+      which-typed-array: 1.1.13
 
   /is-typedarray@1.0.0:
     resolution: {integrity: sha512-cyA56iCMHAh5CdzjJIa4aohJyeO1YbwLi3Jc35MmRU6poroFjIGZzUzupGiRPOjgHg9TLu43xbpwXk523fMxKA==}
@@ -9112,7 +8842,7 @@ packages:
   /is-weakref@1.0.2:
     resolution: {integrity: sha512-qctsuLZmIQ0+vSSMfoVvyFe2+GSEvnmZ2ezTup1SBse9+twCCeial6EEi3Nc2KFcf6+qz2FBPnjXsk8xhKSaPQ==}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
 
   /is-windows@1.0.2:
     resolution: {integrity: sha512-eXK1UInq2bPmjyX6e3VHIzMLobc4J94i4AWn+Hpq3OU5KkrRC96OAcR3PRJ/pGu6m8TRnBHP9dkXQVsT/COVIA==}
@@ -9124,48 +8854,24 @@ packages:
     engines: {node: '>=8'}
     dependencies:
       is-docker: 2.2.1
+    dev: true
 
   /is-yarn-global@0.4.1:
     resolution: {integrity: sha512-/kppl+R+LO5VmhYSEWARUFjodS25D68gvj8W7z0I7OWhUla5xWu8KL6CtB2V0R6yqhnRgbcaREMr4EEM6htLPQ==}
     engines: {node: '>=12'}
     dev: true
 
-  /isarray@0.0.1:
-    resolution: {integrity: sha512-D2S+3GLxWH+uhrNEcoh/fnmYeP8E8/zHl644d/jdA0g2uyXvy3sb0qxotE+ne0LtccHknQzWwZEzhak7oJ0COQ==}
-    dev: true
-
-  /isarray@1.0.0:
-    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
-    dev: true
-
   /isarray@2.0.5:
     resolution: {integrity: sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw==}
 
-  /isbinaryfile@5.0.0:
-    resolution: {integrity: sha512-UDdnyGvMajJUWCkib7Cei/dvyJrrvo4FIrsvSFWdPpXSUorzXrDJ0S+X5Q4ZlasfPjca4yqCNNsjbCeiy8FFeg==}
-    engines: {node: '>= 14.0.0'}
-    dev: true
-
-  /isbot@3.6.10:
-    resolution: {integrity: sha512-+I+2998oyP4oW9+OTQD8TS1r9P6wv10yejukj+Ksj3+UR5pUhsZN3f8W7ysq0p1qxpOVNbl5mCuv0bCaF8y5iQ==}
+  /isbot@3.6.13:
+    resolution: {integrity: sha512-uoP4uK5Dc2CrabmK+Gue1jTL+scHiCc1c9rblRpJwG8CPxjLIv8jmGyyGRGkbPOweayhkskdZsEQXG6p+QCQrg==}
     engines: {node: '>=12'}
     dev: false
 
   /isexe@2.0.0:
     resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
 
-  /isobject@2.1.0:
-    resolution: {integrity: sha512-+OUdGJlgjOBZDfxnDjYYG6zp487z0JGNQq3cYQYg5f5hKR+syHMsaztzGeml/4kGG55CSpKSpWTY+jYGgsHLgA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      isarray: 1.0.0
-    dev: true
-
-  /isobject@3.0.1:
-    resolution: {integrity: sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /issue-parser@6.0.0:
     resolution: {integrity: sha512-zKa/Dxq2lGsBIXQ7CUZWTHfvxPC2ej0KfO7fIPqLlHB9J2hJ7rGhZ5rilhuufylr4RXYPzJUeFjKxz305OsNlA==}
     engines: {node: '>=10.13'}
@@ -9177,15 +8883,6 @@ packages:
       lodash.uniqby: 4.7.0
     dev: true
 
-  /istextorbinary@2.1.0:
-    resolution: {integrity: sha512-kT1g2zxZ5Tdabtpp9VSdOzW9lb6LXImyWbzbQeTxoRtHhurC9Ej9Wckngr2+uepPL09ky/mJHmN9jeJPML5t6A==}
-    engines: {node: '>=0.12'}
-    dependencies:
-      binaryextensions: 2.3.0
-      editions: 1.3.4
-      textextensions: 2.6.0
-    dev: true
-
   /iterate-iterator@1.0.2:
     resolution: {integrity: sha512-t91HubM4ZDQ70M9wqp+pcNpu8OyJ9UAtXntT/Bcsvp5tZMnz9vRa+IunKXeI8AnfZMTv0jNuVEmGeLSMjVvfPw==}
     dev: true
@@ -9204,12 +8901,22 @@ packages:
       '@isaacs/cliui': 8.0.2
     optionalDependencies:
       '@pkgjs/parseargs': 0.11.0
+    dev: false
+
+  /jackspeak@2.3.6:
+    resolution: {integrity: sha512-N3yCS/NegsOBokc8GAdM8UcmfsKiSS8cipheD/nivzr700H+nsMOxJjQnvwOcRYVuFkdH0wGUvW2WbXGmrZGbQ==}
+    engines: {node: '>=14'}
+    dependencies:
+      '@isaacs/cliui': 8.0.2
+    optionalDependencies:
+      '@pkgjs/parseargs': 0.11.0
+    dev: true
 
   /jest-worker@27.5.1:
     resolution: {integrity: sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==}
     engines: {node: '>= 10.13.0'}
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
       merge-stream: 2.0.0
       supports-color: 8.1.1
 
@@ -9218,9 +8925,6 @@ packages:
     engines: {node: '>=10'}
     dev: false
 
-  /js-sdsl@4.4.0:
-    resolution: {integrity: sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==}
-
   /js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
@@ -9239,21 +8943,14 @@ packages:
 
   /js-yaml@4.1.0:
     resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
-    hasBin: true
     dependencies:
       argparse: 2.0.1
 
   /jsdoctypeparser@9.0.0:
     resolution: {integrity: sha512-jrTA2jJIL6/DAEILBEh2/w9QxCuwmvNXIry39Ay/HVfhE3o2yVV0U44blYkqdHA/OKloJEqvJy0xU+GSdE2SIw==}
     engines: {node: '>=10'}
-    hasBin: true
     dev: false
 
-  /jsesc@0.3.0:
-    resolution: {integrity: sha512-UHQmAeTXV+iwEk0aHheJRqo6Or90eDxI6KIYpHSjKLXKuKlPt1CQ7tGBerFcFA8uKU5mYxiPMlckmFptd5XZzA==}
-    hasBin: true
-    dev: true
-
   /jsesc@0.5.0:
     resolution: {integrity: sha512-uZz5UnB7u4T9LvwmFqXii7pZSouaRPorGs5who1Ip7VO0wxanFvBL7GkM6dTHlgX+jhBApRetaWpnDabOeTcnA==}
     hasBin: true
@@ -9290,17 +8987,6 @@ packages:
   /json-stable-stringify-without-jsonify@1.0.1:
     resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
 
-  /json-stable-stringify@1.0.2:
-    resolution: {integrity: sha512-eunSSaEnxV12z+Z73y/j5N37/In40GK4GmsSy+tEHJMxknvqnA7/djeYtAgW0GsWHUfg+847WJjKaEylk2y09g==}
-    dependencies:
-      jsonify: 0.0.1
-    dev: true
-
-  /json5@0.5.1:
-    resolution: {integrity: sha512-4xrs1aW+6N5DalkqSVA8fxh458CXvR99WU8WLKmq4v8eWAL86Xo3BVqyd3SkA9wEVjCMqyvvRRkshAdOnBp5rw==}
-    hasBin: true
-    dev: true
-
   /json5@1.0.2:
     resolution: {integrity: sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==}
     hasBin: true
@@ -9316,12 +9002,6 @@ packages:
     resolution: {integrity: sha512-gfFQZrcTc8CnKXp6Y4/CBT3fTc0OVuDofpre4aEeEpSBPV5X5v4+Vmx+8snU7RLPrNHPKSgLxGo9YuQzz20o+w==}
     dev: false
 
-  /jsonfile@2.4.0:
-    resolution: {integrity: sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==}
-    optionalDependencies:
-      graceful-fs: 4.2.11
-    dev: true
-
   /jsonfile@4.0.0:
     resolution: {integrity: sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==}
     optionalDependencies:
@@ -9335,12 +9015,8 @@ packages:
     optionalDependencies:
       graceful-fs: 4.2.11
 
-  /jsonify@0.0.1:
-    resolution: {integrity: sha512-2/Ki0GcmuqSrgFyelQq9M05y7PS0mEwuIzrf3f1fPqkVDVRvZrPZtVSMHxdgo8Aq0sxAOb/cr2aqqA3LeWHVPg==}
-    dev: true
-
-  /keyv@3.1.0:
-    resolution: {integrity: sha512-9ykJ/46SN/9KPM/sichzQ7OvXyGDYKGTaDlKMGCAlg2UK8KRy4jb0d8sFc+0Tt0YYnThq8X2RZgCg74RPxgcVA==}
+  /keyv@3.0.0:
+    resolution: {integrity: sha512-eguHnq22OE3uVoSYG0LVWNP+4ppamWr9+zWBe1bsNcovIMy6huUJFPgy4mGwCd/rnl3vOLGW1MTlu4c57CT1xA==}
     dependencies:
       json-buffer: 3.0.0
     dev: true
@@ -9351,25 +9027,6 @@ packages:
       json-buffer: 3.0.1
     dev: true
 
-  /kind-of@3.2.2:
-    resolution: {integrity: sha512-NOW9QQXMoZGg/oqnVNoNTTIFEIid1627WCffUBJEdMxYApq7mNE7CpzucIPc+ZQg25Phej7IJSmX3hO+oblOtQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-buffer: 1.1.6
-    dev: true
-
-  /kind-of@4.0.0:
-    resolution: {integrity: sha512-24XsCxmEbRwEDbz/qz3stgin8TTzZ1ESR56OMCN0ujYg+vRutNSiOj9bHH9u85DKgXguraugV5sFuvbD4FW/hw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-buffer: 1.1.6
-    dev: true
-
-  /kind-of@5.1.0:
-    resolution: {integrity: sha512-NGEErnH6F2vUuXDh+OlbcKW7/wOcfdRHaZ7VWtqCztfHri/++YKmP51OdWeGPuqCOba6kk2OTe5d02VmTB80Pw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /kind-of@6.0.3:
     resolution: {integrity: sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==}
     engines: {node: '>=0.10.0'}
@@ -9387,23 +9044,6 @@ packages:
       package-json: 8.1.1
     dev: true
 
-  /lcid@3.1.1:
-    resolution: {integrity: sha512-M6T051+5QCGLBQb8id3hdvIW8+zeFV2FyBGFS9IEK5H9Wt4MueD4bW1eWikpHgZp+5xR3l5c8pZUkQsIA0BFZg==}
-    engines: {node: '>=8'}
-    dependencies:
-      invert-kv: 3.0.1
-    dev: true
-
-  /leek@0.0.24:
-    resolution: {integrity: sha512-6PVFIYXxlYF0o6hrAsHtGpTmi06otkwNrMcmQ0K96SeSRHPREPa9J3nJZ1frliVH7XT0XFswoJFQoXsDukzGNQ==}
-    dependencies:
-      debug: 2.6.9
-      lodash.assign: 3.2.0
-      rsvp: 3.6.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /lerna-changelog@2.2.0:
     resolution: {integrity: sha512-yjYNAHrbnw8xYFKmYWJEP52Tk4xSdlNmzpYr26+3glbSGDmpe8UMo8f9DlEntjGufL+opup421oVTXcLshwAaQ==}
     engines: {node: 12.* || 14.* || >= 16}
@@ -9444,16 +9084,6 @@ packages:
   /lines-and-columns@1.2.4:
     resolution: {integrity: sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==}
 
-  /linkify-it@4.0.1:
-    resolution: {integrity: sha512-C7bfi1UZmoj8+PQx22XyeXCuBlokoyWQL5pWSP+EI6nzRylyThouddufc2c1NDIcP9k5agmN9fLpA7VNJfIiqw==}
-    dependencies:
-      uc.micro: 1.0.6
-    dev: true
-
-  /livereload-js@3.4.1:
-    resolution: {integrity: sha512-5MP0uUeVCec89ZbNOT/i97Mc+q3SxXmiUGhRFOTmhrGPn//uWVQdCvcLJDy64MSBR5MidFdOR7B9viumoavy6g==}
-    dev: true
-
   /load-json-file@4.0.0:
     resolution: {integrity: sha512-Kx8hMakjX03tiGTLAIdJ+lL0htKnXjEZN6hk/tozf/WOuYGdZBJrZ+rCJRbVCugsjB3jMLn9746NsQIf5VjBMw==}
     engines: {node: '>=4'}
@@ -9509,17 +9139,6 @@ packages:
     resolution: {integrity: sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw==}
     dev: true
 
-  /lodash._baseassign@3.2.0:
-    resolution: {integrity: sha512-t3N26QR2IdSN+gqSy9Ds9pBu/J1EAFEshKlUHpJG3rvyJOYgcELIxcIeKKfZk7sjOz11cFfzJRsyFry/JyabJQ==}
-    dependencies:
-      lodash._basecopy: 3.0.1
-      lodash.keys: 3.1.2
-    dev: true
-
-  /lodash._basecopy@3.0.1:
-    resolution: {integrity: sha512-rFR6Vpm4HeCK1WPGvjZSJ+7yik8d8PVUdCJx5rT2pogG4Ve/2ZS7kfmO5l5T2o5V2mqlNIfSF5MZlr1+xOoYQQ==}
-    dev: true
-
   /lodash._baseflatten@3.1.4:
     resolution: {integrity: sha512-fESngZd+X4k+GbTxdMutf8ohQa0s3sJEHIcwtu4/LsIQ2JTDzdRxDCMQjW+ezzwRitLmHnacVVmosCbxifefbw==}
     dependencies:
@@ -9527,18 +9146,6 @@ packages:
       lodash.isarray: 3.0.4
     dev: true
 
-  /lodash._bindcallback@3.0.1:
-    resolution: {integrity: sha512-2wlI0JRAGX8WEf4Gm1p/mv/SZ+jLijpj0jyaE/AXeuQphzCgD8ZQW4oSpoN8JAopujOFGU3KMuq7qfHBWlGpjQ==}
-    dev: true
-
-  /lodash._createassigner@3.1.1:
-    resolution: {integrity: sha512-LziVL7IDnJjQeeV95Wvhw6G28Z8Q6da87LWKOPWmzBLv4u6FAT/x5v00pyGW0u38UoogNF2JnD3bGgZZDaNEBw==}
-    dependencies:
-      lodash._bindcallback: 3.0.1
-      lodash._isiterateecall: 3.0.9
-      lodash.restparam: 3.6.1
-    dev: true
-
   /lodash._getnative@3.9.1:
     resolution: {integrity: sha512-RrL9VxMEPyDMHOd9uFbvMe8X55X16/cGM5IgOKgRElQZutpX89iS6vwl64duTV1/16w5JY7tuFNXqoekmh1EmA==}
     dev: true
@@ -9551,14 +9158,6 @@ packages:
     resolution: {integrity: sha512-xYHt68QRoYGjeeM/XOE1uJtvXQAgvszfBhjV4yvsQH0u2i9I6cI6c6/eG4Hh3UAOVn0y/xAXwmTzEay49Q//HA==}
     dev: true
 
-  /lodash.assign@3.2.0:
-    resolution: {integrity: sha512-/VVxzgGBmbphasTg51FrztxQJ/VgAUpol6zmJuSVSGcNg4g7FA4z7rQV8Ovr9V3vFBNWZhvKWHfpAytjTVUfFA==}
-    dependencies:
-      lodash._baseassign: 3.2.0
-      lodash._createassigner: 3.1.1
-      lodash.keys: 3.1.2
-    dev: true
-
   /lodash.assignin@4.2.0:
     resolution: {integrity: sha512-yX/rx6d/UTVh7sSVWVSIMjfnz95evAgDFdb1ZozC35I9mSFCkmzptOzevxjgbQUsc78NR44LVHWjsoMQXy9FDg==}
     dev: true
@@ -9603,10 +9202,6 @@ packages:
       lodash._isiterateecall: 3.0.9
     dev: true
 
-  /lodash.foreach@4.5.0:
-    resolution: {integrity: sha512-aEXTF4d+m05rVOAUG3z4vZZ4xVexLKZGF0lIxuHZ1Hplpk/3B6Z1+/ICICYRLm7c41Z2xiejbkCkJoTlypoXhQ==}
-    dev: true
-
   /lodash.isarguments@3.1.0:
     resolution: {integrity: sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==}
     dev: true
@@ -9623,14 +9218,6 @@ packages:
     resolution: {integrity: sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw==}
     dev: true
 
-  /lodash.keys@3.1.2:
-    resolution: {integrity: sha512-CuBsapFjcubOGMn3VD+24HOAPxM79tH+V6ivJL3CHYjtrawauDJHUk//Yew9Hvc6e9rbCrURGk8z6PC+8WJBfQ==}
-    dependencies:
-      lodash._getnative: 3.9.1
-      lodash.isarguments: 3.1.0
-      lodash.isarray: 3.0.4
-    dev: true
-
   /lodash.memoize@4.1.2:
     resolution: {integrity: sha512-t7j+NzmgnQzTAYXcsHYLgimltOV1MXHtlOWf6GjL9Kj8GK5FInw5JotxvbOs+IvV1/Dzo04/fCGfLVs7aXb4Ag==}
     dev: false
@@ -9642,14 +9229,6 @@ packages:
     resolution: {integrity: sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==}
     dev: true
 
-  /lodash.omit@4.5.0:
-    resolution: {integrity: sha512-XeqSp49hNGmlkj2EJlfrQFIzQ6lXdNro9sddtQzcJY8QaoC2GO0DT7xaIokHeyM+mIT0mPMlPvkYzg2xCuHdZg==}
-    dev: true
-
-  /lodash.restparam@3.6.1:
-    resolution: {integrity: sha512-L4/arjjuq4noiUJpt3yS6KIKDtJwNe2fIYgMqyYYKoeIfV1iEqvPwhCx23o+R9dzouGihDAPN1dTIRWa7zk8tw==}
-    dev: true
-
   /lodash.template@4.5.0:
     resolution: {integrity: sha512-84vYFxIkmidUiFxidA/KjjH9pAycqW+h980j7Fuz5qxRtO9pgB7MDFTdys1N7A5mcucRiDyEq4fusljItR1T/A==}
     dependencies:
@@ -9665,6 +9244,7 @@ packages:
 
   /lodash.uniq@4.5.0:
     resolution: {integrity: sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==}
+    dev: false
 
   /lodash.uniqby@4.7.0:
     resolution: {integrity: sha512-e/zcLx6CSbmaEgFHCA7BnoQKyCtKMxnuWrJygbwPs/AIn+IMKl66L8/s+wBUn5LRw2pZx3bUHibiV1b6aTWIww==}
@@ -9673,13 +9253,6 @@ packages:
   /lodash@4.17.21:
     resolution: {integrity: sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg==}
 
-  /log-symbols@2.2.0:
-    resolution: {integrity: sha512-VeIAFslyIerEJLXHziedo2basKbMKtTw3vfn5IzG0XTjhAVEJyNHnL2p7vc+wBDSdQuUpNw3M2u6xb9QsAY5Eg==}
-    engines: {node: '>=4'}
-    dependencies:
-      chalk: 2.4.2
-    dev: true
-
   /log-symbols@4.1.0:
     resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
     engines: {node: '>=10'}
@@ -9742,18 +9315,18 @@ packages:
     dependencies:
       '@jridgewell/sourcemap-codec': 1.4.15
 
-  /magic-string@0.30.0:
-    resolution: {integrity: sha512-LA+31JYDJLs82r2ScLrlz1GjSgu66ZV518eyWT+S8VhyQn/JL0u9MeBOvQMGYiPk1DBiSN9DDMOcXvigJZaViQ==}
+  /magic-string@0.30.3:
+    resolution: {integrity: sha512-B7xGbll2fG/VjP+SWg4sX3JynwIU0mjoTc6MPpKNuIvftk6u6vqhDnk1R80b8C2GBR6ywqy+1DcKBrevBg+bmw==}
     engines: {node: '>=12'}
     dependencies:
       '@jridgewell/sourcemap-codec': 1.4.15
     dev: false
 
-  /make-dir@3.1.0:
-    resolution: {integrity: sha512-g3FeP20LNwhALb/6Cz6Dd4F2ngze0jz7tbzrD2wAV+o9FeNHe4rL+yK2md0J/fiSf1sa1ADhXqi5+oVwOM/eGw==}
-    engines: {node: '>=8'}
+  /magic-string@0.30.5:
+    resolution: {integrity: sha512-7xlpfBaQaP/T6Vh8MO/EqXSW5En6INHEvEXQiuff7Gku0PWjU3uf6w/j9o7O+SpB5fOAkrI5HeoNgwjEO0pFsA==}
+    engines: {node: '>=12'}
     dependencies:
-      semver: 6.3.1
+      '@jridgewell/sourcemap-codec': 1.4.15
     dev: true
 
   /make-error@1.3.6:
@@ -9784,24 +9357,6 @@ packages:
       - supports-color
     dev: true
 
-  /makeerror@1.0.12:
-    resolution: {integrity: sha512-JmqCvUhmt43madlpFzG4BQzG2Z3m6tvQDNKdClZnO3VbIudJYmxsT0FNJMeiB2+JTSlTQTSbU8QdesVmwJcmLg==}
-    dependencies:
-      tmpl: 1.0.5
-    dev: true
-
-  /map-age-cleaner@0.1.3:
-    resolution: {integrity: sha512-bJzx6nMoP6PDLPBFmg7+xRKeFZvFboMrGlxmNj9ClvX53KrmvM5bXFXEWjbz4cz1AFn+jWJ9z/DJSz7hrs0w3w==}
-    engines: {node: '>=6'}
-    dependencies:
-      p-defer: 1.0.0
-    dev: true
-
-  /map-cache@0.2.2:
-    resolution: {integrity: sha512-8y/eV9QQZCiyn1SprXSrCmqJN0yNRATe+PO8ztwqrvrbdRLA3eYJF0yaR0YayLWkMbsQSKWS9N2gPcGEc4UsZg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /map-obj@1.0.1:
     resolution: {integrity: sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==}
     engines: {node: '>=0.10.0'}
@@ -9816,42 +9371,6 @@ packages:
     resolution: {integrity: sha512-CkYQrPYZfWnu/DAmVCpTSX/xHpKZ80eKh2lAkyA6AJTef6bW+6JpbQZN5rofum7da+SyN1bi5ctTm+lTfcCW3g==}
     dev: true
 
-  /map-visit@1.0.0:
-    resolution: {integrity: sha512-4y7uGv8bd2WdM9vpQsiQNo41Ln1NvhvDRuVt0k2JZQ+ezN2uaQes7lZeZ+QQUHOLQAtDaBJ+7wCbi+ab/KFs+w==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      object-visit: 1.0.1
-    dev: true
-
-  /markdown-it-terminal@0.4.0(markdown-it@13.0.1):
-    resolution: {integrity: sha512-NeXtgpIK6jBciHTm9UhiPnyHDdqyVIdRPJ+KdQtZaf/wR74gvhCNbw5li4TYsxRp5u3ZoHEF4DwpECeZqyCw+w==}
-    peerDependencies:
-      markdown-it: '>= 13.0.0'
-    dependencies:
-      ansi-styles: 3.2.1
-      cardinal: 1.0.0
-      cli-table: 0.3.11
-      lodash.merge: 4.6.2
-      markdown-it: 13.0.1
-    dev: true
-
-  /markdown-it@13.0.1:
-    resolution: {integrity: sha512-lTlxriVoy2criHP0JKRhO2VDG9c2ypWCsT237eDiLqi09rmbKoUetyGHq2uOIRoRS//kfoJckS0eUzzkDR+k2Q==}
-    hasBin: true
-    dependencies:
-      argparse: 2.0.1
-      entities: 3.0.1
-      linkify-it: 4.0.1
-      mdurl: 1.0.1
-      uc.micro: 1.0.6
-    dev: true
-
-  /matcher-collection@1.1.2:
-    resolution: {integrity: sha512-YQ/teqaOIIfUHedRam08PB3NK7Mjct6BvzRnJmpGDm8uFXpNr1sbY4yuflI5JcEs6COpYA0FpRQhSDBf1tT95g==}
-    dependencies:
-      minimatch: 3.1.2
-    dev: true
-
   /matcher-collection@2.0.1:
     resolution: {integrity: sha512-daE62nS2ZQsDg9raM0IlZzLmI2u+7ZapXBwdoeBUKAYERPDDIc0qNqA8E0Rp2D+gspKR7BgIFP52GeujaGXWeQ==}
     engines: {node: 6.* || 8.* || >= 10.*}
@@ -9863,8 +9382,8 @@ packages:
   /mdast-util-from-markdown@1.3.1:
     resolution: {integrity: sha512-4xTO/M8c82qBcnQc1tgpNtubGUW/Y1tBQ1B0i5CtSoelOLKFYlElIr3bvgREYYO5iRqbMY1YuqZng0GVOI8Qww==}
     dependencies:
-      '@types/mdast': 3.0.13
-      '@types/unist': 2.0.8
+      '@types/mdast': 3.0.14
+      '@types/unist': 2.0.9
       decode-named-character-reference: 1.0.2
       mdast-util-to-string: 3.2.0
       micromark: 3.2.0
@@ -9882,63 +9401,29 @@ packages:
   /mdast-util-to-string@3.2.0:
     resolution: {integrity: sha512-V4Zn/ncyN1QNSqSBxTrMOLpjr+IKdHl2v3KVLoWmDPscP4r9GcCi71gjgvUV1SFSKh92AjAG4peFuBl2/YgCJg==}
     dependencies:
-      '@types/mdast': 3.0.13
+      '@types/mdast': 3.0.14
     dev: true
 
   /mdn-data@2.0.14:
     resolution: {integrity: sha512-dn6wd0uw5GsdswPFfsgMp5NSB0/aDe6fK94YJV/AJDYXL6HVLWBsxeq7js7Ad+mU2K9LAlwpk6kN2D5mwCPVow==}
     dev: false
 
-  /mdurl@1.0.1:
-    resolution: {integrity: sha512-/sKlQJCBYVY9Ers9hqzKou4H6V5UWc/M59TH2dvkt+84itfnq7uFOMLpOiOS4ujvHP4etln18fmIxA5R5fll0g==}
-    dev: true
-
   /media-typer@0.3.0:
     resolution: {integrity: sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==}
     engines: {node: '>= 0.6'}
     dev: true
 
-  /mem@5.1.1:
-    resolution: {integrity: sha512-qvwipnozMohxLXG1pOqoLiZKNkC4r4qqRucSoDwXowsNGDSULiqFTRUF05vcZWnwJSG22qTsynQhxbaMtnX9gw==}
-    engines: {node: '>=8'}
-    dependencies:
-      map-age-cleaner: 0.1.3
-      mimic-fn: 2.1.0
-      p-is-promise: 2.1.0
-    dev: true
-
   /memory-fs@0.2.0:
     resolution: {integrity: sha512-+y4mDxU4rvXXu5UDSGCGNiesFmwCHuefGMoPCO1WYucNYj7DsLqrFaa2fXVI0H+NNiPTwwzKwspn9yTZqUGqng==}
 
-  /memory-streams@0.1.3:
-    resolution: {integrity: sha512-qVQ/CjkMyMInPaaRMrwWNDvf6boRZXaT/DbQeMYcCWuXPEBf1v8qChOc9OlEVQp2uOvRXa1Qu30fLmKhY6NipA==}
-    dependencies:
-      readable-stream: 1.0.34
-    dev: true
-
   /memorystream@0.3.1:
     resolution: {integrity: sha512-S3UwM3yj5mtUSEfP41UZmt/0SCoVYUcU1rkXv+BQ5Ig8ndL4sPoJNBUJERafdPb5jjHJGuMgytgKvKIf58XNBw==}
     engines: {node: '>= 0.10.0'}
     dev: true
 
-  /meow@11.0.0(typescript@5.0.4):
-    resolution: {integrity: sha512-Cl0yeeIrko6d94KpUo1M+0X1sB14ikoaqlIGuTH1fW4I+E3+YljL54/hb/BWmVfrV9tTV9zU04+xjw08Fh2WkA==}
-    engines: {node: '>=14.16'}
-    dependencies:
-      '@types/minimist': 1.2.2
-      camelcase-keys: 8.0.2
-      decamelize: 6.0.0
-      decamelize-keys: 1.1.1
-      hard-rejection: 2.1.0
-      minimist-options: 4.1.0
-      normalize-package-data: 4.0.1
-      read-pkg-up: 9.1.0
-      redent: 4.0.0
-      trim-newlines: 4.1.1
-      type-fest: 3.10.0(typescript@5.0.4)
-      yargs-parser: 21.1.1
-    transitivePeerDependencies:
-      - typescript
+  /meow@12.1.1:
+    resolution: {integrity: sha512-BhXM0Au22RwUneMPwSCnyhTOizdWoIEPU9sp0Aqa1PnDMR5Wv2FGXYDjuzJEIX+Eo2Rb8xuYe5jrnm5QowQFkw==}
+    engines: {node: '>=16.10'}
     dev: true
 
   /meow@9.0.0:
@@ -9966,15 +9451,6 @@ packages:
   /merge-stream@2.0.0:
     resolution: {integrity: sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==}
 
-  /merge-trees@2.0.0:
-    resolution: {integrity: sha512-5xBbmqYBalWqmhYm51XlohhkmVOua3VAUrrWh8t9iOkaLpS6ifqm/UVuUjQCeDVJ9Vx3g2l6ihfkbLSTeKsHbw==}
-    dependencies:
-      fs-updater: 1.0.4
-      heimdalljs: 0.2.6
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /merge2@1.4.1:
     resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
     engines: {node: '>= 8'}
@@ -10142,7 +9618,7 @@ packages:
   /micromark@3.2.0:
     resolution: {integrity: sha512-uD66tJj54JLYq0De10AhWycZWGQNUvDI55xPgk2sQM5kn1JYlhbCMTtEeT27+vAhW2FBQxLlOmS3pmA7/2z4aA==}
     dependencies:
-      '@types/debug': 4.1.9
+      '@types/debug': 4.1.10
       debug: 4.3.4(supports-color@8.1.1)
       decode-named-character-reference: 1.0.2
       micromark-core-commonmark: 1.1.0
@@ -10163,27 +9639,6 @@ packages:
       - supports-color
     dev: true
 
-  /micromatch@3.1.10:
-    resolution: {integrity: sha512-MWikgl9n9M3w+bpsY3He8L+w9eF9338xRl8IAO5viDizwSzziFEyUzo2xrrloB64ADbTf8uA8vRqqttDTOmccg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      arr-diff: 4.0.0
-      array-unique: 0.3.2
-      braces: 2.3.2
-      define-property: 2.0.2
-      extend-shallow: 3.0.2
-      extglob: 2.0.4
-      fragment-cache: 0.2.1
-      kind-of: 6.0.3
-      nanomatch: 1.2.13
-      object.pick: 1.3.0
-      regex-not: 1.0.2
-      snapdragon: 0.8.2
-      to-regex: 3.0.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /micromatch@4.0.5:
     resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==}
     engines: {node: '>=8.6'}
@@ -10204,17 +9659,12 @@ packages:
   /mime@1.6.0:
     resolution: {integrity: sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==}
     engines: {node: '>=4'}
-    hasBin: true
-    dev: true
-
-  /mimic-fn@1.2.0:
-    resolution: {integrity: sha512-jf84uxzwiuiIVKiOLpfYk7N46TSy8ubTonmneY9vrpHNAnp0QBt2BxWV9dO3/j+BoVAb+a5G6YDPW3M5HOdMWQ==}
-    engines: {node: '>=4'}
     dev: true
 
   /mimic-fn@2.1.0:
     resolution: {integrity: sha512-OqbOk5oEQeAZ8WXWydlu9HJjz9WVdEIvamMCcXmuqUYjTknH/sqsWvhQ3vgwKFRR1HpjvNBKQ37nbJgYzGqGcg==}
     engines: {node: '>=6'}
+    dev: true
 
   /mimic-fn@4.0.0:
     resolution: {integrity: sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==}
@@ -10257,19 +9707,21 @@ packages:
     engines: {node: '>=10'}
     dependencies:
       brace-expansion: 2.0.1
+    dev: false
 
-  /minimatch@7.4.6:
-    resolution: {integrity: sha512-sBz8G/YjVniEz6lKPNpKxXwazJe4c19fEfV2GDMX6AjFz+MX9uDWIZW8XreVhkFW3fkIdTv/gxWr/Kks5FFAVw==}
-    engines: {node: '>=10'}
+  /minimatch@9.0.0:
+    resolution: {integrity: sha512-0jJj8AvgKqWN05mrwuqi8QYKx1WmYSUoKSxu5Qhs9prezTz10sxAHGNZe9J9cqIJzta8DWsleh2KaVaLl6Ru2w==}
+    engines: {node: '>=16 || 14 >=14.17'}
     dependencies:
       brace-expansion: 2.0.1
-    dev: true
+    dev: false
 
-  /minimatch@9.0.0:
-    resolution: {integrity: sha512-0jJj8AvgKqWN05mrwuqi8QYKx1WmYSUoKSxu5Qhs9prezTz10sxAHGNZe9J9cqIJzta8DWsleh2KaVaLl6Ru2w==}
+  /minimatch@9.0.3:
+    resolution: {integrity: sha512-RHiac9mvaRw0x3AYRgDC1CxAP7HTcNrrECeA8YYJeWnpo+2Q5CegtZjaotWTWxDG3UeGA1coE05iH1mPjT/2mg==}
     engines: {node: '>=16 || 14 >=14.17'}
     dependencies:
       brace-expansion: 2.0.1
+    dev: true
 
   /minimist-options@4.1.0:
     resolution: {integrity: sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==}
@@ -10280,10 +9732,6 @@ packages:
       kind-of: 6.0.3
     dev: true
 
-  /minimist@0.2.4:
-    resolution: {integrity: sha512-Pkrrm8NjyQ8yVt8Am9M+yUt74zE3iokhzbG1bFVNjLB92vwM71hf40RkEsryg98BujhVOncKm/C1xROxZ030LQ==}
-    dev: true
-
   /minimist@1.2.8:
     resolution: {integrity: sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==}
 
@@ -10354,46 +9802,28 @@ packages:
 
   /mitt@3.0.0:
     resolution: {integrity: sha512-7dX2/10ITVyqh4aOSVI9gdape+t9l2/8QxHrFmUXu4EEUpdlxl6RudZUPZoc+zuY2hk1j7XxVroIVIan/pD/SQ==}
+    dev: false
 
-  /mixin-deep@1.3.2:
-    resolution: {integrity: sha512-WRoDn//mXBiJ1H40rqa3vH0toePwSsGb45iInWlTySa+Uu4k3tYUSxa2v1KqAiLtvlrSzaExqS1gtk96A9zvEA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      for-in: 1.0.2
-      is-extendable: 1.0.1
+  /mitt@3.0.1:
+    resolution: {integrity: sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==}
     dev: true
 
   /mkdirp-classic@0.5.3:
     resolution: {integrity: sha512-gKLcREMhtuZRwRAfqP3RFW+TK4JqApVBtOIftVgjuABpAtpxhPGaDcfvbhNvD0B8iD1oUr/txX35NjcaY6Ns/A==}
 
-  /mkdirp@0.5.6:
-    resolution: {integrity: sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==}
-    hasBin: true
-    dependencies:
-      minimist: 1.2.8
-    dev: true
-
   /mkdirp@1.0.4:
     resolution: {integrity: sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==}
     engines: {node: '>=10'}
-    hasBin: true
     dev: true
 
   /mkdirp@3.0.1:
     resolution: {integrity: sha512-+NsyUUAZDmo6YVHzL/stxSu3t9YS1iljliy3BSDrXJ/dkn1KYdmtZODGGjLcc9XLgVVpH4KshHB8XmZgMhaBXg==}
     engines: {node: '>=10'}
-    hasBin: true
-    dev: true
-
-  /mktemp@0.4.0:
-    resolution: {integrity: sha512-IXnMcJ6ZyTuhRmJSjzvHSRhlVPiN9Jwc6e59V0bEJ0ba6OBeX2L0E+mRN1QseeOF4mM+F1Rit6Nh7o+rl2Yn/A==}
-    engines: {node: '>0.9'}
     dev: true
 
   /mocha@10.2.0:
     resolution: {integrity: sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==}
     engines: {node: '>= 14.0.0'}
-    hasBin: true
     dependencies:
       ansi-colors: 4.1.1
       browser-stdout: 1.3.1
@@ -10418,23 +9848,6 @@ packages:
       yargs-unparser: 2.0.0
     dev: true
 
-  /morgan@1.10.0:
-    resolution: {integrity: sha512-AbegBVI4sh6El+1gNwvD5YIck7nSA36weD7xvIxG4in80j/UoK8AEGaWnnz8v1GxonMCltmlNs5ZKbGvl9b1XQ==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      basic-auth: 2.0.1
-      debug: 2.6.9
-      depd: 2.0.0
-      on-finished: 2.3.0
-      on-headers: 1.0.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /mout@1.2.4:
-    resolution: {integrity: sha512-mZb9uOruMWgn/fw28DG4/yE3Kehfk1zKCLhuDU2O3vlKdnBBr4XaOCqVTflJ5aODavGUPqFHZgrFX3NJVuxGhQ==}
-    dev: true
-
   /mri@1.2.0:
     resolution: {integrity: sha512-tzzskb3bG8LvYGFF/mDTpq3jpI6Q9wc3LEmBaghu+DdCssd1FakN7Bc0hVNmEyGq1bq3RgfkCb3cmQLpNPOroA==}
     engines: {node: '>=4'}
@@ -10452,15 +9865,6 @@ packages:
 
   /mustache@4.2.0:
     resolution: {integrity: sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==}
-    hasBin: true
-    dev: true
-
-  /mute-stream@0.0.7:
-    resolution: {integrity: sha512-r65nCZhrbXXb6dXOACihYApHw2Q6pV0M3V0PSxd74N0+D8nzAdEAITq2oAjA1jVnKI+tGvEBUpqiMh0+rW6zDQ==}
-    dev: true
-
-  /mute-stream@0.0.8:
-    resolution: {integrity: sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==}
     dev: true
 
   /mute-stream@1.0.0:
@@ -10479,7 +9883,6 @@ packages:
   /nanoid@3.3.3:
     resolution: {integrity: sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==}
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
-    hasBin: true
     dev: true
 
   /nanoid@3.3.6:
@@ -10487,28 +9890,6 @@ packages:
     engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
     hasBin: true
 
-  /nanomatch@1.2.13:
-    resolution: {integrity: sha512-fpoe2T0RbHwBTBUOftAfBPaDEi06ufaUai0mE6Yn1kacc3SnTErfb/h+X94VXzI64rKFHYImXSvdwGGCmwOqCA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      arr-diff: 4.0.0
-      array-unique: 0.3.2
-      define-property: 2.0.2
-      extend-shallow: 3.0.2
-      fragment-cache: 0.2.1
-      is-windows: 1.0.2
-      kind-of: 6.0.3
-      object.pick: 1.3.0
-      regex-not: 1.0.2
-      snapdragon: 0.8.2
-      to-regex: 3.0.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /natural-compare-lite@1.4.0:
-    resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==}
-
   /natural-compare@1.4.0:
     resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
 
@@ -10541,8 +9922,8 @@ packages:
     engines: {node: '>=10.5.0'}
     dev: true
 
-  /node-fetch@2.6.7:
-    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}
+  /node-fetch@2.6.12:
+    resolution: {integrity: sha512-C/fGU2E8ToujUivIO0H+tpQ6HWo4eEmchoPIoXtxCrVghxdKq+QOHqEZW7tuP3KlV3bC8FRMO5nMCC7Zm1VP6g==}
     engines: {node: 4.x || >=6.0.0}
     peerDependencies:
       encoding: ^0.1.0
@@ -10551,9 +9932,10 @@ packages:
         optional: true
     dependencies:
       whatwg-url: 5.0.0
+    dev: true
 
-  /node-fetch@2.7.0:
-    resolution: {integrity: sha512-c4FRfUm/dbcWZ7U+1Wq0AwCyFL+3nt2bEw05wfxSz+DWpWsitgmSgYmy2dQdWyKC1694ELPqMs/YzUSNozLt8A==}
+  /node-fetch@2.6.7:
+    resolution: {integrity: sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==}
     engines: {node: 4.x || >=6.0.0}
     peerDependencies:
       encoding: ^0.1.0
@@ -10562,7 +9944,7 @@ packages:
         optional: true
     dependencies:
       whatwg-url: 5.0.0
-    dev: true
+    dev: false
 
   /node-fetch@3.3.2:
     resolution: {integrity: sha512-dRB78srN/l6gqWulah9SrxeYnxeddIG30+GOqK/9OlLVyLg3HPnr6SqOWTWOXKRwC2eGYCkZ59NNuSgvSrpgOA==}
@@ -10573,14 +9955,6 @@ packages:
       formdata-polyfill: 4.0.10
     dev: true
 
-  /node-int64@0.4.0:
-    resolution: {integrity: sha512-O5lz91xSOeoXP6DulyHfllpq+Eg00MWitZIbtPfoSEvqIHdl5gfcY6hYzDWnj0qD5tz52PI08u9qUvSVeUBeHw==}
-    dev: true
-
-  /node-modules-path@1.0.2:
-    resolution: {integrity: sha512-6Gbjq+d7uhkO7epaKi5DNgUJn7H0gEyA4Jg0Mo1uQOi3Rk50G83LtmhhFyw0LxnAFhtlspkiiw52ISP13qzcBg==}
-    dev: true
-
   /node-notifier@10.0.1:
     resolution: {integrity: sha512-YX7TSyDukOZ0g+gmzjB6abKu+hTGvO8+8+gIFDsRCU2t8fLV/P2unmt+LGFaIa4y64aX98Qksa97rgz4vMNeLQ==}
     dependencies:
@@ -10599,19 +9973,12 @@ packages:
     resolution: {integrity: sha512-3l4E8uMPY1HdMMryPRUAl+oIHtXtyiTlIiESNSVSNxcPfzAFzeTbXFQkZfAwBbo0B1qMSG8nUABx+Gd+YrbKrQ==}
     engines: {node: '>=6'}
 
-  /nopt@3.0.6:
-    resolution: {integrity: sha512-4GUt3kSEYmk4ITxzB/b9vaIDfUVWN/Ml1Fwl11IlnIG2iaJ9O6WXZ9SrYM9NLI8OCBieN2Y8SWC2oJV0RQ7qYg==}
-    hasBin: true
-    dependencies:
-      abbrev: 1.1.1
-    dev: true
-
   /normalize-package-data@2.5.0:
     resolution: {integrity: sha512-/5CMN3T0R4XTj4DcGaexo+roZSdSFW/0AOOTROrjxzCG1wrWXEsGbRKevjlIL+ZDE4sZlJr5ED4YW0yqmkK+eA==}
     dependencies:
       hosted-git-info: 2.8.9
-      resolve: 1.22.8
-      semver: 5.7.2
+      resolve: 1.22.4
+      semver: 5.7.1
       validate-npm-package-license: 3.0.4
     dev: true
 
@@ -10625,23 +9992,6 @@ packages:
       validate-npm-package-license: 3.0.4
     dev: true
 
-  /normalize-package-data@4.0.1:
-    resolution: {integrity: sha512-EBk5QKKuocMJhB3BILuKhmaPjI8vNRSpIfO9woLC6NyHVkKKdVEdAO1mrT0ZfxNR1lKwCcTkuZfmGIFdizZ8Pg==}
-    engines: {node: ^12.13.0 || ^14.15.0 || >=16.0.0}
-    dependencies:
-      hosted-git-info: 5.2.1
-      is-core-module: 2.13.0
-      semver: 7.5.4
-      validate-npm-package-license: 3.0.4
-    dev: true
-
-  /normalize-path@2.1.1:
-    resolution: {integrity: sha512-3pKJwH184Xo/lnH6oyP1q2pMd7HcypqqmRs91/6/i2CGtWwIKGCkOOMTm/zXbgTEWHw1uNpNi/igc3ePOYHb6w==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      remove-trailing-separator: 1.1.0
-    dev: true
-
   /normalize-path@3.0.0:
     resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
     engines: {node: '>=0.10.0'}
@@ -10661,20 +10011,9 @@ packages:
     engines: {node: '>=14.16'}
     dev: true
 
-  /npm-package-arg@10.1.0:
-    resolution: {integrity: sha512-uFyyCEmgBfZTtrKk/5xDfHp6+MdrqGotX/VoOyEEl3mBwiEE5FlBaePanazJSVMPT7vKepcjYBY2ztg9A3yPIA==}
-    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
-    dependencies:
-      hosted-git-info: 6.1.1
-      proc-log: 3.0.0
-      semver: 7.5.4
-      validate-npm-package-name: 5.0.0
-    dev: true
-
   /npm-run-all@4.1.5:
     resolution: {integrity: sha512-Oo82gJDAVcaMdi3nuoKFavkIHBRVqQ1qvMb+9LHk/cF4P6B2m8aP04hGf7oL6wZ9BuGwX1onlLhpuoofSyoQDQ==}
     engines: {node: '>= 4'}
-    hasBin: true
     dependencies:
       ansi-styles: 3.2.1
       chalk: 2.4.2
@@ -10699,6 +10038,7 @@ packages:
     engines: {node: '>=8'}
     dependencies:
       path-key: 3.1.1
+    dev: true
 
   /npm-run-path@5.1.0:
     resolution: {integrity: sha512-sJOdmRGrY2sjNTRMbSvluQqg+8X7ZK61yvzBEIDhz4f8z1TZFYABsqjjCBd/0PUNE9M6QDgHJXQkGUEm7Q+l9Q==}
@@ -10732,15 +10072,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /object-copy@0.1.0:
-    resolution: {integrity: sha512-79LYn6VAb63zgtmAteVOWo9Vdj71ZVBy3Pbse+VqxDpEP83XuujMrGqHIwAXJ5I/aM0zU7dIyIAhifVTPrNItQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      copy-descriptor: 0.1.1
-      define-property: 0.2.5
-      kind-of: 3.2.2
-    dev: true
-
   /object-hash@1.3.1:
     resolution: {integrity: sha512-OSuu/pU4ENM9kmREg0BdNrUDIl1heYa4mBZacJc+vVWz4GtAwu7jO8s4AIt2aGRUTqxykpWzI3Oqnsm13tTMDA==}
     engines: {node: '>= 0.10.0'}
@@ -10749,6 +10080,9 @@ packages:
   /object-inspect@1.12.3:
     resolution: {integrity: sha512-geUvdk7c+eizMNUDkRpW1wJwgfOiOeHbxBR/hLXK1aT6zmVSO0jsQcs7fj6MGw89jC/cjGfLcNOrtMYtGqm81g==}
 
+  /object-inspect@1.13.1:
+    resolution: {integrity: sha512-5qoj1RUiKOMsCCNLV1CBiPYE10sziTsnmNxkAI/rZhiD63CF7IqdFGC/XzjWjpSgLf0LxXX3bDFIh0E18f6UhQ==}
+
   /object-keys@1.1.1:
     resolution: {integrity: sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==}
     engines: {node: '>= 0.4'}
@@ -10758,43 +10092,40 @@ packages:
     engines: {node: '>= 10.12.0'}
     dev: false
 
-  /object-visit@1.0.1:
-    resolution: {integrity: sha512-GBaMwwAVK9qbQN3Scdo0OyvgPW7l3lnaVMj84uTOZlswkX0KpF6fyDBJhtTthf7pymztoN36/KEr1DyhF96zEA==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      isobject: 3.0.1
-    dev: true
-
   /object.assign@4.1.4:
     resolution: {integrity: sha512-1mxKf0e58bvyjSCtKYY4sRe9itRk3PJpquJOjeIkz885CczcI4IvJJDLPS72oowuSh+pBxUFROpX+TU++hxhZQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
+      call-bind: 1.0.5
+      define-properties: 1.2.0
       has-symbols: 1.0.3
       object-keys: 1.1.1
 
-  /object.pick@1.3.0:
-    resolution: {integrity: sha512-tqa/UMy/CCoYmj+H5qc07qvSL9dqcs/WZENZ1JbtWBlATP+iVOe778gE6MSijnyCnORzDuX6hU+LA4SZ09YjFQ==}
-    engines: {node: '>=0.10.0'}
+  /object.fromentries@2.0.6:
+    resolution: {integrity: sha512-VciD13dswC4j1Xt5394WR4MzmAQmlgN72phd/riNp9vtD7tp4QQWJ0R4wvclXcafgcYK8veHRed2W6XeGBvcfg==}
+    engines: {node: '>= 0.4'}
     dependencies:
-      isobject: 3.0.1
-    dev: true
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+    dev: false
+
+  /object.groupby@1.0.0:
+    resolution: {integrity: sha512-70MWG6NfRH9GnbZOikuhPPYzpUpof9iW2J9E4dW7FXTqPNb6rllE6u39SKwwiNh8lCwX3DDb5OgcKGiEBrTTyw==}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+      get-intrinsic: 1.2.2
+    dev: false
 
   /object.values@1.1.6:
     resolution: {integrity: sha512-FVVTkD1vENCsAcwNs9k6jea2uHC/X0+JcjG8YA60FN5CMaJmG95wT9jek/xX9nornqGRrBkKtzuAu2wuHpKqvw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
-
-  /on-finished@2.3.0:
-    resolution: {integrity: sha512-ikqdkGAAyf/X/gPhXGvfgAytDZtDbr+bkNUJ0N9h5MI/dmdgCs3l6hoHrcUv41sRKew3jIwrp4qQDXiK99Utww==}
-    engines: {node: '>= 0.8'}
-    dependencies:
-      ee-first: 1.1.1
-    dev: true
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
 
   /on-finished@2.4.1:
     resolution: {integrity: sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==}
@@ -10813,18 +10144,12 @@ packages:
     dependencies:
       wrappy: 1.0.2
 
-  /onetime@2.0.1:
-    resolution: {integrity: sha512-oyyPpiMaKARvvcgip+JV+7zci5L8D1W9RZIz2l1o08AM3pfspitVWnPt3mzHcBPp12oYMTy0pqrFs/C+m3EwsQ==}
-    engines: {node: '>=4'}
-    dependencies:
-      mimic-fn: 1.2.0
-    dev: true
-
   /onetime@5.1.2:
     resolution: {integrity: sha512-kbpaSSGJTWdAY5KPVeMOKXSrPtr8C8C7wodJbcsd51jRnmD+GZu8Y0VoU6Dm5Z4vWr0Ig/1NKuWRKf7j5aaYSg==}
     engines: {node: '>=6'}
     dependencies:
       mimic-fn: 2.1.0
+    dev: true
 
   /onetime@6.0.0:
     resolution: {integrity: sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==}
@@ -10859,29 +10184,18 @@ packages:
       define-lazy-prop: 3.0.0
       is-inside-container: 1.0.0
       is-wsl: 2.2.0
+    dev: true
 
-  /optionator@0.9.1:
-    resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==}
+  /optionator@0.9.3:
+    resolution: {integrity: sha512-JjCoypp+jKn1ttEFExxhetCKeJt9zhAgAve5FXHixTvFDW/5aEktX9bufBKLRRMdU7bNtpLfcGu94B3cdEJgjg==}
     engines: {node: '>= 0.8.0'}
     dependencies:
+      '@aashutoshrathi/word-wrap': 1.2.6
       deep-is: 0.1.4
       fast-levenshtein: 2.0.6
       levn: 0.4.1
       prelude-ls: 1.2.1
       type-check: 0.4.0
-      word-wrap: 1.2.3
-
-  /ora@3.4.0:
-    resolution: {integrity: sha512-eNwHudNbO1folBP3JsZ19v9azXWtQZjICdr3Q0TDPIaeBQ3mXLrh54wM+er0+hSp+dWKf+Z8KM58CYzEyIYxYg==}
-    engines: {node: '>=6'}
-    dependencies:
-      chalk: 2.4.2
-      cli-cursor: 2.1.0
-      cli-spinners: 2.9.1
-      log-symbols: 2.2.0
-      strip-ansi: 5.2.0
-      wcwidth: 1.0.1
-    dev: true
 
   /ora@5.4.1:
     resolution: {integrity: sha512-5b6Y85tPxZZ7QytO+BQzysW31HJku27cRIlkbAXaNx+BdcVi+LlRFmVXzeF6a7JCwJpyw5c4b+YSVImQIrBpuQ==}
@@ -10913,20 +10227,6 @@ packages:
       strip-ansi: 7.1.0
     dev: true
 
-  /os-homedir@1.0.2:
-    resolution: {integrity: sha512-B5JU3cabzk8c67mRRd3ECmROafjYMXbuzlwtqdM8IbS8ktlTix8aFGb2bAGKrSRIlnfKwovGUUr72JUPyOb6kQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /os-locale@5.0.0:
-    resolution: {integrity: sha512-tqZcNEDAIZKBEPnHPlVDvKrp7NzgLi7jRmhKiUoa2NUmhl13FtkAGLUVR+ZsYvApBQdBfYm43A4tXXQ4IrYLBA==}
-    engines: {node: '>=10'}
-    dependencies:
-      execa: 4.1.0
-      lcid: 3.1.1
-      mem: 5.1.1
-    dev: true
-
   /os-name@5.1.0:
     resolution: {integrity: sha512-YEIoAnM6zFmzw3PQ201gCVCIWbXNyKObGlVvpAVvraAeOHnlYVKFssbA/riRX5R40WA6kKrZ7Dr7dWzO3nKSeQ==}
     engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
@@ -10940,13 +10240,6 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /osenv@0.1.5:
-    resolution: {integrity: sha512-0CWcCECdMVc2Rw3U5w9ZjqX6ga6ubk1xDVKxtBQPK7wis/0F2r9T6k4ydGYhecl7YUBxBVxhL5oisPsNxAPe2g==}
-    dependencies:
-      os-homedir: 1.0.2
-      os-tmpdir: 1.0.2
-    dev: true
-
   /p-cancelable@1.1.0:
     resolution: {integrity: sha512-s73XxOZ4zpt1edZYZzvhqFa6uvQc1vwUa0K0BdtIZgQMAJj9IbebH+JkgKZc9h+B05PKHLOTl4ajG1BmNrVZlw==}
     engines: {node: '>=6'}
@@ -10957,25 +10250,10 @@ packages:
     engines: {node: '>=12.20'}
     dev: true
 
-  /p-defer@1.0.0:
-    resolution: {integrity: sha512-wB3wfAxZpk2AzOfUMJNL+d36xothRSyj8EXOa4f6GMqYDN9BJaaSISbsk+wS9abmnebVw95C2Kb5t85UmpCxuw==}
-    engines: {node: '>=4'}
-    dev: true
-
-  /p-defer@3.0.0:
-    resolution: {integrity: sha512-ugZxsxmtTln604yeYd29EGrNhazN2lywetzpKhfmQjW/VJmhpDmWbiX+h0zL8V91R0UXkhb3KtPmyq9PZw3aYw==}
-    engines: {node: '>=8'}
-    dev: true
-
   /p-finally@1.0.0:
     resolution: {integrity: sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow==}
     engines: {node: '>=4'}
 
-  /p-is-promise@2.1.0:
-    resolution: {integrity: sha512-Y3W0wlRPK8ZMRbNq97l4M5otioeA5lm1z7bkNkxCka8HSPjR0xRWmpCmc9utiaLP9Jb1eD8BgeIxTW4AIF45Pg==}
-    engines: {node: '>=6'}
-    dev: true
-
   /p-limit@2.3.0:
     resolution: {integrity: sha512-//88mFWSJx8lxCzwdAABTJL2MyWB12+eIY7MDL2SqLmAkeKU9qxRvWuSyTjm3FUmpBEMuFfckAIqEaVGUDxb6w==}
     engines: {node: '>=6'}
@@ -11064,7 +10342,7 @@ packages:
       '@tootallnate/quickjs-emscripten': 0.23.0
       agent-base: 7.1.0
       debug: 4.3.4(supports-color@8.1.1)
-      get-uri: 6.0.2
+      get-uri: 6.0.1
       http-proxy-agent: 7.0.0
       https-proxy-agent: 7.0.2
       pac-resolver: 7.0.0
@@ -11120,16 +10398,11 @@ packages:
     resolution: {integrity: sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==}
     engines: {node: '>=8'}
     dependencies:
-      '@babel/code-frame': 7.22.13
+      '@babel/code-frame': 7.22.10
       error-ex: 1.3.2
       json-parse-even-better-errors: 2.3.1
       lines-and-columns: 1.2.4
 
-  /parse-passwd@1.0.0:
-    resolution: {integrity: sha512-1Y1A//QUXEZK7YKz+rD9WydcE1+EuPr6ZBgKecAB8tmoW6UFv0NREVJe1p+jRxtThkcbbKkfwIbWJe/IeE6m2Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /parse-path@7.0.0:
     resolution: {integrity: sha512-Euf9GG8WT9CdqwuWJGdf3RkUcTBArppHABkO7Lm8IzRQp0e2r/kkFnmhu4TSK30Wcu5rVAZLmfPKSBBi9tWFog==}
     dependencies:
@@ -11161,11 +10434,6 @@ packages:
     engines: {node: '>= 0.8'}
     dev: true
 
-  /pascalcase@0.1.1:
-    resolution: {integrity: sha512-XHXfu/yOQRy9vYOtUDVMN60OEJjW013GoObG1o+xwQTpB9eYJX/BjXMsdW13ZDPruFhYYn0AG22w0xgQMwl3Nw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /path-exists@3.0.0:
     resolution: {integrity: sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==}
     engines: {node: '>=4'}
@@ -11200,10 +10468,6 @@ packages:
   /path-parse@1.0.7:
     resolution: {integrity: sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==}
 
-  /path-posix@1.0.0:
-    resolution: {integrity: sha512-1gJ0WpNIiYcQydgg3Ed8KzvIqTsDpNwq+cjBCssvBtuTWjEqY1AW+i+OepiEMqDCzyro9B2sLAe4RBPajMYFiA==}
-    dev: true
-
   /path-root-regex@0.1.2:
     resolution: {integrity: sha512-4GlJ6rZDhQZFE0DPVKh0e9jmZ5egZfxTkp7bcRDuPlJXbAwhxcl2dINPUAsjLdejqaLsCeg8axcLjIbvBjN4pQ==}
     engines: {node: '>=0.10.0'}
@@ -11216,12 +10480,21 @@ packages:
       path-root-regex: 0.1.2
     dev: true
 
+  /path-scurry@1.10.1:
+    resolution: {integrity: sha512-MkhCqzzBEpPvxxQ71Md0b1Kk51W01lrYvlMzSUaIzNsODdd7mqhiimSZlr+VegAz5Z6Vzt9Xg2ttE//XBhH3EQ==}
+    engines: {node: '>=16 || 14 >=14.17'}
+    dependencies:
+      lru-cache: 9.1.1
+      minipass: 5.0.0
+    dev: true
+
   /path-scurry@1.7.0:
     resolution: {integrity: sha512-UkZUeDjczjYRE495+9thsgcVgsaCPkaw80slmfVFgllxY+IO8ubTsOpFVjDPROBqJdHfVPUFRHPBV/WciOVfWg==}
     engines: {node: '>=16 || 14 >=14.17'}
     dependencies:
       lru-cache: 9.1.1
       minipass: 5.0.0
+    dev: false
 
   /path-to-regexp@0.1.7:
     resolution: {integrity: sha512-5DFkuoqlv1uYQKxy8omFBeJPQcdoE07Kv2sferDCrAq1ohOU+MSDswDIbnx3YAM60qIOnYa53wBhXW0EbMonrQ==}
@@ -11257,7 +10530,6 @@ packages:
   /pidtree@0.3.1:
     resolution: {integrity: sha512-qQbW94hLHEqCg7nhby4yRC7G2+jYHY4Rguc2bjw7Uug4GIJuu1tvf2uHaZv5Q8zdt+WKJ6qK1FOI6amaWUo5FA==}
     engines: {node: '>=0.10'}
-    hasBin: true
     dev: true
 
   /pify@3.0.0:
@@ -11270,18 +10542,6 @@ packages:
     engines: {node: '>=10'}
     dev: false
 
-  /pinkie-promise@2.0.1:
-    resolution: {integrity: sha512-0Gni6D4UcLTbv9c57DfxDGdr41XfgUjqWZu492f0cIGr16zDU06BWP/RAEvOuo7CQ0CNjHaLlM59YJJFm3NWlw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      pinkie: 2.0.4
-    dev: true
-
-  /pinkie@2.0.4:
-    resolution: {integrity: sha512-MnUuEycAemtSaeFSjXKW/aroV7akBbY+Sv+RkyqFjgAe73F+MR0TBWKBRDkmfWq/HiFmdavfZ1G7h4SPZXaCSg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /pkg-dir@5.0.0:
     resolution: {integrity: sha512-NPE8TDbzl/3YQYY7CSS228s3g2ollTFnc+Qi3tqmqJp9Vg2ovUpixcJEo2HJScN2Ez+kEaal6y70c0ehqJBJeA==}
     engines: {node: '>=10'}
@@ -11315,22 +10575,6 @@ packages:
     engines: {node: '>=4'}
     dev: true
 
-  /portfinder@1.0.32:
-    resolution: {integrity: sha512-on2ZJVVDXRADWE6jnQaX0ioEylzgBpQk8r55NE4wjXW1ZxO+BgDlY6DXwj20i0V8eB4SenDQ00WEaxfiIQPcxg==}
-    engines: {node: '>= 0.12.0'}
-    dependencies:
-      async: 2.6.4
-      debug: 3.2.7
-      mkdirp: 0.5.6
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /posix-character-classes@0.1.1:
-    resolution: {integrity: sha512-xTgYBc3fuo7Yt7JbiuFxSYGToMoz8fLoE6TC9Wx1P/u+LfeThMOAqmuyECnlBaaJb+u1m9hHiXUEtwW4OzfUJg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /postcss-calc@8.2.4(postcss@8.4.31):
     resolution: {integrity: sha512-SmWMSJmB8MRnnULldx0lQIyhSNvuDl9HfrZkaqqE/WHAhToYsAvDq+yAsA/kIyINDszOp3Rh0GFoNuH5Ypsm3Q==}
     peerDependencies:
@@ -11347,7 +10591,7 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       caniuse-api: 3.0.0
       colord: 2.9.3
       postcss: 8.4.31
@@ -11360,7 +10604,7 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       postcss: 8.4.31
       postcss-value-parser: 4.2.0
     dev: false
@@ -11415,7 +10659,7 @@ packages:
     dependencies:
       lilconfig: 2.1.0
       postcss: 8.4.31
-      ts-node: 10.9.1(@types/node@18.16.6)(typescript@5.0.4)
+      ts-node: 10.9.1(@types/node@20.8.10)(typescript@5.2.2)
       yaml: 1.10.2
     dev: false
 
@@ -11436,7 +10680,7 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       caniuse-api: 3.0.0
       cssnano-utils: 3.1.0(postcss@8.4.31)
       postcss: 8.4.31
@@ -11471,7 +10715,7 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       cssnano-utils: 3.1.0(postcss@8.4.31)
       postcss: 8.4.31
       postcss-value-parser: 4.2.0
@@ -11609,7 +10853,7 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       postcss: 8.4.31
       postcss-value-parser: 4.2.0
     dev: false
@@ -11652,7 +10896,7 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       caniuse-api: 3.0.0
       postcss: 8.4.31
     dev: false
@@ -11700,6 +10944,15 @@ packages:
     resolution: {integrity: sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==}
     dev: false
 
+  /postcss@8.4.23:
+    resolution: {integrity: sha512-bQ3qMcpF6A/YjR55xtoTr0jGOlnPOKAIMdOWiv0EIT6HVPEaJiJB4NLljSbiHoC2RX7DN5Uvjtpbg1NPdwv1oA==}
+    engines: {node: ^10 || ^12 || >=14}
+    dependencies:
+      nanoid: 3.3.6
+      picocolors: 1.0.0
+      source-map-js: 1.0.2
+    dev: true
+
   /postcss@8.4.31:
     resolution: {integrity: sha512-PS08Iboia9mts/2ygV3eLpY5ghnUcfLV/EXTOW1E2qYxJKGGBUtNjN76FYHnMs36RmARn41bC0AZmn+rR0OVpQ==}
     engines: {node: ^10 || ^12 || >=14}
@@ -11723,34 +10976,39 @@ packages:
     dependencies:
       fast-diff: 1.2.0
 
+  /prettier-plugin-organize-imports@3.2.3(prettier@3.0.3)(typescript@5.2.2):
+    resolution: {integrity: sha512-KFvk8C/zGyvUaE3RvxN2MhCLwzV6OBbFSkwZ2OamCrs9ZY4i5L77jQ/w4UmUr+lqX8qbaqVq6bZZkApn+IgJSg==}
+    peerDependencies:
+      '@volar/vue-language-plugin-pug': ^1.0.4
+      '@volar/vue-typescript': ^1.0.4
+      prettier: '>=2.0'
+      typescript: ^5.2.2 || 5
+    peerDependenciesMeta:
+      '@volar/vue-language-plugin-pug':
+        optional: true
+      '@volar/vue-typescript':
+        optional: true
+    dependencies:
+      prettier: 3.0.3
+      typescript: 5.2.2
+    dev: true
+
   /prettier@2.8.8:
     resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
     engines: {node: '>=10.13.0'}
     hasBin: true
-
-  /preval.macro@5.0.0:
-    resolution: {integrity: sha512-+OZRqZYx1pjZ7H5Jis8bPFXkiT7lwA46UzAT4IjuzFVKwkJK+TwIx1TCqrqNCf8U3e5O12mEJEz1BXslkCLWfQ==}
-    engines: {node: '>=10'}
-    dependencies:
-      babel-plugin-preval: 5.1.0
     dev: true
 
+  /prettier@3.0.3:
+    resolution: {integrity: sha512-L/4pUDMxcNa8R/EthV08Zt42WBO4h1rarVtK0K+QJG0X187OLo7l699jWw0GKuwzkPQ//jMFA/8Xm6Fh3J/DAg==}
+    engines: {node: '>=14'}
+    hasBin: true
+
   /printf@0.6.1:
     resolution: {integrity: sha512-is0ctgGdPJ5951KulgfzvHGwJtZ5ck8l042vRkV6jrkpBzTmb/lueTqguWHy2JfVA+RY6gFVlaZgUS0j7S/dsw==}
     engines: {node: '>= 0.9.0'}
     dev: true
 
-  /proc-log@3.0.0:
-    resolution: {integrity: sha512-++Vn7NS4Xf9NacaU9Xq3URUuqZETPsf8L4j5/ckhaRYsfPeRyzGw+iDjFhV/Jr3uNmTvvddEJFWh5R1gRgUH8A==}
-    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
-    dev: true
-
-  /process-relative-require@1.0.0:
-    resolution: {integrity: sha512-r8G5WJPozMJAiv8sDdVWKgJ4In/zBXqwJdMCGAXQt2Kd3HdbAuJVzWYM4JW150hWoaI9DjhtbjcsCCHIMxm8RA==}
-    dependencies:
-      node-modules-path: 1.0.2
-    dev: true
-
   /progress@2.0.3:
     resolution: {integrity: sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==}
     engines: {node: '>=0.4.0'}
@@ -11764,17 +11022,6 @@ packages:
         optional: true
     dev: true
 
-  /promise-map-series@0.2.3:
-    resolution: {integrity: sha512-wx9Chrutvqu1N/NHzTayZjE1BgIwt6SJykQoCOic4IZ9yUDjKyVYrpLa/4YCNsV61eRENfs29hrEquVuB13Zlw==}
-    dependencies:
-      rsvp: 3.6.2
-    dev: true
-
-  /promise-map-series@0.3.0:
-    resolution: {integrity: sha512-3npG2NGhTc8BWBolLLf8l/92OxMGaRLbqvIh9wjCHhDXNvk4zsxaTaCpiCunW09qWPrN2zeNSNwRLVBrQQtutA==}
-    engines: {node: 10.* || >= 12.*}
-    dev: true
-
   /promise-retry@2.0.1:
     resolution: {integrity: sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==}
     engines: {node: '>=10'}
@@ -11789,17 +11036,12 @@ packages:
     dependencies:
       array.prototype.map: 1.0.6
       call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
       get-intrinsic: 1.2.1
       iterate-value: 1.0.2
     dev: true
 
-  /promise.hash.helper@1.0.8:
-    resolution: {integrity: sha512-KYcnXctWUWyVD3W3Ye0ZDuA1N8Szrh85cVCxpG6xYrOk/0CttRtYCmU30nWsUch0NuExQQ63QXvzRE6FLimZmg==}
-    engines: {node: 10.* || >= 12.*}
-    dev: true
-
   /promise.series@0.2.0:
     resolution: {integrity: sha512-VWQJyU2bcDTgZw8kpfBpB/ejZASlCrzwz5f2hjb/zlujOEB4oeiAhHygAWq8ubsX2GVkD4kCU5V2dwOTaCY5EQ==}
     engines: {node: '>=0.12'}
@@ -11848,7 +11090,6 @@ packages:
   /ps-tree@1.2.0:
     resolution: {integrity: sha512-0VnamPPYHl4uaU/nSFeZZpR21QAWRz+sRv4iW9+v/GS/J5U5iZB5BNN6J0RMoOvdx2gWM2+ZFMIm58q24e4UYA==}
     engines: {node: '>= 0.10'}
-    hasBin: true
     dependencies:
       event-stream: 3.3.4
     dev: true
@@ -11870,66 +11111,127 @@ packages:
       escape-goat: 4.0.0
     dev: true
 
-  /puppeteer-chromium-resolver@20.0.0(typescript@5.0.4):
+  /puppeteer-chromium-resolver@20.0.0(typescript@5.2.2):
     resolution: {integrity: sha512-c+laWfA6+CHxByGApB61k/mO50omzOM+HZ6phHN6vvdfCGeLKJUDJbbWlh5J2wfJZQu/nJGUntCQRjrkWbgSxQ==}
     requiresBuild: true
     dependencies:
-      '@puppeteer/browsers': 1.1.0(typescript@5.0.4)
+      '@puppeteer/browsers': 1.1.0(typescript@5.2.2)
       eight-colors: 1.0.3
       gauge: 5.0.1
-      puppeteer-core: 20.1.2(typescript@5.0.4)
+      puppeteer-core: 20.1.2(typescript@5.2.2)
     transitivePeerDependencies:
       - bufferutil
       - encoding
       - supports-color
       - typescript
       - utf-8-validate
+    dev: false
+
+  /puppeteer-chromium-resolver@21.0.0:
+    resolution: {integrity: sha512-sjOX4ACPz4KgYuoHBPEwpDlcFY6W4n13dXhJh+cV449YzeO0diNpLgAQqTfaTJr/GFA6sLt4eNb0h+VJkuvGgg==}
+    requiresBuild: true
+    dependencies:
+      '@puppeteer/browsers': 1.8.0
+      eight-colors: 1.0.3
+      gauge: 5.0.1
+      puppeteer-core: 21.4.1
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - utf-8-validate
+    dev: true
 
-  /puppeteer-core@20.1.2(typescript@5.0.4):
+  /puppeteer-core@20.1.2(typescript@5.2.2):
     resolution: {integrity: sha512-S1BLte+jVC/ugZkNoxFW9Fvbyr30CKZ0IIumf98FFqLh06Vuc21fddsr34botKtz27T81pqkpDYXNXYomA01dg==}
     engines: {node: '>=16.0.0'}
     peerDependencies:
-      typescript: '>= 4.7.4 || 5'
+      typescript: ^5.2.2 || 5
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@puppeteer/browsers': 1.1.0(typescript@5.0.4)
+      '@puppeteer/browsers': 1.1.0(typescript@5.2.2)
       chromium-bidi: 0.4.7(devtools-protocol@0.0.1120988)
       cross-fetch: 3.1.5
       debug: 4.3.4(supports-color@8.1.1)
       devtools-protocol: 0.0.1120988
-      typescript: 5.0.4
+      typescript: 5.2.2
       ws: 8.13.0
     transitivePeerDependencies:
       - bufferutil
       - encoding
       - supports-color
       - utf-8-validate
+    dev: false
+
+  /puppeteer-core@21.4.1:
+    resolution: {integrity: sha512-Lh0e+oGhUquxVOi1U701gTfFLFvw5gDBFh3CWpnfAvtItmyZKUce4R54VNfOJfi+KKnzhVPdB/lDrg65gdRIng==}
+    engines: {node: '>=16.3.0'}
+    dependencies:
+      '@puppeteer/browsers': 1.8.0
+      chromium-bidi: 0.4.32(devtools-protocol@0.0.1191157)
+      cross-fetch: 4.0.0
+      debug: 4.3.4(supports-color@8.1.1)
+      devtools-protocol: 0.0.1191157
+      ws: 8.14.2
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - utf-8-validate
+    dev: true
+
+  /puppeteer-core@21.5.0:
+    resolution: {integrity: sha512-qG0RJ6qKgFz09UUZxDB9IcyTJGypQXMuE8WmEoHk7kgjutmRiOVv5RgsyUkY67AxDdBWx21bn1PHHRJnO/6b4A==}
+    engines: {node: '>=16.3.0'}
+    dependencies:
+      '@puppeteer/browsers': 1.8.0
+      chromium-bidi: 0.4.33(devtools-protocol@0.0.1203626)
+      cross-fetch: 4.0.0
+      debug: 4.3.4(supports-color@8.1.1)
+      devtools-protocol: 0.0.1203626
+      ws: 8.14.2
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - utf-8-validate
+    dev: true
 
-  /puppeteer@20.1.2(typescript@5.0.4):
+  /puppeteer@20.1.2(typescript@5.2.2):
     resolution: {integrity: sha512-QYDp+iVMP30TwlkXFOocON9qR3Nac5ez7PdXbY90mfuEgZb9vf3/OXL2vHprxwPtb2hgD4AxXvLZhEIqfD2y8Q==}
     requiresBuild: true
     dependencies:
-      '@puppeteer/browsers': 1.1.0(typescript@5.0.4)
+      '@puppeteer/browsers': 1.1.0(typescript@5.2.2)
       cosmiconfig: 8.1.3
-      puppeteer-core: 20.1.2(typescript@5.0.4)
+      puppeteer-core: 20.1.2(typescript@5.2.2)
     transitivePeerDependencies:
       - bufferutil
       - encoding
       - supports-color
       - typescript
       - utf-8-validate
+    dev: false
 
-  /qs@6.11.0:
-    resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==}
-    engines: {node: '>=0.6'}
+  /puppeteer@21.5.0(typescript@5.2.2):
+    resolution: {integrity: sha512-prvy9rdauyIaaEgefQRcw9zhQnYQbl8O1Gj5VJazKJ7kwNx703+Paw/1bwA+b96jj/S+r55hrmF5SfiEG5PUcg==}
+    engines: {node: '>=16.3.0'}
+    requiresBuild: true
     dependencies:
-      side-channel: 1.0.4
+      '@puppeteer/browsers': 1.8.0
+      cosmiconfig: 8.3.6(typescript@5.2.2)
+      puppeteer-core: 21.5.0
+    transitivePeerDependencies:
+      - bufferutil
+      - encoding
+      - supports-color
+      - typescript
+      - utf-8-validate
     dev: true
 
-  /qs@6.11.1:
-    resolution: {integrity: sha512-0wsrzgTz/kAVIeuxSjnpGC56rzYtr6JT/2BwEvMaPhFIoYa1aGO8LbzuU1R0uUYQkLpWBTOj0l/CLAJB64J6nQ==}
+  /qs@6.11.0:
+    resolution: {integrity: sha512-MvjoMCJwEarSbUYk5O+nmoSzSutSsTwF85zcHPQ9OrlFoZOYIjaqBAJIqIXjptyD5vThxGq52Xu/MaJzRkIk4Q==}
     engines: {node: '>=0.6'}
     dependencies:
       side-channel: 1.0.4
@@ -11938,6 +11240,10 @@ packages:
   /queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
+  /queue-tick@1.0.1:
+    resolution: {integrity: sha512-kJt5qhMxoszgU/62PLP1CJytzd2NKetjSRnyuj31fDd3Rlcz3fzlFdFLD1SItunPwyqEOkca6GbV612BWfaBag==}
+    dev: true
+
   /quick-lru@4.0.1:
     resolution: {integrity: sha512-ARhCpm70fzdcvNQfPoy49IaanKkTlRWF2JMzqhcJbhSFRZv7nPTvZJdcY7301IPmvW+/p0RgIWnQDLJxifsQ7g==}
     engines: {node: '>=8'}
@@ -11948,27 +11254,24 @@ packages:
     engines: {node: '>=10'}
     dev: true
 
-  /quick-lru@6.1.1:
-    resolution: {integrity: sha512-S27GBT+F0NTRiehtbrgaSE1idUAJ5bX8dPAQTdylEyNlrdcH5X4Lz7Edz3DYzecbsCluD5zO8ZNEe04z3D3u6Q==}
-    engines: {node: '>=12'}
-    dev: true
-
-  /quick-temp@0.1.8:
-    resolution: {integrity: sha512-YsmIFfD9j2zaFwJkzI6eMG7y0lQP7YeWzgtFgNl38pGWZBSXJooZbOWwkcRot7Vt0Fg9L23pX0tqWU3VvLDsiA==}
-    dependencies:
-      mktemp: 0.4.0
-      rimraf: 2.7.1
-      underscore.string: 3.3.6
-    dev: true
-
   /qunit@2.19.4:
     resolution: {integrity: sha512-aqUzzUeCqlleWYKlpgfdHHw9C6KxkB9H3wNfiBg5yHqQMzy0xw/pbCRHYFkjl8MsP/t8qkTQE+JTYL71azgiew==}
     engines: {node: '>=10'}
+    dependencies:
+      commander: 7.2.0
+      node-watch: 0.7.3
+      tiny-glob: 0.2.9
+    dev: false
+
+  /qunit@2.20.0:
+    resolution: {integrity: sha512-N8Fp1J55waE+QG1KwX2LOyqulZUToRrrPBqDOfYfuAMkEglFL15uwvmH1P4Tq/omQ/mGbBI8PEB3PhIfvUb+jg==}
+    engines: {node: '>=10'}
     hasBin: true
     dependencies:
       commander: 7.2.0
       node-watch: 0.7.3
       tiny-glob: 0.2.9
+    dev: true
 
   /randombytes@2.1.0:
     resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
@@ -11980,14 +11283,6 @@ packages:
     engines: {node: '>= 0.6'}
     dev: true
 
-  /raw-body@1.1.7:
-    resolution: {integrity: sha512-WmJJU2e9Y6M5UzTOkHaM7xJGAPQD8PNzx3bAd2+uhZAim6wDk6dAZxPVYLF67XhbR4hmKGh33Lpmh4XWrCH5Mg==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      bytes: 1.0.0
-      string_decoder: 0.10.31
-    dev: true
-
   /raw-body@2.5.1:
     resolution: {integrity: sha512-qqJBtEyVgS0ZmPGdCFPWJ3FreoqvG4MVQln/kCgF7Olq95IbOp0/BWyMwbdtn4VTvkM8Y7khCQ2Xgk/tcrCXig==}
     engines: {node: '>= 0.8'}
@@ -12000,7 +11295,6 @@ packages:
 
   /rc@1.2.8:
     resolution: {integrity: sha512-y3bGgqKj3QBdxLbLkomlohkvsA8gdAiUQlSBJnBhfn+BPxg4bc62d8TcBW15wavDfgexCgccckhcZvywyQYPOw==}
-    hasBin: true
     dependencies:
       deep-extend: 0.6.0
       ini: 1.3.8
@@ -12008,6 +11302,11 @@ packages:
       strip-json-comments: 2.0.1
     dev: true
 
+  /react-refresh@0.14.0:
+    resolution: {integrity: sha512-wViHqhAd8OHeLS/IRMJjTSDHF3U9eWi62F/MledQGPdJGDhodXJ9PBLNGr6WWL7qlH12Mt3TyTpbS+hGXMjCzQ==}
+    engines: {node: '>=0.10.0'}
+    dev: true
+
   /read-pkg-up@7.0.1:
     resolution: {integrity: sha512-zK0TB7Xd6JpCLmlLmufqykGE+/TlOePD6qKClNW7hHDKFh/J7/7gCWGR7joEQEW1bKq3a3yUZSObOoWLFQ4ohg==}
     engines: {node: '>=8'}
@@ -12017,15 +11316,6 @@ packages:
       type-fest: 0.8.1
     dev: true
 
-  /read-pkg-up@9.1.0:
-    resolution: {integrity: sha512-vaMRR1AC1nrd5CQM0PhlRsO5oc2AAigqr7cCrZ/MW/Rsaflz4RlgzkpL4qoU/z1F6wrbd85iFv1OQj/y5RdGvg==}
-    engines: {node: ^12.20.0 || ^14.13.1 || >=16.0.0}
-    dependencies:
-      find-up: 6.3.0
-      read-pkg: 7.1.0
-      type-fest: 2.19.0
-    dev: true
-
   /read-pkg@3.0.0:
     resolution: {integrity: sha512-BLq/cCO9two+lBgiTYNqD6GdtK8s4NpaWrl6/rCO9w0TUS8oJl7cmToOZfRYllKTISY6nt1U7jQ53brmKqY6BA==}
     engines: {node: '>=4'}
@@ -12045,25 +11335,6 @@ packages:
       type-fest: 0.6.0
     dev: true
 
-  /read-pkg@7.1.0:
-    resolution: {integrity: sha512-5iOehe+WF75IccPc30bWTbpdDQLOCc3Uu8bi3Dte3Eueij81yx1Mrufk8qBx/YAbR4uL1FdUr+7BKXDwEtisXg==}
-    engines: {node: '>=12.20'}
-    dependencies:
-      '@types/normalize-package-data': 2.4.1
-      normalize-package-data: 3.0.3
-      parse-json: 5.2.0
-      type-fest: 2.19.0
-    dev: true
-
-  /readable-stream@1.0.34:
-    resolution: {integrity: sha512-ok1qVCJuRkNmvebYikljxJA/UEsKwLl2nI1OmaqAu4/UE+h0wKCHok4XkL/gvi39OacXvw59RJUOFUkDib2rHg==}
-    dependencies:
-      core-util-is: 1.0.3
-      inherits: 2.0.4
-      isarray: 0.0.1
-      string_decoder: 0.10.31
-    dev: true
-
   /readable-stream@3.6.2:
     resolution: {integrity: sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA==}
     engines: {node: '>= 6'}
@@ -12082,7 +11353,7 @@ packages:
     resolution: {integrity: sha512-HFM8rkZ+i3zrV+4LQjwQ0W+ez98pApMGM3HUrN04j3CqzPOzl9nmP15Y8YXNm8QHGv/eacOVEjqhmWpkRV0NAw==}
     engines: {node: '>= 0.10'}
     dependencies:
-      resolve: 1.22.8
+      resolve: 1.22.4
     dev: true
 
   /redent@3.0.0:
@@ -12093,25 +11364,11 @@ packages:
       strip-indent: 3.0.0
     dev: true
 
-  /redent@4.0.0:
-    resolution: {integrity: sha512-tYkDkVVtYkSVhuQ4zBgfvciymHaeuel+zFKXShfDnFP5SyVEP7qo70Rf1jTOTCx3vGNAbnEi/xFkcfQVMIBWag==}
-    engines: {node: '>=12'}
-    dependencies:
-      indent-string: 5.0.0
-      strip-indent: 4.0.0
-    dev: true
-
-  /redeyed@1.0.1:
-    resolution: {integrity: sha512-8eEWsNCkV2rvwKLS1Cvp5agNjMhwRe2um+y32B2+3LqOzg4C9BBPs6vzAfV16Ivb8B9HPNKIqd8OrdBws8kNlQ==}
-    dependencies:
-      esprima: 3.0.0
-    dev: true
-
   /refa@0.11.0:
     resolution: {integrity: sha512-486O8/pQXwj9jV0mVvUnTsxq0uknpBnNJ0eCUhkZqJRQ8KutrT1PhzmumdCeM1hSBF2eMlFPmwECRER4IbKXlQ==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
     dependencies:
-      '@eslint-community/regexpp': 4.5.1
+      '@eslint-community/regexpp': 4.6.2
     dev: false
 
   /regenerate-unicode-properties@10.1.0:
@@ -12123,27 +11380,19 @@ packages:
   /regenerate@1.4.2:
     resolution: {integrity: sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==}
 
-  /regenerator-runtime@0.13.11:
-    resolution: {integrity: sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==}
-
-  /regenerator-transform@0.15.1:
-    resolution: {integrity: sha512-knzmNAcuyxV+gQCufkYcvOqX/qIIfHLv0u5x79kRxuGojfYVky1f15TzZEu2Avte8QGepvUNTnLskf8E6X6Vyg==}
-    dependencies:
-      '@babel/runtime': 7.21.5
+  /regenerator-runtime@0.14.0:
+    resolution: {integrity: sha512-srw17NI0TUWHuGa5CFGGmhfNIeja30WMBfbslPNhf6JrqQlLN5gcrvig1oqPxiVaXb0oW0XRKtH6Nngs5lKCIA==}
 
-  /regex-not@1.0.2:
-    resolution: {integrity: sha512-J6SDjUgDxQj5NusnOtdFxDwN/+HWykR8GELwctJ7mdqhcyy1xEc4SRFHUXvxTp661YaVKAjfRLZ9cCqS6tn32A==}
-    engines: {node: '>=0.10.0'}
+  /regenerator-transform@0.15.2:
+    resolution: {integrity: sha512-hfMp2BoF0qOk3uc5V20ALGDS2ddjQaLrdl7xrGXvAIow7qeWRM2VA2HuCHkUKk9slq3VwEwLNK3DFBqDfPGYtg==}
     dependencies:
-      extend-shallow: 3.0.2
-      safe-regex: 1.1.0
-    dev: true
+      '@babel/runtime': 7.23.2
 
   /regexp-ast-analysis@0.6.0:
     resolution: {integrity: sha512-OLxjyjPkVH+rQlBLb1I/P/VTmamSjGkvN5PTV5BXP432k3uVz727J7H29GA5IFiY0m7e1xBN7049Wn59FY3DEQ==}
     engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
     dependencies:
-      '@eslint-community/regexpp': 4.5.1
+      '@eslint-community/regexpp': 4.6.2
       refa: 0.11.0
     dev: false
 
@@ -12152,18 +11401,23 @@ packages:
     hasBin: true
     dev: true
 
+  /regexp.prototype.flags@1.5.0:
+    resolution: {integrity: sha512-0SutC3pNudRKgquxGoRGIz946MZVHqbNfPjBdxeOhBrdgDKlRoXmYLQN9xRbrR09ZXWeGAdPuif7egofn6v5LA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      functions-have-names: 1.2.3
+    dev: true
+
   /regexp.prototype.flags@1.5.1:
     resolution: {integrity: sha512-sy6TXMN+hnP/wMy+ISxg3krXx7BAtWVO4UouuCN/ziM9UEne0euamVNafDfvC83bRNr95y0V5iijeDQFUNpvrg==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
+      call-bind: 1.0.5
+      define-properties: 1.2.0
       set-function-name: 2.0.1
 
-  /regexpp@3.2.0:
-    resolution: {integrity: sha512-pq2bWo9mVD43nbts2wGv17XLiNLya+GklZ8kaDLV2Z08gDCsGpnKn9BFMepvWuHCbyVvY7J5o5+BVvoQbmlJLg==}
-    engines: {node: '>=8'}
-
   /regexpu-core@5.3.2:
     resolution: {integrity: sha512-RAM5FlZz+Lhmo7db9L298p2vHP5ZywrVXmVXpmAD9GuL5MPH6t9ROw1iA/wfHkQ76Qe7AaPF0nGuim96/IrQMQ==}
     engines: {node: '>=4'}
@@ -12203,13 +11457,20 @@ packages:
       rc: 1.2.8
     dev: true
 
+  /regjsparser@0.10.0:
+    resolution: {integrity: sha512-qx+xQGZVsy55CH0a1hiVwHmqjLryfh7wQyF5HO07XJ9f7dQMY/gPQHhlyDkIzJKC+x2fUCpCcUODUUUFrm7SHA==}
+    hasBin: true
+    dependencies:
+      jsesc: 0.5.0
+    dev: true
+
   /regjsparser@0.9.1:
     resolution: {integrity: sha512-dQUtn90WanSNl+7mQKcXAgZxvUe7Z0SqXlgzv0za4LwiUhyzBC58yQO3liFoUgu8GiJVInAhJjkj1N0EtQ5nkQ==}
     hasBin: true
     dependencies:
       jsesc: 0.5.0
 
-  /release-it@16.2.1(typescript@5.0.4):
+  /release-it@16.2.1(typescript@5.2.2):
     resolution: {integrity: sha512-+bHiKPqkpld+NaiW+K/2WsjaHgfPB00J6uk8a+g8QyuBtzfFoMVe+GKsfaDO5ztEHRrSg+7luoXzd8IfvPNPig==}
     engines: {node: '>=16'}
     hasBin: true
@@ -12218,7 +11479,7 @@ packages:
       '@octokit/rest': 19.0.13
       async-retry: 1.3.3
       chalk: 5.3.0
-      cosmiconfig: 8.3.6(typescript@5.0.4)
+      cosmiconfig: 8.3.6(typescript@5.2.2)
       execa: 7.2.0
       git-url-parse: 13.1.0
       globby: 13.2.2
@@ -12247,40 +11508,10 @@ packages:
       - typescript
     dev: true
 
-  /remove-trailing-separator@1.1.0:
-    resolution: {integrity: sha512-/hS+Y0u3aOfIETiaiirUFwDBDzmXPvO+jAfKTitUngIPzdKc6Z0LoFjM/CK5PL4C+eKwHohlHAb6H0VFfmmUsw==}
-    dev: true
-
-  /remove-types@1.0.0:
-    resolution: {integrity: sha512-G7Hk1Q+UJ5DvlNAoJZObxANkBZGiGdp589rVcTW/tYqJWJ5rwfraSnKSQaETN8Epaytw8J40nS/zC7bcHGv36w==}
-    dependencies:
-      '@babel/core': 7.23.2
-      '@babel/plugin-syntax-decorators': 7.21.0(@babel/core@7.23.2)
-      '@babel/plugin-transform-typescript': 7.21.3(@babel/core@7.23.2)
-      prettier: 2.8.8
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /repeat-element@1.1.4:
-    resolution: {integrity: sha512-LFiNfRcSu7KK3evMyYOuCzv3L10TW7yC1G2/+StMjK8Y6Vqd2MG7r/Qjw4ghtuCOjFvlnms/iMmLqpvW/ES/WQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /repeat-string@1.6.1:
-    resolution: {integrity: sha512-PV0dzCYDNfRi1jCDbJzpW7jNNDRuCOG/jI5ctQcGKt/clZD+YcPS3yIlWuTJMmESC8aevCFmWJy5wjAFgNqN6w==}
-    engines: {node: '>=0.10'}
-    dev: true
-
   /require-directory@2.1.1:
     resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
     engines: {node: '>=0.10.0'}
 
-  /require-from-string@2.0.2:
-    resolution: {integrity: sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /requireindex@1.2.0:
     resolution: {integrity: sha512-L9jEkOi3ASd9PYit2cwRfyppc9NoABujTP8/5gFcbERmo5jUoAKovIC3fsF17pkTnGsrByysqX+Kxd2OTNI1ww==}
     engines: {node: '>=0.10.5'}
@@ -12289,22 +11520,10 @@ packages:
     resolution: {integrity: sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==}
     dev: true
 
-  /reselect@4.1.8:
-    resolution: {integrity: sha512-ab9EmR80F/zQTMNeneUr4cv+jSwPJgIlvEmVwLerwrWVbpLlBuls9XHzIeTFy4cegU2NHBp3va0LKOzU5qFEYQ==}
-    dev: true
-
   /resolve-alpn@1.2.1:
     resolution: {integrity: sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==}
     dev: true
 
-  /resolve-dir@1.0.1:
-    resolution: {integrity: sha512-R7uiTjECzvOsWSfdM0QKFNBVFcK27aHOUwdvK53BcW8zqnGdYp0Fbj82cy54+2A4P2tFM22J5kRfe1R+lM/1yg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      expand-tilde: 2.0.2
-      global-modules: 1.0.0
-    dev: true
-
   /resolve-from@4.0.0:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
@@ -12313,19 +11532,12 @@ packages:
     resolution: {integrity: sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==}
     engines: {node: '>=8'}
 
-  /resolve-package-path@1.2.7:
-    resolution: {integrity: sha512-fVEKHGeK85bGbVFuwO9o1aU0n3vqQGrezPc51JGu9UTXpFQfWq5qCeKxyaRUSvephs+06c5j5rPq/dzHGEo8+Q==}
-    dependencies:
-      path-root: 0.1.1
-      resolve: 1.22.8
-    dev: true
-
   /resolve-package-path@3.1.0:
     resolution: {integrity: sha512-2oC2EjWbMJwvSN6Z7DbDfJMnD8MYEouaLn5eIX0j8XwPsYCVIyY9bbnX88YHVkbr8XHqvZrYbxaLPibfTYKZMA==}
     engines: {node: 10.* || >= 12}
     dependencies:
       path-root: 0.1.1
-      resolve: 1.22.8
+      resolve: 1.22.4
     dev: true
 
   /resolve-package-path@4.0.3:
@@ -12335,21 +11547,18 @@ packages:
       path-root: 0.1.1
     dev: true
 
-  /resolve-path@1.4.0:
-    resolution: {integrity: sha512-i1xevIst/Qa+nA9olDxLWnLk8YZbi8R/7JPbCMcgyWaFR6bKWaexgJgEB5oc2PKMjYdrHynyz0NY+if+H98t1w==}
-    engines: {node: '>= 0.8'}
-    dependencies:
-      http-errors: 1.6.3
-      path-is-absolute: 1.0.1
-    dev: true
+  /resolve-pkg-maps@1.0.0:
+    resolution: {integrity: sha512-seS2Tj26TBVOC2NIc2rOe2y2ZO7efxITtLZcGSOnHHNOQ7CkiUBfw0Iw2ck6xkIhPwLhKNLS8BO+hEpngQlqzw==}
 
-  /resolve-url@0.2.1:
-    resolution: {integrity: sha512-ZuF55hVUQaaczgOIwqWzkEcEidmlD/xl44x1UZnhOXcYuFN2S6+rcxpG+C1N3So0wvNI3DmJICUFfu2SxhBmvg==}
-    deprecated: https://github.com/lydell/resolve-url#deprecated
-    dev: true
+  /resolve@1.22.2:
+    resolution: {integrity: sha512-Sb+mjNHOULsBv818T40qSPeRiuWLyaGMa5ewydRLFimneixmVy2zdivRl+AF6jaYPC8ERxGDmFSiqui6SfPd+g==}
+    dependencies:
+      is-core-module: 2.13.0
+      path-parse: 1.0.7
+      supports-preserve-symlinks-flag: 1.0.0
 
-  /resolve@1.22.8:
-    resolution: {integrity: sha512-oKWePCxqpd6FlLvGV1VU0x7bkPmmCNolxzjMf4NczoDnQcIWrAF+cPtZn5i6n+RfD2d9i0tzpKnG6Yk168yIyw==}
+  /resolve@1.22.4:
+    resolution: {integrity: sha512-PXNdCiPqDqeUou+w1C2eTQbNfxKSuMxqTCuvlmmMsk1NWHL5fRrhY6Pl0qEYYc6+QqGClco1Qj8XnjPego4wfg==}
     hasBin: true
     dependencies:
       is-core-module: 2.13.0
@@ -12369,14 +11578,6 @@ packages:
       lowercase-keys: 3.0.0
     dev: true
 
-  /restore-cursor@2.0.0:
-    resolution: {integrity: sha512-6IzJLuGi4+R14vwagDHX+JrXmPVtPpn4mffDJ1UdR7/Edm87fl6yi8mMBIVvFtJaNTUvjughmW4hwLhRG7gC1Q==}
-    engines: {node: '>=4'}
-    dependencies:
-      onetime: 2.0.1
-      signal-exit: 3.0.7
-    dev: true
-
   /restore-cursor@3.1.0:
     resolution: {integrity: sha512-l+sSefzHpj5qimhFSE5a8nufZYAM3sBSVMAPtYkmC+4EH2anSGaEMXSD0izRQbu9nfyQ9y5JrVmp7E8oZrUjvA==}
     engines: {node: '>=8'}
@@ -12393,11 +11594,6 @@ packages:
       signal-exit: 3.0.7
     dev: true
 
-  /ret@0.1.15:
-    resolution: {integrity: sha512-TTlYpa+OL+vMMNG24xSlQGEJ3B/RzEfUlLct7b5G/ytav+wPrplCpVMFuwzXbkecJrb6IYo1iFb0S9v37754mg==}
-    engines: {node: '>=0.12'}
-    dev: true
-
   /retry@0.12.0:
     resolution: {integrity: sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==}
     engines: {node: '>= 4'}
@@ -12408,26 +11604,12 @@ packages:
     engines: {node: '>= 4'}
     dev: true
 
-  /reusify@1.0.4:
-    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
-    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
-
-  /rimraf@2.5.4:
-    resolution: {integrity: sha512-Lw7SHMjssciQb/rRz7JyPIy9+bbUshEucPoLRvWqy09vC5zQixl8Uet+Zl+SROBB/JMWHJRdCk1qdxNWHNMvlQ==}
-    hasBin: true
-    dependencies:
-      glob: 7.2.3
-    dev: true
-
-  /rimraf@2.6.3:
-    resolution: {integrity: sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==}
-    hasBin: true
-    dependencies:
-      glob: 7.2.3
-    dev: true
+  /reusify@1.0.4:
+    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
+    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
 
-  /rimraf@2.7.1:
-    resolution: {integrity: sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==}
+  /rimraf@2.5.4:
+    resolution: {integrity: sha512-Lw7SHMjssciQb/rRz7JyPIy9+bbUshEucPoLRvWqy09vC5zQixl8Uet+Zl+SROBB/JMWHJRdCk1qdxNWHNMvlQ==}
     hasBin: true
     dependencies:
       glob: 7.2.3
@@ -12439,21 +11621,21 @@ packages:
     dependencies:
       glob: 7.2.3
 
-  /rimraf@5.0.0:
-    resolution: {integrity: sha512-Jf9llaP+RvaEVS5nPShYFhtXIrb3LRKP281ib3So0KkeZKo2wIKyq0Re7TOSwanasA423PSr6CCIL4bP6T040g==}
+  /rimraf@5.0.5:
+    resolution: {integrity: sha512-CqDakW+hMe/Bz202FPEymy68P+G50RfMQK+Qo5YUqc9SPipvbGjCGKd0RSKEelbsfQuw3g5NZDSrlZZAJurH1A==}
     engines: {node: '>=14'}
     hasBin: true
     dependencies:
-      glob: 10.2.3
+      glob: 10.3.10
     dev: true
 
-  /rollup-plugin-polyfill-node@0.12.0(rollup@3.21.6):
+  /rollup-plugin-polyfill-node@0.12.0(rollup@3.28.0):
     resolution: {integrity: sha512-PWEVfDxLEKt8JX1nZ0NkUAgXpkZMTb85rO/Ru9AQ69wYW8VUCfDgP4CGRXXWYni5wDF0vIeR1UoF3Jmw/Lt3Ug==}
     peerDependencies:
       rollup: ^1.20.0 || ^2.0.0 || ^3.0.0 || 3
     dependencies:
-      '@rollup/plugin-inject': 5.0.3(rollup@3.21.6)
-      rollup: 3.21.6
+      '@rollup/plugin-inject': 5.0.3(rollup@3.28.0)
+      rollup: 3.28.0
     dev: false
 
   /rollup-plugin-postcss@4.0.2(postcss@8.4.31)(ts-node@10.9.1):
@@ -12472,7 +11654,7 @@ packages:
       postcss-load-config: 3.1.4(postcss@8.4.31)(ts-node@10.9.1)
       postcss-modules: 4.3.1(postcss@8.4.31)
       promise.series: 0.2.0
-      resolve: 1.22.8
+      resolve: 1.22.2
       rollup-pluginutils: 2.8.2
       safe-identifier: 0.4.2
       style-inject: 0.3.0
@@ -12480,35 +11662,35 @@ packages:
       - ts-node
     dev: false
 
-  /rollup-plugin-sourcemaps@0.6.3(@types/node@18.16.6)(rollup@3.21.6):
+  /rollup-plugin-sourcemaps@0.6.3(@types/node@20.8.10)(rollup@3.21.6):
     resolution: {integrity: sha512-paFu+nT1xvuO1tPFYXGe+XnQvg4Hjqv/eIhG8i5EspfYYPBKL57X7iVbfv55aNVASg3dzWvES9dmWsL2KhfByw==}
     engines: {node: '>=10.0.0'}
     peerDependencies:
-      '@types/node': '>=10.0.0'
+      '@types/node': ^20.8.10
       rollup: '>=0.31.2 || 3'
     peerDependenciesMeta:
       '@types/node':
         optional: true
     dependencies:
       '@rollup/pluginutils': 5.0.2(rollup@3.21.6)
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
       rollup: 3.21.6
       source-map-resolve: 0.6.0
     dev: true
 
-  /rollup-plugin-ts@3.2.0(@babel/core@7.23.2)(@babel/plugin-transform-runtime@7.21.4)(@babel/preset-env@7.21.5)(@babel/preset-typescript@7.21.5)(@babel/runtime@7.21.5)(rollup@3.21.6)(typescript@5.0.4):
-    resolution: {integrity: sha512-KkTLVifkUexEiAXS9VtSjDrjKr0TyusmNJpb2ZTAzI9VuPumSu4AktIaVNnwv70iUEitHwZtET7OAM+5n1u1tg==}
-    engines: {node: '>=14.9.0', npm: '>=7.0.0', pnpm: '>=3.2.0', yarn: '>=1.13'}
+  /rollup-plugin-ts@3.4.4(@babel/core@7.23.2)(@babel/plugin-transform-runtime@7.23.2)(@babel/preset-env@7.23.2)(@babel/preset-typescript@7.23.2)(@babel/runtime@7.23.2)(rollup@3.28.0)(typescript@5.2.2):
+    resolution: {integrity: sha512-xgHn5o/1GD222EWxmMQYiWR00oEClv86O5fiEiIVtcaGXV2yWMn6x6jr082A/xmxu3CcdXiTUHomi/9FXTepWg==}
+    engines: {node: '>=16.15.1', npm: '>=7.0.0', pnpm: '>=3.2.0', yarn: '>=1.13'}
     peerDependencies:
-      '@babel/core': '>=6.x || >=7.x'
-      '@babel/plugin-transform-runtime': '>=6.x || >=7.x'
-      '@babel/preset-env': '>=6.x || >=7.x'
-      '@babel/preset-typescript': '>=6.x || >=7.x'
-      '@babel/runtime': '>=6.x || >=7.x'
+      '@babel/core': '>=7.x'
+      '@babel/plugin-transform-runtime': '>=7.x'
+      '@babel/preset-env': '>=7.x'
+      '@babel/preset-typescript': '>=7.x'
+      '@babel/runtime': '>=7.x'
       '@swc/core': '>=1.x'
       '@swc/helpers': '>=0.2'
-      rollup: '>=1.x || >=2.x || 3'
-      typescript: '>=3.2.x || >= 4.x || 5'
+      rollup: '>=1.x || >=2.x || >=3.x || 3'
+      typescript: ^5.2.2 || 5
     peerDependenciesMeta:
       '@babel/core':
         optional: true
@@ -12526,22 +11708,22 @@ packages:
         optional: true
     dependencies:
       '@babel/core': 7.23.2
-      '@babel/plugin-transform-runtime': 7.21.4(@babel/core@7.23.2)
-      '@babel/preset-env': 7.21.5(@babel/core@7.23.2)
-      '@babel/preset-typescript': 7.21.5(@babel/core@7.23.2)
-      '@babel/runtime': 7.21.5
-      '@rollup/pluginutils': 5.0.2(rollup@3.21.6)
+      '@babel/plugin-transform-runtime': 7.23.2(@babel/core@7.23.2)
+      '@babel/preset-env': 7.23.2(@babel/core@7.23.2)
+      '@babel/preset-typescript': 7.23.2(@babel/core@7.23.2)
+      '@babel/runtime': 7.23.2
+      '@rollup/pluginutils': 5.0.2(rollup@3.28.0)
       '@wessberg/stringutil': 1.0.19
       ansi-colors: 4.1.3
-      browserslist: 4.22.1
-      browserslist-generator: 2.0.3
-      compatfactory: 2.0.9(typescript@5.0.4)
+      browserslist: 4.21.10
+      browserslist-generator: 2.1.0
+      compatfactory: 3.0.0(typescript@5.2.2)
       crosspath: 2.0.0
-      magic-string: 0.27.0
-      rollup: 3.21.6
-      ts-clone-node: 2.0.4(typescript@5.0.4)
+      magic-string: 0.30.3
+      rollup: 3.28.0
+      ts-clone-node: 3.0.0(typescript@5.2.2)
       tslib: 2.6.2
-      typescript: 5.0.4
+      typescript: 5.2.2
     dev: false
 
   /rollup-pluginutils@2.8.2:
@@ -12553,17 +11735,35 @@ packages:
   /rollup@3.21.6:
     resolution: {integrity: sha512-SXIICxvxQxR3D4dp/3LDHZIJPC8a4anKMHd4E3Jiz2/JnY+2bEjqrOokAauc5ShGVNFHlEFjBXAXlaxkJqIqSg==}
     engines: {node: '>=14.18.0', npm: '>=8.0.0'}
-    hasBin: true
     optionalDependencies:
       fsevents: 2.3.3
-
-  /rsvp@3.2.1:
-    resolution: {integrity: sha512-Rf4YVNYpKjZ6ASAmibcwTNciQ5Co5Ztq6iZPEykHpkoflnD/K5ryE/rHehFsTm4NJj8nKDhbi3eKBWGogmNnkg==}
     dev: true
 
-  /rsvp@3.6.2:
-    resolution: {integrity: sha512-OfWGQTb9vnwRjwtA2QwpG2ICclHC3pgXZO5xt8H2EfgDquO0qVdSb5T88L4qJVAEugbS56pAuV4XZM58UX8ulw==}
-    engines: {node: 0.12.* || 4.* || 6.* || >= 7.*}
+  /rollup@3.28.0:
+    resolution: {integrity: sha512-d7zhvo1OUY2SXSM6pfNjgD5+d0Nz87CUp4mt8l/GgVP3oBsPwzNvSzyu1me6BSG9JIgWNTVcafIXBIyM8yQ3yw==}
+    engines: {node: '>=14.18.0', npm: '>=8.0.0'}
+    hasBin: true
+    optionalDependencies:
+      fsevents: 2.3.3
+
+  /rollup@4.3.0:
+    resolution: {integrity: sha512-scIi1NrKLDIYSPK66jjECtII7vIgdAMFmFo8h6qm++I6nN9qDSV35Ku6erzGVqYjx+lj+j5wkusRMr++8SyDZg==}
+    engines: {node: '>=18.0.0', npm: '>=8.0.0'}
+    hasBin: true
+    optionalDependencies:
+      '@rollup/rollup-android-arm-eabi': 4.3.0
+      '@rollup/rollup-android-arm64': 4.3.0
+      '@rollup/rollup-darwin-arm64': 4.3.0
+      '@rollup/rollup-darwin-x64': 4.3.0
+      '@rollup/rollup-linux-arm-gnueabihf': 4.3.0
+      '@rollup/rollup-linux-arm64-gnu': 4.3.0
+      '@rollup/rollup-linux-arm64-musl': 4.3.0
+      '@rollup/rollup-linux-x64-gnu': 4.3.0
+      '@rollup/rollup-linux-x64-musl': 4.3.0
+      '@rollup/rollup-win32-arm64-msvc': 4.3.0
+      '@rollup/rollup-win32-ia32-msvc': 4.3.0
+      '@rollup/rollup-win32-x64-msvc': 4.3.0
+      fsevents: 2.3.3
     dev: true
 
   /rsvp@4.8.5:
@@ -12576,10 +11776,6 @@ packages:
     engines: {node: '>=12'}
     dependencies:
       execa: 5.1.1
-
-  /run-async@2.4.1:
-    resolution: {integrity: sha512-tvVnVv01b8c1RrA6Ep7JkStj85Guv/YrMcwqYQnwjsAS2cTmmPGBBjAjpCW7RrSodNSoE2/qg9O4bceNvUuDgQ==}
-    engines: {node: '>=0.12.0'}
     dev: true
 
   /run-async@3.0.0:
@@ -12592,13 +11788,6 @@ packages:
     dependencies:
       queue-microtask: 1.2.3
 
-  /rxjs@6.6.7:
-    resolution: {integrity: sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==}
-    engines: {npm: '>=2.0.0'}
-    dependencies:
-      tslib: 1.14.1
-    dev: true
-
   /rxjs@7.8.1:
     resolution: {integrity: sha512-AA3TVj+0A2iuIoQkWEK/tqFjBq2j+6PO6Y0zJcvzLAFhEFIO3HL0vls9hWLncZbAAbK0mar7oZ4V079I/qPMxg==}
     dependencies:
@@ -12616,8 +11805,8 @@ packages:
     resolution: {integrity: sha512-6XbUAseYE2KtOuGueyeobCySj9L4+66Tn6KQMOPQJrAJEowYKW/YR/MGJZl7FdydUdaFu4LYyDZjxf4/Nmo23Q==}
     engines: {node: '>=0.4'}
     dependencies:
-      call-bind: 1.0.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      get-intrinsic: 1.2.2
       has-symbols: 1.0.3
       isarray: 2.0.5
 
@@ -12632,85 +11821,29 @@ packages:
     resolution: {integrity: sha512-6pNbSMW6OhAi9j+N8V+U715yBQsaWJ7eyEUaOrawX+isg5ZxhUlV1NipNtgaKHmFGiABwt+ZF04Ii+3Xjkg+8w==}
     dev: false
 
-  /safe-json-parse@1.0.1:
-    resolution: {integrity: sha512-o0JmTu17WGUaUOHa1l0FPGXKBfijbxK6qoHzlkihsDXxzBHvJcA7zgviKR92Xs841rX9pK16unfphLq0/KqX7A==}
-    dev: true
-
   /safe-regex-test@1.0.0:
     resolution: {integrity: sha512-JBUUzyOgEwXQY1NuPtvcj/qcBDbDmEvWufhlnXZIm75DEHp+afM1r1ujJpJsV/gSM4t59tpDyPi1sd6ZaPFfsA==}
     dependencies:
-      call-bind: 1.0.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      get-intrinsic: 1.2.2
       is-regex: 1.1.4
 
-  /safe-regex@1.1.0:
-    resolution: {integrity: sha512-aJXcif4xnaNUzvUuC5gcb46oTS7zvg4jpMTnuqtrEPlR3vFr4pxtdTwaF1Qs3Enjn9HK+ZlwQui+a7z0SywIzg==}
-    dependencies:
-      ret: 0.1.15
-    dev: true
-
-  /safe-regex@2.1.1:
-    resolution: {integrity: sha512-rx+x8AMzKb5Q5lQ95Zoi6ZbJqwCLkqi3XuJXp5P3rT8OEc6sZCJG5AE5dU3lsgRr/F4Bs31jSlVN+j5KrsGu9A==}
-    dependencies:
-      regexp-tree: 0.1.27
-    dev: true
-
-  /safe-stable-stringify@2.4.3:
-    resolution: {integrity: sha512-e2bDA2WJT0wxseVd4lsDP4+3ONX6HpMXQa1ZhFQ7SU+GjvORCmShbCMltrtIDfkYhVHrOcPtj+KhmDBdPdZD1g==}
-    engines: {node: '>=10'}
-    dev: true
-
   /safer-buffer@2.1.2:
     resolution: {integrity: sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==}
     dev: true
 
-  /sane@4.1.0:
-    resolution: {integrity: sha512-hhbzAgTIX8O7SHfp2c8/kREfEn4qO/9q8C9beyY6+tvZ87EpoZ3i1RIEvp27YBswnNbY9mWd6paKVmKbAgLfZA==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    deprecated: some dependency vulnerabilities fixed, support for node < 10 dropped, and newer ECMAScript syntax/features added
-    hasBin: true
-    dependencies:
-      '@cnakazawa/watch': 1.0.4
-      anymatch: 2.0.0
-      capture-exit: 2.0.0
-      exec-sh: 0.3.6
-      execa: 1.0.0
-      fb-watchman: 2.0.2
-      micromatch: 3.1.10
-      minimist: 1.2.8
-      walker: 1.0.8
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /sane@5.0.1:
-    resolution: {integrity: sha512-9/0CYoRz0MKKf04OMCO3Qk3RQl1PAwWAhPSQSym4ULiLpTZnrY1JoZU0IEikHu8kdk2HvKT/VwQMq/xFZ8kh1Q==}
-    engines: {node: 10.* || >= 12.*}
-    hasBin: true
-    dependencies:
-      '@cnakazawa/watch': 1.0.4
-      anymatch: 3.1.3
-      capture-exit: 2.0.0
-      exec-sh: 0.3.6
-      execa: 4.1.0
-      fb-watchman: 2.0.2
-      micromatch: 4.0.5
-      minimist: 1.2.8
-      walker: 1.0.8
-    dev: true
-
-  /schema-utils@3.3.0:
-    resolution: {integrity: sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==}
+  /schema-utils@3.1.2:
+    resolution: {integrity: sha512-pvjEHOgWc9OWA/f/DE3ohBWTD6EleVLf7iFUkoSwAxttdBhB9QUebQgxER2kWueOvRJXPHNnyrvvh9eZINB8Eg==}
     engines: {node: '>= 10.13.0'}
     dependencies:
-      '@types/json-schema': 7.0.13
+      '@types/json-schema': 7.0.12
       ajv: 6.12.6
       ajv-keywords: 3.5.2(ajv@6.12.6)
 
   /scslre@0.2.0:
     resolution: {integrity: sha512-4hc49fUMmX3jM0XdFUAPBrs1xwEcdHa0KyjEsjFs+Zfc66mpFpq5YmRgDtl+Ffo6AtJIilfei+yKw8fUn3N88w==}
     dependencies:
-      '@eslint-community/regexpp': 4.5.1
+      '@eslint-community/regexpp': 4.6.2
       refa: 0.11.0
       regexp-ast-analysis: 0.6.0
     dev: false
@@ -12722,22 +11855,14 @@ packages:
       semver: 7.5.4
     dev: true
 
-  /semver@5.7.2:
-    resolution: {integrity: sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==}
+  /semver@5.7.1:
+    resolution: {integrity: sha512-sauaDf/PZdVgrLTNYHRtpXa1iRiKcaebiKQ1BJdpQlWH2lCvexQdX55snPFyK7QzpudqbCI0qXFfOasHdyNDGQ==}
     hasBin: true
 
   /semver@6.3.1:
     resolution: {integrity: sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==}
     hasBin: true
 
-  /semver@7.5.2:
-    resolution: {integrity: sha512-SoftuTROv/cRjCze/scjGyiDtcUyxw1rgYQSZY7XTmtR5hX+dm76iDbTH8TkLPHCQmlbQVSSbNZCPM2hb0knnQ==}
-    engines: {node: '>=10'}
-    hasBin: true
-    dependencies:
-      lru-cache: 6.0.0
-    dev: true
-
   /semver@7.5.4:
     resolution: {integrity: sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==}
     engines: {node: '>=10'}
@@ -12793,28 +11918,23 @@ packages:
     resolution: {integrity: sha512-KiKBS8AnWGEyLzofFfmvKwpdPzqiy16LvQfK3yv/fVH7Bj13/wl3JSR1J+rfgRE9q7xUJK4qvgS8raSOeLUehw==}
     dev: true
 
+  /set-function-length@1.1.1:
+    resolution: {integrity: sha512-VoaqjbBJKiWtg4yRcKBQ7g7wnGnLV3M8oLvVWwOk2PdYY6PEFegR1vezXR0tw6fZGF9csVakIRjrJiy2veSBFQ==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      define-data-property: 1.1.1
+      get-intrinsic: 1.2.2
+      gopd: 1.0.1
+      has-property-descriptors: 1.0.0
+
   /set-function-name@2.0.1:
     resolution: {integrity: sha512-tMNCiqYVkXIZgc2Hnoy2IvC/f8ezc5koaRFkCjrpWzGpCd3qbZXPzVy9MAZzK1ch/X0jvSkojys3oqJN0qCmdA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      define-data-property: 1.1.0
+      define-data-property: 1.1.1
       functions-have-names: 1.2.3
       has-property-descriptors: 1.0.0
 
-  /set-value@2.0.1:
-    resolution: {integrity: sha512-JxHc1weCN68wRY0fhCoXpyK55m/XPHafOmK4UWD7m2CI14GMcFypt4w/0+NV5f/ZMby2F6S2wwA7fgynh9gWSw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      extend-shallow: 2.0.1
-      is-extendable: 0.1.1
-      is-plain-object: 2.0.4
-      split-string: 3.1.0
-    dev: true
-
-  /setprototypeof@1.1.0:
-    resolution: {integrity: sha512-BvE/TwpZX4FXExxOxZyRGQQv651MSwmWKZGqvmPcRIjDqWub67kTKuIMx43cZZrS/cBBzwBcNDWoFxt2XEFIpQ==}
-    dev: true
-
   /setprototypeof@1.2.0:
     resolution: {integrity: sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==}
     dev: true
@@ -12873,12 +11993,9 @@ packages:
     resolution: {integrity: sha512-uUWsN4aOxJAS8KOuf3QMyFtgm1pkb6I+KRZbRF/ghdf5T7sM+B1lLLzPDxswUjkmHyxQAVzEgG35E3NzDM9GVw==}
     engines: {node: '>=14'}
 
-  /silent-error@1.1.1:
-    resolution: {integrity: sha512-n4iEKyNcg4v6/jpb3c0/iyH2G1nzUNl7Gpqtn/mHIJK9S/q/7MCfoO4rwVOoO59qPFIc0hVHvMbiOJ0NdtxKKw==}
-    dependencies:
-      debug: 2.6.9
-    transitivePeerDependencies:
-      - supports-color
+  /signal-exit@4.1.0:
+    resolution: {integrity: sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==}
+    engines: {node: '>=14'}
     dev: true
 
   /simple-html-tokenizer@0.5.11:
@@ -12892,6 +12009,7 @@ packages:
   /slash@4.0.0:
     resolution: {integrity: sha512-3dOsAHXXUkQTpOYcoAxLIorMTp4gIQr5IW3iVb7A7lFIp0VHhnynm9izx6TssdrIcVIESAlVjtnO2K8bg+Coew==}
     engines: {node: '>=12'}
+    dev: true
 
   /slash@5.1.0:
     resolution: {integrity: sha512-ZA6oR3T/pEyuqwMgAKT0/hAv8oAXckzbkmR0UkUosQ+Mc4RxGoJkRmwHgHufaenlyAgE1Mxgpdcrf75y6XcnDg==}
@@ -12907,36 +12025,8 @@ packages:
     resolution: {integrity: sha512-V21+XeNni+tTyiST1MHsa84AQhT1aFZipzPpOFAVB8DkHzwJyjjAmt9bgwnuZiZWnIbMo2duE29wybxv/7HWUw==}
     dev: true
 
-  /snapdragon-node@2.1.1:
-    resolution: {integrity: sha512-O27l4xaMYt/RSQ5TR3vpWCAB5Kb/czIcqUFOM/C4fYcLnbZUc1PkjTAMjof2pBWaSTwOUd6qUHcFGVGj7aIwnw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      define-property: 1.0.0
-      isobject: 3.0.1
-      snapdragon-util: 3.0.1
-    dev: true
-
-  /snapdragon-util@3.0.1:
-    resolution: {integrity: sha512-mbKkMdQKsjX4BAL4bRYTj21edOf8cN7XHdYUJEe+Zn99hVEYcMvKPct1IqNe7+AZPirn8BCDOQBHQZknqmKlZQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      kind-of: 3.2.2
-    dev: true
-
-  /snapdragon@0.8.2:
-    resolution: {integrity: sha512-FtyOnWN/wCHTVXOMwvSv26d+ko5vWlIDD6zoUJ7LW8vh+ZBC8QdljveRP+crNrtBwioEUWy/4dMtbBjA4ioNlg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      base: 0.11.2
-      debug: 2.6.9
-      define-property: 0.2.5
-      extend-shallow: 2.0.1
-      map-cache: 0.2.2
-      source-map: 0.5.7
-      source-map-resolve: 0.5.3
-      use: 3.1.1
-    transitivePeerDependencies:
-      - supports-color
+  /smob@1.4.0:
+    resolution: {integrity: sha512-MqR3fVulhjWuRNSMydnTlweu38UhQ0HXM4buStD/S3mc/BzX3CuM9OmhyQpmtYCvoYdl5ris6TI0ZqH355Ymqg==}
     dev: true
 
   /socket.io-adapter@2.5.2:
@@ -13004,40 +12094,12 @@ packages:
       smart-buffer: 4.2.0
     dev: true
 
-  /sort-object-keys@1.1.3:
-    resolution: {integrity: sha512-855pvK+VkU7PaKYPc+Jjnmt4EzejQHyhhF33q31qG8x7maDzkeFhAAThdCYay11CISO+qAMwjOBP+fPZe0IPyg==}
-    dev: true
-
-  /sort-package-json@1.57.0:
-    resolution: {integrity: sha512-FYsjYn2dHTRb41wqnv+uEqCUvBpK3jZcTp9rbz2qDTmel7Pmdtf+i2rLaaPMRZeSVM60V3Se31GyWFpmKs4Q5Q==}
-    hasBin: true
-    dependencies:
-      detect-indent: 6.1.0
-      detect-newline: 3.1.0
-      git-hooks-list: 1.0.3
-      globby: 10.0.0
-      is-plain-obj: 2.1.0
-      sort-object-keys: 1.1.3
-    dev: true
-
   /source-map-js@1.0.2:
     resolution: {integrity: sha512-R0XvVJ9WusLiqTCEiGCmICCMplcCkIwwR11mOSD9CR5u+IXYdiseeEuXCVAjS54zqwkLcPNnmU4OeJ6tUrWhDw==}
     engines: {node: '>=0.10.0'}
 
-  /source-map-resolve@0.5.3:
-    resolution: {integrity: sha512-Htz+RnsXWk5+P2slx5Jh3Q66vhQj1Cllm0zvnaY98+NFx+Dv2CF/f5O/t8x+KaNdrdIAsruNzoh/KpialbqAnw==}
-    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
-    dependencies:
-      atob: 2.1.2
-      decode-uri-component: 0.2.2
-      resolve-url: 0.2.1
-      source-map-url: 0.4.1
-      urix: 0.1.0
-    dev: true
-
   /source-map-resolve@0.6.0:
     resolution: {integrity: sha512-KXBr9d/fO/bWo97NXsPIAW1bFSBOuCnjbNTBMO7N59hsv5i9yzRDfcYwwt0l04+VqnKC+EwzvJZIP/qkuMgR/w==}
-    deprecated: See https://github.com/lydell/source-map-resolve#deprecated
     dependencies:
       atob: 2.1.2
       decode-uri-component: 0.2.2
@@ -13049,47 +12111,13 @@ packages:
       buffer-from: 1.1.2
       source-map: 0.6.1
 
-  /source-map-url@0.3.0:
-    resolution: {integrity: sha512-QU4fa0D6aSOmrT+7OHpUXw+jS84T0MLaQNtFs8xzLNe6Arj44Magd7WEbyVW5LNYoAPVV35aKs4azxIfVJrToQ==}
-    deprecated: See https://github.com/lydell/source-map-url#deprecated
-    dev: true
-
-  /source-map-url@0.4.1:
-    resolution: {integrity: sha512-cPiFOTLUKvJFIg4SKVScy4ilPPW6rFgMgfuZJPNoDuMs3nC1HbMUycBoJw77xFIp6z1UJQJOfx6C9GMH80DiTw==}
-    deprecated: See https://github.com/lydell/source-map-url#deprecated
-    dev: true
-
-  /source-map@0.1.43:
-    resolution: {integrity: sha512-VtCvB9SIQhk3aF6h+N85EaqIaBFIAfZ9Cu+NJHHVvc8BbEcnvDcFw6sqQ2dQrT6SlOrZq3tIvyD9+EGq/lJryQ==}
-    engines: {node: '>=0.8.0'}
-    dependencies:
-      amdefine: 1.0.1
-    dev: true
-
-  /source-map@0.4.4:
-    resolution: {integrity: sha512-Y8nIfcb1s/7DcobUz1yOO1GSp7gyL+D9zLHDehT7iRESqGSxjJ448Sg7rvfgsRJCnKLdSl11uGf0s9X80cH0/A==}
-    engines: {node: '>=0.8.0'}
-    dependencies:
-      amdefine: 1.0.1
-    dev: true
-
-  /source-map@0.5.7:
-    resolution: {integrity: sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
   /source-map@0.6.1:
     resolution: {integrity: sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==}
     engines: {node: '>=0.10.0'}
 
-  /sourcemap-validator@1.1.1:
-    resolution: {integrity: sha512-pq6y03Vs6HUaKo9bE0aLoksAcpeOo9HZd7I8pI6O480W/zxNZ9U32GfzgtPP0Pgc/K1JHna569nAbOk3X8/Qtw==}
-    engines: {node: ^0.10 || ^4.5 || 6.* || >= 7.*}
-    dependencies:
-      jsesc: 0.3.0
-      lodash.foreach: 4.5.0
-      lodash.template: 4.5.0
-      source-map: 0.1.43
+  /source-map@0.7.4:
+    resolution: {integrity: sha512-l3BikUxvPOcn5E74dZiq5BGsTb5yEwhaTSzccU6t4sDOH8NWJCstKO5QT2CvtFoK6F0saL7p9xHAqHOlCPJygA==}
+    engines: {node: '>= 8'}
     dev: true
 
   /spawn-args@0.2.0:
@@ -13118,13 +12146,6 @@ packages:
     resolution: {integrity: sha512-XkD+zwiqXHikFZm4AX/7JSCXA98U5Db4AFd5XUg/+9UNtnH75+Z9KxtpYiJZx36mUDVOwH83pl7yvCer6ewM3w==}
     dev: true
 
-  /split-string@3.1.0:
-    resolution: {integrity: sha512-NzNVhJDYpwceVVii8/Hu6DKfD2G+NrQHlS/V/qgv763EYudVwEcMQNxd2lh+0VrUByXN/oJkl5grOhYWvQUYiw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      extend-shallow: 3.0.2
-    dev: true
-
   /split@0.3.3:
     resolution: {integrity: sha512-wD2AeVmxXRBoX44wAycgjVpMhvbwdI2aZjCkvfNcH1YqHQvJVa1duWc73OyVGJUc05fhFaTZeQ/PYsrmyH0JVA==}
     dependencies:
@@ -13135,10 +12156,6 @@ packages:
     resolution: {integrity: sha512-D9cPgkvLlV3t3IzL0D0YLvGA9Ahk4PcvVwUbN0dSGr1aP0Nrt4AEnTUbuGvquEC0mA64Gqt1fzirlRs5ibXx8g==}
     dev: true
 
-  /sprintf-js@1.1.2:
-    resolution: {integrity: sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==}
-    dev: true
-
   /ssri@8.0.1:
     resolution: {integrity: sha512-97qShzy1AiyxvPNIkLWoGua7xoQzzPjQ0HAH4B0rWKo7SZ6USuPcrUiAFrws0UH8RrbWmgq3LMTObhPIHbbBeQ==}
     engines: {node: '>= 8'}
@@ -13148,22 +12165,8 @@ packages:
 
   /stable@0.1.8:
     resolution: {integrity: sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==}
-    deprecated: 'Modern JS already guarantees Array#sort() is a stable sort, so this library is deprecated. See the compatibility table on MDN: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort#browser_compatibility'
     dev: false
 
-  /static-extend@0.1.2:
-    resolution: {integrity: sha512-72E9+uLc27Mt718pMHt9VMNiAL4LMsmDbBva8mxWUCkT07fSzEGMYUCk0XWY6lp0j6RBAG4cJ3mWuZv2OE3s0g==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      define-property: 0.2.5
-      object-copy: 0.1.0
-    dev: true
-
-  /statuses@1.5.0:
-    resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==}
-    engines: {node: '>= 0.6'}
-    dev: true
-
   /statuses@2.0.1:
     resolution: {integrity: sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==}
     engines: {node: '>= 0.8'}
@@ -13189,22 +12192,17 @@ packages:
       duplexer: 0.1.2
     dev: true
 
+  /streamx@2.15.1:
+    resolution: {integrity: sha512-fQMzy2O/Q47rgwErk/eGeLu/roaFWV0jVsogDmrszM9uIw8L5OA+t+V93MgYlufNptfjmYR1tOMWhei/Eh7TQA==}
+    dependencies:
+      fast-fifo: 1.3.2
+      queue-tick: 1.0.1
+    dev: true
+
   /string-hash@1.1.3:
     resolution: {integrity: sha512-kJUvRUFK49aub+a7T1nNE66EJbZBMnBgoC1UbCZ5n6bsZKBRga4KgBRTMn/pFkeCZSYtNeSyMxPDM0AXWELk2A==}
     dev: false
 
-  /string-template@0.2.1:
-    resolution: {integrity: sha512-Yptehjogou2xm4UJbxJ4CxgZx12HBfeystp0y3x7s4Dj32ltVVG1Gg8YhKjHZkHicuKpZX/ffilA8505VbUbpw==}
-    dev: true
-
-  /string-width@2.1.1:
-    resolution: {integrity: sha512-nOqH59deCq9SRHlxq1Aw85Jnt4w6KvLKqWVik6oA9ZklXLNIOlqg4F2yrT1MVaTjAqvVwdfeZ7w7aCvJD7ugkw==}
-    engines: {node: '>=4'}
-    dependencies:
-      is-fullwidth-code-point: 2.0.0
-      strip-ansi: 4.0.0
-    dev: true
-
   /string-width@4.2.3:
     resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
     engines: {node: '>=8'}
@@ -13226,7 +12224,7 @@ packages:
     engines: {node: '>=16'}
     dependencies:
       eastasianwidth: 0.2.0
-      emoji-regex: 10.2.1
+      emoji-regex: 10.3.0
       strip-ansi: 7.1.0
     dev: true
 
@@ -13235,62 +12233,62 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      define-properties: 1.2.0
+      es-abstract: 1.21.2
+    dev: true
+
+  /string.prototype.trim@1.2.7:
+    resolution: {integrity: sha512-p6TmeT1T3411M8Cgg9wBTMRtY2q9+PNy9EV1i2lIXUN/btt763oIfxwN3RR8VU6wHX8j/1CFy0L+YuThm6bgOg==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
     dev: true
 
   /string.prototype.trim@1.2.8:
     resolution: {integrity: sha512-lfjY4HcixfQXOfaqCvcBuOIapyaroTXhbkfJN3gcB1OtyupngWK4sEET9Knd0cXd28kTUqu/kHoV4HKSJdnjiQ==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+
+  /string.prototype.trimend@1.0.6:
+    resolution: {integrity: sha512-JySq+4mrPf9EsDBEDYMOb/lM7XQLulwg5R/m1r0PXEFqrV0qHvl58sdTilSXtKOflCsK2E8jxf+GKC0T07RWwQ==}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+    dev: true
 
   /string.prototype.trimend@1.0.7:
     resolution: {integrity: sha512-Ni79DqeB72ZFq1uH/L6zJ+DKZTkOtPIHovb3YZHQViE+HDouuU4mBrLOLDn5Dde3RF8qw5qVETEjhu9locMLvA==}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+
+  /string.prototype.trimstart@1.0.6:
+    resolution: {integrity: sha512-omqjMDaY92pbn5HOX7f9IccLA+U1tA9GvtU4JrodiXFfYB7jPzzHpRzpglLAjtUV6bB557zwClJezTqnAiYnQA==}
+    dependencies:
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
+    dev: true
 
   /string.prototype.trimstart@1.0.7:
     resolution: {integrity: sha512-NGhtDFu3jCEm7B4Fy0DpLewdJQOZcQ0rGbwQ/+stjnrp2i+rlKeCvos9hOIeCmqwratM47OBxY7uFZzjxHXmrg==}
     dependencies:
-      call-bind: 1.0.2
-      define-properties: 1.2.1
-      es-abstract: 1.22.2
-
-  /string_decoder@0.10.31:
-    resolution: {integrity: sha512-ev2QzSzWPYmy9GuqfIVildA4OdcGLeFZQrq5ys6RtiuF+RQQiZWr8TZNyAcuVXyQRYfEO+MsoB/1BuQVhOJuoQ==}
-    dev: true
+      call-bind: 1.0.5
+      define-properties: 1.2.0
+      es-abstract: 1.22.3
 
   /string_decoder@1.3.0:
     resolution: {integrity: sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==}
     dependencies:
       safe-buffer: 5.2.1
 
-  /strip-ansi@3.0.1:
-    resolution: {integrity: sha512-VhumSSbBqDTP8p2ZLKj40UjBCV4+v8bUSEpUb4KjRgWk9pbqGF4REFj6KEagidb2f/M6AzC0EmFyDNGaw9OCzg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      ansi-regex: 2.1.1
-    dev: true
-
-  /strip-ansi@4.0.0:
-    resolution: {integrity: sha512-4XaJ2zQdCzROZDivEVIDPkcQn8LMFSa8kj8Gxb/Lnwzv9A8VctNZ+lfivC/sV3ivW8ElJTERXZoPBRrZKkNKow==}
-    engines: {node: '>=4'}
-    dependencies:
-      ansi-regex: 3.0.1
-    dev: true
-
-  /strip-ansi@5.2.0:
-    resolution: {integrity: sha512-DuRs1gKbBqsMKIZlrffwlug8MHkcnpjs5VPmL1PAh+mA30U0DTotfDZ0d2UUsXpPmPmMMJ6W773MaA3J+lbiWA==}
-    engines: {node: '>=6'}
-    dependencies:
-      ansi-regex: 4.1.1
-    dev: true
-
   /strip-ansi@6.0.1:
     resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
     engines: {node: '>=8'}
@@ -13315,6 +12313,7 @@ packages:
   /strip-final-newline@2.0.0:
     resolution: {integrity: sha512-BrpvfNAE3dcvq7ll3xVumzjKjZQ5tI1sEUIKr3Uoks0XUl45St3FlatVqef9prk4jRDzhW6WZg+3bk93y6pLjA==}
     engines: {node: '>=6'}
+    dev: true
 
   /strip-final-newline@3.0.0:
     resolution: {integrity: sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==}
@@ -13327,13 +12326,6 @@ packages:
       min-indent: 1.0.1
     dev: true
 
-  /strip-indent@4.0.0:
-    resolution: {integrity: sha512-mnVSV2l+Zv6BLpSD/8V87CW/y9EmmbYzGCIavsnsI6/nwn26DwffM/yztm30Z/I2DY9wdS3vXVCMnHDgZaVNoA==}
-    engines: {node: '>=12'}
-    dependencies:
-      min-indent: 1.0.1
-    dev: true
-
   /strip-json-comments@2.0.1:
     resolution: {integrity: sha512-4gB8na07fecVVkOI6Rs4e7T6NOTki5EmL7TUduTs6bu3EdnSycntVJ4re8kgZA+wx9IueI2Y11bfbgwtzuE0KQ==}
     engines: {node: '>=0.10.0'}
@@ -13357,22 +12349,11 @@ packages:
     peerDependencies:
       postcss: ^8.2.15
     dependencies:
-      browserslist: 4.22.1
+      browserslist: 4.21.10
       postcss: 8.4.31
       postcss-selector-parser: 6.0.12
     dev: false
 
-  /sum-up@1.0.3:
-    resolution: {integrity: sha512-zw5P8gnhiqokJUWRdR6F4kIIIke0+ubQSGyYUY506GCbJWtV7F6Xuy0j6S125eSX2oF+a8KdivsZ8PlVEH0Mcw==}
-    dependencies:
-      chalk: 1.1.3
-    dev: true
-
-  /supports-color@2.0.0:
-    resolution: {integrity: sha512-KKNVtd6pCYgPIKU4cp2733HWYCpplQhddZLBUryaAHou723x+FRzQ5Df824Fj+IyyuiQTRoub4SnIFfIcrp70g==}
-    engines: {node: '>=0.8.0'}
-    dev: true
-
   /supports-color@5.5.0:
     resolution: {integrity: sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==}
     engines: {node: '>=4'}
@@ -13406,7 +12387,6 @@ packages:
   /svgo@2.8.0:
     resolution: {integrity: sha512-+N/Q9kV1+F+UeWYoSiULYo4xYSDQlTgb+ayMobAXPwMnLvop7oxKMo9OzIrX5x3eS4L4f2UHhc9axXwY8DpChg==}
     engines: {node: '>=10.13.0'}
-    hasBin: true
     dependencies:
       '@trysound/sax': 0.2.0
       commander: 7.2.0
@@ -13420,28 +12400,16 @@ packages:
   /symlink-or-copy@1.3.1:
     resolution: {integrity: sha512-0K91MEXFpBUaywiwSSkmKjnGcasG/rVBXFLJz5DrgGabpYD6N+3yZrfD6uUIfpuTu65DZLHi7N8CizHc07BPZA==}
 
-  /sync-disk-cache@1.3.4:
-    resolution: {integrity: sha512-GlkGeM81GPPEKz/lH7QUTbvqLq7K/IUTuaKDSMulP9XQ42glqNJIN/RKgSOw4y8vxL1gOVvj+W7ruEO4s36eCw==}
-    dependencies:
-      debug: 2.6.9
-      heimdalljs: 0.2.6
-      mkdirp: 0.5.6
-      rimraf: 2.7.1
-      username-sync: 1.0.3
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /synckit@0.8.5:
     resolution: {integrity: sha512-L1dapNV6vu2s/4Sputv8xGsCdAVlb5nRDMFU/E27D44l5U6cw1g0dGd45uLc+OXjNMmF4ntiMdCimzcjFKQI8Q==}
     engines: {node: ^14.18.0 || >=16.0.0}
     dependencies:
-      '@pkgr/utils': 2.4.0
+      '@pkgr/utils': 2.4.2
       tslib: 2.6.2
+    dev: true
 
   /tap-parser@7.0.0:
     resolution: {integrity: sha512-05G8/LrzqOOFvZhhAk32wsGiPZ1lfUrl+iV7+OkKgfofZxiceZWMHkKmow71YsyVQ8IvGBP2EjcIjE5gL4l5lA==}
-    hasBin: true
     dependencies:
       events-to-array: 1.1.2
       js-yaml: 3.14.1
@@ -13463,6 +12431,15 @@ packages:
       mkdirp-classic: 0.5.3
       pump: 3.0.0
       tar-stream: 2.2.0
+    dev: false
+
+  /tar-fs@3.0.4:
+    resolution: {integrity: sha512-5AFQU8b9qLfZCX9zp2duONhPmZv0hGYiBPJsyUdqMjzq/mqVpy/rEUSeHk1+YitmxugaptgBh5oDGU3VsAJq4w==}
+    dependencies:
+      mkdirp-classic: 0.5.3
+      pump: 3.0.0
+      tar-stream: 3.1.6
+    dev: true
 
   /tar-stream@2.2.0:
     resolution: {integrity: sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==}
@@ -13473,6 +12450,15 @@ packages:
       fs-constants: 1.0.0
       inherits: 2.0.4
       readable-stream: 3.6.2
+    dev: false
+
+  /tar-stream@3.1.6:
+    resolution: {integrity: sha512-B/UyjYwPpMBv+PaFSWAmtYjwdrlEaZQEhMIBFNC5oEG8lpiW8XjcSdmEaClj28ArfKScKHs2nshz3k2le6crsg==}
+    dependencies:
+      b4a: 1.6.4
+      fast-fifo: 1.3.2
+      streamx: 2.15.1
+    dev: true
 
   /tar@6.2.0:
     resolution: {integrity: sha512-/Wo7DcT0u5HUV486xg675HtjNd3BXZ6xDbzsCUZPt5iw8bTQ63bP0Raut3mvro9u+CUyq7YQd8Cx55fsZXxqLQ==}
@@ -13493,16 +12479,8 @@ packages:
       rimraf: 2.5.4
     dev: true
 
-  /temp@0.9.4:
-    resolution: {integrity: sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      mkdirp: 0.5.6
-      rimraf: 2.6.3
-    dev: true
-
-  /terser-webpack-plugin@5.3.9(webpack@5.88.2):
-    resolution: {integrity: sha512-ZuXsqE07EcggTWQjXUj+Aot/OMcD0bMKGgF63f7UxYcu5/AJF53aIpK1YoP5xR9l6s/Hy2b+t1AM0bLNPRuhwA==}
+  /terser-webpack-plugin@5.3.8(webpack@5.82.1):
+    resolution: {integrity: sha512-WiHL3ElchZMsK27P8uIUh4604IgJyAW47LVXGbEoB21DbQcZ+OuMpGjVYnEUaqcWM6dO8uS2qUbA7LSCWqvsbg==}
     engines: {node: '>= 10.13.0'}
     peerDependencies:
       '@swc/core': '*'
@@ -13517,19 +12495,29 @@ packages:
       uglify-js:
         optional: true
     dependencies:
-      '@jridgewell/trace-mapping': 0.3.19
+      '@jridgewell/trace-mapping': 0.3.18
       jest-worker: 27.5.1
-      schema-utils: 3.3.0
+      schema-utils: 3.1.2
       serialize-javascript: 6.0.1
-      terser: 5.21.0
-      webpack: 5.88.2
+      terser: 5.19.2
+      webpack: 5.82.1
+
+  /terser@5.17.1:
+    resolution: {integrity: sha512-hVl35zClmpisy6oaoKALOpS0rDYLxRFLHhRuDlEGTKey9qHjS1w9GMORjuwIMt70Wan4lwsLYyWDVnWgF+KUEw==}
+    engines: {node: '>=10'}
+    dependencies:
+      '@jridgewell/source-map': 0.3.3
+      acorn: 8.10.0
+      commander: 2.20.3
+      source-map-support: 0.5.21
+    dev: true
 
-  /terser@5.21.0:
-    resolution: {integrity: sha512-WtnFKrxu9kaoXuiZFSGrcAvvBqAdmKx0SFNmVNYdJamMu9yyN3I/QF0FbH4QcqJQ+y1CJnzxGIKH0cSj+FGYRw==}
+  /terser@5.19.2:
+    resolution: {integrity: sha512-qC5+dmecKJA4cpYxRa5aVkKehYsQKc+AHeKl0Oe62aYjBL8ZA33tTljktDHJSaxxMnbI5ZYw+o/S2DxxLu8OfA==}
     engines: {node: '>=10'}
     hasBin: true
     dependencies:
-      '@jridgewell/source-map': 0.3.5
+      '@jridgewell/source-map': 0.3.3
       acorn: 8.10.0
       commander: 2.20.3
       source-map-support: 0.5.21
@@ -13600,7 +12588,6 @@ packages:
   /testem@3.10.1:
     resolution: {integrity: sha512-42c4e7qlAelwMd8O3ogtVGRbgbr6fJnX6H51ACOIG1V1IjsKPlcQtxPyOwaL4iikH22Dfh+EyIuJnMG4yxieBQ==}
     engines: {node: '>= 7.*'}
-    hasBin: true
     dependencies:
       '@xmldom/xmldom': 0.8.7
       backbone: 1.4.1
@@ -13693,11 +12680,6 @@ packages:
   /text-table@0.2.0:
     resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
 
-  /textextensions@2.6.0:
-    resolution: {integrity: sha512-49WtAWS+tcsy93dRt6P0P3AMD2m5PvXRhuEA0kaXos5ZLlujtYmpmFsB+QvWUSxE1ZsstmYXfQ7L40+EcQgpAQ==}
-    engines: {node: '>=0.8'}
-    dev: true
-
   /thenify-all@1.6.0:
     resolution: {integrity: sha512-RNxQH/qI8/t3thXJDwcstUO4zeqo64+Uy/+sNVRBx4Xn2OX+OZ9oP+iJnNFqplFra2ZUVeKCSa2oVWi3T4uVmA==}
     engines: {node: '>=0.8'}
@@ -13711,13 +12693,6 @@ packages:
       any-promise: 1.3.0
     dev: true
 
-  /through2@3.0.2:
-    resolution: {integrity: sha512-enaDQ4MUyP2W6ZyT6EsMzqBPZaM/avg8iuo+l2d3QCs0J+6RaqkHV/2/lOwDTueBHeJ/2LG9lrLW3d5rWPucuQ==}
-    dependencies:
-      inherits: 2.0.4
-      readable-stream: 3.6.2
-    dev: true
-
   /through@2.3.8:
     resolution: {integrity: sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==}
 
@@ -13727,28 +12702,9 @@ packages:
       globalyzer: 0.1.0
       globrex: 0.1.2
 
-  /tiny-lr@2.0.0:
-    resolution: {integrity: sha512-f6nh0VMRvhGx4KCeK1lQ/jaL0Zdb5WdR+Jk8q9OSUQnaSDxAEGH1fgqLZ+cMl5EW3F2MGnCsalBO1IsnnogW1Q==}
-    dependencies:
-      body: 5.1.0
-      debug: 3.2.7
-      faye-websocket: 0.11.4
-      livereload-js: 3.4.1
-      object-assign: 4.1.1
-      qs: 6.11.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /titleize@3.0.0:
     resolution: {integrity: sha512-KxVu8EYHDPBdUYdKZdKtU2aj2XfEx9AfjXxE/Aj0vT06w2icA09Vus1rh6eSu1y01akYg6BjIK/hxyLJINoMLQ==}
     engines: {node: '>=12'}
-
-  /tmp@0.0.28:
-    resolution: {integrity: sha512-c2mmfiBmND6SOVxzogm1oda0OJ1HZVIk/5n26N59dDTh80MUeavpiCls4PGAdkX1PFkKokLpcf7prSjCeXLsJg==}
-    engines: {node: '>=0.4.0'}
-    dependencies:
-      os-tmpdir: 1.0.2
     dev: true
 
   /tmp@0.0.33:
@@ -13758,13 +12714,6 @@ packages:
       os-tmpdir: 1.0.2
     dev: true
 
-  /tmp@0.1.0:
-    resolution: {integrity: sha512-J7Z2K08jbGcdA1kkQpJSqLF6T0tdQqpR2pnSUXsIchbPdTI9v3e85cLW0d6WDhwuAleOV71j2xWs8qMPfK7nKw==}
-    engines: {node: '>=6'}
-    dependencies:
-      rimraf: 2.7.1
-    dev: true
-
   /tmp@0.2.1:
     resolution: {integrity: sha512-76SUhtfqR2Ijn+xllcI5P1oyannHNHByD80W1q447gU3mp9G9PSpGdWmjUOHRDPiHYacIk66W7ubDTuPF3BEtQ==}
     engines: {node: '>=8.17.0'}
@@ -13772,10 +12721,6 @@ packages:
       rimraf: 3.0.2
     dev: true
 
-  /tmpl@1.0.5:
-    resolution: {integrity: sha512-3f0uOEAQwIqGuWW2MVzYg8fV/QNnc/IpuJNG837rLuczAaLVHslWHZQj4IGiEl5Hs3kkbhwL9Ab7Hrsmuj+Smw==}
-    dev: true
-
   /to-absolute-glob@3.0.0:
     resolution: {integrity: sha512-loO/XEWTRqpfcpI7+Jr2RR2Umaaozx1t6OSVWtMi0oy5F/Fxg3IC+D/TToDnxyAGs7uZBGT/6XmyDUxgsObJXA==}
     engines: {node: '>=0.10.0'}
@@ -13785,45 +12730,20 @@ packages:
     dev: true
 
   /to-fast-properties@2.0.0:
-    resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}
-    engines: {node: '>=4'}
-
-  /to-object-path@0.3.0:
-    resolution: {integrity: sha512-9mWHdnGRuh3onocaHzukyvCZhzvr6tiflAy/JRFXcJX0TjgfWA9pk9t8CMbzmBE4Jfw58pXbkngtBtqYxzNEyg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      kind-of: 3.2.2
-    dev: true
+    resolution: {integrity: sha512-/OaKK0xYrs3DmxRYqL/yDc+FxFUVYhDlXMhRmv3z915w2HF1tnN1omB354j8VUGO/hbRzyD6Y3sA7v7GS/ceog==}
+    engines: {node: '>=4'}
 
   /to-readable-stream@1.0.0:
     resolution: {integrity: sha512-Iq25XBt6zD5npPhlLVXGFN3/gyR2/qODcKNNyTMd4vbm39HUaOiAM4PMq0eMVC/Tkxz+Zjdsc55g9yyz+Yq00Q==}
     engines: {node: '>=6'}
     dev: true
 
-  /to-regex-range@2.1.1:
-    resolution: {integrity: sha512-ZZWNfCjUokXXDGXFpZehJIkZqq91BcULFq/Pi7M5i4JnxXdhMKAK682z8bCW3o8Hj1wuuzoKcW3DfVzaP6VuNg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-number: 3.0.0
-      repeat-string: 1.6.1
-    dev: true
-
   /to-regex-range@5.0.1:
     resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
     engines: {node: '>=8.0'}
     dependencies:
       is-number: 7.0.0
 
-  /to-regex@3.0.2:
-    resolution: {integrity: sha512-FWtleNAtZ/Ki2qtqej2CXTOayOH9bHDQF+Q48VpWyDXjbYxA4Yz8iDB31zXOBUlOHHKidDbqGVrTUvQMPmBGBw==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      define-property: 2.0.2
-      extend-shallow: 3.0.2
-      regex-not: 1.0.2
-      safe-regex: 1.1.0
-    dev: true
-
   /toidentifier@1.0.1:
     resolution: {integrity: sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==}
     engines: {node: '>=0.6'}
@@ -13836,59 +12756,37 @@ packages:
   /tr46@0.0.3:
     resolution: {integrity: sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==}
 
-  /tree-sync@1.4.0:
-    resolution: {integrity: sha512-YvYllqh3qrR5TAYZZTXdspnIhlKAYezPYw11ntmweoceu4VK+keN356phHRIIo1d+RDmLpHZrUlmxga2gc9kSQ==}
-    dependencies:
-      debug: 2.6.9
-      fs-tree-diff: 0.5.9
-      mkdirp: 0.5.6
-      quick-temp: 0.1.8
-      walk-sync: 0.3.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /tree-sync@2.1.0:
-    resolution: {integrity: sha512-OLWW+Nd99NOM53aZ8ilT/YpEiOo6mXD3F4/wLbARqybSZ3Jb8IxHK5UGVbZaae0wtXAyQshVV+SeqVBik+Fbmw==}
-    engines: {node: '>=8'}
-    dependencies:
-      debug: 4.3.4(supports-color@8.1.1)
-      fs-tree-diff: 2.0.1
-      mkdirp: 0.5.6
-      quick-temp: 0.1.8
-      walk-sync: 0.3.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /trim-newlines@3.0.1:
     resolution: {integrity: sha512-c1PTsA3tYrIsLGkJkzHF+w9F2EyxfXGo4UyJc4pFL++FMjnq0HJS69T3M7d//gKrFKwy429bouPescbjecU+Zw==}
     engines: {node: '>=8'}
     dev: true
 
-  /trim-newlines@4.1.1:
-    resolution: {integrity: sha512-jRKj0n0jXWo6kh62nA5TEh3+4igKDXLvzBJcPpiizP7oOolUrYIxmVBG9TOtHYFHoddUk6YvAkGeGoSVTXfQXQ==}
-    engines: {node: '>=12'}
-    dev: true
+  /ts-api-utils@1.0.3(typescript@5.2.2):
+    resolution: {integrity: sha512-wNMeqtMz5NtwpT/UZGY5alT+VoKdSsOOP/kqHFcUW1P/VRhH2wJ48+DN2WwUliNbQ976ETwDL0Ifd2VVvgonvg==}
+    engines: {node: '>=16.13.0'}
+    peerDependencies:
+      typescript: ^5.2.2 || 5
+    dependencies:
+      typescript: 5.2.2
 
-  /ts-clone-node@2.0.4(typescript@5.0.4):
-    resolution: {integrity: sha512-eG6FAgmQsenhIJOIFhUcO6yyYejBKZIKcI3y21jiQmIOrth5pD6GElyPAyeihbPSyBs3u/9PVNXy+5I7jGy8jA==}
+  /ts-clone-node@3.0.0(typescript@5.2.2):
+    resolution: {integrity: sha512-egavvyHbIoelkgh1IC2agNB1uMNjB8VJgh0g/cn0bg2XXTcrtjrGMzEk4OD3Fi2hocICjP3vMa56nkzIzq0FRg==}
     engines: {node: '>=14.9.0'}
     peerDependencies:
-      typescript: ^3.x || ^4.x || 5
+      typescript: ^5.2.2 || 5
     dependencies:
-      compatfactory: 2.0.9(typescript@5.0.4)
-      typescript: 5.0.4
+      compatfactory: 3.0.0(typescript@5.2.2)
+      typescript: 5.2.2
     dev: false
 
-  /ts-node@10.9.1(@types/node@18.16.6)(typescript@5.0.4):
+  /ts-node@10.9.1(@types/node@20.8.10)(typescript@5.2.2):
     resolution: {integrity: sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==}
     hasBin: true
     peerDependencies:
       '@swc/core': '>=1.2.50'
       '@swc/wasm': '>=1.2.50'
-      '@types/node': '*'
-      typescript: '>=2.7 || 5'
+      '@types/node': ^20.8.10
+      typescript: ^5.2.2 || 5
     peerDependenciesMeta:
       '@swc/core':
         optional: true
@@ -13900,14 +12798,14 @@ packages:
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.3
-      '@types/node': 18.16.6
-      acorn: 8.10.0
+      '@types/node': 20.8.10
+      acorn: 8.8.2
       acorn-walk: 8.2.0
       arg: 4.1.3
       create-require: 1.1.1
       diff: 4.0.2
       make-error: 1.3.6
-      typescript: 5.0.4
+      typescript: 5.2.2
       v8-compile-cache-lib: 3.0.1
       yn: 3.1.1
 
@@ -13921,22 +12819,23 @@ packages:
 
   /tslib@1.14.1:
     resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
+    dev: false
 
   /tslib@2.6.2:
     resolution: {integrity: sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==}
 
-  /tsutils@3.21.0(typescript@5.0.4):
+  /tsutils@3.21.0(typescript@5.2.2):
     resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
     engines: {node: '>= 6'}
     peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta || 5'
+      typescript: ^5.2.2 || 5
     dependencies:
       tslib: 1.14.1
-      typescript: 5.0.4
+      typescript: 5.2.2
+    dev: false
 
   /tsx@3.12.7:
     resolution: {integrity: sha512-C2Ip+jPmqKd1GWVQDvz/Eyc6QJbGfE7NrR3fx5BpEHMZsEHoIxHL1j+lKdGobr8ovEyqeNkPLSKp6SCSOt7gmw==}
-    hasBin: true
     dependencies:
       '@esbuild-kit/cjs-loader': 2.4.2
       '@esbuild-kit/core-utils': 3.1.0
@@ -13945,65 +12844,75 @@ packages:
       fsevents: 2.3.3
     dev: true
 
-  /turbo-darwin-64@1.9.3:
-    resolution: {integrity: sha512-0dFc2cWXl82kRE4Z+QqPHhbEFEpUZho1msHXHWbz5+PqLxn8FY0lEVOHkq5tgKNNEd5KnGyj33gC/bHhpZOk5g==}
+  /tsx@3.14.0:
+    resolution: {integrity: sha512-xHtFaKtHxM9LOklMmJdI3BEnQq/D5F73Of2E1GDrITi9sgoVkvIsrQUTY1G8FlmGtA+awCI4EBlTRRYxkL2sRg==}
+    hasBin: true
+    dependencies:
+      esbuild: 0.18.20
+      get-tsconfig: 4.7.2
+      source-map-support: 0.5.21
+    optionalDependencies:
+      fsevents: 2.3.3
+    dev: true
+
+  /turbo-darwin-64@1.10.16:
+    resolution: {integrity: sha512-+Jk91FNcp9e9NCLYlvDDlp2HwEDp14F9N42IoW3dmHI5ZkGSXzalbhVcrx3DOox3QfiNUHxzWg4d7CnVNCuuMg==}
     cpu: [x64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-darwin-arm64@1.9.3:
-    resolution: {integrity: sha512-1cYbjqLBA2zYE1nbf/qVnEkrHa4PkJJbLo7hnuMuGM0bPzh4+AnTNe98gELhqI1mkTWBu/XAEeF5u6dgz0jLNA==}
+  /turbo-darwin-arm64@1.10.16:
+    resolution: {integrity: sha512-jqGpFZipIivkRp/i+jnL8npX0VssE6IAVNKtu573LXtssZdV/S+fRGYA16tI46xJGxSAivrZ/IcgZrV6Jk80bw==}
     cpu: [arm64]
     os: [darwin]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-linux-64@1.9.3:
-    resolution: {integrity: sha512-UuBPFefawEwpuxh5pM9Jqq3q4C8M0vYxVYlB3qea/nHQ80pxYq7ZcaLGEpb10SGnr3oMUUs1zZvkXWDNKCJb8Q==}
+  /turbo-linux-64@1.10.16:
+    resolution: {integrity: sha512-PpqEZHwLoizQ6sTUvmImcRmACyRk9EWLXGlqceogPZsJ1jTRK3sfcF9fC2W56zkSIzuLEP07k5kl+ZxJd8JMcg==}
     cpu: [x64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-linux-arm64@1.9.3:
-    resolution: {integrity: sha512-vUrNGa3hyDtRh9W0MkO+l1dzP8Co2gKnOVmlJQW0hdpOlWlIh22nHNGGlICg+xFa2f9j4PbQlWTsc22c019s8Q==}
+  /turbo-linux-arm64@1.10.16:
+    resolution: {integrity: sha512-TMjFYz8to1QE0fKVXCIvG/4giyfnmqcQIwjdNfJvKjBxn22PpbjeuFuQ5kNXshUTRaTJihFbuuCcb5OYFNx4uw==}
     cpu: [arm64]
     os: [linux]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-windows-64@1.9.3:
-    resolution: {integrity: sha512-0BZ7YaHs6r+K4ksqWus1GKK3W45DuDqlmfjm/yuUbTEVc8szmMCs12vugU2Zi5GdrdJSYfoKfEJ/PeegSLIQGQ==}
+  /turbo-windows-64@1.10.16:
+    resolution: {integrity: sha512-+jsf68krs0N66FfC4/zZvioUap/Tq3sPFumnMV+EBo8jFdqs4yehd6+MxIwYTjSQLIcpH8KoNMB0gQYhJRLZzw==}
     cpu: [x64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo-windows-arm64@1.9.3:
-    resolution: {integrity: sha512-QJUYLSsxdXOsR1TquiOmLdAgtYcQ/RuSRpScGvnZb1hY0oLc7JWU0llkYB81wVtWs469y8H9O0cxbKwCZGR4RQ==}
+  /turbo-windows-arm64@1.10.16:
+    resolution: {integrity: sha512-sKm3hcMM1bl0B3PLG4ifidicOGfoJmOEacM5JtgBkYM48ncMHjkHfFY7HrJHZHUnXM4l05RQTpLFoOl/uIo2HQ==}
     cpu: [arm64]
     os: [win32]
     requiresBuild: true
     dev: true
     optional: true
 
-  /turbo@1.9.3:
-    resolution: {integrity: sha512-ID7mxmaLUPKG/hVkp+h0VuucB1U99RPCJD9cEuSEOdIPoSIuomcIClEJtKamUsdPLhLCud+BvapBNnhgh58Nzw==}
+  /turbo@1.10.16:
+    resolution: {integrity: sha512-2CEaK4FIuSZiP83iFa9GqMTQhroW2QryckVqUydmg4tx78baftTOS0O+oDAhvo9r9Nit4xUEtC1RAHoqs6ZEtg==}
     hasBin: true
-    requiresBuild: true
     optionalDependencies:
-      turbo-darwin-64: 1.9.3
-      turbo-darwin-arm64: 1.9.3
-      turbo-linux-64: 1.9.3
-      turbo-linux-arm64: 1.9.3
-      turbo-windows-64: 1.9.3
-      turbo-windows-arm64: 1.9.3
+      turbo-darwin-64: 1.10.16
+      turbo-darwin-arm64: 1.10.16
+      turbo-linux-64: 1.10.16
+      turbo-linux-arm64: 1.10.16
+      turbo-windows-64: 1.10.16
+      turbo-windows-arm64: 1.10.16
     dev: true
 
   /type-check@0.4.0:
@@ -14012,11 +12921,6 @@ packages:
     dependencies:
       prelude-ls: 1.2.1
 
-  /type-fest@0.11.0:
-    resolution: {integrity: sha512-OdjXJxnCN1AvyLSzeKIgXTXxV+99ZuXl3Hpo9XpJAv9MBcHrrJOQ5kV7ypXOuQie+AmWG25hLbiKdwYTifzcfQ==}
-    engines: {node: '>=8'}
-    dev: true
-
   /type-fest@0.18.1:
     resolution: {integrity: sha512-OIAYXk8+ISY+qTOwkHtKqzAuxchoMiD9Udx+FSGQDuiRR+PJKJHc2NJAXlbhkGwTt/4/nKZxELY1w3ReWOL8mw==}
     engines: {node: '>=10'}
@@ -14051,15 +12955,6 @@ packages:
     engines: {node: '>=12.20'}
     dev: true
 
-  /type-fest@3.10.0(typescript@5.0.4):
-    resolution: {integrity: sha512-hmAPf1datm+gt3c2mvu0sJyhFy6lTkIGf0GzyaZWxRLnabQfPUqg6tF95RPg6sLxKI7nFLGdFxBcf2/7+GXI+A==}
-    engines: {node: '>=14.16'}
-    peerDependencies:
-      typescript: '>=4.7.0 || 5'
-    dependencies:
-      typescript: 5.0.4
-    dev: true
-
   /type-is@1.6.18:
     resolution: {integrity: sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==}
     engines: {node: '>= 0.6'}
@@ -14072,15 +12967,15 @@ packages:
     resolution: {integrity: sha512-Y8KTSIglk9OZEr8zywiIHG/kmQ7KWyjseXs1CbSo8vC42w7hg2HgYTxSWwP0+is7bWDc1H+Fo026CpHFwm8tkw==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
-      get-intrinsic: 1.2.1
+      call-bind: 1.0.5
+      get-intrinsic: 1.2.2
       is-typed-array: 1.1.12
 
   /typed-array-byte-length@1.0.0:
     resolution: {integrity: sha512-Or/+kvLxNpeQ9DtSydonMxCx+9ZXOswtwJn17SNLvhptaXYDJvkFFP5zbfU/uLmvnBJlI4yrnXRxpdWH/M5tNA==}
     engines: {node: '>= 0.4'}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       for-each: 0.3.3
       has-proto: 1.0.1
       is-typed-array: 1.1.12
@@ -14090,7 +12985,7 @@ packages:
     engines: {node: '>= 0.4'}
     dependencies:
       available-typed-arrays: 1.0.5
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       for-each: 0.3.3
       has-proto: 1.0.1
       is-typed-array: 1.1.12
@@ -14098,7 +12993,7 @@ packages:
   /typed-array-length@1.0.4:
     resolution: {integrity: sha512-KjZypGq+I/H7HI5HlOoGHkWUUGq+Q0TPhQurLbyrVrvnKTBgzLhIJ7j6J/XTQOi0d1RjyZ0wdas8bKs2p0x3Ng==}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       for-each: 0.3.3
       is-typed-array: 1.1.12
 
@@ -14108,31 +13003,19 @@ packages:
       is-typedarray: 1.0.0
     dev: true
 
-  /typescript@5.0.4:
-    resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==}
-    engines: {node: '>=12.20'}
+  /typescript@5.2.2:
+    resolution: {integrity: sha512-mI4WrpHsbCIcwT9cF4FZvr80QUeKvsUsUvKDoR+X/7XHQH98xYD8YHZg7ANtz2GtZt/CBq2QJ0thkGJMHfqc1w==}
+    engines: {node: '>=14.17'}
     hasBin: true
 
   /ua-parser-js@1.0.35:
     resolution: {integrity: sha512-fKnGuqmTBnIE+/KXSzCn4db8RTigUzw1AN0DmdU6hJovUTbYJKyqj+8Mt1c4VfRDnOVJnENmfYkIPZ946UrSAA==}
     dev: false
 
-  /uc.micro@1.0.6:
-    resolution: {integrity: sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA==}
-    dev: true
-
-  /uglify-js@3.17.4:
-    resolution: {integrity: sha512-T9q82TJI9e/C1TAxYvfb16xO120tMVFZrGA3f9/P4424DNu6ypK103y0GPFVa17yotwSyZW5iYXgjYHkGrJW/g==}
-    engines: {node: '>=0.8.0'}
-    hasBin: true
-    requiresBuild: true
-    dev: true
-    optional: true
-
   /unbox-primitive@1.0.2:
     resolution: {integrity: sha512-61pPlCD9h51VoreyJ0BReideM3MDKMKnh6+V9L08331ipq6Q8OFXZYiqP6n/tbHx4s5I9uRhcye6BrbkizkBDw==}
     dependencies:
-      call-bind: 1.0.2
+      call-bind: 1.0.5
       has-bigints: 1.0.2
       has-symbols: 1.0.3
       which-boxed-primitive: 1.0.2
@@ -14148,17 +13031,13 @@ packages:
     engines: {node: '>=0.10.0'}
     dev: true
 
-  /underscore.string@3.3.6:
-    resolution: {integrity: sha512-VoC83HWXmCrF6rgkyxS9GHv8W9Q5nhMKho+OadDJGzL2oDYbYEppBaCMH6pFlwLeqj2QS+hhkw2kpXkSdD1JxQ==}
-    dependencies:
-      sprintf-js: 1.1.2
-      util-deprecate: 1.0.2
-    dev: true
-
   /underscore@1.13.6:
     resolution: {integrity: sha512-+A5Sja4HP1M08MaXya7p5LvjuM7K6q/2EaC0+iovj/wOcMsTzMvDFbasi/oSapiwOlt252IqsKqPjCl7huKS0A==}
     dev: true
 
+  /undici-types@5.26.5:
+    resolution: {integrity: sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==}
+
   /unicode-canonical-property-names-ecmascript@2.0.0:
     resolution: {integrity: sha512-yY5PpDlfVIU5+y/BSCxAJRBIS1Zc2dDG3Ujq+sR0U+JjUevW2JhocOF+soROYDSaAezOzOKuyyixhD6mBknSmQ==}
     engines: {node: '>=4'}
@@ -14178,16 +13057,6 @@ packages:
     resolution: {integrity: sha512-6t3foTQI9qne+OZoVQB/8x8rk2k1eVy1gRXhV3oFQ5T6R1dqQ1xtin3XqSlx3+ATBkliTaR/hHyJBm+LVPNM8w==}
     engines: {node: '>=4'}
 
-  /union-value@1.0.1:
-    resolution: {integrity: sha512-tJfXmxMeWYnczCVs7XAEvIV7ieppALdyepWMkHkwciRpZraG/xwT+s2JN8+pr1+8jCRf80FFzvr+MpQeeoF4Xg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      arr-union: 3.1.0
-      get-value: 2.0.6
-      is-extendable: 0.1.1
-      set-value: 2.0.1
-    dev: true
-
   /unique-filename@1.1.1:
     resolution: {integrity: sha512-Vmp0jIp2ln35UTXuryvjzkjGdRyf9b2lTXuSYUiPmzRcl3FDtYqAwOnTJkAngD9SWhnoJzDbTKwaOrZ+STtxNQ==}
     dependencies:
@@ -14200,13 +13069,6 @@ packages:
       imurmurhash: 0.1.4
     dev: true
 
-  /unique-string@2.0.0:
-    resolution: {integrity: sha512-uNaeirEPvpZWSgzwsPGtU2zVSTrn/8L5q/IexZmH0eH6SA73CmAA5U4GwORTxQAZs95TAXLNqeLoPPNO5gZfWg==}
-    engines: {node: '>=8'}
-    dependencies:
-      crypto-random-string: 2.0.0
-    dev: true
-
   /unique-string@3.0.0:
     resolution: {integrity: sha512-VGXBUVwxKMBUznyffQweQABPRRW1vHZAbadFZud4pLFAqRGvv/96vafgjWFqzourzr8YonlQiPgH0YCJfawoGQ==}
     engines: {node: '>=12'}
@@ -14217,7 +13079,7 @@ packages:
   /unist-util-stringify-position@3.0.3:
     resolution: {integrity: sha512-k5GzIBZ/QatR8N5X2y+drfpWG8IDBzdnVj6OInRNWm1oXrzydiaAT2OQiA8DPRRZyAKb9b6I2a6PxYklZD0gKg==}
     dependencies:
-      '@types/unist': 2.0.8
+      '@types/unist': 2.0.9
     dev: true
 
   /universal-user-agent@6.0.0:
@@ -14232,7 +13094,6 @@ packages:
   /universalify@1.0.0:
     resolution: {integrity: sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug==}
     engines: {node: '>= 10.0.0'}
-    dev: true
 
   /universalify@2.0.0:
     resolution: {integrity: sha512-hAZsKq7Yy11Zu1DE0OzWjw7nnLZmJZYTDZZyEFHZdUhV8FkH5MCfoU1XMaxXovpyW5nq5scPqq0ZDP9Zyl04oQ==}
@@ -14243,7 +13104,7 @@ packages:
     engines: {node: '>= 0.8'}
     dev: true
 
-  /unplugin-fonts@1.0.3(vite@4.3.9):
+  /unplugin-fonts@1.0.3(vite@4.4.9):
     resolution: {integrity: sha512-6Wq0SMhMznUx7DTkqr/ogCvWg2vFSCApHmhUcUISxqfnuME2B/KRLa6+bWyX3sbPNhYsW4zI7jvUkkmIumwenw==}
     peerDependencies:
       '@nuxt/kit': ^3.0.0
@@ -14254,7 +13115,7 @@ packages:
     dependencies:
       fast-glob: 3.3.1
       unplugin: 1.3.1
-      vite: 4.3.9(@types/node@18.16.6)
+      vite: 4.4.9(@types/node@20.8.10)
     dev: false
 
   /unplugin@1.3.1:
@@ -14266,24 +13127,20 @@ packages:
       webpack-virtual-modules: 0.5.0
     dev: false
 
-  /unset-value@1.0.0:
-    resolution: {integrity: sha512-PcA2tsuGSF9cnySLHTLSh2qrQiJ70mn+r+Glzxv2TWZblxsxCC52BDlZoPCsz7STd9pN7EZetkWZBAvk4cgZdQ==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      has-value: 0.3.1
-      isobject: 3.0.1
-    dev: true
-
-  /untildify@2.1.0:
-    resolution: {integrity: sha512-sJjbDp2GodvkB0FZZcn7k6afVisqX5BZD7Yq3xp4nN2O15BBK0cLm3Vwn2vQaF7UDS0UUsrQMkkplmDI5fskig==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      os-homedir: 1.0.2
-    dev: true
-
   /untildify@4.0.0:
     resolution: {integrity: sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw==}
     engines: {node: '>=8'}
+    dev: true
+
+  /update-browserslist-db@1.0.11(browserslist@4.21.10):
+    resolution: {integrity: sha512-dCwEFf0/oT85M1fHBg4F0jtLwJrutGoHSQXCh7u4o2t1drG+c0a9Flnqww6XUKSfQMPpJBRjU8d4RXB09qtvaA==}
+    hasBin: true
+    peerDependencies:
+      browserslist: '>= 4.21.0'
+    dependencies:
+      browserslist: 4.21.10
+      escalade: 3.1.1
+      picocolors: 1.0.0
 
   /update-browserslist-db@1.0.13(browserslist@4.22.1):
     resolution: {integrity: sha512-xebP81SNcPuNpPP3uzeW1NYXxI3rxyJzF3pD6sH4jE7o/IX+WtSpwnVU+qIsDPyk0d3hmFQ7mjqc6AtV604hbg==}
@@ -14320,11 +13177,6 @@ packages:
     dependencies:
       punycode: 2.3.0
 
-  /urix@0.1.0:
-    resolution: {integrity: sha512-Am1ousAhSLBeB9cG/7k7r2R0zj50uDRlZHPGbazid5s9rlF1F/QKYObEKSIunSjIOkJZqwRRLpvewjEkM7pSqg==}
-    deprecated: Please see https://github.com/lydell/urix#deprecated
-    dev: true
-
   /url-join@4.0.1:
     resolution: {integrity: sha512-jk1+QP6ZJqyOiuEI9AEWQfju/nB2Pw466kbA0LEZljHwKeMgd9WrAEgEGxjPDD2+TNbbb37rTyhEfrCXfuKXnA==}
     dev: true
@@ -14345,13 +13197,8 @@ packages:
       prepend-http: 2.0.0
     dev: true
 
-  /use@3.1.1:
-    resolution: {integrity: sha512-cwESVXlO3url9YWlFW/TA9cshCEhtu7IKJ/p5soJ/gGpj7vbvFrAY/eIioQ6Dw23KjZhYgiIo8HOs1nQ2vr/oQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /username-sync@1.0.3:
-    resolution: {integrity: sha512-m/7/FSqjJNAzF2La448c/aEom0gJy7HY7Y509h6l0ePvEkFictAGptwWaj1msWJ38JbfEDOUoE8kqFee9EHKdA==}
+  /urlpattern-polyfill@9.0.0:
+    resolution: {integrity: sha512-WHN8KDQblxd32odxeIgo83rdVDE2bvdkb86it7bMhYZwWKJz0+O0RK/eZiHYnM+zgt/U7hAHOlCQGfjjvSkw2g==}
     dev: true
 
   /util-deprecate@1.0.2:
@@ -14367,18 +13214,13 @@ packages:
     hasBin: true
     dev: true
 
-  /uuid@9.0.0:
-    resolution: {integrity: sha512-MXcSTerfPa4uqyzStbRoTgt5XIe3x5+42+q1sDuy3R5MDk66URdLMOZe5aPX/SQd+kuYAh0FdP/pO28IkQyTeg==}
-    hasBin: true
-    dev: true
-
   /uvu@0.5.6:
     resolution: {integrity: sha512-+g8ENReyr8YsOc6fv/NVJs2vFdHBnBNdfE49rshrTzDWOlUx4Gq7KOS2GD8eqhy2j+Ejq29+SbKH8yjkAqXqoA==}
     engines: {node: '>=8'}
     hasBin: true
     dependencies:
       dequal: 2.0.3
-      diff: 5.1.0
+      diff: 5.0.0
       kleur: 4.1.5
       sade: 1.8.1
     dev: true
@@ -14393,13 +13235,6 @@ packages:
       spdx-expression-parse: 3.0.1
     dev: true
 
-  /validate-npm-package-name@5.0.0:
-    resolution: {integrity: sha512-YuKoXDAhBYxY7SfOKxHBDoSyENFeW5VvIIQp2TGQuit8gpK6MnWaQelBKxso72DoxTZfZdcP3W90LqpSkgPzLQ==}
-    engines: {node: ^14.17.0 || ^16.13.0 || >=18.0.0}
-    dependencies:
-      builtins: 5.0.1
-    dev: true
-
   /validate-peer-dependencies@1.2.0:
     resolution: {integrity: sha512-nd2HUpKc6RWblPZQ2GDuI65sxJ2n/UqZwSBVtj64xlWjMx0m7ZB2m9b2JS3v1f+n9VWH/dd1CMhkHfP6pIdckA==}
     dependencies:
@@ -14420,12 +13255,22 @@ packages:
     engines: {node: '>= 0.8'}
     dev: true
 
-  /vite@4.3.9(@types/node@18.16.6):
+  /vite-plugin-babel@1.1.3(@babel/core@7.23.2)(vite@4.5.0):
+    resolution: {integrity: sha512-WE8ORQm8530kj0geiDL1r/+P2MaU0b+5wL5E8Jq07aounFwRIUeJXziGiMr2DFQs78vaefB5GRKh257M8Z6gFQ==}
+    peerDependencies:
+      '@babel/core': ^7.0.0
+      vite: ^2.7.0 || ^3.0.0 || ^4.0.0
+    dependencies:
+      '@babel/core': 7.23.2
+      vite: 4.5.0(@types/node@20.8.10)
+    dev: true
+
+  /vite@4.3.9(@types/node@20.8.10):
     resolution: {integrity: sha512-qsTNZjO9NoJNW7KnOrgYwczm0WctJ8m/yqYAMAK9Lxt4SoySUfS5S8ia9K7JHpa3KEeMfyF8LoJ3c5NeBJy6pg==}
     engines: {node: ^14.18.0 || >=16.0.0}
     hasBin: true
     peerDependencies:
-      '@types/node': '>= 14'
+      '@types/node': ^20.8.10
       less: '*'
       sass: '*'
       stylus: '*'
@@ -14445,54 +13290,112 @@ packages:
       terser:
         optional: true
     dependencies:
-      '@types/node': 18.16.6
+      '@types/node': 20.8.10
       esbuild: 0.17.18
-      postcss: 8.4.31
+      postcss: 8.4.23
       rollup: 3.21.6
     optionalDependencies:
       fsevents: 2.3.3
+    dev: true
+
+  /vite@4.4.9(@types/node@20.8.10):
+    resolution: {integrity: sha512-2mbUn2LlUmNASWwSCNSJ/EG2HuSRTnVNaydp6vMCm5VIqJsjMfbIWtbH2kDuwUVW5mMUKKZvGPX/rqeqVvv1XA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.8.10
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+    dependencies:
+      '@types/node': 20.8.10
+      esbuild: 0.18.20
+      postcss: 8.4.31
+      rollup: 3.28.0
+    optionalDependencies:
+      fsevents: 2.3.3
+    dev: false
+
+  /vite@4.5.0(@types/node@20.8.10):
+    resolution: {integrity: sha512-ulr8rNLA6rkyFAlVWw2q5YJ91v098AFQ2R0PRFwPzREXOUJQPtFUG0t+/ZikhaOCDqFoDhN6/v8Sq0o4araFAw==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': ^20.8.10
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+    dependencies:
+      '@types/node': 20.8.10
+      esbuild: 0.18.20
+      postcss: 8.4.31
+      rollup: 3.28.0
+    optionalDependencies:
+      fsevents: 2.3.3
+    dev: true
 
   /vscode-json-languageservice@4.2.1:
     resolution: {integrity: sha512-xGmv9QIWs2H8obGbWg+sIPI/3/pFgj/5OWBhNzs00BkYQ9UaB2F6JJaGB/2/YOZJ3BvLXQTC4Q7muqU25QgAhA==}
     dependencies:
       jsonc-parser: 3.2.0
-      vscode-languageserver-textdocument: 1.0.8
-      vscode-languageserver-types: 3.17.3
+      vscode-languageserver-textdocument: 1.0.11
+      vscode-languageserver-types: 3.17.5
       vscode-nls: 5.2.0
-      vscode-uri: 3.0.7
+      vscode-uri: 3.0.8
     dev: false
 
-  /vscode-languageserver-textdocument@1.0.8:
-    resolution: {integrity: sha512-1bonkGqQs5/fxGT5UchTgjGVnfysL0O8v1AYMBjqTbWQTFn721zaPGDYFkOKtfDgFiSgXM3KwaG3FMGfW4Ed9Q==}
+  /vscode-languageserver-textdocument@1.0.11:
+    resolution: {integrity: sha512-X+8T3GoiwTVlJbicx/sIAF+yuJAqz8VvwJyoMVhwEMoEKE/fkDmrqUgDMyBECcM2A2frVZIUj5HI/ErRXCfOeA==}
     dev: false
 
-  /vscode-languageserver-types@3.17.3:
-    resolution: {integrity: sha512-SYU4z1dL0PyIMd4Vj8YOqFvHu7Hz/enbWtpfnVbJHU4Nd1YNYx8u0ennumc6h48GQNeOLxmwySmnADouT/AuZA==}
+  /vscode-languageserver-types@3.17.5:
+    resolution: {integrity: sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==}
     dev: false
 
   /vscode-nls@5.2.0:
     resolution: {integrity: sha512-RAaHx7B14ZU04EU31pT+rKz2/zSl7xMsfIZuo8pd+KZO6PXtQmpevpq3vxvWNcrGbdmhM/rr5Uw5Mz+NBfhVng==}
     dev: false
 
-  /vscode-uri@3.0.7:
-    resolution: {integrity: sha512-eOpPHogvorZRobNqJGhapa0JdwaxpjVvyBp0QIUMRMSf8ZAlqOdEquKuRmw9Qwu0qXtJIWqFtMkmvJjUZmMjVA==}
+  /vscode-uri@3.0.8:
+    resolution: {integrity: sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==}
     dev: false
 
-  /walk-sync@0.3.4:
-    resolution: {integrity: sha512-ttGcuHA/OBnN2pcM6johpYlEms7XpO5/fyKIr48541xXedan4roO8cS1Q2S/zbbjGH/BarYDAMeS2Mi9HE5Tig==}
-    dependencies:
-      ensure-posix-path: 1.1.1
-      matcher-collection: 1.1.2
-    dev: true
-
-  /walk-sync@1.1.4:
-    resolution: {integrity: sha512-nowc9thB/Jg0KW4TgxoRjLLYRPvl3DB/98S89r4ZcJqq2B0alNcKDh6pzLkBSkPMzRSMsJghJHQi79qw0YWEkA==}
-    dependencies:
-      '@types/minimatch': 3.0.5
-      ensure-posix-path: 1.1.1
-      matcher-collection: 1.1.2
-    dev: true
-
   /walk-sync@2.2.0:
     resolution: {integrity: sha512-IC8sL7aB4/ZgFcGI2T1LczZeFWZ06b3zoHH7jBPyHxOtIIz1jppWHjjEXkOFvFojBVAK9pV7g47xOZ4LW3QLfg==}
     engines: {node: 8.* || >= 10.*}
@@ -14503,33 +13406,6 @@ packages:
       minimatch: 3.1.2
     dev: true
 
-  /walk-sync@3.0.0:
-    resolution: {integrity: sha512-41TvKmDGVpm2iuH7o+DAOt06yyu/cSHpX3uzAwetzASvlNtVddgIjXIb2DfB/Wa20B1Jo86+1Dv1CraSU7hWdw==}
-    engines: {node: 10.* || >= 12.*}
-    dependencies:
-      '@types/minimatch': 3.0.5
-      ensure-posix-path: 1.1.1
-      matcher-collection: 2.0.1
-      minimatch: 3.1.2
-    dev: true
-
-  /walker@1.0.8:
-    resolution: {integrity: sha512-ts/8E8l5b7kY0vlWLewOkDXMmPdLcVV4GmOQLyxuSswIJsweeFZtAsMF7k1Nszz+TYBQrlYRmzOnr398y1JemQ==}
-    dependencies:
-      makeerror: 1.0.12
-    dev: true
-
-  /watch-detector@1.0.2:
-    resolution: {integrity: sha512-MrJK9z7kD5Gl3jHBnnBVHvr1saVGAfmkyyrvuNzV/oe0Gr1nwZTy5VSA0Gw2j2Or0Mu8HcjUa44qlBvC2Ofnpg==}
-    engines: {node: '>= 8'}
-    dependencies:
-      heimdalljs-logger: 0.1.10
-      silent-error: 1.1.1
-      tmp: 0.1.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /watchpack@2.4.0:
     resolution: {integrity: sha512-Lcvm7MGST/4fup+ifyKi2hjyIAwcdI4HRgtvTpIUxBRhB+RFtUh8XtDOxUfctVCnhVi+QQj49i91OyvzkJl6cg==}
     engines: {node: '>=10.13.0'}
@@ -14559,8 +13435,8 @@ packages:
     resolution: {integrity: sha512-kyDivFZ7ZM0BVOUteVbDFhlRt7Ah/CSPwJdi8hBpkK7QLumUqdLtVfm/PX/hkcnrvr0i77fO5+TjZ94Pe+C9iw==}
     dev: false
 
-  /webpack@5.88.2:
-    resolution: {integrity: sha512-JmcgNZ1iKj+aiR0OvTYtWQqJwq37Pf683dY9bVORwVbUrDhLhdn/PlO2sHsFHPkj7sHNQF3JwaAkp49V+Sq1tQ==}
+  /webpack@5.82.1:
+    resolution: {integrity: sha512-C6uiGQJ+Gt4RyHXXYt+v9f+SN1v83x68URwgxNQ98cvH8kxiuywWGP4XeNZ1paOzZ63aY3cTciCEQJNFUljlLw==}
     engines: {node: '>=10.13.0'}
     hasBin: true
     peerDependencies:
@@ -14569,17 +13445,17 @@ packages:
       webpack-cli:
         optional: true
     dependencies:
-      '@types/eslint-scope': 3.7.5
-      '@types/estree': 1.0.2
+      '@types/eslint-scope': 3.7.4
+      '@types/estree': 1.0.1
       '@webassemblyjs/ast': 1.11.6
       '@webassemblyjs/wasm-edit': 1.11.6
       '@webassemblyjs/wasm-parser': 1.11.6
       acorn: 8.10.0
-      acorn-import-assertions: 1.9.0(acorn@8.10.0)
+      acorn-import-assertions: 1.8.0(acorn@8.10.0)
       browserslist: 4.22.1
       chrome-trace-event: 1.0.3
-      enhanced-resolve: 5.15.0
-      es-module-lexer: 1.3.1
+      enhanced-resolve: 5.14.0
+      es-module-lexer: 1.2.1
       eslint-scope: 5.1.1
       events: 3.3.0
       glob-to-regexp: 0.4.1
@@ -14588,9 +13464,9 @@ packages:
       loader-runner: 4.3.0
       mime-types: 2.1.35
       neo-async: 2.6.2
-      schema-utils: 3.3.0
+      schema-utils: 3.1.2
       tapable: 2.2.1
-      terser-webpack-plugin: 5.3.9(webpack@5.88.2)
+      terser-webpack-plugin: 5.3.8(webpack@5.82.1)
       watchpack: 2.4.0
       webpack-sources: 3.2.3
     transitivePeerDependencies:
@@ -14598,20 +13474,6 @@ packages:
       - esbuild
       - uglify-js
 
-  /websocket-driver@0.7.4:
-    resolution: {integrity: sha512-b17KeDIQVjvb0ssuSDF2cYXSg2iztliJ4B9WdsuB6J952qCPKmnVq4DyW5motImXHDC1cBT/1UezrJVsKw5zjg==}
-    engines: {node: '>=0.8.0'}
-    dependencies:
-      http-parser-js: 0.5.8
-      safe-buffer: 5.2.1
-      websocket-extensions: 0.1.4
-    dev: true
-
-  /websocket-extensions@0.1.4:
-    resolution: {integrity: sha512-OqedPIGOfsDlo31UNwYbCFMSaO9m9G/0faIHj5/dZFDMFqPTcx6UwqyOy3COEaEOg/9VsGIpdqn62W5KhoKSpg==}
-    engines: {node: '>=0.8.0'}
-    dev: true
-
   /whatwg-url@5.0.0:
     resolution: {integrity: sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==}
     dependencies:
@@ -14627,15 +13489,27 @@ packages:
       is-string: 1.0.7
       is-symbol: 1.0.4
 
-  /which-typed-array@1.1.11:
-    resolution: {integrity: sha512-qe9UWWpkeG5yzZ0tNYxDmd7vo58HDBc39mZ0xWWpolAGADdFOzkfamWLDxkOWcvHQKVmdTyQdLD4NOfjLWTKew==}
+  /which-typed-array@1.1.13:
+    resolution: {integrity: sha512-P5Nra0qjSncduVPEAr7xhoF5guty49ArDTwzJ/yNuPIbZppyRxFQsRCWrocxIY+CnMVG+qfbU2FmDKyvSGClow==}
     engines: {node: '>= 0.4'}
     dependencies:
       available-typed-arrays: 1.0.5
-      call-bind: 1.0.2
+      call-bind: 1.0.5
+      for-each: 0.3.3
+      gopd: 1.0.1
+      has-tostringtag: 1.0.0
+
+  /which-typed-array@1.1.9:
+    resolution: {integrity: sha512-w9c4xkx6mPidwp7180ckYWfMmvxpjlZuIudNtDf4N/tTAUB8VJbX25qZoAsrtGuYNnGw3pa0AXgbGKRB8/EceA==}
+    engines: {node: '>= 0.4'}
+    dependencies:
+      available-typed-arrays: 1.0.5
+      call-bind: 1.0.5
       for-each: 0.3.3
       gopd: 1.0.1
       has-tostringtag: 1.0.0
+      is-typed-array: 1.1.10
+    dev: true
 
   /which@1.3.1:
     resolution: {integrity: sha512-HxJdYWq1MTIQbJ3nw0cqssHoTNU267KlrDuGZ1WYlxDStUtKUhOaJmh112/TZmHxxUfuJqPXSOm7tDyas0OSIQ==}
@@ -14674,37 +13548,10 @@ packages:
       execa: 5.1.1
     dev: true
 
-  /word-wrap@1.2.3:
-    resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==}
-    engines: {node: '>=0.10.0'}
-
-  /wordwrap@0.0.3:
-    resolution: {integrity: sha512-1tMA907+V4QmxV7dbRvb4/8MaRALK6q9Abid3ndMYnbyo8piisCmeONVqVSXqQA3KaP4SLt5b7ud6E2sqP8TFw==}
-    engines: {node: '>=0.4.0'}
-    dev: true
-
-  /wordwrap@1.0.0:
-    resolution: {integrity: sha512-gvVzJFlPycKc5dZN4yPkP8w7Dc37BtP1yczEneOb4uq34pXZcvrtRTmWV8W+Ume+XCxKgbjM+nevkyFPMybd4Q==}
-    dev: true
-
-  /workerpool@3.1.2:
-    resolution: {integrity: sha512-WJFA0dGqIK7qj7xPTqciWBH5DlJQzoPjsANvc3Y4hNB0SScT+Emjvt0jPPkDBUjBNngX1q9hHgt1Gfwytu6pug==}
-    dependencies:
-      '@babel/core': 7.23.2
-      object-assign: 4.1.1
-      rsvp: 4.8.5
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /workerpool@6.2.1:
     resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==}
     dev: true
 
-  /workerpool@6.4.0:
-    resolution: {integrity: sha512-i3KR1mQMNwY2wx20ozq2EjISGtQWDIfV56We+yGJ5yDs8jTwQiLLaqHlkBHITlCuJnYlVRmXegxFxZg7gqI++A==}
-    dev: true
-
   /wrap-ansi@6.2.0:
     resolution: {integrity: sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==}
     engines: {node: '>=8'}
@@ -14766,10 +13613,19 @@ packages:
         optional: true
       utf-8-validate:
         optional: true
+    dev: false
 
-  /xdg-basedir@4.0.0:
-    resolution: {integrity: sha512-PSNhEJDejZYV7h50BohL09Er9VaIefr2LMAf3OEmpCkjOi34eYyQYAXUTjEQtZJTKcF0E2UKTh+osDLsgNim9Q==}
-    engines: {node: '>=8'}
+  /ws@8.14.2:
+    resolution: {integrity: sha512-wEBG1ftX4jcglPxgFCMJmZ2PLtSbJ2Peg6TmpJFTbe9GZYOQCDPdMYu/Tm0/bGZkw8paZnJY45J4K2PZrLYq8g==}
+    engines: {node: '>=10.0.0'}
+    peerDependencies:
+      bufferutil: ^4.0.1
+      utf-8-validate: '>=5.0.2'
+    peerDependenciesMeta:
+      bufferutil:
+        optional: true
+      utf-8-validate:
+        optional: true
     dev: true
 
   /xdg-basedir@5.1.0:
@@ -14777,9 +13633,9 @@ packages:
     engines: {node: '>=12'}
     dev: true
 
-  /xo@0.54.2(eslint-import-resolver-typescript@3.5.5)(webpack@5.88.2):
-    resolution: {integrity: sha512-1S3r+ecCg8OVPtu711as+cgwxOg+WQNRgSzqZ+OHzYlsa8CpW3ych0Ve9k8Q2QG6gqO3HSpaS5AXi9D0yPUffg==}
-    engines: {node: '>=14.16'}
+  /xo@0.56.0(@types/eslint@8.44.6)(eslint-import-resolver-typescript@3.6.1)(webpack@5.82.1):
+    resolution: {integrity: sha512-ohzSqgQ8POgZ3KNaEK/gxDovb6h3cglxv8+xi9Dn7gmRe8g4qotpOZpMs5ACJhvkJDmJOhiKbk6Uq6Mx1Di9DA==}
+    engines: {node: '>=16'}
     hasBin: true
     peerDependencies:
       webpack: '>=1.11.0'
@@ -14787,56 +13643,48 @@ packages:
       webpack:
         optional: true
     dependencies:
-      '@eslint/eslintrc': 1.4.1
-      '@typescript-eslint/eslint-plugin': 5.59.5(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4)
-      '@typescript-eslint/parser': 5.59.5(eslint@8.40.0)(typescript@5.0.4)
+      '@eslint/eslintrc': 2.1.2
+      '@typescript-eslint/eslint-plugin': 6.9.1(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2)
+      '@typescript-eslint/parser': 6.9.1(eslint@8.53.0)(typescript@5.2.2)
       arrify: 3.0.0
-      cosmiconfig: 8.3.6(typescript@5.0.4)
+      cosmiconfig: 8.3.6(typescript@5.2.2)
       define-lazy-prop: 3.0.0
-      eslint: 8.40.0
-      eslint-config-prettier: 8.8.0(eslint@8.40.0)
-      eslint-config-xo: 0.43.1(eslint@8.40.0)
-      eslint-config-xo-typescript: 0.57.0(@typescript-eslint/eslint-plugin@5.59.5)(@typescript-eslint/parser@5.59.5)(eslint@8.40.0)(typescript@5.0.4)
+      eslint: 8.53.0
+      eslint-config-prettier: 8.8.0(eslint@8.53.0)
+      eslint-config-xo: 0.43.1(eslint@8.53.0)
+      eslint-config-xo-typescript: 1.0.1(@typescript-eslint/eslint-plugin@6.9.1)(@typescript-eslint/parser@6.9.1)(eslint@8.53.0)(typescript@5.2.2)
       eslint-formatter-pretty: 5.0.0
-      eslint-import-resolver-webpack: 0.13.2(eslint-plugin-import@2.27.5)(webpack@5.88.2)
-      eslint-plugin-ava: 14.0.0(eslint@8.40.0)
-      eslint-plugin-eslint-comments: 3.2.0(eslint@8.40.0)
-      eslint-plugin-import: 2.27.5(@typescript-eslint/parser@5.59.5)(eslint-import-resolver-typescript@3.5.5)(eslint-import-resolver-webpack@0.13.2)(eslint@8.40.0)
-      eslint-plugin-n: 15.7.0(eslint@8.40.0)
+      eslint-import-resolver-webpack: 0.13.2(eslint-plugin-import@2.27.5)(webpack@5.82.1)
+      eslint-plugin-ava: 14.0.0(eslint@8.53.0)
+      eslint-plugin-eslint-comments: 3.2.0(eslint@8.53.0)
+      eslint-plugin-import: 2.27.5(@typescript-eslint/parser@6.9.1)(eslint-import-resolver-typescript@3.6.1)(eslint-import-resolver-webpack@0.13.2)(eslint@8.53.0)
+      eslint-plugin-n: 16.2.0(eslint@8.53.0)
       eslint-plugin-no-use-extend-native: 0.5.0
-      eslint-plugin-prettier: 4.2.1(eslint-config-prettier@8.8.0)(eslint@8.40.0)(prettier@2.8.8)
-      eslint-plugin-unicorn: 46.0.1(eslint@8.40.0)
+      eslint-plugin-prettier: 5.0.1(@types/eslint@8.44.6)(eslint-config-prettier@8.8.0)(eslint@8.53.0)(prettier@3.0.3)
+      eslint-plugin-unicorn: 48.0.1(eslint@8.53.0)
       esm-utils: 4.1.2
       find-cache-dir: 4.0.0
       find-up: 6.3.0
       get-stdin: 9.0.0
-      get-tsconfig: 4.5.0
+      get-tsconfig: 4.7.0
       globby: 13.2.2
       imurmurhash: 0.1.4
       json-stable-stringify-without-jsonify: 1.0.1
       lodash-es: 4.17.21
-      meow: 11.0.0(typescript@5.0.4)
+      meow: 12.1.1
       micromatch: 4.0.5
       open-editor: 4.0.0
-      prettier: 2.8.8
+      prettier: 3.0.3
       semver: 7.5.4
       slash: 5.1.0
       to-absolute-glob: 3.0.0
-      typescript: 5.0.4
-      webpack: 5.88.2
+      typescript: 5.2.2
+      webpack: 5.82.1
     transitivePeerDependencies:
+      - '@types/eslint'
       - eslint-import-resolver-typescript
       - supports-color
     dev: true
-    bundledDependencies:
-      - '@typescript-eslint/eslint-plugin'
-      - '@typescript-eslint/parser'
-      - eslint-config-xo-typescript
-
-  /xtend@4.0.2:
-    resolution: {integrity: sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ==}
-    engines: {node: '>=0.4'}
-    dev: true
 
   /y18n@5.0.8:
     resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
@@ -14848,20 +13696,12 @@ packages:
   /yallist@4.0.0:
     resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
 
-  /yam@1.0.0:
-    resolution: {integrity: sha512-Hv9xxHtsJ9228wNhk03xnlDReUuWVvHwM4rIbjdAXYvHLs17xjuyF50N6XXFMN6N0omBaqgOok/MCK3At9fTAg==}
-    engines: {node: ^4.5 || 6.* || >= 7.*}
-    dependencies:
-      fs-extra: 4.0.3
-      lodash.merge: 4.6.2
-    dev: true
-
   /yaml@1.10.2:
     resolution: {integrity: sha512-r3vXyErRCYJ7wg28yvBY5VSoAF8ZvlcW9/BwUzEtUsjvX/DKs24dIkuwjtuprwJJHsbyUbLApepYTR1BN4uHrg==}
     engines: {node: '>= 6'}
 
-  /yaml@2.3.2:
-    resolution: {integrity: sha512-N/lyzTPaJasoDmfV7YTrYCI0G/3ivm/9wdG0aHuheKowWQwGTsK0Eoiw6utmzAnI6pkJa0DUVygvp3spqqEKXg==}
+  /yaml@2.3.3:
+    resolution: {integrity: sha512-zw0VAJxgeZ6+++/su5AFoqBbZbrEakwu+X0M5HmcwUiBL7AzcuPKjj5we4xfQLp78LkEMpD0cOnUhmgOVy3KdQ==}
     engines: {node: '>= 14'}
     dev: true
 
@@ -14913,6 +13753,7 @@ packages:
       string-width: 4.2.3
       y18n: 5.0.8
       yargs-parser: 21.1.1
+    dev: false
 
   /yargs@17.7.2:
     resolution: {integrity: sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==}
@@ -14945,7 +13786,3 @@ packages:
     resolution: {integrity: sha512-9bnSc/HEW2uRy67wc+T8UwauLuPJVn28jb+GtJY16iiKWyvmYJRXVT4UamsAEGQfPohgr2q4Tq0sQbQlxTfi1g==}
     engines: {node: '>=12.20'}
     dev: true
-
-settings:
-  autoInstallPeers: true
-  excludeLinksFromLockfile: false
diff --git a/test/index.html b/test/index.html
index e1cbce9bb2..72528e74ff 100644
--- a/test/index.html
+++ b/test/index.html
@@ -58,7 +58,7 @@
       });
 
       QUnit.config.urlConfig.push({
-        id: 'enable_local_should_log',
+        id: 'enable_trace_logging',
         label: 'Enable LOCAL_SHOULD_LOG (extra debug logging info)',
         tooltip: 'Enable LOCAL_SHOULD_LOG (extra debug logging info)',
       });
diff --git a/tsconfig.cjs.json b/tsconfig.cjs.json
index b5aadc836f..52cc2fef97 100644
--- a/tsconfig.cjs.json
+++ b/tsconfig.cjs.json
@@ -4,7 +4,7 @@
     "checkJs": true,
     "target": "esnext",
     "moduleResolution": "nodenext",
-    "module": "esnext",
+    "module": "NodeNext",
     "skipLibCheck": true,
     "allowSyntheticDefaultImports": true,
     "esModuleInterop": true,
diff --git a/tsconfig.json b/tsconfig.json
index d3edf4c2bb..2593955580 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -1,10 +1,12 @@
 {
   "compilerOptions": {
+    "incremental": true,
     "skipLibCheck": true,
     "module": "esnext",
     "moduleResolution": "bundler",
     "strict": true,
-    "baseUrl": "."
+    "baseUrl": ".",
+    "noEmit": true
   },
   "files": [],
   "references": [
diff --git a/vite.config.mts b/vite.config.mts
index 73a507649e..d775fcd9d8 100644
--- a/vite.config.mts
+++ b/vite.config.mts
@@ -1,9 +1,19 @@
 import { defineConfig } from 'vite';
 
 export default defineConfig({
+  optimizeDeps: {
+    include: [],
+  },
   server: {
     open: '?hidepassed',
   },
+  plugins: [
+    // react({
+    //   babel: {
+    //     plugins: [['@babel/plugin-proposal-decorators', { loose: true, version: '2023-05' }]],
+    //   },
+    // }),
+  ],
   mode: 'testing',
   resolve: {
     extensions: ['.mjs', '.js', '.mts', '.ts', '.jsx', '.tsx', '.json', '.d.ts'],