Verifying data restored with structuredClone() when prototypes and descriptors are lost

Answer

For verifying that a structuredClone() snapshot matches the original state, rely on a structural deep‑equality check of the data that the algorithm actually preserves. Schema validation can be added as a second layer only if you already have a formal shape definition; it is not required for basic integrity.

Why structural comparison is enough

• structuredClone() creates a pure structural copy: it keeps own enumerable properties of plain objects, Map, Set, Date, ArrayBuffer etc., but discards prototype chains, turns accessor properties into their current values, skips non‑enumerable own properties, and throws DataCloneError for functions.
• There is no built‑in API to query which fields were dropped; you must compare the original and cloned values yourself.
• A cycle‑safe deep‑equal that inspects own enumerable keys, Map/Set entries, Date.getTime(), ArrayBuffer.byteLength, and recursively nested structures confirms that everything the clone can preserve is present.

Steps for the snapshot‑and‑restore flow

1. Feature‑detect structuredClone (global in browsers, require('node:util').structuredClone or global in recent Node).
2. Take the snapshot: const snapshot = structuredClone(state);
3. Mutate the live state as needed.
4. Restore: const restored = structuredClone(snapshot);
5. Run a cycle‑aware deep equality (deepEqual(state, restored)) that compares:
   • own enumerable object keys and values,
   • Map entries (map.size and map.entries()),
   • Set values,
   • Date timestamps,
   • ArrayBuffer byte lengths,
   • recursively nested structures.
6. If equality passes, the restored data is structurally identical to the snapshot for all data that structuredClone() can preserve.

Handling prototype loss

When downstream code expects class methods or instanceof checks, re‑apply the correct prototype after cloning:

function rehydrate(clone, Constructor) {
  if (clone !== null && typeof clone === 'object') {
    Object.setPrototypeOf(clone, Constructor.prototype);
  }
  return clone;
}
// usage
const restoredInstance = rehydrate(restored, MyClass);

Alternatively, store the constructor name before cloning and instantiate a new object, copying the cloned plain properties into it.
Detecting silently dropped fields
There is no documented way to ask structuredClone() what it omitted. To audit dropped descriptors you must:

Before cloning, capture Object.getOwnPropertyDescriptors(original) for own enumerable properties.
After cloning, compare the descriptor set with Object.getOwnPropertyDescriptors(clone); any missing entries indicate properties that were not copied (accessors become values, non‑enumerable are omitted).

If your state depends on those omitted aspects, you need to handle them outside of structuredClone() (e.g., serialize them separately).
One missing detail
Do you need to preserve non‑enumerable own properties or accessor getters/setters in your state tree? If yes, the verification step must be supplemented with a custom serialization for those properties, because structuredClone() cannot clone them reliably.