web: XREFs, data links & extraction, ARCHIVE transmittals, worker-side saves

The last four big web-vs-desktop gaps.

XREFs: XATTACH reads the picked drawing's bytes and registers them
name-keyed (the image/PDF-underlay pattern), pre-parses on the web
worker, and the commit merge produces the same xref block flow as
native. Opened drawings resolve xrefs from the registry (trailing-name
match) before cache build; unresolved references produce ONE warning
listing the names and the fix — drop the referenced files on the page
(drops and picker opens now register their bytes) and reopen or
XRELOAD. XRELOAD works off the registry on unsaved drawings too.

Data Link & Extraction: spreadsheet links read picked xlsx/csv bytes
(calamine from slices / CSV from string) through a session registry,
so preview, refresh, and table-insert work on web; extraction takes
external drawings via a multi-file picker parsed on the worker, and
outputs CSV/TXT/.dxex via download_bytes. The disabled 'Add folder'
button explains why.

ARCHIVE/ETRANSMIT: assembles the drawing plus registered images, PDF
underlays, and session plot tables into a ZIP delivered as
{stem}_transmit.zip; skipped dependencies are reported by name.

Save/autosave off the UI thread: the parse worker gains a serialize
action (protocol v5) — the document is prepared once on the main
thread (clone, styles, dimension bake), then the DWG/DXF writer pass,
the dominant cost, runs on the worker; any worker failure falls back
to inline serialization with the identical shared implementation.
The save path also clears the dirty flag only when the tab didn't
change mid-write, and the runtime-fields sidecar now carries
graphic_data, fixing a pre-existing loss of raw DWG round-trip bytes
on web-opened documents.

(cherry picked from commit 2e100634)

Ported onto main (#1717 review): the new ocs_save crate builds on the
pinned codec; the hand-written ZIP writer is replaced by the zip crate
already in the tree; ARCHIVE packs registered xref bytes too and
serializes document_for_save() like a web Save; the web save prepares
document_for_save() (prepare_document_for_save now takes the copy by
value, so no second clone); the wasm resolve_path consults the xref
registry, so every reference lookup — not just resolve — finds dropped
files; XRELOAD keeps main's undo, unload and stale-baseline handling;
native data extraction streams the source drawings one at a time.

src/scene/model/image_model.rs

@@ -573,6 +573,19 @@ fn registered_bytes_by_name(path: &str) -> Option<Arc<Vec<u8>>> {
         .map(|(_, bytes)| Arc::clone(bytes))
 }
 
+/// Original image file bytes registered for a reference, resolved the way
+/// `decode_reference` resolves pixels: exact reference first, then any
+/// registration that names the same file. The web ARCHIVE/ETRANSMIT
+/// packages these bytes into the transmittal; `None` means nothing was
+/// picked or dropped for the reference this session.
+pub fn registered_source_bytes(path: &str) -> Option<Arc<Vec<u8>>> {
+    let path = path.trim();
+    if path.is_empty() {
+        return None;
+    }
+    registered_bytes(path).or_else(|| registered_bytes_by_name(path))
+}
+
 /// Drop every memoised image so the next resolve re-reads / re-fetches. Called
 /// when a new document is opened — a fresh drawing shouldn't inherit a prior
 /// one's stale successes or offline failures.

src/scene/model/pdf_raster.rs

@@ -38,6 +38,18 @@ fn source_cache() -> &'static Mutex<HashMap<String, Arc<Vec<u8>>>> {
     SOURCES.get_or_init(|| Mutex::new(HashMap::new()))
 }
 
+/// Bytes registered for exactly this PDF reference (the attach flow keys by
+/// the same path the underlay definition stores). The web ARCHIVE/ETRANSMIT
+/// packages the underlay into the transmittal; `None` means no PDF was
+/// picked for this reference this session.
+pub fn registered_source_bytes(path: &str) -> Option<Arc<Vec<u8>>> {
+    source_cache()
+        .lock()
+        .unwrap_or_else(|error| error.into_inner())
+        .get(path)
+        .cloned()
+}
+
 /// Keep bytes selected through a file dialog. Browsers expose no reusable path,
 /// while native builds also benefit by avoiding a second disk read.
 pub fn register_source(path: &str, bytes: Arc<Vec<u8>>) {