Offer explicit resolution choices for device state conflicts
This commit is contained in:
parent
52f39d58cb
commit
637a4e4e17
|
|
@ -602,7 +602,7 @@ dependencies = [
|
|||
|
||||
[[package]]
|
||||
name = "canvas-pilot"
|
||||
version = "0.9.62"
|
||||
version = "0.9.63"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"craft-dwg",
|
||||
|
|
|
|||
|
|
@ -4,7 +4,7 @@ default-members = ["crates/canvas-pilot"]
|
|||
resolver = "3"
|
||||
|
||||
[workspace.package]
|
||||
version = "0.9.62"
|
||||
version = "0.9.63"
|
||||
edition = "2024"
|
||||
license = "MIT"
|
||||
repository = "https://proxy.dandaedre.com/gitea/idle-org/canvas-pilot"
|
||||
|
|
|
|||
|
|
@ -458,7 +458,8 @@ pub(crate) fn send_with_awj_port(
|
|||
execute(plan, &mut connection)
|
||||
}
|
||||
|
||||
fn validate_fresh(plan: &Plan, fresh: &Snapshot) -> Result<(), String> {
|
||||
/// Read-only stale-state validation; does not weaken execution-time checks.
|
||||
pub fn validate_fresh(plan: &Plan, fresh: &Snapshot) -> Result<(), String> {
|
||||
if fresh.profile != plan.profile {
|
||||
return Err("Device profile changed; reconnect and review mapping.".into());
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,12 +9,14 @@ use std::sync::mpsc::{self, Receiver, TryRecvError};
|
|||
struct DeviceFailure {
|
||||
message: String,
|
||||
refreshed: Option<Box<device::Snapshot>>,
|
||||
conflict: bool,
|
||||
}
|
||||
impl From<String> for DeviceFailure {
|
||||
fn from(message: String) -> Self {
|
||||
Self {
|
||||
message,
|
||||
refreshed: None,
|
||||
conflict: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -29,15 +31,155 @@ impl DeviceFailure {
|
|||
Ok(snapshot) => Self {
|
||||
message,
|
||||
refreshed: Some(Box::new(snapshot)),
|
||||
conflict: false,
|
||||
},
|
||||
Err(error) => Self {
|
||||
message: format!("{message}\nCould not refresh device state: {error}"),
|
||||
refreshed: None,
|
||||
conflict: false,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
struct SendConflict {
|
||||
host: String,
|
||||
plans: Vec<Plan>,
|
||||
links: Vec<(usize, canvas_pilot::DeviceLink)>,
|
||||
sizing: Sizing,
|
||||
details: Vec<String>,
|
||||
}
|
||||
impl SendConflict {
|
||||
fn reload_links(&self) -> Result<Vec<(usize, canvas_pilot::DeviceLink)>, String> {
|
||||
let mut links = std::collections::BTreeMap::new();
|
||||
for (id, link) in &self.links {
|
||||
if let Some(previous) = links.insert(*id, link.clone())
|
||||
&& previous != *link
|
||||
{
|
||||
return Err("A local layer has multiple device destinations. Cancel and choose which layer to load using the mapping controls.".into());
|
||||
}
|
||||
}
|
||||
Ok(links.into_iter().collect())
|
||||
}
|
||||
fn reprepare(
|
||||
&self,
|
||||
snapshot: &device::Snapshot,
|
||||
layout: &canvas_pilot::Layout,
|
||||
) -> Result<Vec<Plan>, String> {
|
||||
self.plans
|
||||
.iter()
|
||||
.map(|old| {
|
||||
if old.profile != snapshot.profile {
|
||||
return Err(
|
||||
"The device family changed. Reconnect and check the mapping.".into(),
|
||||
);
|
||||
}
|
||||
let index = snapshot
|
||||
.screens
|
||||
.iter()
|
||||
.position(|s| s.id == old.screen)
|
||||
.ok_or("A destination screen is no longer available.")?;
|
||||
let screen = &snapshot.screens[index];
|
||||
let bank = if old.target == Target::Preview {
|
||||
&screen.preview_bank
|
||||
} else {
|
||||
&screen.program_bank
|
||||
};
|
||||
if bank != &old.bank {
|
||||
return Err(
|
||||
"Preview/Program roles changed. Cancel and select the destination again."
|
||||
.into(),
|
||||
);
|
||||
}
|
||||
let mappings: Vec<_> = self
|
||||
.links
|
||||
.iter()
|
||||
.filter(|(_, l)| l.screen == old.screen)
|
||||
.map(|(id, l)| (*id, l.layer.clone()))
|
||||
.collect();
|
||||
if mappings.is_empty() {
|
||||
return Err("The original mapping is no longer available.".into());
|
||||
}
|
||||
Plan::prepare(snapshot, layout, index, &mappings, old.target, self.sizing)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
fn conflict_details(plans: &[Plan], fresh: &device::Snapshot) -> Vec<String> {
|
||||
fn diff(
|
||||
path: &str,
|
||||
before: &serde_json::Value,
|
||||
after: &serde_json::Value,
|
||||
out: &mut std::collections::BTreeMap<String, String>,
|
||||
) {
|
||||
if before == after {
|
||||
return;
|
||||
}
|
||||
if let (Some(a), Some(b)) = (before.as_object(), after.as_object()) {
|
||||
let keys: std::collections::BTreeSet<_> = a.keys().chain(b.keys()).collect();
|
||||
for key in keys {
|
||||
diff(
|
||||
&format!("{path}/{key}"),
|
||||
a.get(key).unwrap_or(&serde_json::Value::Null),
|
||||
b.get(key).unwrap_or(&serde_json::Value::Null),
|
||||
out,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
let label = path
|
||||
.split('/')
|
||||
.filter(|p| !matches!(*p, "" | "device" | "items" | "pp" | "status" | "control"))
|
||||
.map(|p| match p {
|
||||
"screenList" => "Screen",
|
||||
"liveLayerList" => "Layer",
|
||||
"presetList" => "Bank",
|
||||
"inputList" => "Input",
|
||||
"posH" => "Horizontal center",
|
||||
"posV" => "Vertical center",
|
||||
"sizeH" => "Width",
|
||||
"sizeV" => "Height",
|
||||
_ => p,
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join(" / ");
|
||||
out.insert(path.into(), format!("{label}: {before} → {after}"));
|
||||
}
|
||||
}
|
||||
let mut changes = std::collections::BTreeMap::new();
|
||||
for plan in plans {
|
||||
for (path, before) in &plan.observed {
|
||||
diff(
|
||||
path,
|
||||
before,
|
||||
fresh.raw.pointer(path).unwrap_or(&serde_json::Value::Null),
|
||||
&mut changes,
|
||||
);
|
||||
}
|
||||
for c in &plan.changes {
|
||||
let path = format!("/{}", c.path.join("/"));
|
||||
diff(
|
||||
&path,
|
||||
&c.before,
|
||||
fresh.raw.pointer(&path).unwrap_or(&serde_json::Value::Null),
|
||||
&mut changes,
|
||||
);
|
||||
}
|
||||
}
|
||||
let count = changes.len();
|
||||
let mut details: Vec<_> = changes.into_values().take(100).collect();
|
||||
if count > 100 {
|
||||
details.push(format!("{} additional device fields changed.", count - 100));
|
||||
}
|
||||
if details.is_empty() {
|
||||
details.push(
|
||||
"Device family, destination availability or Preview/Program roles changed.".into(),
|
||||
);
|
||||
}
|
||||
details
|
||||
}
|
||||
|
||||
fn linked_layer_label(layout: &canvas_pilot::Layout, id: usize) -> String {
|
||||
(0..layout.layers().len())
|
||||
.find(|&i| layout.layer_info(i).id == id)
|
||||
|
|
@ -157,6 +299,8 @@ pub(super) struct DeviceUi {
|
|||
destinations: Vec<Destination>,
|
||||
mapping_scope: Option<(TransferScope, Vec<usize>, String)>,
|
||||
error: String,
|
||||
send_attempt: Option<SendConflict>,
|
||||
conflict: Option<SendConflict>,
|
||||
}
|
||||
impl DeviceUi {
|
||||
pub(super) fn try_startup_connection(&mut self, ctx: &egui::Context) {
|
||||
|
|
@ -318,7 +462,7 @@ impl DeviceUi {
|
|||
pub(super) fn online(&self) -> bool {
|
||||
self.snapshot.is_some()
|
||||
}
|
||||
fn send(&mut self, ctx: &egui::Context, plans: Vec<Plan>) {
|
||||
fn send(&mut self, ctx: &egui::Context, plans: Vec<Plan>, layout: &canvas_pilot::Layout) {
|
||||
if self.input_sending {
|
||||
self.error = "Wait for the input send to finish.".into();
|
||||
return;
|
||||
|
|
@ -326,11 +470,52 @@ impl DeviceUi {
|
|||
let (tx, rx) = mpsc::channel();
|
||||
self.pending = Some(rx);
|
||||
self.sending = true;
|
||||
let links = self
|
||||
.scoped_send_links(layout)
|
||||
.into_iter()
|
||||
.filter(|(_, link)| {
|
||||
plans.iter().any(|p| {
|
||||
p.screen == link.screen
|
||||
&& p.observed.iter().any(|(path, _)| {
|
||||
*path == p.profile.layer_path(&p.screen, &p.bank, &link.layer)
|
||||
})
|
||||
})
|
||||
})
|
||||
.collect();
|
||||
self.send_attempt = Some(SendConflict {
|
||||
host: self.host.clone(),
|
||||
plans: plans.clone(),
|
||||
links,
|
||||
sizing: self.sizing,
|
||||
details: vec![],
|
||||
});
|
||||
self.conflict = None;
|
||||
self.error.clear();
|
||||
self.message.clear();
|
||||
let host = self.host.clone();
|
||||
let ctx = ctx.clone();
|
||||
std::thread::spawn(move || {
|
||||
// Check every screen before the first write, so this dialog cannot conceal a partial send.
|
||||
let fresh = match device::fetch(&host) {
|
||||
Ok(snapshot) => snapshot,
|
||||
Err(error) => {
|
||||
let _ = tx.send(Err(error.into()));
|
||||
ctx.request_repaint();
|
||||
return;
|
||||
}
|
||||
};
|
||||
if let Some(error) = plans
|
||||
.iter()
|
||||
.find_map(|plan| device_send::validate_fresh(plan, &fresh).err())
|
||||
{
|
||||
let _ = tx.send(Err(DeviceFailure {
|
||||
message: error,
|
||||
refreshed: Some(Box::new(fresh)),
|
||||
conflict: true,
|
||||
}));
|
||||
ctx.request_repaint();
|
||||
return;
|
||||
}
|
||||
let result: Result<device::Snapshot, String> = (|| {
|
||||
let mut last = None;
|
||||
for (i, plan) in plans.iter().enumerate() {
|
||||
|
|
@ -400,6 +585,12 @@ impl DeviceUi {
|
|||
self.error = failure.message.clone();
|
||||
match failure.refreshed {
|
||||
Some(snapshot) => {
|
||||
if failure.conflict
|
||||
&& let Some(mut attempt) = self.send_attempt.take()
|
||||
{
|
||||
attempt.details = conflict_details(&attempt.plans, &snapshot);
|
||||
self.conflict = Some(attempt);
|
||||
}
|
||||
self.message = "Device state refreshed. Check the updated layers before sending again; the send was not retried.".into();
|
||||
Ok(*snapshot)
|
||||
}
|
||||
|
|
@ -408,6 +599,7 @@ impl DeviceUi {
|
|||
}
|
||||
other => other.map_err(|failure| failure.message),
|
||||
};
|
||||
self.send_attempt = None;
|
||||
match result {
|
||||
Ok(snapshot) => {
|
||||
if let Ok(address) = device::address(&self.host) {
|
||||
|
|
@ -783,7 +975,7 @@ impl Editor {
|
|||
{
|
||||
match plans {
|
||||
Ok(plans) => {
|
||||
self.device.send(ui.ctx(), plans);
|
||||
self.device.send(ui.ctx(), plans, &self.layout);
|
||||
}
|
||||
Err(error) => {
|
||||
self.device.error = error;
|
||||
|
|
@ -850,6 +1042,76 @@ impl Editor {
|
|||
self.settings.save(&self.application_settings(ctx));
|
||||
}
|
||||
}
|
||||
fn send_conflict_window(&mut self, ctx: &egui::Context) {
|
||||
let Some(conflict) = self.device.conflict.clone() else {
|
||||
return;
|
||||
};
|
||||
if conflict.host != self.device.host || !self.device.online() {
|
||||
self.device.conflict = None;
|
||||
return;
|
||||
}
|
||||
let prepared = conflict.reprepare(self.device.snapshot.as_ref().unwrap(), &self.layout);
|
||||
let program = conflict.plans.iter().any(|p| p.target == Target::Program);
|
||||
let force_allowed =
|
||||
prepared.is_ok() && (!program || self.device.allow_program) && !self.device.busy();
|
||||
let reload_links = conflict.reload_links();
|
||||
let reload_allowed =
|
||||
!program && !conflict.links.is_empty() && reload_links.is_ok() && !self.device.busy();
|
||||
let mut action = 0;
|
||||
let modal=egui::Modal::new(egui::Id::new("device-send-conflict")).show(ctx, |ui| {
|
||||
ui.set_max_width(680.);
|
||||
ui.heading("Device state has changed");
|
||||
ui.label("The device no longer matches the state used to prepare this send. No layers were sent.");
|
||||
egui::ScrollArea::vertical().max_height(260.).show(ui,|ui| {for detail in &conflict.details {ui.label(detail);}});
|
||||
ui.separator();
|
||||
ui.label("Send my layout anyway rebuilds the send against the current device state. Input routing is not changed, and all validation checks remain active.");
|
||||
if let Err(error)=&prepared {ui.colored_label(ui.visuals().error_fg_color,error);}
|
||||
ui.label("Discard local changes and reload replaces the mapped local layers’ geometry, crop, fit and masks with the device Preview values. Other layers remain unchanged. Undo is available.");
|
||||
if program {ui.small("Reload is available for Preview destinations only.");}
|
||||
if let Err(error)=&reload_links {ui.colored_label(ui.visuals().error_fg_color,error);}
|
||||
if !self.device.error.is_empty() {ui.small(&self.device.error);}
|
||||
ui.horizontal_wrapped(|ui| {
|
||||
if ui.button("Cancel send").clicked() {action=1;}
|
||||
if ui.add_enabled(force_allowed,egui::Button::new("Send my layout anyway")).clicked() {action=2;}
|
||||
let destructive=egui::Button::new(egui::RichText::new("Discard local changes and reload").color(ui.visuals().error_fg_color));
|
||||
if ui.add_enabled(reload_allowed,destructive).clicked() {action=3;}
|
||||
});
|
||||
});
|
||||
if modal.should_close() {
|
||||
action = 1;
|
||||
}
|
||||
match action {
|
||||
1 => {
|
||||
self.device.conflict = None;
|
||||
}
|
||||
2 => {
|
||||
if let Ok(plans) = prepared {
|
||||
self.device.conflict = None;
|
||||
let mut attempt = conflict.clone();
|
||||
attempt.plans = plans.clone();
|
||||
self.device.send(ctx, plans, &self.layout);
|
||||
self.device.send_attempt = Some(attempt);
|
||||
}
|
||||
}
|
||||
3 => {
|
||||
match load_linked_layers(
|
||||
&mut self.layout,
|
||||
self.device.snapshot.as_ref().unwrap(),
|
||||
reload_links.as_ref().unwrap(),
|
||||
) {
|
||||
Ok(()) => {
|
||||
self.sync();
|
||||
self.device.conflict = None;
|
||||
self.device.error.clear();
|
||||
self.device.message="Mapped layers reloaded from the device. Undo restores the previous local layout.".into();
|
||||
}
|
||||
Err(error) => self.device.error = error,
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
pub(super) fn device_window(&mut self, ctx: &egui::Context) {
|
||||
if !self.device.allow_program {
|
||||
self.device.target = Target::Preview;
|
||||
|
|
@ -857,6 +1119,7 @@ impl Editor {
|
|||
let was_pending = self.device.pending.is_some();
|
||||
let recent_before = self.device.recent_hosts.clone();
|
||||
self.device.poll();
|
||||
self.send_conflict_window(ctx);
|
||||
if self.device.recent_hosts != recent_before {
|
||||
self.settings.save(&self.application_settings(ctx));
|
||||
}
|
||||
|
|
@ -1057,7 +1320,7 @@ impl Editor {
|
|||
}
|
||||
self.device.open = open;
|
||||
if let Some(plan) = send_plan {
|
||||
self.device.send(ctx, vec![plan]);
|
||||
self.device.send(ctx, vec![plan], &self.layout);
|
||||
}
|
||||
if imported {
|
||||
self.sync();
|
||||
|
|
@ -1421,6 +1684,113 @@ mod tests {
|
|||
)
|
||||
.unwrap()
|
||||
}
|
||||
fn conflict_fixture() -> (Editor, SendConflict) {
|
||||
let mut app = Editor::default();
|
||||
let old = linked_test_snapshot();
|
||||
let link = canvas_pilot::DeviceLink {
|
||||
family: device::Family::Midra4k,
|
||||
screen: "1".into(),
|
||||
layer: "1".into(),
|
||||
};
|
||||
app.layout.set_device_link(0, Some(link.clone())).unwrap();
|
||||
app.device.snapshot = Some(old.clone());
|
||||
let plans = app.device.linked_plans(&app.layout).unwrap();
|
||||
let mut fresh = old;
|
||||
fresh.raw["device"]["screenList"]["items"]["1"]["presetList"]["items"]["UP"]["liveLayerList"]
|
||||
["items"]["1"]["position"]["pp"]["posH"] = serde_json::json!(900);
|
||||
fresh.screens[0].layers[0].geometry.x += 100.;
|
||||
let details = conflict_details(&plans, &fresh);
|
||||
let conflict = SendConflict {
|
||||
host: app.device.host.clone(),
|
||||
plans,
|
||||
links: vec![(app.layout.layer_info(0).id, link)],
|
||||
sizing: Sizing::default(),
|
||||
details,
|
||||
};
|
||||
app.device.snapshot = Some(fresh);
|
||||
(app, conflict)
|
||||
}
|
||||
#[test]
|
||||
fn conflict_reprepare_preserves_intent_and_enforces_fresh_state() {
|
||||
let (app, conflict) = conflict_fixture();
|
||||
let fresh = app.device.snapshot.as_ref().unwrap();
|
||||
assert!(
|
||||
conflict
|
||||
.details
|
||||
.iter()
|
||||
.any(|s| s.contains("Horizontal center: 500 → 900"))
|
||||
);
|
||||
assert!(device_send::validate_fresh(&conflict.plans[0], fresh).is_err());
|
||||
let plans = conflict.reprepare(fresh, &app.layout).unwrap();
|
||||
assert!(device_send::validate_fresh(&plans[0], fresh).is_ok());
|
||||
let mut moved_again = fresh.clone();
|
||||
moved_again.raw["device"]["screenList"]["items"]["1"]["presetList"]["items"]["UP"]["liveLayerList"]
|
||||
["items"]["1"]["position"]["pp"]["posH"] = serde_json::json!(901);
|
||||
assert!(device_send::validate_fresh(&plans[0], &moved_again).is_err());
|
||||
let mut swapped = fresh.clone();
|
||||
swapped.screens[0].preview_bank = "DOWN".into();
|
||||
assert!(
|
||||
conflict
|
||||
.reprepare(&swapped, &app.layout)
|
||||
.unwrap_err()
|
||||
.contains("roles changed")
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
fn preflight_conflict_opens_choices_with_fresh_connected_state() {
|
||||
let (mut app, conflict) = conflict_fixture();
|
||||
let fresh = app.device.snapshot.take().unwrap();
|
||||
let (tx, rx) = mpsc::channel();
|
||||
app.device.pending = Some(rx);
|
||||
app.device.sending = true;
|
||||
app.device.send_attempt = Some(conflict);
|
||||
tx.send(Err(DeviceFailure {
|
||||
message: "Device state changed".into(),
|
||||
refreshed: Some(Box::new(fresh)),
|
||||
conflict: true,
|
||||
}))
|
||||
.unwrap();
|
||||
app.device.poll();
|
||||
assert!(app.device.online());
|
||||
assert!(
|
||||
app.device
|
||||
.conflict
|
||||
.as_ref()
|
||||
.unwrap()
|
||||
.details
|
||||
.iter()
|
||||
.any(|s| s.contains("500 → 900"))
|
||||
);
|
||||
assert!(app.device.pending.is_none());
|
||||
assert!(!app.device.sending);
|
||||
}
|
||||
#[test]
|
||||
fn conflict_reload_requires_unambiguous_destinations() {
|
||||
let (_, mut conflict) = conflict_fixture();
|
||||
let mut second = conflict.links[0].clone();
|
||||
second.1.layer = "2".into();
|
||||
conflict.links.push(second);
|
||||
assert!(conflict.reload_links().is_err());
|
||||
}
|
||||
#[test]
|
||||
fn conflict_cancel_and_reload_are_local_and_reload_is_undoable() {
|
||||
let ctx = egui::Context::default();
|
||||
let (mut app, conflict) = conflict_fixture();
|
||||
let before = app.layout.layers().clone();
|
||||
app.device.conflict = Some(conflict.clone());
|
||||
super::super::tests::click_text(&mut app, &ctx, "Cancel send");
|
||||
assert!(app.device.conflict.is_none());
|
||||
assert_eq!(app.layout.layers(), &before);
|
||||
assert!(app.device.pending.is_none());
|
||||
app.device.conflict = Some(conflict);
|
||||
super::super::tests::click_text(&mut app, &ctx, "Discard local changes and reload");
|
||||
assert!(app.device.conflict.is_none());
|
||||
assert_ne!(app.layout.layers()[0], before[0]);
|
||||
assert_eq!(app.layout.layers()[1], before[1]);
|
||||
assert!(app.device.pending.is_none());
|
||||
app.layout.undo();
|
||||
assert_eq!(app.layout.layers(), &before);
|
||||
}
|
||||
#[test]
|
||||
fn directional_routes_load_separately_and_send_one_source_to_multiple_layers() {
|
||||
let snapshot = linked_test_snapshot();
|
||||
|
|
|
|||
|
|
@ -4,6 +4,14 @@
|
|||
|
||||
## Unreleased
|
||||
|
||||
### v0.9.63
|
||||
|
||||
- Added a device-state conflict dialog with changed fields, Cancel send, Send my
|
||||
layout anyway, and a warning-colored Discard local changes and reload action.
|
||||
All screens are checked before the first write. Explicit overwrite rebuilds
|
||||
plans against fresh state without bypassing validation; scoped Preview reload
|
||||
is undoable and refuses ambiguous multi-destination layers.
|
||||
|
||||
### v0.9.62
|
||||
|
||||
- A rejected or failed layer send now refreshes device state read-only and keeps
|
||||
|
|
|
|||
|
|
@ -206,3 +206,22 @@ linked units and other Aquilon models remain unverified. See the
|
|||
[adapter contract](../../interfaces/device-adapters.md) for tested scope and limits.
|
||||
|
||||
Shared device input drafts are session-only; [projects omit them](advanced-exchange.md#saved-input-corrections). Opening a file never changes an input.
|
||||
|
||||
### When device state changes before sending
|
||||
|
||||
**Device state has changed** lists the changed fields before any screen is sent:
|
||||
|
||||
- **Cancel send** keeps your local edits and sends nothing.
|
||||
- **Send my layout anyway** rebuilds the original mapped send against the refreshed
|
||||
device state. It overwrites the mapped layout fields, not source routing. Range,
|
||||
input compatibility and fresh-state checks still apply. A changed device family
|
||||
or Preview/Program bank requires checking the mapping again instead.
|
||||
- **Discard local changes and reload** uses a warning color because it replaces
|
||||
the mapped local layers’ geometry, crop, fit and masks with the device Preview
|
||||
snapshot shown in the dialog. Other layers stay unchanged; Undo restores your
|
||||
edits. This action is unavailable for Program or ambiguous multiple destinations
|
||||
belonging to the same local layer.
|
||||
|
||||
If the device changes again before an explicit overwrite, sending can be stopped
|
||||
again. Changes or failures occurring during a send remain reported as partial-send
|
||||
errors, with the completed-screen count; they never trigger an automatic retry.
|
||||
|
|
|
|||
|
|
@ -353,3 +353,17 @@ the send error and any completed-screen count. No send is retried automatically;
|
|||
check the refreshed state before explicitly sending again. If refreshing fails,
|
||||
the snapshot is cleared and both errors are reported. This also applies to partial
|
||||
send failures: refreshing does not imply rollback or successful completion.
|
||||
|
||||
### Explicit stale-state conflict resolution
|
||||
|
||||
Before a multi-screen send, a fresh read validates every plan before the first
|
||||
write. A preflight conflict returns the fresh snapshot and opens a local dialog
|
||||
with deduplicated changed fields (up to 100, with an additional-field count).
|
||||
Overwrite recomputes plans from the current editor layout using the original
|
||||
screen/layer mappings, sizing and target. It rejects changed physical bank roles
|
||||
or device family and retains all per-send validation; there is no bypass flag.
|
||||
The destructive reload imports only the mapped Preview layer geometry/framing,
|
||||
fit and masks, atomically and through normal undo. Program and ambiguous fan-out
|
||||
reloads are disabled. The dialog and attempted mapping are transient UI state;
|
||||
project and exchange schemas are unchanged. Partial-send errors do not offer this
|
||||
no-writes conflict dialog.
|
||||
|
|
|
|||
Loading…
Reference in New Issue