Unable to find original handle for node

Error message

Unable to find original handle for node {}. The node will be removed!

What it means

While restoring original handles and inheriting properties, each instance node must find its counterpart in the parent resource via its original handle. When a node has no such original handle (it was added locally, or the link data was lost), it cannot inherit and is scheduled for removal with this warning.

Solutions

Keep runtime-added nodes separate from resource instances (create them in a non-instance graph or re-instantiate after adding).
Re-add the node intentionally after sync; treat removal as expected for unsourced nodes.
Save the scene so original-handle metadata is generated, or upgrade through the proper editor version.
If the node should be inherited, ensure it exists in the parent prefab.

Example fix

// before
let child = instance.graph_mut().add_node(my_node); // added to resource instance at runtime
// after
// add runtime-only nodes to a separate free-floating graph, or:
let child = scene.content_ref().graph_mut().add_node(my_node);

Defensive patterns

Strategy: validation

Validate before calling

// find instance nodes lacking an original handle before sync removes them
fn unlinked(instance: &SceneResourceInstance) -> Vec<Handle<Node>> {
    instance.nodes()
        .filter(|n| n.original_handle_in_resource().is_none())
        .map(|n| n.self_handle())
        .collect()
}

Type guard

fn has_original(n: &Node) -> bool { n.original_handle_in_resource().is_some() }

Try / catch

let unlinked = unlinked(&instance);
if !unlinked.is_empty() {
    // move runtime-created nodes out or re-create them after sync
}

Prevention

Add runtime nodes to free graphs, not resource instances
Save scenes via the editor so original-handle metadata is written
Don't copy nodes between instances manually; re-instantiate instead
Upgrade scene files through the editor when changing engine versions

When it happens

Trigger: restore_original_handles_and_inherit_properties iterates instance nodes and finds one whose original_handle_in_resource() is None — e.g. a node added at runtime to an instance then synced, or corruption of instance metadata.

Common situations: Runtime-added child nodes on a scene-resource instance when the instance is re-synchronized with its asset; loading a scene saved by an older engine version without original-handle metadata; manually copied nodes between instances.

Related errors

AI-assisted analysis of FyroxEngine/Fyrox@76c91aad8e (2026-09-10). Data as JSON: /api/errors/90d1b91fc9de94ef. Report an issue: GitHub.

Appendix: source

Thrown at fyrox-graph/src/lib.rs:1437

                            let base = node.base().clone();
                            let mut resource_node_clone = resource_node.clone();
                            variable::mark_inheritable_properties_non_modified(
                                &mut resource_node_clone as &mut dyn Reflect,
                                &ignored_types,
                            );
                            resource_node_clone.set_base(base);
                            *node = resource_node_clone;
                        }

                        // Then try to inherit properties.
                        Log::verify(variable::try_inherit_properties(
                            node,
                            resource_node,
                            &ignored_types,
                        ));
                    } else {
                        Log::warn(format!(
                            "Unable to find original handle for node {}. The node will be removed!",
                            node.name(),
                        ))
                    }
                }
            }
        }

        Log::writeln(MessageKind::Information, "Original handles resolved!");
    }

    /// Maps handles in properties of instances after property inheritance. It is needed, because when a
    /// property contains node handle, the handle cannot be used directly after inheritance. Instead, it
    /// must be mapped to respective instance first.
    ///
    /// To do so, we at first, build node handle mapping (original handle -> instance handle) starting from
    /// instance root. Then we must find all inheritable properties and try to remap them to instance handles.
    fn remap_handles(&mut self, instances: &[(Handle<Self::NodeWrapper>, Resource<Self::Prefab>)]) {

View on GitHub (pinned to 76c91aad8e)