@atlaskit/editor-plugin-collab-edit 13.0.30 → 13.1.1

package/dist/es2019/pm-plugins/main/agent-shimmer-decorations.js

@@ -0,0 +1,115 @@
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+
+// Kept out of `plugin-state.ts` so all the agent-shimmer plumbing lives together and is easy to
+// remove if the approach changes. `plugin-state` just reduces the active ranges and asks this module
+// to build the decorations.
+
+/** Default time the skeleton shimmer stays on the agent-authored content (ms). */
+export const AGENT_SHIMMER_DEFAULT_DURATION_MS = 3000;
+
+// Skeleton-loader bar over the agent-authored range, plus a Rovo AI telepointer at the end.
+export const AGENT_SHIMMER_CLASS = 'collab-agent-shimmer';
+export const ROVO_AGENT_TELEPOINTER_CLASS = 'ai-in-editor-telepointer';
+export const ROVO_AGENT_TELEPOINTER_LABEL_CLASS = 'ai-in-editor-telepointer-label';
+export const ADD_AGENT_SHIMMER_META = 'addAgentShimmer'; // register the shimmer decorations
+export const REMOVE_AGENT_SHIMMER_META = 'removeAgentShimmer'; // remove them once the shimmer ends
+
+// A range an agent step wrote; the skeleton + telepointer decorations are drawn over `from`..`to`
+// and kept until removal (so positions can be re-mapped). Pure data only. `telepointerLabel` is the
+// label for the trailing agent telepointer (the agent's type); when absent, no telepointer is shown.
+
+// Rovo AI in-editor telepointer/cursor shown at the end of an agent-authored range (same DOM/style
+// pattern as editor-plugin-ai's in-editor direct-streaming telepointer).
+const createRovoAgentTelepointer = label => {
+  const element = document.createElement('span');
+  element.setAttribute('data-testid', 'ai-in-editor-telepointer-widget');
+  element.className = ROVO_AGENT_TELEPOINTER_CLASS;
+  const labelElement = document.createElement('span');
+  labelElement.setAttribute('data-testid', 'ai-in-editor-telepointer-widget-label');
+  labelElement.className = ROVO_AGENT_TELEPOINTER_LABEL_CLASS;
+  labelElement.append(label);
+  element.appendChild(labelElement);
+  return element;
+};
+
+/**
+ * Pure reducer for the active shimmer ranges from a transaction's changes. Maps existing ranges
+ * forward as the doc changes, replaces them wholesale when a new agent batch lands (a new batch
+ * supersedes any still-in-flight shimmer), and drops a range when its removal timer fires. Returns a
+ * fresh array (never mutates in place) plus whether anything changed.
+ */
+export const reduceAgentShimmers = (current, tr, added, removedShimmerId) => {
+  let next = current;
+  let changed = false;
+
+  // Ranges added in THIS transaction are already in post-change coords, so map the pre-existing
+  // ones BEFORE replacing with any new batch.
+  if (tr.docChanged && next.length) {
+    next = next.map(shimmer => ({
+      ...shimmer,
+      from: tr.mapping.map(shimmer.from, -1),
+      to: tr.mapping.map(shimmer.to, 1)
+    }));
+    changed = true;
+  }
+  if (added !== null && added !== void 0 && added.length) {
+    next = added.map(shimmer => ({
+      ...shimmer
+    }));
+    changed = true;
+  }
+  if (removedShimmerId) {
+    next = next.filter(shimmer => shimmer.shimmerId !== removedShimmerId);
+    changed = true;
+  }
+  return {
+    changed,
+    next
+  };
+};
+
+/**
+ * Builds the inline skeleton-bar + trailing telepointer decorations for the active shimmer ranges.
+ * `getValidPos` clamps a raw position to a valid decoration position (owned by `plugin-state`).
+ * One bad range is isolated via `onError` so it can't kill the others.
+ */
+export const buildAgentShimmerDecorations = (tr, shimmers, getValidPos, onError) => {
+  const decorations = [];
+  const docEnd = tr.doc.nodeSize - 2;
+  shimmers.forEach(({
+    shimmerId,
+    from,
+    to,
+    telepointerLabel
+  }) => {
+    try {
+      const validFrom = getValidPos(tr, Math.max(from, 1));
+      const validTo = getValidPos(tr, Math.min(to, docEnd));
+      if (validTo <= validFrom) {
+        return;
+      }
+      // Skeleton-loader bar over the whole agent-authored range...
+      decorations.push(Decoration.inline(validFrom, validTo, {
+        class: AGENT_SHIMMER_CLASS
+      }, {
+        isAgentShimmer: true,
+        shimmerId
+      }));
+      // ...and, when enabled, a Rovo AI telepointer/cursor (labelled with the agent's type) at the
+      // end of the range.
+      if (telepointerLabel) {
+        decorations.push(Decoration.widget(validTo, createRovoAgentTelepointer(telepointerLabel), {
+          isAgentShimmer: true,
+          shimmerId,
+          class: ROVO_AGENT_TELEPOINTER_CLASS,
+          key: `agent-telepointer-${shimmerId}`,
+          side: 1
+        }));
+      }
+    } catch (err) {
+      // One bad range must not kill the others.
+      onError(err);
+    }
+  });
+  return decorations;
+};

package/dist/es2019/pm-plugins/main/agent-shimmer-ranges.js

@@ -0,0 +1,151 @@
+import { getCollabState } from '@atlaskit/prosemirror-collab';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+// When an agent step lands we cover the top-level block(s) it wrote with a skeleton-loader shimmer
+// (plus a Rovo agent telepointer at the end of the range), then remove it on a timer to reveal the
+// content. Gated behind the `platform_editor_agent_be_streaming` experiment; `durationMs` sets how
+// long the shimmer stays and a 0 duration disables it.
+let agentShimmerIdCounter = 0;
+
+// A step is position-neutral when its StepMap changes no range's length — i.e. it shifts no
+// positions. Attribute-only steps (e.g. `localId` assignment) produce an empty StepMap, and
+// same-size replacements preserve lengths, so both are position-neutral. Used to decide whether a
+// rebase over local unconfirmed steps could have invalidated our index-based range math.
+export const isPositionNeutralStep = step => {
+  let neutral = true;
+  step.getMap().forEach((oldStart, oldEnd, newStart, newEnd) => {
+    if (oldEnd - oldStart !== newEnd - newStart) {
+      neutral = false;
+    }
+  });
+  return neutral;
+};
+
+/**
+ * Derive the shimmer ranges for the agent-authored steps in a received batch, in final-doc
+ * coordinates. `agentType` present ⇒ agent-authored (per the NCS↔Editor steps contract). Each
+ * emitted range is expanded to the whole top-level block(s) the agent touched, which the plugin
+ * covers with the skeleton shimmer. Ranges with no new content (pure deletions) are dropped.
+ *
+ * Steps whose new content is in the same or directly-adjacent top-level block are coalesced into one
+ * range, so an edit that arrives as several steps in a region shimmers as a single unit. Edits
+ * separated by an untouched block stay independent.
+ *
+ * Correctness: the range math assumes `tr` is a linear 1:1 apply of `steps`. Under the native collab
+ * plugin, `receiveTransaction` rebases incoming steps over unconfirmed local steps when they exist;
+ * that only invalidates our positions if a local step shifted positions, so we skip solely when a
+ * rebased local step changed sizes (a rare, safe degrade). Any unexpected error also degrades to no
+ * shimmer, so this never throws into the shared remote-step handler.
+ */
+export const getAgentShimmerRanges = (json, steps, tr, view, durationMs, telepointerEnabled) => {
+  var _json$find;
+  if (!expValEquals('platform_editor_agent_be_streaming', 'isEnabled', true)) {
+    return [];
+  }
+  // Nothing to reveal if the shimmer is disabled.
+  if (durationMs <= 0) {
+    return [];
+  }
+  // Telepointer label = the agent's type upper-cased (e.g. `mcp` → "MCP"), falling back to a generic
+  // "Agent"; `undefined` when the telepointer is disabled, so the plugin skips it. `agentType` is the
+  // same on every step of an agent batch, so read it from the first agent-authored step.
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const agentType = (_json$find = json.find(step => typeof (step === null || step === void 0 ? void 0 : step.agentType) === 'string')) === null || _json$find === void 0 ? void 0 : _json$find.agentType;
+  const telepointerLabel = telepointerEnabled ? (agentType === null || agentType === void 0 ? void 0 : agentType.toUpperCase()) || 'Agent' : undefined;
+  // When the batch was rebased over local unconfirmed steps, our index-based range math is only
+  // valid if those local steps shifted no positions. Attribute-only steps (e.g. `localId`) and
+  // same-size replacements are position-neutral, so the shimmer stays correct. Skip only when a
+  // local step actually changed sizes (a genuine concurrent content edit).
+  if (Number(tr.getMeta('rebased')) > 0) {
+    var _getCollabState$uncon, _getCollabState;
+    const unconfirmed = (_getCollabState$uncon = (_getCollabState = getCollabState(view.state)) === null || _getCollabState === void 0 ? void 0 : _getCollabState.unconfirmed) !== null && _getCollabState$uncon !== void 0 ? _getCollabState$uncon : [];
+    if (unconfirmed.some(entry => !isPositionNeutralStep(entry.step))) {
+      return [];
+    }
+  }
+  try {
+    // Map an inserted range in doc_{i+1} forward through the remaining steps to final-doc coords.
+    // (A later step's own inserted content starts at its `from`; only subsequent steps shift it.)
+    const mapToFinalDoc = (pos, stepIndex, bias) => {
+      let p = pos;
+      for (let j = stepIndex + 1; j < steps.length; j++) {
+        p = steps[j].getMap().map(p, bias);
+      }
+      return p;
+    };
+
+    // Derive each agent step's changed ranges from its StepMap — the canonical, step-type-agnostic
+    // source of what a step wrote. We only need the NEW extent (the content now in the document), in
+    // final-doc coords, since the highlight decorates content that is already present.
+
+    const infos = [];
+    json.forEach((rawStep, index) => {
+      if (typeof (rawStep === null || rawStep === void 0 ? void 0 : rawStep.agentType) !== 'string') {
+        return;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const pmStep = steps[index];
+      if (typeof (pmStep === null || pmStep === void 0 ? void 0 : pmStep.getMap) !== 'function') {
+        return;
+      }
+      pmStep.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+        if (newEnd <= newStart) {
+          return; // pure deletion / attribute-only — no new content to highlight
+        }
+        infos.push({
+          from: mapToFinalDoc(newStart, index, -1),
+          to: mapToFinalDoc(newEnd, index, 1)
+        });
+      });
+    });
+    if (!infos.length) {
+      return [];
+    }
+
+    // Group the changed ranges by the TOP-LEVEL block they landed in, then highlight each touched
+    // block IN FULL. NCS emits a single agent edit as many small replace fragments and often keeps a
+    // common prefix/suffix untouched, so the changed sub-ranges cover only part of a block (e.g. half
+    // a rewritten heading). Expanding to the whole block's content makes the entire heading/paragraph
+    // shimmer as one unit rather than leaving the unchanged half undecorated. Directly-adjacent
+    // touched blocks (index n and n+1) merge into one group so a multi-block rewrite reveals together;
+    // a genuinely untouched block in between (index gap > 1) splits the run, so far-apart edits stay
+    // independent.
+    const docSize = tr.doc.content.size;
+    const clampPos = pos => Math.min(Math.max(pos, 1), docSize);
+    const blockIndexAt = pos => tr.doc.resolve(clampPos(pos)).index(0);
+    // Start/end of the content of the top-level block containing `pos`, so the whole block is covered.
+    const blockContentStart = pos => {
+      const $pos = tr.doc.resolve(clampPos(pos));
+      return $pos.depth >= 1 ? $pos.start(1) : pos;
+    };
+    const blockContentEnd = pos => {
+      const $pos = tr.doc.resolve(clampPos(pos));
+      return $pos.depth >= 1 ? $pos.end(1) : pos;
+    };
+    const sorted = [...infos].sort((a, b) => a.from - b.from || a.to - b.to);
+    const groups = [];
+    sorted.forEach(info => {
+      const block = blockIndexAt(info.from);
+      const current = groups[groups.length - 1];
+      if (current && block <= current.maxBlock + 1) {
+        current.to = Math.max(current.to, info.to);
+        current.maxBlock = Math.max(current.maxBlock, block);
+      } else {
+        groups.push({
+          from: info.from,
+          to: info.to,
+          maxBlock: block
+        });
+      }
+    });
+    return groups.map(group => ({
+      shimmerId: `agent-shimmer-${agentShimmerIdCounter++}`,
+      from: blockContentStart(group.from),
+      to: blockContentEnd(group.to),
+      telepointerLabel
+    }));
+  } catch {
+    // Never let shimmer range derivation throw into the shared remote-step handler; degrade to no
+    // shimmer.
+    return [];
+  }
+};

package/dist/es2019/pm-plugins/main/plugin-state.js

@@ -5,6 +5,8 @@ import { Selection } from '@atlaskit/editor-prosemirror/state';
 import { DecorationSet } from '@atlaskit/editor-prosemirror/view';
 import { Participants } from '../participants';
 import { createTelepointers, findPointers, getPositionOfTelepointer, isReplaceStep, hasExistingNudge } from '../utils';
+import { ADD_AGENT_SHIMMER_META, buildAgentShimmerDecorations, reduceAgentShimmers, REMOVE_AGENT_SHIMMER_META } from './agent-shimmer-decorations';
+
 /**
  * Returns position where it's possible to place a decoration.
  */
@@ -29,7 +31,9 @@ export class PluginState {
   get sessionId() {
     return this.sid;
   }
-  constructor(decorations, participants, sessionId, collabInitalised = false, onError, nudgeAnimations = new Map()) {
+  constructor(decorations, participants, sessionId, collabInitalised = false, onError, nudgeAnimations = new Map(), agentShimmers = []) {
+    // Active agent-edit shimmer ranges (pure data). Replaced with a fresh array of fresh
+    // objects whenever it changes — never mutated in place.
     // eslint-disable-next-line no-console
     _defineProperty(this, "onError", error => console.error(error));
     this.decorationSet = decorations;
@@ -38,6 +42,7 @@ export class PluginState {
     this.isReady = collabInitalised;
     this.onError = onError || this.onError;
     this.nudgeAnimations = nudgeAnimations;
+    this.agentShimmers = agentShimmers;
   }
   getFullName(sessionId) {
     const participant = this.participants.get(sessionId);
@@ -62,6 +67,8 @@ export class PluginState {
     const presenceData = tr.getMeta('presence');
     const telepointerData = tr.getMeta('telepointer');
     const nudgeTelepointerData = tr.getMeta('nudgeTelepointer');
+    const agentShimmerData = tr.getMeta(ADD_AGENT_SHIMMER_META);
+    const removeAgentShimmerId = tr.getMeta(REMOVE_AGENT_SHIMMER_META);
     const sessionIdData = tr.getMeta('sessionId');
     let collabInitialised = tr.getMeta('collabInitialised');
     if (typeof collabInitialised !== 'boolean') {
@@ -159,6 +166,11 @@ export class PluginState {
     // Ignored via go/ees005
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     this.decorationSet.find().forEach(deco => {
+      var _deco$spec;
+      // Never let telepointer dim/side logic touch agent-shimmer decorations.
+      if ((_deco$spec = deco.spec) !== null && _deco$spec !== void 0 && _deco$spec.isAgentShimmer) {
+        return;
+      }
       if (deco.type.toDOM) {
         const hasTelepointerDimClass = deco.type.toDOM.classList.contains(TELEPOINTER_DIM_CLASS);
         const browser = getBrowserInfo();
@@ -187,8 +199,12 @@ export class PluginState {
       // Ignored via go/ees005
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       this.decorationSet.find().forEach(deco => {
-        var _deco$spec, _deco$spec$pointer, _deco$spec2;
-        if (deco.type.toDOM && participants.get(nudgeSessionId) && ((_deco$spec = deco.spec) === null || _deco$spec === void 0 ? void 0 : (_deco$spec$pointer = _deco$spec.pointer) === null || _deco$spec$pointer === void 0 ? void 0 : _deco$spec$pointer.sessionId) === nudgeSessionId && ((_deco$spec2 = deco.spec) === null || _deco$spec2 === void 0 ? void 0 : _deco$spec2.key) === `telepointer-${nudgeSessionId}`) {
+        var _deco$spec2, _deco$spec3, _deco$spec3$pointer, _deco$spec4;
+        // Never let telepointer nudge logic touch agent-shimmer decorations.
+        if ((_deco$spec2 = deco.spec) !== null && _deco$spec2 !== void 0 && _deco$spec2.isAgentShimmer) {
+          return;
+        }
+        if (deco.type.toDOM && participants.get(nudgeSessionId) && ((_deco$spec3 = deco.spec) === null || _deco$spec3 === void 0 ? void 0 : (_deco$spec3$pointer = _deco$spec3.pointer) === null || _deco$spec3$pointer === void 0 ? void 0 : _deco$spec3$pointer.sessionId) === nudgeSessionId && ((_deco$spec4 = deco.spec) === null || _deco$spec4 === void 0 ? void 0 : _deco$spec4.key) === `telepointer-${nudgeSessionId}`) {
           // Restart animation by removing and re-adding the class
           deco.type.toDOM.classList.remove(TELEPOINTER_PULSE_DURING_TR_CLASS);
           deco.type.toDOM.classList.remove(TELEPOINTER_PULSE_CLASS);
@@ -198,6 +214,38 @@ export class PluginState {
         }
       });
     }
+
+    // Register / keep-aligned / remove the agent-edit purple highlight
+    // decorations. Fully fault-isolated — it works on local copies and only merges into the shared
+    // `add`/`remove` (and commits `this.agentShimmers`) after the whole block succeeds, so a fault
+    // here can never corrupt telepointer decorations or the shared decoration set. Never mutates
+    // shimmer entries in place: each change produces a fresh array of fresh objects.
+    try {
+      const {
+        changed,
+        next
+      } = reduceAgentShimmers(this.agentShimmers, tr, agentShimmerData, removeAgentShimmerId);
+      if (changed) {
+        // Build into local arrays; only merge into the shared add/remove once the block succeeds.
+        const agentRemove = this.decorationSet.find(undefined, undefined, spec => spec.isAgentShimmer);
+        const agentAdd = buildAgentShimmerDecorations(tr, next, getValidPos, this.onError);
+
+        // Commit only after the whole block succeeded.
+        remove = remove.concat(agentRemove);
+        add = add.concat(agentAdd);
+        this.agentShimmers = next;
+      }
+    } catch (err) {
+      this.onError(err);
+      // Degrade to no shimmer without corrupting telepointer decorations: drop all agent
+      // decorations and clear agent state, leaving the telepointer `add`/`remove` untouched.
+      this.agentShimmers = [];
+      try {
+        remove = remove.concat(this.decorationSet.find(undefined, undefined, spec => spec.isAgentShimmer));
+      } catch {
+        // Teardown must not re-throw.
+      }
+    }
     if (remove.length) {
       this.decorationSet = this.decorationSet.remove(remove);
     }
@@ -218,7 +266,7 @@ export class PluginState {
         }
       }
     }
-    const nextState = new PluginState(this.decorationSet, participants, sid, collabInitialised, this.onError, this.nudgeAnimations);
+    const nextState = new PluginState(this.decorationSet, participants, sid, collabInitialised, this.onError, this.nudgeAnimations, this.agentShimmers);
     return PluginState.eq(nextState, this) ? this : nextState;
   }
   static eq(a, b) {

package/dist/es2019/pm-plugins/utils.js

@@ -8,7 +8,13 @@ import { AttrStep, ReplaceStep } from '@atlaskit/editor-prosemirror/transform';
 import { Decoration } from '@atlaskit/editor-prosemirror/view';
 import { getParticipantColor } from '@atlaskit/editor-shared-styles';
 import { preserveNodeIdentity } from './preserve-node-identity';
-export const findPointers = (id, decorations) => decorations.find().reduce((arr, deco) => deco.spec.pointer.presenceId === id ? arr.concat(deco) : arr, []);
+export const findPointers = (id, decorations) => decorations.find().reduce(
+// `pointer` is absent on non-telepointer decorations (e.g. the agent-shimmer
+// sweep decorations), so guard against it to avoid crashing this shared helper.
+(arr, deco) => {
+  var _deco$spec$pointer;
+  return ((_deco$spec$pointer = deco.spec.pointer) === null || _deco$spec$pointer === void 0 ? void 0 : _deco$spec$pointer.presenceId) === id ? arr.concat(deco) : arr;
+}, []);
 function style(options) {
   const color = options && options.color || "var(--ds-border, #0B120E24)";
   const borderWidth = "var(--ds-border-width-focused, 2px)";

package/dist/esm/pm-plugins/actions.js

@@ -7,6 +7,10 @@ import * as allAtlaskitCustomSteps from '@atlaskit/custom-steps';
 import { AllSelection, NodeSelection } from '@atlaskit/editor-prosemirror/state';
 import { Step } from '@atlaskit/editor-prosemirror/transform';
 import { receiveTransaction } from '@atlaskit/prosemirror-collab';
+import { expValEquals } from '@atlaskit/tmp-editor-statsig/exp-val-equals';
+import { expVal } from '@atlaskit/tmp-editor-statsig/expVal';
+import { ADD_AGENT_SHIMMER_META, AGENT_SHIMMER_DEFAULT_DURATION_MS, REMOVE_AGENT_SHIMMER_META } from './main/agent-shimmer-decorations';
+import { getAgentShimmerRanges } from './main/agent-shimmer-ranges';
 import { replaceDocument } from './utils';
 
 /*
@@ -70,6 +74,22 @@ export var applyRemoteSteps = function applyRemoteSteps(json, view, userIds, opt
     tr.setMeta('addToHistory', false);
     tr.setMeta('isRemote', true);
 
+    // Agent edit shimmer: mark the ranges agent steps just wrote so the plugin reveals them with the
+    // gloss-sweep → purple-highlight sequence. Gated as a whole so no experiment reads run
+    // off-experiment; off-path leaves `agentShimmers` empty and everything below is a no-op.
+    var durationMs = 0;
+    var agentShimmers = [];
+    if (expValEquals('platform_editor_agent_be_streaming', 'isEnabled', true)) {
+      durationMs = expVal('platform_editor_agent_be_streaming', 'durationMs', AGENT_SHIMMER_DEFAULT_DURATION_MS);
+      // Telepointer shown by default; `telepointerDisabled` hides it (inverted because `expVal`
+      // only permits `false` as a boolean default).
+      var telepointerEnabled = !expVal('platform_editor_agent_be_streaming', 'telepointerDisabled', false);
+      agentShimmers = getAgentShimmerRanges(json, steps, tr, view, durationMs, telepointerEnabled);
+      if (agentShimmers.length) {
+        tr.setMeta(ADD_AGENT_SHIMMER_META, agentShimmers);
+      }
+    }
+
     /*
      * Persist marks across transactions. Fixes an issue where
      * marks are lost if remote transactions are dispatched
@@ -79,6 +99,25 @@ export var applyRemoteSteps = function applyRemoteSteps(json, view, userIds, opt
       tr.setStoredMarks(state.tr.storedMarks);
     }
     view.dispatch(tr);
+
+    // Remove each shimmer after `durationMs`. `dispatchMeta` is guarded so a timer firing after
+    // teardown is a harmless no-op. Only reached when the gated block above produced ranges, so this
+    // whole path is off-experiment-safe.
+    if (agentShimmers.length) {
+      var dispatchMeta = function dispatchMeta(metaKey, value) {
+        try {
+          view.dispatch(view.state.tr.setMeta(metaKey, value));
+        } catch (_unused) {
+          // View torn down before the timer fired — nothing to clean up.
+        }
+      };
+      agentShimmers.forEach(function (_ref) {
+        var shimmerId = _ref.shimmerId;
+        setTimeout(function () {
+          dispatchMeta(REMOVE_AGENT_SHIMMER_META, shimmerId);
+        }, durationMs);
+      });
+    }
   }
 };
 export var handleTelePointer = function handleTelePointer(telepointerData, view) {

package/dist/esm/pm-plugins/main/agent-shimmer-decorations.js

@@ -0,0 +1,120 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+import { Decoration } from '@atlaskit/editor-prosemirror/view';
+
+// Kept out of `plugin-state.ts` so all the agent-shimmer plumbing lives together and is easy to
+// remove if the approach changes. `plugin-state` just reduces the active ranges and asks this module
+// to build the decorations.
+
+/** Default time the skeleton shimmer stays on the agent-authored content (ms). */
+export var AGENT_SHIMMER_DEFAULT_DURATION_MS = 3000;
+
+// Skeleton-loader bar over the agent-authored range, plus a Rovo AI telepointer at the end.
+export var AGENT_SHIMMER_CLASS = 'collab-agent-shimmer';
+export var ROVO_AGENT_TELEPOINTER_CLASS = 'ai-in-editor-telepointer';
+export var ROVO_AGENT_TELEPOINTER_LABEL_CLASS = 'ai-in-editor-telepointer-label';
+export var ADD_AGENT_SHIMMER_META = 'addAgentShimmer'; // register the shimmer decorations
+export var REMOVE_AGENT_SHIMMER_META = 'removeAgentShimmer'; // remove them once the shimmer ends
+
+// A range an agent step wrote; the skeleton + telepointer decorations are drawn over `from`..`to`
+// and kept until removal (so positions can be re-mapped). Pure data only. `telepointerLabel` is the
+// label for the trailing agent telepointer (the agent's type); when absent, no telepointer is shown.
+
+// Rovo AI in-editor telepointer/cursor shown at the end of an agent-authored range (same DOM/style
+// pattern as editor-plugin-ai's in-editor direct-streaming telepointer).
+var createRovoAgentTelepointer = function createRovoAgentTelepointer(label) {
+  var element = document.createElement('span');
+  element.setAttribute('data-testid', 'ai-in-editor-telepointer-widget');
+  element.className = ROVO_AGENT_TELEPOINTER_CLASS;
+  var labelElement = document.createElement('span');
+  labelElement.setAttribute('data-testid', 'ai-in-editor-telepointer-widget-label');
+  labelElement.className = ROVO_AGENT_TELEPOINTER_LABEL_CLASS;
+  labelElement.append(label);
+  element.appendChild(labelElement);
+  return element;
+};
+
+/**
+ * Pure reducer for the active shimmer ranges from a transaction's changes. Maps existing ranges
+ * forward as the doc changes, replaces them wholesale when a new agent batch lands (a new batch
+ * supersedes any still-in-flight shimmer), and drops a range when its removal timer fires. Returns a
+ * fresh array (never mutates in place) plus whether anything changed.
+ */
+export var reduceAgentShimmers = function reduceAgentShimmers(current, tr, added, removedShimmerId) {
+  var next = current;
+  var changed = false;
+
+  // Ranges added in THIS transaction are already in post-change coords, so map the pre-existing
+  // ones BEFORE replacing with any new batch.
+  if (tr.docChanged && next.length) {
+    next = next.map(function (shimmer) {
+      return _objectSpread(_objectSpread({}, shimmer), {}, {
+        from: tr.mapping.map(shimmer.from, -1),
+        to: tr.mapping.map(shimmer.to, 1)
+      });
+    });
+    changed = true;
+  }
+  if (added !== null && added !== void 0 && added.length) {
+    next = added.map(function (shimmer) {
+      return _objectSpread({}, shimmer);
+    });
+    changed = true;
+  }
+  if (removedShimmerId) {
+    next = next.filter(function (shimmer) {
+      return shimmer.shimmerId !== removedShimmerId;
+    });
+    changed = true;
+  }
+  return {
+    changed: changed,
+    next: next
+  };
+};
+
+/**
+ * Builds the inline skeleton-bar + trailing telepointer decorations for the active shimmer ranges.
+ * `getValidPos` clamps a raw position to a valid decoration position (owned by `plugin-state`).
+ * One bad range is isolated via `onError` so it can't kill the others.
+ */
+export var buildAgentShimmerDecorations = function buildAgentShimmerDecorations(tr, shimmers, getValidPos, onError) {
+  var decorations = [];
+  var docEnd = tr.doc.nodeSize - 2;
+  shimmers.forEach(function (_ref) {
+    var shimmerId = _ref.shimmerId,
+      from = _ref.from,
+      to = _ref.to,
+      telepointerLabel = _ref.telepointerLabel;
+    try {
+      var validFrom = getValidPos(tr, Math.max(from, 1));
+      var validTo = getValidPos(tr, Math.min(to, docEnd));
+      if (validTo <= validFrom) {
+        return;
+      }
+      // Skeleton-loader bar over the whole agent-authored range...
+      decorations.push(Decoration.inline(validFrom, validTo, {
+        class: AGENT_SHIMMER_CLASS
+      }, {
+        isAgentShimmer: true,
+        shimmerId: shimmerId
+      }));
+      // ...and, when enabled, a Rovo AI telepointer/cursor (labelled with the agent's type) at the
+      // end of the range.
+      if (telepointerLabel) {
+        decorations.push(Decoration.widget(validTo, createRovoAgentTelepointer(telepointerLabel), {
+          isAgentShimmer: true,
+          shimmerId: shimmerId,
+          class: ROVO_AGENT_TELEPOINTER_CLASS,
+          key: "agent-telepointer-".concat(shimmerId),
+          side: 1
+        }));
+      }
+    } catch (err) {
+      // One bad range must not kill the others.
+      onError(err);
+    }
+  });
+  return decorations;
+};