structuredClone DataCloneError: Separate Data from Functions

2026-10-15

Frontend

JavaScript

/

Node.js

/

Troubleshooting

structuredClone({ save() {} }) throws DataCloneError: the object contains a function. Moving that callback into a nested object does not fix the error. Build a payload containing the data you intend to copy, and keep executable behavior outside that payload.

There is a second boundary to check. A class instance with only data fields can clone successfully while losing its prototype methods. A successful call therefore does not prove that the result can replace the original instance.

Separate a rejected value from lost behavior#

MDN’s structured clone guide documents that functions cannot be cloned and that prototype chains are not duplicated. Those rules produce different outcomes for an own method and a prototype method. The following cases were executed with Node.js 24.13.0 on macOS during article preparation on October 15, 2026.

Input in the fixture	Observed result	What to change
Object literal with `save() {}`	`DataCloneError`	Exclude executable behavior from the payload
Nested `options.onDone` callback	`DataCloneError`	Project the nested data fields too
Property whose value is a symbol	`DataCloneError`	Choose an explicit cloneable identifier representation
`Job` instance with data fields and prototype `run()`	Clone succeeds; `run` is undefined and `instanceof Job` is false	Reconstruct behavior explicitly if the consumer needs an instance
Same instance with an own `onDone` callback added	`DataCloneError`	Copy selected data rather than the entire instance
Data graph with a cycle, a shared child, undefined, and a Date	Clone succeeds; assertions preserve those relationships and values	Do not diagnose cycles alone as the cause

The table describes these inputs, rather than every possible object or platform type. In particular, the symbol case uses a symbol value; it is not a claim about symbol-keyed properties.

Reproduce the failure and the data-only fix#

Save this as clone-boundary.mjs and run node clone-boundary.mjs. It needs no package installation. The assertions verify the error name instead of matching engine-specific message text.

1
import assert from 'node:assert/strict';
2

3
for (const [label, value] of [
4
  ['own method', { save() {} }],
5
  ['nested callback', { options: { onDone() {} } }],
6
  ['symbol value', { token: Symbol('id') }],
7
]) {
8
  assert.throws(() => structuredClone(value), { name: 'DataCloneError' });
9
  console.log(`${label}: DataCloneError`);
10
}
11

12
class Job {
13
  constructor(id) {
14
    this.id = id;
15
    this.options = { retries: 2 };
16
  }
17
  run() { return this.id; }
18
}
19
const job = new Job('job-7');
20
const plain = structuredClone(job);
21
assert.equal(plain instanceof Job, false);
22
assert.equal(typeof plain.run, 'undefined');
23
assert.notEqual(plain.options, job.options);
24
console.log(`prototype method: ${typeof plain.run}; instanceof Job: ${plain instanceof Job}`);
25

26
job.onDone = () => 'finished';
27
assert.throws(() => structuredClone(job), { name: 'DataCloneError' });
28
const payload = { id: job.id, options: { retries: job.options.retries } };
29
const copy = structuredClone(payload);
30
copy.options.retries = 5;
31
assert.equal(job.options.retries, 2);
32
assert.equal(copy.options.retries, 5);
33
assert.equal(Object.hasOwn(copy, 'onDone'), false);
34
console.log(`projected payload: source retries ${job.options.retries}; copy retries ${copy.options.retries}`);
35

36
const shallow = { ...job };
37
assert.equal(shallow.onDone, job.onDone);
38
assert.equal(shallow.options, job.options);
39
console.log('spread: callback and nested object still shared');
40

41
const shared = { count: 1 };
42
const graph = { left: shared, right: shared, missing: undefined,
43
  created: new Date('2026-10-15T00:00:00Z') };
44
graph.self = graph;
45
const cloned = structuredClone(graph);
46
assert.equal(cloned.self, cloned);
47
assert.equal(cloned.left, cloned.right);
48
assert.notEqual(cloned.left, shared);
49
assert.equal(Object.hasOwn(cloned, 'missing'), true);
50
assert.equal(cloned.missing, undefined);
51
assert.equal(cloned.created instanceof Date, true);
52
assert.equal(cloned.created.getTime(), graph.created.getTime());
53
console.log('data graph: cycle, shared reference, undefined, and Date preserved');
54
console.log('all assertions passed');

Expected output:

1
own method: DataCloneError
2
nested callback: DataCloneError
3
symbol value: DataCloneError
4
prototype method: undefined; instanceof Job: false
5
projected payload: source retries 2; copy retries 5
6
spread: callback and nested object still shared
7
data graph: cycle, shared reference, undefined, and Date preserved
8
all assertions passed

The payload expression is an explicit field selection: it copies the job ID and retry count, leaving onDone on the original job. The test changes the cloned retry count and verifies that the source remains unchanged. This establishes the desired data independence for this payload; it does not validate arbitrary input or implement a general serializer.

cloned.left === cloned.right is also intentional. The clone has a new child object, but two references to the same source child remain two references to one cloned child. Deep copying does not require breaking every relationship inside the copied graph. MDN’s method reference also illustrates support for circular references.

Keep callbacks with the component that owns them#

When the consumer only needs job parameters, pass the projected data. When it needs a runnable Job, create a new instance from validated fields using an application-defined constructor or factory, then attach the appropriate local callback. The fixture deliberately stops at the data copy: it does not assume how another process or component should execute the job.

Do not treat the original callback as portable data. Its captured state and side effects belong to your application. Keeping the original function reference may be acceptable for a same-process wrapper, but that is a different contract from obtaining an independent data clone.

Object spread does not repair that contract. The fixture proves that { ...job } retains the same callback reference and the same nested options object. A shallow wrapper may be useful, but it does not give the isolation checked for the projected payload.

JSON round-tripping is a separate serialization choice. It does not preserve every JavaScript value; for example, undefined object properties disappear from JSON. Replacing a failing clone with JSON serialization can therefore change the payload instead of preserving it. Define the accepted fields and types before choosing either operation.

Narrow a real failing payload without changing its meaning#

Start at the call site and identify whether it receives a data record or an instance carrying behavior. For a known plain record, reduce the failing input to selected fields and nested sections until the failure is reproducible. Then replace the accidental instance or callback with the data the consumer actually needs, and assert both the outgoing shape and the required independence.

Avoid treating a generic property walker as a complete cloneability validator. The fixture covers ordinary objects, one ordinary class, and a Date; it does not exercise proxies, accessors, DOM nodes, framework reactive state, transferable buffers, or worker message delivery. A getter or proxy can introduce behavior during inspection. Diagnose those types using their own platform documentation and a reproduction in the actual runtime.

These checks were executed in Node.js, not a browser or a deployed worker. Error message wording and platform object support remain environment-dependent. If the result must keep methods, test that requirement explicitly; if it only needs data, project the data and test that the copy can change independently.