@@ -709,7 +709,7 @@ function createDictionaryConverter(
   };
 
   const dictionaries = ArrayIsArray(members[0]) ? members : [members];
-  const sortedDictionaries = [];
+  const sortedMembers = [];
 
   function ownMember(member, key) {
     return ObjectPrototypeHasOwnProperty(member, key) ? member[key] : undefined;
@@ -723,7 +723,7 @@ function createDictionaryConverter(
   // from least-derived to most-derived and sort only within each dictionary.
   // Callers with inheritance pass one member array per dictionary level.
   for (let i = 0; i < dictionaries.length; i++) {
-    const sortedMembers = ArrayPrototypeToSorted(
+    const sortedDictionary = ArrayPrototypeToSorted(
       dictionaries[i],
       compareMembers,
     );
@@ -732,22 +732,21 @@ function createDictionaryConverter(
     // Re-materialize each descriptor once with every key present, copied from
     // own properties only. The ordinary prototype is deliberate: nothing
     // consults it now, and detaching it measurably slows these reads down.
-    for (let j = 0; j < sortedMembers.length; j++) {
-      const member = sortedMembers[j];
+    for (let j = 0; j < sortedDictionary.length; j++) {
+      const member = sortedDictionary[j];
       const defaultValue = ownMember(member, 'defaultValue');
       const required = ownMember(member, 'required');
       if (typeof defaultValue === 'function' || required) {
         anyMissingMemberHandling = true;
       }
-      sortedMembers[j] = {
+      setOwnProperty(sortedMembers, sortedMembers.length, {
         key: ownMember(member, 'key'),
         converter: ownMember(member, 'converter'),
         defaultValue,
         required,
         validator: ownMember(member, 'validator'),
-      };
+      });
     }
-    ArrayPrototypePush(sortedDictionaries, sortedMembers);
   }
 
   const hasMissingMemberHandling = anyMissingMemberHandling;
@@ -763,43 +762,41 @@ function createDictionaryConverter(
 
     // Step 2: create the IDL dictionary value.
     const idlDict = { __proto__: null };
-
-    // Steps 3-4: iterate each dictionary level, then its sorted members.
-    for (let i = 0; i < sortedDictionaries.length; i++) {
-      const sortedMembers = sortedDictionaries[i];
-      for (let j = 0; j < sortedMembers.length; j++) {
-        const member = sortedMembers[j];
-        // Step 4.1.1: get the dictionary member identifier.
-        const key = member.key;
-        // Steps 4.1.2-4.1.3: read the JavaScript member value.
-        const jsMemberValue = jsDict == null ? undefined : jsDict[key];
-
-        // Step 4.1.4: convert and store present member values.
-        if (jsMemberValue !== undefined) {
-          const converter = member.converter;
-          // Step 4.1.4.1: convert the JavaScript value to IDL.
-          const idlMemberValue = converter(
-            jsMemberValue,
-            makeOptions(options, dictionaryMemberContext(key, options)),
-          );
-          // Validators are a Node.js extension after conversion. They let
-          // consumers reject known unsupported values while dictionary
-          // conversion still has precise member context. Web Crypto uses this
-          // so SubtleCrypto.supports() can make accurate decisions from
-          // normalized dictionaries instead of probing by running operations.
-          member.validator?.(idlMemberValue, jsDict);
-          // Step 4.1.4.2: set idlDict[key] to the IDL value.
-          idlDict[key] = idlMemberValue;
-        } else if (hasMissingMemberHandling) {
-          if (typeof member.defaultValue === 'function') {
-            // Step 4.1.5: store the member default value.
-            idlDict[key] = member.defaultValue();
-          } else if (member.required) {
-            // Step 4.1.6: required missing members throw.
-            throw makeException(
-              missingDictionaryMemberMessage(dictionaryName, key),
-              makeOptions(options, options.context, 'ERR_MISSING_OPTION'));
-          }
+    if (jsDict == null && !hasMissingMemberHandling) return idlDict;
+
+    // Steps 3-4: members retain their per-dictionary order from construction.
+    for (let i = 0; i < sortedMembers.length; i++) {
+      const member = sortedMembers[i];
+      // Step 4.1.1: get the dictionary member identifier.
+      const key = member.key;
+      // Steps 4.1.2-4.1.3: read the JavaScript member value.
+      const jsMemberValue = jsDict == null ? undefined : jsDict[key];
+
+      // Step 4.1.4: convert and store present member values.
+      if (jsMemberValue !== undefined) {
+        const converter = member.converter;
+        // Step 4.1.4.1: convert the JavaScript value to IDL.
+        const idlMemberValue = converter(
+          jsMemberValue,
+          makeOptions(options, dictionaryMemberContext(key, options)),
+        );
+        // Validators are a Node.js extension after conversion. They let
+        // consumers reject known unsupported values while dictionary
+        // conversion still has precise member context. Web Crypto uses this
+        // so SubtleCrypto.supports() can make accurate decisions from
+        // normalized dictionaries instead of probing by running operations.
+        member.validator?.(idlMemberValue, jsDict);
+        // Step 4.1.4.2: set idlDict[key] to the IDL value.
+        idlDict[key] = idlMemberValue;
+      } else if (hasMissingMemberHandling) {
+        if (typeof member.defaultValue === 'function') {
+          // Step 4.1.5: store the member default value.
+          idlDict[key] = member.defaultValue();
+        } else if (member.required) {
+          // Step 4.1.6: required missing members throw.
+          throw makeException(
+            missingDictionaryMemberMessage(dictionaryName, key),
+            makeOptions(options, options.context, 'ERR_MISSING_OPTION'));
         }
       }
     }
 
@@ -0,0 +1,67 @@
+'use strict';
+
+// Flags: --expose-internals
+
+const common = require('../common');
+const assert = require('node:assert/strict');
+const { createDictionaryConverter } = require('internal/webidl');
+
+const groups = [
+  [{ key: 'z', converter: String }, { key: 'b', converter: String }],
+  [{ key: 'c', converter: String }, { key: 'a', converter: String }],
+];
+let convert;
+Object.defineProperty(Array.prototype, 2, {
+  configurable: true,
+  get: common.mustNotCall(),
+  set: common.mustNotCall(),
+});
+try {
+  convert = createDictionaryConverter('Derived', groups);
+} finally {
+  delete Array.prototype[2];
+}
+
+const first = convert(null);
+const second = convert(undefined, new Proxy({}, { get: common.mustNotCall() }));
+assert.deepStrictEqual(first, { __proto__: null });
+assert.deepStrictEqual(second, first);
+assert.notStrictEqual(first, second);
+
+const trace = [];
+const input = {
+  __proto__: { c: 'inherited' },
+  b: {
+    toString: common.mustCall(() => {
+      trace.push('convert b');
+      input.z = 'changed';
+      return 'b';
+    }),
+  },
+  z: 'original',
+  a: 'a',
+};
+const result = convert(new Proxy(input, {
+  get(target, key) { trace.push(key); return target[key]; },
+}));
+assert.deepStrictEqual(trace, ['b', 'convert b', 'z', 'a', 'c']);
+assert.deepStrictEqual(result, { __proto__: null, b: 'b', z: 'changed', a: 'a', c: 'inherited' });
+
+trace.length = 0;
+convert(new Proxy({}, { get(target, key) { trace.push(key); } }));
+assert.deepStrictEqual(trace, ['b', 'z', 'a', 'c']);
+
+const defaults = createDictionaryConverter('Defaults', [[{
+  key: 'z', converter: common.mustNotCall(), defaultValue: common.mustCall(() => [], 2),
+}]]);
+assert.notStrictEqual(defaults(null).z, defaults(undefined).z);
+
+const required = createDictionaryConverter('Required', [[{
+  key: 'z', converter: common.mustNotCall(), defaultValue: common.mustCall(() => 'default', 2),
+}], [
+  { key: 'a', converter: common.mustNotCall(), required: true },
+  { key: 'b', converter: common.mustNotCall(), defaultValue: common.mustNotCall() },
+]]);
+for (const value of [null, undefined]) {
+  assert.throws(() => required(value), { code: 'ERR_MISSING_OPTION' });
+}