ember-vite-hmr 2.2.4 → 2.4.0

package/dist/lib/babel-plugin/service-proxy.js

@@ -0,0 +1,300 @@
+import { ImportUtil } from 'babel-import-util';
+// Rewrites `export default class MyService extends Service { ... }` (or the
+// equivalent separate-declaration form) into a generated `...HmrProxy` class
+// that's exported in its place. The proxy keeps a stable identity for
+// Ember's container/injections while the actual state-bearing instance --
+// the "delegate" -- gets swapped underneath on every HMR accept, which is
+// what lets a service's field/method edits apply without a full page
+// reload. Private members on the original class (and any of its ancestors
+// in the app's own source) are rewritten separately by
+// `renamePrivateClassMembers` (see ../private-members.ts) before this runs,
+// so this function doesn't need to special-case them at all.
+export function transformServiceExport(babel, path, state) {
+    var _a;
+    const t = babel.types;
+    // Check if this is a service file (normalize path for cross-platform compatibility)
+    const normalizedFilename = (_a = state.filename) === null || _a === void 0 ? void 0 : _a.replace(/\\/g, '/');
+    if (!(normalizedFilename === null || normalizedFilename === void 0 ? void 0 : normalizedFilename.includes('/services/'))) {
+        return;
+    }
+    const declaration = path.node.declaration;
+    // Handle both inline class declaration and identifier reference
+    let classDeclaration = null;
+    let classIdentifier = null;
+    let classPath = null;
+    if (declaration.type === 'ClassDeclaration' && declaration.id) {
+        // Case 1: export default class MyService extends Service { ... }
+        classDeclaration = declaration;
+        classIdentifier = declaration.id;
+        classPath = path.get('declaration');
+    }
+    else if (declaration.type === 'Identifier') {
+        // Case 2: class MyService extends Service { ... } \n export default MyService;
+        const binding = path.scope.getBinding(declaration.name);
+        if (binding && binding.path.isClassDeclaration()) {
+            classDeclaration = binding.path
+                .node;
+            classIdentifier = classDeclaration.id;
+            classPath =
+                binding.path;
+        }
+    }
+    if (!classDeclaration || !classIdentifier || !classPath) {
+        return;
+    }
+    if (classIdentifier.name.endsWith('HmrProxy')) {
+        return;
+    }
+    // Check if it extends Service
+    const superClass = classDeclaration.superClass;
+    if (!superClass ||
+        ((superClass.type !== 'Identifier' || superClass.name !== 'Service') &&
+            superClass.type !== 'MemberExpression')) {
+        return;
+    }
+    // Get the program path for ImportUtil
+    const programPath = path.findParent((p) => p.isProgram());
+    if (!programPath) {
+        return;
+    }
+    // Private members are renamed generically by the `Class` visitor in
+    // ../../babel-plugin.ts, not here -- it runs on every class regardless of
+    // whether it ends up wrapped by this HMR proxy.
+    const util = new ImportUtil(babel, programPath);
+    const tracked = util.import(programPath, '@glimmer/tracking', 'tracked');
+    const Service = util.import(programPath, '@ember/service', 'default');
+    const originalClassName = classIdentifier.name;
+    const proxyClassName = `${originalClassName}HmrProxy`;
+    // Keep the original class as-is, just remove it from export
+    // We'll add it back as a non-exported class
+    const babelTemplate = babel.template;
+    // The live proxy instance and the latest accepted implementation must
+    // live on `import.meta.hot.data`, not in a module-scope `let`: Vite
+    // guarantees that object (and only that object) survives across a
+    // module's hot re-evaluations. A component's `@service` injection can
+    // end up constructing the proxy against a *later* re-evaluation of
+    // this module than the one whose `import.meta.hot.accept` closure
+    // captured a module-scope variable — the closure and the constructor
+    // would then silently operate on two disconnected variable bindings
+    // (a duplicate-module symptom), and the HMR swap would never reach
+    // the instance actually rendered.
+    const ctorBody = babelTemplate.statements(`
+      super(...args);
+      this._owner = args[0];
+      const Impl = (import.meta.hot && import.meta.hot.data._impl) || ${proxyClassName}.Impl;
+      this._delegate = new Impl(this._owner);
+      if (import.meta.hot) {
+        import.meta.hot.data._proxy = this;
+      }
+      return new Proxy(this, {
+        get(target, prop, receiver) {
+          if (prop === '_delegate') {
+            return target._delegate;
+          }
+          // A subclass of this service (see the Reflect.get fallback
+          // below) may override a method the base delegate class also
+          // defines. Since 'prop in delegate' walks the delegate's
+          // *entire* prototype chain, it would match the base
+          // implementation before the subclass's own override ever
+          // gets a chance -- so look for an own property between
+          // target's dynamic prototype and this proxy's own prototype
+          // first, and prefer it over the delegate.
+          let proto = Object.getPrototypeOf(target);
+          while (proto && proto !== ${proxyClassName}.prototype) {
+            if (Object.prototype.hasOwnProperty.call(proto, prop)) {
+              return Reflect.get(target, prop, receiver);
+            }
+            proto = Object.getPrototypeOf(proto);
+          }
+          const delegate = target._delegate;
+          // Function-valued properties are returned exactly as stored
+          // on the delegate, never bound. Binding used to be necessary
+          // for prototype methods reading native '#private' fields
+          // (private-field access requires 'this' to literally be the
+          // declaring instance), but the private-member rewrite below
+          // now rewrites every '#private' member the app's own source
+          // declares to a plain property, which reads correctly
+          // through this same trap regardless of what 'this' is at
+          // the call site -- so a bound copy is never needed for that
+          // case. Binding would also be actively wrong for
+          // identity-sensitive own-property function values
+          // (modifier()/helper() results, component classes, etc.),
+          // since bind() returns a fresh function object and silently
+          // drops any metadata associated with the original one via a
+          // WeakMap (see #560/#561).
+          //
+          // Calling a returned prototype method as 'service.method()'
+          // now runs it with 'this' set to the proxy (standard
+          // member-call semantics), not the raw delegate -- the same
+          // way own-property function values have always run here.
+          // Reflection idioms inside such a method (Object.keys(this),
+          // 'this instanceof OriginalClass', for-in over this)
+          // therefore see the proxy's own shape, not the delegate's --
+          // a pre-existing limitation for own-property functions, now
+          // also true for prototype methods. Nothing in this repo's
+          // services relies on that, and ember-source's own
+          // Service/EmberObject/CoreObject chain declares no native
+          // '#private' fields, so this is safe for the common case;
+          // a third-party base class outside the app's own source that
+          // both uses native '#private' fields AND relies on such
+          // reflection from a service method would still be affected.
+          if (prop in delegate) {
+            return delegate[prop];
+          }
+          // Not on the delegate: fall through to the proxy's own real
+          // prototype chain, which covers methods declared on a subclass
+          // of this service (the subclass never went through this babel
+          // transform itself, since it doesn't extend Service directly).
+          return Reflect.get(target, prop, receiver);
+        },
+        set(target, prop, value) {
+          target._delegate[prop] = value;
+          return true;
+        },
+        defineProperty(target, prop, descriptor) {
+          // A subclass's own class fields are installed via
+          // [[DefineOwnProperty]] against whatever 'this' super() returned
+          // (this proxy), bypassing the 'set' trap entirely. Route them to
+          // the delegate too, so subclass state lives alongside the rest
+          // of the service's state instead of stranded on the proxy target.
+          return Reflect.defineProperty(target._delegate, prop, descriptor);
+        },
+      });
+    `)();
+    const willDestroyBody = babelTemplate.statements(`
+      super.willDestroy();
+      this._delegate.willDestroy();
+      if (import.meta.hot && import.meta.hot.data._proxy === this) {
+        import.meta.hot.data._proxy = undefined;
+      }
+    `)();
+    // Create the HMR proxy service class
+    const proxyClass = t.classDeclaration(t.identifier(proxyClassName), Service, t.classBody([
+        // static Impl = OriginalService (reference to the original class)
+        t.classProperty(t.identifier('Impl'), t.identifier(originalClassName), null, null, false, true),
+        // @tracked _delegate
+        t.classProperty(t.identifier('_delegate'), null, null, [t.decorator(tracked)], false, false),
+        t.classMethod('constructor', t.identifier('constructor'), [t.restElement(t.identifier('args'))], t.blockStatement(ctorBody)),
+        t.classMethod('method', t.identifier('willDestroy'), [], t.blockStatement(willDestroyBody)),
+    ]));
+    // For Case 1 (inline class), we need to keep the class as non-exported
+    // For Case 2 (separate declaration), the class already exists, so we don't recreate it
+    if (declaration.type === 'ClassDeclaration') {
+        // Case 1: Inline class export - create a non-exported version
+        const originalClass = t.classDeclaration(classIdentifier, classDeclaration.superClass, classDeclaration.body, classDeclaration.decorators || []);
+        // Replace the export with all the necessary declarations
+        // IMPORTANT: Class must be declared BEFORE the proxy class that references it
+        path.replaceWithMultiple([
+            originalClass, // The original class (no longer exported) - MUST BE FIRST
+            t.exportDefaultDeclaration(proxyClass), // Export the proxy class
+        ]);
+    }
+    else {
+        // Case 2: Separate declaration - class already exists, just replace the export
+        path.replaceWithMultiple([
+            t.exportDefaultDeclaration(proxyClass), // Export the proxy class
+        ]);
+    }
+    // Add HMR code after the export using babel template
+    if (programPath) {
+        const hmrCode = `
+      if (import.meta.hot) {
+        import.meta.hot.accept((newModule) => {
+          const NewImpl = newModule?.default?.Impl;
+          if (!NewImpl) {
+            return;
+          }
+
+          // Remember the latest accepted implementation so a proxy
+          // constructed *after* this update (its instantiation raced
+          // behind the HMR swap) still picks up the new class instead
+          // of the stale one captured at module-evaluation time.
+          import.meta.hot.data._impl = NewImpl;
+
+          const proxy = import.meta.hot.data._proxy;
+          if (!proxy) {
+            // No instance has been created yet; the next construction
+            // will read import.meta.hot.data._impl above.
+            return;
+          }
+
+          const oldDelegate = proxy._delegate;
+          const newDelegate = new NewImpl(proxy._owner);
+          proxy._delegate = newDelegate;
+
+          // Sync state from old to new while keeping new implementation defaults.
+          // Keys come from both 'for...in' (own AND inherited enumerable
+          // properties -- this is what picks up a '@tracked' field, which
+          // decorator-transforms implements as an *enumerable* accessor pair
+          // on the prototype, not an own instance property) and
+          // Object.getOwnPropertyNames (own properties regardless of
+          // enumerability -- this is what picks up an undecorated private
+          // field, which the private-member rewrite in
+          // ../private-members.ts's hideRenamedProperties makes a
+          // non-enumerable own property specifically so it's invisible to
+          // 'for...in', 'Object.keys', etc. everywhere *except* here). Using
+          // only 'for...in' would silently drop such a field's live,
+          // runtime-mutated value on every hot-reload, resetting it to
+          // whatever the new module's field initializer produces.
+          const keysToSync = new Set();
+          for (const key in oldDelegate) {
+            keysToSync.add(key);
+          }
+          for (const key of Object.getOwnPropertyNames(oldDelegate)) {
+            keysToSync.add(key);
+          }
+          for (const key of keysToSync) {
+            const descriptor =
+              Object.getOwnPropertyDescriptor(oldDelegate, key) ||
+              Object.getOwnPropertyDescriptor(Object.getPrototypeOf(oldDelegate), key);
+            const hasOwnDefault = Object.prototype.hasOwnProperty.call(newDelegate, key);
+            const currentValue = newDelegate[key];
+            const previousValue = oldDelegate[key];
+
+            // Skip Service instances - they should not be synced
+            if (previousValue instanceof Service) {
+              continue;
+            }
+
+            // Skip function properties that the new implementation also
+            // declares (a fresh redefinition should win over the old
+            // one). But a function-valued property the new
+            // implementation *doesn't* declare at all isn't a stale
+            // redefinition -- it's state a subclass installed on the
+            // delegate directly (subclasses of this service never go
+            // through this transform themselves, since their
+            // superclass isn't literally named Service; their own
+            // class fields land on the delegate via the proxy's
+            // defineProperty trap instead). Dropping it here would
+            // silently break e.g. an arrow-function class field on a
+            // subclass across a base-class HMR swap.
+            if (typeof previousValue === 'function' && hasOwnDefault) {
+              continue;
+            }
+
+            const shouldSync =
+              !!descriptor &&
+              (descriptor.writable || descriptor.set || Object.prototype.hasOwnProperty.call(oldDelegate, key)) &&
+              (!hasOwnDefault || currentValue === previousValue);
+
+            if (shouldSync) {
+              try {
+                newDelegate[key] = previousValue;
+              } catch (e) {
+                // Skip non-writable properties
+              }
+            }
+          }
+
+          newDelegate._hmrAccepted?.(oldDelegate);
+
+          if (oldDelegate.willDestroy) {
+            oldDelegate.willDestroy();
+          }
+        });
+      }
+    `;
+        const template = babel.template.statements(hmrCode);
+        programPath.pushContainer('body', template());
+    }
+}

package/dist/lib/babel-plugin/template-imports.d.ts

@@ -0,0 +1,46 @@
+import type * as BabelTypesNamespace from '@babel/types';
+import { Program } from '@babel/types';
+import type * as Babel from '@babel/core';
+import { NodeVisitor } from '@glimmer/syntax';
+interface ASTPluginEnvironment {
+    locals: string[];
+    filename: string;
+}
+export interface HmrImportStatement {
+    local: string;
+    source: string;
+    specifier: string;
+}
+export interface HmrImportMetadata {
+    importVar: string;
+    bindings: string[];
+    importStatements: HmrImportStatement[];
+}
+export declare const hmrImportMetadataCache: Map<string, HmrImportMetadata>;
+export declare function normalizeHmrCacheFilename(filename: string): string;
+declare class HotAstProcessor {
+    options: {
+        itsStatic: boolean;
+    };
+    counter: number;
+    meta: {
+        locals: Set<string>;
+        importVar: string | null;
+        importBindings: Set<string>;
+        babelProgram?: Program;
+    };
+    didCreateImportClass: boolean;
+    constructor();
+    reset(): void;
+    transform(env: ASTPluginEnvironment): {
+        visitor: Record<string, unknown>;
+    };
+    buildVisitor({ importVar, importBindings, babelProgram, }: {
+        importVar: string;
+        importBindings: Set<string>;
+        babelProgram: Program;
+    }): NodeVisitor;
+}
+export declare const hotAstProcessor: HotAstProcessor;
+export declare function finalizeTemplateImports(babel: typeof Babel, path: Babel.NodePath<BabelTypesNamespace.Program>, filename: string | undefined): void;
+export {};

package/dist/lib/babel-plugin/template-imports.js

@@ -0,0 +1,250 @@
+import * as glimmer from '@glimmer/syntax';
+import { ImportUtil } from 'babel-import-util';
+// Populated by finalizeTemplateImports below (once per file, per babel
+// pass) and consumed by lib/hmr.ts's Vite `transform` hook, so that hook
+// doesn't have to re-parse and re-traverse the same file from scratch just
+// to recover metadata this babel pass already computed. Keyed by the file's
+// path, normalized the same way on both sides (see normalizeHmrCacheFilename
+// / lib/hmr.ts's normalizePath) since both run against the same on-disk
+// file within the same Vite transform pipeline pass.
+//
+// This assumes babel never truly interleaves two files' Program visitors in
+// a way that corrupts a single file's own derived data -- see the
+// `hotAstProcessor.meta.babelProgram === path.node` guard at the write site
+// below, which detects (and skips caching for) the case where a concurrent
+// babel pass for a *different* file has reset the shared `hotAstProcessor`
+// singleton in between. On any doubt, lib/hmr.ts falls back to its own
+// from-source parse, which is always correct, just slower.
+export const hmrImportMetadataCache = new Map();
+export function normalizeHmrCacheFilename(filename) {
+    return filename.split('?')[0].replace(/\\/g, '/');
+}
+function computeImportStatements(programBody, bindings) {
+    const importStatements = [];
+    for (const statement of programBody) {
+        if (statement.type !== 'ImportDeclaration')
+            continue;
+        for (const specifier of statement.specifiers) {
+            const local = specifier.local.name;
+            if (!bindings.has(local))
+                continue;
+            let specifierName = 'default';
+            if (specifier.type === 'ImportSpecifier') {
+                const imported = specifier.imported;
+                specifierName =
+                    imported.type === 'Identifier' ? imported.name : imported.value;
+            }
+            else if (specifier.type === 'ImportNamespaceSpecifier') {
+                specifierName = '*';
+            }
+            importStatements.push({
+                local,
+                source: statement.source.value,
+                specifier: specifierName,
+            });
+        }
+    }
+    return importStatements;
+}
+// Rewrites `<Foo />`/`{{foo}}`/`(helper "foo")`-style template references to
+// a statically imported binding through a per-module `template__imports__`
+// class instance instead, so swapping which module a virtual HMR wrapper
+// resolves to (see lib/hmr.ts's `transform` hook) is visible to templates
+// without re-evaluating the whole module. `transform` below is registered
+// as an `ember-template-compilation` transform (see test-app/babel.config.mjs
+// and tests/babel-plugin.test.js), separate from -- and running before --
+// the js-level `hotReplaceAst` babel plugin in ../babel-plugin.ts, which is
+// why the bookkeeping this class accumulates (`meta.importBindings` etc.) is
+// read back later by that plugin's `Program` visitor (see
+// `finalizeTemplateImports` below) to actually emit the `template__imports__`
+// class declaration.
+class HotAstProcessor {
+    constructor() {
+        this.options = {
+            itsStatic: false,
+        };
+        this.counter = 0;
+        this.meta = {
+            locals: new Set(),
+            importVar: null,
+            babelProgram: undefined,
+            importBindings: new Set(),
+        };
+        this.didCreateImportClass = false;
+        this.transform = this.transform.bind(this);
+    }
+    reset() {
+        this.meta.importVar = null;
+        this.meta.babelProgram = undefined;
+        this.meta.importBindings = new Set();
+    }
+    transform(env) {
+        var _a;
+        if (process.env.EMBER_VITE_HMR_ENABLED !== 'true') {
+            return {
+                visitor: {},
+            };
+        }
+        if ((_a = env.filename) === null || _a === void 0 ? void 0 : _a.includes('node_modules')) {
+            return {
+                visitor: {},
+            };
+        }
+        const meta = this.meta;
+        const importVar = env.meta.jsutils.bindExpression(meta.importVar || 'null', null, {
+            nameHint: 'template__imports__',
+        });
+        meta.importVar = meta.importVar || importVar;
+        return {
+            visitor: Object.assign({}, this.buildVisitor({
+                importVar,
+                importBindings: meta.importBindings,
+                babelProgram: meta.babelProgram,
+            })),
+        };
+    }
+    buildVisitor({ importVar, importBindings, babelProgram, }) {
+        const findImport = function findImport(specifier) {
+            return babelProgram.body.find((b) => b.type === 'ImportDeclaration' &&
+                b.specifiers.some((s) => s.local.name === specifier));
+        };
+        const findBlockParams = function (expression, p) {
+            if (p.node.type === 'Template') {
+                return false;
+            }
+            if (p.node &&
+                p.node.type === 'BlockStatement' &&
+                p.node.program.blockParams.includes(expression)) {
+                return true;
+            }
+            const node = p.node;
+            if (node && node.blockParams && node.blockParams.includes(expression)) {
+                return true;
+            }
+            if (!p.parent)
+                return false;
+            return findBlockParams(expression, p.parent);
+        };
+        const visitor = {
+            PathExpression: (node, p) => {
+                var _a, _b;
+                if ((((_a = p.parentNode) === null || _a === void 0 ? void 0 : _a.type) === 'SubExpression' ||
+                    ((_b = p.parentNode) === null || _b === void 0 ? void 0 : _b.type) === 'MustacheStatement') &&
+                    p.parentNode.params.includes(node)) {
+                    return;
+                }
+                const original = node.original.split('.')[0];
+                if (original === 'this')
+                    return;
+                if (original.startsWith('@'))
+                    return;
+                if (original === 'block')
+                    return;
+                if (original.startsWith('this.'))
+                    return;
+                if (findBlockParams(original, p))
+                    return;
+                if (node.original === 'helper' ||
+                    node.original === 'component' ||
+                    node.original === 'modifier') {
+                    // node.original;
+                    const parent = p.parentNode;
+                    if (typeof parent.params[0].original !==
+                        'string') {
+                        return;
+                    }
+                    const original = parent.params[0].original.split('.')[0];
+                    if (original && findBlockParams(original, p))
+                        return;
+                    if (original === null || original === void 0 ? void 0 : original.includes('.'))
+                        return;
+                    if (!original)
+                        return;
+                    if (findImport(original)) {
+                        const param = glimmer.builders.path(`${importVar}.${original}`);
+                        parent.params.splice(0, 1, param);
+                        importBindings.add(original);
+                    }
+                    return;
+                }
+                if (importVar) {
+                    if (findImport(node.original)) {
+                        node.original = `${importVar}.${node.original}`;
+                        node.parts = node.original.split('.');
+                        importBindings.add(original);
+                    }
+                    return;
+                }
+            },
+            ElementNode: (element, p) => {
+                const original = element.tag.split('.')[0];
+                if (findBlockParams(original, p))
+                    return;
+                if (importVar) {
+                    if (findImport(original)) {
+                        element.tag = `${importVar}.${original}`;
+                        p.node.tag = element.tag;
+                        importBindings.add(original);
+                    }
+                    return;
+                }
+            },
+        };
+        return visitor;
+    }
+}
+export const hotAstProcessor = new HotAstProcessor();
+// Emits the `template__imports__` class the templates rewritten by
+// `HotAstProcessor.transform` above reference, once per module -- run from
+// the js babel plugin's own `Program` visitor (not `HotAstProcessor` itself)
+// since it needs `ImportUtil`/babel `types` to generate js AST, whereas the
+// processor above only ever produces hbs AST.
+export function finalizeTemplateImports(babel, path, filename) {
+    const t = babel.types;
+    if (!hotAstProcessor.meta.importVar ||
+        hotAstProcessor.meta.importBindings.size === 0) {
+        return;
+    }
+    const util = new ImportUtil(babel, path);
+    const tracked = util.import(path, '@glimmer/tracking', 'tracked');
+    util.import(path, '@glimmer/component', 'default');
+    const klass = t.classExpression(path.scope.generateUidIdentifier('Imports'), null, t.classBody([]));
+    const bindings = [...hotAstProcessor.meta.importBindings].sort();
+    for (const local of bindings) {
+        klass.body.body.push(t.classProperty(t.identifier(local), t.identifier(local), null, [
+            t.decorator(tracked),
+        ]));
+    }
+    const newExp = t.newExpression(klass, []);
+    const assign = t.assignmentExpression('=', t.identifier(hotAstProcessor.meta.importVar), newExp);
+    const varDeclaration = path.node.body.findIndex((e) => e.type === 'VariableDeclaration' &&
+        e.declarations[0].id.name ===
+            hotAstProcessor.meta.importVar) + 1;
+    const lastImportIndex = path.node.body.findLastIndex((e) => e.type === 'ImportDeclaration') + 1;
+    path.node.body.splice(Math.max(varDeclaration, lastImportIndex), 0, t.expressionStatement(assign));
+    // Export metadata about tracked imports for hmr.ts to use
+    const importMetadata = t.variableDeclaration('const', [
+        t.variableDeclarator(t.identifier('__hmr_import_metadata__'), t.objectExpression([
+            t.objectProperty(t.identifier('importVar'), t.stringLiteral(hotAstProcessor.meta.importVar)),
+            t.objectProperty(t.identifier('bindings'), t.arrayExpression(bindings.map((b) => t.stringLiteral(b)))),
+        ])),
+    ]);
+    const exportMetadata = t.exportNamedDeclaration(importMetadata, []);
+    path.node.body.push(exportMetadata);
+    // Share the metadata just computed above with lib/hmr.ts via the
+    // in-process cache (see hmrImportMetadataCache's own comment). Only trust
+    // `hotAstProcessor.meta` here if it's still the same Program node `pre()`
+    // set it up for -- if a concurrent babel pass for a *different* file
+    // reset the shared singleton in between (see hmrImportMetadataCache's doc
+    // comment), `meta.babelProgram` would point at that other file's AST (or
+    // be undefined) instead of `path.node`, and this file's data must not be
+    // cached under this file's key.
+    if (filename && hotAstProcessor.meta.babelProgram === path.node) {
+        hmrImportMetadataCache.set(normalizeHmrCacheFilename(filename), {
+            importVar: hotAstProcessor.meta.importVar,
+            bindings,
+            importStatements: computeImportStatements(path.node.body, hotAstProcessor.meta.importBindings),
+        });
+    }
+    path.scope.crawl();
+}

package/dist/lib/babel-plugin.d.ts

@@ -1,34 +1,6 @@
 import { PluginObj } from '@babel/core';
-import { Program } from '@babel/types';
 import type * as Babel from '@babel/core';
-import { NodeVisitor } from '@glimmer/syntax';
-interface ASTPluginEnvironment {
-    locals: string[];
-    filename: string;
-}
-declare class HotAstProcessor {
-    options: {
-        itsStatic: boolean;
-    };
-    counter: number;
-    meta: {
-        locals: Set<string>;
-        importVar: string | null;
-        importBindings: Set<string>;
-        babelProgram?: Program;
-    };
-    didCreateImportClass: boolean;
-    constructor();
-    reset(): void;
-    transform(env: ASTPluginEnvironment): {
-        visitor: Record<string, unknown>;
-    };
-    buildVisitor({ importVar, importBindings, babelProgram, }: {
-        importVar: string;
-        importBindings: Set<string>;
-        babelProgram: Program;
-    }): NodeVisitor;
-}
-export declare const hotAstProcessor: HotAstProcessor;
+import { hotAstProcessor, hmrImportMetadataCache, normalizeHmrCacheFilename } from './babel-plugin/template-imports.js';
+export type { HmrImportStatement, HmrImportMetadata, } from './babel-plugin/template-imports.js';
+export { hotAstProcessor, hmrImportMetadataCache, normalizeHmrCacheFilename };
 export default function hotReplaceAst(babel: typeof Babel): PluginObj;
-export {};