diff --git a/eslint-rules/index.js b/eslint-rules/index.js
new file mode 100644
index 00000000000..436f5be5af9
--- /dev/null
+++ b/eslint-rules/index.js
@@ -0,0 +1,9 @@
+/* eslint-disable no-undef */
+
+'use strict';
+
+module.exports = {
+  rules: {
+    'no-barrel-imports': require('./no-barrel-imports'),
+  },
+};
diff --git a/eslint-rules/no-barrel-imports.js b/eslint-rules/no-barrel-imports.js
new file mode 100644
index 00000000000..c9891282970
--- /dev/null
+++ b/eslint-rules/no-barrel-imports.js
@@ -0,0 +1,588 @@
+/* eslint-disable no-undef */
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parse } = require('@typescript-eslint/typescript-estree');
+
+const WORKSPACE_ROOT = path.resolve(__dirname, '..');
+const PACKAGES_ROOT = path.join(WORKSPACE_ROOT, 'packages');
+
+const moduleCache = new Map();
+const owningPackageCache = new Map();
+const wildcardExportsCache = new Map();
+
+// Barrels we deliberately don't rewrite imports from. `@glimmer/component`
+// has its own legacy-resolution tsconfig that can't follow deep paths;
+// `@ember/version` is a one-line shim that re-exports from `ember/version`
+// (a different package), and we want to keep `@ember/version` as the canonical
+// import path for the framework version.
+const EXCLUDED_BARRELS = new Set(['@glimmer/component', '@ember/version']);
+
+const idOrStr = (n) => (n.type === 'Identifier' ? n.name : n.value);
+
+function resolveBarrelPath(specifier) {
+  if (!specifier?.startsWith('@ember/') && !specifier?.startsWith('@glimmer/')) return null;
+  for (const ext of ['.ts', '.js']) {
+    const p = path.join(PACKAGES_ROOT, specifier, `index${ext}`);
+    if (fs.existsSync(p)) return p;
+  }
+  return null;
+}
+
+function resolveImportSource(spec, fromFile) {
+  if (!spec.startsWith('.')) return resolveBarrelPath(spec);
+  const base = path.resolve(path.dirname(fromFile), spec);
+  for (const c of [
+    base,
+    base + '.ts',
+    base + '.js',
+    path.join(base, 'index.ts'),
+    path.join(base, 'index.js'),
+  ]) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+// A name may be exported both as a value and as a type with the same identifier
+// (e.g. `export const X = ...; export type X = typeof X`). When merging entries
+// for the same name, treat the export as a value if any declaration is a value.
+function setExport(exports, name, entry) {
+  const existing = exports.get(name);
+  if (existing) {
+    exports.set(name, { ...entry, isType: existing.isType && entry.isType });
+  } else {
+    exports.set(name, entry);
+  }
+}
+
+function declarationNames(decl) {
+  if (!decl) return [];
+  switch (decl.type) {
+    case 'VariableDeclaration':
+      return decl.declarations
+        .filter((v) => v.id?.type === 'Identifier')
+        .map((v) => ({ name: v.id.name, isType: false }));
+    case 'FunctionDeclaration':
+    case 'ClassDeclaration':
+    case 'TSEnumDeclaration':
+      return decl.id ? [{ name: decl.id.name, isType: false }] : [];
+    case 'TSInterfaceDeclaration':
+    case 'TSTypeAliasDeclaration':
+    case 'TSModuleDeclaration':
+      return decl.id?.name ? [{ name: decl.id.name, isType: true }] : [];
+    default:
+      return [];
+  }
+}
+
+function getModuleExports(filepath, stack = new Set()) {
+  if (moduleCache.has(filepath)) return moduleCache.get(filepath);
+  if (stack.has(filepath)) return new Map();
+  stack.add(filepath);
+
+  let ast;
+  try {
+    ast = parse(fs.readFileSync(filepath, 'utf8'), { jsx: false, range: true, loc: true });
+  } catch {
+    moduleCache.set(filepath, null);
+    stack.delete(filepath);
+    return null;
+  }
+
+  const exports = new Map();
+  for (const stmt of ast.body) {
+    if (stmt.type === 'ExportNamedDeclaration') collectNamedExports(stmt, exports, filepath, stack);
+    else if (stmt.type === 'ExportAllDeclaration')
+      collectStarExports(stmt, exports, filepath, stack);
+    else if (stmt.type === 'ExportDefaultDeclaration') {
+      setExport(exports, 'default', {
+        source: filepath,
+        localName: 'default',
+        isType: false,
+        kind: 'local',
+      });
+    }
+  }
+
+  moduleCache.set(filepath, exports);
+  stack.delete(filepath);
+  return exports;
+}
+
+function collectNamedExports(stmt, exports, filepath, stack) {
+  const stmtIsType = stmt.exportKind === 'type';
+
+  if (stmt.declaration) {
+    for (const { name, isType } of declarationNames(stmt.declaration)) {
+      setExport(exports, name, {
+        source: filepath,
+        localName: name,
+        isType: isType || stmtIsType,
+        kind: 'local',
+      });
+    }
+    return;
+  }
+
+  if (!stmt.source) {
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec.type !== 'ExportSpecifier') continue;
+      setExport(exports, idOrStr(spec.exported), {
+        source: filepath,
+        localName: idOrStr(spec.local),
+        isType: stmtIsType || spec.exportKind === 'type',
+        kind: 'local',
+      });
+    }
+    return;
+  }
+
+  const sourceSpec = stmt.source.value;
+  const targetFile = resolveImportSource(sourceSpec, filepath);
+  const isBare = !sourceSpec.startsWith('.');
+  const nested = targetFile ? getModuleExports(targetFile, stack) : null;
+
+  for (const spec of stmt.specifiers) {
+    if (spec.type !== 'ExportSpecifier') continue;
+    const isType = stmtIsType || spec.exportKind === 'type';
+    let source = targetFile;
+    let bareSource = !targetFile && isBare ? sourceSpec : null;
+    let local = idOrStr(spec.local);
+
+    const nestedEntry = nested?.get(local);
+    if (nestedEntry && nestedEntry.kind !== 'namespace') {
+      if (nestedEntry.source) {
+        source = nestedEntry.source;
+        bareSource = null;
+        local = nestedEntry.localName;
+      } else if (nestedEntry.bareSource) {
+        source = null;
+        bareSource = nestedEntry.bareSource;
+        local = nestedEntry.localName;
+      }
+    }
+
+    setExport(exports, idOrStr(spec.exported), {
+      source,
+      bareSource,
+      localName: local,
+      isType,
+      kind: 'named',
+    });
+  }
+}
+
+function collectStarExports(stmt, exports, filepath, stack) {
+  const stmtIsType = stmt.exportKind === 'type';
+  const targetFile = resolveImportSource(stmt.source.value, filepath);
+
+  if (stmt.exported) {
+    setExport(exports, idOrStr(stmt.exported), {
+      source: targetFile,
+      isType: stmtIsType,
+      kind: 'namespace',
+    });
+    return;
+  }
+  if (!targetFile) return;
+  const nested = getModuleExports(targetFile, stack);
+  if (!nested) return;
+  for (const [name, entry] of nested) {
+    if (name === 'default' || exports.has(name)) continue;
+    exports.set(name, { ...entry, isType: entry.isType || stmtIsType });
+  }
+}
+
+const SCOPE_PREFIXES = [
+  path.join(PACKAGES_ROOT, '@ember') + path.sep,
+  path.join(PACKAGES_ROOT, '@glimmer') + path.sep,
+];
+const EXCLUDED_FILE_PREFIXES = [path.join(PACKAGES_ROOT, '@glimmer/component') + path.sep];
+const TEST_DIR_RE = /[\\/](?:test|tests)[\\/]/;
+
+const isInScope = (filename) => SCOPE_PREFIXES.some((p) => filename.startsWith(p));
+const isExcludedFile = (filename) => EXCLUDED_FILE_PREFIXES.some((p) => filename.startsWith(p));
+const isInTestFile = (filename) =>
+  TEST_DIR_RE.test(filename) || filename.includes(`${path.sep}internal-test-helpers${path.sep}`);
+
+const stripExt = (p) => p.replace(/\.(?:d\.ts|[mc]?[jt]sx?)$/, '');
+const toPosix = (p) => (path.sep === '/' ? p : p.replaceAll(path.sep, '/'));
+
+// Map an absolute file path back to (packageRoot, bareSpec) by convention:
+// `@ember/-internals/<x>` is depth-3, all other `@ember/<x>` and `@glimmer/<x>` are depth-2.
+function getPackageInfo(absFile) {
+  if (!absFile.startsWith(PACKAGES_ROOT + path.sep)) return null;
+  const parts = toPosix(absFile.slice(PACKAGES_ROOT.length + 1)).split('/');
+  const depth = parts[0] === '@ember' && parts[1] === '-internals' ? 3 : 2;
+  const bareSpec = parts.slice(0, depth).join('/');
+  return { packageRoot: path.join(PACKAGES_ROOT, ...bareSpec.split('/')), bareSpec };
+}
+
+function findOwningPackage(absFile) {
+  if (owningPackageCache.has(absFile)) return owningPackageCache.get(absFile);
+  let dir = path.dirname(absFile);
+  let result = null;
+  while (dir.length >= PACKAGES_ROOT.length && dir.startsWith(PACKAGES_ROOT)) {
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+      result = dir;
+      break;
+    }
+    dir = path.dirname(dir);
+  }
+  owningPackageCache.set(absFile, result);
+  return result;
+}
+
+function packageHasWildcardSourceExports(packageRoot) {
+  if (wildcardExportsCache.has(packageRoot)) return wildcardExportsCache.get(packageRoot);
+  let allowed = false;
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    const wildcard = pkg.exports?.['./*'];
+    const matches = (v) => v === './*.ts';
+    allowed =
+      matches(wildcard) ||
+      (wildcard && typeof wildcard === 'object' && Object.values(wildcard).some(matches));
+  } catch {
+    /* ignore */
+  }
+  wildcardExportsCache.set(packageRoot, allowed);
+  return allowed;
+}
+
+function computeNewSpecifier(targetAbs, currentFile) {
+  const targetInfo = getPackageInfo(targetAbs);
+  if (!targetInfo) return null;
+  const tail = toPosix(path.relative(targetInfo.packageRoot, targetAbs));
+  // If the target IS the package's own index file, use just the bare specifier
+  // (any `/index` suffix is redundant and confuses TS's module resolution).
+  const isPackageIndex = /^index\.[mc]?[jt]sx?$/.test(tail);
+
+  const currentInfo = getPackageInfo(currentFile);
+  if (currentInfo?.bareSpec === targetInfo.bareSpec) {
+    let rel = toPosix(path.relative(path.dirname(currentFile), targetAbs));
+    if (!rel.startsWith('.')) rel = './' + rel;
+    return { newSpec: stripExt(rel), deep: false };
+  }
+
+  if (isPackageIndex) {
+    return { newSpec: targetInfo.bareSpec, deep: false };
+  }
+
+  return {
+    newSpec: stripExt(path.posix.join(targetInfo.bareSpec, tail)),
+    deep: true,
+    owningPackageRoot: findOwningPackage(targetAbs),
+  };
+}
+
+function specPart(item, statementIsType) {
+  const typePrefix = !statementIsType && item.isType ? 'type ' : '';
+  if (item.sourceName === item.localName) return `${typePrefix}${item.sourceName}`;
+  return `${typePrefix}${item.sourceName} as ${item.localName}`;
+}
+
+function buildImportStatements(groups, allTypes) {
+  const out = [];
+  for (const [newSpec, items] of groups) {
+    const useType = allTypes || items.every((it) => it.isType);
+    const typeKw = useType ? 'type ' : '';
+    if (items.length === 1 && items[0].sourceName === 'default') {
+      out.push(`import ${typeKw}${items[0].localName} from '${newSpec}';`);
+    } else {
+      const parts = items.map((it) => specPart(it, useType));
+      out.push(`import ${typeKw}{ ${parts.join(', ')} } from '${newSpec}';`);
+    }
+  }
+  return out.join('\n');
+}
+
+function buildExportStatements(groups, allTypes) {
+  const out = [];
+  for (const [newSpec, items] of groups) {
+    const useType = allTypes || items.every((it) => it.isType);
+    const typeKw = useType ? 'type ' : '';
+    const parts = items.map((it) => {
+      const tp = !useType && it.isType ? 'type ' : '';
+      return it.sourceName === it.exportedName
+        ? `${tp}${it.sourceName}`
+        : `${tp}${it.sourceName} as ${it.exportedName}`;
+    });
+    out.push(`export ${typeKw}{ ${parts.join(', ')} } from '${newSpec}';`);
+  }
+  return out.join('\n');
+}
+
+function pushGroup(groups, key, item) {
+  const items = groups.get(key) ?? [];
+  items.push(item);
+  groups.set(key, items);
+}
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    schema: [],
+    docs: {
+      description:
+        'Disallow imports from barrel index files within @ember and @glimmer source code; prefer direct imports from source files for tree-shaking.',
+    },
+    messages: {
+      barrelImport:
+        'Avoid importing from the "{{spec}}" barrel; import directly from the source file ({{names}}).',
+      barrelImportUnresolved:
+        'Avoid importing from the "{{spec}}" barrel; import directly from the source file. Could not auto-fix: {{names}}.',
+      missingWildcardExports:
+        'Avoid importing from the "{{spec}}" barrel. Cannot auto-fix because {{packages}} {{verb}} missing `"./*": "./*.ts"` in the `exports` field — add it to enable direct imports.',
+    },
+  },
+  create(context) {
+    const { filename } = context;
+    if (!filename || !isInScope(filename) || isInTestFile(filename) || isExcludedFile(filename)) {
+      return {};
+    }
+
+    function resolveSpecifier(moduleExports, importedName, barrelPath, originalSpec) {
+      const entry = moduleExports.get(importedName);
+      if (!entry) return { unresolved: true };
+      if (entry.source === barrelPath) return { local: true };
+      let newSpec;
+      let owningPackageRoot = null;
+      if (entry.source) {
+        const computed = computeNewSpecifier(entry.source, filename);
+        newSpec = computed?.newSpec;
+        if (computed?.deep) owningPackageRoot = computed.owningPackageRoot;
+      } else if (entry.bareSource && entry.bareSource !== originalSpec) {
+        newSpec = entry.bareSource;
+      }
+      if (!newSpec) return { unresolved: true };
+      return {
+        newSpecifier: newSpec,
+        localName: entry.localName,
+        isType: entry.isType,
+        namespace: entry.kind === 'namespace',
+        owningPackageRoot,
+      };
+    }
+
+    function reportUnresolved(node, spec, names) {
+      context.report({
+        node,
+        messageId: 'barrelImportUnresolved',
+        data: { spec, names: names.join(', ') || '(see above)' },
+      });
+    }
+
+    function reportMissingExports(node, spec, packageRoots) {
+      const paths = [...packageRoots]
+        .map((root) => path.relative(WORKSPACE_ROOT, path.join(root, 'package.json')))
+        .sort();
+      context.report({
+        node,
+        messageId: 'missingWildcardExports',
+        data: {
+          spec,
+          packages: paths.join(', '),
+          verb: paths.length > 1 ? 'are' : 'is',
+        },
+      });
+    }
+
+    function collectMissingExports(items) {
+      const missing = new Set();
+      for (const item of items) {
+        if (item.owningPackageRoot && !packageHasWildcardSourceExports(item.owningPackageRoot)) {
+          missing.add(item.owningPackageRoot);
+        }
+      }
+      return missing;
+    }
+
+    function check(node) {
+      const spec = node.source?.value;
+      if (typeof spec !== 'string') return;
+      if (EXCLUDED_BARRELS.has(spec)) return;
+      const barrelPath = resolveBarrelPath(spec);
+      if (!barrelPath || filename === barrelPath) return;
+
+      const moduleExports = getModuleExports(barrelPath);
+      if (!moduleExports) {
+        reportUnresolved(node, spec, ['(could not parse barrel)']);
+        return;
+      }
+
+      if (node.type === 'ImportDeclaration')
+        return handleImport(node, moduleExports, spec, barrelPath);
+      if (node.type === 'ExportNamedDeclaration')
+        return handleExportNamed(node, moduleExports, spec, barrelPath);
+      if (node.type === 'ExportAllDeclaration') reportUnresolved(node, spec, ['*']);
+    }
+
+    function handleImport(node, moduleExports, spec, barrelPath) {
+      const isWholeTypeImport = node.importKind === 'type';
+      const groups = new Map();
+      const namespaceImports = [];
+      const kept = []; // specifiers that must stay with the original barrel spec
+      const unresolved = [];
+      let allLocal = node.specifiers.length > 0;
+
+      for (const sp of node.specifiers) {
+        if (sp.type === 'ImportNamespaceSpecifier') {
+          unresolved.push('* as ' + sp.local.name);
+          allLocal = false;
+          continue;
+        }
+        const importedName =
+          sp.type === 'ImportDefaultSpecifier'
+            ? 'default'
+            : sp.type === 'ImportSpecifier'
+              ? idOrStr(sp.imported)
+              : null;
+        if (importedName === null) continue;
+
+        const local = sp.local.name;
+        const specIsType = isWholeTypeImport || sp.importKind === 'type';
+        const r = resolveSpecifier(moduleExports, importedName, barrelPath, spec);
+
+        if (r.local) {
+          kept.push({ sourceName: importedName, localName: local, isType: specIsType });
+          continue;
+        }
+        allLocal = false;
+        if (r.unresolved) {
+          unresolved.push(importedName);
+          continue;
+        }
+        if (r.namespace) {
+          namespaceImports.push({
+            newSpec: r.newSpecifier,
+            localName: local,
+            isType: specIsType || r.isType,
+            owningPackageRoot: r.owningPackageRoot,
+          });
+          continue;
+        }
+        pushGroup(groups, r.newSpecifier, {
+          sourceName: r.localName,
+          localName: local,
+          isType: specIsType || r.isType,
+          owningPackageRoot: r.owningPackageRoot,
+        });
+      }
+
+      if (allLocal) return;
+      if (unresolved.length > 0) {
+        reportUnresolved(node, spec, unresolved);
+        return;
+      }
+      if (groups.size === 0 && namespaceImports.length === 0) return;
+
+      const allItems = [...namespaceImports, ...[...groups.values()].flat()];
+      const missing = collectMissingExports(allItems);
+      if (missing.size > 0) {
+        reportMissingExports(node, spec, missing);
+        return;
+      }
+
+      // Locally-defined symbols stay with the original barrel — they can't
+      // be sourced from a sub-file because they don't live in one.
+      for (const item of kept) pushGroup(groups, spec, item);
+
+      const statements = namespaceImports.map((ns) => {
+        const useType = isWholeTypeImport || ns.isType;
+        return `import ${useType ? 'type ' : ''}* as ${ns.localName} from '${ns.newSpec}';`;
+      });
+      if (groups.size > 0) statements.push(buildImportStatements(groups, isWholeTypeImport));
+
+      const allSpecs = [...namespaceImports.map((n) => n.newSpec), ...groups.keys()];
+      context.report({
+        node,
+        messageId: 'barrelImport',
+        data: { spec, names: allSpecs.join(', ') },
+        fix: (fixer) => fixer.replaceText(node, statements.join('\n')),
+      });
+    }
+
+    function handleExportNamed(node, moduleExports, spec, barrelPath) {
+      const isWholeTypeExport = node.exportKind === 'type';
+      const groups = new Map();
+      const namespaceExports = [];
+      const kept = [];
+      const unresolved = [];
+      let allLocal = node.specifiers.length > 0;
+
+      for (const sp of node.specifiers) {
+        if (sp.type !== 'ExportSpecifier') continue;
+        const importedName = idOrStr(sp.local);
+        const exportedName = idOrStr(sp.exported);
+        const specIsType = isWholeTypeExport || sp.exportKind === 'type';
+        const r = resolveSpecifier(moduleExports, importedName, barrelPath, spec);
+
+        if (r.local) {
+          kept.push({ sourceName: importedName, exportedName, isType: specIsType });
+          continue;
+        }
+        allLocal = false;
+        if (r.unresolved) {
+          unresolved.push(importedName);
+          continue;
+        }
+        if (r.namespace) {
+          namespaceExports.push({
+            newSpec: r.newSpecifier,
+            exportedName,
+            isType: specIsType || r.isType,
+            owningPackageRoot: r.owningPackageRoot,
+          });
+          continue;
+        }
+        pushGroup(groups, r.newSpecifier, {
+          sourceName: r.localName,
+          exportedName,
+          isType: specIsType || r.isType,
+          owningPackageRoot: r.owningPackageRoot,
+        });
+      }
+
+      if (allLocal) return;
+      if (unresolved.length > 0) {
+        reportUnresolved(node, spec, unresolved);
+        return;
+      }
+      if (groups.size === 0 && namespaceExports.length === 0) return;
+
+      const allItems = [...namespaceExports, ...[...groups.values()].flat()];
+      const missing = collectMissingExports(allItems);
+      if (missing.size > 0) {
+        reportMissingExports(node, spec, missing);
+        return;
+      }
+
+      for (const item of kept) pushGroup(groups, spec, item);
+
+      const statements = namespaceExports.map((ns) => {
+        const useType = isWholeTypeExport || ns.isType;
+        return `export ${useType ? 'type ' : ''}* as ${ns.exportedName} from '${ns.newSpec}';`;
+      });
+      if (groups.size > 0) statements.push(buildExportStatements(groups, isWholeTypeExport));
+
+      const allSpecs = [...namespaceExports.map((n) => n.newSpec), ...groups.keys()];
+      context.report({
+        node,
+        messageId: 'barrelImport',
+        data: { spec, names: allSpecs.join(', ') },
+        fix: (fixer) => fixer.replaceText(node, statements.join('\n')),
+      });
+    }
+
+    return {
+      ImportDeclaration: check,
+      ExportNamedDeclaration: (node) => node.source && check(node),
+      ExportAllDeclaration: check,
+    };
+  },
+};
diff --git a/eslint.config.mjs b/eslint.config.mjs
index 7407d64b580..02c10e37b82 100644
--- a/eslint.config.mjs
+++ b/eslint.config.mjs
@@ -1,4 +1,5 @@
 import emberInternal from 'eslint-plugin-ember-internal';
+import emberLocal from './eslint-rules/index.js';
 import importPlugin from 'eslint-plugin-import';
 import qunitPluginRecommended from 'eslint-plugin-qunit/configs/recommended';
 import disableFeatures from 'eslint-plugin-disable-features';
@@ -40,6 +41,7 @@ export default [
   {
     plugins: {
       'ember-internal': emberInternal,
+      'ember-local': emberLocal,
       'disable-features': disableFeatures,
     },
 
@@ -517,4 +519,11 @@ export default [
       '@typescript-eslint/naming-convention': 'off',
     },
   },
+  {
+    files: ['packages/@ember/**/*.{ts,js}', 'packages/@glimmer/**/*.{ts,js}'],
+    ignores: ['packages/@ember/**/tests/**', 'packages/@glimmer/**/test/**'],
+    rules: {
+      'ember-local/no-barrel-imports': 'error',
+    },
+  },
 ];
diff --git a/package.json b/package.json
index 008724da9c5..919d707db62 100644
--- a/package.json
+++ b/package.json
@@ -16,6 +16,34 @@
     },
     "./package.json": "./package.json"
   },
+  "sideEffects": [
+    "./dist/dev/**",
+    "**/@ember/-internals/glimmer/lib/setup-registry.js",
+    "**/@ember/-internals/glimmer/lib/register-curly-component.js",
+    "**/@ember/-internals/glimmer/lib/syntax/register-routing-keywords.js",
+    "**/@ember/-internals/glimmer/lib/environment.js",
+    "**/@ember/-internals/glimmer/lib/renderer.js",
+    "**/@ember/-internals/glimmer/lib/helper.js",
+    "**/@ember/-internals/glimmer/lib/helpers/element.js",
+    "**/@ember/-internals/glimmer/lib/components/input.js",
+    "**/@ember/-internals/glimmer/lib/components/textarea.js",
+    "**/@ember/-internals/glimmer/lib/components/link-to.js",
+    "**/@ember/-internals/runtime/lib/ext/rsvp.js",
+    "**/@ember/-internals/metal/lib/observer.js",
+    "**/@ember/-internals/metal/lib/decorator.js",
+    "**/@glimmer/runtime/lib/debug-render-tree-register.js",
+    "**/@glimmer/runtime/lib/component/template-only.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/expressions.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/vm.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/debugger.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/content.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/component.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/dom.js",
+    "**/@glimmer/runtime/lib/compiled/opcodes/lists.js",
+    "**/@glimmer/runtime/lib/vm/low-level.js",
+    "**/@glimmer/validator/index.js",
+    "**/@glimmer/validator/lib/validators.js"
+  ],
   "homepage": "https://emberjs.com/",
   "bugs": {
     "url": "https://github.com/emberjs/ember.js/issues"
@@ -188,6 +216,7 @@
       "@ember/-internals/runtime/lib/mixins/action_handler.js": "ember-source/@ember/-internals/runtime/lib/mixins/action_handler.js",
       "@ember/-internals/runtime/lib/mixins/comparable.js": "ember-source/@ember/-internals/runtime/lib/mixins/comparable.js",
       "@ember/-internals/runtime/lib/mixins/container_proxy.js": "ember-source/@ember/-internals/runtime/lib/mixins/container_proxy.js",
+      "@ember/-internals/runtime/lib/mixins/content-for.js": "ember-source/@ember/-internals/runtime/lib/mixins/content-for.js",
       "@ember/-internals/runtime/lib/mixins/registry_proxy.js": "ember-source/@ember/-internals/runtime/lib/mixins/registry_proxy.js",
       "@ember/-internals/runtime/lib/mixins/target_action_support.js": "ember-source/@ember/-internals/runtime/lib/mixins/target_action_support.js",
       "@ember/-internals/string/index.js": "ember-source/@ember/-internals/string/index.js",
@@ -236,9 +265,11 @@
       "@ember/enumerable/mutable.js": "ember-source/@ember/enumerable/mutable.js",
       "@ember/helper/index.js": "ember-source/@ember/helper/index.js",
       "@ember/instrumentation/index.js": "ember-source/@ember/instrumentation/index.js",
+      "@ember/instrumentation/lib/internal-instrument.js": "ember-source/@ember/instrumentation/lib/internal-instrument.js",
       "@ember/modifier/index.js": "ember-source/@ember/modifier/index.js",
       "@ember/modifier/on.js": "ember-source/@ember/modifier/on.js",
       "@ember/object/-internals.js": "ember-source/@ember/object/-internals.js",
+      "@ember/object/action.js": "ember-source/@ember/object/action.js",
       "@ember/object/compat.js": "ember-source/@ember/object/compat.js",
       "@ember/object/computed.js": "ember-source/@ember/object/computed.js",
       "@ember/object/core.js": "ember-source/@ember/object/core.js",
diff --git a/packages/@ember/-internals/container/lib/container.ts b/packages/@ember/-internals/container/lib/container.ts
index 0705d2ee2de..540fd98bb35 100644
--- a/packages/@ember/-internals/container/lib/container.ts
+++ b/packages/@ember/-internals/container/lib/container.ts
@@ -7,7 +7,7 @@ import type {
   FullName,
 } from '@ember/-internals/owner';
 import { setOwner } from '@ember/-internals/owner';
-import { dictionary } from '@ember/-internals/utils';
+import dictionary from '@ember/-internals/utils/lib/dictionary';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { DebugRegistry } from './registry';
diff --git a/packages/@ember/-internals/container/lib/registry.ts b/packages/@ember/-internals/container/lib/registry.ts
index 81111ab2ff7..9e11f2e9569 100644
--- a/packages/@ember/-internals/container/lib/registry.ts
+++ b/packages/@ember/-internals/container/lib/registry.ts
@@ -7,9 +7,10 @@ import type {
   RegisterOptions,
   Resolver,
 } from '@ember/-internals/owner';
-import { dictionary, intern } from '@ember/-internals/utils';
+import dictionary from '@ember/-internals/utils/lib/dictionary';
+import intern from '@ember/-internals/utils/lib/intern';
 import { assert } from '@ember/debug';
-import type { set } from '@ember/object';
+import type { set } from '@ember/-internals/metal/lib/property_set';
 import { DEBUG } from '@glimmer/env';
 import type { ContainerOptions, LazyInjection } from './container';
 import Container from './container';
diff --git a/packages/@ember/-internals/deprecations/index.ts b/packages/@ember/-internals/deprecations/index.ts
index b68b84b616e..bf105825bae 100644
--- a/packages/@ember/-internals/deprecations/index.ts
+++ b/packages/@ember/-internals/deprecations/index.ts
@@ -1,5 +1,5 @@
-import type { DeprecationOptions } from '@ember/debug';
-import { ENV } from '@ember/-internals/environment';
+import type { DeprecationOptions } from '@ember/debug/lib/deprecate';
+import { ENV } from '@ember/-internals/environment/lib/env';
 import { VERSION } from '@ember/version';
 import { deprecate, assert } from '@ember/debug';
 import { dasherize } from '../string/index';
diff --git a/packages/@ember/-internals/glimmer/index.ts b/packages/@ember/-internals/glimmer/index.ts
index 1e47aa55bbd..b6b5c188813 100644
--- a/packages/@ember/-internals/glimmer/index.ts
+++ b/packages/@ember/-internals/glimmer/index.ts
@@ -444,7 +444,7 @@
   @public
  */
 
-export { templateFactory as template, templateCacheCounters } from '@glimmer/opcode-compiler';
+export { default as template, templateCacheCounters } from '@glimmer/opcode-compiler/lib/template';
 
 export { default as RootTemplate } from './lib/templates/root';
 export { default as Input } from './lib/components/input';
@@ -467,13 +467,8 @@ export {
   htmlSafe,
   isHTMLSafe,
 } from './lib/utils/string';
-export {
-  Renderer,
-  _resetRenderers,
-  renderSettled,
-  renderComponent,
-  type View,
-} from './lib/renderer';
+export { _resetRenderers, renderSettled, renderComponent } from './lib/renderer';
+export { Renderer, type View } from './lib/classic-renderer';
 export {
   getTemplate,
   setTemplate,
diff --git a/packages/@ember/-internals/glimmer/lib/classic-renderer.ts b/packages/@ember/-internals/glimmer/lib/classic-renderer.ts
new file mode 100644
index 00000000000..87486c421e7
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/classic-renderer.ts
@@ -0,0 +1,372 @@
+import { privatize as P } from '@ember/-internals/container/lib/registry';
+import type { InternalOwner } from '@ember/-internals/owner';
+import { getOwner } from '@ember/-internals/owner';
+import type { Nullable } from '@ember/-internals/utility-types';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
+import { getViewElement, getViewId } from '@ember/-internals/views/lib/system/utils';
+import { assert } from '@ember/debug';
+import {
+  associateDestroyableChild,
+  destroy,
+  isDestroyed,
+  isDestroying,
+} from '@glimmer/destroyable';
+import type {
+  Bounds,
+  CurriedComponent,
+  DynamicScope as GlimmerDynamicScope,
+  Environment,
+  EvaluationContext,
+  RenderResult as GlimmerRenderResult,
+  Template,
+  TemplateFactory,
+} from '@glimmer/interfaces';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createConstRef, UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference/lib/reference';
+import type { CurriedValue } from '@glimmer/runtime/lib/curried-value';
+import { curry } from '@glimmer/runtime/lib/curried-value';
+import { createCapturedArgs, EMPTY_POSITIONAL } from '@glimmer/runtime/lib/vm/arguments';
+import { clientBuilder } from '@glimmer/runtime/lib/vm/element-builder';
+import { inTransaction } from '@glimmer/runtime/lib/environment';
+import { renderMain } from '@glimmer/runtime/lib/render';
+import { dict } from '@glimmer/util/lib/collections';
+import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
+
+import { hasDOM } from '../../browser-environment';
+import type Component from './component';
+import type ClassicComponent from './component';
+import { BOUNDS } from './component-managers/curly-symbols';
+import { createRootOutlet } from './component-managers/outlet';
+import { RootComponentDefinition } from './component-managers/root';
+import { makeRouteTemplate } from './component-managers/route-template';
+import { unwrapTemplate } from './component-managers/unwrap-template';
+import { BaseRenderer, errorLoopTransaction, type IBuilder, type RootState } from './renderer';
+import ResolverImpl from './resolver';
+import type { OutletState } from './utils/outlet';
+import OutletView from './views/outlet';
+
+export interface View {
+  parentView: Nullable<View>;
+  renderer: Renderer;
+  tagName: string | null;
+  elementId: string | null;
+  isDestroying: boolean;
+  isDestroyed: boolean;
+  [BOUNDS]: Bounds | null;
+}
+
+export class DynamicScope implements GlimmerDynamicScope {
+  constructor(
+    public view: View | null,
+    public outletState: Reference<OutletState | undefined>
+  ) {}
+
+  child() {
+    return new DynamicScope(this.view, this.outletState);
+  }
+
+  get(key: 'outletState'): Reference<OutletState | undefined> {
+    assert(
+      `Using \`-get-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`,
+      key === 'outletState'
+    );
+    return this.outletState;
+  }
+
+  set(key: 'outletState', value: Reference<OutletState | undefined>) {
+    assert(
+      `Using \`-with-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`,
+      key === 'outletState'
+    );
+    this.outletState = value;
+    return value;
+  }
+}
+
+class ClassicRootState implements RootState {
+  readonly type = 'classic';
+  public id: string;
+  public result: GlimmerRenderResult | undefined;
+  public destroyed: boolean;
+  public render: () => void;
+  readonly env: Environment;
+
+  constructor(
+    public root: Component | OutletView,
+    context: EvaluationContext,
+    owner: object,
+    template: Template,
+    self: Reference<unknown>,
+    parentElement: SimpleElement,
+    dynamicScope: DynamicScope,
+    builder: IBuilder
+  ) {
+    assert(
+      `You cannot render \`${valueForRef(self)}\` without a template.`,
+      template !== undefined
+    );
+
+    this.id = root instanceof OutletView ? guidFor(root) : getViewId(root);
+    this.result = undefined;
+    this.destroyed = false;
+    this.env = context.env;
+
+    this.render = errorLoopTransaction(() => {
+      let layout = unwrapTemplate(template).asLayout();
+
+      let iterator = renderMain(
+        context,
+        owner,
+        self,
+        builder(context.env, { element: parentElement, nextSibling: null }),
+        layout,
+        dynamicScope
+      );
+
+      let result = (this.result = iterator.sync());
+
+      associateDestroyableChild(this, result);
+
+      this.render = errorLoopTransaction(() => {
+        if (isDestroying(result) || isDestroyed(result)) return;
+
+        return result.rerender({
+          alwaysRevalidate: false,
+        });
+      });
+    });
+  }
+
+  isFor(possibleRoot: unknown): boolean {
+    return this.root === possibleRoot;
+  }
+
+  destroy() {
+    let { result, env } = this;
+
+    this.destroyed = true;
+
+    this.root = null as any;
+    this.result = undefined;
+    this.render = undefined as any;
+
+    if (result !== undefined) {
+      /*
+       Handles these scenarios:
+
+       * When roots are removed during standard rendering process, a transaction exists already
+         `.begin()` / `.commit()` are not needed.
+       * When roots are being destroyed manually (`component.append(); component.destroy() case), no
+         transaction exists already.
+       * When roots are being destroyed during `Renderer#destroy`, no transaction exists
+
+       */
+
+      inTransaction(env, () => destroy(result!));
+    }
+  }
+}
+
+interface ViewRegistry {
+  [viewId: string]: unknown;
+}
+
+export class Renderer extends BaseRenderer {
+  static override strict(
+    owner: object,
+    document: SimpleDocument | Document,
+    options: { isInteractive: boolean; hasDOM?: boolean }
+  ): BaseRenderer {
+    return new BaseRenderer(
+      owner,
+      { hasDOM: hasDOM, ...options },
+      document as SimpleDocument,
+      new ResolverImpl(),
+      clientBuilder
+    );
+  }
+
+  private _rootTemplate: Template;
+  private _viewRegistry: ViewRegistry;
+
+  static create(props: { _viewRegistry: any }): Renderer {
+    let { _viewRegistry } = props;
+    let owner = getOwner(props);
+    assert('Renderer is unexpectedly missing an owner', owner);
+    let document = owner.lookup('service:-document') as SimpleDocument;
+    let env = owner.lookup('-environment:main') as {
+      isInteractive: boolean;
+      hasDOM: boolean;
+    };
+    let rootTemplate = owner.lookup(P`template:-root`) as TemplateFactory;
+    let builder = owner.lookup('service:-dom-builder') as IBuilder;
+    return new this(owner, document, env, rootTemplate, _viewRegistry, builder);
+  }
+
+  constructor(
+    owner: InternalOwner,
+    document: SimpleDocument,
+    env: { isInteractive: boolean; hasDOM: boolean },
+    rootTemplate: TemplateFactory,
+    viewRegistry: ViewRegistry,
+    builder = clientBuilder,
+    resolver = new ResolverImpl()
+  ) {
+    super(owner, env, document, resolver, builder);
+    this._rootTemplate = rootTemplate(owner);
+    this._viewRegistry = viewRegistry || owner.lookup('-view-registry:main');
+  }
+
+  // renderer HOOKS
+
+  appendOutletView(view: OutletView, target: SimpleElement): void {
+    // TODO: This bypasses the {{outlet}} syntax so logically duplicates
+    // some of the set up code. Since this is all internal (or is it?),
+    // we can refactor this to do something more direct/less convoluted
+    // and with less setup, but get it working first
+    let outlet = createRootOutlet(view);
+    let { name, /* controller, */ template } = view.state;
+
+    let named = dict<Reference>();
+
+    named['Component'] = createConstRef(
+      makeRouteTemplate(view.owner, name, template as Template),
+      '@Component'
+    );
+
+    // TODO: is this guaranteed to be undefined? It seems to be the
+    // case in the `OutletView` class. Investigate how much that class
+    // exists as an internal implementation detail only, or if it was
+    // used outside of core. As far as I can tell, test-helpers uses
+    // it but only for `setOutletState`.
+    // named['controller'] = createConstRef(controller, '@controller');
+    // Update: at least according to the debug render tree tests, we
+    // appear to always expect this to be undefined. Not a definitive
+    // source by any means, but is useful evidence
+    named['controller'] = UNDEFINED_REFERENCE;
+    named['model'] = UNDEFINED_REFERENCE;
+
+    let args = createCapturedArgs(named, EMPTY_POSITIONAL);
+
+    this._appendDefinition(
+      view,
+      curry(0 as CurriedComponent, outlet, view.owner, args, true),
+      target
+    );
+  }
+
+  appendTo(view: ClassicComponent, target: SimpleElement): void {
+    let definition = new RootComponentDefinition(view);
+    this._appendDefinition(
+      view,
+      curry(0 as CurriedComponent, definition, this.state.owner, null, true),
+      target
+    );
+  }
+
+  _appendDefinition(
+    root: OutletView | ClassicComponent,
+    definition: CurriedValue,
+    target: SimpleElement
+  ): void {
+    let self = createConstRef(definition, 'this');
+    let dynamicScope = new DynamicScope(null, UNDEFINED_REFERENCE);
+    let rootState = new ClassicRootState(
+      root,
+      this.state.context,
+      this.state.owner,
+      this._rootTemplate,
+      self,
+      target,
+      dynamicScope,
+      this.state.builder
+    );
+    this.state.renderRoot(rootState, this);
+  }
+
+  cleanupRootFor(component: ClassicComponent): void {
+    // no need to cleanup roots if we have already been destroyed
+    if (isDestroyed(this)) {
+      return;
+    }
+
+    let roots = this.state.roots;
+
+    // traverse in reverse so we can remove items
+    // without mucking up the index
+    let i = roots.length;
+    while (i--) {
+      let root = roots[i];
+      assert('has root', root);
+      if (root.type === 'classic' && (root as ClassicRootState).isFor(component)) {
+        root.destroy();
+        roots.splice(i, 1);
+      }
+    }
+  }
+
+  remove(view: ClassicComponent): void {
+    view._transitionTo('destroying');
+
+    this.cleanupRootFor(view);
+
+    if (this.state.isInteractive) {
+      view.trigger('didDestroyElement');
+    }
+  }
+
+  get _roots() {
+    return this.state.debug.roots;
+  }
+
+  get _inRenderTransaction() {
+    return this.state.debug.inRenderTransaction;
+  }
+
+  get _isInteractive() {
+    return this.state.debug.isInteractive;
+  }
+
+  get _context() {
+    return this.state.context;
+  }
+
+  register(view: any): void {
+    let id = getViewId(view);
+    assert(
+      'Attempted to register a view with an id already in use: ' + id,
+      !this._viewRegistry[id]
+    );
+    this._viewRegistry[id] = view;
+  }
+
+  unregister(view: any): void {
+    delete this._viewRegistry[getViewId(view)];
+  }
+
+  getElement(component: View): Nullable<Element> {
+    if (this._isInteractive) {
+      return getViewElement(component);
+    } else {
+      throw new Error(
+        'Accessing `this.element` is not allowed in non-interactive environments (such as FastBoot).'
+      );
+    }
+  }
+
+  getBounds(component: View): {
+    parentElement: SimpleElement;
+    firstNode: SimpleNode;
+    lastNode: SimpleNode;
+  } {
+    let bounds: Bounds | null = component[BOUNDS];
+
+    assert('object passed to getBounds must have the BOUNDS symbol as a property', bounds);
+
+    let parentElement = bounds.parentElement();
+    let firstNode = bounds.firstNode();
+    let lastNode = bounds.lastNode();
+
+    return { parentElement, firstNode, lastNode };
+  }
+}
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/curly-symbols.ts b/packages/@ember/-internals/glimmer/lib/component-managers/curly-symbols.ts
new file mode 100644
index 00000000000..6df8d6280c1
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly-symbols.ts
@@ -0,0 +1,9 @@
+export const DIRTY_TAG: unique symbol = Symbol('DIRTY_TAG');
+export const IS_DISPATCHING_ATTRS: unique symbol = Symbol('IS_DISPATCHING_ATTRS');
+export const BOUNDS: unique symbol = Symbol('BOUNDS');
+
+export const CURLY_COMPONENT_BRAND: unique symbol = Symbol('CURLY_COMPONENT_BRAND');
+
+export function isCurlyManager(manager: object): boolean {
+  return (manager as { [CURLY_COMPONENT_BRAND]?: boolean })[CURLY_COMPONENT_BRAND] === true;
+}
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
index 44b4cdc5c61..c74f7543908 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
@@ -4,11 +4,15 @@ import {
   getOwner,
   setOwner,
 } from '@ember/-internals/owner';
-import { guidFor } from '@ember/-internals/utils';
-import { addChildView, setElementView, setViewElement } from '@ember/-internals/views';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
+import {
+  addChildView,
+  setElementView,
+  setViewElement,
+} from '@ember/-internals/views/lib/system/utils';
 import type { Nullable } from '@ember/-internals/utility-types';
 import { assert, debugFreeze } from '@ember/debug';
-import { _instrumentStart } from '@ember/instrumentation';
+import { _instrumentStart } from '@ember/instrumentation/lib/internal-instrument';
 import { DEBUG } from '@glimmer/env';
 import type {
   Bounds,
@@ -25,10 +29,15 @@ import type {
   WithDynamicLayout,
   WithDynamicTagName,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { childRefFor, createComputeRef, createPrimitiveRef, valueForRef } from '@glimmer/reference';
-import { reifyPositional } from '@glimmer/runtime';
-import { EMPTY_ARRAY } from '@glimmer/util';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import {
+  childRefFor,
+  createComputeRef,
+  createPrimitiveRef,
+  valueForRef,
+} from '@glimmer/reference/lib/reference';
+import { reifyPositional } from '@glimmer/runtime/lib/vm/arguments';
+import { EMPTY_ARRAY } from '@glimmer/util/lib/array-utils';
 import { unwrapTemplate } from './unwrap-template';
 import {
   beginTrackFrame,
@@ -36,9 +45,8 @@ import {
   consumeTag,
   endTrackFrame,
   endUntrackFrame,
-  validateTag,
-  valueForTag,
-} from '@glimmer/validator';
+} from '@glimmer/validator/lib/tracking';
+import { validateTag, valueForTag } from '@glimmer/validator/lib/validators';
 import type Component from '../component';
 import type { DynamicScope } from '../renderer';
 import type RuntimeResolver from '../resolver';
@@ -52,6 +60,7 @@ import {
 
 import ComponentStateBucket from '../utils/curly-component-state-bucket';
 import { processComponentArgs } from '../utils/process-args';
+import { BOUNDS, CURLY_COMPONENT_BRAND, DIRTY_TAG, IS_DISPATCHING_ATTRS } from './curly-symbols';
 
 const COMPONENT_ARGS_MAP = new WeakMap<object, CapturedArguments['named']>();
 
@@ -61,9 +70,7 @@ export function getComponentCapturedArgs(
   return COMPONENT_ARGS_MAP.get(component);
 }
 
-export const DIRTY_TAG = Symbol('DIRTY_TAG');
-export const IS_DISPATCHING_ATTRS = Symbol('IS_DISPATCHING_ATTRS');
-export const BOUNDS = Symbol('BOUNDS');
+export { BOUNDS, DIRTY_TAG, IS_DISPATCHING_ATTRS } from './curly-symbols';
 
 const EMBER_VIEW_REF = createPrimitiveRef('ember-view');
 
@@ -552,7 +559,6 @@ const CURLY_CAPABILITIES: InternalComponentCapabilities = {
 };
 
 export const CURLY_COMPONENT_MANAGER = new CurlyComponentManager();
+(CURLY_COMPONENT_MANAGER as unknown as Record<symbol, boolean>)[CURLY_COMPONENT_BRAND] = true;
 
-export function isCurlyManager(manager: object): boolean {
-  return manager === CURLY_COMPONENT_MANAGER;
-}
+export { CURLY_COMPONENT_BRAND, isCurlyManager } from './curly-symbols';
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts b/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts
index 77c8d793479..88fb9353f69 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/mount.ts
@@ -18,9 +18,9 @@ import type {
   WithSubOwner,
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
-import { capabilityFlagsFrom } from '@glimmer/manager';
-import type { Reference } from '@glimmer/reference';
-import { createConstRef, valueForRef } from '@glimmer/reference';
+import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createConstRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { unwrapTemplate } from './unwrap-template';
 import type RuntimeResolver from '../resolver';
 
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
index f140f5f34a5..b56684b04de 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
@@ -2,7 +2,7 @@ import type { InternalOwner } from '@ember/-internals/owner';
 import type { Nullable } from '@ember/-internals/utility-types';
 import { assert } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
-import { _instrumentStart } from '@ember/instrumentation';
+import { _instrumentStart } from '@ember/instrumentation/lib/internal-instrument';
 import { precompileTemplate } from '@ember/template-compilation';
 import type {
   CompilableProgram,
@@ -15,10 +15,10 @@ import type {
   WithCreateInstance,
   WithCustomDebugRenderTree,
 } from '@glimmer/interfaces';
-import { capabilityFlagsFrom } from '@glimmer/manager';
-import type { Reference } from '@glimmer/reference';
-import { UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference';
-import { EMPTY_ARGS } from '@glimmer/runtime';
+import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference/lib/reference';
+import { EMPTY_ARGS } from '@glimmer/runtime/lib/vm/arguments';
 import { unwrapTemplate } from './unwrap-template';
 
 import type { DynamicScope } from '../renderer';
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/root.ts b/packages/@ember/-internals/glimmer/lib/component-managers/root.ts
index a0488f74488..c05e0500a91 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/root.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/root.ts
@@ -1,6 +1,6 @@
-import { getFactoryFor } from '@ember/-internals/container';
+import { getFactoryFor } from '@ember/-internals/container/lib/container';
 import { assert } from '@ember/debug';
-import { _instrumentStart } from '@ember/instrumentation';
+import { _instrumentStart } from '@ember/instrumentation/lib/internal-instrument';
 import { DEBUG } from '@glimmer/env';
 import type {
   ComponentDefinition,
@@ -10,8 +10,9 @@ import type {
   VMArguments,
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
-import { capabilityFlagsFrom } from '@glimmer/manager';
-import { CONSTANT_TAG, consumeTag } from '@glimmer/validator';
+import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
+import { CONSTANT_TAG } from '@glimmer/validator/lib/validators';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
 import type Component from '../component';
 import type { DynamicScope } from '../renderer';
 import ComponentStateBucket from '../utils/curly-component-state-bucket';
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts b/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
index bfb6a4ba09b..1d578b97e40 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
@@ -1,5 +1,5 @@
 import type { InternalOwner } from '@ember/-internals/owner';
-import { _instrumentStart } from '@ember/instrumentation';
+import { _instrumentStart } from '@ember/instrumentation/lib/internal-instrument';
 import type {
   CapturedArguments,
   CompilableProgram,
@@ -15,10 +15,10 @@ import type {
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
 import { DEBUG } from '@glimmer/env';
-import { capabilityFlagsFrom } from '@glimmer/manager';
-import type { Reference } from '@glimmer/reference';
-import { createDebugAliasRef, valueForRef } from '@glimmer/reference';
-import { curry, type CurriedValue } from '@glimmer/runtime';
+import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createDebugAliasRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { curry, type CurriedValue } from '@glimmer/runtime/lib/curried-value';
 import { unwrapTemplate } from './unwrap-template';
 
 interface RouteTemplateInstanceState {
diff --git a/packages/@ember/-internals/glimmer/lib/component.ts b/packages/@ember/-internals/glimmer/lib/component.ts
index d66842da331..2040dc62592 100644
--- a/packages/@ember/-internals/glimmer/lib/component.ts
+++ b/packages/@ember/-internals/glimmer/lib/component.ts
@@ -1,40 +1,31 @@
-import type { View } from '@ember/-internals/glimmer';
-import {
-  descriptorForProperty,
-  get,
-  nativeDescDecorator,
-  PROPERTY_DID_CHANGE,
-} from '@ember/-internals/metal';
-import type { PropertyDidChange } from '@ember/-internals/metal';
+import type { View } from './renderer';
+import { descriptorForProperty, nativeDescDecorator } from '@ember/-internals/metal/lib/decorator';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { PROPERTY_DID_CHANGE } from '@ember/-internals/metal/lib/property_events';
+import type { PropertyDidChange } from '@ember/-internals/metal/lib/property_events';
 import { getOwner } from '@ember/-internals/owner';
-import { TargetActionSupport } from '@ember/-internals/runtime';
-import type { ViewStates } from '@ember/-internals/views';
+import TargetActionSupport from '@ember/-internals/runtime/lib/mixins/target_action_support';
+import type ViewStates from '@ember/-internals/views/lib/views/states';
+import ActionSupport from '@ember/-internals/views/lib/mixins/action_support';
 import {
-  ActionSupport,
   addChildView,
-  CoreView,
-  EventDispatcher,
   getChildViews,
   getViewElement,
-} from '@ember/-internals/views';
-import { guidFor } from '@ember/-internals/utils';
+} from '@ember/-internals/views/lib/system/utils';
+import CoreView from '@ember/-internals/views/lib/views/core_view';
+import EventDispatcher from '@ember/-internals/views/lib/system/event_dispatcher';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { Environment, Template, TemplateFactory } from '@glimmer/interfaces';
-import { setInternalComponentManager } from '@glimmer/manager';
-import { isUpdatableRef, updateRef } from '@glimmer/reference';
-import { normalizeProperty } from '@glimmer/runtime';
-import type { DirtyableTag } from '@glimmer/validator';
-import { createTag, dirtyTag } from '@glimmer/validator';
+import { isUpdatableRef, updateRef } from '@glimmer/reference/lib/reference';
+import { normalizeProperty } from '@glimmer/runtime/lib/dom/props';
+import type { DirtyableTag } from '@glimmer/interfaces';
+import { createTag, DIRTY_TAG as dirtyTag } from '@glimmer/validator/lib/validators';
 import type { SimpleElement } from '@simple-dom/interface';
-import {
-  BOUNDS,
-  CURLY_COMPONENT_MANAGER,
-  DIRTY_TAG,
-  IS_DISPATCHING_ATTRS,
-  getComponentCapturedArgs,
-} from './component-managers/curly';
-import { hasDOM } from '@ember/-internals/browser-environment';
+import { getComponentCapturedArgs } from './component-managers/curly';
+import { BOUNDS, DIRTY_TAG, IS_DISPATCHING_ATTRS } from './component-managers/curly-symbols';
+import hasDOM from '@ember/-internals/browser-environment/lib/has-dom';
 
 // Keep track of which component classes have already been processed for lazy event setup.
 let lazyEventsProcessed = new WeakMap<EventDispatcher, WeakSet<object>>();
@@ -1685,11 +1676,4 @@ class Component<S = unknown>
   }
 }
 
-// We continue to use reopenClass here so that positionalParams can be overridden with reopenClass in subclasses.
-Component.reopenClass({
-  positionalParams: [],
-});
-
-setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
-
 export default Component;
diff --git a/packages/@ember/-internals/glimmer/lib/components/abstract-input.ts b/packages/@ember/-internals/glimmer/lib/components/abstract-input.ts
index 01bae28b626..5f84f710373 100644
--- a/packages/@ember/-internals/glimmer/lib/components/abstract-input.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/abstract-input.ts
@@ -1,8 +1,13 @@
-import { tracked } from '@ember/-internals/metal';
+import { tracked } from '@ember/-internals/metal/lib/tracked';
 import { assert } from '@ember/debug';
-import { action } from '@ember/object';
-import type { Reference } from '@glimmer/reference';
-import { isConstRef, isUpdatableRef, updateRef, valueForRef } from '@glimmer/reference';
+import { action } from '@ember/object/action';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import {
+  isConstRef,
+  isUpdatableRef,
+  updateRef,
+  valueForRef,
+} from '@glimmer/reference/lib/reference';
 import type { EventListener } from './internal';
 import InternalComponent from './internal';
 
diff --git a/packages/@ember/-internals/glimmer/lib/components/input.ts b/packages/@ember/-internals/glimmer/lib/components/input.ts
index 6401d7a2864..0bb706c7dce 100644
--- a/packages/@ember/-internals/glimmer/lib/components/input.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/input.ts
@@ -1,12 +1,12 @@
 /**
 @module @ember/component
 */
-import { hasDOM } from '@ember/-internals/browser-environment';
+import hasDOM from '@ember/-internals/browser-environment/lib/has-dom';
 import { type Opaque } from '@ember/-internals/utility-types';
 import { assert, warn } from '@ember/debug';
-import { action } from '@ember/object';
-import { valueForRef } from '@glimmer/reference';
-import { untrack } from '@glimmer/validator';
+import { action } from '@ember/object/action';
+import { valueForRef } from '@glimmer/reference/lib/reference';
+import { untrack } from '@glimmer/validator/lib/tracking';
 import InputTemplate from '../templates/input';
 import AbstractInput, { valueFrom } from './abstract-input';
 import { type OpaqueInternalComponentConstructor, opaquify } from './internal';
diff --git a/packages/@ember/-internals/glimmer/lib/components/internal.ts b/packages/@ember/-internals/glimmer/lib/components/internal.ts
index 9bd6c132b6a..cd5571b35dc 100644
--- a/packages/@ember/-internals/glimmer/lib/components/internal.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/internal.ts
@@ -1,6 +1,6 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import { setOwner } from '@ember/-internals/owner';
-import { guidFor } from '@ember/-internals/utils';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
 import { assert } from '@ember/debug';
 import type {
   CapturedArguments,
@@ -13,10 +13,11 @@ import type {
   VMArguments,
   WithCreateInstance,
 } from '@glimmer/interfaces';
-import { setComponentTemplate, setInternalComponentManager } from '@glimmer/manager';
-import type { Reference } from '@glimmer/reference';
-import { createConstRef, isConstRef, valueForRef } from '@glimmer/reference';
-import { untrack } from '@glimmer/validator';
+import { setComponentTemplate } from '@glimmer/manager/lib/public/template';
+import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createConstRef, isConstRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { untrack } from '@glimmer/validator/lib/tracking';
 
 function NOOP(): void {}
 
diff --git a/packages/@ember/-internals/glimmer/lib/components/link-to.ts b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
index a8c55b759e0..3199f0e064b 100644
--- a/packages/@ember/-internals/glimmer/lib/components/link-to.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
@@ -1,16 +1,18 @@
 import type Route from '@ember/routing/route';
 import type { RouterState, RoutingService } from '@ember/routing/-internals';
-import { isSimpleClick } from '@ember/-internals/views';
-import { assert, debugFreeze, inspect, warn } from '@ember/debug';
+import { isSimpleClick } from '@ember/-internals/views/lib/system/utils';
+import inspect from '@ember/debug/lib/inspect';
+import { assert, debugFreeze, warn } from '@ember/debug';
 import { getEngineParent } from '@ember/engine/parent';
 import type EngineInstance from '@ember/engine/instance';
-import { flaggedInstrument } from '@ember/instrumentation';
-import { action } from '@ember/object';
+import { flaggedInstrument } from '@ember/instrumentation/lib/internal-instrument';
+import { action } from '@ember/object/action';
 import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
 import type { Maybe } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
-import { consumeTag, createCache, getValue, tagFor, untrack } from '@glimmer/validator';
+import { consumeTag, createCache, getValue, untrack } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
 import type { Transition } from 'router_js';
 import LinkToTemplate from '../templates/link-to';
 import InternalComponent, { type OpaqueInternalComponentConstructor, opaquify } from './internal';
diff --git a/packages/@ember/-internals/glimmer/lib/components/textarea.ts b/packages/@ember/-internals/glimmer/lib/components/textarea.ts
index 3ab5f40c178..c50beee6abf 100644
--- a/packages/@ember/-internals/glimmer/lib/components/textarea.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/textarea.ts
@@ -2,7 +2,7 @@
 @module @ember/component
 */
 import { type Opaque } from '@ember/-internals/utility-types';
-import { action } from '@ember/object';
+import { action } from '@ember/object/action';
 import TextareaTemplate from '../templates/textarea';
 import AbstractInput from './abstract-input';
 import { type OpaqueInternalComponentConstructor, opaquify } from './internal';
diff --git a/packages/@ember/-internals/glimmer/lib/dom.ts b/packages/@ember/-internals/glimmer/lib/dom.ts
index 23731e97af5..d9b07fe2c22 100644
--- a/packages/@ember/-internals/glimmer/lib/dom.ts
+++ b/packages/@ember/-internals/glimmer/lib/dom.ts
@@ -1,7 +1,6 @@
-export {
-  DOMChanges,
-  DOMTreeConstruction,
-  clientBuilder,
-  rehydrationBuilder,
-} from '@glimmer/runtime';
-export { NodeDOMTreeConstruction, serializeBuilder } from '@glimmer/node';
+export { DOMChanges } from '@glimmer/runtime/lib/dom/helper';
+export { DOMTreeConstruction } from '@glimmer/runtime/lib/dom/api';
+export { clientBuilder } from '@glimmer/runtime/lib/vm/element-builder';
+export { rehydrationBuilder } from '@glimmer/runtime/lib/vm/rehydrate-builder';
+export { default as NodeDOMTreeConstruction } from '@glimmer/node/lib/node-dom-helper';
+export { serializeBuilder } from '@glimmer/node/lib/serialize-builder';
diff --git a/packages/@ember/-internals/glimmer/lib/environment.ts b/packages/@ember/-internals/glimmer/lib/environment.ts
index 2ebcbdea8e5..fc2d99f4f4d 100644
--- a/packages/@ember/-internals/glimmer/lib/environment.ts
+++ b/packages/@ember/-internals/glimmer/lib/environment.ts
@@ -1,15 +1,16 @@
-import { ENV } from '@ember/-internals/environment';
-import { get, set, _getProp, _setProp } from '@ember/-internals/metal';
+import { ENV } from '@ember/-internals/environment/lib/env';
+import { get, _getProp } from '@ember/-internals/metal/lib/property_get';
+import { set, _setProp } from '@ember/-internals/metal/lib/property_set';
 import type { InternalOwner } from '@ember/-internals/owner';
-import { getDebugName } from '@ember/-internals/utils';
-import { constructStyleDeprecationMessage } from '@ember/-internals/views';
+import getDebugName from '@ember/-internals/utils/lib/get-debug-name';
+import { constructStyleDeprecationMessage } from '@ember/-internals/views/lib/system/utils';
 import { assert, deprecate, warn } from '@ember/debug';
-import type { DeprecationOptions } from '@ember/debug';
+import type { DeprecationOptions } from '@ember/debug/lib/deprecate';
 import { schedule, _backburner } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import setGlobalContext from '@glimmer/global-context';
-import type { EnvironmentDelegate } from '@glimmer/runtime';
-import { debug } from '@glimmer/validator';
+import type { EnvironmentDelegate } from '@glimmer/runtime/lib/environment';
+import { debug } from '@glimmer/validator/lib/debug';
 import toIterator from './utils/iterator';
 import { isHTMLSafe } from './utils/string';
 import toBool from './utils/to-bool';
diff --git a/packages/@ember/-internals/glimmer/lib/helper.ts b/packages/@ember/-internals/glimmer/lib/helper.ts
index a538c33aeed..9f99e1d9829 100644
--- a/packages/@ember/-internals/glimmer/lib/helper.ts
+++ b/packages/@ember/-internals/glimmer/lib/helper.ts
@@ -2,17 +2,20 @@
 @module @ember/component
 */
 
-import type { InternalFactoryManager } from '@ember/-internals/container';
+import type { InternalFactoryManager } from '@ember/-internals/container/lib/container';
 import type { InternalFactory, InternalOwner } from '@ember/-internals/owner';
 import { setOwner } from '@ember/-internals/owner';
 import { FrameworkObject } from '@ember/object/-internals';
-import { getDebugName } from '@ember/-internals/utils';
+import getDebugName from '@ember/-internals/utils/lib/get-debug-name';
 import { assert } from '@ember/debug';
 import { join } from '@ember/runloop';
 import type { Arguments, HelperManager } from '@glimmer/interfaces';
-import { getInternalHelperManager, helperCapabilities, setHelperManager } from '@glimmer/manager';
-import type { DirtyableTag } from '@glimmer/validator';
-import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
+import { getInternalHelperManager } from '@glimmer/manager/lib/internal/api';
+import { helperCapabilities } from '@glimmer/manager/lib/public/helper';
+import { setHelperManager } from '@glimmer/manager/lib/public/api';
+import type { DirtyableTag } from '@glimmer/interfaces';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { createTag, DIRTY_TAG as dirtyTag } from '@glimmer/validator/lib/validators';
 
 const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
 
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.ts b/packages/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.ts
index 6f821c8c171..00903f55928 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.ts
@@ -3,7 +3,7 @@
 */
 import { assert } from '@ember/debug';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 export default internalHelper(({ positional, named }: CapturedArguments) => {
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.ts b/packages/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.ts
index 10fc222f5fe..04ea40921ad 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.ts
@@ -1,7 +1,7 @@
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { CapturedArguments, Helper } from '@glimmer/interfaces';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 let helper: Helper;
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/-normalize-class.ts b/packages/@ember/-internals/glimmer/lib/helpers/-normalize-class.ts
index 5603e12c135..6c8dfc656ff 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/-normalize-class.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/-normalize-class.ts
@@ -1,7 +1,7 @@
 import { assert } from '@ember/debug';
 import { dasherize } from '@ember/-internals/string';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 export default internalHelper(({ positional }: CapturedArguments) => {
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/-resolve.ts b/packages/@ember/-internals/glimmer/lib/helpers/-resolve.ts
index 71bd9f3ff43..b7386154056 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/-resolve.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/-resolve.ts
@@ -5,7 +5,7 @@ import type { FullName, InternalOwner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createConstRef, isConstRef, valueForRef } from '@glimmer/reference';
+import { createConstRef, isConstRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 export default internalHelper(
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/-track-array.ts b/packages/@ember/-internals/glimmer/lib/helpers/-track-array.ts
index c380be4737d..607015a4a55 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/-track-array.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/-track-array.ts
@@ -1,12 +1,12 @@
 /**
 @module ember
 */
-import { tagForProperty } from '@ember/-internals/metal';
-import { isObject } from '@ember/-internals/utils';
+import { tagForProperty } from '@ember/-internals/metal/lib/tags';
+import { isObject } from '@ember/-internals/utils/lib/spec';
 import { assert } from '@ember/debug';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
-import { consumeTag } from '@glimmer/validator';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
 import { internalHelper } from './internal-helper';
 
 /**
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/each-in.ts b/packages/@ember/-internals/glimmer/lib/helpers/each-in.ts
index 682d71b7c8a..a591a16005f 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/each-in.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/each-in.ts
@@ -1,13 +1,13 @@
 /**
 @module ember
 */
-import { tagForObject } from '@ember/-internals/metal';
-import { _contentFor } from '@ember/-internals/runtime';
-import { isProxy } from '@ember/-internals/utils';
+import { tagForObject } from '@ember/-internals/metal/lib/tags';
+import { contentFor as _contentFor } from '@ember/-internals/runtime/lib/mixins/content-for';
+import { isProxy } from '@ember/-internals/utils/lib/is_proxy';
 import { assert } from '@ember/debug';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
-import { consumeTag } from '@glimmer/validator';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
 import { internalHelper } from './internal-helper';
 
 /**
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/element.ts b/packages/@ember/-internals/glimmer/lib/helpers/element.ts
index 7c2aefec1a8..d8800ff9d88 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/element.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/element.ts
@@ -3,8 +3,8 @@
 */
 
 import type { CapturedArguments, InternalComponentManager } from '@glimmer/interfaces';
-import { createComputeRef, valueForRef, NULL_REFERENCE } from '@glimmer/reference';
-import { setInternalComponentManager } from '@glimmer/manager';
+import { createComputeRef, valueForRef, NULL_REFERENCE } from '@glimmer/reference/lib/reference';
+import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { internalHelper } from './internal-helper';
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts b/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts
index f474a052e6e..c11617194c9 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/internal-helper.ts
@@ -1,6 +1,6 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import type { Helper, HelperDefinitionState } from '@glimmer/interfaces';
-import { setInternalHelperManager } from '@glimmer/manager';
+import { setInternalHelperManager } from '@glimmer/manager/lib/internal/api';
 
 export function internalHelper(helper: Helper<InternalOwner>): HelperDefinitionState {
   return setInternalHelperManager(helper, {});
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/mut.ts b/packages/@ember/-internals/glimmer/lib/helpers/mut.ts
index 2c75d05fbc2..94bb9c2106c 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/mut.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/mut.ts
@@ -3,7 +3,7 @@
 */
 import { assert } from '@ember/debug';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createInvokableRef, isUpdatableRef } from '@glimmer/reference';
+import { createInvokableRef, isUpdatableRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 /**
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/readonly.ts b/packages/@ember/-internals/glimmer/lib/helpers/readonly.ts
index 503eeefb44c..b251f82069b 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/readonly.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/readonly.ts
@@ -2,7 +2,7 @@
 @module ember
 */
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createReadOnlyRef } from '@glimmer/reference';
+import { createReadOnlyRef } from '@glimmer/reference/lib/reference';
 import { assert } from '@ember/debug';
 import { internalHelper } from './internal-helper';
 
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/unbound.ts b/packages/@ember/-internals/glimmer/lib/helpers/unbound.ts
index 402604cfbd1..637daeb8ce0 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/unbound.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/unbound.ts
@@ -4,7 +4,7 @@
 
 import { assert } from '@ember/debug';
 import type { CapturedArguments } from '@glimmer/interfaces';
-import { createUnboundRef, valueForRef } from '@glimmer/reference';
+import { createUnboundRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 /**
diff --git a/packages/@ember/-internals/glimmer/lib/helpers/unique-id.ts b/packages/@ember/-internals/glimmer/lib/helpers/unique-id.ts
index edf1d29eeab..bb02f12de21 100644
--- a/packages/@ember/-internals/glimmer/lib/helpers/unique-id.ts
+++ b/packages/@ember/-internals/glimmer/lib/helpers/unique-id.ts
@@ -25,8 +25,8 @@
   @public
   */
 
-import type { Reference } from '@glimmer/reference';
-import { createConstRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createConstRef } from '@glimmer/reference/lib/reference';
 import { internalHelper } from './internal-helper';
 
 export default internalHelper((): Reference<string> => {
diff --git a/packages/@ember/-internals/glimmer/lib/register-classic-helper.ts b/packages/@ember/-internals/glimmer/lib/register-classic-helper.ts
new file mode 100644
index 00000000000..5018abe63ea
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/register-classic-helper.ts
@@ -0,0 +1,28 @@
+import { DEBUG } from '@glimmer/env';
+import { setInternalHelperManager } from '@glimmer/manager/lib/internal/api';
+
+import { CLASSIC_HELPER_MANAGER, isClassicHelper } from './helper';
+import { registerClassicHelperHandler } from './resolver';
+
+const CLASSIC_HELPER_MANAGER_ASSOCIATED = new WeakSet();
+
+registerClassicHelperHandler((definition, factory) => {
+  if (!isClassicHelper(definition)) return null;
+
+  // For classic class based helpers, we need to pass the factoryFor result
+  // itself rather than the raw value (`factoryFor(...).class`). This is
+  // because injections are already bound in the factoryFor result, including
+  // type-based injections.
+  if (DEBUG) {
+    // In DEBUG we need to only set the associated value once, otherwise
+    // we'll trigger an assertion.
+    if (!CLASSIC_HELPER_MANAGER_ASSOCIATED.has(factory)) {
+      CLASSIC_HELPER_MANAGER_ASSOCIATED.add(factory);
+      setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
+    }
+  } else {
+    setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
+  }
+
+  return factory;
+});
diff --git a/packages/@ember/-internals/glimmer/lib/register-curly-component.ts b/packages/@ember/-internals/glimmer/lib/register-curly-component.ts
new file mode 100644
index 00000000000..cec33796b74
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/register-curly-component.ts
@@ -0,0 +1,10 @@
+import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+
+import Component from './component';
+import { CURLY_COMPONENT_MANAGER } from './component-managers/curly';
+
+Component.reopenClass({
+  positionalParams: [],
+});
+
+setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
diff --git a/packages/@ember/-internals/glimmer/lib/renderer.ts b/packages/@ember/-internals/glimmer/lib/renderer.ts
index cfc74e0e423..07409bcf277 100644
--- a/packages/@ember/-internals/glimmer/lib/renderer.ts
+++ b/packages/@ember/-internals/glimmer/lib/renderer.ts
@@ -1,9 +1,5 @@
-import { privatize as P } from '@ember/-internals/container';
-import { ENV } from '@ember/-internals/environment';
+import { ENV } from '@ember/-internals/environment/lib/env';
 import type { InternalOwner } from '@ember/-internals/owner';
-import { getOwner } from '@ember/-internals/owner';
-import { guidFor } from '@ember/-internals/utils';
-import { getViewElement, getViewId } from '@ember/-internals/views';
 import { assert } from '@ember/debug';
 import { _backburner, _getCurrentRunLoop } from '@ember/runloop';
 import {
@@ -15,91 +11,36 @@ import {
 } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
 import type {
-  Bounds,
+  ClassicResolver,
   Cursor,
   DebugRenderTree,
   Environment,
-  DynamicScope as GlimmerDynamicScope,
-  RenderResult as GlimmerRenderResult,
-  Template,
-  TemplateFactory,
   EvaluationContext,
-  CurriedComponent,
+  RenderResult as GlimmerRenderResult,
   TreeBuilder,
-  ClassicResolver,
 } from '@glimmer/interfaces';
+import { artifacts } from '@glimmer/program/lib/helpers';
+import { RuntimeOpImpl } from '@glimmer/program/lib/opcode';
+import { renderComponent as glimmerRenderComponent } from '@glimmer/runtime/lib/render';
+import { clientBuilder } from '@glimmer/runtime/lib/vm/element-builder';
+import { inTransaction, runtimeOptions } from '@glimmer/runtime/lib/environment';
+import { EvaluationContextImpl } from '@glimmer/opcode-compiler/lib/program-context';
+import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
+import type { SimpleDocument, SimpleElement } from '@simple-dom/interface';
 
-import type { Nullable } from '@ember/-internals/utility-types';
-import { artifacts, RuntimeOpImpl } from '@glimmer/program';
-import type { Reference } from '@glimmer/reference';
-import { createConstRef, UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference';
-import type { CurriedValue } from '@glimmer/runtime';
-import {
-  clientBuilder,
-  createCapturedArgs,
-  curry,
-  EMPTY_POSITIONAL,
-  inTransaction,
-  renderComponent as glimmerRenderComponent,
-  renderMain,
-  runtimeOptions,
-} from '@glimmer/runtime';
-import { dict } from '@glimmer/util';
-import { unwrapTemplate } from './component-managers/unwrap-template';
-import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator';
-import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
-import RSVP from 'rsvp';
-import type Component from './component';
 import { hasDOM } from '../../browser-environment';
-import type ClassicComponent from './component';
-import { BOUNDS } from './component-managers/curly';
-import { createRootOutlet } from './component-managers/outlet';
-import { RootComponentDefinition } from './component-managers/root';
 import { EmberEnvironmentDelegate } from './environment';
 import ResolverImpl from './resolver';
-import type { OutletState } from './utils/outlet';
-import OutletView from './views/outlet';
-import { makeRouteTemplate } from './component-managers/route-template';
-import { EvaluationContextImpl } from '@glimmer/opcode-compiler';
 
 export type IBuilder = (env: Environment, cursor: Cursor) => TreeBuilder;
 
-export interface View {
-  parentView: Nullable<View>;
-  renderer: Renderer;
-  tagName: string | null;
-  elementId: string | null;
-  isDestroying: boolean;
-  isDestroyed: boolean;
-  [BOUNDS]: Bounds | null;
-}
-
-export class DynamicScope implements GlimmerDynamicScope {
-  constructor(
-    public view: View | null,
-    public outletState: Reference<OutletState | undefined>
-  ) {}
-
-  child() {
-    return new DynamicScope(this.view, this.outletState);
-  }
-
-  get(key: 'outletState'): Reference<OutletState | undefined> {
-    assert(
-      `Using \`-get-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`,
-      key === 'outletState'
-    );
-    return this.outletState;
-  }
-
-  set(key: 'outletState', value: Reference<OutletState | undefined>) {
-    assert(
-      `Using \`-with-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`,
-      key === 'outletState'
-    );
-    this.outletState = value;
-    return value;
-  }
+export interface RootState {
+  readonly type: 'classic' | 'component';
+  readonly destroyed: boolean;
+  readonly result: GlimmerRenderResult | undefined;
+  render(): void;
+  destroy(): void;
+  isFor(possibleRoot: unknown): boolean;
 }
 
 const NO_OP = () => {};
@@ -107,7 +48,7 @@ const NO_OP = () => {};
 // This wrapper logic prevents us from rerendering in case of a hard failure
 // during render. This prevents infinite revalidation type loops from occuring,
 // and ensures that errors are not swallowed by subsequent follow on failures.
-function errorLoopTransaction(fn: () => void) {
+export function errorLoopTransaction(fn: () => void) {
   if (DEBUG) {
     return () => {
       let didError = true;
@@ -133,9 +74,7 @@ function errorLoopTransaction(fn: () => void) {
   }
 }
 
-type RootState = ClassicRootState | ComponentRootState;
-
-class ComponentRootState {
+class ComponentRootState implements RootState {
   readonly type = 'component';
 
   #result: GlimmerRenderResult | undefined;
@@ -169,7 +108,7 @@ class ComponentRootState {
     });
   }
 
-  isFor(_component: ClassicComponent): boolean {
+  isFor(_root: unknown): boolean {
     return false;
   }
 
@@ -190,90 +129,6 @@ class ComponentRootState {
   }
 }
 
-class ClassicRootState {
-  readonly type = 'classic';
-  public id: string;
-  public result: GlimmerRenderResult | undefined;
-  public destroyed: boolean;
-  public render: () => void;
-  readonly env: Environment;
-
-  constructor(
-    public root: Component | OutletView,
-    context: EvaluationContext,
-    owner: object,
-    template: Template,
-    self: Reference<unknown>,
-    parentElement: SimpleElement,
-    dynamicScope: DynamicScope,
-    builder: IBuilder
-  ) {
-    assert(
-      `You cannot render \`${valueForRef(self)}\` without a template.`,
-      template !== undefined
-    );
-
-    this.id = root instanceof OutletView ? guidFor(root) : getViewId(root);
-    this.result = undefined;
-    this.destroyed = false;
-    this.env = context.env;
-
-    this.render = errorLoopTransaction(() => {
-      let layout = unwrapTemplate(template).asLayout();
-
-      let iterator = renderMain(
-        context,
-        owner,
-        self,
-        builder(context.env, { element: parentElement, nextSibling: null }),
-        layout,
-        dynamicScope
-      );
-
-      let result = (this.result = iterator.sync());
-
-      associateDestroyableChild(this, result);
-
-      this.render = errorLoopTransaction(() => {
-        if (isDestroying(result) || isDestroyed(result)) return;
-
-        return result.rerender({
-          alwaysRevalidate: false,
-        });
-      });
-    });
-  }
-
-  isFor(possibleRoot: unknown): boolean {
-    return this.root === possibleRoot;
-  }
-
-  destroy() {
-    let { result, env } = this;
-
-    this.destroyed = true;
-
-    this.root = null as any;
-    this.result = undefined;
-    this.render = undefined as any;
-
-    if (result !== undefined) {
-      /*
-       Handles these scenarios:
-
-       * When roots are removed during standard rendering process, a transaction exists already
-         `.begin()` / `.commit()` are not needed.
-       * When roots are being destroyed manually (`component.append(); component.destroy() case), no
-         transaction exists already.
-       * When roots are being destroyed during `Renderer#destroy`, no transaction exists
-
-       */
-
-      inTransaction(env, () => destroy(result!));
-    }
-  }
-}
-
 const renderers: BaseRenderer[] = [];
 
 export function _resetRenderers() {
@@ -297,7 +152,17 @@ function loopBegin(): void {
   }
 }
 
-let renderSettledDeferred: RSVP.Deferred<void> | null = null;
+type Deferred = { promise: Promise<void>; resolve: () => void };
+
+function defer(): Deferred {
+  let resolve!: () => void;
+  let promise = new Promise<void>((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+
+let renderSettledDeferred: Deferred | null = null;
 /*
   Returns a promise which will resolve when rendering has settled. Settled in
   this context is defined as when all of the tags in use are "current" (e.g.
@@ -309,7 +174,7 @@ let renderSettledDeferred: RSVP.Deferred<void> | null = null;
 */
 export function renderSettled() {
   if (renderSettledDeferred === null) {
-    renderSettledDeferred = RSVP.defer();
+    renderSettledDeferred = defer();
     // if there is no current runloop, the promise created above will not have
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {
@@ -351,10 +216,6 @@ function loopEnd() {
 _backburner.on('begin', loopBegin);
 _backburner.on('end', loopEnd);
 
-interface ViewRegistry {
-  [viewId: string]: unknown;
-}
-
 type Resolver = ClassicResolver;
 
 interface RendererData {
@@ -717,12 +578,12 @@ export function renderComponent(
 const RENDER_CACHE = new WeakMap<IntoTarget, RenderCacheEntry>();
 const RENDERER_CACHE = new WeakMap<object, BaseRenderer>();
 
-class BaseRenderer {
+export class BaseRenderer {
   static strict(
     owner: object,
     document: SimpleDocument | Document,
     options: { isInteractive: boolean; hasDOM?: boolean }
-  ) {
+  ): BaseRenderer {
     return new BaseRenderer(
       owner,
       { hasDOM: hasDOM, ...options },
@@ -801,208 +662,6 @@ class BaseRenderer {
   rerender(): void {
     this.state.scheduleRevalidate(this);
   }
-
-  // render(component: Component, options: { into: Cursor; args?: Record<string, unknown> }): void {
-  //   this.state.renderRoot(component);
-  // }
 }
 
-export class Renderer extends BaseRenderer {
-  static strict(
-    owner: object,
-    document: SimpleDocument | Document,
-    options: { isInteractive: boolean; hasDOM?: boolean }
-  ): BaseRenderer {
-    return new BaseRenderer(
-      owner,
-      { hasDOM: hasDOM, ...options },
-      document as SimpleDocument,
-      new ResolverImpl(),
-      clientBuilder
-    );
-  }
-
-  private _rootTemplate: Template;
-  private _viewRegistry: ViewRegistry;
-
-  static create(props: { _viewRegistry: any }): Renderer {
-    let { _viewRegistry } = props;
-    let owner = getOwner(props);
-    assert('Renderer is unexpectedly missing an owner', owner);
-    let document = owner.lookup('service:-document') as SimpleDocument;
-    let env = owner.lookup('-environment:main') as {
-      isInteractive: boolean;
-      hasDOM: boolean;
-    };
-    let rootTemplate = owner.lookup(P`template:-root`) as TemplateFactory;
-    let builder = owner.lookup('service:-dom-builder') as IBuilder;
-    return new this(owner, document, env, rootTemplate, _viewRegistry, builder);
-  }
-
-  constructor(
-    owner: InternalOwner,
-    document: SimpleDocument,
-    env: { isInteractive: boolean; hasDOM: boolean },
-    rootTemplate: TemplateFactory,
-    viewRegistry: ViewRegistry,
-    builder = clientBuilder,
-    resolver = new ResolverImpl()
-  ) {
-    super(owner, env, document, resolver, builder);
-    this._rootTemplate = rootTemplate(owner);
-    this._viewRegistry = viewRegistry || owner.lookup('-view-registry:main');
-  }
-
-  // renderer HOOKS
-
-  appendOutletView(view: OutletView, target: SimpleElement): void {
-    // TODO: This bypasses the {{outlet}} syntax so logically duplicates
-    // some of the set up code. Since this is all internal (or is it?),
-    // we can refactor this to do something more direct/less convoluted
-    // and with less setup, but get it working first
-    let outlet = createRootOutlet(view);
-    let { name, /* controller, */ template } = view.state;
-
-    let named = dict<Reference>();
-
-    named['Component'] = createConstRef(
-      makeRouteTemplate(view.owner, name, template as Template),
-      '@Component'
-    );
-
-    // TODO: is this guaranteed to be undefined? It seems to be the
-    // case in the `OutletView` class. Investigate how much that class
-    // exists as an internal implementation detail only, or if it was
-    // used outside of core. As far as I can tell, test-helpers uses
-    // it but only for `setOutletState`.
-    // named['controller'] = createConstRef(controller, '@controller');
-    // Update: at least according to the debug render tree tests, we
-    // appear to always expect this to be undefined. Not a definitive
-    // source by any means, but is useful evidence
-    named['controller'] = UNDEFINED_REFERENCE;
-    named['model'] = UNDEFINED_REFERENCE;
-
-    let args = createCapturedArgs(named, EMPTY_POSITIONAL);
-
-    this._appendDefinition(
-      view,
-      curry(0 as CurriedComponent, outlet, view.owner, args, true),
-      target
-    );
-  }
-
-  appendTo(view: ClassicComponent, target: SimpleElement): void {
-    let definition = new RootComponentDefinition(view);
-    this._appendDefinition(
-      view,
-      curry(0 as CurriedComponent, definition, this.state.owner, null, true),
-      target
-    );
-  }
-
-  _appendDefinition(
-    root: OutletView | ClassicComponent,
-    definition: CurriedValue,
-    target: SimpleElement
-  ): void {
-    let self = createConstRef(definition, 'this');
-    let dynamicScope = new DynamicScope(null, UNDEFINED_REFERENCE);
-    let rootState = new ClassicRootState(
-      root,
-      this.state.context,
-      this.state.owner,
-      this._rootTemplate,
-      self,
-      target,
-      dynamicScope,
-      this.state.builder
-    );
-    this.state.renderRoot(rootState, this);
-  }
-
-  cleanupRootFor(component: ClassicComponent): void {
-    // no need to cleanup roots if we have already been destroyed
-    if (isDestroyed(this)) {
-      return;
-    }
-
-    let roots = this.state.roots;
-
-    // traverse in reverse so we can remove items
-    // without mucking up the index
-    let i = roots.length;
-    while (i--) {
-      let root = roots[i];
-      assert('has root', root);
-      if (root.type === 'classic' && root.isFor(component)) {
-        root.destroy();
-        roots.splice(i, 1);
-      }
-    }
-  }
-
-  remove(view: ClassicComponent): void {
-    view._transitionTo('destroying');
-
-    this.cleanupRootFor(view);
-
-    if (this.state.isInteractive) {
-      view.trigger('didDestroyElement');
-    }
-  }
-
-  get _roots() {
-    return this.state.debug.roots;
-  }
-
-  get _inRenderTransaction() {
-    return this.state.debug.inRenderTransaction;
-  }
-
-  get _isInteractive() {
-    return this.state.debug.isInteractive;
-  }
-
-  get _context() {
-    return this.state.context;
-  }
-
-  register(view: any): void {
-    let id = getViewId(view);
-    assert(
-      'Attempted to register a view with an id already in use: ' + id,
-      !this._viewRegistry[id]
-    );
-    this._viewRegistry[id] = view;
-  }
-
-  unregister(view: any): void {
-    delete this._viewRegistry[getViewId(view)];
-  }
-
-  getElement(component: View): Nullable<Element> {
-    if (this._isInteractive) {
-      return getViewElement(component);
-    } else {
-      throw new Error(
-        'Accessing `this.element` is not allowed in non-interactive environments (such as FastBoot).'
-      );
-    }
-  }
-
-  getBounds(component: View): {
-    parentElement: SimpleElement;
-    firstNode: SimpleNode;
-    lastNode: SimpleNode;
-  } {
-    let bounds: Bounds | null = component[BOUNDS];
-
-    assert('object passed to getBounds must have the BOUNDS symbol as a property', bounds);
-
-    let parentElement = bounds.parentElement();
-    let firstNode = bounds.firstNode();
-    let lastNode = bounds.lastNode();
-
-    return { parentElement, firstNode, lastNode };
-  }
-}
+export type { DynamicScope, Renderer, View } from './classic-renderer';
diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts
index af51ab9865d..0ba9e0ac322 100644
--- a/packages/@ember/-internals/glimmer/lib/resolver.ts
+++ b/packages/@ember/-internals/glimmer/lib/resolver.ts
@@ -1,7 +1,7 @@
 import type { InternalFactory, InternalOwner } from '@ember/-internals/owner';
 import { isFactory } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
-import { _instrumentStart } from '@ember/instrumentation';
+import { _instrumentStart } from '@ember/instrumentation/lib/internal-instrument';
 import { DEBUG } from '@glimmer/env';
 import type {
   ClassicResolver,
@@ -12,23 +12,19 @@ import type {
   TemplateFactory,
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
+import { getComponentTemplate } from '@glimmer/manager/lib/public/template';
+import { getInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+import { array } from '@glimmer/runtime/lib/helpers/array';
+import { concat } from '@glimmer/runtime/lib/helpers/concat';
+import { fn } from '@glimmer/runtime/lib/helpers/fn';
+import { get } from '@glimmer/runtime/lib/helpers/get';
+import { hash } from '@glimmer/runtime/lib/helpers/hash';
+import { on } from '@glimmer/runtime/lib/modifiers/on';
 import {
-  getComponentTemplate,
-  getInternalComponentManager,
-  setInternalHelperManager,
-} from '@glimmer/manager';
-import {
-  array,
-  concat,
-  fn,
-  get,
-  hash,
-  on,
   templateOnlyComponent,
   TEMPLATE_ONLY_COMPONENT_MANAGER,
-} from '@glimmer/runtime';
-import { isCurlyManager } from './component-managers/curly';
-import { CLASSIC_HELPER_MANAGER, isClassicHelper } from './helper';
+} from '@glimmer/runtime/lib/component/template-only';
+import { isCurlyManager } from './component-managers/curly-symbols';
 import { default as disallowDynamicResolution } from './helpers/-disallow-dynamic-resolution';
 import { default as inElementNullCheckHelper } from './helpers/-in-element-null-check';
 import { default as normalizeClassHelper } from './helpers/-normalize-class';
@@ -40,9 +36,6 @@ import { default as readonly } from './helpers/readonly';
 import { default as unbound } from './helpers/unbound';
 import { default as uniqueId } from './helpers/unique-id';
 
-import { mountHelper } from './syntax/mount';
-import { outletHelper } from './syntax/outlet';
-
 function instrumentationPayload(name: string) {
   return { object: `component:${name}` };
 }
@@ -96,11 +89,14 @@ const BUILTIN_KEYWORD_HELPERS: Record<string, object> = {
   '-normalize-class': normalizeClassHelper,
   '-resolve': resolve,
   '-track-array': trackArray,
-  '-mount': mountHelper,
-  '-outlet': outletHelper,
   '-in-el-null': inElementNullCheckHelper,
 };
 
+export function registerBuiltInKeywordHelper(name: string, helper: object): void {
+  BUILTIN_KEYWORD_HELPERS[name] = helper;
+  BUILTIN_HELPERS[name] = helper;
+}
+
 const BUILTIN_HELPERS: Record<string, object> = {
   ...BUILTIN_KEYWORD_HELPERS,
   array,
@@ -134,7 +130,17 @@ const BUILTIN_MODIFIERS: Record<string, object> = {
   on,
 };
 
-const CLASSIC_HELPER_MANAGER_ASSOCIATED = new WeakSet();
+type ClassicHelperHandler = (
+  definition: object,
+
+  factory: any
+) => HelperDefinitionState | null;
+
+let classicHelperHandler: ClassicHelperHandler | null = null;
+
+export function registerClassicHelperHandler(handler: ClassicHelperHandler): void {
+  classicHelperHandler = handler;
+}
 
 export default class ResolverImpl implements ClassicResolver<InternalOwner> {
   private componentDefinitionCache: Map<object, ResolvedComponentDefinition | null> = new Map();
@@ -166,23 +172,11 @@ export default class ResolverImpl implements ClassicResolver<InternalOwner> {
       return null;
     }
 
-    if (typeof definition === 'function' && isClassicHelper(definition)) {
-      // For classic class based helpers, we need to pass the factoryFor result itself rather
-      // than the raw value (`factoryFor(...).class`). This is because injections are already
-      // bound in the factoryFor result, including type-based injections
-
-      if (DEBUG) {
-        // In DEBUG we need to only set the associated value once, otherwise
-        // we'll trigger an assertion
-        if (!CLASSIC_HELPER_MANAGER_ASSOCIATED.has(factory)) {
-          CLASSIC_HELPER_MANAGER_ASSOCIATED.add(factory);
-          setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
-        }
-      } else {
-        setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
+    if (typeof definition === 'function' && classicHelperHandler !== null) {
+      let result = classicHelperHandler(definition, factory);
+      if (result !== null) {
+        return result;
       }
-
-      return factory;
     }
 
     return definition;
diff --git a/packages/@ember/-internals/glimmer/lib/setup-registry.ts b/packages/@ember/-internals/glimmer/lib/setup-registry.ts
index 1608fe1f185..62783b9ce90 100644
--- a/packages/@ember/-internals/glimmer/lib/setup-registry.ts
+++ b/packages/@ember/-internals/glimmer/lib/setup-registry.ts
@@ -1,15 +1,19 @@
-import type { Registry } from '@ember/-internals/container';
-import { privatize as P } from '@ember/-internals/container';
+import type Registry from '@ember/-internals/container/lib/registry';
+import { privatize as P } from '@ember/-internals/container/lib/registry';
 import { getOwner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
 import Input from './components/input';
 import LinkTo from './components/link-to';
 import Textarea from './components/textarea';
 import { clientBuilder, rehydrationBuilder, serializeBuilder } from './dom';
-import { Renderer } from './renderer';
+import { Renderer } from './classic-renderer';
 import OutletTemplate from './templates/outlet';
 import RootTemplate from './templates/root';
 import OutletView from './views/outlet';
+import './syntax/register-routing-keywords';
+import '@glimmer/runtime/lib/debug-render-tree-register';
+import './register-curly-component';
+import './register-classic-helper';
 
 export function setupApplicationRegistry(registry: Registry): void {
   // because we are using injections we can't use instantiate false
diff --git a/packages/@ember/-internals/glimmer/lib/syntax/mount.ts b/packages/@ember/-internals/glimmer/lib/syntax/mount.ts
index eef12143582..57baca66aeb 100644
--- a/packages/@ember/-internals/glimmer/lib/syntax/mount.ts
+++ b/packages/@ember/-internals/glimmer/lib/syntax/mount.ts
@@ -6,10 +6,11 @@ import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { Nullable } from '@ember/-internals/utility-types';
 import type { CapturedArguments, CurriedComponent } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
-import type { CurriedValue } from '@glimmer/runtime';
-import { createCapturedArgs, curry, EMPTY_POSITIONAL } from '@glimmer/runtime';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
+import type { CurriedValue } from '@glimmer/runtime/lib/curried-value';
+import { createCapturedArgs, EMPTY_POSITIONAL } from '@glimmer/runtime/lib/vm/arguments';
+import { curry } from '@glimmer/runtime/lib/curried-value';
 import { MountDefinition } from '../component-managers/mount';
 import { internalHelper } from '../helpers/internal-helper';
 
diff --git a/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts b/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
index c4f6909a579..d0027f2339e 100644
--- a/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
@@ -7,18 +7,19 @@ import type {
   DynamicScope,
   Template,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
 import {
   childRefFromParts,
   createComputeRef,
   createConstRef,
   createDebugAliasRef,
   valueForRef,
-} from '@glimmer/reference';
-import type { CurriedValue } from '@glimmer/runtime';
-import { createCapturedArgs, curry, EMPTY_POSITIONAL } from '@glimmer/runtime';
-import { dict } from '@glimmer/util';
-import { hasInternalComponentManager } from '@glimmer/manager';
+} from '@glimmer/reference/lib/reference';
+import type { CurriedValue } from '@glimmer/runtime/lib/curried-value';
+import { createCapturedArgs, EMPTY_POSITIONAL } from '@glimmer/runtime/lib/vm/arguments';
+import { curry } from '@glimmer/runtime/lib/curried-value';
+import { dict } from '@glimmer/util/lib/collections';
+import { hasInternalComponentManager } from '@glimmer/manager/lib/internal/api';
 import { OutletComponent, type OutletDefinitionState } from '../component-managers/outlet';
 import { makeRouteTemplate } from '../component-managers/route-template';
 import { internalHelper } from '../helpers/internal-helper';
diff --git a/packages/@ember/-internals/glimmer/lib/syntax/register-routing-keywords.ts b/packages/@ember/-internals/glimmer/lib/syntax/register-routing-keywords.ts
new file mode 100644
index 00000000000..dc336be8a1e
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/syntax/register-routing-keywords.ts
@@ -0,0 +1,6 @@
+import { registerBuiltInKeywordHelper } from '../resolver';
+import { mountHelper } from './mount';
+import { outletHelper } from './outlet';
+
+registerBuiltInKeywordHelper('-mount', mountHelper);
+registerBuiltInKeywordHelper('-outlet', outletHelper);
diff --git a/packages/@ember/-internals/glimmer/lib/utils/bindings.ts b/packages/@ember/-internals/glimmer/lib/utils/bindings.ts
index 405c44d390b..e540201c5a1 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/bindings.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/bindings.ts
@@ -1,15 +1,15 @@
-import { get } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import { assert } from '@ember/debug';
 import { dasherize } from '@ember/-internals/string';
 import type { ElementOperations } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
 import {
   childRefFor,
   childRefFromParts,
   createComputeRef,
   createPrimitiveRef,
   valueForRef,
-} from '@glimmer/reference';
+} from '@glimmer/reference/lib/reference';
 import type Component from '../component';
 
 function referenceForParts(rootRef: Reference<Component>, parts: string[]): Reference {
diff --git a/packages/@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.ts b/packages/@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.ts
index 5a4fb529a6f..49907136c01 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.ts
@@ -1,10 +1,16 @@
-import { clearElementView, clearViewElement, getViewElement } from '@ember/-internals/views';
+import {
+  clearElementView,
+  clearViewElement,
+  getViewElement,
+} from '@ember/-internals/views/lib/system/utils';
 import { registerDestructor } from '@glimmer/destroyable';
 import type { CapturedNamedArguments } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { createConstRef } from '@glimmer/reference';
-import type { Revision, Tag } from '@glimmer/validator';
-import { beginUntrackFrame, endUntrackFrame, valueForTag } from '@glimmer/validator';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createConstRef } from '@glimmer/reference/lib/reference';
+import type { Revision } from '@glimmer/validator/lib/validators';
+import type { Tag } from '@glimmer/interfaces';
+import { beginUntrackFrame, endUntrackFrame } from '@glimmer/validator/lib/tracking';
+import { valueForTag } from '@glimmer/validator/lib/validators';
 import type Component from '../component';
 
 type Finalizer = () => void;
diff --git a/packages/@ember/-internals/glimmer/lib/utils/iterator.ts b/packages/@ember/-internals/glimmer/lib/utils/iterator.ts
index 34e3c512d64..a497c8a4a73 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/iterator.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/iterator.ts
@@ -1,10 +1,11 @@
-import { objectAt } from '@ember/-internals/metal';
+import { objectAt } from '@ember/-internals/metal/lib/object-at';
 import type EmberArray from '@ember/array';
 import { isEmberArray } from '@ember/array/-internals';
-import { isObject } from '@ember/-internals/utils';
+import { isObject } from '@ember/-internals/utils/lib/spec';
 import type { Nullable } from '@ember/-internals/utility-types';
-import type { IteratorDelegate } from '@glimmer/reference';
-import { consumeTag, isTracking, tagFor } from '@glimmer/validator';
+import type { IteratorDelegate } from '@glimmer/reference/lib/iterable';
+import { consumeTag, isTracking } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
 import { EachInWrapper } from '../helpers/each-in';
 import type { NativeArray } from '@ember/array';
 
diff --git a/packages/@ember/-internals/glimmer/lib/utils/managers.ts b/packages/@ember/-internals/glimmer/lib/utils/managers.ts
index 54fb7f46656..4f26f4487c3 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/managers.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/managers.ts
@@ -1,7 +1,8 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import type { ComponentManager } from '@glimmer/interfaces';
-import { setComponentManager as glimmerSetComponentManager } from '@glimmer/manager';
-export { modifierCapabilities, componentCapabilities } from '@glimmer/manager';
+import { setComponentManager as glimmerSetComponentManager } from '@glimmer/manager/lib/public/api';
+export { modifierCapabilities } from '@glimmer/manager/lib/public/modifier';
+export { componentCapabilities } from '@glimmer/manager/lib/public/component';
 
 /**
    Associate a class with a component manager (an object that is responsible for
diff --git a/packages/@ember/-internals/glimmer/lib/utils/process-args.ts b/packages/@ember/-internals/glimmer/lib/utils/process-args.ts
index 5b45c9f20fa..db10397450c 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/process-args.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/process-args.ts
@@ -1,7 +1,7 @@
-import { MUTABLE_CELL } from '@ember/-internals/views';
+import { MUTABLE_CELL } from '@ember/-internals/views/lib/compat/attrs';
 import type { CapturedNamedArguments } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { isUpdatableRef, updateRef, valueForRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { isUpdatableRef, updateRef, valueForRef } from '@glimmer/reference/lib/reference';
 import { assert } from '@ember/debug';
 
 // ComponentArgs takes EvaluatedNamedArgs and converts them into the
diff --git a/packages/@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.ts b/packages/@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.ts
index 57d23ea7e86..ef97de8c7eb 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.ts
@@ -1 +1 @@
-export { isSerializationFirstNode } from '@glimmer/runtime';
+export { isSerializationFirstNode } from '@glimmer/runtime/lib/vm/rehydrate-builder';
diff --git a/packages/@ember/-internals/glimmer/lib/utils/string.ts b/packages/@ember/-internals/glimmer/lib/utils/string.ts
index d00c17e7ec6..f1a846afe0b 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/string.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/string.ts
@@ -2,7 +2,7 @@
 @module @ember/template
 */
 
-import type { SafeString as GlimmerSafeString } from '@glimmer/runtime';
+import type { SafeString as GlimmerSafeString } from '@glimmer/runtime/lib/upsert';
 
 /**
   A wrapper around a string that has been marked as "trusted". **When
diff --git a/packages/@ember/-internals/glimmer/lib/utils/to-bool.ts b/packages/@ember/-internals/glimmer/lib/utils/to-bool.ts
index a17bdd505f7..ded35d037d6 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/to-bool.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/to-bool.ts
@@ -1,15 +1,20 @@
 import { isHTMLSafe } from './string';
-import { get, tagForProperty } from '@ember/-internals/metal';
-import { isArray } from '@ember/array';
-import { isProxy } from '@ember/-internals/utils';
-import { consumeTag } from '@glimmer/validator';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { tagForProperty } from '@ember/-internals/metal/lib/tags';
+import { isEmberArray } from '@ember/array/-internals';
+import { isProxy } from '@ember/-internals/utils/lib/is_proxy';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+
+function isArrayLike(obj: unknown): obj is ArrayLike<unknown> {
+  return Array.isArray(obj) || isEmberArray(obj);
+}
 
 export default function toBool(predicate: unknown): boolean {
   if (isProxy(predicate)) {
     consumeTag(tagForProperty(predicate, 'content'));
 
     return Boolean(get(predicate, 'isTruthy'));
-  } else if (isArray(predicate)) {
+  } else if (isArrayLike(predicate)) {
     consumeTag(tagForProperty(predicate as object, '[]'));
 
     return (predicate as { length: number }).length !== 0;
diff --git a/packages/@ember/-internals/glimmer/lib/views/outlet.ts b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
index 7cc9be26e73..00d0828a8e3 100644
--- a/packages/@ember/-internals/glimmer/lib/views/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
@@ -7,9 +7,10 @@ import type { BootOptions } from '@ember/engine/instance';
 import { assert } from '@ember/debug';
 import { schedule } from '@ember/runloop';
 import type { Template, TemplateFactory } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { createComputeRef, updateRef } from '@glimmer/reference';
-import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createComputeRef, updateRef } from '@glimmer/reference/lib/reference';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { createTag, DIRTY_TAG as dirtyTag } from '@glimmer/validator/lib/validators';
 import type { SimpleElement } from '@simple-dom/interface';
 import type { OutletDefinitionState } from '../component-managers/outlet';
 import type { Renderer } from '../renderer';
diff --git a/packages/@ember/-internals/meta/lib/meta.ts b/packages/@ember/-internals/meta/lib/meta.ts
index 17c3ff59ec6..781566d20bd 100644
--- a/packages/@ember/-internals/meta/lib/meta.ts
+++ b/packages/@ember/-internals/meta/lib/meta.ts
@@ -1,9 +1,10 @@
-import type { ComputedProperty } from '@ember/-internals/metal';
-import { toString } from '@ember/-internals/utils';
+import type { ComputedProperty } from '@ember/-internals/metal/lib/computed';
+import toString from '@ember/-internals/utils/lib/to-string';
 import { assert } from '@ember/debug';
 import { isDestroyed } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
-import type { Revision, UpdatableTag } from '@glimmer/validator';
+import type { Revision } from '@glimmer/validator/lib/validators';
+import type { UpdatableTag } from '@glimmer/interfaces';
 
 type ObjMap<T> = { [key: string]: T };
 
diff --git a/packages/@ember/-internals/metal/lib/alias.ts b/packages/@ember/-internals/metal/lib/alias.ts
index 66ebf468f31..76687936880 100644
--- a/packages/@ember/-internals/metal/lib/alias.ts
+++ b/packages/@ember/-internals/metal/lib/alias.ts
@@ -1,16 +1,15 @@
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor } from '@ember/-internals/meta';
-import { assert, inspect } from '@ember/debug';
-import type { UpdatableTag } from '@glimmer/validator';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor } from '@ember/-internals/meta/lib/meta';
+import inspect from '@ember/debug/lib/inspect';
+import { assert } from '@ember/debug';
+import type { UpdatableTag } from '@glimmer/interfaces';
+import { consumeTag, untrack } from '@glimmer/validator/lib/tracking';
+import { tagFor, tagMetaFor } from '@glimmer/validator/lib/meta';
 import {
-  consumeTag,
-  tagFor,
-  tagMetaFor,
-  untrack,
-  updateTag,
+  UPDATE_TAG as updateTag,
   validateTag,
   valueForTag,
-} from '@glimmer/validator';
+} from '@glimmer/validator/lib/validators';
 import { CHAIN_PASS_THROUGH, finishLazyChains, getChainTagsForKey } from './chain-tags';
 import type { ExtendedMethodDecorator } from './decorator';
 import {
diff --git a/packages/@ember/-internals/metal/lib/array_events.ts b/packages/@ember/-internals/metal/lib/array_events.ts
index ee7c73285c5..61fd6072501 100644
--- a/packages/@ember/-internals/metal/lib/array_events.ts
+++ b/packages/@ember/-internals/metal/lib/array_events.ts
@@ -1,4 +1,4 @@
-import { peekMeta } from '@ember/-internals/meta';
+import { peekMeta } from '@ember/-internals/meta/lib/meta';
 import { sendEvent } from './events';
 import { notifyPropertyChange } from './property_events';
 
diff --git a/packages/@ember/-internals/metal/lib/cache.ts b/packages/@ember/-internals/metal/lib/cache.ts
index afc7080c6ca..f6349c9c469 100644
--- a/packages/@ember/-internals/metal/lib/cache.ts
+++ b/packages/@ember/-internals/metal/lib/cache.ts
@@ -1,4 +1,4 @@
-export { createCache, getValue, isConst } from '@glimmer/validator';
+export { createCache, getValue, isConst } from '@glimmer/validator/lib/tracking';
 
 /**
   Ember uses caching based on trackable values to avoid updating large portions
diff --git a/packages/@ember/-internals/metal/lib/cached.ts b/packages/@ember/-internals/metal/lib/cached.ts
index b40ccf4a2de..ea6049b4377 100644
--- a/packages/@ember/-internals/metal/lib/cached.ts
+++ b/packages/@ember/-internals/metal/lib/cached.ts
@@ -2,7 +2,7 @@
 // Both glimmerjs/glimmer.js and emberjs/ember.js have the exact same implementation
 // of @cached, so any changes made to one should also be made to the other
 import { DEBUG } from '@glimmer/env';
-import { createCache, getValue } from '@glimmer/validator';
+import { createCache, getValue } from '@glimmer/validator/lib/tracking';
 
 /**
  * @decorator
diff --git a/packages/@ember/-internals/metal/lib/chain-tags.ts b/packages/@ember/-internals/metal/lib/chain-tags.ts
index 8e6a0261a88..9827cf1cf6b 100644
--- a/packages/@ember/-internals/metal/lib/chain-tags.ts
+++ b/packages/@ember/-internals/metal/lib/chain-tags.ts
@@ -1,15 +1,16 @@
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor, peekMeta } from '@ember/-internals/meta';
-import { isObject } from '@ember/-internals/utils';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor, peekMeta } from '@ember/-internals/meta/lib/meta';
+import { isObject } from '@ember/-internals/utils/lib/spec';
 import { assert } from '@ember/debug';
-import type { Tag, TagMeta } from '@glimmer/validator';
+import type { Tag } from '@glimmer/interfaces';
+import type { TagMeta } from '@glimmer/validator/lib/meta';
 import {
   combine,
   createUpdatableTag,
-  tagMetaFor,
-  updateTag,
+  UPDATE_TAG as updateTag,
   validateTag,
-} from '@glimmer/validator';
+} from '@glimmer/validator/lib/validators';
+import { tagMetaFor } from '@glimmer/validator/lib/meta';
 import { objectAt } from './object-at';
 import { tagForProperty } from './tags';
 
diff --git a/packages/@ember/-internals/metal/lib/computed.ts b/packages/@ember/-internals/metal/lib/computed.ts
index aac84147b84..aa164cb4ba5 100644
--- a/packages/@ember/-internals/metal/lib/computed.ts
+++ b/packages/@ember/-internals/metal/lib/computed.ts
@@ -1,21 +1,19 @@
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor } from '@ember/-internals/meta';
-import { toString } from '@ember/-internals/utils';
-import { assert, inspect } from '@ember/debug';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor } from '@ember/-internals/meta/lib/meta';
+import toString from '@ember/-internals/utils/lib/to-string';
+import inspect from '@ember/debug/lib/inspect';
+import { assert } from '@ember/debug';
 import { isDestroyed } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
-import type { UpdatableTag } from '@glimmer/validator';
+import type { UpdatableTag } from '@glimmer/interfaces';
 import {
   ALLOW_CYCLES,
-  consumeTag,
-  tagFor,
-  tagMetaFor,
-  track,
-  untrack,
-  updateTag,
+  UPDATE_TAG as updateTag,
   validateTag,
   valueForTag,
-} from '@glimmer/validator';
+} from '@glimmer/validator/lib/validators';
+import { consumeTag, track, untrack } from '@glimmer/validator/lib/tracking';
+import { tagFor, tagMetaFor } from '@glimmer/validator/lib/meta';
 import { finishLazyChains, getChainTagsForKeys } from './chain-tags';
 import type {
   ExtendedMethodDecorator,
diff --git a/packages/@ember/-internals/metal/lib/computed_cache.ts b/packages/@ember/-internals/metal/lib/computed_cache.ts
index 31a856ebc9f..678fff489db 100644
--- a/packages/@ember/-internals/metal/lib/computed_cache.ts
+++ b/packages/@ember/-internals/metal/lib/computed_cache.ts
@@ -1,4 +1,4 @@
-import { peekMeta } from '@ember/-internals/meta';
+import { peekMeta } from '@ember/-internals/meta/lib/meta';
 
 export function getCachedValueFor<T, K extends keyof T>(obj: T, key: K): T[K] | undefined;
 export function getCachedValueFor(obj: object, key: string): unknown;
diff --git a/packages/@ember/-internals/metal/lib/decorator.ts b/packages/@ember/-internals/metal/lib/decorator.ts
index 5c71ad98338..ee6e9229858 100644
--- a/packages/@ember/-internals/metal/lib/decorator.ts
+++ b/packages/@ember/-internals/metal/lib/decorator.ts
@@ -1,7 +1,8 @@
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor, peekMeta } from '@ember/-internals/meta';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor, peekMeta } from '@ember/-internals/meta/lib/meta';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
+import { registerComputedSetterCheck } from './property_set';
 
 export type DecoratorPropertyDescriptor = (PropertyDescriptor & { initializer?: any }) | undefined;
 
@@ -109,6 +110,8 @@ function DESCRIPTOR_SETTER_FUNCTION(
 
 export const COMPUTED_SETTERS = new WeakSet();
 
+registerComputedSetterCheck((setter) => COMPUTED_SETTERS.has(setter));
+
 export function makeComputedDecorator(
   desc: ComputedDescriptor,
   DecoratorClass: { prototype: object }
diff --git a/packages/@ember/-internals/metal/lib/deprecate_property.ts b/packages/@ember/-internals/metal/lib/deprecate_property.ts
index 04f8313dd7d..8c2c49dbd59 100644
--- a/packages/@ember/-internals/metal/lib/deprecate_property.ts
+++ b/packages/@ember/-internals/metal/lib/deprecate_property.ts
@@ -3,7 +3,7 @@
 */
 
 import { deprecate } from '@ember/debug';
-import type { DeprecationOptions } from '@ember/debug';
+import type { DeprecationOptions } from '@ember/debug/lib/deprecate';
 import { get } from './property_get';
 import { set } from './property_set';
 
diff --git a/packages/@ember/-internals/metal/lib/events.ts b/packages/@ember/-internals/metal/lib/events.ts
index ab77fb52c86..56668b9bc9b 100644
--- a/packages/@ember/-internals/metal/lib/events.ts
+++ b/packages/@ember/-internals/metal/lib/events.ts
@@ -1,9 +1,9 @@
 /**
 @module @ember/object
 */
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor, peekMeta } from '@ember/-internals/meta';
-import { setListeners } from '@ember/-internals/utils';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor, peekMeta } from '@ember/-internals/meta/lib/meta';
+import { setListeners } from '@ember/-internals/utils/lib/super';
 import type { AnyFn } from '@ember/-internals/utility-types';
 import { assert } from '@ember/debug';
 
diff --git a/packages/@ember/-internals/metal/lib/namespace_search.ts b/packages/@ember/-internals/metal/lib/namespace_search.ts
index a9ab713bf9e..b06a7963b31 100644
--- a/packages/@ember/-internals/metal/lib/namespace_search.ts
+++ b/packages/@ember/-internals/metal/lib/namespace_search.ts
@@ -1,5 +1,5 @@
-import { context } from '@ember/-internals/environment';
-import { getName, setName } from '@ember/-internals/utils';
+import { context } from '@ember/-internals/environment/lib/context';
+import { getName, setName } from '@ember/-internals/utils/lib/name';
 
 const hasOwnProperty = Object.prototype.hasOwnProperty;
 
diff --git a/packages/@ember/-internals/metal/lib/observer.ts b/packages/@ember/-internals/metal/lib/observer.ts
index 4154e3441a8..2cb14d2d44e 100644
--- a/packages/@ember/-internals/metal/lib/observer.ts
+++ b/packages/@ember/-internals/metal/lib/observer.ts
@@ -1,12 +1,14 @@
-import { ENV } from '@ember/-internals/environment';
-import { peekMeta } from '@ember/-internals/meta';
-import type { schedule } from '@ember/runloop';
+import { ENV } from '@ember/-internals/environment/lib/env';
+import { peekMeta } from '@ember/-internals/meta/lib/meta';
+import { registerAsyncObserverFlush, type schedule } from '@ember/runloop';
 import { registerDestructor } from '@glimmer/destroyable';
-import type { Tag } from '@glimmer/validator';
-import { CURRENT_TAG, tagMetaFor, validateTag, valueForTag } from '@glimmer/validator';
+import type { Tag } from '@glimmer/interfaces';
+import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
+import { tagMetaFor } from '@glimmer/validator/lib/meta';
 import { getChainTagsForKey } from './chain-tags';
 import changeEvent from './change_event';
 import { addListener, removeListener, sendEvent } from './events';
+import { registerObserverDeactivationHooks, registerObserverFlushSync } from './property_events';
 
 interface ActiveObserver {
   tag: Tag;
@@ -269,3 +271,7 @@ function destroyObservers(target: object) {
   if (SYNC_OBSERVERS.size > 0) SYNC_OBSERVERS.delete(target);
   if (ASYNC_OBSERVERS.size > 0) ASYNC_OBSERVERS.delete(target);
 }
+
+registerObserverFlushSync(flushSyncObservers);
+registerObserverDeactivationHooks(suspendedObserverDeactivation, resumeObserverDeactivation);
+registerAsyncObserverFlush(flushAsyncObservers);
diff --git a/packages/@ember/-internals/metal/lib/path_cache.ts b/packages/@ember/-internals/metal/lib/path_cache.ts
index 1859f03272a..bb86157d250 100644
--- a/packages/@ember/-internals/metal/lib/path_cache.ts
+++ b/packages/@ember/-internals/metal/lib/path_cache.ts
@@ -1,4 +1,4 @@
-import { Cache } from '@ember/-internals/utils';
+import Cache from '@ember/-internals/utils/lib/cache';
 
 const firstDotIndexCache = new Cache<string, number>(1000, (key) => key.indexOf('.'));
 
diff --git a/packages/@ember/-internals/metal/lib/properties.ts b/packages/@ember/-internals/metal/lib/properties.ts
index 68ec802b1ef..968b10d1752 100644
--- a/packages/@ember/-internals/metal/lib/properties.ts
+++ b/packages/@ember/-internals/metal/lib/properties.ts
@@ -2,9 +2,9 @@
 @module @ember/object
 */
 
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor } from '@ember/-internals/meta';
-import { setWithMandatorySetter } from '@ember/-internals/utils';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor } from '@ember/-internals/meta/lib/meta';
+import { setWithMandatorySetter } from '@ember/-internals/utils/lib/mandatory-setter';
 import { DEBUG } from '@glimmer/env';
 import type { ExtendedMethodDecorator } from './decorator';
 import { descriptorForProperty, isClassicDecorator } from './decorator';
diff --git a/packages/@ember/-internals/metal/lib/property_events.ts b/packages/@ember/-internals/metal/lib/property_events.ts
index 12758ed9858..6b501f86467 100644
--- a/packages/@ember/-internals/metal/lib/property_events.ts
+++ b/packages/@ember/-internals/metal/lib/property_events.ts
@@ -1,13 +1,21 @@
-import type { Meta } from '@ember/-internals/meta';
-import { peekMeta } from '@ember/-internals/meta';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { peekMeta } from '@ember/-internals/meta/lib/meta';
 import { assert } from '@ember/debug';
-import {
-  flushSyncObservers,
-  resumeObserverDeactivation,
-  suspendedObserverDeactivation,
-} from './observer';
 import { markObjectAsDirty } from './tags';
 
+let observerFlushSync: (() => void) | null = null;
+let observerSuspendDeactivation: (() => void) | null = null;
+let observerResumeDeactivation: (() => void) | null = null;
+
+export function registerObserverFlushSync(fn: () => void): void {
+  observerFlushSync = fn;
+}
+
+export function registerObserverDeactivationHooks(suspend: () => void, resume: () => void): void {
+  observerSuspendDeactivation = suspend;
+  observerResumeDeactivation = resume;
+}
+
 /**
  @module ember
  @private
@@ -61,8 +69,8 @@ function notifyPropertyChange(
 
   markObjectAsDirty(obj, keyName);
 
-  if (deferred <= 0) {
-    flushSyncObservers();
+  if (deferred <= 0 && observerFlushSync !== null) {
+    observerFlushSync();
   }
 
   if (PROPERTY_DID_CHANGE in obj) {
@@ -87,7 +95,9 @@ function notifyPropertyChange(
 */
 function beginPropertyChanges(): void {
   deferred++;
-  suspendedObserverDeactivation();
+  if (observerSuspendDeactivation !== null) {
+    observerSuspendDeactivation();
+  }
 }
 
 /**
@@ -97,8 +107,12 @@ function beginPropertyChanges(): void {
 function endPropertyChanges(): void {
   deferred--;
   if (deferred <= 0) {
-    flushSyncObservers();
-    resumeObserverDeactivation();
+    if (observerFlushSync !== null) {
+      observerFlushSync();
+    }
+    if (observerResumeDeactivation !== null) {
+      observerResumeDeactivation();
+    }
   }
 }
 
diff --git a/packages/@ember/-internals/metal/lib/property_get.ts b/packages/@ember/-internals/metal/lib/property_get.ts
index c797bc38589..c1cd6eb2168 100644
--- a/packages/@ember/-internals/metal/lib/property_get.ts
+++ b/packages/@ember/-internals/metal/lib/property_get.ts
@@ -1,12 +1,13 @@
 /**
 @module @ember/object
 */
-import type { _ProxyMixin as ProxyMixin } from '@ember/-internals/runtime';
-import { setProxy } from '@ember/-internals/utils';
+import type ProxyMixin from '@ember/-internals/runtime/lib/mixins/-proxy';
+import { setProxy } from '@ember/-internals/utils/lib/is_proxy';
 import { isEmberArray } from '@ember/array/-internals';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import { consumeTag, isTracking, tagFor, track } from '@glimmer/validator';
+import { consumeTag, isTracking, track } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
 import { isPath } from './path_cache';
 
 export const PROXY_CONTENT = Symbol('PROXY_CONTENT');
diff --git a/packages/@ember/-internals/metal/lib/property_set.ts b/packages/@ember/-internals/metal/lib/property_set.ts
index 65b78f9c1ed..56280e1b9f2 100644
--- a/packages/@ember/-internals/metal/lib/property_set.ts
+++ b/packages/@ember/-internals/metal/lib/property_set.ts
@@ -1,11 +1,21 @@
-import { lookupDescriptor, setWithMandatorySetter, toString } from '@ember/-internals/utils';
+import lookupDescriptor from '@ember/-internals/utils/lib/lookup-descriptor';
+import { setWithMandatorySetter } from '@ember/-internals/utils/lib/mandatory-setter';
+import toString from '@ember/-internals/utils/lib/to-string';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import { COMPUTED_SETTERS } from './decorator';
 import { isPath } from './path_cache';
 import { notifyPropertyChange } from './property_events';
 import { getPossibleMandatoryProxyValue, _getPath as getPath } from './property_get';
 
+let computedSetterCheck: ((setter: (this: object, value: unknown) => void) => boolean) | null =
+  null;
+
+export function registerComputedSetterCheck(
+  fn: (setter: (this: object, value: unknown) => void) => boolean
+): void {
+  computedSetterCheck = fn;
+}
+
 interface ExtendedObject {
   isDestroyed?: boolean;
   setUnknownProperty?: (keyName: string, value: any) => any;
@@ -68,7 +78,12 @@ export function set<T>(obj: object, keyName: string, value: T, tolerant?: boolea
 export function _setProp(obj: object, keyName: string, value: any) {
   let descriptor = lookupDescriptor(obj, keyName);
 
-  if (descriptor !== null && COMPUTED_SETTERS.has(descriptor.set!)) {
+  if (
+    descriptor !== null &&
+    descriptor.set !== undefined &&
+    computedSetterCheck !== null &&
+    computedSetterCheck(descriptor.set)
+  ) {
     (obj as any)[keyName] = value;
     return value;
   }
diff --git a/packages/@ember/-internals/metal/lib/tags.ts b/packages/@ember/-internals/metal/lib/tags.ts
index 3d7f267436a..41ab6860a53 100644
--- a/packages/@ember/-internals/metal/lib/tags.ts
+++ b/packages/@ember/-internals/metal/lib/tags.ts
@@ -1,10 +1,14 @@
-import { isObject, setupMandatorySetter, toString } from '@ember/-internals/utils';
+import { isObject } from '@ember/-internals/utils/lib/spec';
+import { setupMandatorySetter } from '@ember/-internals/utils/lib/mandatory-setter';
+import toString from '@ember/-internals/utils/lib/to-string';
 import { assert } from '@ember/debug';
 import { isDestroyed } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
-import { getCustomTagFor } from '@glimmer/manager';
-import type { Tag, TagMeta } from '@glimmer/validator';
-import { CONSTANT_TAG, dirtyTagFor, tagFor } from '@glimmer/validator';
+import { getCustomTagFor } from '@glimmer/manager/lib/util/args-proxy';
+import type { Tag } from '@glimmer/interfaces';
+import type { TagMeta } from '@glimmer/validator/lib/meta';
+import { CONSTANT_TAG } from '@glimmer/validator/lib/validators';
+import { dirtyTagFor, tagFor } from '@glimmer/validator/lib/meta';
 
 /////////
 
diff --git a/packages/@ember/-internals/metal/lib/tracked.ts b/packages/@ember/-internals/metal/lib/tracked.ts
index 226b632c2e3..71dc16cbe75 100644
--- a/packages/@ember/-internals/metal/lib/tracked.ts
+++ b/packages/@ember/-internals/metal/lib/tracked.ts
@@ -1,8 +1,10 @@
-import { meta as metaFor } from '@ember/-internals/meta';
+import { meta as metaFor } from '@ember/-internals/meta/lib/meta';
 import { isEmberArray } from '@ember/array/-internals';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import { consumeTag, dirtyTagFor, tagFor, trackedData } from '@glimmer/validator';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { dirtyTagFor, tagFor } from '@glimmer/validator/lib/meta';
+import { trackedData } from '@glimmer/validator/lib/tracked-data';
 import type { ElementDescriptor } from '..';
 import { CHAIN_PASS_THROUGH } from './chain-tags';
 import type { ExtendedMethodDecorator, DecoratorPropertyDescriptor } from './decorator';
diff --git a/packages/@ember/-internals/package.json b/packages/@ember/-internals/package.json
index cc947bbb6b5..ed45dfe6c74 100644
--- a/packages/@ember/-internals/package.json
+++ b/packages/@ember/-internals/package.json
@@ -20,7 +20,8 @@
     "./string": "./string/index.ts",
     "./utility-types": "./utility-types/index.ts",
     "./utils": "./utils/index.ts",
-    "./views": "./views/index.ts"
+    "./views": "./views/index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/application": "workspace:*",
diff --git a/packages/@ember/-internals/runtime/lib/mixins/-proxy.ts b/packages/@ember/-internals/runtime/lib/mixins/-proxy.ts
index e7e3e218454..19adf728f97 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/-proxy.ts
+++ b/packages/@ember/-internals/runtime/lib/mixins/-proxy.ts
@@ -2,31 +2,25 @@
 @module ember
 */
 
-import { meta } from '@ember/-internals/meta';
+import { meta } from '@ember/-internals/meta/lib/meta';
 import Mixin from '@ember/object/mixin';
-import {
-  get,
-  set,
-  defineProperty,
-  tagForObject,
-  computed,
-  tagForProperty,
-} from '@ember/-internals/metal';
-import { setProxy, setupMandatorySetter, isObject, isProxy } from '@ember/-internals/utils';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+import { defineProperty } from '@ember/-internals/metal/lib/properties';
+import { tagForObject, tagForProperty } from '@ember/-internals/metal/lib/tags';
+import computed from '@ember/-internals/metal/lib/computed';
+import { setProxy, isProxy } from '@ember/-internals/utils/lib/is_proxy';
+import { setupMandatorySetter } from '@ember/-internals/utils/lib/mandatory-setter';
+import { isObject } from '@ember/-internals/utils/lib/spec';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import { setCustomTagFor } from '@glimmer/manager';
-import type { UpdatableTag, Tag } from '@glimmer/validator';
-import { combine, updateTag, tagFor, tagMetaFor } from '@glimmer/validator';
-
-export function contentFor<T>(proxy: ProxyMixin<T>): T | null {
-  let content = get(proxy, 'content');
-  // SAFETY: Ideally we'd assert instead of casting, but @glimmer/validator doesn't give us
-  // sufficient public types for this. Previously this code was .js and worked correctly so
-  // hopefully this is sufficiently reliable.
-  updateTag(tagForObject(proxy) as UpdatableTag, tagForObject(content));
-  return content;
-}
+import { setCustomTagFor } from '@glimmer/manager/lib/util/args-proxy';
+import type { Tag } from '@glimmer/interfaces';
+import { combine } from '@glimmer/validator/lib/validators';
+import { tagFor, tagMetaFor } from '@glimmer/validator/lib/meta';
+
+import { contentFor } from './content-for';
+export { contentFor };
 
 function customTagForProxy(proxy: object, key: string, addMandatorySetter?: boolean): Tag {
   assert('Expected a proxy', isProxy(proxy));
diff --git a/packages/@ember/-internals/runtime/lib/mixins/action_handler.ts b/packages/@ember/-internals/runtime/lib/mixins/action_handler.ts
index c9496fde7ff..bab591600ee 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/action_handler.ts
+++ b/packages/@ember/-internals/runtime/lib/mixins/action_handler.ts
@@ -3,7 +3,7 @@
 */
 
 import Mixin from '@ember/object/mixin';
-import { get } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import { assert } from '@ember/debug';
 
 /**
diff --git a/packages/@ember/-internals/runtime/lib/mixins/container_proxy.ts b/packages/@ember/-internals/runtime/lib/mixins/container_proxy.ts
index ee60ca9cde9..9b9a870a7c9 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/container_proxy.ts
+++ b/packages/@ember/-internals/runtime/lib/mixins/container_proxy.ts
@@ -2,7 +2,7 @@ import { schedule, join } from '@ember/runloop';
 /**
 @module ember
 */
-import type { Container } from '@ember/-internals/container';
+import type Container from '@ember/-internals/container/lib/container';
 import Mixin from '@ember/object/mixin';
 import type { ContainerProxy } from '@ember/-internals/owner';
 
diff --git a/packages/@ember/-internals/runtime/lib/mixins/content-for.ts b/packages/@ember/-internals/runtime/lib/mixins/content-for.ts
new file mode 100644
index 00000000000..34f3b7f8723
--- /dev/null
+++ b/packages/@ember/-internals/runtime/lib/mixins/content-for.ts
@@ -0,0 +1,13 @@
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { tagForObject } from '@ember/-internals/metal/lib/tags';
+import type { UpdatableTag } from '@glimmer/interfaces';
+import { UPDATE_TAG as updateTag } from '@glimmer/validator/lib/validators';
+import type ProxyMixin from './-proxy';
+
+export function contentFor<T>(proxy: ProxyMixin<T>): T | null {
+  let content = get(proxy, 'content');
+  // SAFETY: @glimmer/validator doesn't expose enough public types for an
+  // assertion here.
+  updateTag(tagForObject(proxy) as UpdatableTag, tagForObject(content));
+  return content;
+}
diff --git a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts
index 1399a185d49..600b2bf62f2 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts
+++ b/packages/@ember/-internals/runtime/lib/mixins/registry_proxy.ts
@@ -2,7 +2,7 @@
 @module ember
 */
 
-import type { Registry } from '@ember/-internals/container';
+import type Registry from '@ember/-internals/container/lib/registry';
 import type { RegistryProxy } from '@ember/-internals/owner';
 import type { AnyFn } from '@ember/-internals/utility-types';
 
diff --git a/packages/@ember/-internals/runtime/lib/mixins/target_action_support.ts b/packages/@ember/-internals/runtime/lib/mixins/target_action_support.ts
index f01223f2b42..d5a7d79229f 100644
--- a/packages/@ember/-internals/runtime/lib/mixins/target_action_support.ts
+++ b/packages/@ember/-internals/runtime/lib/mixins/target_action_support.ts
@@ -2,8 +2,9 @@
 @module ember
 */
 
-import { context } from '@ember/-internals/environment';
-import { get, computed } from '@ember/-internals/metal';
+import { context } from '@ember/-internals/environment/lib/context';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import computed from '@ember/-internals/metal/lib/computed';
 import Mixin from '@ember/object/mixin';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
diff --git a/packages/@ember/-internals/string/index.ts b/packages/@ember/-internals/string/index.ts
index e2e2591b6b4..642ae8b687e 100644
--- a/packages/@ember/-internals/string/index.ts
+++ b/packages/@ember/-internals/string/index.ts
@@ -4,7 +4,7 @@
   now deprecated and to be removed.
 */
 
-import { Cache } from '@ember/-internals/utils';
+import Cache from '@ember/-internals/utils/lib/cache';
 
 const STRING_DASHERIZE_REGEXP = /[ _]/g;
 
diff --git a/packages/@ember/-internals/utils/lib/is_proxy.ts b/packages/@ember/-internals/utils/lib/is_proxy.ts
index 8456b61f9dc..443e4c805b0 100644
--- a/packages/@ember/-internals/utils/lib/is_proxy.ts
+++ b/packages/@ember/-internals/utils/lib/is_proxy.ts
@@ -1,4 +1,4 @@
-import type { _ProxyMixin as ProxyMixin } from '@ember/-internals/runtime';
+import type ProxyMixin from '@ember/-internals/runtime/lib/mixins/-proxy';
 import { isObject } from './spec';
 
 const PROXIES = new WeakSet();
diff --git a/packages/@ember/-internals/utils/lib/mandatory-setter.ts b/packages/@ember/-internals/utils/lib/mandatory-setter.ts
index 92e157f8d8e..fb8c902deeb 100644
--- a/packages/@ember/-internals/utils/lib/mandatory-setter.ts
+++ b/packages/@ember/-internals/utils/lib/mandatory-setter.ts
@@ -1,6 +1,6 @@
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import type { Tag } from '@glimmer/validator';
+import type { Tag } from '@glimmer/interfaces';
 import lookupDescriptor from './lookup-descriptor';
 
 export let setupMandatorySetter:
diff --git a/packages/@ember/-internals/views/lib/compat/fallback-view-registry.ts b/packages/@ember/-internals/views/lib/compat/fallback-view-registry.ts
index 728924073ff..7f73b851aed 100644
--- a/packages/@ember/-internals/views/lib/compat/fallback-view-registry.ts
+++ b/packages/@ember/-internals/views/lib/compat/fallback-view-registry.ts
@@ -1,3 +1,3 @@
-import { dictionary } from '@ember/-internals/utils';
+import dictionary from '@ember/-internals/utils/lib/dictionary';
 
 export default dictionary(null);
diff --git a/packages/@ember/-internals/views/lib/mixins/action_support.ts b/packages/@ember/-internals/views/lib/mixins/action_support.ts
index f7d79862587..a4c95d28ac3 100644
--- a/packages/@ember/-internals/views/lib/mixins/action_support.ts
+++ b/packages/@ember/-internals/views/lib/mixins/action_support.ts
@@ -1,9 +1,10 @@
 /**
  @module ember
 */
-import { get } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import Mixin from '@ember/object/mixin';
-import { assert, inspect } from '@ember/debug';
+import inspect from '@ember/debug/lib/inspect';
+import { assert } from '@ember/debug';
 
 /**
  @class ActionSupport
diff --git a/packages/@ember/-internals/views/lib/system/event_dispatcher.ts b/packages/@ember/-internals/views/lib/system/event_dispatcher.ts
index 1a023ff6cbd..afe9debd56e 100644
--- a/packages/@ember/-internals/views/lib/system/event_dispatcher.ts
+++ b/packages/@ember/-internals/views/lib/system/event_dispatcher.ts
@@ -1,10 +1,11 @@
 import { getOwner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
-import { get, set } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
 import EmberObject from '@ember/object';
 import { getElementView } from './utils';
-import type { BootEnvironment } from '@ember/-internals/glimmer';
-import type Component from '@ember/component';
+import type { BootEnvironment } from '@ember/-internals/glimmer/lib/views/outlet';
+import type Component from '@ember/-internals/glimmer/lib/component';
 
 /**
 @module ember
diff --git a/packages/@ember/-internals/views/lib/system/utils.ts b/packages/@ember/-internals/views/lib/system/utils.ts
index 05d81d7611c..1a33fdfcb68 100644
--- a/packages/@ember/-internals/views/lib/system/utils.ts
+++ b/packages/@ember/-internals/views/lib/system/utils.ts
@@ -1,7 +1,7 @@
-import type { View } from '@ember/-internals/glimmer';
+import type { View } from '@ember/-internals/glimmer/lib/renderer';
 import type { InternalOwner } from '@ember/-internals/owner';
 import { getOwner } from '@ember/-internals/owner';
-import { guidFor } from '@ember/-internals/utils';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
 import { assert } from '@ember/debug';
 import type { Dict } from '@glimmer/interfaces';
 
diff --git a/packages/@ember/-internals/views/lib/views/core_view.ts b/packages/@ember/-internals/views/lib/views/core_view.ts
index 241b233da65..ceb6c0cfa8f 100644
--- a/packages/@ember/-internals/views/lib/views/core_view.ts
+++ b/packages/@ember/-internals/views/lib/views/core_view.ts
@@ -1,6 +1,6 @@
-import type { Renderer, View } from '@ember/-internals/glimmer';
-import { inject } from '@ember/-internals/metal';
-import { ActionHandler } from '@ember/-internals/runtime';
+import type { Renderer, View } from '@ember/-internals/glimmer/lib/renderer';
+import inject from '@ember/-internals/metal/lib/injected_property';
+import ActionHandler from '@ember/-internals/runtime/lib/mixins/action_handler';
 import Evented from '@ember/object/evented';
 import { FrameworkObject } from '@ember/object/-internals';
 import type { ViewState } from './states';
diff --git a/packages/@ember/-internals/views/lib/views/states.ts b/packages/@ember/-internals/views/lib/views/states.ts
index c9480ffbdf4..b38ae20ddfd 100644
--- a/packages/@ember/-internals/views/lib/views/states.ts
+++ b/packages/@ember/-internals/views/lib/views/states.ts
@@ -1,7 +1,7 @@
-import { teardownMandatorySetter } from '@ember/-internals/utils';
-import type Component from '@ember/component';
+import { teardownMandatorySetter } from '@ember/-internals/utils/lib/mandatory-setter';
+import type Component from '@ember/-internals/glimmer/lib/component';
 import { assert } from '@ember/debug';
-import { flaggedInstrument } from '@ember/instrumentation';
+import { flaggedInstrument } from '@ember/instrumentation/lib/internal-instrument';
 import { join } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 
diff --git a/packages/@ember/application/index.ts b/packages/@ember/application/index.ts
index dc6d923835a..e4ac76f8de3 100644
--- a/packages/@ember/application/index.ts
+++ b/packages/@ember/application/index.ts
@@ -2,16 +2,17 @@
 @module @ember/application
 */
 
-import { getOwner as actualGetOwner, setOwner as actualSetOwner } from '@ember/owner';
-import { dictionary } from '@ember/-internals/utils';
-import { ENV } from '@ember/-internals/environment';
-import { hasDOM } from '@ember/-internals/browser-environment';
+import { setOwner as actualSetOwner } from '@ember/-internals/owner';
+import { getOwner as actualGetOwner } from '@ember/owner';
+import dictionary from '@ember/-internals/utils/lib/dictionary';
+import { ENV } from '@ember/-internals/environment/lib/env';
+import hasDOM from '@ember/-internals/browser-environment/lib/has-dom';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { join, once, run, schedule } from '@ember/runloop';
-import { libraries } from '@ember/-internals/metal';
-import { RSVP } from '@ember/-internals/runtime';
-import { EventDispatcher } from '@ember/-internals/views';
+import libraries from '@ember/-internals/metal/lib/libraries';
+import RSVP from '@ember/-internals/runtime/lib/ext/rsvp';
+import EventDispatcher from '@ember/-internals/views/lib/system/event_dispatcher';
 import Route from '@ember/routing/route';
 import Router from '@ember/routing/router';
 import HashLocation from '@ember/routing/hash-location';
@@ -21,9 +22,10 @@ import { BucketCache } from '@ember/routing/-internals';
 import ApplicationInstance from '@ember/application/instance';
 import Engine, { buildInitializerMethod } from '@ember/engine';
 import type { BootOptions } from '@ember/engine/instance';
-import type { Container, Registry } from '@ember/-internals/container';
-import { privatize as P } from '@ember/-internals/container';
-import { setupApplicationRegistry } from '@ember/-internals/glimmer';
+import type Container from '@ember/-internals/container/lib/container';
+import type Registry from '@ember/-internals/container/lib/registry';
+import { privatize as P } from '@ember/-internals/container/lib/registry';
+import { setupApplicationRegistry } from '@ember/-internals/glimmer/lib/setup-registry';
 import RouterService from '@ember/routing/router-service';
 import type { EngineInstanceOptions } from '@ember/engine/instance';
 import type { SimpleDocument, SimpleElement } from '@simple-dom/interface';
diff --git a/packages/@ember/application/instance.ts b/packages/@ember/application/instance.ts
index 47ecb342bd4..1bc600c172c 100644
--- a/packages/@ember/application/instance.ts
+++ b/packages/@ember/application/instance.ts
@@ -2,17 +2,20 @@
 @module @ember/application
 */
 
-import { get, set } from '@ember/object';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+// eslint-disable-next-line ember-local/no-barrel-imports
 import * as environment from '@ember/-internals/browser-environment';
 import EngineInstance from '@ember/engine/instance';
 import type { BootOptions } from '@ember/engine/instance';
 import type Application from '@ember/application';
-import { renderSettled } from '@ember/-internals/glimmer';
-import type { BootEnvironment, Component } from '@ember/-internals/glimmer';
+import { renderSettled } from '@ember/-internals/glimmer/lib/renderer';
+import type { BootEnvironment } from '@ember/-internals/glimmer/lib/views/outlet';
+import type Component from '@ember/-internals/glimmer/lib/component';
 import { assert } from '@ember/debug';
 import Router from '@ember/routing/router';
-import { EventDispatcher } from '@ember/-internals/views';
-import type { Registry } from '@ember/-internals/container';
+import EventDispatcher from '@ember/-internals/views/lib/system/event_dispatcher';
+import type Registry from '@ember/-internals/container/lib/registry';
 import type { SimpleElement } from '@simple-dom/interface';
 
 /**
diff --git a/packages/@ember/application/namespace.ts b/packages/@ember/application/namespace.ts
index 17424a6a9f5..6b3277f24be 100644
--- a/packages/@ember/application/namespace.ts
+++ b/packages/@ember/application/namespace.ts
@@ -12,9 +12,10 @@ import {
   processAllNamespaces,
   removeNamespace,
   type Namespace as MetalNamespace,
-} from '@ember/-internals/metal'; // Preloaded into namespaces
-import { get } from '@ember/object';
-import { getName, guidFor, setName } from '@ember/-internals/utils';
+} from '@ember/-internals/metal/lib/namespace_search'; // Preloaded into namespaces
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { getName, setName } from '@ember/-internals/utils/lib/name';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
 import { assert } from '@ember/debug';
 import EmberObject from '@ember/object';
 
diff --git a/packages/@ember/application/package.json b/packages/@ember/application/package.json
index 074819001a0..aa0f4bfb648 100644
--- a/packages/@ember/application/package.json
+++ b/packages/@ember/application/package.json
@@ -5,7 +5,8 @@
   "exports": {
     ".": "./index.ts",
     "./instance": "./instance.ts",
-    "./namespace": "./namespace.ts"
+    "./namespace": "./namespace.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/array/index.ts b/packages/@ember/array/index.ts
index 044eaf6ddbc..48e0c1b5b1e 100644
--- a/packages/@ember/array/index.ts
+++ b/packages/@ember/array/index.ts
@@ -2,24 +2,25 @@
 @module @ember/array
 */
 import { DEBUG } from '@glimmer/env';
-import { PROXY_CONTENT } from '@ember/-internals/metal';
+import { PROXY_CONTENT } from '@ember/-internals/metal/lib/property_get';
+import { objectAt } from '@ember/-internals/metal/lib/object-at';
+import { replaceInNativeArray, replace } from '@ember/-internals/metal/lib/array';
+import computed from '@ember/-internals/metal/lib/computed';
 import {
-  objectAt,
-  replaceInNativeArray,
-  replace,
-  computed,
   beginPropertyChanges,
   endPropertyChanges,
-} from '@ember/-internals/metal';
-import { get, set } from '@ember/object';
+} from '@ember/-internals/metal/lib/property_events';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
 import Mixin from '@ember/object/mixin';
 import { assert } from '@ember/debug';
 import Enumerable from '@ember/enumerable';
 import MutableEnumerable from '@ember/enumerable/mutable';
-import { compare, typeOf } from '@ember/utils';
+import compare from '@ember/utils/lib/compare';
+import typeOf from '@ember/utils/lib/type-of';
 import Observable from '@ember/object/observable';
 import type { MethodNamesOf, MethodParams, MethodReturns } from '@ember/-internals/utility-types';
-import type { ComputedPropertyCallback } from '@ember/-internals/metal';
+import type { ComputedPropertyCallback } from '@ember/-internals/metal/lib/computed';
 import { isEmberArray, setEmberArray } from '@ember/array/-internals';
 
 export { default as makeArray } from './make';
diff --git a/packages/@ember/array/package.json b/packages/@ember/array/package.json
index 4d70f3a7416..8585c775652 100644
--- a/packages/@ember/array/package.json
+++ b/packages/@ember/array/package.json
@@ -7,7 +7,8 @@
     "./-internals": "./-internals.ts",
     "./proxy": "./proxy.ts",
     "./make": "./make.ts",
-    "./mutable": "./mutable.ts"
+    "./mutable": "./mutable.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
@@ -19,6 +20,7 @@
     "@ember/utils": "workspace:*",
     "@glimmer/destroyable": "workspace:*",
     "@glimmer/env": "workspace:*",
+    "@glimmer/interfaces": "workspace:*",
     "@glimmer/manager": "workspace:*",
     "@glimmer/owner": "workspace:*",
     "@glimmer/util": "workspace:*",
diff --git a/packages/@ember/array/proxy.ts b/packages/@ember/array/proxy.ts
index ff72f1990ac..d4a9907c2ff 100644
--- a/packages/@ember/array/proxy.ts
+++ b/packages/@ember/array/proxy.ts
@@ -2,34 +2,32 @@
 @module @ember/array/proxy
 */
 
+import { objectAt } from '@ember/-internals/metal/lib/object-at';
+import alias from '@ember/-internals/metal/lib/alias';
+import { PROPERTY_DID_CHANGE } from '@ember/-internals/metal/lib/property_events';
+import { addArrayObserver, removeArrayObserver, replace } from '@ember/-internals/metal/lib/array';
 import {
-  objectAt,
-  alias,
-  PROPERTY_DID_CHANGE,
-  addArrayObserver,
-  removeArrayObserver,
-  replace,
   arrayContentDidChange,
   arrayContentWillChange,
-  tagForProperty,
-} from '@ember/-internals/metal';
-import { get } from '@ember/object';
-import type { PropertyDidChange } from '@ember/-internals/metal';
-import { isObject } from '@ember/-internals/utils';
+} from '@ember/-internals/metal/lib/array_events';
+import { tagForProperty } from '@ember/-internals/metal/lib/tags';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import type { PropertyDidChange } from '@ember/-internals/metal/lib/property_events';
+import { isObject } from '@ember/-internals/utils/lib/spec';
 import EmberObject from '@ember/object';
 import EmberArray, { type NativeArray } from '@ember/array';
 import MutableArray from '@ember/array/mutable';
 import { assert } from '@ember/debug';
-import { setCustomTagFor } from '@glimmer/manager';
+import { setCustomTagFor } from '@glimmer/manager/lib/util/args-proxy';
 import {
   combine,
-  consumeTag,
   validateTag,
   valueForTag,
-  tagFor,
-  type Tag,
   type Revision,
-} from '@glimmer/validator';
+} from '@glimmer/validator/lib/validators';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
+import type { Tag } from '@glimmer/interfaces';
 
 function isMutable<T>(obj: T[] | EmberArray<T>): obj is T[] | MutableArray<T> {
   return Array.isArray(obj) || typeof (obj as MutableArray<T>).replace === 'function';
diff --git a/packages/@ember/canary-features/index.ts b/packages/@ember/canary-features/index.ts
index 0d2c89324f2..01548b71daa 100644
--- a/packages/@ember/canary-features/index.ts
+++ b/packages/@ember/canary-features/index.ts
@@ -1,4 +1,4 @@
-import { ENV } from '@ember/-internals/environment';
+import { ENV } from '@ember/-internals/environment/lib/env';
 
 /**
   Set `EmberENV.FEATURES` in your application's `config/environment.js` file
diff --git a/packages/@ember/canary-features/package.json b/packages/@ember/canary-features/package.json
index a48d2c25cce..e787701b4c8 100644
--- a/packages/@ember/canary-features/package.json
+++ b/packages/@ember/canary-features/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/component/helper.ts b/packages/@ember/component/helper.ts
index c1aa1427027..85b8a435196 100644
--- a/packages/@ember/component/helper.ts
+++ b/packages/@ember/component/helper.ts
@@ -1,6 +1,6 @@
 export {
-  Helper as default,
+  default,
   helper,
   type FunctionBasedHelper,
   type FunctionBasedHelperInstance,
-} from '@ember/-internals/glimmer';
+} from '@ember/-internals/glimmer/lib/helper';
diff --git a/packages/@ember/component/index.ts b/packages/@ember/component/index.ts
index 0834c935f80..9ce284937b3 100644
--- a/packages/@ember/component/index.ts
+++ b/packages/@ember/component/index.ts
@@ -3,13 +3,13 @@
   @public
  */
 
-export { setComponentTemplate, getComponentTemplate } from '@glimmer/manager';
+export { setComponentTemplate, getComponentTemplate } from '@glimmer/manager/lib/public/template';
 
-export { Component as default, Input, Textarea } from '@ember/-internals/glimmer';
-export {
-  componentCapabilities as capabilities,
-  setComponentManager,
-} from '@ember/-internals/glimmer';
+export { default } from '@ember/-internals/glimmer/lib/component';
+export { default as Input } from '@ember/-internals/glimmer/lib/components/input';
+export { default as Textarea } from '@ember/-internals/glimmer/lib/components/textarea';
+export { componentCapabilities as capabilities } from '@glimmer/manager/lib/public/component';
+export { setComponentManager } from '@ember/-internals/glimmer/lib/utils/managers';
 
 /**
  * Assigns a TemplateFactory to a component class.
diff --git a/packages/@ember/component/package.json b/packages/@ember/component/package.json
index 1ba77462038..e101a1c97b1 100644
--- a/packages/@ember/component/package.json
+++ b/packages/@ember/component/package.json
@@ -5,7 +5,8 @@
   "exports": {
     ".": "./index.ts",
     "./helper": "./helper.ts",
-    "./template-only": "./template-only.ts"
+    "./template-only": "./template-only.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/component/template-only.ts b/packages/@ember/component/template-only.ts
index 93625305975..92fd1696cc1 100644
--- a/packages/@ember/component/template-only.ts
+++ b/packages/@ember/component/template-only.ts
@@ -31,7 +31,7 @@
   @category EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
 */
 import { type Opaque } from '@ember/-internals/utility-types';
-import { templateOnlyComponent as glimmerTemplateOnlyComponent } from '@glimmer/runtime';
+import { templateOnlyComponent as glimmerTemplateOnlyComponent } from '@glimmer/runtime/lib/component/template-only';
 
 /**
  * Template-only components have no backing class instance, so `this` in their
diff --git a/packages/@ember/controller/index.ts b/packages/@ember/controller/index.ts
index 02b17a3be21..a65d5dd8d3e 100644
--- a/packages/@ember/controller/index.ts
+++ b/packages/@ember/controller/index.ts
@@ -1,11 +1,15 @@
 import { getOwner } from '@ember/-internals/owner'; // This is imported from -internals to avoid circularity
-import { computed, get } from '@ember/object';
+import computed from '@ember/-internals/metal/lib/computed';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import { FrameworkObject } from '@ember/object/-internals';
-import { inject as metalInject } from '@ember/-internals/metal';
-import type { DecoratorPropertyDescriptor, ElementDescriptor } from '@ember/-internals/metal';
+import metalInject from '@ember/-internals/metal/lib/injected_property';
+import type {
+  DecoratorPropertyDescriptor,
+  ElementDescriptor,
+} from '@ember/-internals/metal/lib/decorator';
 import Mixin from '@ember/object/mixin';
 import type { RouteArgs } from '@ember/routing/-internals';
-import { ActionHandler } from '@ember/-internals/runtime';
+import ActionHandler from '@ember/-internals/runtime/lib/mixins/action_handler';
 import type { Transition } from 'router_js';
 
 export type ControllerQueryParamType = 'boolean' | 'number' | 'array' | 'string';
diff --git a/packages/@ember/controller/package.json b/packages/@ember/controller/package.json
index 516e2c15e8b..90e42a88425 100644
--- a/packages/@ember/controller/package.json
+++ b/packages/@ember/controller/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
@@ -16,7 +17,7 @@
     "@glimmer/env": "workspace:*",
     "@glimmer/owner": "workspace:*",
     "@glimmer/util": "workspace:*",
-    "@glimmer/validator":"workspace:*",
+    "@glimmer/validator": "workspace:*",
     "expect-type": "^0.15.0",
     "internal-test-helpers": "workspace:*"
   },
diff --git a/packages/@ember/debug/container-debug-adapter.ts b/packages/@ember/debug/container-debug-adapter.ts
index e62fcb0ed7b..f61fe2652d6 100644
--- a/packages/@ember/debug/container-debug-adapter.ts
+++ b/packages/@ember/debug/container-debug-adapter.ts
@@ -1,9 +1,9 @@
 import { classify, dasherize } from '@ember/-internals/string';
 import EmberObject from '@ember/object';
-import { typeOf } from '@ember/utils';
+import typeOf from '@ember/utils/lib/type-of';
 import type Owner from '@ember/owner';
 import { getOwner } from '@ember/-internals/owner';
-import type { Resolver } from '@ember/owner';
+import type { Resolver } from '@ember/-internals/owner';
 import Namespace from '@ember/application/namespace';
 
 /**
diff --git a/packages/@ember/debug/data-adapter.ts b/packages/@ember/debug/data-adapter.ts
index a92118eb33a..4b37faaff4b 100644
--- a/packages/@ember/debug/data-adapter.ts
+++ b/packages/@ember/debug/data-adapter.ts
@@ -1,14 +1,15 @@
 import type Owner from '@ember/owner';
 import { getOwner } from '@ember/-internals/owner';
 import { _backburner, next } from '@ember/runloop';
-import { get } from '@ember/object';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import { dasherize } from '@ember/-internals/string';
 import Namespace from '@ember/application/namespace';
 import type { NativeArray } from '@ember/array';
 import EmberObject from '@ember/object';
 import { A as emberA } from '@ember/array';
-import type { Cache } from '@glimmer/validator';
-import { consumeTag, createCache, getValue, tagFor, untrack } from '@glimmer/validator';
+import type { Cache } from '@glimmer/validator/lib/tracking';
+import { consumeTag, createCache, getValue, untrack } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
 import type ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
 import { assert } from '.';
 
diff --git a/packages/@ember/debug/index.ts b/packages/@ember/debug/index.ts
index 522c0109e78..d24c1ec74cf 100644
--- a/packages/@ember/debug/index.ts
+++ b/packages/@ember/debug/index.ts
@@ -1,5 +1,5 @@
 import { isChrome, isFirefox } from '@ember/-internals/browser-environment';
-import { ENV } from '@ember/-internals/environment';
+import { ENV } from '@ember/-internals/environment/lib/env';
 import type { AnyFn } from '@ember/-internals/utility-types';
 import { DEBUG } from '@glimmer/env';
 import type { DeprecateFunc, DeprecationOptions } from './lib/deprecate';
diff --git a/packages/@ember/debug/lib/capture-render-tree.ts b/packages/@ember/debug/lib/capture-render-tree.ts
index 6f7d28bb532..03c5cd4b3fa 100644
--- a/packages/@ember/debug/lib/capture-render-tree.ts
+++ b/packages/@ember/debug/lib/capture-render-tree.ts
@@ -1,4 +1,4 @@
-import type { Renderer } from '@ember/-internals/glimmer';
+import type { Renderer } from '@ember/-internals/glimmer/lib/renderer';
 import type Owner from '@ember/owner';
 import type { CapturedRenderNode } from '@glimmer/interfaces';
 
diff --git a/packages/@ember/debug/lib/deprecate.ts b/packages/@ember/debug/lib/deprecate.ts
index 20a30302868..ce32eacfbd4 100644
--- a/packages/@ember/debug/lib/deprecate.ts
+++ b/packages/@ember/debug/lib/deprecate.ts
@@ -1,4 +1,4 @@
-import { ENV } from '@ember/-internals/environment';
+import { ENV } from '@ember/-internals/environment/lib/env';
 import { DEBUG } from '@glimmer/env';
 
 import { assert } from './assert';
diff --git a/packages/@ember/debug/package.json b/packages/@ember/debug/package.json
index d3dba7157e9..0d271bb0f79 100644
--- a/packages/@ember/debug/package.json
+++ b/packages/@ember/debug/package.json
@@ -5,7 +5,8 @@
   "exports": {
     ".": "./index.ts",
     "./container-debug-adapter": "./container-debug-adapter.ts",
-    "./data-adapter": "./data-adapter.ts"
+    "./data-adapter": "./data-adapter.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/deprecated-features/package.json b/packages/@ember/deprecated-features/package.json
index 4571941dcae..c42c06292ad 100644
--- a/packages/@ember/deprecated-features/package.json
+++ b/packages/@ember/deprecated-features/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {}
 }
\ No newline at end of file
diff --git a/packages/@ember/destroyable/package.json b/packages/@ember/destroyable/package.json
index 07688a98e9e..16feea8982b 100644
--- a/packages/@ember/destroyable/package.json
+++ b/packages/@ember/destroyable/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@glimmer/destroyable": "workspace:*",
diff --git a/packages/@ember/engine/index.ts b/packages/@ember/engine/index.ts
index e16240fa87d..593c52a2930 100644
--- a/packages/@ember/engine/index.ts
+++ b/packages/@ember/engine/index.ts
@@ -1,20 +1,21 @@
 export { getEngineParent, setEngineParent } from './parent';
 
-import { canInvoke } from '@ember/-internals/utils';
+import { canInvoke } from '@ember/-internals/utils/lib/invoke';
 import Controller from '@ember/controller';
 import Namespace from '@ember/application/namespace';
-import { Registry } from '@ember/-internals/container';
-import type { ResolverClass } from '@ember/-internals/container';
+import Registry from '@ember/-internals/container/lib/registry';
+import type { ResolverClass } from '@ember/-internals/container/lib/registry';
 import DAG from 'dag-map';
 import { assert } from '@ember/debug';
 import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';
-import { get, set } from '@ember/object';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
 import type { EngineInstanceOptions } from '@ember/engine/instance';
 import EngineInstance from '@ember/engine/instance';
 import { RoutingService } from '@ember/routing/-internals';
-import { ComponentLookup } from '@ember/-internals/views';
-import { setupEngineRegistry } from '@ember/-internals/glimmer';
-import { RegistryProxyMixin } from '@ember/-internals/runtime';
+import ComponentLookup from '@ember/-internals/views/lib/component_lookup';
+import { setupEngineRegistry } from '@ember/-internals/glimmer/lib/setup-registry';
+import RegistryProxyMixin from '@ember/-internals/runtime/lib/mixins/registry_proxy';
 
 function props(obj: object) {
   let properties = [];
diff --git a/packages/@ember/engine/instance.ts b/packages/@ember/engine/instance.ts
index 097b5c6ca6e..050d27eb3b8 100644
--- a/packages/@ember/engine/instance.ts
+++ b/packages/@ember/engine/instance.ts
@@ -3,18 +3,19 @@
 */
 
 import EmberObject from '@ember/object';
-import { RSVP } from '@ember/-internals/runtime';
+import RSVP from '@ember/-internals/runtime/lib/ext/rsvp';
 import { assert } from '@ember/debug';
-import { Registry, privatize as P } from '@ember/-internals/container';
-import { guidFor } from '@ember/-internals/utils';
+import { default as Registry, privatize as P } from '@ember/-internals/container/lib/registry';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
 import { ENGINE_PARENT, getEngineParent, setEngineParent } from './parent';
-import { ContainerProxyMixin, RegistryProxyMixin } from '@ember/-internals/runtime';
+import ContainerProxyMixin from '@ember/-internals/runtime/lib/mixins/container_proxy';
+import RegistryProxyMixin from '@ember/-internals/runtime/lib/mixins/registry_proxy';
 import type { InternalOwner } from '@ember/-internals/owner';
 import type Owner from '@ember/-internals/owner';
 import { type FullName, isFactory } from '@ember/-internals/owner';
 import type Engine from '@ember/engine';
 import type Application from '@ember/application';
-import type { BootEnvironment } from '@ember/-internals/glimmer';
+import type { BootEnvironment } from '@ember/-internals/glimmer/lib/views/outlet';
 import type { SimpleElement } from '@simple-dom/interface';
 
 export interface BootOptions {
diff --git a/packages/@ember/engine/package.json b/packages/@ember/engine/package.json
index b08914eb32f..1756d1d1cdc 100644
--- a/packages/@ember/engine/package.json
+++ b/packages/@ember/engine/package.json
@@ -5,7 +5,8 @@
   "exports": {
     ".": "./index.ts",
     "./instance": "./instance.ts",
-    "./parent": "./parent.ts"
+    "./parent": "./parent.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/enumerable/package.json b/packages/@ember/enumerable/package.json
index 8c7a9a95bf2..a12c717454d 100644
--- a/packages/@ember/enumerable/package.json
+++ b/packages/@ember/enumerable/package.json
@@ -4,7 +4,8 @@
   "type": "module",
   "exports": {
     ".": "./index.ts",
-    "./mutable": "./mutable.ts"
+    "./mutable": "./mutable.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/helper/index.ts b/packages/@ember/helper/index.ts
index bdf745a9974..502c6baae91 100644
--- a/packages/@ember/helper/index.ts
+++ b/packages/@ember/helper/index.ts
@@ -2,18 +2,18 @@
 @module @ember/helper
 */
 
-import { setHelperManager as glimmerSetHelperManager, helperCapabilities } from '@glimmer/manager';
-import {
-  invokeHelper as glimmerInvokeHelper,
-  hash as glimmerHash,
-  array as glimmerArray,
-  concat as glimmerConcat,
-  eq as glimmerEq,
-  get as glimmerGet,
-  fn as glimmerFn,
-  neq as glimmerNeq,
-} from '@glimmer/runtime';
-import { element as glimmerElement, uniqueId as glimmerUniqueId } from '@ember/-internals/glimmer';
+import { setHelperManager as glimmerSetHelperManager } from '@glimmer/manager/lib/public/api';
+import { helperCapabilities } from '@glimmer/manager/lib/public/helper';
+import { invokeHelper as glimmerInvokeHelper } from '@glimmer/runtime/lib/helpers/invoke';
+import { hash as glimmerHash } from '@glimmer/runtime/lib/helpers/hash';
+import { array as glimmerArray } from '@glimmer/runtime/lib/helpers/array';
+import { concat as glimmerConcat } from '@glimmer/runtime/lib/helpers/concat';
+import { eq as glimmerEq } from '@glimmer/runtime/lib/helpers/eq';
+import { get as glimmerGet } from '@glimmer/runtime/lib/helpers/get';
+import { fn as glimmerFn } from '@glimmer/runtime/lib/helpers/fn';
+import { neq as glimmerNeq } from '@glimmer/runtime/lib/helpers/neq';
+import glimmerElement from '@ember/-internals/glimmer/lib/helpers/element';
+import { uniqueId as glimmerUniqueId } from '@ember/-internals/glimmer/lib/helpers/unique-id';
 import { type Opaque } from '@ember/-internals/utility-types';
 
 /**
diff --git a/packages/@ember/helper/package.json b/packages/@ember/helper/package.json
index 08cdf2c7a0e..8884ff2d17a 100644
--- a/packages/@ember/helper/package.json
+++ b/packages/@ember/helper/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/instrumentation/index.ts b/packages/@ember/instrumentation/index.ts
index 00938f3a9c7..1fe451298f6 100644
--- a/packages/@ember/instrumentation/index.ts
+++ b/packages/@ember/instrumentation/index.ts
@@ -1,28 +1,19 @@
-/* eslint no-console:off */
-/* global console */
-
-import { ENV } from '@ember/-internals/environment';
-import { assert } from '@ember/debug';
-
-export interface Listener<T> {
-  before: (name: string, timestamp: number, payload: object) => T;
-  after: (name: string, timestamp: number, payload: object, beforeValue: T) => void;
-}
-
-export interface Subscriber<T> {
-  pattern: string;
-  regex: RegExp;
-  object: Listener<T>;
-}
+import {
+  NOOP,
+  _instrumentStart,
+  resetCache,
+  subscribers,
+  type Listener,
+  type Subscriber,
+} from './lib/internal-instrument';
+
+export { _instrumentStart, flaggedInstrument, subscribers } from './lib/internal-instrument';
+export type { Listener, Subscriber, StructuredProfilePayload } from './lib/internal-instrument';
 
 export interface PayloadWithException {
   exception?: any;
 }
 
-export interface StructuredProfilePayload {
-  object: string | object;
-}
-
 /**
 @module @ember/instrumentation
 @private
@@ -78,23 +69,6 @@ export interface StructuredProfilePayload {
   @static
   @private
 */
-export let subscribers: Subscriber<any>[] = [];
-let cache: { [key: string]: Listener<any>[] } = {};
-
-function populateListeners(name: string) {
-  let listeners: Listener<any>[] = [];
-
-  for (let subscriber of subscribers) {
-    if (subscriber.regex.test(name)) {
-      listeners.push(subscriber.object);
-    }
-  }
-
-  cache[name] = listeners;
-  return listeners;
-}
-
-const time = (): number => performance.now();
 
 type InstrumentCallback<Binding, Result> = (this: Binding) => Result;
 
@@ -172,14 +146,6 @@ export function instrument<Binding, Result>(
   }
 }
 
-export function flaggedInstrument<Result>(
-  _name: string,
-  _payload: object,
-  callback: () => Result
-): Result {
-  return callback();
-}
-
 function withFinalizer<Binding, Result>(
   callback: InstrumentCallback<Binding, Result>,
   finalizer: () => void,
@@ -196,67 +162,6 @@ function withFinalizer<Binding, Result>(
   }
 }
 
-function NOOP() {}
-
-// private for now
-export function _instrumentStart(name: string, payloadFunc: () => object): () => void;
-export function _instrumentStart<Arg>(
-  name: string,
-  payloadFunc: (arg: Arg) => object,
-  payloadArg: Arg
-): () => void;
-export function _instrumentStart<Arg>(
-  name: string,
-  payloadFunc: ((arg: Arg) => object) | (() => object),
-  payloadArg?: Arg
-): () => void {
-  if (subscribers.length === 0) {
-    return NOOP;
-  }
-
-  let listeners = cache[name];
-
-  if (!listeners) {
-    listeners = populateListeners(name);
-  }
-
-  if (listeners.length === 0) {
-    return NOOP;
-  }
-
-  let payload = payloadFunc(payloadArg!);
-
-  let STRUCTURED_PROFILE = ENV.STRUCTURED_PROFILE;
-  let timeName: string;
-  if (STRUCTURED_PROFILE) {
-    timeName = `${name}: ${(payload as StructuredProfilePayload).object}`;
-    console.time(timeName);
-  }
-
-  let beforeValues: any[] = [];
-  let timestamp = time();
-  for (let listener of listeners) {
-    beforeValues.push(listener.before(name, timestamp, payload));
-  }
-
-  const constListeners = listeners;
-
-  return function _instrumentEnd(): void {
-    let timestamp = time();
-    for (let i = 0; i < constListeners.length; i++) {
-      let listener = constListeners[i];
-      assert('has listener', listener); // Iterating over values
-      if (typeof listener.after === 'function') {
-        listener.after(name, timestamp, payload, beforeValues[i]);
-      }
-    }
-
-    if (STRUCTURED_PROFILE) {
-      console.timeEnd(timeName);
-    }
-  };
-}
-
 /**
   Subscribes to a particular event or instrumented block of code.
 
@@ -292,7 +197,7 @@ export function subscribe<T>(pattern: string, object: Listener<T>): Subscriber<T
   };
 
   subscribers.push(subscriber);
-  cache = {};
+  resetCache();
 
   return subscriber;
 }
@@ -317,7 +222,7 @@ export function unsubscribe(subscriber: Subscriber<any>): void {
   }
 
   subscribers.splice(index, 1);
-  cache = {};
+  resetCache();
 }
 
 /**
@@ -330,5 +235,5 @@ export function unsubscribe(subscriber: Subscriber<any>): void {
 */
 export function reset(): void {
   subscribers.length = 0;
-  cache = {};
+  resetCache();
 }
diff --git a/packages/@ember/instrumentation/lib/internal-instrument.ts b/packages/@ember/instrumentation/lib/internal-instrument.ts
new file mode 100644
index 00000000000..10cab44910e
--- /dev/null
+++ b/packages/@ember/instrumentation/lib/internal-instrument.ts
@@ -0,0 +1,114 @@
+import { ENV } from '@ember/-internals/environment/lib/env';
+import { assert } from '@ember/debug';
+
+export interface Listener<T> {
+  before: (name: string, timestamp: number, payload: object) => T;
+  after: (name: string, timestamp: number, payload: object, beforeValue: T) => void;
+}
+
+export interface Subscriber<T> {
+  pattern: string;
+  regex: RegExp;
+  object: Listener<T>;
+}
+
+export interface StructuredProfilePayload {
+  object: string | object;
+}
+
+export const subscribers: Subscriber<any>[] = [];
+
+export const cache: { [key: string]: Listener<any>[] } = {};
+
+export function resetCache(): void {
+  for (const key of Object.keys(cache)) {
+    delete cache[key];
+  }
+}
+
+function populateListeners(name: string): Listener<any>[] {
+  let listeners: Listener<any>[] = [];
+
+  for (let subscriber of subscribers) {
+    if (subscriber.regex.test(name)) {
+      listeners.push(subscriber.object);
+    }
+  }
+
+  cache[name] = listeners;
+  return listeners;
+}
+
+const time = (): number => performance.now();
+
+export const NOOP = (): void => {};
+
+// `flaggedInstrument` historically wrapped a callback in conditionally-
+// enabled instrumentation; today it's a thin pass-through.
+export function flaggedInstrument<Result>(
+  _name: string,
+  _payload: object,
+  callback: () => Result
+): Result {
+  return callback();
+}
+
+export function _instrumentStart(name: string, payloadFunc: () => object): () => void;
+export function _instrumentStart<Arg>(
+  name: string,
+  payloadFunc: (arg: Arg) => object,
+  payloadArg: Arg
+): () => void;
+export function _instrumentStart<Arg>(
+  name: string,
+  payloadFunc: ((arg: Arg) => object) | (() => object),
+  payloadArg?: Arg
+): () => void {
+  if (subscribers.length === 0) {
+    return NOOP;
+  }
+
+  let listeners = cache[name];
+
+  if (!listeners) {
+    listeners = populateListeners(name);
+  }
+
+  if (listeners.length === 0) {
+    return NOOP;
+  }
+
+  let payload = payloadFunc(payloadArg!);
+
+  let STRUCTURED_PROFILE = ENV.STRUCTURED_PROFILE;
+  let timeName: string;
+  if (STRUCTURED_PROFILE) {
+    timeName = `${name}: ${(payload as StructuredProfilePayload).object}`;
+    // eslint-disable-next-line no-console
+    console.time(timeName);
+  }
+
+  let beforeValues: any[] = [];
+  let timestamp = time();
+  for (let listener of listeners) {
+    beforeValues.push(listener.before(name, timestamp, payload));
+  }
+
+  const constListeners = listeners;
+
+  return function _instrumentEnd(): void {
+    let timestamp = time();
+    for (let i = 0; i < constListeners.length; i++) {
+      let listener = constListeners[i];
+      assert('has listener', listener);
+      if (typeof listener.after === 'function') {
+        listener.after(name, timestamp, payload, beforeValues[i]);
+      }
+    }
+
+    if (STRUCTURED_PROFILE) {
+      // eslint-disable-next-line no-console
+      console.timeEnd(timeName);
+    }
+  };
+}
diff --git a/packages/@ember/instrumentation/package.json b/packages/@ember/instrumentation/package.json
index 71c5dba9d64..b0e5097cebd 100644
--- a/packages/@ember/instrumentation/package.json
+++ b/packages/@ember/instrumentation/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/modifier/index.ts b/packages/@ember/modifier/index.ts
index dfbb7ffa3b5..428bc4f71b5 100644
--- a/packages/@ember/modifier/index.ts
+++ b/packages/@ember/modifier/index.ts
@@ -1,4 +1,4 @@
-import { setModifierManager as glimmerSetModifierManager } from '@glimmer/manager';
+import { setModifierManager as glimmerSetModifierManager } from '@glimmer/manager/lib/public/api';
 
 import type Owner from '@ember/owner';
 import type { ModifierManager } from '@glimmer/interfaces';
@@ -15,4 +15,4 @@ export const setModifierManager: <T extends object>(
 export type { ModifierManager };
 
 export type { ModifierCapabilities } from '@glimmer/interfaces';
-export { modifierCapabilities as capabilities } from '@ember/-internals/glimmer';
+export { modifierCapabilities as capabilities } from '@glimmer/manager/lib/public/modifier';
diff --git a/packages/@ember/modifier/on.ts b/packages/@ember/modifier/on.ts
index e440c3921fa..1ee27e47e35 100644
--- a/packages/@ember/modifier/on.ts
+++ b/packages/@ember/modifier/on.ts
@@ -1,4 +1,4 @@
-import { on as glimmerOn } from '@glimmer/runtime';
+import { on as glimmerOn } from '@glimmer/runtime/lib/modifiers/on';
 
 import type { Opaque } from '@ember/-internals/utility-types';
 
diff --git a/packages/@ember/modifier/package.json b/packages/@ember/modifier/package.json
index ce095c02a16..b4f8daa52c8 100644
--- a/packages/@ember/modifier/package.json
+++ b/packages/@ember/modifier/package.json
@@ -4,7 +4,8 @@
   "type": "module",
   "exports": {
     ".": "./index.ts",
-    "./on": "./on.ts"
+    "./on": "./on.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/object/-internals.ts b/packages/@ember/object/-internals.ts
index 880c5a05af9..9021a8dd03d 100644
--- a/packages/@ember/object/-internals.ts
+++ b/packages/@ember/object/-internals.ts
@@ -1,7 +1,7 @@
-export { getCachedValueFor as cacheFor } from '@ember/-internals/metal';
-export { guidFor } from '@ember/-internals/utils';
+export { getCachedValueFor as cacheFor } from '@ember/-internals/metal/lib/computed_cache';
+export { guidFor } from '@ember/-internals/utils/lib/guid';
 
-import { addListener } from '@ember/-internals/metal';
+import { addListener } from '@ember/-internals/metal/lib/events';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import EmberObject from '.';
diff --git a/packages/@ember/object/action.ts b/packages/@ember/object/action.ts
new file mode 100644
index 00000000000..e514c005b81
--- /dev/null
+++ b/packages/@ember/object/action.ts
@@ -0,0 +1,120 @@
+import { assert } from '@ember/debug';
+import type {
+  ElementDescriptor,
+  ExtendedMethodDecorator,
+} from '@ember/-internals/metal/lib/decorator';
+import { isElementDescriptor, setClassicDecorator } from '@ember/-internals/metal/lib/decorator';
+
+const BINDINGS_MAP = new WeakMap();
+
+interface HasProto {
+  constructor: {
+    proto(): void;
+  };
+}
+
+function hasProto(obj: unknown): obj is HasProto {
+  return (
+    obj != null &&
+    (obj as any).constructor !== undefined &&
+    typeof ((obj as any).constructor as any).proto === 'function'
+  );
+}
+
+interface HasActions {
+  actions: Record<string | symbol, unknown>;
+}
+
+function setupAction(
+  target: Partial<HasActions>,
+  key: string | symbol,
+  actionFn: Function
+): TypedPropertyDescriptor<unknown> {
+  if (hasProto(target)) {
+    target.constructor.proto();
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(target, 'actions')) {
+    let parentActions = target.actions;
+    // we need to assign because of the way mixins copy actions down when inheriting
+    target.actions = parentActions ? Object.assign({}, parentActions) : {};
+  }
+
+  assert("[BUG] Somehow the target doesn't have actions!", target.actions != null);
+
+  target.actions[key] = actionFn;
+
+  return {
+    get() {
+      let bindings = BINDINGS_MAP.get(this);
+
+      if (bindings === undefined) {
+        bindings = new Map();
+        BINDINGS_MAP.set(this, bindings);
+      }
+
+      let fn = bindings.get(actionFn);
+
+      if (fn === undefined) {
+        fn = actionFn.bind(this);
+        bindings.set(actionFn, fn);
+      }
+
+      return fn;
+    },
+  };
+}
+
+export function action(
+  target: ElementDescriptor[0],
+  key: ElementDescriptor[1],
+  desc: ElementDescriptor[2]
+): PropertyDescriptor;
+export function action(desc: PropertyDescriptor): ExtendedMethodDecorator;
+export function action(
+  ...args: ElementDescriptor | [PropertyDescriptor]
+): PropertyDescriptor | ExtendedMethodDecorator {
+  let actionFn: object | Function;
+
+  if (!isElementDescriptor(args)) {
+    actionFn = args[0];
+
+    let decorator: ExtendedMethodDecorator = function (
+      target,
+      key,
+      _desc,
+      _meta,
+      isClassicDecorator
+    ) {
+      assert(
+        'The @action decorator may only be passed a method when used in classic classes. You should decorate methods directly in native classes',
+        isClassicDecorator
+      );
+
+      assert(
+        'The action() decorator must be passed a method when used in classic classes',
+        typeof actionFn === 'function'
+      );
+
+      return setupAction(target, key, actionFn);
+    };
+
+    setClassicDecorator(decorator);
+
+    return decorator;
+  }
+
+  let [target, key, desc] = args;
+
+  actionFn = desc?.value;
+
+  assert(
+    'The @action decorator must be applied to methods when used in native classes',
+    typeof actionFn === 'function'
+  );
+
+  // SAFETY: TS types are weird with decorators. This should work.
+  return setupAction(target, key, actionFn);
+}
+
+setClassicDecorator(action as ExtendedMethodDecorator);
diff --git a/packages/@ember/object/compat.ts b/packages/@ember/object/compat.ts
index 39265d27b66..e7df59b091f 100644
--- a/packages/@ember/object/compat.ts
+++ b/packages/@ember/object/compat.ts
@@ -1,14 +1,19 @@
-import type { Meta } from '@ember/-internals/meta';
-import type { ExtendedMethodDecorator, DecoratorPropertyDescriptor } from '@ember/-internals/metal';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import type {
+  ExtendedMethodDecorator,
+  DecoratorPropertyDescriptor,
+} from '@ember/-internals/metal/lib/decorator';
 import {
   descriptorForProperty,
   isElementDescriptor,
   setClassicDecorator,
-} from '@ember/-internals/metal';
-import type { ElementDescriptor } from '@ember/-internals/metal';
+} from '@ember/-internals/metal/lib/decorator';
+import type { ElementDescriptor } from '@ember/-internals/metal/lib/decorator';
 import { assert } from '@ember/debug';
-import type { UpdatableTag } from '@glimmer/validator';
-import { consumeTag, tagFor, track, updateTag } from '@glimmer/validator';
+import type { UpdatableTag } from '@glimmer/interfaces';
+import { consumeTag, track } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
+import { UPDATE_TAG as updateTag } from '@glimmer/validator/lib/validators';
 
 let wrapGetterSetter = function (target: object, key: string, desc: PropertyDescriptor) {
   let { get: originalGet } = desc;
diff --git a/packages/@ember/object/computed.ts b/packages/@ember/object/computed.ts
index 9949474f786..5e4d41bc33b 100644
--- a/packages/@ember/object/computed.ts
+++ b/packages/@ember/object/computed.ts
@@ -1,4 +1,6 @@
-export { ComputedProperty as default, expandProperties, alias } from '@ember/-internals/metal';
+export { ComputedProperty as default } from '@ember/-internals/metal/lib/computed';
+export { default as expandProperties } from '@ember/-internals/metal/lib/expand_properties';
+export { default as alias } from '@ember/-internals/metal/lib/alias';
 
 export {
   empty,
diff --git a/packages/@ember/object/core.ts b/packages/@ember/object/core.ts
index a8ed8d112e1..858015174fb 100644
--- a/packages/@ember/object/core.ts
+++ b/packages/@ember/object/core.ts
@@ -2,23 +2,20 @@
   @module @ember/object/core
 */
 
-import { getFactoryFor, setFactoryFor } from '@ember/-internals/container';
+import { getFactoryFor, setFactoryFor } from '@ember/-internals/container/lib/container';
 import { type default as Owner, getOwner } from '@ember/-internals/owner';
-import { guidFor } from '@ember/-internals/utils';
-import { meta } from '@ember/-internals/meta';
-import type { ComputedProperty, HasUnknownProperty } from '@ember/-internals/metal';
-import {
-  PROXY_CONTENT,
-  sendEvent,
-  activateObserver,
-  defineProperty,
-  descriptorForProperty,
-  isClassicDecorator,
-  DEBUG_INJECTION_FUNCTIONS,
-  hasUnknownProperty,
-} from '@ember/-internals/metal';
+import { guidFor } from '@ember/-internals/utils/lib/guid';
+import { meta } from '@ember/-internals/meta/lib/meta';
+import type { ComputedProperty } from '@ember/-internals/metal/lib/computed';
+import type { HasUnknownProperty } from '@ember/-internals/metal/lib/property_get';
+import { PROXY_CONTENT, hasUnknownProperty } from '@ember/-internals/metal/lib/property_get';
+import { sendEvent } from '@ember/-internals/metal/lib/events';
+import { activateObserver } from '@ember/-internals/metal/lib/observer';
+import { defineProperty } from '@ember/-internals/metal/lib/properties';
+import { descriptorForProperty, isClassicDecorator } from '@ember/-internals/metal/lib/decorator';
+import { DEBUG_INJECTION_FUNCTIONS } from '@ember/-internals/metal/lib/injected_property';
 import Mixin, { applyMixin } from '@ember/object/mixin';
-import { ActionHandler } from '@ember/-internals/runtime';
+import ActionHandler from '@ember/-internals/runtime/lib/mixins/action_handler';
 import makeArray from '@ember/array/make';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
diff --git a/packages/@ember/object/evented.ts b/packages/@ember/object/evented.ts
index 2134d344206..097d274d4bf 100644
--- a/packages/@ember/object/evented.ts
+++ b/packages/@ember/object/evented.ts
@@ -1,7 +1,12 @@
-import { addListener, removeListener, hasListeners, sendEvent } from '@ember/-internals/metal';
+import {
+  addListener,
+  removeListener,
+  hasListeners,
+  sendEvent,
+} from '@ember/-internals/metal/lib/events';
 import Mixin from '@ember/object/mixin';
 
-export { on } from '@ember/-internals/metal';
+export { on } from '@ember/-internals/metal/lib/events';
 
 /**
 @module @ember/object/evented
diff --git a/packages/@ember/object/events.ts b/packages/@ember/object/events.ts
index 3f4559266fc..66224dac13f 100644
--- a/packages/@ember/object/events.ts
+++ b/packages/@ember/object/events.ts
@@ -1 +1 @@
-export { addListener, removeListener, sendEvent } from '@ember/-internals/metal';
+export { addListener, removeListener, sendEvent } from '@ember/-internals/metal/lib/events';
diff --git a/packages/@ember/object/index.ts b/packages/@ember/object/index.ts
index 58325bcf278..11a3a745e36 100644
--- a/packages/@ember/object/index.ts
+++ b/packages/@ember/object/index.ts
@@ -1,27 +1,19 @@
 import { assert } from '@ember/debug';
-import { ENV } from '@ember/-internals/environment';
-import type { ElementDescriptor, ExtendedMethodDecorator } from '@ember/-internals/metal';
-import {
-  isElementDescriptor,
-  expandProperties,
-  setClassicDecorator,
-} from '@ember/-internals/metal';
-import { getFactoryFor } from '@ember/-internals/container';
-import { setObservers } from '@ember/-internals/utils';
+import { ENV } from '@ember/-internals/environment/lib/env';
+import expandProperties from '@ember/-internals/metal/lib/expand_properties';
+import { getFactoryFor } from '@ember/-internals/container/lib/container';
+import { setObservers } from '@ember/-internals/utils/lib/super';
 import type { AnyFn } from '@ember/-internals/utility-types';
 import CoreObject from '@ember/object/core';
 import Observable from '@ember/object/observable';
 
-export {
-  notifyPropertyChange,
-  defineProperty,
-  get,
-  set,
-  getProperties,
-  setProperties,
-  computed,
-  trySet,
-} from '@ember/-internals/metal';
+export { notifyPropertyChange } from '@ember/-internals/metal/lib/property_events';
+export { defineProperty } from '@ember/-internals/metal/lib/properties';
+export { get } from '@ember/-internals/metal/lib/property_get';
+export { set, trySet } from '@ember/-internals/metal/lib/property_set';
+export { default as getProperties } from '@ember/-internals/metal/lib/get_properties';
+export { default as setProperties } from '@ember/-internals/metal/lib/set_properties';
+export { default as computed } from '@ember/-internals/metal/lib/computed';
 
 /**
 @module @ember/object
@@ -112,120 +104,7 @@ export default EmberObject;
   @return {PropertyDecorator} property decorator instance
 */
 
-const BINDINGS_MAP = new WeakMap();
-
-interface HasProto {
-  constructor: {
-    proto(): void;
-  };
-}
-
-function hasProto(obj: unknown): obj is HasProto {
-  return (
-    obj != null &&
-    (obj as any).constructor !== undefined &&
-    typeof ((obj as any).constructor as any).proto === 'function'
-  );
-}
-
-interface HasActions {
-  actions: Record<string | symbol, unknown>;
-}
-
-function setupAction(
-  target: Partial<HasActions>,
-  key: string | symbol,
-  actionFn: Function
-): TypedPropertyDescriptor<unknown> {
-  if (hasProto(target)) {
-    target.constructor.proto();
-  }
-
-  if (!Object.prototype.hasOwnProperty.call(target, 'actions')) {
-    let parentActions = target.actions;
-    // we need to assign because of the way mixins copy actions down when inheriting
-    target.actions = parentActions ? Object.assign({}, parentActions) : {};
-  }
-
-  assert("[BUG] Somehow the target doesn't have actions!", target.actions != null);
-
-  target.actions[key] = actionFn;
-
-  return {
-    get() {
-      let bindings = BINDINGS_MAP.get(this);
-
-      if (bindings === undefined) {
-        bindings = new Map();
-        BINDINGS_MAP.set(this, bindings);
-      }
-
-      let fn = bindings.get(actionFn);
-
-      if (fn === undefined) {
-        fn = actionFn.bind(this);
-        bindings.set(actionFn, fn);
-      }
-
-      return fn;
-    },
-  };
-}
-
-export function action(
-  target: ElementDescriptor[0],
-  key: ElementDescriptor[1],
-  desc: ElementDescriptor[2]
-): PropertyDescriptor;
-export function action(desc: PropertyDescriptor): ExtendedMethodDecorator;
-export function action(
-  ...args: ElementDescriptor | [PropertyDescriptor]
-): PropertyDescriptor | ExtendedMethodDecorator {
-  let actionFn: object | Function;
-
-  if (!isElementDescriptor(args)) {
-    actionFn = args[0];
-
-    let decorator: ExtendedMethodDecorator = function (
-      target,
-      key,
-      _desc,
-      _meta,
-      isClassicDecorator
-    ) {
-      assert(
-        'The @action decorator may only be passed a method when used in classic classes. You should decorate methods directly in native classes',
-        isClassicDecorator
-      );
-
-      assert(
-        'The action() decorator must be passed a method when used in classic classes',
-        typeof actionFn === 'function'
-      );
-
-      return setupAction(target, key, actionFn);
-    };
-
-    setClassicDecorator(decorator);
-
-    return decorator;
-  }
-
-  let [target, key, desc] = args;
-
-  actionFn = desc?.value;
-
-  assert(
-    'The @action decorator must be applied to methods when used in native classes',
-    typeof actionFn === 'function'
-  );
-
-  // SAFETY: TS types are weird with decorators. This should work.
-  return setupAction(target, key, actionFn);
-}
-
-// SAFETY: TS types are weird with decorators. This should work.
-setClassicDecorator(action as ExtendedMethodDecorator);
+export { action } from './action';
 
 // ..........................................................
 // OBSERVER HELPER
diff --git a/packages/@ember/object/lib/computed/computed_macros.ts b/packages/@ember/object/lib/computed/computed_macros.ts
index 0c71a2967e0..94f9cb769a7 100644
--- a/packages/@ember/object/lib/computed/computed_macros.ts
+++ b/packages/@ember/object/lib/computed/computed_macros.ts
@@ -1,8 +1,13 @@
-import { computed, isElementDescriptor, alias, expandProperties } from '@ember/-internals/metal';
-import { get, set } from '@ember/object';
-import type { DeprecationOptions } from '@ember/debug';
+import computed from '@ember/-internals/metal/lib/computed';
+import { isElementDescriptor } from '@ember/-internals/metal/lib/decorator';
+import alias from '@ember/-internals/metal/lib/alias';
+import expandProperties from '@ember/-internals/metal/lib/expand_properties';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+import type { DeprecationOptions } from '@ember/debug/lib/deprecate';
 import { assert, deprecate } from '@ember/debug';
-import { isEmpty, isNone } from '@ember/utils';
+import isEmpty from '@ember/utils/lib/is_empty';
+import isNone from '@ember/utils/lib/is_none';
 
 /**
 @module @ember/object
diff --git a/packages/@ember/object/lib/computed/reduce_computed_macros.ts b/packages/@ember/object/lib/computed/reduce_computed_macros.ts
index 525c9611746..a08f1953b3d 100644
--- a/packages/@ember/object/lib/computed/reduce_computed_macros.ts
+++ b/packages/@ember/object/lib/computed/reduce_computed_macros.ts
@@ -3,9 +3,11 @@
 */
 import { DEBUG } from '@glimmer/env';
 import { assert } from '@ember/debug';
-import { autoComputed, isElementDescriptor } from '@ember/-internals/metal';
-import { computed, get } from '@ember/object';
-import { compare } from '@ember/utils';
+import { autoComputed } from '@ember/-internals/metal/lib/computed';
+import { isElementDescriptor } from '@ember/-internals/metal/lib/decorator';
+import computed from '@ember/-internals/metal/lib/computed';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import compare from '@ember/utils/lib/compare';
 import EmberArray, { A as emberA, uniqBy as uniqByArray } from '@ember/array';
 import type { NativeArray } from '@ember/array';
 
diff --git a/packages/@ember/object/mixin.ts b/packages/@ember/object/mixin.ts
index 65119179d00..c76b57f7dbe 100644
--- a/packages/@ember/object/mixin.ts
+++ b/packages/@ember/object/mixin.ts
@@ -1,32 +1,32 @@
 /**
 @module @ember/object/mixin
 */
-import { INIT_FACTORY } from '@ember/-internals/container';
-import type { Meta } from '@ember/-internals/meta';
-import { meta as metaFor, peekMeta } from '@ember/-internals/meta';
-import { observerListenerMetaFor, ROOT, wrap } from '@ember/-internals/utils';
+import { INIT_FACTORY } from '@ember/-internals/container/lib/container';
+import type { Meta } from '@ember/-internals/meta/lib/meta';
+import { meta as metaFor, peekMeta } from '@ember/-internals/meta/lib/meta';
+import { observerListenerMetaFor, ROOT, wrap } from '@ember/-internals/utils/lib/super';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
+import type {
+  ComputedDecorator,
+  ComputedPropertyGetter,
+  ComputedPropertyObj,
+  ComputedPropertySetter,
+} from '@ember/-internals/metal/lib/computed';
+import { type ComputedDescriptor, isClassicDecorator } from '@ember/-internals/metal/lib/decorator';
+import { ComputedProperty } from '@ember/-internals/metal/lib/computed';
 import {
-  type ComputedDecorator,
-  type ComputedPropertyGetter,
-  type ComputedPropertyObj,
-  type ComputedPropertySetter,
-  type ComputedDescriptor,
-  isClassicDecorator,
-} from '@ember/-internals/metal';
-import {
-  ComputedProperty,
   descriptorForDecorator,
   makeComputedDecorator,
   nativeDescDecorator,
-  setUnprocessedMixins,
+} from '@ember/-internals/metal/lib/decorator';
+import { setUnprocessedMixins } from '@ember/-internals/metal/lib/namespace_search';
+import {
   addObserver,
   removeObserver,
   revalidateObservers,
-  defineDecorator,
-  defineValue,
-} from '@ember/-internals/metal';
+} from '@ember/-internals/metal/lib/observer';
+import { defineDecorator, defineValue } from '@ember/-internals/metal/lib/properties';
 import { addListener, removeListener } from '@ember/object/events';
 
 const a_concat = Array.prototype.concat;
diff --git a/packages/@ember/object/observable.ts b/packages/@ember/object/observable.ts
index 05ba879bac8..ae4a5aad9d3 100644
--- a/packages/@ember/object/observable.ts
+++ b/packages/@ember/object/observable.ts
@@ -2,19 +2,18 @@
 @module @ember/object/observable
 */
 
-import { peekMeta } from '@ember/-internals/meta';
+import { peekMeta } from '@ember/-internals/meta/lib/meta';
+import { hasListeners } from '@ember/-internals/metal/lib/events';
 import {
-  hasListeners,
   beginPropertyChanges,
   notifyPropertyChange,
   endPropertyChanges,
-  addObserver,
-  removeObserver,
-  get,
-  set,
-  getProperties,
-  setProperties,
-} from '@ember/-internals/metal';
+} from '@ember/-internals/metal/lib/property_events';
+import { addObserver, removeObserver } from '@ember/-internals/metal/lib/observer';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+import getProperties from '@ember/-internals/metal/lib/get_properties';
+import setProperties from '@ember/-internals/metal/lib/set_properties';
 
 import Mixin from '@ember/object/mixin';
 import { assert } from '@ember/debug';
diff --git a/packages/@ember/object/observers.ts b/packages/@ember/object/observers.ts
index 6c2f616cdeb..595cec5fd1a 100644
--- a/packages/@ember/object/observers.ts
+++ b/packages/@ember/object/observers.ts
@@ -1 +1 @@
-export { addObserver, removeObserver } from '@ember/-internals/metal';
+export { addObserver, removeObserver } from '@ember/-internals/metal/lib/observer';
diff --git a/packages/@ember/object/package.json b/packages/@ember/object/package.json
index d6e7c7eaeb4..e0c4ce1ff36 100644
--- a/packages/@ember/object/package.json
+++ b/packages/@ember/object/package.json
@@ -15,7 +15,8 @@
     "./compat": "./compat.ts",
     "./proxy": "./proxy.ts",
     "./promise-proxy-mixin": "./promise-proxy-mixin.ts",
-    "./observers": "./observers.ts"
+    "./observers": "./observers.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
@@ -28,6 +29,7 @@
     "@ember/utils": "workspace:*",
     "@glimmer/destroyable": "workspace:*",
     "@glimmer/env": "workspace:*",
+    "@glimmer/interfaces": "workspace:*",
     "@glimmer/manager": "workspace:*",
     "@glimmer/owner": "workspace:*",
     "@glimmer/util": "workspace:*",
diff --git a/packages/@ember/object/promise-proxy-mixin.ts b/packages/@ember/object/promise-proxy-mixin.ts
index eafe2a9522d..9571771a803 100644
--- a/packages/@ember/object/promise-proxy-mixin.ts
+++ b/packages/@ember/object/promise-proxy-mixin.ts
@@ -1,4 +1,6 @@
-import { get, setProperties, computed } from '@ember/object';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import setProperties from '@ember/-internals/metal/lib/set_properties';
+import computed from '@ember/-internals/metal/lib/computed';
 import Mixin from '@ember/object/mixin';
 import type { AnyFn, MethodNamesOf } from '@ember/-internals/utility-types';
 import type RSVP from 'rsvp';
diff --git a/packages/@ember/object/proxy.ts b/packages/@ember/object/proxy.ts
index 57b162b8924..d561d7777df 100644
--- a/packages/@ember/object/proxy.ts
+++ b/packages/@ember/object/proxy.ts
@@ -3,7 +3,7 @@
 */
 
 import { FrameworkObject } from '@ember/object/-internals';
-import { _ProxyMixin } from '@ember/-internals/runtime';
+import _ProxyMixin from '@ember/-internals/runtime/lib/mixins/-proxy';
 
 /**
   `ObjectProxy` forwards all properties not defined by the proxy itself
diff --git a/packages/@ember/owner/package.json b/packages/@ember/owner/package.json
index 2ee55bd4ae5..84e3795a759 100644
--- a/packages/@ember/owner/package.json
+++ b/packages/@ember/owner/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/reactive/collections.ts b/packages/@ember/reactive/collections.ts
index b4c6eaaff8d..73205476ad2 100644
--- a/packages/@ember/reactive/collections.ts
+++ b/packages/@ember/reactive/collections.ts
@@ -46,7 +46,7 @@
  * @returns {Array} A tracked array that updates reactively
  * @public
  */
-export { trackedArray } from '@glimmer/validator';
+export { trackedArray } from '@glimmer/validator/lib/collections/array';
 
 /**
  * A utility for creating tracked objects, copying the original data so that
@@ -89,7 +89,7 @@ export { trackedArray } from '@glimmer/validator';
  * @returns {Object} A tracked object that updates reactively
  * @public
  */
-export { trackedObject } from '@glimmer/validator';
+export { trackedObject } from '@glimmer/validator/lib/collections/object';
 
 /**
  * A utility for creating tracked sets, copying the original data so that
@@ -133,7 +133,7 @@ export { trackedObject } from '@glimmer/validator';
  * @returns {Set} A tracked Set that updates reactively
  * @public
  */
-export { trackedSet } from '@glimmer/validator';
+export { trackedSet } from '@glimmer/validator/lib/collections/set';
 
 /**
  * A utility for creating tracked weak sets, copying the original data so that
@@ -174,7 +174,7 @@ export { trackedSet } from '@glimmer/validator';
  * @returns {WeakSet} A tracked WeakSet that updates reactively
  * @public
  */
-export { trackedWeakSet } from '@glimmer/validator';
+export { trackedWeakSet } from '@glimmer/validator/lib/collections/weak-set';
 
 /**
  * A utility for creating tracked maps, copying the original data so that
@@ -218,7 +218,7 @@ export { trackedWeakSet } from '@glimmer/validator';
  * @returns {Map} A tracked Map that updates reactively
  * @public
  */
-export { trackedMap } from '@glimmer/validator';
+export { trackedMap } from '@glimmer/validator/lib/collections/map';
 
 /**
  * A utility for creating tracked weak maps, copying the original data so that
@@ -259,4 +259,4 @@ export { trackedMap } from '@glimmer/validator';
  * @returns {WeakMap} A tracked WeakMap that updates reactively
  * @public
  */
-export { trackedWeakMap } from '@glimmer/validator';
+export { trackedWeakMap } from '@glimmer/validator/lib/collections/weak-map';
diff --git a/packages/@ember/reactive/package.json b/packages/@ember/reactive/package.json
index 9ffd74c6289..7a624600d98 100644
--- a/packages/@ember/reactive/package.json
+++ b/packages/@ember/reactive/package.json
@@ -4,9 +4,10 @@
   "type": "module",
   "exports": {
     ".": "./index.ts",
-    "./collections": "./collections.ts"
+    "./collections": "./collections.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
-    "@glimmer/validator": "0.95.0"
+    "@glimmer/validator": "workspace:*"
   }
 }
diff --git a/packages/@ember/renderer/index.ts b/packages/@ember/renderer/index.ts
index 870e0508e02..a8c5366ba5a 100644
--- a/packages/@ember/renderer/index.ts
+++ b/packages/@ember/renderer/index.ts
@@ -61,7 +61,7 @@
   @public
 */
 
-export { renderSettled } from '@ember/-internals/glimmer';
+export { renderSettled } from '@ember/-internals/glimmer/lib/renderer';
 
 /**
  * Render a component into a DOM element.
@@ -79,4 +79,4 @@ export { renderSettled } from '@ember/-internals/glimmer';
  * @param {Object} [options.args] Optionally pass args in to the component. These may be reactive as long as it is an object or object-like
  * @public
  */
-export { renderComponent } from '@ember/-internals/glimmer';
+export { renderComponent } from '@ember/-internals/glimmer/lib/renderer';
diff --git a/packages/@ember/renderer/package.json b/packages/@ember/renderer/package.json
index 16c60a1d471..a4843dd6fae 100644
--- a/packages/@ember/renderer/package.json
+++ b/packages/@ember/renderer/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*"
diff --git a/packages/@ember/routing/index.ts b/packages/@ember/routing/index.ts
index 474d8b90c17..be0dd6e698f 100644
--- a/packages/@ember/routing/index.ts
+++ b/packages/@ember/routing/index.ts
@@ -1 +1 @@
-export { LinkTo } from '@ember/-internals/glimmer';
+export { default as LinkTo } from '@ember/-internals/glimmer/lib/components/link-to';
diff --git a/packages/@ember/routing/lib/controller_for.ts b/packages/@ember/routing/lib/controller_for.ts
index e8e0ddcec5f..1ab76835b69 100644
--- a/packages/@ember/routing/lib/controller_for.ts
+++ b/packages/@ember/routing/lib/controller_for.ts
@@ -1,6 +1,6 @@
-import type { Container } from '@ember/-internals/container';
+import type Container from '@ember/-internals/container/lib/container';
 import type { FactoryClass, InternalFactory } from '@ember/-internals/owner';
-import type { RegisterOptions } from '@ember/owner';
+import type { RegisterOptions } from '@ember/-internals/owner';
 
 /**
   @module @ember/routing
diff --git a/packages/@ember/routing/lib/generate_controller.ts b/packages/@ember/routing/lib/generate_controller.ts
index 59da394330d..13576758301 100644
--- a/packages/@ember/routing/lib/generate_controller.ts
+++ b/packages/@ember/routing/lib/generate_controller.ts
@@ -1,4 +1,4 @@
-import { get } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import type { InternalFactory, default as Owner } from '@ember/-internals/owner';
 import Controller from '@ember/controller';
 import { assert, info } from '@ember/debug';
diff --git a/packages/@ember/routing/lib/utils.ts b/packages/@ember/routing/lib/utils.ts
index 67351d00310..6f01ef3aab2 100644
--- a/packages/@ember/routing/lib/utils.ts
+++ b/packages/@ember/routing/lib/utils.ts
@@ -1,4 +1,4 @@
-import { get } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
 import { getOwner } from '@ember/-internals/owner';
 import type { ControllerQueryParam, ControllerQueryParamType } from '@ember/controller';
 import { assert } from '@ember/debug';
diff --git a/packages/@ember/routing/package.json b/packages/@ember/routing/package.json
index b75af126221..5a956191f63 100644
--- a/packages/@ember/routing/package.json
+++ b/packages/@ember/routing/package.json
@@ -11,7 +11,8 @@
     "./location": "./location.ts",
     "./route": "./route.ts",
     "./-internals": "./-internals.ts",
-    "./router-service": "./router-service.ts"
+    "./router-service": "./router-service.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/routing/route.ts b/packages/@ember/routing/route.ts
index 7b4a8f24eac..ae3b59a1a59 100644
--- a/packages/@ember/routing/route.ts
+++ b/packages/@ember/routing/route.ts
@@ -1,29 +1,33 @@
-import { privatize as P } from '@ember/-internals/container';
-import {
-  addObserver,
-  defineProperty,
-  descriptorForProperty,
-  flushAsyncObservers,
-} from '@ember/-internals/metal';
+import { privatize as P } from '@ember/-internals/container/lib/registry';
+import { addObserver, flushAsyncObservers } from '@ember/-internals/metal/lib/observer';
+import { defineProperty } from '@ember/-internals/metal/lib/properties';
+import { descriptorForProperty } from '@ember/-internals/metal/lib/decorator';
 import type Owner from '@ember/owner';
 import { getOwner } from '@ember/-internals/owner';
 import type { default as BucketCache } from './lib/cache';
-import EmberObject, { computed, get, set, getProperties, setProperties } from '@ember/object';
+import computed from '@ember/-internals/metal/lib/computed';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+import getProperties from '@ember/-internals/metal/lib/get_properties';
+import setProperties from '@ember/-internals/metal/lib/set_properties';
+import EmberObject from '@ember/object';
 import Evented from '@ember/object/evented';
 import { A as emberA } from '@ember/array';
-import { ActionHandler } from '@ember/-internals/runtime';
-import { typeOf } from '@ember/utils';
-import { isProxy, lookupDescriptor } from '@ember/-internals/utils';
+import ActionHandler from '@ember/-internals/runtime/lib/mixins/action_handler';
+import typeOf from '@ember/utils/lib/type-of';
+import { isProxy } from '@ember/-internals/utils/lib/is_proxy';
+import lookupDescriptor from '@ember/-internals/utils/lib/lookup-descriptor';
 import type { AnyFn } from '@ember/-internals/utility-types';
 import Controller from '@ember/controller';
 import type { ControllerQueryParamType } from '@ember/controller';
-import { assert, info, isTesting } from '@ember/debug';
+import { isTesting } from '@ember/debug/lib/testing';
+import { assert, info } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
-import { hasInternalComponentManager } from '@glimmer/manager';
-import type { RenderState } from '@ember/-internals/glimmer';
+import { hasInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+import type { RenderState } from '@ember/-internals/glimmer/lib/utils/outlet';
 import type { TemplateFactory } from '@glimmer/interfaces';
 import type { InternalRouteInfo, Route as IRoute, Transition, TransitionState } from 'router_js';
 import { PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
diff --git a/packages/@ember/routing/router-service.ts b/packages/@ember/routing/router-service.ts
index 936e7539d1c..b703e47abb7 100644
--- a/packages/@ember/routing/router-service.ts
+++ b/packages/@ember/routing/router-service.ts
@@ -6,7 +6,8 @@ import Evented from '@ember/object/evented';
 import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
-import { consumeTag, tagFor } from '@glimmer/validator';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { tagFor } from '@glimmer/validator/lib/meta';
 import type { ModelFor, Transition } from 'router_js';
 import type Route from '@ember/routing/route';
 import EmberRouter from '@ember/routing/router';
diff --git a/packages/@ember/routing/router.ts b/packages/@ember/routing/router.ts
index 114c398476e..7f6d760dd9d 100644
--- a/packages/@ember/routing/router.ts
+++ b/packages/@ember/routing/router.ts
@@ -1,7 +1,14 @@
-import { privatize as P } from '@ember/-internals/container';
-import type { BootEnvironment, OutletState, OutletView } from '@ember/-internals/glimmer';
-import { computed, get, set } from '@ember/object';
-import type { default as Owner, FactoryManager } from '@ember/owner';
+import { privatize as P } from '@ember/-internals/container/lib/registry';
+import type {
+  BootEnvironment,
+  default as OutletView,
+} from '@ember/-internals/glimmer/lib/views/outlet';
+import type { OutletState } from '@ember/-internals/glimmer/lib/utils/outlet';
+import computed from '@ember/-internals/metal/lib/computed';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+import type { FactoryManager } from '@ember/-internals/owner';
+import type Owner from '@ember/owner';
 import { getOwner } from '@ember/owner';
 import { default as BucketCache } from './lib/cache';
 import { default as DSL, type DSLCallback } from './lib/dsl';
@@ -21,7 +28,7 @@ import type {
 import type RouterService from '@ember/routing/router-service';
 import EmberObject from '@ember/object';
 import { A as emberA } from '@ember/array';
-import { typeOf } from '@ember/utils';
+import typeOf from '@ember/utils/lib/type-of';
 import Evented from '@ember/object/evented';
 import { assert, info } from '@ember/debug';
 import { cancel, once, run, scheduleOnce } from '@ember/runloop';
diff --git a/packages/@ember/runloop/index.ts b/packages/@ember/runloop/index.ts
index bac83b17287..0b7fb97aca6 100644
--- a/packages/@ember/runloop/index.ts
+++ b/packages/@ember/runloop/index.ts
@@ -1,9 +1,16 @@
 import { assert } from '@ember/debug';
 import { onErrorTarget } from '@ember/-internals/error-handling';
-import { flushAsyncObservers } from '@ember/-internals/metal';
 import Backburner, { type Timer, type DeferredActionQueues } from 'backburner.js';
 import type { AnyFn } from '@ember/-internals/utility-types';
 
+let asyncObserverFlush: ((schedule: AsyncObserverScheduler) => void) | null = null;
+
+type AsyncObserverScheduler = typeof schedule;
+
+export function registerAsyncObserverFlush(fn: (schedule: AsyncObserverScheduler) => void): void {
+  asyncObserverFlush = fn;
+}
+
 export type { Timer };
 
 // Partial types from https://medium.com/codex/currying-in-typescript-ca5226c85b85
@@ -45,12 +52,16 @@ function onBegin(current: DeferredActionQueues) {
 function onEnd(_current: DeferredActionQueues, next: DeferredActionQueues) {
   currentRunLoop = next;
 
-  flushAsyncObservers(schedule);
+  if (asyncObserverFlush !== null) {
+    asyncObserverFlush(schedule);
+  }
 }
 
 function flush(queueName: string, next: () => void) {
   if (queueName === 'render' || queueName === _rsvpErrorQueue) {
-    flushAsyncObservers(schedule);
+    if (asyncObserverFlush !== null) {
+      asyncObserverFlush(schedule);
+    }
   }
 
   next();
diff --git a/packages/@ember/runloop/package.json b/packages/@ember/runloop/package.json
index ec634d80459..e0b194a2af7 100644
--- a/packages/@ember/runloop/package.json
+++ b/packages/@ember/runloop/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/service/index.ts b/packages/@ember/service/index.ts
index c42f498bb37..85f69d04b12 100644
--- a/packages/@ember/service/index.ts
+++ b/packages/@ember/service/index.ts
@@ -1,7 +1,10 @@
 import { FrameworkObject } from '@ember/object/-internals';
 import { DEPRECATIONS, deprecateUntil } from '@ember/-internals/deprecations';
-import type { DecoratorPropertyDescriptor, ElementDescriptor } from '@ember/-internals/metal';
-import { inject as metalInject } from '@ember/-internals/metal';
+import type {
+  DecoratorPropertyDescriptor,
+  ElementDescriptor,
+} from '@ember/-internals/metal/lib/decorator';
+import metalInject from '@ember/-internals/metal/lib/injected_property';
 
 /**
  @module @ember/service
diff --git a/packages/@ember/service/package.json b/packages/@ember/service/package.json
index d098d020379..4af5a789601 100644
--- a/packages/@ember/service/package.json
+++ b/packages/@ember/service/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/template-compilation/package.json b/packages/@ember/template-compilation/package.json
index 751f7ce4016..9df8e4b158f 100644
--- a/packages/@ember/template-compilation/package.json
+++ b/packages/@ember/template-compilation/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/template-compiler/lib/compile-options.ts b/packages/@ember/template-compiler/lib/compile-options.ts
index 10fb8e0bf1a..9cc0471a381 100644
--- a/packages/@ember/template-compiler/lib/compile-options.ts
+++ b/packages/@ember/template-compiler/lib/compile-options.ts
@@ -1,5 +1,5 @@
 import { array, eq, fn, hash, neq } from '@ember/helper';
-import { on } from '@ember/modifier';
+import { on } from '@ember/modifier/on';
 import { assert } from '@ember/debug';
 import {
   RESOLUTION_MODE_TRANSFORMS,
diff --git a/packages/@ember/template-compiler/lib/dasherize-component-name.ts b/packages/@ember/template-compiler/lib/dasherize-component-name.ts
index 52bdda1329b..27c8d36e3bd 100644
--- a/packages/@ember/template-compiler/lib/dasherize-component-name.ts
+++ b/packages/@ember/template-compiler/lib/dasherize-component-name.ts
@@ -1,4 +1,4 @@
-import { Cache } from '@ember/-internals/utils';
+import Cache from '@ember/-internals/utils/lib/cache';
 
 /*
   This diverges from `Ember.String.dasherize` so that`<XFoo />` can resolve to `x-foo`.
diff --git a/packages/@ember/template-compiler/lib/plugins/assert-against-attrs.ts b/packages/@ember/template-compiler/lib/plugins/assert-against-attrs.ts
index 481e1a6839f..7a6a6091507 100644
--- a/packages/@ember/template-compiler/lib/plugins/assert-against-attrs.ts
+++ b/packages/@ember/template-compiler/lib/plugins/assert-against-attrs.ts
@@ -1,5 +1,6 @@
 import { assert, deprecate } from '@ember/debug';
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import calculateLocationDisplay from '../system/calculate-location-display';
 import type { EmberASTPluginEnvironment } from '../types';
 import { trackLocals } from './utils';
diff --git a/packages/@ember/template-compiler/lib/plugins/assert-against-named-outlets.ts b/packages/@ember/template-compiler/lib/plugins/assert-against-named-outlets.ts
index da7931acfca..ea902e25dc7 100644
--- a/packages/@ember/template-compiler/lib/plugins/assert-against-named-outlets.ts
+++ b/packages/@ember/template-compiler/lib/plugins/assert-against-named-outlets.ts
@@ -1,5 +1,6 @@
 import { assert } from '@ember/debug';
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import calculateLocationDisplay from '../system/calculate-location-display';
 import type { EmberASTPluginEnvironment } from '../types';
 import { trackLocals } from './utils';
diff --git a/packages/@ember/template-compiler/lib/plugins/assert-input-helper-without-block.ts b/packages/@ember/template-compiler/lib/plugins/assert-input-helper-without-block.ts
index 9164bd92286..2f74e9766bc 100644
--- a/packages/@ember/template-compiler/lib/plugins/assert-input-helper-without-block.ts
+++ b/packages/@ember/template-compiler/lib/plugins/assert-input-helper-without-block.ts
@@ -1,5 +1,6 @@
 import { assert } from '@ember/debug';
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import calculateLocationDisplay from '../system/calculate-location-display';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath, trackLocals } from './utils';
diff --git a/packages/@ember/template-compiler/lib/plugins/assert-reserved-named-arguments.ts b/packages/@ember/template-compiler/lib/plugins/assert-reserved-named-arguments.ts
index b769ba64b1b..3d009b60d09 100644
--- a/packages/@ember/template-compiler/lib/plugins/assert-reserved-named-arguments.ts
+++ b/packages/@ember/template-compiler/lib/plugins/assert-reserved-named-arguments.ts
@@ -1,5 +1,6 @@
 import { assert } from '@ember/debug';
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import calculateLocationDisplay from '../system/calculate-location-display';
 import type { EmberASTPluginEnvironment } from '../types';
 
diff --git a/packages/@ember/template-compiler/lib/plugins/auto-import-builtins.ts b/packages/@ember/template-compiler/lib/plugins/auto-import-builtins.ts
index bf3ee5b993d..0ef3f5a6740 100644
--- a/packages/@ember/template-compiler/lib/plugins/auto-import-builtins.ts
+++ b/packages/@ember/template-compiler/lib/plugins/auto-import-builtins.ts
@@ -1,4 +1,5 @@
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath, trackLocals } from './utils';
 
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-action-syntax.ts b/packages/@ember/template-compiler/lib/plugins/transform-action-syntax.ts
index d606378f2ec..6598fa17ffc 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-action-syntax.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-action-syntax.ts
@@ -1,4 +1,5 @@
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import type { Builders, EmberASTPluginEnvironment } from '../types';
 import { isPath, trackLocals } from './utils';
 
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-each-in-into-each.ts b/packages/@ember/template-compiler/lib/plugins/transform-each-in-into-each.ts
index 895721210f2..7660b0cba0d 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-each-in-into-each.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-each-in-into-each.ts
@@ -1,4 +1,5 @@
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath } from './utils';
 
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-each-track-array.ts b/packages/@ember/template-compiler/lib/plugins/transform-each-track-array.ts
index 6465a1c33c8..5e235be19ee 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-each-track-array.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-each-track-array.ts
@@ -1,4 +1,5 @@
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import { assert } from '@ember/debug';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath, trackLocals } from './utils';
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-in-element.ts b/packages/@ember/template-compiler/lib/plugins/transform-in-element.ts
index 2adeb1c12c8..87c739728f5 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-in-element.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-in-element.ts
@@ -1,5 +1,6 @@
 import { assert } from '@ember/debug';
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath } from './utils';
 
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.ts b/packages/@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.ts
index d576592a37c..09aa6f3cd2b 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-quoted-bindings-into-just-bindings.ts
@@ -1,4 +1,5 @@
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 
 export default function transformQuotedBindingsIntoJustBindings(/* env */): ASTPlugin {
   return {
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-resolutions.ts b/packages/@ember/template-compiler/lib/plugins/transform-resolutions.ts
index 311a485d0e0..b8876271d06 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-resolutions.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-resolutions.ts
@@ -1,7 +1,8 @@
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import type { AST, ASTPlugin } from '@glimmer/syntax';
-import { print } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
+import print from '@glimmer/syntax/lib/generation/print';
 import calculateLocationDisplay from '../system/calculate-location-display';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath, isStringLiteral, trackLocals } from './utils';
diff --git a/packages/@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet.ts b/packages/@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet.ts
index 9a9f45b4a47..ac9bf4bd17a 100644
--- a/packages/@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet.ts
+++ b/packages/@ember/template-compiler/lib/plugins/transform-wrap-mount-and-outlet.ts
@@ -1,4 +1,5 @@
-import type { AST, ASTPlugin } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
+import type { ASTPlugin } from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import type { EmberASTPluginEnvironment } from '../types';
 import { isPath, trackLocals } from './utils';
 
diff --git a/packages/@ember/template-compiler/lib/plugins/utils.ts b/packages/@ember/template-compiler/lib/plugins/utils.ts
index 1a36792df41..2ae11def02c 100644
--- a/packages/@ember/template-compiler/lib/plugins/utils.ts
+++ b/packages/@ember/template-compiler/lib/plugins/utils.ts
@@ -1,4 +1,4 @@
-import type { AST } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
 import type { EmberASTPluginEnvironment } from '../types';
 
 export function isPath(node: AST.Node): node is AST.PathExpression {
diff --git a/packages/@ember/template-compiler/lib/system/calculate-location-display.ts b/packages/@ember/template-compiler/lib/system/calculate-location-display.ts
index 70d240cb729..8c247a90abe 100644
--- a/packages/@ember/template-compiler/lib/system/calculate-location-display.ts
+++ b/packages/@ember/template-compiler/lib/system/calculate-location-display.ts
@@ -1,4 +1,4 @@
-import type { AST } from '@glimmer/syntax';
+import type * as AST from '@glimmer/syntax/lib/v1/api';
 
 export default function calculateLocationDisplay(
   moduleName: string | undefined,
diff --git a/packages/@ember/template-compiler/lib/template.ts b/packages/@ember/template-compiler/lib/template.ts
index c0304a8432f..425f00d6a56 100644
--- a/packages/@ember/template-compiler/lib/template.ts
+++ b/packages/@ember/template-compiler/lib/template.ts
@@ -1,8 +1,8 @@
 import templateOnly, { type TemplateOnlyComponent } from '@ember/component/template-only';
-import { precompile as glimmerPrecompile } from '@glimmer/compiler';
+import { precompile as glimmerPrecompile } from '@glimmer/compiler/lib/compiler';
 import type { SerializedTemplateWithLazyBlock } from '@glimmer/interfaces';
-import { setComponentTemplate } from '@glimmer/manager';
-import { templateFactory } from '@glimmer/opcode-compiler';
+import { setComponentTemplate } from '@glimmer/manager/lib/public/template';
+import templateFactory from '@glimmer/opcode-compiler/lib/template';
 import compileOptions, { keywords, RUNTIME_KEYWORDS_NAME } from './compile-options';
 import type { EmberPrecompileOptions } from './types';
 
diff --git a/packages/@ember/template-compiler/lib/types.ts b/packages/@ember/template-compiler/lib/types.ts
index 10309ac8ab9..934c3de87aa 100644
--- a/packages/@ember/template-compiler/lib/types.ts
+++ b/packages/@ember/template-compiler/lib/types.ts
@@ -1,10 +1,10 @@
 import type {
   ASTPluginBuilder,
   ASTPluginEnvironment,
-  builders,
   PrecompileOptions,
   PrecompileOptionsWithLexicalScope,
-} from '@glimmer/syntax';
+} from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
+import type builders from '@glimmer/syntax/lib/v1/public-builders';
 
 export type Builders = typeof builders;
 
diff --git a/packages/@ember/template-compiler/package.json b/packages/@ember/template-compiler/package.json
index 5f4fc58cfd7..026dd334b21 100644
--- a/packages/@ember/template-compiler/package.json
+++ b/packages/@ember/template-compiler/package.json
@@ -6,7 +6,8 @@
     "./runtime": "./runtime.ts",
     "./-internal-primitives": "./-internal-primitives.ts",
     "./-internal-utils": "./-internal-utils.ts",
-    "./types": "./lib/types.ts"
+    "./types": "./lib/types.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
@@ -23,6 +24,6 @@
     "expect-type": "^0.15.0"
   },
   "devDependencies": {
-     "internal-test-helpers": "workspace:*"
+    "internal-test-helpers": "workspace:*"
   }
 }
diff --git a/packages/@ember/template-factory/index.ts b/packages/@ember/template-factory/index.ts
index e05f7f33cf2..db5d30c6353 100644
--- a/packages/@ember/template-factory/index.ts
+++ b/packages/@ember/template-factory/index.ts
@@ -1 +1 @@
-export { templateFactory as createTemplateFactory } from '@glimmer/opcode-compiler';
+export { default as createTemplateFactory } from '@glimmer/opcode-compiler/lib/template';
diff --git a/packages/@ember/template-factory/package.json b/packages/@ember/template-factory/package.json
index ca9eec29dc4..df3d5679182 100644
--- a/packages/@ember/template-factory/package.json
+++ b/packages/@ember/template-factory/package.json
@@ -3,9 +3,10 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
-    "@glimmer/opcode-compiler": "0.94.10"
+    "@glimmer/opcode-compiler": "workspace:*"
   }
 }
diff --git a/packages/@ember/template/index.ts b/packages/@ember/template/index.ts
index a177015c07b..e1095169d01 100644
--- a/packages/@ember/template/index.ts
+++ b/packages/@ember/template/index.ts
@@ -7,4 +7,4 @@ export {
   isHTMLSafe,
   type SafeString,
   type TrustedHTML,
-} from '@ember/-internals/glimmer';
+} from '@ember/-internals/glimmer/lib/utils/string';
diff --git a/packages/@ember/template/package.json b/packages/@ember/template/package.json
index cbd113c51e4..ed5be09c68d 100644
--- a/packages/@ember/template/package.json
+++ b/packages/@ember/template/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/utils/lib/compare.ts b/packages/@ember/utils/lib/compare.ts
index ed070317f29..26dae8d10ea 100644
--- a/packages/@ember/utils/lib/compare.ts
+++ b/packages/@ember/utils/lib/compare.ts
@@ -1,6 +1,6 @@
 import type { TypeName } from './type-of';
 import typeOf from './type-of';
-import { Comparable } from '@ember/-internals/runtime';
+import Comparable from '@ember/-internals/runtime/lib/mixins/comparable';
 import { assert } from '@ember/debug';
 
 const TYPE_ORDER: Record<TypeName, number> = {
diff --git a/packages/@ember/utils/lib/is_empty.ts b/packages/@ember/utils/lib/is_empty.ts
index 9bc46e82c08..bf58995e70b 100644
--- a/packages/@ember/utils/lib/is_empty.ts
+++ b/packages/@ember/utils/lib/is_empty.ts
@@ -1,5 +1,5 @@
-import { get } from '@ember/object';
-import { hasUnknownProperty } from '@ember/-internals/metal';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { hasUnknownProperty } from '@ember/-internals/metal/lib/property_get';
 /**
  @module @ember/utils
 */
diff --git a/packages/@ember/utils/package.json b/packages/@ember/utils/package.json
index 43ffa12c448..a26dab58aae 100644
--- a/packages/@ember/utils/package.json
+++ b/packages/@ember/utils/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@ember/version/package.json b/packages/@ember/version/package.json
index aac5a26488e..f61f55d3498 100644
--- a/packages/@ember/version/package.json
+++ b/packages/@ember/version/package.json
@@ -3,7 +3,8 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
     "@ember/-internals": "workspace:*",
diff --git a/packages/@glimmer/compiler/lib/builder/builder-interface.ts b/packages/@glimmer/compiler/lib/builder/builder-interface.ts
index 46180e61a1b..b6de8b6ed08 100644
--- a/packages/@glimmer/compiler/lib/builder/builder-interface.ts
+++ b/packages/@glimmer/compiler/lib/builder/builder-interface.ts
@@ -1,4 +1,4 @@
-import type { VariableKind } from '@glimmer/constants';
+import type { VariableKind } from '@glimmer/constants/lib/builder-constants';
 import type { Dict, DictValue, Nullable, PresentArray } from '@glimmer/interfaces';
 import {
   APPEND_EXPR_HEAD,
@@ -33,9 +33,11 @@ import {
   MODIFIER_HEAD,
   SPLAT_HEAD,
   THIS_VAR,
-} from '@glimmer/constants';
-import { expect, isPresentArray } from '@glimmer/debug-util';
-import { assertNever, dict } from '@glimmer/util';
+} from '@glimmer/constants/lib/builder-constants';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import { isPresentArray } from '@glimmer/debug-util/lib/present';
+import { dict } from '@glimmer/util/lib/collections';
+import { assertNever } from '@glimmer/util';
 
 export type BuilderParams = BuilderExpression[];
 export type BuilderHash = Nullable<Dict<BuilderExpression>>;
diff --git a/packages/@glimmer/compiler/lib/builder/builder.ts b/packages/@glimmer/compiler/lib/builder/builder.ts
index 2eb32c0cf60..be4db75a3c9 100644
--- a/packages/@glimmer/compiler/lib/builder/builder.ts
+++ b/packages/@glimmer/compiler/lib/builder/builder.ts
@@ -1,4 +1,4 @@
-import type { VariableKind } from '@glimmer/constants';
+import type { VariableKind } from '@glimmer/constants/lib/builder-constants';
 import type {
   AttrNamespace,
   Dict,
@@ -32,15 +32,18 @@ import {
   LITERAL_HEAD,
   LOCAL_VAR,
   MODIFIER_HEAD,
-  NS_XLINK,
-  NS_XML,
-  NS_XMLNS,
   SPLAT_HEAD,
   THIS_VAR,
-} from '@glimmer/constants';
-import { exhausted, expect, isPresentArray, assert } from '@glimmer/debug-util';
-import { assertNever, dict, values } from '@glimmer/util';
-import { SexpOpcodes as Op, VariableResolutionContext } from '@glimmer/wire-format';
+} from '@glimmer/constants/lib/builder-constants';
+import { NS_XLINK, NS_XML, NS_XMLNS } from '@glimmer/constants/lib/dom';
+import { exhausted, expect } from '@glimmer/debug-util/lib/platform-utils';
+import { isPresentArray } from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { dict } from '@glimmer/util/lib/collections';
+import { values } from '@glimmer/util/lib/object-utils';
+import { assertNever } from '@glimmer/util';
+import { opcodes as Op } from '@glimmer/wire-format/lib/opcodes';
+import { resolution as VariableResolutionContext } from '@glimmer/wire-format/lib/resolution';
 
 import type {
   BuilderComment,
diff --git a/packages/@glimmer/compiler/lib/compiler.ts b/packages/@glimmer/compiler/lib/compiler.ts
index 8fbe1f95285..324be429eee 100644
--- a/packages/@glimmer/compiler/lib/compiler.ts
+++ b/packages/@glimmer/compiler/lib/compiler.ts
@@ -8,9 +8,10 @@ import type {
   PrecompileOptions,
   PrecompileOptionsWithLexicalScope,
   TemplateIdFn,
-} from '@glimmer/syntax';
+} from '@glimmer/syntax/lib/parser/tokenizer-event-handlers';
 import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
-import { normalize, src } from '@glimmer/syntax';
+import * as src from '@glimmer/syntax/lib/source/api';
+import { normalize } from '@glimmer/syntax/lib/v2/normalize';
 import { LOCAL_LOGGER } from '@glimmer/util';
 
 import pass0 from './passes/1-normalization/index';
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts
index 8bf73e83944..3cfe0c6ebd5 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/context.ts
@@ -1,4 +1,5 @@
-import type { ASTv2, SymbolTable } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import type { SymbolTable } from '@glimmer/syntax/lib/symbol-table';
 
 import type { OptionalList } from '../../shared/list';
 import type { Result } from '../../shared/result';
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts
index 820942ddced..395bcbe8143 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/index.ts
@@ -1,5 +1,9 @@
-import type { ASTv2, src } from '@glimmer/syntax';
-import { DebugLogger, frag, fragment, valueFragment } from '@glimmer/debug';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import type * as src from '@glimmer/syntax/lib/source/api';
+import * as fragment from '@glimmer/debug/lib/render/combinators';
+import { DebugLogger } from '@glimmer/debug/lib/render/logger';
+import { frag } from '@glimmer/debug/lib/render/fragment';
+import { value as valueFragment } from '@glimmer/debug/lib/render/basic';
 import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { LOCAL_LOGGER } from '@glimmer/util';
 
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 14023c4a624..5c3b33ea21a 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/append.ts
@@ -1,5 +1,7 @@
-import { CURRIED_COMPONENT, CURRIED_HELPER } from '@glimmer/constants';
-import { ASTv2, generateSyntaxError, src } from '@glimmer/syntax';
+import { CURRIED_COMPONENT, CURRIED_HELPER } from '@glimmer/constants/lib/curried';
+import * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import * as src from '@glimmer/syntax/lib/source/api';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { NormalizationState } from '../context';
 
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 fabb323dd70..7f0c1b5c12d 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/block.ts
@@ -1,6 +1,6 @@
-import type { ASTv2 } from '@glimmer/syntax';
-import { CURRIED_COMPONENT } from '@glimmer/constants';
-import { generateSyntaxError } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { CURRIED_COMPONENT } from '@glimmer/constants/lib/curried';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { NormalizationState } from '../context';
 
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/call.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/call.ts
index 9681c5ab292..8202b7d98da 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/call.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/call.ts
@@ -1,4 +1,8 @@
-import { CURRIED_COMPONENT, CURRIED_HELPER, CURRIED_MODIFIER } from '@glimmer/constants';
+import {
+  CURRIED_COMPONENT,
+  CURRIED_HELPER,
+  CURRIED_MODIFIER,
+} from '@glimmer/constants/lib/curried';
 
 import { keywords } from './impl';
 import { curryKeyword } from './utils/curry';
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 327d613aa8c..a469aa034d5 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/keywords/impl.ts
@@ -1,6 +1,8 @@
-import type { ASTv2, KeywordType } from '@glimmer/syntax';
-import { exhausted } from '@glimmer/debug-util';
-import { generateSyntaxError, isKeyword, KEYWORDS_TYPES } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import type { KeywordType } from '@glimmer/syntax/lib/keywords';
+import { exhausted } from '@glimmer/debug-util/lib/platform-utils';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
+import { isKeyword, KEYWORDS_TYPES } from '@glimmer/syntax/lib/keywords';
 
 import type { Result } from '../../../shared/result';
 import type { NormalizationState } from '../context';
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 be04b72cea2..4abd1384d64 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
@@ -1,6 +1,11 @@
 import type { CurriedType } from '@glimmer/interfaces';
-import { CURRIED_COMPONENT, CURRIED_HELPER, CURRIED_MODIFIER } from '@glimmer/constants';
-import { ASTv2, generateSyntaxError } from '@glimmer/syntax';
+import {
+  CURRIED_COMPONENT,
+  CURRIED_HELPER,
+  CURRIED_MODIFIER,
+} from '@glimmer/constants/lib/curried';
+import * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { NormalizationState } from '../../context';
 import type { KeywordDelegate } from '../impl';
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 bcc4ac37871..375e25c4bf3 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,5 +1,5 @@
-import type { ASTv2 } from '@glimmer/syntax';
-import { generateSyntaxError } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { Result } from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
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 1146e10a5a8..6d416daf61e 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,4 +1,6 @@
-import { ASTv2, generateSyntaxError, SourceSlice } from '@glimmer/syntax';
+import * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
+import { SourceSlice } from '@glimmer/syntax/lib/source/slice';
 
 import type { Result } from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
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 756d554cebe..7c4122db97e 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,5 +1,5 @@
-import type { ASTv2 } from '@glimmer/syntax';
-import { generateSyntaxError } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { NormalizationState } from '../../context';
 import type { KeywordDelegate } from '../impl';
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 40b0a480f35..021e5ce01db 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,5 +1,5 @@
-import type { ASTv2 } from '@glimmer/syntax';
-import { generateSyntaxError } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { Result } from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
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 9baa4b9113c..0d9aebab384 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,4 +1,6 @@
-import { ASTv2, maybeLoc, src } from '@glimmer/syntax';
+import * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import * as src from '@glimmer/syntax/lib/source/api';
+import { maybeLoc } from '@glimmer/syntax/lib/source/span-list';
 
 import type { NormalizationState } from '../../context';
 
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 1bfdcdeb934..c774413859c 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,4 +1,4 @@
-import type { ASTv2 } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
 
 import type { Result } from '../../../../shared/result';
 import type { NormalizationState } from '../../context';
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 35d7455d134..0987b12a1d6 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,5 +1,6 @@
-import type { ASTv2, SourceSlice } from '@glimmer/syntax';
-import { generateSyntaxError } from '@glimmer/syntax';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import type { SourceSlice } from '@glimmer/syntax/lib/source/slice';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { Result } from '../../../../shared/result';
 import type { Classified, ClassifiedElement, PreparedArgs } from './classified';
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 3ba59f0d641..665ebd590ca 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/expressions.ts
@@ -1,6 +1,7 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { getLast, isPresentArray } from '@glimmer/debug-util';
-import { ASTv2, KEYWORDS_TYPES } from '@glimmer/syntax';
+import { getLast, isPresentArray } from '@glimmer/debug-util/lib/present';
+import * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import { KEYWORDS_TYPES } from '@glimmer/syntax/lib/keywords';
 
 import type { AnyOptionalList, PresentList } from '../../../shared/list';
 import type { NormalizationState } from '../context';
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 4968eec669b..1660cacf315 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/statements.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/statements.ts
@@ -1,4 +1,4 @@
-import { ASTv2 } from '@glimmer/syntax';
+import * as ASTv2 from '@glimmer/syntax/lib/v2/api';
 
 import type { NormalizationState } from '../context';
 
diff --git a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/strict-mode.ts b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/strict-mode.ts
index 2aa68ff2ded..2d30ed042c6 100644
--- a/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/strict-mode.ts
+++ b/packages/@glimmer/compiler/lib/passes/1-normalization/visitors/strict-mode.ts
@@ -1,6 +1,7 @@
-import type { HasSourceSpan } from '@glimmer/syntax';
-import { CURRIED_COMPONENT, CURRIED_HELPER } from '@glimmer/constants';
-import { generateSyntaxError, loc } from '@glimmer/syntax';
+import type { HasSourceSpan } from '@glimmer/syntax/lib/source/span-list';
+import { CURRIED_COMPONENT, CURRIED_HELPER } from '@glimmer/constants/lib/curried';
+import { generateSyntaxError } from '@glimmer/syntax/lib/syntax-error';
+import { loc } from '@glimmer/syntax/lib/source/span-list';
 
 import type { Result } from '../../../shared/result';
 import type * as mir from '../../2-encoding/mir';
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
index eeb970bcb16..cdd4c6ad0d1 100644
--- a/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
+++ b/packages/@glimmer/compiler/lib/passes/2-encoding/content.ts
@@ -9,10 +9,10 @@ import type {
   WellKnownAttrName,
   WireFormat,
 } from '@glimmer/interfaces';
-import { exhausted } from '@glimmer/debug-util';
+import { exhausted } from '@glimmer/debug-util/lib/platform-utils';
 import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { LOCAL_LOGGER } from '@glimmer/util';
-import { SexpOpcodes } from '@glimmer/wire-format';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 import type { OptionalList } from '../../shared/list';
 import type * as mir from './mir';
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/expressions.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/expressions.ts
index ccd22ff78d8..220ce54d059 100644
--- a/packages/@glimmer/compiler/lib/passes/2-encoding/expressions.ts
+++ b/packages/@glimmer/compiler/lib/passes/2-encoding/expressions.ts
@@ -1,7 +1,12 @@
 import type { PresentArray, WireFormat } from '@glimmer/interfaces';
-import type { ASTv2 } from '@glimmer/syntax';
-import { assertPresentArray, isPresentArray, assert, mapPresentArray } from '@glimmer/debug-util';
-import { SexpOpcodes } from '@glimmer/wire-format';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
+import {
+  assertPresentArray,
+  isPresentArray,
+  mapPresentArray,
+} from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 import type * as mir from './mir';
 
diff --git a/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts b/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts
index cb10e013e8b..d1d9cf69ce7 100644
--- a/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts
+++ b/packages/@glimmer/compiler/lib/passes/2-encoding/mir.ts
@@ -1,12 +1,12 @@
 import type { CurriedType, PresentArray } from '@glimmer/interfaces';
+import type * as ASTv2 from '@glimmer/syntax/lib/v2/api';
 import type {
-  ASTv2,
   BlockSymbolTable,
   ProgramSymbolTable,
-  SourceSlice,
   SymbolTable,
-} from '@glimmer/syntax';
-import { node } from '@glimmer/syntax';
+} from '@glimmer/syntax/lib/symbol-table';
+import type { SourceSlice } from '@glimmer/syntax/lib/source/slice';
+import { node } from '@glimmer/syntax/lib/v2/objects/node';
 
 import type { AnyOptionalList, OptionalList, PresentList } from '../../shared/list';
 
diff --git a/packages/@glimmer/compiler/lib/shared/list.ts b/packages/@glimmer/compiler/lib/shared/list.ts
index 15b48a2aaf0..75e1fe03e60 100644
--- a/packages/@glimmer/compiler/lib/shared/list.ts
+++ b/packages/@glimmer/compiler/lib/shared/list.ts
@@ -1,5 +1,5 @@
 import type { Nullable, PresentArray } from '@glimmer/interfaces';
-import { isPresentArray, mapPresentArray } from '@glimmer/debug-util';
+import { isPresentArray, mapPresentArray } from '@glimmer/debug-util/lib/present';
 
 export interface OptionalList<T> {
   map<U>(callback: (input: T) => U): MapList<T, U, AnyOptionalList<T>>;
diff --git a/packages/@glimmer/compiler/lib/shared/result.ts b/packages/@glimmer/compiler/lib/shared/result.ts
index bd551ae3764..cd4134d80e0 100644
--- a/packages/@glimmer/compiler/lib/shared/result.ts
+++ b/packages/@glimmer/compiler/lib/shared/result.ts
@@ -1,4 +1,4 @@
-import type { GlimmerSyntaxError } from '@glimmer/syntax';
+import type { GlimmerSyntaxError } from '@glimmer/syntax/lib/syntax-error';
 
 import type { AnyOptionalList } from './list';
 
diff --git a/packages/@glimmer/compiler/lib/utils.ts b/packages/@glimmer/compiler/lib/utils.ts
index 425cd0dd548..ff3be5b3b0f 100644
--- a/packages/@glimmer/compiler/lib/utils.ts
+++ b/packages/@glimmer/compiler/lib/utils.ts
@@ -1,5 +1,5 @@
 import type { Dict, WellKnownAttrName, WellKnownTagName } from '@glimmer/interfaces';
-import { WellKnownAttrNames, WellKnownTagNames } from '@glimmer/wire-format';
+import { WellKnownAttrNames, WellKnownTagNames } from '@glimmer/wire-format/lib/well-known';
 
 // There is a small whitelist of namespaced attributes specially
 // enumerated in
diff --git a/packages/@glimmer/compiler/lib/wire-format-debug.ts b/packages/@glimmer/compiler/lib/wire-format-debug.ts
index ddd02880ca7..423570d60f1 100644
--- a/packages/@glimmer/compiler/lib/wire-format-debug.ts
+++ b/packages/@glimmer/compiler/lib/wire-format-debug.ts
@@ -5,10 +5,14 @@ import type {
   SerializedTemplateBlock,
   WireFormat,
 } from '@glimmer/interfaces';
-import { CURRIED_COMPONENT, CURRIED_HELPER, CURRIED_MODIFIER } from '@glimmer/constants';
-import { exhausted } from '@glimmer/debug-util';
-import { dict } from '@glimmer/util';
-import { SexpOpcodes as Op } from '@glimmer/wire-format';
+import {
+  CURRIED_COMPONENT,
+  CURRIED_HELPER,
+  CURRIED_MODIFIER,
+} from '@glimmer/constants/lib/curried';
+import { exhausted } from '@glimmer/debug-util/lib/platform-utils';
+import { dict } from '@glimmer/util/lib/collections';
+import { opcodes as Op } from '@glimmer/wire-format/lib/opcodes';
 
 import { inflateAttrName, inflateTagName } from './utils';
 
diff --git a/packages/@glimmer/compiler/package.json b/packages/@glimmer/compiler/package.json
index a91403128d9..73a5091471b 100644
--- a/packages/@glimmer/compiler/package.json
+++ b/packages/@glimmer/compiler/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/compiler"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "repo-meta": {
     "supportcjs": true
   },
diff --git a/packages/@glimmer/component/package.json b/packages/@glimmer/component/package.json
index 16688584349..24e58c7f907 100644
--- a/packages/@glimmer/component/package.json
+++ b/packages/@glimmer/component/package.json
@@ -3,7 +3,8 @@
   "version": "2.1.1",
   "description": "Glimmer component library",
   "exports": {
-    ".": "./dist/index.js"
+    ".": "./dist/index.js",
+    "./*": "./*.ts"
   },
   "keywords": [
     "ember-addon"
diff --git a/packages/@glimmer/constants/lib/immediate.ts b/packages/@glimmer/constants/lib/immediate.ts
index e45a3e9aae0..1c582973210 100644
--- a/packages/@glimmer/constants/lib/immediate.ts
+++ b/packages/@glimmer/constants/lib/immediate.ts
@@ -1,4 +1,4 @@
-import { assert } from '@glimmer/debug-util';
+import assert from '@glimmer/debug-util/lib/assert';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 
 /*
diff --git a/packages/@glimmer/constants/package.json b/packages/@glimmer/constants/package.json
index 7bad358a898..77632423395 100644
--- a/packages/@glimmer/constants/package.json
+++ b/packages/@glimmer/constants/package.json
@@ -17,5 +17,9 @@
     "eslint": "^9.20.1",
     "publint": "^0.3.2",
     "typescript": "^5.7.3"
+  },
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
   }
 }
diff --git a/packages/@glimmer/debug-util/package.json b/packages/@glimmer/debug-util/package.json
index e6cb231a474..b1787c001d4 100644
--- a/packages/@glimmer/debug-util/package.json
+++ b/packages/@glimmer/debug-util/package.json
@@ -5,7 +5,10 @@
   "license": "MIT",
   "description": "Common utilities used in Glimmer with debug-specific behavior",
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "scripts": {},
   "dependencies": {
     "@glimmer/interfaces": "workspace:*"
diff --git a/packages/@glimmer/debug/lib/debug.ts b/packages/@glimmer/debug/lib/debug.ts
index 2956a721990..b30423f8fc1 100644
--- a/packages/@glimmer/debug/lib/debug.ts
+++ b/packages/@glimmer/debug/lib/debug.ts
@@ -7,9 +7,10 @@ import type {
   Program,
   RuntimeOp,
 } from '@glimmer/interfaces';
-import { exhausted, expect, unreachable } from '@glimmer/debug-util';
+import { exhausted, expect, unreachable } from '@glimmer/debug-util/lib/platform-utils';
 import { LOCAL_DEBUG, LOCAL_SUBTLE_LOGGING, LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
-import { enumerate, LOCAL_LOGGER } from '@glimmer/util';
+import { enumerate } from '@glimmer/util/lib/array-utils';
+import { LOCAL_LOGGER } from '@glimmer/util';
 
 import type { Primitive, RegisterName } from './dism/dism';
 import type { NormalizedOperand, OperandType, ShorthandOperand } from './dism/operand-types';
diff --git a/packages/@glimmer/debug/lib/decoders.ts b/packages/@glimmer/debug/lib/decoders.ts
index 1bbe9d0a9b2..f21e83c24fb 100644
--- a/packages/@glimmer/debug/lib/decoders.ts
+++ b/packages/@glimmer/debug/lib/decoders.ts
@@ -3,10 +3,9 @@ import {
   CURRIED_COMPONENT,
   CURRIED_HELPER,
   CURRIED_MODIFIER,
-  decodeHandle,
-  decodeImmediate,
-} from '@glimmer/constants';
-import { $fp, $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0 } from '@glimmer/vm';
+} from '@glimmer/constants/lib/curried';
+import { decodeHandle, decodeImmediate } from '@glimmer/constants/lib/immediate';
+import { $fp, $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0 } from '@glimmer/vm/lib/registers';
 
 import type { Primitive, RegisterName } from './dism/dism';
 
diff --git a/packages/@glimmer/debug/lib/dism/opcode.ts b/packages/@glimmer/debug/lib/dism/opcode.ts
index bcffde758d0..e102cd960e7 100644
--- a/packages/@glimmer/debug/lib/dism/opcode.ts
+++ b/packages/@glimmer/debug/lib/dism/opcode.ts
@@ -1,4 +1,7 @@
-import type { ClassifiedLocalDebug, ClassifiedLocalDebugFor } from '@glimmer/debug-util';
+import type {
+  ClassifiedLocalDebug,
+  ClassifiedLocalDebugFor,
+} from '@glimmer/debug-util/lib/debug-brand';
 import type {
   AppendingBlock,
   BlockSymbolNames,
@@ -8,8 +11,9 @@ import type {
   PositionalArguments,
   VMArguments,
 } from '@glimmer/interfaces';
-import { dev, exhausted, getLocalDebugType } from '@glimmer/debug-util';
-import { isIndexable } from '@glimmer/util';
+import { dev, exhausted } from '@glimmer/debug-util/lib/platform-utils';
+import { getLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
+import { isIndexable } from '@glimmer/util/lib/collections';
 
 import type { DisassembledOperand } from '../debug';
 import type { ValueRefOptions } from '../render/basic';
diff --git a/packages/@glimmer/debug/lib/dism/operands.ts b/packages/@glimmer/debug/lib/dism/operands.ts
index 1f0a3b651cf..9d7a3c6e4cb 100644
--- a/packages/@glimmer/debug/lib/dism/operands.ts
+++ b/packages/@glimmer/debug/lib/dism/operands.ts
@@ -1,5 +1,5 @@
 import type { BlockMetadata, ProgramConstants, ProgramHeap } from '@glimmer/interfaces';
-import { decodeHandle } from '@glimmer/constants';
+import { decodeHandle } from '@glimmer/constants/lib/immediate';
 
 import type { RawDisassembledOperand } from '../debug';
 import type {
diff --git a/packages/@glimmer/debug/lib/opcode-metadata.ts b/packages/@glimmer/debug/lib/opcode-metadata.ts
index deeb0ff6bee..b710b81ce6e 100644
--- a/packages/@glimmer/debug/lib/opcode-metadata.ts
+++ b/packages/@glimmer/debug/lib/opcode-metadata.ts
@@ -3,6 +3,16 @@
 import type { Nullable, VmMachineOp, VmOp } from '@glimmer/interfaces';
 import {
   isMachineOp,
+  VM_INVOKE_STATIC_OP,
+  VM_INVOKE_VIRTUAL_OP,
+  VM_JUMP_OP,
+  VM_MACHINE_SIZE,
+  VM_POP_FRAME_OP,
+  VM_PUSH_FRAME_OP,
+  VM_RETURN_OP,
+  VM_RETURN_TO_OP,
+} from '@glimmer/constants/lib/vm-ops';
+import {
   VM_APPEND_DOCUMENT_FRAGMENT_OP,
   VM_APPEND_HTML_OP,
   VM_APPEND_NODE_OP,
@@ -48,16 +58,12 @@ import {
   VM_HELPER_OP,
   VM_IF_INLINE_OP,
   VM_INVOKE_COMPONENT_LAYOUT_OP,
-  VM_INVOKE_STATIC_OP,
-  VM_INVOKE_VIRTUAL_OP,
   VM_INVOKE_YIELD_OP,
   VM_ITERATE_OP,
   VM_JUMP_EQ_OP,
   VM_JUMP_IF_OP,
-  VM_JUMP_OP,
   VM_JUMP_UNLESS_OP,
   VM_LOAD_OP,
-  VM_MACHINE_SIZE,
   VM_MAIN_OP,
   VM_MODIFIER_OP,
   VM_NOT_OP,
@@ -65,7 +71,6 @@ import {
   VM_OPEN_ELEMENT_OP,
   VM_POP_ARGS_OP,
   VM_POP_DYNAMIC_SCOPE_OP,
-  VM_POP_FRAME_OP,
   VM_POP_OP,
   VM_POP_REMOTE_ELEMENT_OP,
   VM_POP_SCOPE_OP,
@@ -79,15 +84,12 @@ import {
   VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP,
   VM_PUSH_DYNAMIC_SCOPE_OP,
   VM_PUSH_EMPTY_ARGS_OP,
-  VM_PUSH_FRAME_OP,
   VM_PUSH_REMOTE_ELEMENT_OP,
   VM_PUSH_SYMBOL_TABLE_OP,
   VM_PUT_COMPONENT_OPERATIONS_OP,
   VM_REGISTER_COMPONENT_DESTRUCTOR_OP,
   VM_REIFY_U32_OP,
   VM_RESOLVE_DYNAMIC_COMPONENT_OP,
-  VM_RETURN_OP,
-  VM_RETURN_TO_OP,
   VM_ROOT_SCOPE_OP,
   VM_SET_BLOCK_OP,
   VM_SET_BLOCKS_OP,
@@ -99,7 +101,7 @@ import {
   VM_TEXT_OP,
   VM_TO_BOOLEAN_OP,
   VM_VIRTUAL_ROOT_SCOPE_OP,
-} from '@glimmer/constants';
+} from '@glimmer/constants/lib/syscall-ops';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 
 import type { NormalizedMetadata } from './metadata';
diff --git a/packages/@glimmer/debug/lib/render/basic.ts b/packages/@glimmer/debug/lib/render/basic.ts
index 68d75020c44..6731d86a0b7 100644
--- a/packages/@glimmer/debug/lib/render/basic.ts
+++ b/packages/@glimmer/debug/lib/render/basic.ts
@@ -1,7 +1,7 @@
 import type { CompilableTemplate, Optional, Reference, SimpleNode } from '@glimmer/interfaces';
-import { IS_COMPILABLE_TEMPLATE } from '@glimmer/constants';
-import { REFERENCE } from '@glimmer/reference';
-import { isIndexable } from '@glimmer/util';
+import { IS_COMPILABLE_TEMPLATE } from '@glimmer/constants/lib/brand';
+import { REFERENCE } from '@glimmer/reference/lib/reference';
+import { isIndexable } from '@glimmer/util/lib/collections';
 
 import type { IntoFragment } from './fragment';
 import type { LeafFragment, ValueFragment } from './fragment-type';
diff --git a/packages/@glimmer/debug/lib/render/fragment.ts b/packages/@glimmer/debug/lib/render/fragment.ts
index b7f3271b5b4..48428455241 100644
--- a/packages/@glimmer/debug/lib/render/fragment.ts
+++ b/packages/@glimmer/debug/lib/render/fragment.ts
@@ -1,5 +1,5 @@
 import type { AnyFn, SimpleNode } from '@glimmer/interfaces';
-import { assertNever } from '@glimmer/debug-util';
+import { assertNever } from '@glimmer/debug-util/lib/assert';
 
 import type { Loggable } from './entry';
 import type { IntoFormat } from './format';
diff --git a/packages/@glimmer/debug/lib/render/ref.ts b/packages/@glimmer/debug/lib/render/ref.ts
index 54dec98ca69..d70ec922f0a 100644
--- a/packages/@glimmer/debug/lib/render/ref.ts
+++ b/packages/@glimmer/debug/lib/render/ref.ts
@@ -1,5 +1,5 @@
 import type { Reference } from '@glimmer/interfaces';
-import { valueForRef } from '@glimmer/reference';
+import { valueForRef } from '@glimmer/reference/lib/reference';
 
 import type { Fragment } from './fragment';
 
diff --git a/packages/@glimmer/debug/lib/stack-check.ts b/packages/@glimmer/debug/lib/stack-check.ts
index 7c51343907b..8889b951c66 100644
--- a/packages/@glimmer/debug/lib/stack-check.ts
+++ b/packages/@glimmer/debug/lib/stack-check.ts
@@ -9,9 +9,9 @@ import type {
   SimpleElement,
   SimpleNode,
 } from '@glimmer/interfaces';
-import type { MachineRegister, Register, SyscallRegister } from '@glimmer/vm';
+import type { MachineRegister, Register, SyscallRegister } from '@glimmer/vm/lib/registers';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { $fp, $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0 } from '@glimmer/vm';
+import { $fp, $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0 } from '@glimmer/vm/lib/registers';
 
 import type { Primitive } from './dism/dism';
 
diff --git a/packages/@glimmer/debug/lib/vm/snapshot.ts b/packages/@glimmer/debug/lib/vm/snapshot.ts
index 0f446709066..715ed5ad42c 100644
--- a/packages/@glimmer/debug/lib/vm/snapshot.ts
+++ b/packages/@glimmer/debug/lib/vm/snapshot.ts
@@ -8,10 +8,10 @@ import type {
   VmMachineOp,
   VmOp,
 } from '@glimmer/interfaces';
-import { exhausted } from '@glimmer/debug-util';
+import { exhausted } from '@glimmer/debug-util/lib/platform-utils';
 import { LOCAL_SUBTLE_LOGGING } from '@glimmer/local-debug-flags';
-import { zipArrays, zipTuples } from '@glimmer/util';
-import { $fp, $pc } from '@glimmer/vm';
+import { zipArrays, zipTuples } from '@glimmer/util/lib/array-utils';
+import { $fp, $pc } from '@glimmer/vm/lib/registers';
 
 import type { Fragment } from '../render/fragment';
 
diff --git a/packages/@glimmer/debug/package.json b/packages/@glimmer/debug/package.json
index ae9a349a3f1..ecc5e82d84d 100644
--- a/packages/@glimmer/debug/package.json
+++ b/packages/@glimmer/debug/package.json
@@ -6,7 +6,10 @@
   "description": "Utilities for helping make working in the vm easier. these should be inlined and stripped for ember usage.",
   "sideEffects": false,
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "scripts": {},
   "dependencies": {
     "@glimmer/interfaces": "workspace:*",
diff --git a/packages/@glimmer/destroyable/index.ts b/packages/@glimmer/destroyable/index.ts
index 5f9c6293614..53f8493c016 100644
--- a/packages/@glimmer/destroyable/index.ts
+++ b/packages/@glimmer/destroyable/index.ts
@@ -1,6 +1,6 @@
 import { DEBUG } from '@glimmer/env';
 import type { Destroyable, Destructor } from '@glimmer/interfaces';
-import { debugToString } from '@glimmer/debug-util';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
 import { scheduleDestroy, scheduleDestroyed } from '@glimmer/global-context';
 
 const LIVE_STATE = 0;
diff --git a/packages/@glimmer/destroyable/package.json b/packages/@glimmer/destroyable/package.json
index a0e9a057caf..da4531ef29d 100644
--- a/packages/@glimmer/destroyable/package.json
+++ b/packages/@glimmer/destroyable/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/destroyable"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/encoder/lib/encoder.ts b/packages/@glimmer/encoder/lib/encoder.ts
index ce9d19be6eb..6f0d948f959 100644
--- a/packages/@glimmer/encoder/lib/encoder.ts
+++ b/packages/@glimmer/encoder/lib/encoder.ts
@@ -8,7 +8,7 @@ import type {
   VmMachineOp,
   VmOp,
 } from '@glimmer/interfaces';
-import { ARG_SHIFT, MAX_SIZE, TYPE_SIZE } from '@glimmer/vm';
+import { ARG_SHIFT, MAX_SIZE, TYPE_SIZE } from '@glimmer/vm/lib/flags';
 
 export class InstructionEncoderImpl implements InstructionEncoder {
   constructor(readonly buffer: CompilerBuffer) {}
diff --git a/packages/@glimmer/encoder/package.json b/packages/@glimmer/encoder/package.json
index 156378b26a4..a72cd33af6a 100644
--- a/packages/@glimmer/encoder/package.json
+++ b/packages/@glimmer/encoder/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/encoder"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/env/package.json b/packages/@glimmer/env/package.json
index e652a975727..f94e3f88fb4 100644
--- a/packages/@glimmer/env/package.json
+++ b/packages/@glimmer/env/package.json
@@ -7,6 +7,7 @@
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./*": "./*.ts"
   }
 }
diff --git a/packages/@glimmer/global-context/package.json b/packages/@glimmer/global-context/package.json
index 22675197f0c..7b7b81d8d68 100644
--- a/packages/@glimmer/global-context/package.json
+++ b/packages/@glimmer/global-context/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/global-context"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/local-debug-flags/package.json b/packages/@glimmer/local-debug-flags/package.json
index 2ab25e74b16..e94433fc968 100644
--- a/packages/@glimmer/local-debug-flags/package.json
+++ b/packages/@glimmer/local-debug-flags/package.json
@@ -5,7 +5,10 @@
   "description": "Helpers for debugging during local development. These get stripped from published builds. This package should not be published.",
   "type": "module",
   "private": true,
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "scripts": {},
   "devDependencies": {
     "eslint": "^9.20.1"
diff --git a/packages/@glimmer/manager/lib/internal/api.ts b/packages/@glimmer/manager/lib/internal/api.ts
index 96a1daa7703..c5b5135e1ae 100644
--- a/packages/@glimmer/manager/lib/internal/api.ts
+++ b/packages/@glimmer/manager/lib/internal/api.ts
@@ -5,7 +5,7 @@ import type {
   InternalModifierManager,
   Owner,
 } from '@glimmer/interfaces';
-import { debugToString } from '@glimmer/debug-util';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
 import { debugAssert } from '@glimmer/global-context';
 
 import { CustomHelperManager } from '../public/helper';
diff --git a/packages/@glimmer/manager/lib/public/component.ts b/packages/@glimmer/manager/lib/public/component.ts
index f8f9be9b7a7..9ab0635c3dc 100644
--- a/packages/@glimmer/manager/lib/public/component.ts
+++ b/packages/@glimmer/manager/lib/public/component.ts
@@ -16,9 +16,9 @@ import type {
   Owner,
   VMArguments,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
 import { registerDestructor } from '@glimmer/destroyable';
-import { createConstRef } from '@glimmer/reference';
+import { createConstRef } from '@glimmer/reference/lib/reference';
 
 import type { ManagerFactory } from './api';
 
diff --git a/packages/@glimmer/manager/lib/public/helper.ts b/packages/@glimmer/manager/lib/public/helper.ts
index 5413ce473bc..85fc1f68065 100644
--- a/packages/@glimmer/manager/lib/public/helper.ts
+++ b/packages/@glimmer/manager/lib/public/helper.ts
@@ -12,7 +12,11 @@ import type {
 } from '@glimmer/interfaces';
 import { associateDestroyableChild } from '@glimmer/destroyable';
 import { debugAssert } from '@glimmer/global-context';
-import { createComputeRef, createConstRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
+import {
+  createComputeRef,
+  createConstRef,
+  UNDEFINED_REFERENCE,
+} from '@glimmer/reference/lib/reference';
 
 import type { ManagerFactory } from './index';
 
diff --git a/packages/@glimmer/manager/lib/public/modifier.ts b/packages/@glimmer/manager/lib/public/modifier.ts
index ef5b74b5b08..84af7f9ee32 100644
--- a/packages/@glimmer/manager/lib/public/modifier.ts
+++ b/packages/@glimmer/manager/lib/public/modifier.ts
@@ -10,12 +10,13 @@ import type {
   SimpleElement,
   UpdatableTag,
 } from '@glimmer/interfaces';
-import { castToBrowser } from '@glimmer/debug-util';
+import { castToBrowser } from '@glimmer/debug-util/lib/simple-cast';
 import { registerDestructor } from '@glimmer/destroyable';
 import { debugAssert } from '@glimmer/global-context';
-import { valueForRef } from '@glimmer/reference';
-import { dict } from '@glimmer/util';
-import { createUpdatableTag, untrack } from '@glimmer/validator';
+import { valueForRef } from '@glimmer/reference/lib/reference';
+import { dict } from '@glimmer/util/lib/collections';
+import { createUpdatableTag } from '@glimmer/validator/lib/validators';
+import { untrack } from '@glimmer/validator/lib/tracking';
 
 import type { ManagerFactory } from '.';
 
diff --git a/packages/@glimmer/manager/lib/public/template.ts b/packages/@glimmer/manager/lib/public/template.ts
index 883a0f99b28..6b587264435 100644
--- a/packages/@glimmer/manager/lib/public/template.ts
+++ b/packages/@glimmer/manager/lib/public/template.ts
@@ -1,6 +1,6 @@
 import { DEBUG } from '@glimmer/env';
 import type { TemplateFactory } from '@glimmer/interfaces';
-import { debugToString } from '@glimmer/debug-util';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
 
 const TEMPLATES: WeakMap<object, TemplateFactory> = new WeakMap();
 
diff --git a/packages/@glimmer/manager/lib/util/args-proxy.ts b/packages/@glimmer/manager/lib/util/args-proxy.ts
index 06c600d1707..88ec478855c 100644
--- a/packages/@glimmer/manager/lib/util/args-proxy.ts
+++ b/packages/@glimmer/manager/lib/util/args-proxy.ts
@@ -5,9 +5,9 @@ import type {
   CapturedNamedArguments,
   CapturedPositionalArguments,
 } from '@glimmer/interfaces';
-import type { Tag } from '@glimmer/validator';
-import { valueForRef } from '@glimmer/reference';
-import { track } from '@glimmer/validator';
+import type { Tag } from '@glimmer/interfaces';
+import { valueForRef } from '@glimmer/reference/lib/reference';
+import { track } from '@glimmer/validator/lib/tracking';
 
 const CUSTOM_TAG_FOR = new WeakMap<object, (obj: object, key: string) => Tag>();
 
diff --git a/packages/@glimmer/manager/lib/util/capabilities.ts b/packages/@glimmer/manager/lib/util/capabilities.ts
index 7254e129804..9ec370a32df 100644
--- a/packages/@glimmer/manager/lib/util/capabilities.ts
+++ b/packages/@glimmer/manager/lib/util/capabilities.ts
@@ -24,8 +24,8 @@ import type {
   WithUpdateHook,
   WrappedCapability,
 } from '@glimmer/interfaces';
-import { check, CheckNumber } from '@glimmer/debug';
-import { InternalComponentCapabilities } from '@glimmer/vm';
+import { check, CheckNumber } from '@glimmer/debug/lib/stack-check';
+import { InternalComponentCapabilities } from '@glimmer/vm/lib/flags';
 
 export const FROM_CAPABILITIES = DEBUG ? new WeakSet() : undefined;
 
diff --git a/packages/@glimmer/manager/package.json b/packages/@glimmer/manager/package.json
index 8f9e7f69272..3500b17a72e 100644
--- a/packages/@glimmer/manager/package.json
+++ b/packages/@glimmer/manager/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/manager"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/node/lib/node-dom-helper.ts b/packages/@glimmer/node/lib/node-dom-helper.ts
index 6b65e00a664..611026dce41 100644
--- a/packages/@glimmer/node/lib/node-dom-helper.ts
+++ b/packages/@glimmer/node/lib/node-dom-helper.ts
@@ -5,7 +5,8 @@ import type {
   SimpleElement,
   SimpleNode,
 } from '@glimmer/interfaces';
-import { ConcreteBounds, DOMTreeConstruction } from '@glimmer/runtime';
+import { ConcreteBounds } from '@glimmer/runtime/lib/bounds';
+import { DOMTreeConstruction } from '@glimmer/runtime/lib/dom/api';
 import createHTMLDocument from '@simple-dom/document';
 
 export default class NodeDOMTreeConstruction extends DOMTreeConstruction {
diff --git a/packages/@glimmer/node/lib/serialize-builder.ts b/packages/@glimmer/node/lib/serialize-builder.ts
index 43a68363b75..b75499cb299 100644
--- a/packages/@glimmer/node/lib/serialize-builder.ts
+++ b/packages/@glimmer/node/lib/serialize-builder.ts
@@ -10,8 +10,9 @@ import type {
   SimpleText,
   TreeBuilder,
 } from '@glimmer/interfaces';
-import type { RemoteBlock } from '@glimmer/runtime';
-import { ConcreteBounds, NewTreeBuilder } from '@glimmer/runtime';
+import type { RemoteBlock } from '@glimmer/runtime/lib/vm/element-builder';
+import { ConcreteBounds } from '@glimmer/runtime/lib/bounds';
+import { NewTreeBuilder } from '@glimmer/runtime/lib/vm/element-builder';
 
 const TEXT_NODE = 3;
 
diff --git a/packages/@glimmer/node/package.json b/packages/@glimmer/node/package.json
index d1ebabd439a..45221506e43 100644
--- a/packages/@glimmer/node/package.json
+++ b/packages/@glimmer/node/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/node"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/opcode-compiler/lib/compilable-template.ts b/packages/@glimmer/opcode-compiler/lib/compilable-template.ts
index 42cdc89737f..46d3ef49e85 100644
--- a/packages/@glimmer/opcode-compiler/lib/compilable-template.ts
+++ b/packages/@glimmer/opcode-compiler/lib/compilable-template.ts
@@ -15,9 +15,9 @@ import type {
   SymbolTable,
   WireFormat,
 } from '@glimmer/interfaces';
-import { IS_COMPILABLE_TEMPLATE } from '@glimmer/constants';
+import { IS_COMPILABLE_TEMPLATE } from '@glimmer/constants/lib/brand';
 import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
-import { EMPTY_ARRAY } from '@glimmer/util';
+import { EMPTY_ARRAY } from '@glimmer/util/lib/array-utils';
 
 import type { HighLevelStatementOp } from './syntax/compilers';
 
diff --git a/packages/@glimmer/opcode-compiler/lib/compiler.ts b/packages/@glimmer/opcode-compiler/lib/compiler.ts
index cb799e6d5f0..4114d0e23bd 100644
--- a/packages/@glimmer/opcode-compiler/lib/compiler.ts
+++ b/packages/@glimmer/opcode-compiler/lib/compiler.ts
@@ -1,6 +1,6 @@
 import type { CompilationContext, HandleResult } from '@glimmer/interfaces';
-import { logOpcodeSlice } from '@glimmer/debug';
-import { extractHandle } from '@glimmer/debug-util';
+import { logOpcodeSlice } from '@glimmer/debug/lib/debug';
+import { extractHandle } from '@glimmer/debug-util/lib/template';
 import { LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 
 export let debugCompiler: (context: CompilationContext, handle: HandleResult) => void;
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts
index 48140a01d46..7a10b4afb88 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/encoder.ts
@@ -16,11 +16,15 @@ import type {
   SingleBuilderOperand,
   STDLib,
 } from '@glimmer/interfaces';
-import { encodeHandle, isMachineOp, VM_PRIMITIVE_OP, VM_RETURN_OP } from '@glimmer/constants';
-import { expect, isPresentArray, assert } from '@glimmer/debug-util';
-import { InstructionEncoderImpl } from '@glimmer/encoder';
-import { dict, Stack } from '@glimmer/util';
-import { ARG_SHIFT, MACHINE_MASK, TYPE_SIZE } from '@glimmer/vm';
+import { encodeHandle } from '@glimmer/constants/lib/immediate';
+import { isMachineOp, VM_RETURN_OP } from '@glimmer/constants/lib/vm-ops';
+import { VM_PRIMITIVE_OP } from '@glimmer/constants/lib/syscall-ops';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import { isPresentArray } from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { InstructionEncoderImpl } from '@glimmer/encoder/lib/encoder';
+import { dict, StackImpl as Stack } from '@glimmer/util/lib/collections';
+import { ARG_SHIFT, MACHINE_MASK, TYPE_SIZE } from '@glimmer/vm/lib/flags';
 
 import { compilableBlock } from '../compilable-template';
 import {
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 95c2d5d96eb..b2862d83504 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/blocks.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/blocks.ts
@@ -5,17 +5,19 @@ import {
   VM_CONSTANT_OP,
   VM_DUP_OP,
   VM_GET_BLOCK_OP,
-  VM_INVOKE_VIRTUAL_OP,
   VM_INVOKE_YIELD_OP,
-  VM_POP_FRAME_OP,
   VM_POP_SCOPE_OP,
   VM_PUSH_BLOCK_SCOPE_OP,
-  VM_PUSH_FRAME_OP,
   VM_PUSH_SYMBOL_TABLE_OP,
   VM_SET_VARIABLE_OP,
   VM_SPREAD_BLOCK_OP,
-} from '@glimmer/constants';
-import { $fp } from '@glimmer/vm';
+} from '@glimmer/constants/lib/syscall-ops';
+import {
+  VM_INVOKE_VIRTUAL_OP,
+  VM_POP_FRAME_OP,
+  VM_PUSH_FRAME_OP,
+} from '@glimmer/constants/lib/vm-ops';
+import { $fp } from '@glimmer/vm/lib/registers';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
 
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 3339e3540ff..4bbfe09b09d 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/components.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/components.ts
@@ -7,7 +7,7 @@ import type {
   Nullable,
   WireFormat,
 } from '@glimmer/interfaces';
-import type { SavedRegister } from '@glimmer/vm';
+import type { SavedRegister } from '@glimmer/vm/lib/registers';
 import {
   VM_BEGIN_COMPONENT_TRANSACTION_OP,
   VM_CLOSE_ELEMENT_OP,
@@ -24,12 +24,10 @@ import {
   VM_GET_COMPONENT_SELF_OP,
   VM_GET_COMPONENT_TAG_NAME_OP,
   VM_INVOKE_COMPONENT_LAYOUT_OP,
-  VM_INVOKE_VIRTUAL_OP,
   VM_JUMP_UNLESS_OP,
   VM_LOAD_OP,
   VM_OPEN_DYNAMIC_ELEMENT_OP,
   VM_POP_DYNAMIC_SCOPE_OP,
-  VM_POP_FRAME_OP,
   VM_POP_OP,
   VM_POP_SCOPE_OP,
   VM_POPULATE_LAYOUT_OP,
@@ -40,7 +38,6 @@ import {
   VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP,
   VM_PUSH_DYNAMIC_SCOPE_OP,
   VM_PUSH_EMPTY_ARGS_OP,
-  VM_PUSH_FRAME_OP,
   VM_PUSH_SYMBOL_TABLE_OP,
   VM_PUT_COMPONENT_OPERATIONS_OP,
   VM_REGISTER_COMPONENT_DESTRUCTOR_OP,
@@ -52,11 +49,17 @@ import {
   VM_SET_NAMED_VARIABLES_OP,
   VM_SET_VARIABLE_OP,
   VM_VIRTUAL_ROOT_SCOPE_OP,
-} from '@glimmer/constants';
-import { unwrap } from '@glimmer/debug-util';
-import { hasCapability } from '@glimmer/manager';
-import { EMPTY_STRING_ARRAY, reverse } from '@glimmer/util';
-import { $s0, $s1, $sp, InternalComponentCapabilities } from '@glimmer/vm';
+} from '@glimmer/constants/lib/syscall-ops';
+import {
+  VM_INVOKE_VIRTUAL_OP,
+  VM_POP_FRAME_OP,
+  VM_PUSH_FRAME_OP,
+} from '@glimmer/constants/lib/vm-ops';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import { hasCapability } from '@glimmer/manager/lib/util/capabilities';
+import { EMPTY_STRING_ARRAY, reverse } from '@glimmer/util/lib/array-utils';
+import { $s0, $s1, $sp } from '@glimmer/vm/lib/registers';
+import { InternalComponentCapabilities } from '@glimmer/vm/lib/flags';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
 
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 72c4cefcdf3..f609cef37d0 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/conditional.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/conditional.ts
@@ -2,15 +2,17 @@ import {
   VM_ENTER_OP,
   VM_EXIT_OP,
   VM_JUMP_EQ_OP,
-  VM_JUMP_OP,
   VM_JUMP_UNLESS_OP,
-  VM_POP_FRAME_OP,
   VM_POP_OP,
+} from '@glimmer/constants/lib/syscall-ops';
+import {
+  VM_JUMP_OP,
+  VM_POP_FRAME_OP,
   VM_PUSH_FRAME_OP,
   VM_RETURN_OP,
   VM_RETURN_TO_OP,
-} from '@glimmer/constants';
-import { unwrap } from '@glimmer/debug-util';
+} from '@glimmer/constants/lib/vm-ops';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
 
 import type { PushStatementOp } from '../../syntax/compilers';
 
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 53a689ebb97..2ebad5b30a1 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/expr.ts
@@ -1,5 +1,5 @@
 import type { WireFormat } from '@glimmer/interfaces';
-import { VM_PRIMITIVE_REFERENCE_OP } from '@glimmer/constants';
+import { VM_PRIMITIVE_REFERENCE_OP } from '@glimmer/constants/lib/syscall-ops';
 
 import type { PushExpressionOp } from '../../syntax/compilers';
 
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 e9aadb6898a..cf85463b62f 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/resolution.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/resolution.ts
@@ -15,8 +15,10 @@ import type {
   ResolveOptionalComponentOrHelperOp,
   SexpOpcode,
 } from '@glimmer/interfaces';
-import { debugToString, expect, assert, unwrap } from '@glimmer/debug-util';
-import { SexpOpcodes } from '@glimmer/wire-format';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
+import { expect, unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 function isGetLikeTuple(opcode: Expressions.Expression): opcode is Expressions.TupleExpression {
   return Array.isArray(opcode) && opcode.length === 2;
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 8dfd69af7bd..838bdc8440a 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/shared.ts
@@ -5,8 +5,8 @@ import type {
   Nullable,
   WireFormat,
 } from '@glimmer/interfaces';
-import { VM_PUSH_ARGS_OP, VM_PUSH_EMPTY_ARGS_OP } from '@glimmer/constants';
-import { EMPTY_ARRAY, EMPTY_STRING_ARRAY } from '@glimmer/util';
+import { VM_PUSH_ARGS_OP, VM_PUSH_EMPTY_ARGS_OP } from '@glimmer/constants/lib/syscall-ops';
+import { EMPTY_ARRAY, EMPTY_STRING_ARRAY } from '@glimmer/util/lib/array-utils';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
 
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 1f9ee02ecc1..466add49cc9 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/stdlib.ts
@@ -7,12 +7,13 @@ import {
   VM_APPEND_TEXT_OP,
   VM_ASSERT_SAME_OP,
   VM_CONTENT_TYPE_OP,
-  VM_INVOKE_STATIC_OP,
   VM_MAIN_OP,
   VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP,
   VM_RESOLVE_CURRIED_COMPONENT_OP,
-} from '@glimmer/constants';
-import { $s0, ContentType } from '@glimmer/vm';
+} from '@glimmer/constants/lib/syscall-ops';
+import { VM_INVOKE_STATIC_OP } from '@glimmer/constants/lib/vm-ops';
+import { $s0 } from '@glimmer/vm/lib/registers';
+import { ContentType } from '@glimmer/vm/lib/content';
 
 import type { HighLevelStatementOp, PushStatementOp } from '../../syntax/compilers';
 
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 652481fa5a8..f2ef561eda3 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/vm.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/helpers/vm.ts
@@ -1,7 +1,6 @@
 import type { CurriedType, NonSmallIntOperand, Nullable, WireFormat } from '@glimmer/interfaces';
+import { encodeImmediate, isSmallInt } from '@glimmer/constants/lib/immediate';
 import {
-  encodeImmediate,
-  isSmallInt,
   VM_BIND_DYNAMIC_SCOPE_OP,
   VM_CAPTURE_ARGS_OP,
   VM_CURRY_OP,
@@ -10,14 +9,13 @@ import {
   VM_FETCH_OP,
   VM_HELPER_OP,
   VM_POP_DYNAMIC_SCOPE_OP,
-  VM_POP_FRAME_OP,
   VM_POP_OP,
   VM_PRIMITIVE_OP,
   VM_PRIMITIVE_REFERENCE_OP,
   VM_PUSH_DYNAMIC_SCOPE_OP,
-  VM_PUSH_FRAME_OP,
-} from '@glimmer/constants';
-import { $fp, $v0 } from '@glimmer/vm';
+} from '@glimmer/constants/lib/syscall-ops';
+import { VM_POP_FRAME_OP, VM_PUSH_FRAME_OP } from '@glimmer/constants/lib/vm-ops';
+import { $fp, $v0 } from '@glimmer/vm/lib/registers';
 
 import type { PushExpressionOp, PushStatementOp } from '../../syntax/compilers';
 
diff --git a/packages/@glimmer/opcode-compiler/lib/opcode-builder/operands.ts b/packages/@glimmer/opcode-compiler/lib/opcode-builder/operands.ts
index 4abfabf53b1..bee3ced3f72 100644
--- a/packages/@glimmer/opcode-compiler/lib/opcode-builder/operands.ts
+++ b/packages/@glimmer/opcode-compiler/lib/opcode-builder/operands.ts
@@ -20,8 +20,8 @@ import type {
   SymbolTableOperand,
   SymbolTableOperandType,
 } from '@glimmer/interfaces';
-import { isSmallInt } from '@glimmer/constants';
-import { assert } from '@glimmer/debug-util';
+import { isSmallInt } from '@glimmer/constants/lib/immediate';
+import assert from '@glimmer/debug-util/lib/assert';
 
 export const HighLevelOperands = {
   Label: 1 satisfies LabelOperandType,
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts b/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts
index 3b571ce56c0..b22e30be04b 100644
--- a/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/compilers.ts
@@ -1,5 +1,6 @@
 import type { BuilderOp, HighLevelOp, SexpOpcode, SexpOpcodeMap } from '@glimmer/interfaces';
-import { assert, unwrap } from '@glimmer/debug-util';
+import assert from '@glimmer/debug-util/lib/assert';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
 
 export type PushExpressionOp = (...op: BuilderOp | HighLevelOp) => void;
 
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts b/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts
index 3841d39b891..1815ea34494 100644
--- a/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/expressions.ts
@@ -12,12 +12,11 @@ import {
   VM_IF_INLINE_OP,
   VM_LOG_OP,
   VM_NOT_OP,
-  VM_POP_FRAME_OP,
-  VM_PUSH_FRAME_OP,
   VM_SPREAD_BLOCK_OP,
-} from '@glimmer/constants';
-import { $v0 } from '@glimmer/vm';
-import { SexpOpcodes } from '@glimmer/wire-format';
+} from '@glimmer/constants/lib/syscall-ops';
+import { VM_POP_FRAME_OP, VM_PUSH_FRAME_OP } from '@glimmer/constants/lib/vm-ops';
+import { $v0 } from '@glimmer/vm/lib/registers';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 import type { PushExpressionOp } from './compilers';
 
diff --git a/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts b/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
index 300fd5bf363..4a57b28a48c 100644
--- a/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
+++ b/packages/@glimmer/opcode-compiler/lib/syntax/statements.ts
@@ -18,27 +18,30 @@ import {
   VM_ENTER_LIST_OP,
   VM_EXIT_LIST_OP,
   VM_FLUSH_ELEMENT_OP,
-  VM_INVOKE_STATIC_OP,
   VM_ITERATE_OP,
-  VM_JUMP_OP,
   VM_MODIFIER_OP,
   VM_OPEN_ELEMENT_OP,
-  VM_POP_FRAME_OP,
   VM_POP_OP,
   VM_POP_REMOTE_ELEMENT_OP,
   VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP,
-  VM_PUSH_FRAME_OP,
   VM_PUSH_REMOTE_ELEMENT_OP,
   VM_PUT_COMPONENT_OPERATIONS_OP,
   VM_RESOLVE_CURRIED_COMPONENT_OP,
-  VM_RETURN_TO_OP,
   VM_STATIC_ATTR_OP,
   VM_STATIC_COMPONENT_ATTR_OP,
   VM_TEXT_OP,
   VM_TO_BOOLEAN_OP,
-} from '@glimmer/constants';
-import { $fp, $sp, ContentType } from '@glimmer/vm';
-import { SexpOpcodes } from '@glimmer/wire-format';
+} from '@glimmer/constants/lib/syscall-ops';
+import {
+  VM_INVOKE_STATIC_OP,
+  VM_JUMP_OP,
+  VM_POP_FRAME_OP,
+  VM_PUSH_FRAME_OP,
+  VM_RETURN_TO_OP,
+} from '@glimmer/constants/lib/vm-ops';
+import { $fp, $sp } from '@glimmer/vm/lib/registers';
+import { ContentType } from '@glimmer/vm/lib/content';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 import type { PushStatementOp } from './compilers';
 
diff --git a/packages/@glimmer/opcode-compiler/lib/template.ts b/packages/@glimmer/opcode-compiler/lib/template.ts
index 4471e315517..3cb2f3ff9b4 100644
--- a/packages/@glimmer/opcode-compiler/lib/template.ts
+++ b/packages/@glimmer/opcode-compiler/lib/template.ts
@@ -10,7 +10,7 @@ import type {
   TemplateFactory,
   TemplateOk,
 } from '@glimmer/interfaces';
-import { assign } from '@glimmer/util';
+import { assign } from '@glimmer/util/lib/object-utils';
 
 import { compilable } from './compilable-template';
 import { WrappedBuilder } from './wrapped-component';
diff --git a/packages/@glimmer/opcode-compiler/lib/utils.ts b/packages/@glimmer/opcode-compiler/lib/utils.ts
index c4db145d92e..26bdb7880b3 100644
--- a/packages/@glimmer/opcode-compiler/lib/utils.ts
+++ b/packages/@glimmer/opcode-compiler/lib/utils.ts
@@ -1,6 +1,8 @@
 import type { NamedBlocks, Nullable, SerializedInlineBlock, WireFormat } from '@glimmer/interfaces';
-import { unwrap } from '@glimmer/debug-util';
-import { assign, dict, enumerate } from '@glimmer/util';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import { assign } from '@glimmer/util/lib/object-utils';
+import { dict } from '@glimmer/util/lib/collections';
+import { enumerate } from '@glimmer/util/lib/array-utils';
 
 interface NamedBlocksDict {
   [key: string]: Nullable<WireFormat.SerializedInlineBlock>;
diff --git a/packages/@glimmer/opcode-compiler/package.json b/packages/@glimmer/opcode-compiler/package.json
index e89e0cb781c..bb2d28c019d 100644
--- a/packages/@glimmer/opcode-compiler/package.json
+++ b/packages/@glimmer/opcode-compiler/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/opcode-compiler"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/owner/package.json b/packages/@glimmer/owner/package.json
index aab6a3f5381..bb3c051270f 100644
--- a/packages/@glimmer/owner/package.json
+++ b/packages/@glimmer/owner/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/owner"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/program/lib/constants.ts b/packages/@glimmer/program/lib/constants.ts
index d8a5a7dbb12..1041fbe8817 100644
--- a/packages/@glimmer/program/lib/constants.ts
+++ b/packages/@glimmer/program/lib/constants.ts
@@ -9,19 +9,20 @@ import type {
   ResolvedComponentDefinition,
   Template,
 } from '@glimmer/interfaces';
-import { constants } from '@glimmer/constants';
-import { expect, assert, unwrapTemplate } from '@glimmer/debug-util';
+import { constants } from '@glimmer/constants/lib/immediate';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
+import { unwrapTemplate } from '@glimmer/debug-util/lib/template';
+import { capabilityFlagsFrom, managerHasCapability } from '@glimmer/manager/lib/util/capabilities';
+import { getComponentTemplate } from '@glimmer/manager/lib/public/template';
 import {
-  capabilityFlagsFrom,
-  getComponentTemplate,
   getInternalComponentManager,
   getInternalHelperManager,
   getInternalModifierManager,
-  managerHasCapability,
-} from '@glimmer/manager';
-import { templateFactory } from '@glimmer/opcode-compiler';
-import { enumerate } from '@glimmer/util';
-import { InternalComponentCapabilities } from '@glimmer/vm';
+} from '@glimmer/manager/lib/internal/api';
+import templateFactory from '@glimmer/opcode-compiler/lib/template';
+import { enumerate } from '@glimmer/util/lib/array-utils';
+import { InternalComponentCapabilities } from '@glimmer/vm/lib/flags';
 
 import { DEFAULT_TEMPLATE } from './util/default-template';
 
diff --git a/packages/@glimmer/program/lib/opcode.ts b/packages/@glimmer/program/lib/opcode.ts
index c7c9a4736ed..d866ae849f1 100644
--- a/packages/@glimmer/program/lib/opcode.ts
+++ b/packages/@glimmer/program/lib/opcode.ts
@@ -1,5 +1,5 @@
 import type { ProgramHeap, RuntimeOp, SomeVmOp } from '@glimmer/interfaces';
-import { ARG_SHIFT, MACHINE_MASK, OPERAND_LEN_MASK, TYPE_MASK } from '@glimmer/vm';
+import { ARG_SHIFT, MACHINE_MASK, OPERAND_LEN_MASK, TYPE_MASK } from '@glimmer/vm/lib/flags';
 
 export class RuntimeOpImpl implements RuntimeOp {
   public offset = 0;
diff --git a/packages/@glimmer/program/lib/program.ts b/packages/@glimmer/program/lib/program.ts
index 672d5be15aa..82fc0fe613c 100644
--- a/packages/@glimmer/program/lib/program.ts
+++ b/packages/@glimmer/program/lib/program.ts
@@ -1,7 +1,7 @@
 import type { Program, ProgramConstants, ProgramHeap, StdLibOperand } from '@glimmer/interfaces';
-import { unwrap } from '@glimmer/debug-util';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { MACHINE_MASK } from '@glimmer/vm';
+import { MACHINE_MASK } from '@glimmer/vm/lib/flags';
 
 import { RuntimeOpImpl } from './opcode';
 
diff --git a/packages/@glimmer/program/lib/util/default-template.ts b/packages/@glimmer/program/lib/util/default-template.ts
index 2539b52f87a..74908f1050a 100644
--- a/packages/@glimmer/program/lib/util/default-template.ts
+++ b/packages/@glimmer/program/lib/util/default-template.ts
@@ -1,5 +1,5 @@
 import type { SerializedTemplateBlock, SerializedTemplateWithLazyBlock } from '@glimmer/interfaces';
-import { SexpOpcodes as op } from '@glimmer/wire-format';
+import { opcodes as op } from '@glimmer/wire-format/lib/opcodes';
 
 /**
  * Default component template, which is a plain yield
diff --git a/packages/@glimmer/program/package.json b/packages/@glimmer/program/package.json
index 875552f4f7d..61f6c1414f1 100644
--- a/packages/@glimmer/program/package.json
+++ b/packages/@glimmer/program/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/program"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/reference/lib/iterable.ts b/packages/@glimmer/reference/lib/iterable.ts
index 4fd2135659a..75c4c63a8b1 100644
--- a/packages/@glimmer/reference/lib/iterable.ts
+++ b/packages/@glimmer/reference/lib/iterable.ts
@@ -1,8 +1,10 @@
 import { DEBUG } from '@glimmer/env';
 import type { Dict, Nullable } from '@glimmer/interfaces';
 import { getPath, toIterator } from '@glimmer/global-context';
-import { EMPTY_ARRAY, isIndexable } from '@glimmer/util';
-import { consumeTag, createTag, dirtyTag } from '@glimmer/validator';
+import { EMPTY_ARRAY } from '@glimmer/util/lib/array-utils';
+import { isIndexable } from '@glimmer/util/lib/collections';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { createTag, DIRTY_TAG as dirtyTag } from '@glimmer/validator/lib/validators';
 
 import type { Reference, ReferenceEnvironment } from './reference';
 
diff --git a/packages/@glimmer/reference/lib/reference.ts b/packages/@glimmer/reference/lib/reference.ts
index e58fb46cf8a..c7232d0469a 100644
--- a/packages/@glimmer/reference/lib/reference.ts
+++ b/packages/@glimmer/reference/lib/reference.ts
@@ -9,18 +9,13 @@ import type {
   ReferenceType,
   UnboundReference,
 } from '@glimmer/interfaces';
-import type { Revision, Tag } from '@glimmer/validator';
-import { expect } from '@glimmer/debug-util';
+import type { Revision } from '@glimmer/validator/lib/validators';
+import type { Tag } from '@glimmer/interfaces';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
 import { getProp, setProp } from '@glimmer/global-context';
-import { isDict } from '@glimmer/util';
-import {
-  CONSTANT_TAG,
-  consumeTag,
-  INITIAL,
-  track,
-  validateTag,
-  valueForTag,
-} from '@glimmer/validator';
+import { isDict } from '@glimmer/util/lib/collections';
+import { CONSTANT_TAG, INITIAL, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
+import { consumeTag, track } from '@glimmer/validator/lib/tracking';
 
 export const REFERENCE: ReferenceSymbol = Symbol('REFERENCE') as ReferenceSymbol;
 
diff --git a/packages/@glimmer/reference/package.json b/packages/@glimmer/reference/package.json
index 94bbf910c25..21eec906d51 100644
--- a/packages/@glimmer/reference/package.json
+++ b/packages/@glimmer/reference/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/reference"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/runtime/index.ts b/packages/@glimmer/runtime/index.ts
index 617edd8ae30..faf4dc34f35 100644
--- a/packages/@glimmer/runtime/index.ts
+++ b/packages/@glimmer/runtime/index.ts
@@ -1,8 +1,3 @@
-/**
- * @deprecated use RichIteratorResult<Tick, Return> or TemplateIterator instead
- */
-import './lib/bootstrap';
-
 import type { RichIteratorResult } from '@glimmer/interfaces';
 
 export { clear, ConcreteBounds, CursorImpl } from './lib/bounds';
diff --git a/packages/@glimmer/runtime/lib/bounds.ts b/packages/@glimmer/runtime/lib/bounds.ts
index 784ed5ca890..224a45cb067 100644
--- a/packages/@glimmer/runtime/lib/bounds.ts
+++ b/packages/@glimmer/runtime/lib/bounds.ts
@@ -1,5 +1,6 @@
 import type { Bounds, Cursor, Nullable, SimpleElement, SimpleNode } from '@glimmer/interfaces';
-import { expect, setLocalDebugType } from '@glimmer/debug-util';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import { setLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
 
 export class CursorImpl implements Cursor {
   constructor(
diff --git a/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts b/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts
index 02b22847193..29f34806454 100644
--- a/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts
+++ b/packages/@glimmer/runtime/lib/compiled/expressions/concat.ts
@@ -1,5 +1,5 @@
-import type { Reference } from '@glimmer/reference';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
 
 export function createConcatRef(partsRefs: Reference[]) {
   return createComputeRef(() => {
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts
index 49e041df998..0795d1c1507 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/-debug-strip.ts
@@ -1,4 +1,4 @@
-import type { Checker } from '@glimmer/debug';
+import type { Checker } from '@glimmer/debug/lib/stack-check';
 import type {
   CapabilityMask,
   CapturedArguments,
@@ -14,8 +14,9 @@ import type {
   Scope,
   ScopeBlock,
 } from '@glimmer/interfaces';
-import type { OpaqueIterator, Reference } from '@glimmer/reference';
-import type { Tag } from '@glimmer/validator';
+import type { OpaqueIterator } from '@glimmer/reference/lib/iterable';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import type { Tag } from '@glimmer/interfaces';
 import {
   CheckArray,
   CheckBlockSymbolTable,
@@ -32,9 +33,9 @@ import {
   CheckString,
   CheckUnknown,
   wrap,
-} from '@glimmer/debug';
-import { REFERENCE, UNDEFINED_REFERENCE } from '@glimmer/reference';
-import { COMPUTE } from '@glimmer/validator';
+} from '@glimmer/debug/lib/stack-check';
+import { REFERENCE, UNDEFINED_REFERENCE } from '@glimmer/reference/lib/reference';
+import { COMPUTE } from '@glimmer/validator/lib/validators';
 
 import { ScopeImpl } from '../../scope';
 import { VMArgumentsImpl } from '../../vm/arguments';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
index 7903011421d..98b020e0131 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/component.ts
@@ -25,9 +25,9 @@ import type {
   WithElementHook,
   WithUpdateHook,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { CURRIED_COMPONENT } from '@glimmer/constants/lib/curried';
 import {
-  CURRIED_COMPONENT,
   VM_BEGIN_COMPONENT_TRANSACTION_OP,
   VM_CAPTURE_ARGS_OP,
   VM_COMMIT_COMPONENT_TRANSACTION_OP,
@@ -54,7 +54,7 @@ import {
   VM_SET_NAMED_VARIABLES_OP,
   VM_STATIC_COMPONENT_ATTR_OP,
   VM_VIRTUAL_ROOT_SCOPE_OP,
-} from '@glimmer/constants';
+} from '@glimmer/constants/lib/syscall-ops';
 import {
   check,
   CheckFunction,
@@ -66,13 +66,19 @@ import {
   CheckRegister,
   CheckString,
   CheckSyscallRegister,
-} from '@glimmer/debug';
-import { debugToString, expect, assert, unwrap, unwrapTemplate } from '@glimmer/debug-util';
+} from '@glimmer/debug/lib/stack-check';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
+import { expect, unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
+import { unwrapTemplate } from '@glimmer/debug-util/lib/template';
 import { registerDestructor } from '@glimmer/destroyable';
-import { managerHasCapability } from '@glimmer/manager';
-import { isConstRef, valueForRef } from '@glimmer/reference';
-import { assign, dict, EMPTY_STRING_ARRAY, enumerate } from '@glimmer/util';
-import { $s0, $t0, $t1, InternalComponentCapabilities } from '@glimmer/vm';
+import { managerHasCapability } from '@glimmer/manager/lib/util/capabilities';
+import { isConstRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { assign } from '@glimmer/util/lib/object-utils';
+import { dict } from '@glimmer/util/lib/collections';
+import { EMPTY_STRING_ARRAY, enumerate } from '@glimmer/util/lib/array-utils';
+import { $s0, $t0, $t1 } from '@glimmer/vm/lib/registers';
+import { InternalComponentCapabilities } from '@glimmer/vm/lib/flags';
 
 import type { CurriedValue } from '../../curried-value';
 import type { UpdatingVM } from '../../vm';
@@ -83,7 +89,7 @@ import { ConcreteBounds } from '../../bounds';
 import { hasCustomDebugRenderTreeLifecycle } from '../../component/interfaces';
 import { resolveComponent } from '../../component/resolve';
 import { isCurriedType, isCurriedValue, resolveCurriedValue } from '../../curried-value';
-import { getDebugName } from '../../debug-render-tree';
+import { getDebugName } from '../../get-debug-name';
 import { APPEND_OPCODES } from '../../opcodes';
 import createClassListRef from '../../references/class-list';
 import { EMPTY_ARGS, VMArgumentsImpl } from '../../vm/arguments';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts
index a24a65e9077..ab8c668f170 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/content.ts
@@ -1,7 +1,6 @@
 import { DEBUG } from '@glimmer/env';
+import { CURRIED_COMPONENT, CURRIED_HELPER } from '@glimmer/constants/lib/curried';
 import {
-  CURRIED_COMPONENT,
-  CURRIED_HELPER,
   VM_APPEND_DOCUMENT_FRAGMENT_OP,
   VM_APPEND_HTML_OP,
   VM_APPEND_NODE_OP,
@@ -9,18 +8,21 @@ import {
   VM_APPEND_TEXT_OP,
   VM_CONTENT_TYPE_OP,
   VM_DYNAMIC_CONTENT_TYPE_OP,
-} from '@glimmer/constants';
+} from '@glimmer/constants/lib/syscall-ops';
 import {
   check,
   CheckDocumentFragment,
   CheckNode,
   CheckSafeString,
   CheckString,
-} from '@glimmer/debug';
-import { hasInternalComponentManager, hasInternalHelperManager } from '@glimmer/manager';
-import { isConstRef, valueForRef } from '@glimmer/reference';
-import { isIndexable } from '@glimmer/util';
-import { ContentType } from '@glimmer/vm';
+} from '@glimmer/debug/lib/stack-check';
+import {
+  hasInternalComponentManager,
+  hasInternalHelperManager,
+} from '@glimmer/manager/lib/internal/api';
+import { isConstRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { isIndexable } from '@glimmer/util/lib/collections';
+import { ContentType } from '@glimmer/vm/lib/content';
 
 import { isCurriedType } from '../../curried-value';
 import { isEmpty, isFragment, isNode, isSafeString, shouldCoerce } from '../../dom/normalize';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
index 22b735ffb42..7d1c46ce3c6 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/debugger.ts
@@ -1,10 +1,11 @@
 // Allow the contents of `debugCallback` without extra annotations
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 import type { DebuggerInfo, Scope } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { decodeHandle, VM_DEBUGGER_OP } from '@glimmer/constants';
-import { unwrap } from '@glimmer/debug-util';
-import { childRefFor, valueForRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { decodeHandle } from '@glimmer/constants/lib/immediate';
+import { VM_DEBUGGER_OP } from '@glimmer/constants/lib/syscall-ops';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import { childRefFor, valueForRef } from '@glimmer/reference/lib/reference';
 
 import { APPEND_OPCODES } from '../../opcodes';
 
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts
index 9c0d378b123..e12d7f8fbfb 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/dom.ts
@@ -10,10 +10,11 @@ import type {
   UpdatingOpcode,
   UpdatingVM,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import type { Revision, Tag } from '@glimmer/validator';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import type { Revision } from '@glimmer/validator/lib/validators';
+import type { Tag } from '@glimmer/interfaces';
+import { CURRIED_MODIFIER } from '@glimmer/constants/lib/curried';
 import {
-  CURRIED_MODIFIER,
   VM_CLOSE_ELEMENT_OP,
   VM_COMMENT_OP,
   VM_DYNAMIC_ATTR_OP,
@@ -26,7 +27,7 @@ import {
   VM_PUSH_REMOTE_ELEMENT_OP,
   VM_STATIC_ATTR_OP,
   VM_TEXT_OP,
-} from '@glimmer/constants';
+} from '@glimmer/constants/lib/syscall-ops';
 import {
   check,
   CheckElement,
@@ -34,14 +35,16 @@ import {
   CheckNode,
   CheckNullable,
   CheckString,
-} from '@glimmer/debug';
-import { debugToString, expect } from '@glimmer/debug-util';
+} from '@glimmer/debug/lib/stack-check';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
 import { associateDestroyableChild, destroy, registerDestructor } from '@glimmer/destroyable';
-import { getInternalModifierManager } from '@glimmer/manager';
-import { createComputeRef, isConstRef, valueForRef } from '@glimmer/reference';
-import { isIndexable } from '@glimmer/util';
-import { consumeTag, CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator';
-import { $t0 } from '@glimmer/vm';
+import { getInternalModifierManager } from '@glimmer/manager/lib/internal/api';
+import { createComputeRef, isConstRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { isIndexable } from '@glimmer/util/lib/collections';
+import { consumeTag } from '@glimmer/validator/lib/tracking';
+import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
+import { $t0 } from '@glimmer/vm/lib/registers';
 
 import type { CurriedValue } from '../../curried-value';
 import type { DynamicAttribute } from '../../vm/attributes/dynamic';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts
index bac07c70aba..0e99c73c52f 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/expressions.ts
@@ -7,10 +7,10 @@ import type {
   Initializable,
   ScopeBlock,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { CURRIED_HELPER } from '@glimmer/constants/lib/curried';
+import { decodeHandle } from '@glimmer/constants/lib/immediate';
 import {
-  CURRIED_HELPER,
-  decodeHandle,
   VM_CONCAT_OP,
   VM_CURRY_OP,
   VM_DYNAMIC_HELPER_OP,
@@ -28,7 +28,7 @@ import {
   VM_SET_BLOCK_OP,
   VM_SET_VARIABLE_OP,
   VM_SPREAD_BLOCK_OP,
-} from '@glimmer/constants';
+} from '@glimmer/constants/lib/syscall-ops';
 import {
   check,
   CheckBlockSymbolTable,
@@ -36,11 +36,12 @@ import {
   CheckMaybe,
   CheckNullable,
   CheckOr,
-} from '@glimmer/debug';
-import { debugToString, assert } from '@glimmer/debug-util';
+} from '@glimmer/debug/lib/stack-check';
+import debugToString from '@glimmer/debug-util/lib/debug-to-string';
+import assert from '@glimmer/debug-util/lib/assert';
 import { _hasDestroyableChildren, associateDestroyableChild, destroy } from '@glimmer/destroyable';
 import { debugAssert, toBool } from '@glimmer/global-context';
-import { getInternalHelperManager } from '@glimmer/manager';
+import { getInternalHelperManager } from '@glimmer/manager/lib/internal/api';
 import {
   childRefFor,
   createComputeRef,
@@ -48,9 +49,10 @@ import {
   TRUE_REFERENCE,
   UNDEFINED_REFERENCE,
   valueForRef,
-} from '@glimmer/reference';
-import { assign, isIndexable } from '@glimmer/util';
-import { $v0 } from '@glimmer/vm';
+} from '@glimmer/reference/lib/reference';
+import { assign } from '@glimmer/util/lib/object-utils';
+import { isIndexable } from '@glimmer/util/lib/collections';
+import { $v0 } from '@glimmer/vm/lib/registers';
 
 import { isCurriedType, resolveCurriedValue } from '../../curried-value';
 import { APPEND_OPCODES } from '../../opcodes';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts
index c4c87ab21fc..1dfae3891d1 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/lists.ts
@@ -1,6 +1,11 @@
-import { VM_ENTER_LIST_OP, VM_EXIT_LIST_OP, VM_ITERATE_OP } from '@glimmer/constants';
-import { check } from '@glimmer/debug';
-import { createIteratorRef, valueForRef } from '@glimmer/reference';
+import {
+  VM_ENTER_LIST_OP,
+  VM_EXIT_LIST_OP,
+  VM_ITERATE_OP,
+} from '@glimmer/constants/lib/syscall-ops';
+import { check } from '@glimmer/debug/lib/stack-check';
+import { createIteratorRef } from '@glimmer/reference/lib/iterable';
+import { valueForRef } from '@glimmer/reference/lib/reference';
 
 import { APPEND_OPCODES } from '../../opcodes';
 import { CheckIterator, CheckReference } from './-debug-strip';
diff --git a/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts b/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts
index c020d26dae7..f701eea5743 100644
--- a/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts
+++ b/packages/@glimmer/runtime/lib/compiled/opcodes/vm.ts
@@ -1,10 +1,9 @@
 import type { CompilableTemplate, Nullable, UpdatingOpcode } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import type { Revision, Tag } from '@glimmer/validator';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import type { Revision } from '@glimmer/validator/lib/validators';
+import type { Tag } from '@glimmer/interfaces';
+import { decodeHandle, decodeImmediate, isHandle } from '@glimmer/constants/lib/immediate';
 import {
-  decodeHandle,
-  decodeImmediate,
-  isHandle,
   VM_ASSERT_SAME_OP,
   VM_BIND_DYNAMIC_SCOPE_OP,
   VM_CHILD_SCOPE_OP,
@@ -29,7 +28,7 @@ import {
   VM_PUSH_DYNAMIC_SCOPE_OP,
   VM_PUSH_SYMBOL_TABLE_OP,
   VM_TO_BOOLEAN_OP,
-} from '@glimmer/constants';
+} from '@glimmer/constants/lib/syscall-ops';
 import {
   check,
   CheckBlockSymbolTable,
@@ -40,8 +39,9 @@ import {
   CheckPrimitive,
   CheckRegister,
   CheckSyscallRegister,
-} from '@glimmer/debug';
-import { expect, assert, unwrap } from '@glimmer/debug-util';
+} from '@glimmer/debug/lib/stack-check';
+import { expect, unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
 import { toBool } from '@glimmer/global-context';
 import {
   createComputeRef,
@@ -53,16 +53,9 @@ import {
   TRUE_REFERENCE,
   UNDEFINED_REFERENCE,
   valueForRef,
-} from '@glimmer/reference';
-import {
-  beginTrackFrame,
-  CONSTANT_TAG,
-  consumeTag,
-  endTrackFrame,
-  INITIAL,
-  validateTag,
-  valueForTag,
-} from '@glimmer/validator';
+} from '@glimmer/reference/lib/reference';
+import { beginTrackFrame, consumeTag, endTrackFrame } from '@glimmer/validator/lib/tracking';
+import { CONSTANT_TAG, INITIAL, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
 
 import type { UpdatingVM } from '../../vm';
 import type { VM } from '../../vm/append';
diff --git a/packages/@glimmer/runtime/lib/component/resolve.ts b/packages/@glimmer/runtime/lib/component/resolve.ts
index 5287d0bdfa7..cc97187c207 100644
--- a/packages/@glimmer/runtime/lib/component/resolve.ts
+++ b/packages/@glimmer/runtime/lib/component/resolve.ts
@@ -6,7 +6,7 @@ import type {
   Owner,
   ResolutionTimeConstants,
 } from '@glimmer/interfaces';
-import { expect } from '@glimmer/debug-util';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
 
 export function resolveComponent(
   resolver: Nullable<ClassicResolver>,
diff --git a/packages/@glimmer/runtime/lib/component/template-only.ts b/packages/@glimmer/runtime/lib/component/template-only.ts
index ba3ee9720f3..71eb3f8dafc 100644
--- a/packages/@glimmer/runtime/lib/component/template-only.ts
+++ b/packages/@glimmer/runtime/lib/component/template-only.ts
@@ -1,7 +1,7 @@
 import type { InternalComponentCapabilities, InternalComponentManager } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { setInternalComponentManager } from '@glimmer/manager';
-import { NULL_REFERENCE } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+import { NULL_REFERENCE } from '@glimmer/reference/lib/reference';
 
 const CAPABILITIES: InternalComponentCapabilities = {
   dynamicLayout: false,
diff --git a/packages/@glimmer/runtime/lib/curried-value.ts b/packages/@glimmer/runtime/lib/curried-value.ts
index 9663cbc2098..d6f942d0123 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 { Reference } from '@glimmer/reference/lib/reference';
 
 const TYPE: unique symbol = Symbol('TYPE');
 const INNER: unique symbol = Symbol('INNER');
diff --git a/packages/@glimmer/runtime/lib/debug-render-tree-register.ts b/packages/@glimmer/runtime/lib/debug-render-tree-register.ts
new file mode 100644
index 00000000000..af8ab37555c
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/debug-render-tree-register.ts
@@ -0,0 +1,4 @@
+import DebugRenderTreeImpl from './debug-render-tree';
+import { registerDebugRenderTreeFactory } from './environment';
+
+registerDebugRenderTreeFactory(() => new DebugRenderTreeImpl());
diff --git a/packages/@glimmer/runtime/lib/debug-render-tree.ts b/packages/@glimmer/runtime/lib/debug-render-tree.ts
index 187e9fabab3..25b580c2740 100644
--- a/packages/@glimmer/runtime/lib/debug-render-tree.ts
+++ b/packages/@glimmer/runtime/lib/debug-render-tree.ts
@@ -2,13 +2,13 @@ import { DEBUG } from '@glimmer/env';
 import type {
   Bounds,
   CapturedRenderNode,
-  ComponentDefinition,
   DebugRenderTree,
   Nullable,
   RenderNode,
 } from '@glimmer/interfaces';
-import { expect } from '@glimmer/debug-util';
-import { assign, Stack } from '@glimmer/util';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import { assign } from '@glimmer/util/lib/object-utils';
+import { StackImpl as Stack } from '@glimmer/util/lib/collections';
 
 import { reifyArgsDebug } from './vm/arguments';
 
@@ -197,9 +197,4 @@ export default class DebugRenderTreeImpl<
   }
 }
 
-export function getDebugName(
-  definition: ComponentDefinition,
-  manager = definition.manager
-): string {
-  return definition.resolvedName ?? definition.debugName ?? manager.getDebugName(definition.state);
-}
+export { getDebugName } from './get-debug-name';
diff --git a/packages/@glimmer/runtime/lib/dom/operations.ts b/packages/@glimmer/runtime/lib/dom/operations.ts
index 779ff30b502..5cbcc133921 100644
--- a/packages/@glimmer/runtime/lib/dom/operations.ts
+++ b/packages/@glimmer/runtime/lib/dom/operations.ts
@@ -9,8 +9,13 @@ import type {
   SimpleNode,
   SimpleText,
 } from '@glimmer/interfaces';
-import { INSERT_BEFORE_BEGIN, INSERT_BEFORE_END, NS_MATHML, NS_SVG } from '@glimmer/constants';
-import { expect } from '@glimmer/debug-util';
+import {
+  INSERT_BEFORE_BEGIN,
+  INSERT_BEFORE_END,
+  NS_MATHML,
+  NS_SVG,
+} from '@glimmer/constants/lib/dom';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
 
 import { ConcreteBounds } from '../bounds';
 
diff --git a/packages/@glimmer/runtime/lib/environment.ts b/packages/@glimmer/runtime/lib/environment.ts
index 9adfe360b61..1648aa0b4b7 100644
--- a/packages/@glimmer/runtime/lib/environment.ts
+++ b/packages/@glimmer/runtime/lib/environment.ts
@@ -2,6 +2,7 @@ import { DEBUG } from '@glimmer/env';
 import type {
   ClassicResolver,
   ComponentInstanceWithCreate,
+  DebugRenderTree,
   Environment,
   EnvironmentOptions,
   GlimmerTreeChanges,
@@ -13,14 +14,22 @@ import type {
   Transaction,
   TransactionSymbol,
 } from '@glimmer/interfaces';
-import { expect, assert } from '@glimmer/debug-util';
-import { ProgramImpl } from '@glimmer/program';
-import { track, updateTag } from '@glimmer/validator';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
+import { ProgramImpl } from '@glimmer/program/lib/program';
+import { track } from '@glimmer/validator/lib/tracking';
+import { UPDATE_TAG as updateTag } from '@glimmer/validator/lib/validators';
 
-import DebugRenderTree from './debug-render-tree';
 import { DOMChangesImpl, DOMTreeConstruction } from './dom/helper';
 import { isArgumentError } from './vm/arguments';
 
+type DebugRenderTreeFactory = () => DebugRenderTree;
+let debugRenderTreeFactory: DebugRenderTreeFactory | null = null;
+
+export function registerDebugRenderTreeFactory(factory: DebugRenderTreeFactory): void {
+  debugRenderTreeFactory = factory;
+}
+
 export const TRANSACTION: TransactionSymbol = Symbol('TRANSACTION') as TransactionSymbol;
 
 class TransactionImpl implements Transaction {
@@ -105,14 +114,17 @@ export class EnvironmentImpl implements Environment {
 
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   isArgumentCaptureError: ((error: any) => boolean) | undefined;
-  debugRenderTree: DebugRenderTree<object> | undefined;
+  debugRenderTree: DebugRenderTree | undefined;
 
   constructor(
     options: EnvironmentOptions,
     private delegate: EnvironmentDelegate
   ) {
     this.isInteractive = delegate.isInteractive;
-    this.debugRenderTree = this.delegate.enableDebugTooling ? new DebugRenderTree() : undefined;
+    this.debugRenderTree =
+      this.delegate.enableDebugTooling && debugRenderTreeFactory
+        ? debugRenderTreeFactory()
+        : undefined;
     this.isArgumentCaptureError = this.delegate.enableDebugTooling ? isArgumentError : undefined;
     if (options.appendOperations) {
       this.appendOperations = options.appendOperations;
diff --git a/packages/@glimmer/runtime/lib/get-debug-name.ts b/packages/@glimmer/runtime/lib/get-debug-name.ts
new file mode 100644
index 00000000000..4fee4aac3a1
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/get-debug-name.ts
@@ -0,0 +1,8 @@
+import type { ComponentDefinition } from '@glimmer/interfaces';
+
+export function getDebugName(
+  definition: ComponentDefinition,
+  manager = definition.manager
+): string {
+  return definition.resolvedName ?? definition.debugName ?? manager.getDebugName(definition.state);
+}
diff --git a/packages/@glimmer/runtime/lib/helpers/array.ts b/packages/@glimmer/runtime/lib/helpers/array.ts
index c4b3f32b830..dd987298931 100644
--- a/packages/@glimmer/runtime/lib/helpers/array.ts
+++ b/packages/@glimmer/runtime/lib/helpers/array.ts
@@ -1,6 +1,6 @@
 import type { CapturedArguments } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { createComputeRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createComputeRef } from '@glimmer/reference/lib/reference';
 
 import { reifyPositional } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
diff --git a/packages/@glimmer/runtime/lib/helpers/concat.ts b/packages/@glimmer/runtime/lib/helpers/concat.ts
index ea73624f3fb..2b42206d3ff 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 { createComputeRef } from '@glimmer/reference/lib/reference';
 
 import { reifyPositional } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
diff --git a/packages/@glimmer/runtime/lib/helpers/fn.ts b/packages/@glimmer/runtime/lib/helpers/fn.ts
index 1fbf2b89305..b8ce4196740 100644
--- a/packages/@glimmer/runtime/lib/helpers/fn.ts
+++ b/packages/@glimmer/runtime/lib/helpers/fn.ts
@@ -1,9 +1,14 @@
 import { DEBUG } from '@glimmer/env';
 import type { AnyFn, CapturedArguments } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { check } from '@glimmer/debug';
-import { buildUntouchableThis } from '@glimmer/debug-util';
-import { createComputeRef, isInvokableRef, updateRef, valueForRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { check } from '@glimmer/debug/lib/stack-check';
+import buildUntouchableThis from '@glimmer/debug-util/lib/untouchable-this';
+import {
+  createComputeRef,
+  isInvokableRef,
+  updateRef,
+  valueForRef,
+} from '@glimmer/reference/lib/reference';
 
 import { reifyPositional } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
diff --git a/packages/@glimmer/runtime/lib/helpers/get.ts b/packages/@glimmer/runtime/lib/helpers/get.ts
index 99fd8d30793..0e9fa4a3439 100644
--- a/packages/@glimmer/runtime/lib/helpers/get.ts
+++ b/packages/@glimmer/runtime/lib/helpers/get.ts
@@ -1,7 +1,11 @@
 import type { CapturedArguments } from '@glimmer/interfaces';
 import { getPath, setPath } from '@glimmer/global-context';
-import { createComputeRef, UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference';
-import { isDict } from '@glimmer/util';
+import {
+  createComputeRef,
+  UNDEFINED_REFERENCE,
+  valueForRef,
+} from '@glimmer/reference/lib/reference';
+import { isDict } from '@glimmer/util/lib/collections';
 
 import { internalHelper } from './internal-helper';
 
diff --git a/packages/@glimmer/runtime/lib/helpers/hash.ts b/packages/@glimmer/runtime/lib/helpers/hash.ts
index 3c482a025d2..d71cc77c86e 100644
--- a/packages/@glimmer/runtime/lib/helpers/hash.ts
+++ b/packages/@glimmer/runtime/lib/helpers/hash.ts
@@ -1,6 +1,6 @@
 import type { CapturedArguments, Dict } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { createComputeRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createComputeRef } from '@glimmer/reference/lib/reference';
 
 import { reifyNamed } from '../vm/arguments';
 import { internalHelper } from './internal-helper';
diff --git a/packages/@glimmer/runtime/lib/helpers/internal-helper.ts b/packages/@glimmer/runtime/lib/helpers/internal-helper.ts
index a95b2999033..a5bc752e73c 100644
--- a/packages/@glimmer/runtime/lib/helpers/internal-helper.ts
+++ b/packages/@glimmer/runtime/lib/helpers/internal-helper.ts
@@ -1,5 +1,5 @@
 import type { Helper, HelperDefinitionState } from '@glimmer/interfaces';
-import { setInternalHelperManager } from '@glimmer/manager';
+import { setInternalHelperManager } from '@glimmer/manager/lib/internal/api';
 
 export function internalHelper(helper: Helper): HelperDefinitionState {
   return setInternalHelperManager(helper, {});
diff --git a/packages/@glimmer/runtime/lib/helpers/invoke.ts b/packages/@glimmer/runtime/lib/helpers/invoke.ts
index e32ab87979b..e82e44e28c3 100644
--- a/packages/@glimmer/runtime/lib/helpers/invoke.ts
+++ b/packages/@glimmer/runtime/lib/helpers/invoke.ts
@@ -1,10 +1,11 @@
 import { DEBUG } from '@glimmer/env';
 import type { Arguments, InternalHelperManager } from '@glimmer/interfaces';
-import type { Cache } from '@glimmer/validator';
+import type { Cache } from '@glimmer/validator/lib/tracking';
 import { associateDestroyableChild, isDestroyed, isDestroying } from '@glimmer/destroyable';
-import { getInternalHelperManager, hasDestroyable, hasValue } from '@glimmer/manager';
+import { getInternalHelperManager } from '@glimmer/manager/lib/internal/api';
+import { hasDestroyable, hasValue } from '@glimmer/manager/lib/public/helper';
 import { getOwner } from '@glimmer/owner';
-import { createCache, getValue } from '@glimmer/validator';
+import { createCache, getValue } from '@glimmer/validator/lib/tracking';
 
 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 787e21e74aa..35dfdc1c827 100644
--- a/packages/@glimmer/runtime/lib/modifiers/on.ts
+++ b/packages/@glimmer/runtime/lib/modifiers/on.ts
@@ -13,12 +13,12 @@ import {
   CheckOr,
   CheckString,
   CheckUndefined,
-} from '@glimmer/debug';
-import { buildUntouchableThis } from '@glimmer/debug-util';
+} from '@glimmer/debug/lib/stack-check';
+import buildUntouchableThis from '@glimmer/debug-util/lib/untouchable-this';
 import { registerDestructor } from '@glimmer/destroyable';
-import { setInternalModifierManager } from '@glimmer/manager';
-import { valueForRef } from '@glimmer/reference';
-import { createUpdatableTag } from '@glimmer/validator';
+import { setInternalModifierManager } from '@glimmer/manager/lib/internal/api';
+import { valueForRef } from '@glimmer/reference/lib/reference';
+import { createUpdatableTag } from '@glimmer/validator/lib/validators';
 
 import { reifyNamed } from '../vm/arguments';
 
diff --git a/packages/@glimmer/runtime/lib/opcodes.ts b/packages/@glimmer/runtime/lib/opcodes.ts
index 247597dda93..2a9228097ed 100644
--- a/packages/@glimmer/runtime/lib/opcodes.ts
+++ b/packages/@glimmer/runtime/lib/opcodes.ts
@@ -1,4 +1,4 @@
-import type { DebugOp, SomeDisassembledOperand } from '@glimmer/debug';
+import type { DebugOp, SomeDisassembledOperand } from '@glimmer/debug/lib/debug';
 import type {
   DebugVmSnapshot,
   Dict,
@@ -10,21 +10,18 @@ import type {
   VmMachineOp,
   VmOp,
 } from '@glimmer/interfaces';
-import { VM_SYSCALL_SIZE } from '@glimmer/constants';
-import {
-  DebugLogger,
-  debugOp,
-  describeOp,
-  describeOpcode,
-  frag,
-  opcodeMetadata,
-  recordStackSize,
-  VmSnapshot,
-} from '@glimmer/debug';
-import { dev, assert, unwrap } from '@glimmer/debug-util';
+import { VM_SYSCALL_SIZE } from '@glimmer/constants/lib/syscall-ops';
+import { DebugLogger } from '@glimmer/debug/lib/render/logger';
+import { debugOp, describeOp, describeOpcode } from '@glimmer/debug/lib/debug';
+import { frag } from '@glimmer/debug/lib/render/fragment';
+import { opcodeMetadata } from '@glimmer/debug/lib/opcode-metadata';
+import { recordStackSize } from '@glimmer/debug/lib/stack-check';
+import { VmSnapshot } from '@glimmer/debug/lib/vm/snapshot';
+import { dev, unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
 import { LOCAL_DEBUG, LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 import { LOCAL_LOGGER } from '@glimmer/util';
-import { $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0 } from '@glimmer/vm';
+import { $pc, $ra, $s0, $s1, $sp, $t0, $t1, $v0 } from '@glimmer/vm/lib/registers';
 
 import type { LowLevelVM, VM } from './vm';
 import type { Externs } from './vm/low-level';
diff --git a/packages/@glimmer/runtime/lib/references/class-list.ts b/packages/@glimmer/runtime/lib/references/class-list.ts
index ad039374926..6860eb03d69 100644
--- a/packages/@glimmer/runtime/lib/references/class-list.ts
+++ b/packages/@glimmer/runtime/lib/references/class-list.ts
@@ -1,5 +1,5 @@
-import type { Reference } from '@glimmer/reference';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
 
 import { normalizeStringValue } from '../dom/normalize';
 
diff --git a/packages/@glimmer/runtime/lib/references/curry-value.ts b/packages/@glimmer/runtime/lib/references/curry-value.ts
index ab1e01433e8..2c092e0e5f3 100644
--- a/packages/@glimmer/runtime/lib/references/curry-value.ts
+++ b/packages/@glimmer/runtime/lib/references/curry-value.ts
@@ -8,11 +8,11 @@ import type {
   Nullable,
   Owner,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { CURRIED_COMPONENT } from '@glimmer/constants';
-import { expect } from '@glimmer/debug-util';
-import { createComputeRef, valueForRef } from '@glimmer/reference';
-import { isIndexable } from '@glimmer/util';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { CURRIED_COMPONENT } from '@glimmer/constants/lib/curried';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import { createComputeRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { isIndexable } from '@glimmer/util/lib/collections';
 
 import { curry, isCurriedType } from '../curried-value';
 
diff --git a/packages/@glimmer/runtime/lib/render.ts b/packages/@glimmer/runtime/lib/render.ts
index ea375633868..7061473ebe7 100644
--- a/packages/@glimmer/runtime/lib/render.ts
+++ b/packages/@glimmer/runtime/lib/render.ts
@@ -11,11 +11,12 @@ import type {
   TemplateIterator,
   TreeBuilder,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { dev, expect, unwrapHandle } from '@glimmer/debug-util';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { dev, expect } from '@glimmer/debug-util/lib/platform-utils';
+import { unwrapHandle } from '@glimmer/debug-util/lib/template';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { childRefFor, createConstRef } from '@glimmer/reference';
-import { debug } from '@glimmer/validator';
+import { childRefFor, createConstRef } from '@glimmer/reference/lib/reference';
+import { debug } from '@glimmer/validator/lib/debug';
 
 import { inTransaction } from './environment';
 import { DynamicScopeImpl } from './scope';
diff --git a/packages/@glimmer/runtime/lib/scope.ts b/packages/@glimmer/runtime/lib/scope.ts
index 853c0c5357e..035f950f742 100644
--- a/packages/@glimmer/runtime/lib/scope.ts
+++ b/packages/@glimmer/runtime/lib/scope.ts
@@ -7,10 +7,10 @@ import type {
   ScopeBlock,
   ScopeSlot,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { unwrap } from '@glimmer/debug-util';
-import { UNDEFINED_REFERENCE } from '@glimmer/reference';
-import { assign } from '@glimmer/util';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import { UNDEFINED_REFERENCE } from '@glimmer/reference/lib/reference';
+import { assign } from '@glimmer/util/lib/object-utils';
 
 export class DynamicScopeImpl implements DynamicScope {
   private bucket: Dict<Reference>;
diff --git a/packages/@glimmer/runtime/lib/vm/append.ts b/packages/@glimmer/runtime/lib/vm/append.ts
index 5d43072ccf5..d6f1613e89f 100644
--- a/packages/@glimmer/runtime/lib/vm/append.ts
+++ b/packages/@glimmer/runtime/lib/vm/append.ts
@@ -20,16 +20,21 @@ import type {
   TreeBuilder,
   UpdatingOpcode,
 } from '@glimmer/interfaces';
-import type { OpaqueIterationItem, OpaqueIterator, Reference } from '@glimmer/reference';
-import type { MachineRegister, Register, SyscallRegister } from '@glimmer/vm';
-import { dev, expect, unwrapHandle } from '@glimmer/debug-util';
+import type { OpaqueIterationItem, OpaqueIterator } from '@glimmer/reference/lib/iterable';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import type { MachineRegister, Register, SyscallRegister } from '@glimmer/vm/lib/registers';
+import { dev, expect } from '@glimmer/debug-util/lib/platform-utils';
+import { unwrapHandle } from '@glimmer/debug-util/lib/template';
 import { associateDestroyableChild } from '@glimmer/destroyable';
 import { assertGlobalContextWasSet } from '@glimmer/global-context';
 import { LOCAL_DEBUG, LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
-import { createIteratorItemRef, UNDEFINED_REFERENCE } from '@glimmer/reference';
-import { LOCAL_LOGGER, reverse, Stack } from '@glimmer/util';
-import { beginTrackFrame, endTrackFrame, resetTracking } from '@glimmer/validator';
-import { $pc, isLowLevelRegister } from '@glimmer/vm';
+import { createIteratorItemRef } from '@glimmer/reference/lib/iterable';
+import { UNDEFINED_REFERENCE } from '@glimmer/reference/lib/reference';
+import { reverse } from '@glimmer/util/lib/array-utils';
+import { StackImpl as Stack } from '@glimmer/util/lib/collections';
+import { LOCAL_LOGGER } from '@glimmer/util';
+import { beginTrackFrame, endTrackFrame, resetTracking } from '@glimmer/validator/lib/tracking';
+import { $pc, isLowLevelRegister } from '@glimmer/vm/lib/registers';
 
 import type { ScopeOptions } from '../scope';
 import type { AppendingBlockList } from './element-builder';
diff --git a/packages/@glimmer/runtime/lib/vm/arguments.ts b/packages/@glimmer/runtime/lib/vm/arguments.ts
index 02ad9ab9af1..f09b81c5ead 100644
--- a/packages/@glimmer/runtime/lib/vm/arguments.ts
+++ b/packages/@glimmer/runtime/lib/vm/arguments.ts
@@ -17,14 +17,26 @@ import type {
   ScopeBlock,
   VMArguments,
 } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import type { Tag } from '@glimmer/validator';
-import { check, CheckBlockSymbolTable, CheckHandle, CheckNullable, CheckOr } from '@glimmer/debug';
-import { setLocalDebugType, unwrap } from '@glimmer/debug-util';
-import { createDebugAliasRef, UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference';
-import { dict, EMPTY_STRING_ARRAY, emptyArray, enumerate } from '@glimmer/util';
-import { CONSTANT_TAG } from '@glimmer/validator';
-import { $sp } from '@glimmer/vm';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import type { Tag } from '@glimmer/interfaces';
+import {
+  check,
+  CheckBlockSymbolTable,
+  CheckHandle,
+  CheckNullable,
+  CheckOr,
+} from '@glimmer/debug/lib/stack-check';
+import { setLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import {
+  createDebugAliasRef,
+  UNDEFINED_REFERENCE,
+  valueForRef,
+} from '@glimmer/reference/lib/reference';
+import { dict } from '@glimmer/util/lib/collections';
+import { EMPTY_STRING_ARRAY, emptyArray, enumerate } from '@glimmer/util/lib/array-utils';
+import { CONSTANT_TAG } from '@glimmer/validator/lib/validators';
+import { $sp } from '@glimmer/vm/lib/registers';
 
 import type { EvaluationStack } from './stack';
 
diff --git a/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts b/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts
index 2771ad973d3..8625d050450 100644
--- a/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts
+++ b/packages/@glimmer/runtime/lib/vm/attributes/dynamic.ts
@@ -9,8 +9,8 @@ import type {
   SimpleElement,
   TreeBuilder,
 } from '@glimmer/interfaces';
-import { NS_SVG } from '@glimmer/constants';
-import { castToBrowser } from '@glimmer/debug-util';
+import { NS_SVG } from '@glimmer/constants/lib/dom';
+import { castToBrowser } from '@glimmer/debug-util/lib/simple-cast';
 import { warnIfStyleNotTrusted } from '@glimmer/global-context';
 
 import type { MutableKey } from '../element-builder';
diff --git a/packages/@glimmer/runtime/lib/vm/content/text.ts b/packages/@glimmer/runtime/lib/vm/content/text.ts
index 1cec5a5a681..fa5658abf81 100644
--- a/packages/@glimmer/runtime/lib/vm/content/text.ts
+++ b/packages/@glimmer/runtime/lib/vm/content/text.ts
@@ -1,6 +1,6 @@
 import type { SimpleText, UpdatingOpcode } from '@glimmer/interfaces';
-import type { Reference } from '@glimmer/reference';
-import { valueForRef } from '@glimmer/reference';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { valueForRef } from '@glimmer/reference/lib/reference';
 
 import { isEmpty, isString } from '../../dom/normalize';
 
diff --git a/packages/@glimmer/runtime/lib/vm/element-builder.ts b/packages/@glimmer/runtime/lib/vm/element-builder.ts
index cfda7902ba2..1e3a21359bc 100644
--- a/packages/@glimmer/runtime/lib/vm/element-builder.ts
+++ b/packages/@glimmer/runtime/lib/vm/element-builder.ts
@@ -18,10 +18,12 @@ import type {
   SimpleText,
   TreeBuilder,
 } from '@glimmer/interfaces';
-import { expect, assert, setLocalDebugType } from '@glimmer/debug-util';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
+import { setLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
 import { destroy, registerDestructor } from '@glimmer/destroyable';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { Stack } from '@glimmer/util';
+import { StackImpl as Stack } from '@glimmer/util/lib/collections';
 
 import type { DynamicAttribute } from './attributes/dynamic';
 
diff --git a/packages/@glimmer/runtime/lib/vm/low-level.ts b/packages/@glimmer/runtime/lib/vm/low-level.ts
index f30c99c1304..a817f25548a 100644
--- a/packages/@glimmer/runtime/lib/vm/low-level.ts
+++ b/packages/@glimmer/runtime/lib/vm/low-level.ts
@@ -1,5 +1,5 @@
 import type { EvaluationContext, Nullable, RuntimeOp } from '@glimmer/interfaces';
-import type { MachineRegister } from '@glimmer/vm';
+import type { MachineRegister } from '@glimmer/vm/lib/registers';
 import {
   VM_INVOKE_STATIC_OP,
   VM_INVOKE_VIRTUAL_OP,
@@ -8,14 +8,19 @@ import {
   VM_PUSH_FRAME_OP,
   VM_RETURN_OP,
   VM_RETURN_TO_OP,
-} from '@glimmer/constants';
-import { assert } from '@glimmer/debug-util';
+} from '@glimmer/constants/lib/vm-ops';
+import assert from '@glimmer/debug-util/lib/assert';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { $fp, $pc, $ra, $sp } from '@glimmer/vm';
+import { $fp, $pc, $ra, $sp } from '@glimmer/vm/lib/registers';
 
 import type { DebugState } from '../opcodes';
 import type { VM } from './append';
 
+// Loading the VM is what creates the demand for opcode handlers — its
+// `evaluateSyscall` calls `APPEND_OPCODES.evaluate(...)`. Pull bootstrap in
+// here (rather than at the package barrel) so consumers using deep imports
+// still get every opcode handler registered before the VM runs.
+import '../bootstrap';
 import { APPEND_OPCODES } from '../opcodes';
 
 export type LowLevelRegisters = [$pc: number, $ra: number, $sp: number, $fp: number];
diff --git a/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts b/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts
index 0028ae54637..ac6ab04ae8d 100644
--- a/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts
+++ b/packages/@glimmer/runtime/lib/vm/rehydrate-builder.ts
@@ -11,9 +11,11 @@ import type {
   SimpleText,
   TreeBuilder,
 } from '@glimmer/interfaces';
-import type { Stack } from '@glimmer/util';
-import { COMMENT_NODE, ELEMENT_NODE, NS_SVG, TEXT_NODE } from '@glimmer/constants';
-import { castToBrowser, castToSimple, expect, assert } from '@glimmer/debug-util';
+import type { StackImpl as Stack } from '@glimmer/util/lib/collections';
+import { COMMENT_NODE, ELEMENT_NODE, NS_SVG, TEXT_NODE } from '@glimmer/constants/lib/dom';
+import { castToBrowser, castToSimple } from '@glimmer/debug-util/lib/simple-cast';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
 
 import { ConcreteBounds, CursorImpl } from '../bounds';
 import { NewTreeBuilder, RemoteBlock } from './element-builder';
diff --git a/packages/@glimmer/runtime/lib/vm/render-result.ts b/packages/@glimmer/runtime/lib/vm/render-result.ts
index bb2129ddfa7..32dbca888d0 100644
--- a/packages/@glimmer/runtime/lib/vm/render-result.ts
+++ b/packages/@glimmer/runtime/lib/vm/render-result.ts
@@ -6,7 +6,7 @@ import type {
   SimpleNode,
   UpdatingOpcode,
 } from '@glimmer/interfaces';
-import { unreachable } from '@glimmer/debug-util';
+import { unreachable } from '@glimmer/debug-util/lib/platform-utils';
 import { associateDestroyableChild, registerDestructor } from '@glimmer/destroyable';
 
 import { clear } from '../bounds';
diff --git a/packages/@glimmer/runtime/lib/vm/stack.ts b/packages/@glimmer/runtime/lib/vm/stack.ts
index b89cc8fbf32..9d736c28a64 100644
--- a/packages/@glimmer/runtime/lib/vm/stack.ts
+++ b/packages/@glimmer/runtime/lib/vm/stack.ts
@@ -1,6 +1,6 @@
-import { assert } from '@glimmer/debug-util';
+import assert from '@glimmer/debug-util/lib/assert';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { $fp, $pc, $sp } from '@glimmer/vm';
+import { $fp, $pc, $sp } from '@glimmer/vm/lib/registers';
 
 import type { LowLevelRegisters } from './low-level';
 
diff --git a/packages/@glimmer/runtime/lib/vm/update.ts b/packages/@glimmer/runtime/lib/vm/update.ts
index 06386416da2..92981cc0531 100644
--- a/packages/@glimmer/runtime/lib/vm/update.ts
+++ b/packages/@glimmer/runtime/lib/vm/update.ts
@@ -14,13 +14,16 @@ import type {
   UpdatingOpcode,
   UpdatingVM as IUpdatingVM,
 } from '@glimmer/interfaces';
-import type { OpaqueIterationItem, OpaqueIterator, Reference } from '@glimmer/reference';
-import { expect, unwrap } from '@glimmer/debug-util';
+import type { OpaqueIterationItem, OpaqueIterator } from '@glimmer/reference/lib/iterable';
+import type { Reference } from '@glimmer/reference/lib/reference';
+import { expect, unwrap } from '@glimmer/debug-util/lib/platform-utils';
 import { associateDestroyableChild, destroy, destroyChildren } from '@glimmer/destroyable';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
-import { updateRef, valueForRef } from '@glimmer/reference';
-import { logStep, Stack } from '@glimmer/util';
-import { debug, resetTracking } from '@glimmer/validator';
+import { updateRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { logStep } from '@glimmer/util/lib/debug-steps';
+import { StackImpl as Stack } from '@glimmer/util/lib/collections';
+import { debug } from '@glimmer/validator/lib/debug';
+import { resetTracking } from '@glimmer/validator/lib/tracking';
 
 import type { Closure } from './append';
 import type { AppendingBlockList } from './element-builder';
diff --git a/packages/@glimmer/runtime/package.json b/packages/@glimmer/runtime/package.json
index 02fb70c80a7..2a0f295272f 100644
--- a/packages/@glimmer/runtime/package.json
+++ b/packages/@glimmer/runtime/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/runtime"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/syntax/lib/parser.ts b/packages/@glimmer/syntax/lib/parser.ts
index 1f2164f2ff7..7b16e7cba85 100644
--- a/packages/@glimmer/syntax/lib/parser.ts
+++ b/packages/@glimmer/syntax/lib/parser.ts
@@ -1,6 +1,8 @@
 import type { Nullable } from '@glimmer/interfaces';
-import { asPresentArray, expect, getLast, assert, unwrap } from '@glimmer/debug-util';
-import { assign } from '@glimmer/util';
+import { asPresentArray, getLast } from '@glimmer/debug-util/lib/present';
+import { expect, unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
+import { assign } from '@glimmer/util/lib/object-utils';
 import {
   EntityParser,
   EventedTokenizer,
diff --git a/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts b/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts
index 3c568b70fe7..d074656f662 100644
--- a/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts
+++ b/packages/@glimmer/syntax/lib/parser/handlebars-node-visitors.ts
@@ -1,7 +1,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
 import type { Nullable, Recast } from '@glimmer/interfaces';
 import type { TokenizerState } from 'simple-html-tokenizer';
-import { getLast, isPresentArray, assert, unwrap } from '@glimmer/debug-util';
+import { getLast, isPresentArray } from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
 
 import type { ParserNodeBuilder, StartTag } from '../parser';
 import type * as src from '../source/api';
diff --git a/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts b/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts
index 1e0efff0155..acb9299b8d6 100644
--- a/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts
+++ b/packages/@glimmer/syntax/lib/parser/tokenizer-event-handlers.ts
@@ -6,9 +6,9 @@ import {
   getFirst,
   getLast,
   isPresentArray,
-  assert,
-} from '@glimmer/debug-util';
-import { assign } from '@glimmer/util';
+} from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { assign } from '@glimmer/util/lib/object-utils';
 import { parse, parseWithoutProcessing } from '@handlebars/parser';
 import { EntityParser } from 'simple-html-tokenizer';
 
diff --git a/packages/@glimmer/syntax/lib/source/loc/match.ts b/packages/@glimmer/syntax/lib/source/loc/match.ts
index 07a7dc6b8f2..1f26a035298 100644
--- a/packages/@glimmer/syntax/lib/source/loc/match.ts
+++ b/packages/@glimmer/syntax/lib/source/loc/match.ts
@@ -1,4 +1,5 @@
-import { isPresentArray, assert } from '@glimmer/debug-util';
+import { isPresentArray } from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
 
 import type { CharOffsetKind, HbsPositionKind, OffsetKind } from './kinds';
 import type { CharPosition, HbsPosition, InvisiblePosition, PositionData } from './offset';
diff --git a/packages/@glimmer/syntax/lib/source/loc/span.ts b/packages/@glimmer/syntax/lib/source/loc/span.ts
index 6168c1231bd..3beff4c394e 100644
--- a/packages/@glimmer/syntax/lib/source/loc/span.ts
+++ b/packages/@glimmer/syntax/lib/source/loc/span.ts
@@ -1,4 +1,4 @@
-import { assert } from '@glimmer/debug-util';
+import assert from '@glimmer/debug-util/lib/assert';
 import { LOCAL_DEBUG } from '@glimmer/local-debug-flags';
 import { assertNever } from '@glimmer/util';
 
diff --git a/packages/@glimmer/syntax/lib/source/location.ts b/packages/@glimmer/syntax/lib/source/location.ts
index 1e2bc3129fc..9adaa277536 100644
--- a/packages/@glimmer/syntax/lib/source/location.ts
+++ b/packages/@glimmer/syntax/lib/source/location.ts
@@ -1,5 +1,5 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { isPresentArray } from '@glimmer/debug-util';
+import { isPresentArray } from '@glimmer/debug-util/lib/present';
 
 import type { SourceSpan } from './span';
 
diff --git a/packages/@glimmer/syntax/lib/source/source.ts b/packages/@glimmer/syntax/lib/source/source.ts
index 822dcccf2cc..68db73bfd39 100644
--- a/packages/@glimmer/syntax/lib/source/source.ts
+++ b/packages/@glimmer/syntax/lib/source/source.ts
@@ -1,6 +1,7 @@
 import { DEBUG } from '@glimmer/env';
 import type { Nullable } from '@glimmer/interfaces';
-import { assert, setLocalDebugType } from '@glimmer/debug-util';
+import assert from '@glimmer/debug-util/lib/assert';
+import { setLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
 
 import type { PrecompileOptions } from '../parser/tokenizer-event-handlers';
 import type { SourceLocation, SourcePosition } from './location';
diff --git a/packages/@glimmer/syntax/lib/source/span-list.ts b/packages/@glimmer/syntax/lib/source/span-list.ts
index fb50c6c5f83..adc0e21e428 100644
--- a/packages/@glimmer/syntax/lib/source/span-list.ts
+++ b/packages/@glimmer/syntax/lib/source/span-list.ts
@@ -1,5 +1,5 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { getFirst, getLast, isPresentArray } from '@glimmer/debug-util';
+import { getFirst, getLast, isPresentArray } from '@glimmer/debug-util/lib/present';
 
 import type { LocatedWithOptionalSpan, LocatedWithSpan } from './location';
 import type { SourceOffset } from './span';
diff --git a/packages/@glimmer/syntax/lib/symbol-table.ts b/packages/@glimmer/syntax/lib/symbol-table.ts
index 84515e2194b..6f44e9b2160 100644
--- a/packages/@glimmer/syntax/lib/symbol-table.ts
+++ b/packages/@glimmer/syntax/lib/symbol-table.ts
@@ -1,7 +1,8 @@
 import type { Core, Dict } from '@glimmer/interfaces';
-import { setLocalDebugType, unwrap } from '@glimmer/debug-util';
-import { dict } from '@glimmer/util';
-import { SexpOpcodes } from '@glimmer/wire-format';
+import { setLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import { dict } from '@glimmer/util/lib/collections';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 import * as ASTv2 from './v2/api';
 
diff --git a/packages/@glimmer/syntax/lib/traversal/traverse.ts b/packages/@glimmer/syntax/lib/traversal/traverse.ts
index cc91b3d3218..980139b1b74 100644
--- a/packages/@glimmer/syntax/lib/traversal/traverse.ts
+++ b/packages/@glimmer/syntax/lib/traversal/traverse.ts
@@ -1,4 +1,5 @@
-import { deprecate, unwrap } from '@glimmer/debug-util';
+import { deprecate } from '@glimmer/debug-util/lib/assert';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
 
 import type * as ASTv1 from '../v1/api';
 import type { VisitorKey, VisitorKeys } from '../v1/visitor-keys';
diff --git a/packages/@glimmer/syntax/lib/v1/legacy-interop.ts b/packages/@glimmer/syntax/lib/v1/legacy-interop.ts
index 27225acfc62..f2b51181562 100644
--- a/packages/@glimmer/syntax/lib/v1/legacy-interop.ts
+++ b/packages/@glimmer/syntax/lib/v1/legacy-interop.ts
@@ -1,5 +1,6 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { asPresentArray, deprecate } from '@glimmer/debug-util';
+import { asPresentArray } from '@glimmer/debug-util/lib/present';
+import { deprecate } from '@glimmer/debug-util/lib/assert';
 
 import type * as ASTv1 from './nodes-v1';
 
diff --git a/packages/@glimmer/syntax/lib/v1/parser-builders.ts b/packages/@glimmer/syntax/lib/v1/parser-builders.ts
index be683407c3d..b63e817b8c6 100644
--- a/packages/@glimmer/syntax/lib/v1/parser-builders.ts
+++ b/packages/@glimmer/syntax/lib/v1/parser-builders.ts
@@ -1,5 +1,5 @@
 import type { Nullable, Optional, PresentArray } from '@glimmer/interfaces';
-import { assert } from '@glimmer/debug-util';
+import assert from '@glimmer/debug-util/lib/assert';
 
 import type * as ASTv1 from './api';
 
diff --git a/packages/@glimmer/syntax/lib/v1/public-builders.ts b/packages/@glimmer/syntax/lib/v1/public-builders.ts
index 931b4f9301b..b91b75e0de6 100644
--- a/packages/@glimmer/syntax/lib/v1/public-builders.ts
+++ b/packages/@glimmer/syntax/lib/v1/public-builders.ts
@@ -1,5 +1,6 @@
 import type { Dict, Maybe, Nullable } from '@glimmer/interfaces';
-import { asPresentArray, deprecate, isPresentArray, assert } from '@glimmer/debug-util';
+import { asPresentArray, isPresentArray } from '@glimmer/debug-util/lib/present';
+import { deprecate, default as assert } from '@glimmer/debug-util/lib/assert';
 
 import type { SourceLocation, SourcePosition } from '../source/location';
 import type * as ASTv1 from './api';
diff --git a/packages/@glimmer/syntax/lib/v2/builders.ts b/packages/@glimmer/syntax/lib/v2/builders.ts
index 0b31cab5fb6..609a3b1cda2 100644
--- a/packages/@glimmer/syntax/lib/v2/builders.ts
+++ b/packages/@glimmer/syntax/lib/v2/builders.ts
@@ -1,6 +1,7 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { assertPresentArray, assert } from '@glimmer/debug-util';
-import { assign } from '@glimmer/util';
+import { assertPresentArray } from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { assign } from '@glimmer/util/lib/object-utils';
 
 import type { SourceSpan } from '../source/span';
 import type { BlockSymbolTable, ProgramSymbolTable, SymbolTable } from '../symbol-table';
diff --git a/packages/@glimmer/syntax/lib/v2/normalize.ts b/packages/@glimmer/syntax/lib/v2/normalize.ts
index a8f8d795a0e..0b24ecaecc2 100644
--- a/packages/@glimmer/syntax/lib/v2/normalize.ts
+++ b/packages/@glimmer/syntax/lib/v2/normalize.ts
@@ -1,6 +1,7 @@
 import type { PresentArray } from '@glimmer/interfaces';
-import { asPresentArray, isPresentArray, assert } from '@glimmer/debug-util';
-import { assign } from '@glimmer/util';
+import { asPresentArray, isPresentArray } from '@glimmer/debug-util/lib/present';
+import assert from '@glimmer/debug-util/lib/assert';
+import { assign } from '@glimmer/util/lib/object-utils';
 
 import type {
   PrecompileOptions,
diff --git a/packages/@glimmer/syntax/lib/v2/objects/node.ts b/packages/@glimmer/syntax/lib/v2/objects/node.ts
index b5596015b4a..862ae3fc1cb 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/node.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/node.ts
@@ -1,5 +1,5 @@
-import { setLocalDebugType } from '@glimmer/debug-util';
-import { assign } from '@glimmer/util';
+import { setLocalDebugType } from '@glimmer/debug-util/lib/debug-brand';
+import { assign } from '@glimmer/util/lib/object-utils';
 
 import type { SourceSpan } from '../../source/span';
 
diff --git a/packages/@glimmer/syntax/lib/v2/objects/resolution.ts b/packages/@glimmer/syntax/lib/v2/objects/resolution.ts
index 6be6345ddd3..c1e344dab0d 100644
--- a/packages/@glimmer/syntax/lib/v2/objects/resolution.ts
+++ b/packages/@glimmer/syntax/lib/v2/objects/resolution.ts
@@ -6,7 +6,7 @@
  */
 
 import type { GetContextualFreeOpcode } from '@glimmer/interfaces';
-import { SexpOpcodes } from '@glimmer/wire-format';
+import { opcodes as SexpOpcodes } from '@glimmer/wire-format/lib/opcodes';
 
 import type { FreeVarNamespace } from './constants';
 
diff --git a/packages/@glimmer/syntax/package.json b/packages/@glimmer/syntax/package.json
index 886a9b99963..d31efaf0837 100644
--- a/packages/@glimmer/syntax/package.json
+++ b/packages/@glimmer/syntax/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/syntax"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "repo-meta": {
     "supportcjs": true
   },
diff --git a/packages/@glimmer/tracking/index.ts b/packages/@glimmer/tracking/index.ts
index 629afe60472..8663169165b 100644
--- a/packages/@glimmer/tracking/index.ts
+++ b/packages/@glimmer/tracking/index.ts
@@ -1,4 +1,5 @@
-export { tracked, cached } from '@ember/-internals/metal';
+export { tracked } from '@ember/-internals/metal/lib/tracked';
+export { cached } from '@ember/-internals/metal/lib/cached';
 
 /**
   In order to tell Ember a value might change, we need to mark it as trackable.
diff --git a/packages/@glimmer/tracking/package.json b/packages/@glimmer/tracking/package.json
index 988575e68ac..82d03c11687 100644
--- a/packages/@glimmer/tracking/package.json
+++ b/packages/@glimmer/tracking/package.json
@@ -4,9 +4,11 @@
   "type": "module",
   "exports": {
     ".": "./index.ts",
-    "./primitives/cache": "./primitives/cache.ts"
+    "./primitives/cache": "./primitives/cache.ts",
+    "./*": "./*.ts"
   },
   "dependencies": {
-    "@ember/-internals": "workspace:*"
+    "@ember/-internals": "workspace:*",
+    "@glimmer/validator": "workspace:*"
   }
-}
\ No newline at end of file
+}
diff --git a/packages/@glimmer/tracking/primitives/cache.ts b/packages/@glimmer/tracking/primitives/cache.ts
index 29d6d20a0a5..772099baf8d 100644
--- a/packages/@glimmer/tracking/primitives/cache.ts
+++ b/packages/@glimmer/tracking/primitives/cache.ts
@@ -1 +1 @@
-export { createCache, getValue, isConst } from '@ember/-internals/metal';
+export { createCache, getValue, isConst } from '@glimmer/validator/lib/tracking';
diff --git a/packages/@glimmer/util/lib/collections.ts b/packages/@glimmer/util/lib/collections.ts
index 4a77ea3f1b4..f083c7f70e6 100644
--- a/packages/@glimmer/util/lib/collections.ts
+++ b/packages/@glimmer/util/lib/collections.ts
@@ -1,5 +1,6 @@
 import type { Dict, Nullable, Stack } from '@glimmer/interfaces';
-import { getLast, unwrap } from '@glimmer/debug-util';
+import { getLast } from '@glimmer/debug-util/lib/present';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
 
 export function dict<T = unknown>(): Dict<T> {
   return Object.create(null) as Dict<T>;
diff --git a/packages/@glimmer/util/lib/debug-steps.ts b/packages/@glimmer/util/lib/debug-steps.ts
index e3798887f0c..b0d29420f36 100644
--- a/packages/@glimmer/util/lib/debug-steps.ts
+++ b/packages/@glimmer/util/lib/debug-steps.ts
@@ -1,6 +1,7 @@
 /// <reference types="qunit" />
 
-import { expect, assert } from '@glimmer/debug-util';
+import { expect } from '@glimmer/debug-util/lib/platform-utils';
+import assert from '@glimmer/debug-util/lib/assert';
 import { LOCAL_DEBUG, LOCAL_TRACE_LOGGING } from '@glimmer/local-debug-flags';
 
 import { LOCAL_LOGGER } from './local-logger';
diff --git a/packages/@glimmer/util/lib/string.ts b/packages/@glimmer/util/lib/string.ts
index aae096250de..8de6c22c751 100644
--- a/packages/@glimmer/util/lib/string.ts
+++ b/packages/@glimmer/util/lib/string.ts
@@ -1,4 +1,4 @@
-import { getFirst, getLast, isPresentArray } from '@glimmer/debug-util';
+import { getFirst, getLast, isPresentArray } from '@glimmer/debug-util/lib/present';
 
 import { enumerate } from './array-utils';
 
diff --git a/packages/@glimmer/util/package.json b/packages/@glimmer/util/package.json
index acc2287f91a..3c9506a44b4 100644
--- a/packages/@glimmer/util/package.json
+++ b/packages/@glimmer/util/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/util"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/validator/lib/debug.ts b/packages/@glimmer/validator/lib/debug.ts
index 3578a060562..154acaee33a 100644
--- a/packages/@glimmer/validator/lib/debug.ts
+++ b/packages/@glimmer/validator/lib/debug.ts
@@ -1,7 +1,7 @@
 import { DEBUG } from '@glimmer/env';
 /* eslint-disable @typescript-eslint/no-non-null-assertion -- @fixme */
 import type { Tag } from '@glimmer/interfaces';
-import { asPresentArray, getLast } from '@glimmer/debug-util';
+import { asPresentArray, getLast } from '@glimmer/debug-util/lib/present';
 import { assert } from '@glimmer/global-context';
 
 interface DebugTransaction {
diff --git a/packages/@glimmer/validator/package.json b/packages/@glimmer/validator/package.json
index 647ea1e3650..fdcfc25357e 100644
--- a/packages/@glimmer/validator/package.json
+++ b/packages/@glimmer/validator/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/validator"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/vm/package.json b/packages/@glimmer/vm/package.json
index f2bb520fa06..2baa6515d0e 100644
--- a/packages/@glimmer/vm/package.json
+++ b/packages/@glimmer/vm/package.json
@@ -8,7 +8,10 @@
     "directory": "packages/@glimmer/vm"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/packages/@glimmer/wire-format/package.json b/packages/@glimmer/wire-format/package.json
index 5bfb6ba257b..1dc8681f15b 100644
--- a/packages/@glimmer/wire-format/package.json
+++ b/packages/@glimmer/wire-format/package.json
@@ -9,7 +9,10 @@
     "directory": "packages/@glimmer/wire-format"
   },
   "type": "module",
-  "exports": "./index.ts",
+  "exports": {
+    ".": "./index.ts",
+    "./*": "./*.ts"
+  },
   "publishConfig": {
     "access": "public",
     "exports": {
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index cb109a206f1..16673617f9a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -508,6 +508,9 @@ importers:
       '@glimmer/env':
         specifier: workspace:*
         version: link:../../@glimmer/env
+      '@glimmer/interfaces':
+        specifier: workspace:*
+        version: link:../../@glimmer/interfaces
       '@glimmer/manager':
         specifier: workspace:*
         version: link:../../@glimmer/manager
@@ -884,6 +887,9 @@ importers:
       '@glimmer/env':
         specifier: workspace:*
         version: link:../../@glimmer/env
+      '@glimmer/interfaces':
+        specifier: workspace:*
+        version: link:../../@glimmer/interfaces
       '@glimmer/manager':
         specifier: workspace:*
         version: link:../../@glimmer/manager
@@ -943,8 +949,8 @@ importers:
   packages/@ember/reactive:
     dependencies:
       '@glimmer/validator':
-        specifier: 0.95.0
-        version: 0.95.0
+        specifier: workspace:*
+        version: link:../../@glimmer/validator
 
   packages/@ember/renderer:
     dependencies:
@@ -1185,8 +1191,8 @@ importers:
   packages/@ember/template-factory:
     dependencies:
       '@glimmer/opcode-compiler':
-        specifier: 0.94.10
-        version: 0.94.10
+        specifier: workspace:*
+        version: link:../../@glimmer/opcode-compiler
 
   packages/@ember/test:
     dependencies:
@@ -2209,6 +2215,9 @@ importers:
       '@ember/-internals':
         specifier: workspace:*
         version: link:../../@ember/-internals
+      '@glimmer/validator':
+        specifier: workspace:*
+        version: link:../validator
 
   packages/@glimmer/util:
     dependencies:
@@ -4292,39 +4301,21 @@ packages:
     resolution: {integrity: sha512-zFZFaMbWy+9WOcDg/kCgrkGgqkLT39EE4FgyFD0MIkQO5coQsrRZyLsiBu1tbchyM+8hT8jAv+EQVUd8u+MdSQ==}
     engines: {node: '>= 18'}
 
-  '@glimmer/destroyable@0.94.8':
-    resolution: {integrity: sha512-IWNz34Q5IYnh20M/3xVv9jIdCATQyaO+8sdUSyUqiz1bAblW5vTXUNXn3uFzGF+CnP6ZSgPxHN/c1sNMAh+lAA==}
-
-  '@glimmer/encoder@0.93.8':
-    resolution: {integrity: sha512-G7ZbC+T+rn7UliG8Y3cn7SIACh7K5HgCxgFhJxU15HtmTUObs52mVR1SyhUBsbs86JHlCqaGguKE1WqP1jt+2g==}
-
   '@glimmer/env@0.1.7':
     resolution: {integrity: sha512-JKF/a9I9jw6fGoz8kA7LEQslrwJ5jms5CXhu/aqkBWk+PmZ6pTl8mlb/eJ/5ujBGTiQzBhy5AIWF712iA+4/mw==}
 
   '@glimmer/global-context@0.84.3':
     resolution: {integrity: sha512-8Oy9Wg5IZxMEeAnVmzD2NkObf89BeHoFSzJgJROE/deutd3rxg83mvlOez4zBBGYwnTb+VGU2LYRpet92egJjA==}
 
-  '@glimmer/global-context@0.93.4':
-    resolution: {integrity: sha512-Yw9xkDReAcC5oS/hY3PjGrFKRygYFA4pdO7tvuxReoVOyUtjoBOAwHJUileiElERDdMWIMfoLema8Td1mqkjhA==}
-
   '@glimmer/interfaces@0.84.3':
     resolution: {integrity: sha512-dk32ykoNojt0mvEaIW6Vli5MGTbQo58uy3Epj7ahCgTHmWOKuw/0G83f2UmFprRwFx689YTXG38I/vbpltEjzg==}
 
   '@glimmer/interfaces@0.94.6':
     resolution: {integrity: sha512-sp/1WePvB/8O+jrcUHwjboNPTKrdGicuHKA9T/lh0vkYK2qM5Xz4i25lQMQ38tEMiw7KixrjHiTUiaXRld+IwA==}
 
-  '@glimmer/manager@0.94.10':
-    resolution: {integrity: sha512-Hqi92t6vtVg4nSRGWTvCJ+0Vg3iF1tiTG9RLzuUtZac7DIAzuQAxjhGbtu82miT+liCqU+MFmB3nkfNH0Zz74g==}
-
-  '@glimmer/opcode-compiler@0.94.10':
-    resolution: {integrity: sha512-KYsaODjkgtpUzMR1chyI0IRcvo4ewnjW8Dy+5833+OIG7rx6INl7HvKtooLzjHv+uJOZ74fd/s/0XfaY6eNEww==}
-
   '@glimmer/reference@0.84.3':
     resolution: {integrity: sha512-lV+p/aWPVC8vUjmlvYVU7WQJsLh319SdXuAWoX/SE3pq340BJlAJiEcAc6q52y9JNhT57gMwtjMX96W5Xcx/qw==}
 
-  '@glimmer/reference@0.94.9':
-    resolution: {integrity: sha512-qlgTYxgEOpgxuyb13u2qwqhibpfktlk08F+nfwuNxtuhodsItBi3YxjFMPrVP0zOjTnhUObR8OYtMsD5WFOddA==}
-
   '@glimmer/syntax@0.84.3':
     resolution: {integrity: sha512-ioVbTic6ZisLxqTgRBL2PCjYZTFIwobifCustrozRU2xGDiYvVIL0vt25h2c1ioDsX59UgVlDkIK4YTAQQSd2A==}
 
@@ -4346,12 +4337,6 @@ packages:
   '@glimmer/validator@0.84.3':
     resolution: {integrity: sha512-RTBV4TokUB0vI31UC7ikpV7lOYpWUlyqaKV//pRC4pexYMlmqnVhkFrdiimB/R1XyNdUOQUmnIAcdic39NkbhQ==}
 
-  '@glimmer/validator@0.95.0':
-    resolution: {integrity: sha512-xF3K5voKeRqhONztfMHDd2wHDYD6UUI9pFPd+RMGtW6DXYv31G0zUm2pGsOwQ9dyNeE6khaXy7e3FtNjDrSmvQ==}
-
-  '@glimmer/vm@0.94.8':
-    resolution: {integrity: sha512-0E8BVNRE/1qlK9OQRUmGlQXwWmoco7vL3yIyLZpTWhbv22C1zEcM826wQT3ioaoUQSlvRsKKH6IEEUal2d3wxQ==}
-
   '@glimmer/wire-format@0.94.8':
     resolution: {integrity: sha512-A+Cp5m6vZMAEu0Kg/YwU2dJZXyYxVJs2zI57d3CP6NctmX7FsT8WjViiRUmt5abVmMmRH5b8BUovqY6GSMAdrw==}
 
@@ -10591,7 +10576,6 @@ packages:
     engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
     deprecated: |-
       You or someone you depend on is using Q, the JavaScript Promise library that gave JavaScript developers strong feelings about promises. They can almost certainly migrate to the native JavaScript promise now. Thank you literally everyone for joining me in this bet against the odds. Be excellent to each other.
-
       (For a CapTP with native promises, see @endo/eventual-send and @endo/captp)
 
   qified@0.9.0:
@@ -14020,24 +14004,12 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@glimmer/destroyable@0.94.8':
-    dependencies:
-      '@glimmer/global-context': 0.93.4
-      '@glimmer/interfaces': 0.94.6
-
-  '@glimmer/encoder@0.93.8':
-    dependencies:
-      '@glimmer/interfaces': 0.94.6
-      '@glimmer/vm': 0.94.8
-
   '@glimmer/env@0.1.7': {}
 
   '@glimmer/global-context@0.84.3':
     dependencies:
       '@glimmer/env': 0.1.7
 
-  '@glimmer/global-context@0.93.4': {}
-
   '@glimmer/interfaces@0.84.3':
     dependencies:
       '@simple-dom/interface': 1.4.0
@@ -14047,25 +14019,6 @@ snapshots:
       '@simple-dom/interface': 1.4.0
       type-fest: 4.41.0
 
-  '@glimmer/manager@0.94.10':
-    dependencies:
-      '@glimmer/destroyable': 0.94.8
-      '@glimmer/global-context': 0.93.4
-      '@glimmer/interfaces': 0.94.6
-      '@glimmer/reference': 0.94.9
-      '@glimmer/util': 0.94.8
-      '@glimmer/validator': 0.95.0
-      '@glimmer/vm': 0.94.8
-
-  '@glimmer/opcode-compiler@0.94.10':
-    dependencies:
-      '@glimmer/encoder': 0.93.8
-      '@glimmer/interfaces': 0.94.6
-      '@glimmer/manager': 0.94.10
-      '@glimmer/util': 0.94.8
-      '@glimmer/vm': 0.94.8
-      '@glimmer/wire-format': 0.94.8
-
   '@glimmer/reference@0.84.3':
     dependencies:
       '@glimmer/env': 0.1.7
@@ -14074,13 +14027,6 @@ snapshots:
       '@glimmer/util': 0.84.3
       '@glimmer/validator': 0.84.3
 
-  '@glimmer/reference@0.94.9':
-    dependencies:
-      '@glimmer/global-context': 0.93.4
-      '@glimmer/interfaces': 0.94.6
-      '@glimmer/util': 0.94.8
-      '@glimmer/validator': 0.95.0
-
   '@glimmer/syntax@0.84.3':
     dependencies:
       '@glimmer/interfaces': 0.84.3
@@ -14118,15 +14064,6 @@ snapshots:
       '@glimmer/env': 0.1.7
       '@glimmer/global-context': 0.84.3
 
-  '@glimmer/validator@0.95.0':
-    dependencies:
-      '@glimmer/global-context': 0.93.4
-      '@glimmer/interfaces': 0.94.6
-
-  '@glimmer/vm@0.94.8':
-    dependencies:
-      '@glimmer/interfaces': 0.94.6
-
   '@glimmer/wire-format@0.94.8':
     dependencies:
       '@glimmer/interfaces': 0.94.6
diff --git a/rollup.config.mjs b/rollup.config.mjs
index ceee7e37ab1..585624c1861 100644
--- a/rollup.config.mjs
+++ b/rollup.config.mjs
@@ -100,6 +100,9 @@ function sharedESMConfig({ input, debugMacrosMode, includePackageMeta = false })
   return {
     onLog: handleRollupWarnings,
     input,
+    treeshake: {
+      moduleSideEffects: moduleHasSideEffects,
+    },
     output: {
       format: 'es',
       dir: outputDir,
@@ -111,6 +114,27 @@ function sharedESMConfig({ input, debugMacrosMode, includePackageMeta = false })
   };
 }
 
+// Tell rollup which source files actually have top-level side effects.
+// Anything matched by `pure` is treated as side-effect-free: unused
+// imports of it can be dropped rather than carried into a downstream
+// shared chunk. The packages here are either explicitly
+// `sideEffects: false` in their own package.json (which gets lost once
+// files are co-bundled into shared chunks across packages) or are pure
+// utility / data-shape packages with no top-level mutation.
+function moduleHasSideEffects(id) {
+  if (!id.includes('/packages/')) return true;
+  for (const pkg of PURE_INTERNAL_PACKAGES) {
+    if (id.includes(`/packages/${pkg}/`)) return false;
+  }
+  return true;
+}
+
+const PURE_INTERNAL_PACKAGES = [
+  '@glimmer/debug',
+  '@glimmer/debug-util',
+  '@glimmer/local-debug-flags',
+];
+
 function glimmerSyntaxESM() {
   return {
     onLog: handleRollupWarnings,