fix: backward compatability for did-update

Author: aklkv

package.json

@@ -85,7 +85,7 @@
     "eslint-plugin-ember": "^12.7.5",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-n": "^17.24.0",
-    "globals": "^17.4.0",
+    "globals": "^17.5.0",
     "prettier": "^3.8.2",
     "prettier-plugin-ember-template-tag": "^2.1.4",
     "publint": "^0.3.18",

pnpm-lock.yaml

@@ -0,0 +1,109 @@
+import * as glimmerValidator from '@glimmer/validator';
+
+// Ember apps can provide @glimmer/validator through different module shapes
+// depending on ember-source version and bundling mode. We centralize the
+// resolution logic here so modifiers can always call a single `untrack` API.
+
+type UntrackCallback = () => void;
+type ValidatorRequire = (moduleName: string) => ValidatorModule;
+
+interface ValidatorModule {
+  untrack?: unknown;
+  beginUntrackFrame?: unknown;
+  endUntrackFrame?: unknown;
+}
+
+function getCallable<T extends (...args: never[]) => unknown>(
+  target: unknown,
+  property: string,
+): T | undefined {
+  const value = (target as Record<string, unknown>)[property];
+
+  return typeof value === 'function' ? (value as T) : undefined;
+}
+
+function tryRequire(maybeRequire: ValidatorRequire | undefined) {
+  if (typeof maybeRequire !== 'function') {
+    return undefined;
+  }
+
+  try {
+    return maybeRequire('@glimmer/validator');
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveValidatorModule(): ValidatorModule {
+  const importedModule = glimmerValidator as ValidatorModule;
+  const importedUntrack = getCallable<Untrack>(importedModule, 'untrack');
+  const importedBeginUntrackFrame = getCallable<() => void>(
+    importedModule,
+    'beginUntrackFrame',
+  );
+
+  if (importedUntrack || importedBeginUntrackFrame) {
+    // Modern ESM shape: use the imported namespace directly.
+    return importedModule;
+  }
+
+  const globalWithEmber = globalThis as {
+    Ember?: {
+      __loader?: {
+        require?: (moduleName: string) => ValidatorModule;
+      };
+    };
+    require?: ValidatorRequire;
+    requirejs?: ValidatorRequire;
+  };
+
+  const requireCandidates: Array<ValidatorRequire | undefined> = [
+    globalWithEmber.Ember?.__loader?.require,
+    globalWithEmber.require,
+    globalWithEmber.requirejs,
+  ];
+
+  for (const maybeRequire of requireCandidates) {
+    const module = tryRequire(maybeRequire);
+
+    if (module) {
+      // Older or compat builds: resolve from runtime module loader.
+      return module;
+    }
+  }
+
+  return {};
+}
+
+type Untrack = (callback: UntrackCallback) => void;
+
+export const untrack: Untrack = (() => {
+  const validator = resolveValidatorModule();
+  const moduleUntrack = getCallable<Untrack>(validator, 'untrack');
+
+  if (moduleUntrack) {
+    return moduleUntrack;
+  }
+
+  const beginUntrackFrame = getCallable<() => void>(
+    validator,
+    'beginUntrackFrame',
+  );
+  const endUntrackFrame = getCallable<() => void>(validator, 'endUntrackFrame');
+
+  if (beginUntrackFrame && endUntrackFrame) {
+    // Some validator versions expose frame primitives instead of `untrack`.
+    return (callback: UntrackCallback) => {
+      beginUntrackFrame();
+
+      try {
+        callback();
+      } finally {
+        endUntrackFrame();
+      }
+    };
+  }
+
+  // Last resort for very old/unexpected runtime shapes.
+  return (callback: UntrackCallback) => callback();
+})();

src/-private/untrack.ts

@@ -1,5 +1,5 @@
 import { setModifierManager, capabilities } from '@ember/modifier';
-import { untrack } from '@glimmer/validator';
+import { untrack } from '../-private/untrack.ts';
 
 import type {
   ModifierArgs,