@oddsquad/vite-plugin-lit 0.2.2 → 0.3.0

package/lib/runtime/patch.js

@@ -18,7 +18,11 @@
  * it never imports lit (keeps it version-agnostic and safe for non-Lit
  * custom elements, which get prototype/static patching only).
  */
-import { subscribeOverride } from './overrides.js';
+import {subscribeOverride} from './overrides.js';
+import {
+  HMR_INCOMPATIBLE_CHANNEL,
+  describeHmrReason,
+} from '../../types/hmr-incompatibility.js';
 // Exactly one patch state per page, even if this module loads twice.
 const STATE_KEY = Symbol.for('@lit-labs/vite-plugin-lit#patch');
 // Brands our lifecycle wrappers so re-instrumentation is idempotent.
@@ -26,8 +30,8 @@ const RECORD_BRAND = Symbol.for('@lit-labs/vite-plugin-lit#wrapperRecord');
 const PROTO_SKIP = ['constructor'];
 const STATIC_SKIP = ['prototype', 'name', 'length'];
 const ownKeys = (o) => [
-    ...Object.getOwnPropertyNames(o),
-    ...Object.getOwnPropertySymbols(o),
+  ...Object.getOwnPropertyNames(o),
+  ...Object.getOwnPropertySymbols(o),
 ];
 /**
  * Syncs own members `source` → `target`: deletes own keys of `target` that
@@ -36,30 +40,32 @@ const ownKeys = (o) => [
  */
 // Exported for unit testing; otherwise module-internal.
 export const syncOwnMembers = (target, source, skip) => {
-    for (const key of ownKeys(target)) {
-        if (skip.includes(key)) {
-            continue;
-        }
-        if (Object.getOwnPropertyDescriptor(source, key) === undefined) {
-            try {
-                delete target[key];
-            }
-            catch {
-                // Non-configurable; leave it.
-            }
-        }
+  for (const key of ownKeys(target)) {
+    if (skip.includes(key)) {
+      continue;
     }
-    for (const key of ownKeys(source)) {
-        if (skip.includes(key)) {
-            continue;
-        }
-        try {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        }
-        catch {
-            // Non-configurable; leave it.
-        }
+    if (Object.getOwnPropertyDescriptor(source, key) === undefined) {
+      try {
+        delete target[key];
+      } catch {
+        // Non-configurable; leave it.
+      }
+    }
+  }
+  for (const key of ownKeys(source)) {
+    if (skip.includes(key)) {
+      continue;
     }
+    try {
+      Object.defineProperty(
+        target,
+        key,
+        Object.getOwnPropertyDescriptor(source, key)
+      );
+    } catch {
+      // Non-configurable; leave it.
+    }
+  }
 };
 /**
  * Defines branded `connectedCallback`/`disconnectedCallback` wrappers on the
@@ -68,44 +74,41 @@ export const syncOwnMembers = (target, source, skip) => {
  * deletes the wrappers).
  */
 const instrument = (state, proto, record) => {
-    for (const name of [
-        'connectedCallback',
-        'disconnectedCallback',
-    ]) {
-        const own = Object.getOwnPropertyDescriptor(proto, name);
-        if (own?.value?.[RECORD_BRAND] === record) {
-            continue;
-        }
-        // May be an own raw function (just copied from the new class), an
-        // inherited base implementation, or absent entirely.
-        const original = proto[name];
-        const wrapper = name === 'connectedCallback'
-            ? function () {
-                record.instances.add(this);
-                const stamp = state.generationOf.get(this);
-                if (stamp !== undefined && stamp !== record.generation) {
-                    // Was detached during one or more patches; catch up.
-                    this.requestUpdate?.();
-                }
-                state.generationOf.set(this, record.generation);
-                original?.call(this);
+  for (const name of ['connectedCallback', 'disconnectedCallback']) {
+    const own = Object.getOwnPropertyDescriptor(proto, name);
+    if (own?.value?.[RECORD_BRAND] === record) {
+      continue;
+    }
+    // May be an own raw function (just copied from the new class), an
+    // inherited base implementation, or absent entirely.
+    const original = proto[name];
+    const wrapper =
+      name === 'connectedCallback'
+        ? function () {
+            record.instances.add(this);
+            const stamp = state.generationOf.get(this);
+            if (stamp !== undefined && stamp !== record.generation) {
+              // Was detached during one or more patches; catch up.
+              this.requestUpdate?.();
             }
-            : function () {
-                record.instances.delete(this);
-                original?.call(this);
-            };
-        wrapper[RECORD_BRAND] = record;
-        try {
-            Object.defineProperty(proto, name, {
-                value: wrapper,
-                writable: true,
-                configurable: true,
-            });
-        }
-        catch {
-            // Non-configurable lifecycle slot; tracking degrades gracefully.
-        }
+            state.generationOf.set(this, record.generation);
+            original?.call(this);
+          }
+        : function () {
+            record.instances.delete(this);
+            original?.call(this);
+          };
+    wrapper[RECORD_BRAND] = record;
+    try {
+      Object.defineProperty(proto, name, {
+        value: wrapper,
+        writable: true,
+        configurable: true,
+      });
+    } catch {
+      // Non-configurable lifecycle slot; tracking degrades gracefully.
     }
+  }
 };
 /**
  * Detects standard-decorator (`accessor`) reactive properties on the new
@@ -113,26 +116,24 @@ const instrument = (state, proto, record) => {
  * accessors would brand-check-throw — in-place patching is impossible.
  */
 const usesStandardDecorators = (ctor) => {
-    const metadataSymbol = Symbol.metadata;
-    if (metadataSymbol === undefined) {
-        return false;
-    }
-    const metadata = Object.getOwnPropertyDescriptor(ctor, metadataSymbol)
-        ?.value;
-    if (metadata === undefined || metadata === null) {
-        return false;
-    }
-    // litPropertyMetadata is a Lit internal (not public API). Guard against
-    // rename, removal, or shape changes — a false negative here means we try
-    // to hot-patch and crash, which is handled by the outer catch in hotPatch.
-    try {
-        const litPropertyMetadata = globalThis.litPropertyMetadata;
-        const properties = litPropertyMetadata?.get(metadata);
-        return properties !== undefined && properties.size > 0;
-    }
-    catch {
-        return false;
-    }
+  const metadataSymbol = Symbol.metadata;
+  if (metadataSymbol === undefined) {
+    return false;
+  }
+  const metadata = Object.getOwnPropertyDescriptor(ctor, metadataSymbol)?.value;
+  if (metadata === undefined || metadata === null) {
+    return false;
+  }
+  // litPropertyMetadata is a Lit internal (not public API). Guard against
+  // rename, removal, or shape changes — a false negative here means we try
+  // to hot-patch and crash, which is handled by the outer catch in hotPatch.
+  try {
+    const litPropertyMetadata = globalThis.litPropertyMetadata;
+    const properties = litPropertyMetadata?.get(metadata);
+    return properties !== undefined && properties.size > 0;
+  } catch {
+    return false;
+  }
 };
 /**
  * Resolves a static `elementStyles` array to its constructed `CSSStyleSheet`s.
@@ -140,19 +141,15 @@ const usesStandardDecorators = (ctor) => {
  * stylesheet support), so callers can bail rather than adopt a partial list.
  */
 const stylesToSheets = (styles) => {
-    if (!Array.isArray(styles))
-        return null;
-    const sheets = [];
-    for (const style of styles) {
-        const sheet = style instanceof CSSStyleSheet
-            ? style
-            : (style?.styleSheet ??
-                undefined);
-        if (!(sheet instanceof CSSStyleSheet))
-            return null;
-        sheets.push(sheet);
-    }
-    return sheets;
+  if (!Array.isArray(styles)) return null;
+  const sheets = [];
+  for (const style of styles) {
+    const sheet =
+      style instanceof CSSStyleSheet ? style : (style?.styleSheet ?? undefined);
+    if (!(sheet instanceof CSSStyleSheet)) return null;
+    sheets.push(sheet);
+  }
+  return sheets;
 };
 /**
  * Re-adopts constructed stylesheets on an instance's shadow root from the
@@ -165,211 +162,253 @@ const stylesToSheets = (styles) => {
  * whole list.
  */
 const readoptStyles = (el, oldSheets) => {
-    const root = el.renderRoot;
-    if (typeof ShadowRoot === 'undefined' || !(root instanceof ShadowRoot)) {
-        return;
-    }
-    const sheets = stylesToSheets(el.constructor.elementStyles);
-    if (sheets === null) {
-        return;
-    }
-    const drop = new Set(oldSheets);
-    const ours = new Set(sheets);
-    // Our styles go first, matching Lit's own order (extra sheets appended).
-    const preserved = [...root.adoptedStyleSheets].filter((s) => !drop.has(s) && !ours.has(s));
-    root.adoptedStyleSheets = [...sheets, ...preserved];
+  const root = el.renderRoot;
+  if (typeof ShadowRoot === 'undefined' || !(root instanceof ShadowRoot)) {
+    return;
+  }
+  const sheets = stylesToSheets(el.constructor.elementStyles);
+  if (sheets === null) {
+    return;
+  }
+  const drop = new Set(oldSheets);
+  const ours = new Set(sheets);
+  // Our styles go first, matching Lit's own order (extra sheets appended).
+  const preserved = [...root.adoptedStyleSheets].filter(
+    (s) => !drop.has(s) && !ours.has(s)
+  );
+  root.adoptedStyleSheets = [...sheets, ...preserved];
 };
+/**
+ * Builds the structured event reported over {@link HMR_INCOMPATIBLE_CHANNEL}.
+ * Exported for unit testing; otherwise module-internal. Whether the send
+ * survives the `location.reload()` that may follow it can only be checked by
+ * hand against a real dev server.
+ */
+export const buildHmrIncompatibleEvent = (tagName, reason, action) => ({
+  tagName,
+  time: Date.now(),
+  reason,
+  action,
+});
 const incompatible = (state, tagName, reason) => {
-    if (state.options.onIncompatible === 'warn') {
-        console.warn(`[lit-plugin] <${tagName}> can't be hot-patched (${reason}). ` +
-            `Reload the page to pick up the change.`);
-    }
-    else {
-        console.info(`[lit-plugin] <${tagName}>: ${reason} — performing full reload.`);
-        location.reload();
-    }
+  const message = describeHmrReason(reason);
+  const action = state.options.onIncompatible === 'warn' ? 'warn' : 'reload';
+  state.hot?.send(
+    HMR_INCOMPATIBLE_CHANNEL,
+    buildHmrIncompatibleEvent(tagName, reason, action)
+  );
+  if (state.options.onIncompatible === 'warn') {
+    console.warn(
+      `[lit-plugin] <${tagName}> can't be hot-patched (${message}). ` +
+        `Reload the page to pick up the change.`
+    );
+  } else {
+    console.info(
+      `[lit-plugin] <${tagName}>: ${message} — performing full reload.`
+    );
+    location.reload();
+  }
 };
 /**
  * Patches the originally-registered class for `record.tagName` in place
  * from the freshly evaluated `NewClass`, then updates live instances.
  */
 const hotPatch = (state, record, NewClass) => {
-    const OldClass = record.canonical;
-    try {
-        // 1. Materialize finalized/elementProperties/elementStyles/
-        //    __attributeToPropertyMap on the new class before we copy statics.
-        if (typeof NewClass.finalize === 'function') {
-            NewClass.finalize();
-        }
-        // 2. Standard-decorator `accessor` properties can't be patched in place.
-        if (usesStandardDecorators(NewClass)) {
-            incompatible(state, record.tagName, 'standard accessor decorators');
-            return;
-        }
-        // The platform snapshots observedAttributes at define time; new
-        // attribute observations can't take effect without a reload.
-        const oldObserved = [...(OldClass.observedAttributes ?? [])];
-        const newObserved = [...(NewClass.observedAttributes ?? [])];
-        // 3. Snapshot reactive property values per live instance through the
-        //    OLD accessors. Vite serves prod lit in dev (no `development`
-        //    export condition), where accessor storage keys are unique
-        //    Symbol()s per class evaluation — without this, state resets.
-        const propertyKeys = new Set([
-            ...(OldClass.elementProperties?.keys() ?? []),
-            ...(NewClass.elementProperties?.keys() ?? []),
-        ]);
-        const snapshots = new Map();
-        for (const el of record.instances) {
-            const values = new Map();
-            for (const key of propertyKeys) {
-                values.set(key, el[key]);
-            }
-            snapshots.set(el, values);
-        }
-        // 4. Re-parent prototype chains. Mixins regenerate intermediate classes
-        //    on every module evaluation, so the parents usually differ.
-        const newProtoParent = Object.getPrototypeOf(NewClass.prototype);
-        if (Object.getPrototypeOf(OldClass.prototype) !== newProtoParent) {
-            Object.setPrototypeOf(OldClass.prototype, newProtoParent);
-        }
-        const newStaticParent = Object.getPrototypeOf(NewClass);
-        if (Object.getPrototypeOf(OldClass) !== newStaticParent) {
-            Object.setPrototypeOf(OldClass, newStaticParent);
-        }
-        // Capture the sheets the OLD class contributed before the static sync
-        // overwrites `elementStyles`, so readoptStyles can drop exactly those and
-        // leave imperatively-adopted sheets in place.
-        const oldSheets = stylesToSheets(OldClass.elementStyles) ?? [];
-        // 5. Sync own members new → old on the prototype and on statics.
-        syncOwnMembers(OldClass.prototype, NewClass.prototype, PROTO_SKIP);
-        syncOwnMembers(OldClass, NewClass, STATIC_SKIP);
-        // 6. The sync replaced/removed our lifecycle wrappers; re-instrument.
-        instrument(state, OldClass.prototype, record);
-        record.generation++;
-        // Module-local `instanceof NewClass` checks keep working against
-        // instances of the canonical class.
-        Object.defineProperty(NewClass, Symbol.hasInstance, {
-            value: (instance) => typeof instance === 'object' &&
-                instance !== null &&
-                OldClass.prototype.isPrototypeOf(instance),
-            configurable: true,
-        });
-        if (oldObserved.length !== newObserved.length ||
-            oldObserved.some((attr, i) => attr !== newObserved[i])) {
-            console.info(`[lit-plugin] <${record.tagName}> changed observedAttributes; the ` +
-                `platform registry can't pick this up — reload recommended.`);
+  const OldClass = record.canonical;
+  try {
+    // 1. Materialize finalized/elementProperties/elementStyles/
+    //    __attributeToPropertyMap on the new class before we copy statics.
+    if (typeof NewClass.finalize === 'function') {
+      NewClass.finalize();
+    }
+    // 2. Standard-decorator `accessor` properties can't be patched in place.
+    if (usesStandardDecorators(NewClass)) {
+      incompatible(state, record.tagName, {code: 'accessor-decorators'});
+      return;
+    }
+    // The platform snapshots observedAttributes at define time; new
+    // attribute observations can't take effect without a reload.
+    const oldObserved = [...(OldClass.observedAttributes ?? [])];
+    const newObserved = [...(NewClass.observedAttributes ?? [])];
+    // 3. Snapshot reactive property values per live instance through the
+    //    OLD accessors. Vite serves prod lit in dev (no `development`
+    //    export condition), where accessor storage keys are unique
+    //    Symbol()s per class evaluation — without this, state resets.
+    const propertyKeys = new Set([
+      ...(OldClass.elementProperties?.keys() ?? []),
+      ...(NewClass.elementProperties?.keys() ?? []),
+    ]);
+    const snapshots = new Map();
+    for (const el of record.instances) {
+      const values = new Map();
+      for (const key of propertyKeys) {
+        values.set(key, el[key]);
+      }
+      snapshots.set(el, values);
+    }
+    // 4. Re-parent prototype chains. Mixins regenerate intermediate classes
+    //    on every module evaluation, so the parents usually differ.
+    const newProtoParent = Object.getPrototypeOf(NewClass.prototype);
+    if (Object.getPrototypeOf(OldClass.prototype) !== newProtoParent) {
+      Object.setPrototypeOf(OldClass.prototype, newProtoParent);
+    }
+    const newStaticParent = Object.getPrototypeOf(NewClass);
+    if (Object.getPrototypeOf(OldClass) !== newStaticParent) {
+      Object.setPrototypeOf(OldClass, newStaticParent);
+    }
+    // Capture the sheets the OLD class contributed before the static sync
+    // overwrites `elementStyles`, so readoptStyles can drop exactly those and
+    // leave imperatively-adopted sheets in place.
+    const oldSheets = stylesToSheets(OldClass.elementStyles) ?? [];
+    // 5. Sync own members new → old on the prototype and on statics.
+    syncOwnMembers(OldClass.prototype, NewClass.prototype, PROTO_SKIP);
+    syncOwnMembers(OldClass, NewClass, STATIC_SKIP);
+    // 6. The sync replaced/removed our lifecycle wrappers; re-instrument.
+    instrument(state, OldClass.prototype, record);
+    record.generation++;
+    // Module-local `instanceof NewClass` checks keep working against
+    // instances of the canonical class.
+    Object.defineProperty(NewClass, Symbol.hasInstance, {
+      value: (instance) =>
+        typeof instance === 'object' &&
+        instance !== null &&
+        OldClass.prototype.isPrototypeOf(instance),
+      configurable: true,
+    });
+    if (
+      oldObserved.length !== newObserved.length ||
+      oldObserved.some((attr, i) => attr !== newObserved[i])
+    ) {
+      console.info(
+        `[lit-plugin] <${record.tagName}> changed observedAttributes; the ` +
+          `platform registry can't pick this up — reload recommended.`
+      );
+      state.hot?.send(
+        HMR_INCOMPATIBLE_CHANNEL,
+        buildHmrIncompatibleEvent(
+          record.tagName,
+          {code: 'observed-attributes-changed'},
+          'none'
+        )
+      );
+    }
+    // 7. Update live instances.
+    const newPropertyKeys = NewClass.elementProperties?.keys() ?? [];
+    // After the static sync this is the NEW class's initializer list.
+    const initializers = OldClass._initializers;
+    // Snapshot: the reconnect below mutates record.instances mid-iteration.
+    // oxlint-disable-next-line unicorn/no-useless-spread
+    for (const el of [...record.instances]) {
+      if (state.options.reconnect) {
+        el.disconnectedCallback?.();
+        el.connectedCallback?.();
+      }
+      // Decorator-created reactive controllers (e.g. @lit/context's
+      // @provide/@consume) live in per-class-evaluation closures keyed by
+      // instance via addInitializer. Re-running the initializers enrolls
+      // live instances in the new closures — without this, the first
+      // assignment through a copied accessor throws and we'd full-reload.
+      // Controllers from previous evaluations stay attached but inert
+      // (everything flows through the newest closures); that's bounded by
+      // edit count and dev-only. Runs before the value restore so e.g. a
+      // re-created ContextProvider exists when the restore pushes into it.
+      if (Array.isArray(initializers)) {
+        for (const initialize of initializers) {
+          initialize(el);
         }
-        // 7. Update live instances.
-        const newPropertyKeys = NewClass.elementProperties?.keys() ?? [];
-        // After the static sync this is the NEW class's initializer list.
-        const initializers = OldClass._initializers;
-        for (const el of [...record.instances]) {
-            if (state.options.reconnect) {
-                el.disconnectedCallback?.();
-                el.connectedCallback?.();
-            }
-            // Decorator-created reactive controllers (e.g. @lit/context's
-            // @provide/@consume) live in per-class-evaluation closures keyed by
-            // instance via addInitializer. Re-running the initializers enrolls
-            // live instances in the new closures — without this, the first
-            // assignment through a copied accessor throws and we'd full-reload.
-            // Controllers from previous evaluations stay attached but inert
-            // (everything flows through the newest closures); that's bounded by
-            // edit count and dev-only. Runs before the value restore so e.g. a
-            // re-created ContextProvider exists when the restore pushes into it.
-            if (Array.isArray(initializers)) {
-                for (const initialize of initializers) {
-                    initialize(el);
-                }
-            }
-            const values = snapshots.get(el);
-            if (values !== undefined) {
-                // Restore through the new accessors — only keys the new class
-                // still declares.
-                for (const key of newPropertyKeys) {
-                    if (values.has(key)) {
-                        el[key] =
-                            values.get(key);
-                    }
-                }
-            }
-            readoptStyles(el, oldSheets);
-            state.generationOf.set(el, record.generation);
-            el.requestUpdate?.();
+      }
+      const values = snapshots.get(el);
+      if (values !== undefined) {
+        // Restore through the new accessors — only keys the new class
+        // still declares.
+        for (const key of newPropertyKeys) {
+          if (values.has(key)) {
+            el[key] = values.get(key);
+          }
         }
+      }
+      readoptStyles(el, oldSheets);
+      state.generationOf.set(el, record.generation);
+      el.requestUpdate?.();
     }
-    catch (e) {
-        incompatible(state, record.tagName, `patching failed: ${e instanceof Error ? e.message : String(e)}`);
-    }
+  } catch (e) {
+    incompatible(state, record.tagName, {
+      code: 'patch-failed',
+      detail: e instanceof Error ? e.message : String(e),
+    });
+  }
 };
 /**
  * Installs the `customElements.define` interceptor. Idempotent (per-page
  * global guard); no-ops in environments without `customElements` (SSR).
  */
 export const install = (options = {}) => {
-    if (typeof customElements === 'undefined') {
-        return;
+  if (typeof customElements === 'undefined') {
+    return;
+  }
+  const g = globalThis;
+  const existing = g[STATE_KEY];
+  if (existing !== undefined) {
+    // Already installed; refresh explicitly-provided options only.
+    if (options.reconnect !== undefined) {
+      existing.options.reconnect = options.reconnect;
     }
-    const g = globalThis;
-    const existing = g[STATE_KEY];
-    if (existing !== undefined) {
-        // Already installed; refresh explicitly-provided options only.
-        if (options.reconnect !== undefined) {
-            existing.options.reconnect = options.reconnect;
-        }
-        if (options.onIncompatible !== undefined) {
-            existing.options.onIncompatible = options.onIncompatible;
-        }
-        return;
+    if (options.onIncompatible !== undefined) {
+      existing.options.onIncompatible = options.onIncompatible;
     }
-    const state = {
-        records: new Map(),
-        generationOf: new WeakMap(),
-        options: {
-            reconnect: options.reconnect ?? false,
-            onIncompatible: options.onIncompatible ?? 'reload',
-        },
-    };
-    g[STATE_KEY] = state;
-    // Let the DevTools panel override these behaviours live (and persist across
-    // reloads) on top of the config-time defaults above.
-    subscribeOverride(import.meta.hot, (o) => {
-        if (o.hmrReconnect !== undefined)
-            state.options.reconnect = o.hmrReconnect;
-        if (o.hmrOnIncompatible !== undefined) {
-            state.options.onIncompatible = o.hmrOnIncompatible;
-        }
-    });
-    const nativeDefine = customElements.define;
-    customElements.define = function (name, ctor, defineOptions) {
-        let record = state.records.get(name);
-        if (record === undefined && this.get(name) !== undefined) {
-            // Defined before install() ran (shouldn't happen — the installer is
-            // import-hoisted — but recover gracefully without instance tracking).
-            record = {
-                tagName: name,
-                canonical: this.get(name),
-                instances: new Set(),
-                generation: 0,
-            };
-            state.records.set(name, record);
-        }
-        if (record === undefined) {
-            record = {
-                tagName: name,
-                canonical: ctor,
-                instances: new Set(),
-                generation: 0,
-            };
-            state.records.set(name, record);
-            instrument(state, ctor.prototype, record);
-            return nativeDefine.call(this, name, ctor, defineOptions);
-        }
-        if (ctor === record.canonical) {
-            // Same class object re-defined; nothing to patch.
-            return;
-        }
-        hotPatch(state, record, ctor);
-    };
+    return;
+  }
+  const hot = import.meta.hot;
+  const state = {
+    records: new Map(),
+    generationOf: new WeakMap(),
+    options: {
+      reconnect: options.reconnect ?? false,
+      onIncompatible: options.onIncompatible ?? 'reload',
+    },
+    hot,
+  };
+  g[STATE_KEY] = state;
+  // Let the DevTools panel override these behaviours live (and persist across
+  // reloads) on top of the config-time defaults above.
+  subscribeOverride(hot, (o) => {
+    if (o.hmrReconnect !== undefined) state.options.reconnect = o.hmrReconnect;
+    if (o.hmrOnIncompatible !== undefined) {
+      state.options.onIncompatible = o.hmrOnIncompatible;
+    }
+  });
+  // Captured to re-invoke below as nativeDefine.call(this, ...).
+  // oxlint-disable-next-line typescript/unbound-method
+  const nativeDefine = customElements.define;
+  customElements.define = function (name, ctor, defineOptions) {
+    let record = state.records.get(name);
+    if (record === undefined && this.get(name) !== undefined) {
+      // Defined before install() ran (shouldn't happen — the installer is
+      // import-hoisted — but recover gracefully without instance tracking).
+      record = {
+        tagName: name,
+        canonical: this.get(name),
+        instances: new Set(),
+        generation: 0,
+      };
+      state.records.set(name, record);
+    }
+    if (record === undefined) {
+      record = {
+        tagName: name,
+        canonical: ctor,
+        instances: new Set(),
+        generation: 0,
+      };
+      state.records.set(name, record);
+      instrument(state, ctor.prototype, record);
+      return nativeDefine.call(this, name, ctor, defineOptions);
+    }
+    if (ctor === record.canonical) {
+      // Same class object re-defined; nothing to patch.
+      return;
+    }
+    hotPatch(state, record, ctor);
+  };
 };
-//# sourceMappingURL=patch.js.map
+//# sourceMappingURL=patch.js.map