diff --git a/build-metadata.json b/build-metadata.json
new file mode 100644
index 00000000000..2432bd551ba
--- /dev/null
+++ b/build-metadata.json
@@ -0,0 +1,6 @@
+{
+  "version": "7.1.0-alpha.1.nvp-explore-true-minimal-app+1e7e9c62",
+  "buildType": "nvp-explore-true-minimal-app",
+  "SHA": "1e7e9c62837e9784ef6e4309923268bdc934451d",
+  "assetPath": "/nvp-explore-true-minimal-app/shas/1e7e9c62837e9784ef6e4309923268bdc934451d.tgz"
+}
\ No newline at end of file
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..fe85723b1e3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "7.1.0-alpha.1",
+  "version": "7.1.0-alpha.1.nvp-explore-true-minimal-app+1e7e9c62",
   "description": "A JavaScript framework for creating ambitious web applications",
   "keywords": [
     "ember-addon"
@@ -22,6 +22,39 @@
   },
   "license": "MIT",
   "main": "lib/index.js",
+  "sideEffects": [
+    "./dist/*/packages/@ember/-internals/glimmer/lib/environment.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/renderer.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/setup-registry.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/syntax/register-routing-keywords.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/helper.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/component.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/components/*.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/component-managers/*.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/modifiers/*.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/helpers/component.js",
+    "./dist/*/packages/@ember/-internals/glimmer/lib/templates/*.js",
+    "./dist/*/packages/@ember/object/index.js",
+    "./dist/*/packages/@ember/object/core.js",
+    "./dist/*/packages/@ember/object/mixin.js",
+    "./dist/*/packages/@ember/object/proxy.js",
+    "./dist/*/packages/@ember/object/observable.js",
+    "./dist/*/packages/@ember/-internals/runtime/lib/mixins/*.js",
+    "./dist/*/packages/@ember/-internals/views/lib/views/*.js",
+    "./dist/*/packages/@ember/-internals/views/lib/mixins/*.js",
+    "./dist/*/packages/@ember/-internals/views/lib/system/event_dispatcher.js",
+    "./dist/*/packages/@ember/array/index.js",
+    "./dist/*/packages/@ember/array/proxy.js",
+    "./dist/*/packages/@ember/array/mutable.js",
+    "./dist/*/packages/@ember/enumerable/*.js",
+    "./dist/*/packages/@ember/controller/index.js",
+    "./dist/*/packages/@ember/service/index.js",
+    "./dist/*/packages/@ember/routing/**/*.js",
+    "./dist/*/packages/@ember/application/**/*.js",
+    "./dist/*/packages/@ember/engine/**/*.js",
+    "./dist/*/packages/ember/version.js",
+    "./dist/*/packages/ember-testing/**/*.js"
+  ],
   "files": [
     "build-metadata.json",
     "blueprints",
@@ -177,6 +210,57 @@
       "@ember/-internals/environment/index.js": "ember-source/@ember/-internals/environment/index.js",
       "@ember/-internals/error-handling/index.js": "ember-source/@ember/-internals/error-handling/index.js",
       "@ember/-internals/glimmer/index.js": "ember-source/@ember/-internals/glimmer/index.js",
+      "@ember/-internals/glimmer/lib/classic-helper-symbol.js": "ember-source/@ember/-internals/glimmer/lib/classic-helper-symbol.js",
+      "@ember/-internals/glimmer/lib/component-managers/curly-symbols.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/curly-symbols.js",
+      "@ember/-internals/glimmer/lib/component-managers/curly.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/curly.js",
+      "@ember/-internals/glimmer/lib/component-managers/mount.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/mount.js",
+      "@ember/-internals/glimmer/lib/component-managers/outlet.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/outlet.js",
+      "@ember/-internals/glimmer/lib/component-managers/root.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/root.js",
+      "@ember/-internals/glimmer/lib/component-managers/route-template.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/route-template.js",
+      "@ember/-internals/glimmer/lib/component-managers/unwrap-template.js": "ember-source/@ember/-internals/glimmer/lib/component-managers/unwrap-template.js",
+      "@ember/-internals/glimmer/lib/component.js": "ember-source/@ember/-internals/glimmer/lib/component.js",
+      "@ember/-internals/glimmer/lib/components/abstract-input.js": "ember-source/@ember/-internals/glimmer/lib/components/abstract-input.js",
+      "@ember/-internals/glimmer/lib/components/input.js": "ember-source/@ember/-internals/glimmer/lib/components/input.js",
+      "@ember/-internals/glimmer/lib/components/internal.js": "ember-source/@ember/-internals/glimmer/lib/components/internal.js",
+      "@ember/-internals/glimmer/lib/components/link-to.js": "ember-source/@ember/-internals/glimmer/lib/components/link-to.js",
+      "@ember/-internals/glimmer/lib/components/textarea.js": "ember-source/@ember/-internals/glimmer/lib/components/textarea.js",
+      "@ember/-internals/glimmer/lib/dom.js": "ember-source/@ember/-internals/glimmer/lib/dom.js",
+      "@ember/-internals/glimmer/lib/environment.js": "ember-source/@ember/-internals/glimmer/lib/environment.js",
+      "@ember/-internals/glimmer/lib/helper.js": "ember-source/@ember/-internals/glimmer/lib/helper.js",
+      "@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.js": "ember-source/@ember/-internals/glimmer/lib/helpers/-disallow-dynamic-resolution.js",
+      "@ember/-internals/glimmer/lib/helpers/-in-element-null-check.js": "ember-source/@ember/-internals/glimmer/lib/helpers/-in-element-null-check.js",
+      "@ember/-internals/glimmer/lib/helpers/-normalize-class.js": "ember-source/@ember/-internals/glimmer/lib/helpers/-normalize-class.js",
+      "@ember/-internals/glimmer/lib/helpers/-resolve.js": "ember-source/@ember/-internals/glimmer/lib/helpers/-resolve.js",
+      "@ember/-internals/glimmer/lib/helpers/-track-array.js": "ember-source/@ember/-internals/glimmer/lib/helpers/-track-array.js",
+      "@ember/-internals/glimmer/lib/helpers/each-in.js": "ember-source/@ember/-internals/glimmer/lib/helpers/each-in.js",
+      "@ember/-internals/glimmer/lib/helpers/element.js": "ember-source/@ember/-internals/glimmer/lib/helpers/element.js",
+      "@ember/-internals/glimmer/lib/helpers/internal-helper.js": "ember-source/@ember/-internals/glimmer/lib/helpers/internal-helper.js",
+      "@ember/-internals/glimmer/lib/helpers/mut.js": "ember-source/@ember/-internals/glimmer/lib/helpers/mut.js",
+      "@ember/-internals/glimmer/lib/helpers/readonly.js": "ember-source/@ember/-internals/glimmer/lib/helpers/readonly.js",
+      "@ember/-internals/glimmer/lib/helpers/unbound.js": "ember-source/@ember/-internals/glimmer/lib/helpers/unbound.js",
+      "@ember/-internals/glimmer/lib/helpers/unique-id.js": "ember-source/@ember/-internals/glimmer/lib/helpers/unique-id.js",
+      "@ember/-internals/glimmer/lib/renderer.js": "ember-source/@ember/-internals/glimmer/lib/renderer.js",
+      "@ember/-internals/glimmer/lib/resolver.js": "ember-source/@ember/-internals/glimmer/lib/resolver.js",
+      "@ember/-internals/glimmer/lib/setup-registry.js": "ember-source/@ember/-internals/glimmer/lib/setup-registry.js",
+      "@ember/-internals/glimmer/lib/syntax/mount.js": "ember-source/@ember/-internals/glimmer/lib/syntax/mount.js",
+      "@ember/-internals/glimmer/lib/syntax/outlet.js": "ember-source/@ember/-internals/glimmer/lib/syntax/outlet.js",
+      "@ember/-internals/glimmer/lib/syntax/register-routing-keywords.js": "ember-source/@ember/-internals/glimmer/lib/syntax/register-routing-keywords.js",
+      "@ember/-internals/glimmer/lib/template.js": "ember-source/@ember/-internals/glimmer/lib/template.js",
+      "@ember/-internals/glimmer/lib/template_registry.js": "ember-source/@ember/-internals/glimmer/lib/template_registry.js",
+      "@ember/-internals/glimmer/lib/templates/input.js": "ember-source/@ember/-internals/glimmer/lib/templates/input.js",
+      "@ember/-internals/glimmer/lib/templates/link-to.js": "ember-source/@ember/-internals/glimmer/lib/templates/link-to.js",
+      "@ember/-internals/glimmer/lib/templates/outlet.js": "ember-source/@ember/-internals/glimmer/lib/templates/outlet.js",
+      "@ember/-internals/glimmer/lib/templates/root.js": "ember-source/@ember/-internals/glimmer/lib/templates/root.js",
+      "@ember/-internals/glimmer/lib/templates/textarea.js": "ember-source/@ember/-internals/glimmer/lib/templates/textarea.js",
+      "@ember/-internals/glimmer/lib/utils/bindings.js": "ember-source/@ember/-internals/glimmer/lib/utils/bindings.js",
+      "@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.js": "ember-source/@ember/-internals/glimmer/lib/utils/curly-component-state-bucket.js",
+      "@ember/-internals/glimmer/lib/utils/iterator.js": "ember-source/@ember/-internals/glimmer/lib/utils/iterator.js",
+      "@ember/-internals/glimmer/lib/utils/managers.js": "ember-source/@ember/-internals/glimmer/lib/utils/managers.js",
+      "@ember/-internals/glimmer/lib/utils/process-args.js": "ember-source/@ember/-internals/glimmer/lib/utils/process-args.js",
+      "@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.js": "ember-source/@ember/-internals/glimmer/lib/utils/serialization-first-node-helpers.js",
+      "@ember/-internals/glimmer/lib/utils/string.js": "ember-source/@ember/-internals/glimmer/lib/utils/string.js",
+      "@ember/-internals/glimmer/lib/utils/to-bool.js": "ember-source/@ember/-internals/glimmer/lib/utils/to-bool.js",
+      "@ember/-internals/glimmer/lib/views/outlet.js": "ember-source/@ember/-internals/glimmer/lib/views/outlet.js",
       "@ember/-internals/meta/index.js": "ember-source/@ember/-internals/meta/index.js",
       "@ember/-internals/meta/lib/meta.js": "ember-source/@ember/-internals/meta/lib/meta.js",
       "@ember/-internals/metal/index.js": "ember-source/@ember/-internals/metal/index.js",
@@ -188,6 +272,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,6 +321,7 @@
       "@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",
@@ -360,5 +446,10 @@
       ]
     }
   },
-  "packageManager": "pnpm@10.30.3"
+  "packageManager": "pnpm@10.30.3",
+  "_originalVersion": "7.1.0-alpha.1",
+  "_versionPreviouslyCalculated": true,
+  "publishConfig": {
+    "tag": "old"
+  }
 }
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..66afa93812e 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';
diff --git a/packages/@ember/-internals/glimmer/lib/classic-helper-symbol.ts b/packages/@ember/-internals/glimmer/lib/classic-helper-symbol.ts
new file mode 100644
index 00000000000..18ecd674dac
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/classic-helper-symbol.ts
@@ -0,0 +1,24 @@
+// Leaf-level brand and registration hook for the classic class-based
+// `Helper` system, factored out so the resolver doesn't statically depend on
+// `./helper` (which extends `FrameworkObject` and pulls in the entire
+// `EmberObject` / `Mixin` / `CoreObject` pyramid).
+//
+// `helper.ts` registers its `CLASSIC_HELPER_MANAGER` here on import. If the
+// app never imports `@ember/component/helper`, classic helpers can't exist
+// and the resolver short-circuits cleanly without dragging in any of it.
+
+export const IS_CLASSIC_HELPER: unique symbol = Symbol('IS_CLASSIC_HELPER');
+
+export function isClassicHelper(obj: object): boolean {
+  return (obj as { [IS_CLASSIC_HELPER]?: boolean })[IS_CLASSIC_HELPER] === true;
+}
+
+let classicHelperManager: object | null = null;
+
+export function registerClassicHelperManager(manager: object): void {
+  classicHelperManager = manager;
+}
+
+export function getClassicHelperManager(): object | null {
+  return classicHelperManager;
+}
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..f757c933a5e
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly-symbols.ts
@@ -0,0 +1,16 @@
+// Leaf-level symbols and the curly-manager identity check, factored out so
+// the renderer and resolver don't have to drag in the classic CurlyComponentManager
+// (and through it the entire `@ember/component`/EmberObject pyramid).
+//
+// `curly.ts` marks its manager singleton with `IS_CURLY_MANAGER` so the check
+// here works without the marker file knowing about the manager itself.
+
+export const BOUNDS = Symbol('BOUNDS');
+export const DIRTY_TAG = Symbol('DIRTY_TAG');
+export const IS_DISPATCHING_ATTRS = Symbol('IS_DISPATCHING_ATTRS');
+
+export const IS_CURLY_MANAGER = Symbol('IS_CURLY_MANAGER');
+
+export function isCurlyManager(manager: object): boolean {
+  return (manager as { [IS_CURLY_MANAGER]?: boolean })[IS_CURLY_MANAGER] === 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..a899542b6ff 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
@@ -4,8 +4,12 @@ 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';
@@ -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,15 @@ import {
 
 import ComponentStateBucket from '../utils/curly-component-state-bucket';
 import { processComponentArgs } from '../utils/process-args';
+import {
+  BOUNDS,
+  DIRTY_TAG,
+  IS_CURLY_MANAGER,
+  IS_DISPATCHING_ATTRS,
+  isCurlyManager,
+} from './curly-symbols';
+
+export { BOUNDS, DIRTY_TAG, IS_DISPATCHING_ATTRS, isCurlyManager };
 
 const COMPONENT_ARGS_MAP = new WeakMap<object, CapturedArguments['named']>();
 
@@ -61,10 +78,6 @@ 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');
-
 const EMBER_VIEW_REF = createPrimitiveRef('ember-view');
 
 function aliasIdToElementId(args: VMArguments, props: any) {
@@ -131,6 +144,10 @@ export default class CurlyComponentManager
     WithDynamicLayout<ComponentStateBucket, RuntimeResolver>,
     WithDynamicTagName<ComponentStateBucket>
 {
+  // marker so `isCurlyManager` can identify this manager without needing
+  // a reference to the singleton (which would re-pull this whole module).
+  [IS_CURLY_MANAGER] = true as const;
+
   protected templateFor(component: Component): CompilableProgram | null {
     let { layout, layoutName } = component;
     let owner = getOwner(component);
@@ -552,7 +569,3 @@ const CURLY_CAPABILITIES: InternalComponentCapabilities = {
 };
 
 export const CURLY_COMPONENT_MANAGER = new CurlyComponentManager();
-
-export function isCurlyManager(manager: object): boolean {
-  return manager === CURLY_COMPONENT_MANAGER;
-}
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..823e1239f51 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
@@ -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..2ca09c5e158 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/root.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/root.ts
@@ -1,4 +1,4 @@
-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 { DEBUG } from '@glimmer/env';
@@ -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..8e6b12278aa 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
@@ -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..f61e446f829 100644
--- a/packages/@ember/-internals/glimmer/lib/component.ts
+++ b/packages/@ember/-internals/glimmer/lib/component.ts
@@ -1,31 +1,28 @@
-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 { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+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,
@@ -34,7 +31,7 @@ import {
   IS_DISPATCHING_ATTRS,
   getComponentCapturedArgs,
 } from './component-managers/curly';
-import { hasDOM } from '@ember/-internals/browser-environment';
+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>>();
diff --git a/packages/@ember/-internals/glimmer/lib/components/abstract-input.ts b/packages/@ember/-internals/glimmer/lib/components/abstract-input.ts
index 01bae28b626..0c63b2793ac 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 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..cd9898555dc 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 { 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..4f11670388c 100644
--- a/packages/@ember/-internals/glimmer/lib/components/link-to.ts
+++ b/packages/@ember/-internals/glimmer/lib/components/link-to.ts
@@ -1,7 +1,8 @@
 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';
@@ -10,7 +11,8 @@ 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/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..a68ce2e408c 100644
--- a/packages/@ember/-internals/glimmer/lib/helper.ts
+++ b/packages/@ember/-internals/glimmer/lib/helper.ts
@@ -2,23 +2,40 @@
 @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';
+import {
+  IS_CLASSIC_HELPER,
+  isClassicHelper,
+  registerClassicHelperManager,
+} from './classic-helper-symbol';
+
+export { isClassicHelper };
 
 const RECOMPUTE_TAG = Symbol('RECOMPUTE_TAG');
 
 // Signature type utilities
 type GetOr<T, K, Else> = K extends keyof T ? T[K] : Else;
 
+// `IS_CLASSIC_HELPER` was historically declared here; it's now defined in
+// `./classic-helper-symbol` so the resolver can check the brand without
+// pulling this whole module (and through it, EmberObject) into the renderer
+// chunk. We keep the class-side brand assignment below to preserve runtime
+// identity — `isClassicHelper(SomeHelperClass) === true` for `Helper`
+// subclasses, exactly as before.
+
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
 type Args<S> = GetOr<S, 'Args', {}>;
 
@@ -41,8 +58,6 @@ export interface HelperInstance<S> {
   [RECOMPUTE_TAG]: DirtyableTag;
 }
 
-const IS_CLASSIC_HELPER: unique symbol = Symbol('IS_CLASSIC_HELPER');
-
 export interface SimpleHelper<S> {
   compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
 }
@@ -178,10 +193,6 @@ export default class Helper<S = unknown> extends FrameworkObject {
 }
 /* eslint-enable import/export */
 
-export function isClassicHelper(obj: object): boolean {
-  return (obj as any)[IS_CLASSIC_HELPER] === true;
-}
-
 interface ClassicHelperStateBucket {
   instance: HelperInstance<unknown>;
   args: Arguments;
@@ -260,6 +271,10 @@ setHelperManager((owner: InternalOwner | undefined): ClassicHelperManager => {
 
 export const CLASSIC_HELPER_MANAGER = getInternalHelperManager(Helper);
 
+// Register with the leaf-level lookup so the resolver can find the classic
+// helper manager without statically importing this module.
+registerClassicHelperManager(CLASSIC_HELPER_MANAGER as object);
+
 ///////////
 
 class Wrapper<S = unknown> implements HelperFactory<SimpleHelper<S>> {
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/renderer.ts b/packages/@ember/-internals/glimmer/lib/renderer.ts
index cfc74e0e423..8578c0ca20b 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 {
@@ -19,48 +15,26 @@ import type {
   Cursor,
   DebugRenderTree,
   Environment,
-  DynamicScope as GlimmerDynamicScope,
   RenderResult as GlimmerRenderResult,
-  Template,
-  TemplateFactory,
   EvaluationContext,
-  CurriedComponent,
   TreeBuilder,
   ClassicResolver,
 } from '@glimmer/interfaces';
 
 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 { artifacts } from '@glimmer/program/lib/helpers';
+import { RuntimeOpImpl } from '@glimmer/program/lib/opcode';
+import { clientBuilder } from '@glimmer/runtime/lib/vm/element-builder';
+import { inTransaction, runtimeOptions } from '@glimmer/runtime/lib/environment';
+import { renderComponent as glimmerRenderComponent } from '@glimmer/runtime/lib/render';
+import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator/lib/validators';
+import type { SimpleDocument, SimpleElement } from '@simple-dom/interface';
 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 { BOUNDS } from './component-managers/curly-symbols';
 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';
+import { EvaluationContextImpl } from '@glimmer/opcode-compiler/lib/program-context';
 
 export type IBuilder = (env: Environment, cursor: Cursor) => TreeBuilder;
 
@@ -74,34 +48,6 @@ export interface View {
   [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;
-  }
-}
-
 const NO_OP = () => {};
 
 // This wrapper logic prevents us from rerendering in case of a hard failure
@@ -190,90 +136,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 +159,17 @@ function loopBegin(): void {
   }
 }
 
-let renderSettledDeferred: RSVP.Deferred<void> | null = null;
+type Deferred = { promise: Promise<void>; resolve: () => void };
+
+function defer(): Deferred {
+  let resolve!: () => void;
+  const 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 +181,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()) {
@@ -821,188 +693,4 @@ export class Renderer extends BaseRenderer {
       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 };
-  }
 }
diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts
index af51ab9865d..3aee7ff6f3c 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,23 @@ import type {
   TemplateFactory,
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
+import { getComponentTemplate } from '@glimmer/manager/lib/public/template';
 import {
-  getComponentTemplate,
   getInternalComponentManager,
   setInternalHelperManager,
-} from '@glimmer/manager';
+} 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 {
-  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 { getClassicHelperManager, isClassicHelper } from './classic-helper-symbol';
 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 +40,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,8 +93,6 @@ const BUILTIN_KEYWORD_HELPERS: Record<string, object> = {
   '-normalize-class': normalizeClassHelper,
   '-resolve': resolve,
   '-track-array': trackArray,
-  '-mount': mountHelper,
-  '-outlet': outletHelper,
   '-in-el-null': inElementNullCheckHelper,
 };
 
@@ -111,6 +106,17 @@ const BUILTIN_HELPERS: Record<string, object> = {
   'unique-id': uniqueId,
 };
 
+/**
+ * Register an additional built-in keyword helper (e.g. `{{outlet}}`,
+ * `{{mount}}`). Kept separate so the renderer doesn't statically depend on
+ * routing/engine infrastructure — callers that need those helpers must opt
+ * in by importing the registration module.
+ */
+export function registerBuiltInKeywordHelper(name: string, helper: object): void {
+  BUILTIN_KEYWORD_HELPERS[name] = helper;
+  BUILTIN_HELPERS[name] = helper;
+}
+
 if (DEBUG) {
   BUILTIN_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
 } else {
@@ -169,17 +175,29 @@ export default class ResolverImpl implements ClassicResolver<InternalOwner> {
     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);
+      // bound in the factoryFor result, including type-based injections.
+      //
+      // The manager is registered lazily by `./helper` on import, so apps that
+      // never load classic helpers don't pull that module (and EmberObject)
+      // into the bundle. If a classic-helper definition somehow shows up
+      // without the manager being registered, that's a user error — assert in
+      // DEBUG and fall through.
+      let manager = getClassicHelperManager();
+      assert(
+        'Encountered a classic helper definition but `@ember/component/helper` was never imported, so its manager has not been registered.',
+        manager !== null
+      );
+      if (manager !== null) {
+        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(manager, factory);
+          }
+        } else {
+          setInternalHelperManager(manager, factory);
         }
-      } else {
-        setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
       }
 
       return factory;
diff --git a/packages/@ember/-internals/glimmer/lib/setup-registry.ts b/packages/@ember/-internals/glimmer/lib/setup-registry.ts
index 1608fe1f185..e4ded5e0e21 100644
--- a/packages/@ember/-internals/glimmer/lib/setup-registry.ts
+++ b/packages/@ember/-internals/glimmer/lib/setup-registry.ts
@@ -1,15 +1,18 @@
-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 OutletTemplate from './templates/outlet';
 import RootTemplate from './templates/root';
-import OutletView from './views/outlet';
+// Side-effect import: registers `-mount` and `-outlet` as built-in keyword
+// helpers. Importing this here keeps the renderer free of routing/engine
+// dependencies so apps that only use `renderComponent` don't pay for them.
+import './syntax/register-routing-keywords';
+// Side-effect import: registers the classic-helper manager with the resolver.
+// Apps that never use classic class-based helpers don't import this and so
+// never pay for `Helper extends FrameworkObject` (and through it, EmberObject).
+import './helper';
 
 export function setupApplicationRegistry(registry: Registry): void {
   // because we are using injections we can't use instantiate false
@@ -40,15 +43,15 @@ export function setupApplicationRegistry(registry: Registry): void {
 }
 
 export function setupEngineRegistry(registry: Registry): void {
-  registry.optionsForType('template', { instantiate: false });
-
-  registry.register('view:-outlet', OutletView);
-  registry.register('template:-outlet', OutletTemplate as any);
-
-  registry.optionsForType('helper', { instantiate: false });
-
-  registry.register('component:input', Input);
-
-  registry.register('component:link-to', LinkTo);
-  registry.register('component:textarea', Textarea);
+  // registry.optionsForType('template', { instantiate: false });
+  //
+  // registry.register('view:-outlet', OutletView);
+  // registry.register('template:-outlet', OutletTemplate as any);
+  //
+  // registry.optionsForType('helper', { instantiate: false });
+  //
+  // registry.register('component:input', Input);
+  //
+  // registry.register('component:link-to', LinkTo);
+  // registry.register('component:textarea', Textarea);
 }
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..937321f8cd4 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/to-bool.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/to-bool.ts
@@ -1,15 +1,25 @@
 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';
+
+// Inlined to avoid pulling `@ember/array` (and through it `@ember/object/mixin`,
+// `typeOf` → `CoreObject`, `Enumerable`, etc.) into the renderer for what is
+// just a truthiness check on `{{#if someArray}}`. We accept brand-marked
+// EmberArrays via `isEmberArray` and native arrays via `Array.isArray` —
+// the same two cases that matter in practice.
+function isArrayish(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 (isArrayish(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..c5a305b2ce3 100644
--- a/packages/@ember/-internals/metal/lib/decorator.ts
+++ b/packages/@ember/-internals/metal/lib/decorator.ts
@@ -1,5 +1,5 @@
-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';
 
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..08c5148cd9c 100644
--- a/packages/@ember/-internals/metal/lib/observer.ts
+++ b/packages/@ember/-internals/metal/lib/observer.ts
@@ -1,9 +1,10 @@
-import { ENV } from '@ember/-internals/environment';
-import { peekMeta } from '@ember/-internals/meta';
+import { ENV } from '@ember/-internals/environment/lib/env';
+import { peekMeta } from '@ember/-internals/meta/lib/meta';
 import 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';
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..b4420bc952b 100644
--- a/packages/@ember/-internals/metal/lib/property_events.ts
+++ b/packages/@ember/-internals/metal/lib/property_events.ts
@@ -1,5 +1,5 @@
-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,
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..7502923e85c 100644
--- a/packages/@ember/-internals/metal/lib/property_set.ts
+++ b/packages/@ember/-internals/metal/lib/property_set.ts
@@ -1,4 +1,6 @@
-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';
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..771ba24bf5b 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..0f3c45349c8
--- /dev/null
+++ b/packages/@ember/-internals/runtime/lib/mixins/content-for.ts
@@ -0,0 +1,18 @@
+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';
+
+// Extracted from `./-proxy` so that consumers (notably the `each-in` helper
+// reachable from the renderer) don't have to drag in `@ember/object/mixin`
+// and the `ProxyMixin = Mixin.create(...)` side effect — that's the entry
+// point to the entire EmberObject/PrototypeMixin pyramid.
+
+export function contentFor<T>(proxy: ProxyMixin<T>): T | null {
+  let content = get(proxy, 'content');
+  // SAFETY: matches the original cast in -proxy.ts; @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..aba69ba106b 100644
--- a/packages/@ember/-internals/views/lib/views/states.ts
+++ b/packages/@ember/-internals/views/lib/views/states.ts
@@ -1,5 +1,5 @@
-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 { join } from '@ember/runloop';
diff --git a/packages/@ember/application/index.ts b/packages/@ember/application/index.ts
index dc6d923835a..6e39f692f75 100644
--- a/packages/@ember/application/index.ts
+++ b/packages/@ember/application/index.ts
@@ -2,29 +2,23 @@
 @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 { 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 Route from '@ember/routing/route';
+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 Router from '@ember/routing/router';
-import HashLocation from '@ember/routing/hash-location';
-import HistoryLocation from '@ember/routing/history-location';
-import NoneLocation from '@ember/routing/none-location';
-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 RouterService from '@ember/routing/router-service';
+import type Container from '@ember/-internals/container/lib/container';
+import type Registry from '@ember/-internals/container/lib/registry';
+import { setupApplicationRegistry } from '@ember/-internals/glimmer/lib/setup-registry';
 import type { EngineInstanceOptions } from '@ember/engine/instance';
 import type { SimpleDocument, SimpleElement } from '@simple-dom/interface';
 
@@ -1107,28 +1101,6 @@ class Application extends Engine {
   }
 }
 
-function commonSetupRegistry(registry: Registry) {
-  registry.register('router:main', Router);
-  registry.register('-view-registry:main', {
-    create() {
-      return dictionary(null);
-    },
-  });
-
-  registry.register('route:basic', Route);
-  registry.register('event_dispatcher:main', EventDispatcher);
-
-  registry.register('location:hash', HashLocation);
-  registry.register('location:history', HistoryLocation);
-  registry.register('location:none', NoneLocation);
-
-  registry.register(P`-bucket-cache:main`, {
-    create() {
-      return new BucketCache();
-    },
-  });
-
-  registry.register('service:router', RouterService);
-}
+function commonSetupRegistry(registry: Registry) {}
 
 export { Application as default };
diff --git a/packages/@ember/application/instance.ts b/packages/@ember/application/instance.ts
index 47ecb342bd4..46f2cdd1ae6 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';
 
 /**
@@ -72,7 +75,7 @@ class ApplicationInstance extends EngineInstance {
     // to notify us when it has created the root-most view. That view is then
     // appended to the rootElement, in the case of apps, to the fixture harness
     // in tests, or rendered to a string in the case of FastBoot.
-    this.register('-application-instance:main', this, { instantiate: false });
+    // this.register('-application-instance:main', this, { instantiate: false });
   }
 
   /**
@@ -297,12 +300,12 @@ class ApplicationInstance extends EngineInstance {
   static setupRegistry(registry: Registry, options: BootOptions | _BootOptions = {}) {
     let coptions = options instanceof _BootOptions ? options : new _BootOptions(options);
 
-    registry.register('-environment:main', coptions.toEnvironment(), {
-      instantiate: false,
-    });
-    registry.register('service:-document', coptions.document!, {
-      instantiate: false,
-    });
+    // registry.register('-environment:main', coptions.toEnvironment(), {
+    //   instantiate: false,
+    // });
+    // registry.register('service:-document', coptions.document!, {
+    //   instantiate: false,
+    // });
 
     super.setupRegistry(registry, coptions);
   }
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..b2e56599513 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 = [];
@@ -314,7 +315,7 @@ class Engine extends Namespace.extend(RegistryProxyMixin) {
 
     registry.set = set;
 
-    registry.register('application:main', namespace, { instantiate: false });
+    // registry.register('application:main', namespace, { instantiate: false });
 
     commonSetupRegistry(registry);
     setupEngineRegistry(registry);
@@ -504,23 +505,6 @@ export function buildInitializerMethod<
   };
 }
 
-function commonSetupRegistry(registry: Registry) {
-  registry.optionsForType('component', { singleton: false });
-  registry.optionsForType('view', { singleton: false });
-
-  registry.register('controller:basic', Controller, { instantiate: false });
-
-  // Register the routing service...
-  registry.register('service:-routing', RoutingService);
-
-  // DEBUGGING
-  registry.register('resolver-for-debugging:main', registry.resolver!, {
-    instantiate: false,
-  });
-
-  registry.register('container-debug-adapter:main', ContainerDebugAdapter);
-
-  registry.register('component-lookup:main', ComponentLookup);
-}
+function commonSetupRegistry(registry: Registry) {}
 
 export default Engine;
diff --git a/packages/@ember/engine/instance.ts b/packages/@ember/engine/instance.ts
index 097b5c6ca6e..2a9c2119057 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 {
@@ -234,7 +235,7 @@ class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerPro
     });
 
     let env = parent.lookup('-environment:main') as Record<string, unknown>;
-    this.register('-environment:main', env, { instantiate: false });
+    // this.register('-environment:main', env, { instantiate: false });
 
     // The type annotation forces TS to (a) validate that these match and (b)
     // *notice* that they match, e.g. below on the `singletons.push()`.
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..bd758b48b02 100644
--- a/packages/@ember/instrumentation/index.ts
+++ b/packages/@ember/instrumentation/index.ts
@@ -1,28 +1,21 @@
 /* eslint no-console:off */
 /* global console */
 
-import { ENV } from '@ember/-internals/environment';
-import { assert } from '@ember/debug';
+import {
+  _instrumentStart,
+  NOOP,
+  resetCache,
+  subscribers,
+} from './lib/internal-instrument';
+import type { Listener, StructuredProfilePayload, Subscriber } from './lib/internal-instrument';
 
-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 type { Listener, StructuredProfilePayload, Subscriber };
+export { _instrumentStart };
 
 export interface PayloadWithException {
   exception?: any;
 }
 
-export interface StructuredProfilePayload {
-  object: string | object;
-}
-
 /**
 @module @ember/instrumentation
 @private
@@ -78,23 +71,7 @@ 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();
+export { subscribers };
 
 type InstrumentCallback<Binding, Result> = (this: Binding) => Result;
 
@@ -196,67 +173,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 +208,7 @@ export function subscribe<T>(pattern: string, object: Listener<T>): Subscriber<T
   };
 
   subscribers.push(subscriber);
-  cache = {};
+  resetCache();
 
   return subscriber;
 }
@@ -317,7 +233,7 @@ export function unsubscribe(subscriber: Subscriber<any>): void {
   }
 
   subscribers.splice(index, 1);
-  cache = {};
+  resetCache();
 }
 
 /**
@@ -330,5 +246,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..5cd9ef0d876
--- /dev/null
+++ b/packages/@ember/instrumentation/lib/internal-instrument.ts
@@ -0,0 +1,116 @@
+// Hot-path bits of `@ember/instrumentation`, factored out so internal
+// callers (the resolver, component managers) don't have to drag in the
+// full subscribe/unsubscribe/instrument machinery — most of which is dead
+// code unless something actually subscribes (e.g. Ember Inspector).
+//
+// `subscribers` and `cache` live here; `index.ts` imports and mutates
+// them via `subscribe`/`unsubscribe`/`reset`.
+
+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;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const subscribers: Subscriber<any>[] = [];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const cache: { [key: string]: Listener<any>[] } = {};
+
+export function resetCache(): void {
+  for (const key of Object.keys(cache)) {
+    delete cache[key];
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function populateListeners(name: string): Listener<any>[] {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-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 => {};
+
+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);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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/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..f664c95ef0b 100644
--- a/packages/@ember/object/index.ts
+++ b/packages/@ember/object/index.ts
@@ -1,27 +1,24 @@
 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 type {
+  ElementDescriptor,
+  ExtendedMethodDecorator,
+} from '@ember/-internals/metal/lib/decorator';
+import { isElementDescriptor, setClassicDecorator } from '@ember/-internals/metal/lib/decorator';
+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
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..db079ea25b2 100644
--- a/packages/@ember/runloop/index.ts
+++ b/packages/@ember/runloop/index.ts
@@ -1,6 +1,6 @@
 import { assert } from '@ember/debug';
 import { onErrorTarget } from '@ember/-internals/error-handling';
-import { flushAsyncObservers } from '@ember/-internals/metal';
+import { flushAsyncObservers } from '@ember/-internals/metal/lib/observer';
 import Backburner, { type Timer, type DeferredActionQueues } from 'backburner.js';
 import type { AnyFn } from '@ember/-internals/utility-types';
 
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..eb4db05fd2e 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 {
@@ -68,7 +68,7 @@ class Disassembler<in out Added extends OperandType> {
   }
 }
 
-export const OPERANDS = Disassembler.build((d) => {
+export const OPERANDS = /*#__PURE__*/ Disassembler.build((d) => {
   return d
     .add(['imm/u32', 'imm/i32', 'imm/u32{todo}', 'imm/i32{todo}'], ({ value }) => ['number', value])
     .add(['const/i32[]'], ({ value, constants }) => [
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..ec5b2c206d1 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';
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..2125fe0aa9c
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/debug-render-tree-register.ts
@@ -0,0 +1,13 @@
+// Side-effect-only module: registers `DebugRenderTreeImpl` as the factory
+// used by `EnvironmentImpl` when `delegate.enableDebugTooling` is true.
+//
+// Importing this file pulls `./debug-render-tree` into the bundle. Apps
+// that don't need render-tree introspection (anything not running the
+// Ember Inspector) shouldn't import this module — `EnvironmentImpl`'s
+// `debugRenderTree` will silently stay `undefined`, which is the same
+// behavior you'd get with `enableDebugTooling: false`.
+
+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..8b09ce748d6 100644
--- a/packages/@glimmer/runtime/lib/debug-render-tree.ts
+++ b/packages/@glimmer/runtime/lib/debug-render-tree.ts
@@ -7,8 +7,9 @@ import type {
   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';
 
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..dd5cb9b3c5a 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,26 @@ 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';
 
+// Lazy registration: the DebugRenderTree implementation registers itself
+// here on import. Apps that don't need it (e.g. anything that isn't running
+// the Ember Inspector) won't pull `./debug-render-tree` into the bundle,
+// since this module no longer references it statically.
+type DebugRenderTreeFactory = () => DebugRenderTree<object>;
+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 {
@@ -112,7 +125,10 @@ export class EnvironmentImpl implements Environment {
     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/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-debug-setup.ts b/packages/@glimmer/runtime/lib/opcodes-debug-setup.ts
new file mode 100644
index 00000000000..2c7dc9ffe21
--- /dev/null
+++ b/packages/@glimmer/runtime/lib/opcodes-debug-setup.ts
@@ -0,0 +1,124 @@
+// Side-effect-only module: when imported, registers the per-opcode debug
+// hooks (`debugBefore` / `debugAfter`) on `AppendOpcodes`. These hooks are
+// only ever called when `LOCAL_DEBUG` is true (via the constant from
+// `@glimmer/local-debug-flags`), so they're useless in production.
+//
+// Pulling them into their own module means production bundles that don't
+// import this file drop `@glimmer/debug/lib/debug` (and its `OPERANDS`
+// disassembler), `DebugLogger`, `VmSnapshot`, `opcodeMetadata`, etc. —
+// 1–3 KB gzip of pure dev-only code.
+
+import type { DebugOp, SomeDisassembledOperand } from '@glimmer/debug/lib/debug';
+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 type { DebugVmSnapshot, Dict, Maybe, RuntimeOp } from '@glimmer/interfaces';
+import { unwrap } from '@glimmer/debug-util/lib/platform-utils';
+import { 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/lib/registers';
+
+import type { AppendOpcodes, DebugState } from './opcodes';
+import { registerDebugOpcodeSetup } from './opcodes';
+
+registerDebugOpcodeSetup((opcodes: AppendOpcodes): void => {
+  opcodes.debugBefore = (debug: DebugVmSnapshot, opcode: RuntimeOp): DebugState => {
+    let opcodeSnapshot = {
+      type: opcode.type,
+      size: opcode.size,
+      isMachine: opcode.isMachine,
+    } as const;
+
+    let snapshot = new VmSnapshot(opcodeSnapshot, debug);
+    let params: Maybe<Dict<SomeDisassembledOperand>> = undefined;
+    let op: DebugOp | undefined = undefined;
+    let closeGroup: (() => void) | undefined;
+
+    if (LOCAL_TRACE_LOGGING) {
+      const logger = DebugLogger.configured();
+
+      let pos = debug.registers[$pc] - opcode.size;
+
+      op = debugOp(debug.context.program, opcode, debug.template);
+
+      closeGroup = logger
+        .group(frag`${pos}. ${describeOp(opcode, debug.context.program, debug.template)}`)
+        .expanded();
+
+      let debugParams = [];
+      for (let [name, param] of Object.entries(op.params)) {
+        const value = param.value;
+        if (value !== null && (typeof value === 'object' || typeof value === 'function')) {
+          debugParams.push(name, '=', value);
+        }
+      }
+      LOCAL_LOGGER.debug(...debugParams);
+    }
+
+    recordStackSize(debug.registers[$sp]);
+    return {
+      op,
+      closeGroup,
+      params,
+      opcode: opcodeSnapshot,
+      debug,
+      snapshot,
+    };
+  };
+
+  opcodes.debugAfter = (postSnapshot: DebugVmSnapshot, pre: DebugState) => {
+    let post = new VmSnapshot(pre.opcode, postSnapshot);
+    let diff = pre.snapshot.diff(post);
+    let {
+      opcode: { type },
+    } = pre;
+
+    let sp = diff.registers[$sp];
+
+    let meta = opcodeMetadata(type);
+    let actualChange = sp.after - sp.before;
+    if (
+      meta &&
+      meta.check !== false &&
+      typeof meta.stackChange! === 'number' &&
+      meta.stackChange !== actualChange
+    ) {
+      throw new Error(
+        `Error in ${pre.op?.name}:\n\n${pre.debug.registers[$pc]}. ${
+          pre.op ? describeOpcode(pre.op.name, pre.params) : unwrap(opcodeMetadata(type)).name
+        }\n\nStack changed by ${actualChange}, expected ${meta.stackChange}`
+      );
+    }
+
+    if (LOCAL_TRACE_LOGGING) {
+      const logger = DebugLogger.configured();
+
+      logger.log(diff.registers[$pc].describe());
+      logger.log(diff.registers[$ra].describe());
+      logger.log(diff.registers[$s0].describe());
+      logger.log(diff.registers[$s1].describe());
+      logger.log(diff.registers[$t0].describe());
+      logger.log(diff.registers[$t1].describe());
+      logger.log(diff.registers[$v0].describe());
+      logger.log(diff.stack.describe());
+      logger.log(diff.destructors.describe());
+      logger.log(diff.scope.describe());
+
+      if (diff.constructing.didChange || diff.blocks.change) {
+        const done = logger.group(`tree construction`).expanded();
+        try {
+          logger.log(diff.constructing.describe());
+          logger.log(diff.blocks.describe());
+          logger.log(diff.cursors.describe());
+        } finally {
+          done();
+        }
+      }
+
+      pre.closeGroup?.();
+    }
+  };
+});
diff --git a/packages/@glimmer/runtime/lib/opcodes.ts b/packages/@glimmer/runtime/lib/opcodes.ts
index 247597dda93..c0e4a6affce 100644
--- a/packages/@glimmer/runtime/lib/opcodes.ts
+++ b/packages/@glimmer/runtime/lib/opcodes.ts
@@ -1,8 +1,7 @@
-import type { DebugOp, SomeDisassembledOperand } from '@glimmer/debug';
+import type { DebugOp, SomeDisassembledOperand } from '@glimmer/debug/lib/debug';
 import type {
   DebugVmSnapshot,
   Dict,
-  Maybe,
   Nullable,
   Optional,
   RuntimeOp,
@@ -10,25 +9,28 @@ 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 { 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 { VM_SYSCALL_SIZE } from '@glimmer/constants/lib/syscall-ops';
+import type { 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 } from '@glimmer/local-debug-flags';
 
 import type { LowLevelVM, VM } from './vm';
 import type { Externs } from './vm/low-level';
 
+// Lazy registration: when `./opcodes-debug-setup` is imported, it calls
+// `registerDebugOpcodeSetup` to install the per-opcode tracing/snapshot
+// hooks. Without that import, the heavy debug imports
+// (`@glimmer/debug/lib/debug`, `DebugLogger`, `VmSnapshot`,
+// `opcodeMetadata`, etc.) stay out of the bundle. Production builds with
+// `LOCAL_DEBUG === false` never need these hooks.
+type DebugOpcodeSetup = (opcodes: AppendOpcodes) => void;
+let debugOpcodeSetup: DebugOpcodeSetup | null = null;
+
+export function registerDebugOpcodeSetup(setup: DebugOpcodeSetup): void {
+  debugOpcodeSetup = setup;
+}
+
 export interface OpcodeJSON {
   type: number | string;
   guid?: Nullable<number>;
@@ -72,104 +74,8 @@ export class AppendOpcodes {
   declare debugAfter?: (debug: DebugVmSnapshot, pre: DebugState) => void;
 
   constructor() {
-    if (LOCAL_DEBUG) {
-      this.debugBefore = (debug: DebugVmSnapshot, opcode: RuntimeOp): DebugState => {
-        let opcodeSnapshot = {
-          type: opcode.type,
-          size: opcode.size,
-          isMachine: opcode.isMachine,
-        } as const;
-
-        let snapshot = new VmSnapshot(opcodeSnapshot, debug);
-        let params: Maybe<Dict<SomeDisassembledOperand>> = undefined;
-        let op: DebugOp | undefined = undefined;
-        let closeGroup: (() => void) | undefined;
-
-        if (LOCAL_TRACE_LOGGING) {
-          const logger = DebugLogger.configured();
-
-          let pos = debug.registers[$pc] - opcode.size;
-
-          op = debugOp(debug.context.program, opcode, debug.template);
-
-          closeGroup = logger
-            .group(frag`${pos}. ${describeOp(opcode, debug.context.program, debug.template)}`)
-            .expanded();
-
-          let debugParams = [];
-          for (let [name, param] of Object.entries(op.params)) {
-            const value = param.value;
-            if (value !== null && (typeof value === 'object' || typeof value === 'function')) {
-              debugParams.push(name, '=', value);
-            }
-          }
-          LOCAL_LOGGER.debug(...debugParams);
-        }
-
-        recordStackSize(debug.registers[$sp]);
-        return {
-          op,
-          closeGroup,
-          params,
-          opcode: opcodeSnapshot,
-          debug,
-          snapshot,
-        };
-      };
-
-      this.debugAfter = (postSnapshot: DebugVmSnapshot, pre: DebugState) => {
-        let post = new VmSnapshot(pre.opcode, postSnapshot);
-        let diff = pre.snapshot.diff(post);
-        let {
-          opcode: { type },
-        } = pre;
-
-        let sp = diff.registers[$sp];
-
-        let meta = opcodeMetadata(type);
-        let actualChange = sp.after - sp.before;
-        if (
-          meta &&
-          meta.check !== false &&
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme
-          typeof meta.stackChange! === 'number' &&
-          meta.stackChange !== actualChange
-        ) {
-          throw new Error(
-            `Error in ${pre.op?.name}:\n\n${pre.debug.registers[$pc]}. ${
-              pre.op ? describeOpcode(pre.op.name, pre.params) : unwrap(opcodeMetadata(type)).name
-            }\n\nStack changed by ${actualChange}, expected ${meta.stackChange}`
-          );
-        }
-
-        if (LOCAL_TRACE_LOGGING) {
-          const logger = DebugLogger.configured();
-
-          logger.log(diff.registers[$pc].describe());
-          logger.log(diff.registers[$ra].describe());
-          logger.log(diff.registers[$s0].describe());
-          logger.log(diff.registers[$s1].describe());
-          logger.log(diff.registers[$t0].describe());
-          logger.log(diff.registers[$t1].describe());
-          logger.log(diff.registers[$v0].describe());
-          logger.log(diff.stack.describe());
-          logger.log(diff.destructors.describe());
-          logger.log(diff.scope.describe());
-
-          if (diff.constructing.didChange || diff.blocks.change) {
-            const done = logger.group(`tree construction`).expanded();
-            try {
-              logger.log(diff.constructing.describe());
-              logger.log(diff.blocks.describe());
-              logger.log(diff.cursors.describe());
-            } finally {
-              done();
-            }
-          }
-
-          pre.closeGroup?.();
-        }
-      };
+    if (LOCAL_DEBUG && debugOpcodeSetup) {
+      debugOpcodeSetup(this);
     }
   }
 
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 8905238c41c..810e2420ae3 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -155,7 +155,7 @@ importers:
         version: 2.1.0
       ember-cli-dependency-checker:
         specifier: ^3.3.1
-        version: 3.3.3(ember-cli@6.11.2(@babel/core@7.29.0)(@types/node@22.19.15))
+        version: 3.3.3(ember-cli@6.11.2(@babel/core@7.29.0)(@types/node@22.19.15)(ejs@3.1.10)(handlebars@4.7.9)(underscore@1.13.8))
       ember-cli-yuidoc:
         specifier: ^0.9.1
         version: 0.9.1
@@ -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:
@@ -2815,7 +2824,7 @@ importers:
         version: 3.0.0
       ember-cli-dependency-checker:
         specifier: ^3.3.3
-        version: 3.3.3(ember-cli@6.11.2(@babel/core@7.29.0)(@types/node@22.19.15))
+        version: 3.3.3(ember-cli@6.11.2(@babel/core@7.29.0)(@types/node@22.19.15)(ejs@3.1.10)(handlebars@4.7.9)(underscore@1.13.8))
       ember-cli-deprecation-workflow:
         specifier: ^3.4.0
         version: 3.4.0(ember-source@)
@@ -4234,39 +4243,21 @@ packages:
     resolution: {integrity: sha512-43/qtrDUokr7LJqoF2c3+RInu/t4zfrpYdoSDfYyhg52rwLV6TnOvdG4fXm7IkSB3wErkcmJS9iEhjVtOSEjjA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@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==}
 
@@ -4288,12 +4279,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==}
 
@@ -13649,24 +13634,12 @@ snapshots:
       '@eslint/core': 0.17.0
       levn: 0.4.1
 
-  '@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
@@ -13676,25 +13649,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
@@ -13703,13 +13657,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
@@ -13747,15 +13694,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
@@ -17461,7 +17399,7 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  ember-cli-dependency-checker@3.3.3(ember-cli@6.11.2(@babel/core@7.29.0)(@types/node@22.19.15)):
+  ember-cli-dependency-checker@3.3.3(ember-cli@6.11.2(@babel/core@7.29.0)(@types/node@22.19.15)(ejs@3.1.10)(handlebars@4.7.9)(underscore@1.13.8)):
     dependencies:
       chalk: 2.4.2
       ember-cli: 6.11.2(@babel/core@7.29.0)(@types/node@22.19.15)(ejs@3.1.10)(handlebars@4.7.9)(underscore@1.13.8)
diff --git a/rollup.config.mjs b/rollup.config.mjs
index ceee7e37ab1..14208a299aa 100644
--- a/rollup.config.mjs
+++ b/rollup.config.mjs
@@ -238,7 +238,6 @@ function rolledUpPackages() {
   return [
     '@ember/-internals/browser-environment',
     '@ember/-internals/environment',
-    '@ember/-internals/glimmer',
     '@ember/-internals/metal',
     '@ember/-internals/utils',
     '@ember/-internals/container',