pptx-angular-viewer 1.15.0 → 1.16.0

package/fesm2022/pptx-angular-viewer.mjs

@@ -22867,7 +22867,7 @@ function assignUserColor(seed, palette = CURSOR_PALETTE) {
  * truncating, the result is exactly `maxChars` characters including a trailing
  * `...` ellipsis.
  */
-function formatCursorLabel$1(userName, maxChars = MAX_LABEL_CHARS) {
+function formatCursorLabel(userName, maxChars = MAX_LABEL_CHARS) {
     if (userName.length <= maxChars) {
         return userName;
     }
@@ -22998,6 +22998,175 @@ function asSelectionIds(value) {
     return value.filter((entry) => typeof entry === 'string');
 }
 
+/**
+ * Create a throttled presence publisher bound to an awareness instance. The
+ * initial presence is announced synchronously so peers learn of us at once.
+ */
+function createPresencePublisher(awareness, identity) {
+    const local = { activeSlideIndex: 0, cursorX: 0, cursorY: 0 };
+    // Starts at 0 so the first real update publishes immediately (the initial
+    // announce below does not consume the throttle budget).
+    let lastBroadcast = 0;
+    let pending = null;
+    function publish() {
+        awareness.setLocalStateField('presence', {
+            userName: identity.userName,
+            userColor: identity.userColor,
+            userAvatar: identity.userAvatar,
+            role: identity.role,
+            activeSlideIndex: local.activeSlideIndex,
+            cursorX: local.cursorX,
+            cursorY: local.cursorY,
+            selectedElementId: local.selectedElementId,
+            lastUpdated: new Date().toISOString(),
+        });
+    }
+    function update(patch) {
+        Object.assign(local, patch);
+        const elapsed = Date.now() - lastBroadcast;
+        if (elapsed >= BROADCAST_THROTTLE_MS) {
+            if (pending !== null) {
+                clearTimeout(pending);
+                pending = null;
+            }
+            lastBroadcast = Date.now();
+            publish();
+        }
+        else if (pending === null) {
+            pending = setTimeout(() => {
+                pending = null;
+                lastBroadcast = Date.now();
+                publish();
+            }, BROADCAST_THROTTLE_MS - elapsed);
+        }
+    }
+    function flush() {
+        if (pending !== null) {
+            clearTimeout(pending);
+            pending = null;
+        }
+        lastBroadcast = Date.now();
+        publish();
+    }
+    function dispose() {
+        if (pending !== null) {
+            clearTimeout(pending);
+            pending = null;
+        }
+    }
+    // Announce initial presence immediately (without consuming the throttle).
+    publish();
+    return { update, flush, dispose };
+}
+
+/**
+ * collaboration-assets.ts: binary payload sync for the pptx-viewer
+ * collaboration stack.
+ *
+ * Large binary element fields (media/OLE/3D-model payloads) are synced once
+ * via a separate `pptx:assets` Y.Map keyed by `${elementId}:${fieldName}`,
+ * instead of being re-embedded as base64 inside every element write. This
+ * avoids re-transmitting multi-MB payloads on every unrelated edit to the
+ * same element: `writeAssetFields` only touches the assets map when the
+ * stored payload actually differs from the incoming value.
+ *
+ * Known, accepted cost: asset entries are NOT garbage-collected when the
+ * element that referenced them is deleted outright (only an explicit
+ * field-clear removes its entry, via the `else` branch below). A long-lived
+ * room's `pptx:assets` map can only grow. No sweep is implemented in this
+ * pass; correct GC across concurrent/offline peers is a separate problem.
+ */
+const YDOC_ASSETS_KEY = 'pptx:assets';
+/**
+ * Element fields large/binary enough to route through the asset map instead
+ * of being embedded inline as a scalar or complex JSON-blob field.
+ */
+const ASSET_ELEMENT_FIELDS = new Set([
+    'mediaData',
+    'posterFrameData',
+    'oleEmbeddedData',
+    'previewImageData',
+    'modelData',
+]);
+const ASSET_REF_KEYS = {
+    mediaData: '_mdRef',
+    posterFrameData: '_pfdRef',
+    oleEmbeddedData: '_oedRef',
+    previewImageData: '_pidRef',
+    modelData: '_moRef',
+};
+const REV_ASSET_REF_KEYS = Object.fromEntries(Object.entries(ASSET_REF_KEYS).map(([field, ref]) => [ref, field]));
+function assetKey(elementId, fieldName) {
+    return `${elementId}:${fieldName}`;
+}
+function getAssetsMap(ydoc) {
+    return ydoc.getMap(YDOC_ASSETS_KEY);
+}
+/** True when `key` is one of the element-map ref-pointer keys this module owns. */
+function isAssetRefKey(key) {
+    return key in REV_ASSET_REF_KEYS;
+}
+/**
+ * Writes any present asset-routed fields from `rec` into `assets`, storing
+ * only a small ref pointer (not the payload) on the element's own `ymap`.
+ * Never reads from `ymap` itself, so it's safe to call on a brand-new,
+ * not-yet-integrated map (Yjs throws on reading an unintegrated type) - use
+ * this from a create/write path. `assets` is always a root-level (already
+ * integrated) map, so the identical-payload skip-write check is still safe.
+ */
+function writeAssetFields(elementId, rec, ymap, assets) {
+    for (const field of ASSET_ELEMENT_FIELDS) {
+        const value = rec[field];
+        if (typeof value === 'string' && value.length > 0) {
+            const key = assetKey(elementId, field);
+            if (assets.get(key) !== value) {
+                assets.set(key, value);
+            }
+            ymap.set(ASSET_REF_KEYS[field], key);
+        }
+    }
+}
+/**
+ * Reconcile variant of {@link writeAssetFields} for an `ymap` that is
+ * already integrated (an existing live element being updated in place):
+ * additionally reads the current ref to skip a redundant set, and clears
+ * the ref + its `assets` entry when the field was cleared.
+ */
+function reconcileAssetFields(elementId, rec, ymap, assets) {
+    for (const field of ASSET_ELEMENT_FIELDS) {
+        const refKey = ASSET_REF_KEYS[field];
+        const value = rec[field];
+        if (typeof value === 'string' && value.length > 0) {
+            const key = assetKey(elementId, field);
+            if (assets.get(key) !== value) {
+                assets.set(key, value);
+            }
+            if (ymap.get(refKey) !== key) {
+                ymap.set(refKey, key);
+            }
+        }
+        else {
+            const existingRef = ymap.get(refKey);
+            if (typeof existingRef === 'string') {
+                ymap.delete(refKey);
+                assets.delete(existingRef);
+            }
+        }
+    }
+}
+/** Rehydrates any asset-routed fields referenced by `ymap` onto `element`. */
+function readAssetFields(ymap, assets, element) {
+    for (const [refKey, field] of Object.entries(REV_ASSET_REF_KEYS)) {
+        const ref = ymap.get(refKey);
+        if (typeof ref === 'string') {
+            const value = assets.get(ref);
+            if (typeof value === 'string') {
+                element[field] = value;
+            }
+        }
+    }
+}
+
 /**
  * collaboration-text-codec.ts: TextSegment[] <-> Y.Text delta codec used by the
  * collaboration sync layer. Split out of collaboration-sync.ts to keep both
@@ -23266,6 +23435,9 @@ const SCALAR_ELEMENT_KEYS = new Set([
     'width',
     'height',
     'rotation',
+    'shapeId',
+    'skewX',
+    'skewY',
     'flipHorizontal',
     'flipVertical',
     'hidden',
@@ -23274,14 +23446,66 @@ const SCALAR_ELEMENT_KEYS = new Set([
     'name',
     'altText',
     'shapeType',
-    'placeholder',
     'imagePath',
     'imageData',
-    'svgContent',
-    'inkSvg',
-    'sourceSlideId',
+    'svgData',
+    'svgPath',
+    'cropLeft',
+    'cropTop',
+    'cropRight',
+    'cropBottom',
+    'tileOffsetX',
+    'tileOffsetY',
+    'tileScaleX',
+    'tileScaleY',
+    'tileFlip',
+    'tileAlignment',
+    'pathData',
+    'pathWidth',
+    'pathHeight',
     'mediaType',
     'mediaPath',
+    'mediaMimeType',
+    'trimStartMs',
+    'trimEndMs',
+    'posterFramePath',
+    'fullScreen',
+    'loop',
+    'fadeInDuration',
+    'fadeOutDuration',
+    'volume',
+    'autoPlay',
+    'playAcrossSlides',
+    'hideWhenNotPlaying',
+    'playbackSpeed',
+    'mediaMissing',
+    'isLinked',
+    'oleTarget',
+    'oleProgId',
+    'oleName',
+    'oleClsId',
+    'oleObjectType',
+    'oleFileExtension',
+    'fileName',
+    'externalPath',
+    'previewImage',
+    'oleShowAsIcon',
+    'oleImgW',
+    'oleImgH',
+    'oleEmbeddedFileName',
+    'oleEmbeddedMimeType',
+    'oleEmbeddedByteSize',
+    'inkPaths',
+    'inkColors',
+    'inkWidths',
+    'inkOpacities',
+    'inkTool',
+    'zoomType',
+    'targetSlideIndex',
+    'targetSectionId',
+    'modelPath',
+    'modelMimeType',
+    'posterImage',
     'linkedTxbxId',
     'linkedTxbxSeq',
     'promptText',
@@ -23294,26 +23518,35 @@ const COMPLEX_ELEMENT_FIELDS = {
     tableData: '_td',
     chartData: '_cd',
     smartArtData: '_smad',
-    connectionStart: '_cs',
-    connectionEnd: '_ce',
-    animations: '_an',
-    nativeAnimations: '_na',
     children: '_ch',
     paragraphIndents: '_pi',
     rawXml: '_rx',
+    extLstXml: '_elx',
     actionClick: '_ac',
     actionHover: '_av',
     locks: '_lk',
     imageEffects: '_ie',
     cropShape: '_cr',
-    mediaBookmarks: '_mb',
+    bookmarks: '_mb',
     captionTracks: '_ct',
+    metadata: '_md',
+    groupFill: '_gf',
+    inkPointPressures: '_ipp',
+    inkStrokes: '_cis',
+    extensionXml: '_ext',
+    customGeometryPaths: '_cgp',
+    customGeometryRawData: '_cgr',
+    customGeometryAdjustHandlesXY: '_cgx',
+    customGeometryAdjustHandlesPolar: '_cgo',
+    customGeometryConnectionSites: '_cgc',
+    customGeometryTextRect: '_cgt',
 };
 const REV_COMPLEX_ELEMENT = Object.fromEntries(Object.entries(COMPLEX_ELEMENT_FIELDS).map(([k, v]) => [v, k]));
 const SCALAR_SLIDE_KEYS = new Set([
     'id',
     'rId',
     'sourceSlideId',
+    'name',
     'layoutPath',
     'layoutName',
     'slideNumber',
@@ -23323,7 +23556,9 @@ const SCALAR_SLIDE_KEYS = new Set([
     'backgroundColor',
     'backgroundImage',
     'backgroundGradient',
+    'backgroundShadeToTitle',
     'notes',
+    'notesCSldName',
     'backgroundShowAnimation',
     'showMasterShapes',
     'isDirty',
@@ -23334,6 +23569,8 @@ const COMPLEX_SLIDE_FIELDS = {
     nativeAnimations: '_na',
     rawTiming: '_rt',
     notesSegments: '_ns',
+    notesShapes: '_nsh',
+    notesClrMapOverride: '_ncm',
     comments: '_cm',
     warnings: '_wa',
     rawXml: '_rx',
@@ -23341,15 +23578,17 @@ const COMPLEX_SLIDE_FIELDS = {
     guides: '_gu',
     customerData: '_cu',
     activeXControls: '_ax',
+    backgroundPattern: '_bp',
+    headerFooterFlags: '_hff',
 };
 const REV_COMPLEX_SLIDE = Object.fromEntries(Object.entries(COMPLEX_SLIDE_FIELDS).map(([k, v]) => [v, k]));
 // ---------------------------------------------------------------------------
 // Element serialization
 // ---------------------------------------------------------------------------
-function writeElementToYMap(element, ymap, factories) {
+function writeElementToYMap(element, ymap, factories, assets) {
     const rec = element;
     for (const [key, value] of Object.entries(rec)) {
-        if (value === undefined) {
+        if (value === undefined || ASSET_ELEMENT_FIELDS.has(key)) {
             continue;
         }
         if (SCALAR_ELEMENT_KEYS.has(key)) {
@@ -23366,8 +23605,9 @@ function writeElementToYMap(element, ymap, factories) {
             ymap.set(COMPLEX_ELEMENT_FIELDS[key], JSON.stringify(value));
         }
     }
+    writeAssetFields(rec.id, rec, ymap, assets);
 }
-function readElementFromYMap(ymap) {
+function readElementFromYMap(ymap, assets) {
     const element = {};
     ymap.forEach((value, key) => {
         if (key === 'textBody') {
@@ -23375,6 +23615,9 @@ function readElementFromYMap(ymap) {
                 element.textSegments = decodeTextBody(value);
             }
         }
+        else if (isAssetRefKey(key)) {
+            // handled by readAssetFields below; not a literal PptxElement field
+        }
         else if (REV_COMPLEX_ELEMENT[key]) {
             try {
                 element[REV_COMPLEX_ELEMENT[key]] = JSON.parse(value);
@@ -23387,12 +23630,13 @@ function readElementFromYMap(ymap) {
             element[key] = value;
         }
     });
+    readAssetFields(ymap, assets, element);
     return element;
 }
 // ---------------------------------------------------------------------------
 // Slide serialization
 // ---------------------------------------------------------------------------
-function writeSlideToYMap(slide, ymap, factories) {
+function writeSlideToYMap(slide, ymap, factories, assets) {
     const rec = slide;
     for (const key of SCALAR_SLIDE_KEYS) {
         if (rec[key] !== undefined) {
@@ -23407,12 +23651,12 @@ function writeSlideToYMap(slide, ymap, factories) {
     const elemArr = factories.createArray();
     for (const el of slide.elements) {
         const elemMap = factories.createMap();
-        writeElementToYMap(el, elemMap, factories);
+        writeElementToYMap(el, elemMap, factories, assets);
         elemArr.push([elemMap]);
     }
     ymap.set('elements', elemArr);
 }
-function readSlideFromYMap(ymap) {
+function readSlideFromYMap(ymap, assets) {
     const slide = {};
     for (const key of SCALAR_SLIDE_KEYS) {
         const v = ymap.get(key);
@@ -23435,7 +23679,7 @@ function readSlideFromYMap(ymap) {
     const elements = [];
     if (elemArr) {
         for (let i = 0; i < elemArr.length; i++) {
-            elements.push(readElementFromYMap(elemArr.get(i)));
+            elements.push(readElementFromYMap(elemArr.get(i), assets));
         }
     }
     slide.elements = elements;
@@ -23450,6 +23694,7 @@ function readSlideFromYMap(ymap) {
  * one-shot seeding of an empty document.
  */
 function writeSlidesToYDoc(slides, ydoc, factories, origin) {
+    const assets = getAssetsMap(ydoc);
     ydoc.transact(() => {
         const arr = ydoc.getArray(YDOC_SLIDES_KEY);
         if (arr.length > 0) {
@@ -23457,16 +23702,17 @@ function writeSlidesToYDoc(slides, ydoc, factories, origin) {
         }
         for (const slide of slides) {
             const ymap = factories.createMap();
-            writeSlideToYMap(slide, ymap, factories);
+            writeSlideToYMap(slide, ymap, factories, assets);
             arr.push([ymap]);
         }
     }, origin);
 }
 function readSlidesFromYDoc(ydoc) {
+    const assets = getAssetsMap(ydoc);
     const arr = ydoc.getArray(YDOC_SLIDES_KEY);
     const slides = [];
     for (let i = 0; i < arr.length; i++) {
-        slides.push(readSlideFromYMap(arr.get(i)));
+        slides.push(readSlideFromYMap(arr.get(i), assets));
     }
     return slides;
 }
@@ -23718,11 +23964,12 @@ function reconcileTextBody(ymap, rec, factories) {
     encodeTextBody(segments, ytext);
     ymap.set('textBody', ytext);
 }
-function reconcileElementYMap(ymap, element, factories) {
+function reconcileElementYMap(ymap, element, factories, assets) {
     const rec = element;
     reconcileScalars(ymap, rec, SCALAR_ELEMENT_KEYS);
     reconcileComplexFields(ymap, rec, COMPLEX_ELEMENT_FIELDS);
     reconcileTextBody(ymap, rec, factories);
+    reconcileAssetFields(rec.id, rec, ymap, assets);
 }
 function mapIdAt(arr, index) {
     const entry = arr.get(index);
@@ -23799,7 +24046,7 @@ const isYArrayLike = (value) => typeof value === 'object' &&
     value !== null &&
     typeof value.insert === 'function' &&
     typeof value.toArray === 'function';
-function reconcileSlideYMap(ymap, slide, factories) {
+function reconcileSlideYMap(ymap, slide, factories, assets) {
     const rec = slide;
     reconcileScalars(ymap, rec, SCALAR_SLIDE_KEYS);
     reconcileComplexFields(ymap, rec, COMPLEX_SLIDE_FIELDS);
@@ -23812,10 +24059,10 @@ function reconcileSlideYMap(ymap, slide, factories) {
         idOf: (el) => (typeof el.id === 'string' ? el.id : undefined),
         create: (el) => {
             const map = factories.createMap();
-            writeElementToYMap(el, map, factories);
+            writeElementToYMap(el, map, factories, assets);
             return map;
         },
-        update: (map, el) => reconcileElementYMap(map, el, factories),
+        update: (map, el) => reconcileElementYMap(map, el, factories, assets),
     });
 }
 /**
@@ -23824,16 +24071,17 @@ function reconcileSlideYMap(ymap, slide, factories) {
  * caller's own observer can skip the resulting events.
  */
 function reconcileSlidesInYDoc(slides, ydoc, factories, origin = LOCAL_SYNC_ORIGIN) {
+    const assets = getAssetsMap(ydoc);
     ydoc.transact(() => {
         const arr = ydoc.getArray(YDOC_SLIDES_KEY);
         reconcileYArrayById(arr, slides, {
             idOf: (slide) => (typeof slide.id === 'string' ? slide.id : undefined),
             create: (slide) => {
                 const map = factories.createMap();
-                writeSlideToYMap(slide, map, factories);
+                writeSlideToYMap(slide, map, factories, assets);
                 return map;
             },
-            update: (map, slide) => reconcileSlideYMap(map, slide, factories),
+            update: (map, slide) => reconcileSlideYMap(map, slide, factories, assets),
         });
     }, origin);
 }
@@ -23890,6 +24138,50 @@ function createSyncGate(onOpen, graceMs = INITIAL_SYNC_GRACE_MS) {
     };
 }
 
+const DEFAULT_DEBOUNCE_MS = 5_000;
+function createWriteBackScheduler(deps) {
+    let timer = null;
+    function cancel() {
+        if (timer !== null) {
+            clearTimeout(timer);
+            timer = null;
+        }
+    }
+    function schedule(config) {
+        if (!config.onWriteBack || config.role !== 'owner' || !deps.getYDoc()) {
+            return;
+        }
+        cancel();
+        const debounceMs = config.writeBackDebounceMs ?? DEFAULT_DEBOUNCE_MS;
+        timer = setTimeout(async () => {
+            timer = null;
+            const ydoc = deps.getYDoc();
+            if (!ydoc || !config.onWriteBack) {
+                return;
+            }
+            const sourceBytes = deps.getSourceBytes?.();
+            if (!sourceBytes) {
+                return;
+            }
+            try {
+                const { PptxHandler } = await import('pptx-viewer-core');
+                const handler = new PptxHandler();
+                await handler.load(sourceBytes.buffer);
+                const slides = readSlidesFromYDoc(ydoc);
+                const merged = deps.mergeTemplateElements
+                    ? deps.mergeTemplateElements(slides, deps.getTemplateElements?.() ?? {})
+                    : slides;
+                const bytes = await handler.save(merged);
+                config.onWriteBack(bytes);
+            }
+            catch {
+                /* non-fatal */
+            }
+        }, debounceMs);
+    }
+    return { schedule, cancel };
+}
+
 // ---------------------------------------------------------------------------
 // Tuning constants (px tolerances for position / size changes)
 // ---------------------------------------------------------------------------
@@ -33282,6 +33574,51 @@ const CHANGE_CASE_OPTIONS$1 = [
     { value: 'toggle', i18nKey: 'pptx.text.changeCaseToggle' },
 ];
 
+/**
+ * color-swatches.ts: the canonical "Office Standard Colors" swatch catalogue
+ * shared by every binding's colour pickers (font colour, highlight colour,
+ * and any future fill/line colour picker that wants the same 10-swatch grid).
+ *
+ * Mirrors the "Standard Colors" row PowerPoint itself ships. Before this
+ * module existed, the VanillaJS (`swatch-picker.ts`) and Svelte
+ * (`SwatchColorPicker.svelte`) bindings each independently hardcoded an
+ * identical 10-colour list; this module is the single source of truth going
+ * forward so no binding drifts from the others.
+ *
+ * There is no shared-i18n dictionary key for individual colour names yet
+ * (only the `pptx.ribbon.customColour` "Custom colour..." row label exists),
+ * so {@link OfficeColorSwatch.label} is a plain English fallback rather than
+ * an `i18nKey`, matching the optional-label convention used elsewhere in this
+ * module family (e.g. `LineSpacingOption` in `text-format-presets.ts`).
+ *
+ * @module render/color-swatches
+ */
+/**
+ * The canonical 10-swatch "Office Standard Colors" catalogue, in PowerPoint's
+ * on-screen order. Consumed by the font-colour and highlight-colour pickers
+ * (and any other picker that wants the same standard set) across every
+ * binding.
+ */
+const OFFICE_COLOR_SWATCHES = [
+    { hex: '#000000', label: 'Black' },
+    { hex: '#ffffff', label: 'White' },
+    { hex: '#ff0000', label: 'Red' },
+    { hex: '#00aa00', label: 'Green' },
+    { hex: '#0000ff', label: 'Blue' },
+    { hex: '#ff8800', label: 'Orange' },
+    { hex: '#8800cc', label: 'Purple' },
+    { hex: '#00cccc', label: 'Cyan' },
+    { hex: '#ff69b4', label: 'Pink' },
+    { hex: '#808080', label: 'Gray' },
+];
+/**
+ * The same catalogue flattened to bare `#rrggbb` hex strings, in the same
+ * order as {@link OFFICE_COLOR_SWATCHES}. A drop-in replacement for the
+ * `readonly string[]` swatch lists the vanilla and Svelte bindings each
+ * hardcoded locally before this module existed.
+ */
+const OFFICE_COLOR_SWATCH_HEXES = OFFICE_COLOR_SWATCHES.map((swatch) => swatch.hex);
+
 /**
  * PowerPoint-style title bar: shared pure logic + Tailwind class tokens.
  *
@@ -37702,25 +38039,14 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.6", ngImpor
  * surface so `collaboration.service.ts`, `collaboration-cursors.component.ts`,
  * the viewer barrel, and the colocated tests are unchanged.
  *
- * Two pieces stay Angular-local because they diverge from the shared copy:
- *  - `RemotePresence` is the Angular name for shared's `SanitizedPresence`
- *    (re-aliased here).
- *  - `formatCursorLabel` keeps the historical single-character ellipsis (`…`)
- *    truncation, which differs from shared's three-dot (`...`) variant that the
- *    React binding expects. Kept local so the rendered label and the colocated
- *    test are unchanged.
- *
- * `mapAwarenessCursors` (the foundational bare-`{ cursor, user }` mapping) now
- * lives in shared and is re-exported here so existing Angular imports are
- * unchanged.
- */
-/**
- * Clamp/format a cursor label so long names don't overflow the chip. Uses a
- * single-character ellipsis (`…`); the total length is exactly `maxChars`.
+ * `RemotePresence` is the Angular name for shared's `SanitizedPresence`
+ * (re-aliased here). `formatCursorLabel` and `mapAwarenessCursors` are now
+ * re-exported as-is from shared: Angular's `formatCursorLabel` used to keep
+ * its own single-character ellipsis (`…`) truncation that differed from
+ * shared's three-dot (`...`) variant, so two peers viewing the same presence
+ * record saw differently-truncated names depending on which binding hosted
+ * the session - a real cross-binding consistency bug, not a style choice.
  */
-function formatCursorLabel(userName, maxChars = MAX_LABEL_CHARS) {
-    return userName.length > maxChars ? `${userName.slice(0, maxChars - 1)}…` : userName;
-}
 
 /**
  * collaboration-cursors.component.ts: Angular port of the Vue
@@ -37862,8 +38188,6 @@ class LocalPresencePublisher {
     setCursor(x, y, activeSlideIndex = this.activeSlide) {
         this.cursor = { x, y };
         this.activeSlide = activeSlideIndex;
-        // A bare `cursor` field mirrors the flat awareness shape some peers read.
-        this.awareness.setLocalStateField('cursor', { x, y });
         this.publish();
     }
     setSelection(selectedElementId, activeSlideIndex = this.activeSlide) {
@@ -37883,14 +38207,14 @@ class LocalPresencePublisher {
  *
  * Isolates the dynamic `yjs` / `y-websocket` / `y-webrtc` imports and provider
  * construction so the service focuses on lifecycle + reactive state. The Yjs
- * packages are dynamically imported so they are fully tree-shaken when
- * collaboration is unused; each specifier is read from a variable so bundlers
- * do not eagerly follow it (mirrors the historical `/* @vite-ignore *\/`
- * pattern).
+ * packages are dynamically imported (plain string-literal specifiers, matching
+ * React/Vue) so they are fully tree-shaken when collaboration is unused, while
+ * still resolving correctly under a consuming app's Vite dev server: an
+ * `@vite-ignore`d or variable specifier skips Vite's dev-time bare-specifier
+ * rewrite, which then fails to resolve natively in the browser.
  */
 async function createDoc() {
-    const yModule = 'yjs';
-    const Y = (await import(/* @vite-ignore */ yModule));
+    const Y = (await import('yjs'));
     const doc = new Y.Doc();
     const factories = {
         createMap: () => new Y.Map(),
@@ -37901,10 +38225,9 @@ async function createDoc() {
 }
 /** Create a y-websocket transport bundle for `config`. */
 async function createWebsocketBundle(config) {
-    const wsSpecifier = 'y-websocket';
     const [{ doc, factories }, yws] = await Promise.all([
         createDoc(),
-        import(/* @vite-ignore */ wsSpecifier),
+        import('y-websocket'),
     ]);
     const provider = new yws.WebsocketProvider(config.serverUrl, config.roomId, doc, config.authToken ? { params: { token: config.authToken } } : undefined);
     return { doc, provider, awareness: provider.awareness, factories };
@@ -37916,10 +38239,9 @@ async function createWebsocketBundle(config) {
  * `authToken` is passed as the room `password`.
  */
 async function createWebrtcBundle(config) {
-    const rtcSpecifier = 'y-webrtc';
     const [{ doc, factories }, yrtc] = await Promise.all([
         createDoc(),
-        import(/* @vite-ignore */ rtcSpecifier),
+        import('y-webrtc'),
     ]);
     const provider = new yrtc.WebrtcProvider(config.roomId, doc, {
         signaling: config.signaling?.length ? config.signaling : undefined,
@@ -38144,9 +38466,14 @@ class CollaborationService {
             this.status.set('error');
             return;
         }
+        // Falls back from a blank serverUrl the same way Vue's session layer
+        // already does, so a bare CollaborationConfig behaves identically
+        // regardless of which binding's session layer receives it directly (not
+        // just via the Share/Broadcast dialogs, which already pre-resolve it).
+        const transport = config.transport ?? resolveTransportForServerUrl(config.serverUrl);
         // Fail fast on mixed content (websocket only): an https page cannot open a
         // ws:// socket, so surface the error rather than hanging until the timeout.
-        if (config.transport !== 'webrtc' && isMixedContentBlocked(config.serverUrl)) {
+        if (transport !== 'webrtc' && isMixedContentBlocked(config.serverUrl)) {
             this.status.set('error');
             return;
         }
@@ -38159,7 +38486,7 @@ class CollaborationService {
         this.activeRole.set(config.role);
         this.status.set('connecting');
         try {
-            const bundle = config.transport === 'webrtc'
+            const bundle = transport === 'webrtc'
                 ? await createWebrtcBundle(config)
                 : await createWebsocketBundle(config);
             this.ydoc = bundle.doc;
@@ -38176,7 +38503,7 @@ class CollaborationService {
             this.localPresence.publish();
             this.awareness.on('change', this.refreshPresence);
             this.awareness.on('update', this.refreshPresence);
-            this.wireStatus(config);
+            this.wireStatus(transport);
             this.syncGate.reset();
             this.wireSynced();
             this.unobserveSlides = observeYDocSlides(this.ydoc, (_events, transaction) => this.onRemoteChange(transaction));
@@ -38195,18 +38522,23 @@ class CollaborationService {
         }
     }
     /** Wire the provider status events + (websocket-only) connection timeout. */
-    wireStatus(config) {
+    wireStatus(transport) {
         const provider = this.provider;
         if (!provider) {
             return;
         }
-        if (config.transport === 'webrtc') {
+        if (transport === 'webrtc') {
             // P2P: no server round-trip to wait on. Treat "created" as connected,
             // and reflect explicit disconnect events.
             this.status.set('connected');
             provider.on('status', (payload) => {
                 if (payload.connected === false && this.active()) {
                     this.status.set('disconnected');
+                    // Re-arm on (re)connect: without this, a peer that drops and
+                    // rejoins keeps the gate permanently open from the first
+                    // connection and can clobber the room with a stale local doc.
+                    this.syncGate.reset();
+                    this.syncGate.arm();
                 }
                 else if (payload.connected === true) {
                     this.status.set('connected');
@@ -38221,6 +38553,8 @@ class CollaborationService {
             }
             else if (payload.status === 'disconnected' && this.active()) {
                 this.status.set('disconnected');
+                this.syncGate.reset();
+                this.syncGate.arm();
             }
         });
         if (provider.wsconnected) {