refactor(timeline): de-Qt oaktimeline and wrap it in a pure C ABI

- de-Qt all 11 sources: markers/workarea lose QObject/signals (list
  re-sort via direct resort() call, drawing moves to the app layer),
  explicit unique_ptr ownership for marker lists and viewer's
  workarea/markers
- timeline undo command families (split/pointer/ripple/general/track)
  now hold oaknode C handles and do all graph work through the oaknode
  C ABI (no adapter layer); gaps are attached to the project graph
  before insertion, orphan handles tracked and freed
- fix the de-Qt severed Block->Track length-changed chain with a
  direct block_length_changed() call (positions were stale after
  split/trim)
- expand oaknode C API by ~20 functions needed by timeline
  (copy_in_graph, block kind/casts, connect_element, input arrays,
  tracklist family, marker/workarea borrowed outlets)
- pure C ABI in include/timeline (marker/workarea/edit, command
  factories returning OakUndoCommand), oakcommon XML get_native
  accessors
- oaknode<->oaktimeline resolve each other at runtime; standalone
  drivers link both into test binaries
- tests: oaktimeline 117, regressions oakcommon 193 / oaknode 96 /
  oakrender 42 / oakcodec 18 / oakaudio 36 all green

include/node/block.h

@@ -49,6 +49,13 @@ typedef struct OakNodeBlock OakNodeBlock;
  */
 typedef struct OakNodeTrack OakNodeTrack;
 
+/**
+ * @brief Opaque handle to a node (olive::Node), see node/node.h.
+ *
+ * Re-declared here so block.h is self-contained; the typedef is identical.
+ */
+typedef struct OakNodeNode OakNodeNode;
+
 /**
  * @brief Concrete transition kinds for oaknode_block_transition_create().
  */
@@ -57,6 +64,14 @@ enum OakNodeTransitionKind {
 	OAKNODE_TRANSITION_DIP_TO_COLOR = 1 /**< DipToColorTransition. */
 };
 
+/**
+ * @brief Input ids of a TransitionBlock's block connections
+ * (TransitionBlock::k_out_block_input / k_in_block_input). Pinned by
+ * test; pass to oaknode_node_connect()/oaknode_node_disconnect().
+ */
+#define OAKNODE_TRANSITION_OUT_BLOCK_INPUT "out_block_in"
+#define OAKNODE_TRANSITION_IN_BLOCK_INPUT "in_block_in"
+
 /**
  * @brief Create a ClipBlock.
  *
@@ -91,6 +106,32 @@ OakNodeBlock *oaknode_block_transition_create(int kind);
  */
 void oaknode_block_free(OakNodeBlock *block);
 
+enum OakNodeBlockKind {
+	OAKNODE_BLOCK_OTHER = 0,
+	OAKNODE_BLOCK_CLIP = 1,
+	OAKNODE_BLOCK_GAP = 2,
+	OAKNODE_BLOCK_TRANSITION = 3
+};
+
+/**
+ * @brief Concrete kind of a block (dynamic_cast query).
+ */
+int oaknode_block_get_kind(OakNodeBlock *block, int *out_kind);
+
+/**
+ * @brief Borrowed cast from a block handle to its node handle.
+ *
+ * Every Block is a Node; the result must not be freed. NULL for NULL.
+ */
+OakNodeNode *oaknode_block_as_node(OakNodeBlock *block);
+
+/**
+ * @brief Borrowed cast from a node handle to a block handle.
+ *
+ * Returns NULL if the node is not a Block (or for NULL).
+ */
+OakNodeBlock *oaknode_block_from_node(OakNodeNode *node);
+
 /**
  * @brief Rational getters/setters use numerator/denominator out pairs.
  *
@@ -233,6 +274,14 @@ int oaknode_transition_get_connected_out_block(OakNodeBlock *transition,
 int oaknode_transition_get_connected_in_block(OakNodeBlock *transition,
 											  OakNodeBlock **out);
 
+/**
+ * @brief Forward cache passthroughs from another clip
+ * (ClipBlock::add_cache_passthrough_from()). Used after splitting a
+ * clip so the new part shares the render caches.
+ */
+int oaknode_clip_add_cache_passthrough_from(OakNodeBlock *clip,
+											OakNodeBlock *other);
+
 #ifdef __cplusplus
 }
 #endif

include/node/node.h

@@ -99,6 +99,17 @@ typedef struct oaknode_value {
  */
 typedef struct OakNodeNode OakNodeNode;
 
+/* Re-declared here so node.h is self-contained; see node/project.h. */
+typedef struct OakNodeProject OakNodeProject;
+
+/**
+ * @brief Opaque borrowed handles to the timeline data owned by viewer
+ * nodes (TimelineMarkerList / TimelineWorkArea in oaktimeline).
+ * oaktimeline reinterprets these into its own handle types.
+ */
+typedef struct OakNodeMarkerList OakNodeMarkerList;
+typedef struct OakNodeWorkArea OakNodeWorkArea;
+
 /**
  * @brief Number of live owned objects created through this API
  * (nodes from oaknode_factory_create_from_id()/oaknode_node_create_copy(),
@@ -469,6 +480,79 @@ int oaknode_node_remove_from_context(OakNodeNode *node, OakNodeNode *context);
  */
 OakNodeNode *oaknode_node_create_copy(const OakNodeNode *node);
 
+/**
+ * @brief Copy a node inside its graph (Node::copy_node_in_graph()),
+ * recording the reconnect operations in a new MultiUndoCommand.
+ *
+ * `*out_command` receives an owned undo command handle (free with
+ * oakundo_command_free()). The copy is inserted into the graph only when
+ * the returned command is redone; treat it as owned (oaknode_node_free())
+ * until then. Returns NULL on failure.
+ */
+OakNodeNode *oaknode_node_copy_in_graph(OakNodeNode *node,
+										OakUndoCommand **out_command);
+
+/**
+ * @brief Get the project this node belongs to (borrowed). *out may be
+ * NULL if the node is orphaned.
+ */
+int oaknode_node_get_project(const OakNodeNode *node,
+							 OakNodeProject **out);
+
+/**
+ * @brief Insert/remove an element in an input array (live,
+ * Node::input_array_insert/remove()). OAKNODE_E_NOT_FOUND for an
+ * unknown input id.
+ */
+int oaknode_node_input_array_insert(OakNodeNode *node,
+									const char *input_id, int index);
+int oaknode_node_input_array_remove(OakNodeNode *node,
+									const char *input_id, int index);
+
+/**
+ * @brief Element-aware variants of oaknode_node_connect()/disconnect()
+ * (NodeInput element != -1, e.g. Sequence's track_in_N array inputs).
+ */
+int oaknode_node_connect_element(OakNodeNode *output_node,
+								 OakNodeNode *input_node,
+								 const char *input_id, int element);
+int oaknode_node_disconnect_element(OakNodeNode *input_node,
+									const char *input_id, int element);
+
+/**
+ * @brief Create a command that adds a node to a project's graph
+ * (olive::NodeAddCommand). Owned; free with oakundo_command_free().
+ */
+OakUndoCommand *oaknode_command_create_add_node(OakNodeProject *graph,
+												OakNodeNode *node);
+
+/**
+ * @brief Create a command that sets a node's position in a context and
+ * repositions its dependencies recursively
+ * (olive::NodeSetPositionAndDependenciesRecursivelyCommand). Owned.
+ */
+OakUndoCommand *oaknode_command_create_set_position_recursive(
+	OakNodeNode *node, OakNodeNode *context, double x, double y);
+
+/**
+ * @brief Borrowed marker list / work area of a viewer node. *out is NULL
+ * when the node is not a viewer (or for NULL input).
+ */
+int oaknode_node_get_markers(const OakNodeNode *node,
+							 OakNodeMarkerList **out);
+int oaknode_node_get_work_area(const OakNodeNode *node,
+							   OakNodeWorkArea **out);
+
+/**
+ * @brief Create a command that removes a node from its graph together
+ * with its exclusive dependencies and disconnects its edges
+ * (NodeRemoveWithExclusiveDependenciesAndDisconnect).
+ *
+ * Owned command handle; free with oakundo_command_free(). Returns NULL
+ * on failure.
+ */
+OakUndoCommand *oaknode_command_create_remove_node(OakNodeNode *node);
+
 /**
  * @brief Destroy an OWNED node immediately (C++ delete). NULL is a no-op.
  *

include/node/sequence.h

@@ -33,6 +33,18 @@
 extern "C" {
 #endif
 
+/**
+ * @brief Sequence texture/samples input ids (ViewerOutput::k_texture_input
+ * / k_samples_input) and the track input id format
+ * (Sequence::k_track_input_format). Pinned by test.
+ */
+#define OAKNODE_SEQUENCE_TEXTURE_INPUT "tex_in"
+#define OAKNODE_SEQUENCE_SAMPLES_INPUT "samples_in"
+#define OAKNODE_SEQUENCE_TRACK_INPUT_FORMAT "track_in_%1"
+
+/* Re-declared here so sequence.h is self-contained; see node/node.h. */
+typedef struct OakNodeNode OakNodeNode;
+
 /**
  * @brief Opaque handle to a sequence (olive::Sequence).
  *
@@ -71,6 +83,12 @@ void oaknode_sequence_free(OakNodeSequence *sequence);
  * @param type One of OAKNODE_TRACK_TYPE_VIDEO / _AUDIO / _SUBTITLE.
  * @return OAKNODE_OK, OAKNODE_E_INVALID or OAKNODE_E_NOT_FOUND (bad type).
  */
+/**
+ * @brief Borrowed cast from a sequence handle to its node handle.
+ * NULL for NULL.
+ */
+OakNodeNode *oaknode_sequence_as_node(OakNodeSequence *sequence);
+
 int oaknode_sequence_get_track_list(OakNodeSequence *sequence, int type,
 									OakNodeTrackList **out);
 

include/node/track.h

@@ -67,6 +67,15 @@ enum OakNodeTrackType {
 	OAKNODE_TRACK_TYPE_COUNT = 3
 };
 
+/* Re-declared here so track.h is self-contained; see node/node.h. */
+typedef struct OakNodeNode OakNodeNode;
+
+/**
+ * @brief Borrowed cast from a track handle to its node handle.
+ * NULL for NULL.
+ */
+OakNodeNode *oaknode_track_as_node(OakNodeTrack *track);
+
 /* ---------------------------------------------------------------- Track */
 
 /**
@@ -220,6 +229,42 @@ int oaknode_track_is_range_free(OakNodeTrack *track, int in_num, int in_den,
 /**
  * @brief Track list type (OakNodeTrackType values).
  */
+/**
+ * @brief Nearest block lookups (Track::nearest_block_before_or_at /
+ * nearest_block_after_or_at). *out is a borrowed handle or NULL.
+ */
+int oaknode_track_get_nearest_block_before_or_at(OakNodeTrack *track,
+		int numerator, int denominator, OakNodeBlock **out);
+int oaknode_track_get_nearest_block_after_or_at(OakNodeTrack *track,
+		int numerator, int denominator, OakNodeBlock **out);
+
+/**
+ * @brief Borrowed sequence owning this track list.
+ */
+int oaknode_tracklist_get_sequence(OakNodeTrackList *list,
+								   OakNodeSequence **out);
+
+/**
+ * @brief The list's track input id on the parent sequence
+ * (e.g. "track_in_0"). Two-stage string getter.
+ */
+int oaknode_tracklist_get_track_input_id(OakNodeTrackList *list,
+										 char *buf, int buf_size);
+
+/**
+ * @brief Live input-array append/remove on the parent sequence for this
+ * list's track input (TrackList::array_append/array_remove_last()).
+ */
+int oaknode_tracklist_array_append(OakNodeTrackList *list);
+int oaknode_tracklist_array_remove_last(OakNodeTrackList *list);
+
+/**
+ * @brief Map a cached track index to the input-array element index
+ * (TrackList::get_array_index_from_cache_index()).
+ */
+int oaknode_tracklist_get_array_index_from_cache_index(
+	OakNodeTrackList *list, int cache_index, int *out_index);
+
 int oaknode_tracklist_get_type(OakNodeTrackList *list, int *type);
 
 /**