Struct SceneTransaction 

pub struct SceneTransaction<'a> { /* private fields */ }

An open transaction over a SceneModel: every edit until it drops is one logical change.

Opened by SceneModel::transaction / SceneModel::user_edit. On drop it closes the scope and — with an edit sink installed — delivers one SceneTransactionRecord with the scene unborrowed.

Nesting joins: a guard opened while another is live adds no boundary, and the outer stamp wins. Everything a guard says (squash, ephemeral, abandon) therefore applies to the transaction it is part of, not to a private one of its own.

Implementations

impl SceneTransaction<'_>

pub fn squash(self) -> Self

Coalesce this transaction’s repeated writes to one continuous quantity — position, bounds, transform, opacity, z, placement — into a single edit keeping the first old and the last new.

Off by default, and deliberately: squashing throws the intermediate path away, which a replay, a presence indicator or a collaboration relay needs, and losing it silently by default is exactly the quiet data loss this seam exists to prevent. The built-in item drag already commits one set_local_pos per gesture, so the default costs nothing in the common case; a caller that writes per sample and wants endpoints asks for it.

Discrete edits — adds, removals, replacements, flags, parent changes — are never coalesced and keep their order.

pub fn ephemeral(self) -> Self

Mark this transaction’s changes as per-frame artefacts: they must be rendered and must not be recorded.

The app-side half of the knob the scene’s own dynamic-bounds refresh uses. An item whose transform follows a rotation Signal writes the model every frame; without this, an app watching the change stream cannot tell that churn from an edit. ephemeral rides every SceneChange and the record, and the framework does nothing else with it — what counts as history is the consumer’s call.

pub fn abandon(self)

Mark the interaction cancelled, then commit.

The scene is not rolled back: applying an inverse is the first 80 % of an undo stack, and undo lives on the other side of this seam. The record arrives with TxnOutcome::Abandoned so the consumer can revert from the old values it was handed without pushing anything a redo could replay — tldraw’s bail, with the stack where it belongs.

On a nested guard this abandons the transaction it joined, because that is the transaction it is part of.

Trait Implementations

impl Debug for SceneTransaction<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for SceneTransaction<'_>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.