עריכה שיתופית

המתודה getSharedStore() הופכת עורך לצומת בסשן עריכה שיתופית.
היא משגרת כל שינוי כזרם פעולות ומחילה את הפעולות שעורכים אחרים שולחים בחזרה – יש לספק את שכבת התעבורה ביניהם (WebSocket, WebRTC או כל דבר אחר שיכול לשאת JSON).
זוהי אחת המתודות של ErdEditorElement, והיא משמשת יחד עם אחסון מרוחק כאשר יש גם לאחסן את השינויים שמועברים הלאה.
החל מגרסה 5.1.0, כדי לשתף תרשים באמצעות מסמך Yjs וכל אחד מהספקים שלו במקום לחבר את שכבת התעבורה באופן ידני, יש לחבר את העורך באמצעות @dineug/erd-editor-yjs – ראו Yjs.

interface ErdEditorElement extends HTMLElement {
  // ...
  getSharedStore: (
    config?: SharedStoreConfig & {
      mouseTracker?: boolean;
      focusTracker?: boolean;
    }
  ) => SharedStore;
}

type SharedStoreConfig = {
  getNickname?: () => string;
};

type SharedStore = {
  connection: () => void;
  disconnect: () => void;
  dispatch: (actions: Array<AnyAction> | AnyAction) => void;
  dispatchSync: (actions: Array<AnyAction> | AnyAction) => void;
  subscribe: (fn: (value: AnyAction[]) => void) => Unsubscribe;
  flushStreamBuffers: () => void;
  getLWW: () => SharedRegisters;
  mergeLWW: (lww: SharedRegisters, version: number) => void;
  getVersion: () => number;
  forgetPeer: (editorId: string) => void;
  reseed: (value: string, options: ReseedOptions) => void;
  destroy: () => void;
};

// a JSON object whose shape is the editor's own: hand it on as it is
type SharedRegisters = Record<string, unknown> & {
  readonly [registersBrand]: true;
};

type ReseedOptions = {
  lww: SharedRegisters;
  version: number;
  keepScreen?: boolean; // default false
};

// example
const sharedStore = editor.getSharedStore();

החבילה @dineug/erd-editor אינה מייצאת אף אחד מהטיפוסים האלה בשמם. קוד TypeScript מגיע אליהם דרך ErdEditorElement, כמו ב-ReturnType<ErdEditorElement['getSharedStore']>.

פעולה היא אובייקט פשוט שניתן לבצע עליו סריאליזציה ושמתאר שינוי אחד במסמך, ולכן היא עוברת את JSON.stringify בשלמותה בדרכה לשכבת התעבורה.
הפעולות מגיעות באצוות: המתודה subscribe מוסרת מערך, והמערך הזה הוא יחידה אחת – יש להעביר אותו הלאה בשלמותו ולהחיל אותו ב-dispatch בשלמותו בצד השני.
יש להתייחס לפעולה כאל אובייקט אטום ולהעביר אותה כמות שהיא, בלי לקרוא או לשכתב אותה, כי המידע הפנימי שהיא נושאת, כגון הגרסה שלה, הוא ששומר על העורכים מסונכרנים.

חלק ממה שעורך עושה נשאר באותו עורך.
העברת טבלה, פתק או קבוצת טבלאות לחזית, כפי שקורה כשבוחרים באחד מהם, אינה נשלחת.
גם הבחירות Statements, Header, Write logical names into empty comments (החל מגרסה 4.2.0) ו-Tables בכרטיסיית סכמת SQL, השייכות לחלון שבו הן נעשות, אינן נשלחות.
החל מגרסה 4.1.0, גם הסייר נשאר בעורך שלו: האם הוא פתוח, הרוחב שלו, השורות המכווצות בו, השורה שעליה נמצא פוקוס המקלדת, מיקום הגלילה של העץ שלו, והחיפוש והאפשרויות שלו אינם נשלחים.
גם ההארה שמעבר אל מפתח זר מוסיף לקו של הקשר שלו אינה נשלחת.
החל מגרסה 4.2.0, גם כרטיסיית מילון נשארת בעורך שלה: איזה גיליון מוצג, והחיפוש, הבחירה, הגלילה ורוחבי העמודות של כל גיליון אינם נשלחים. העריכות, המיונים וייבואי ה-CSV בה כן נשלחים.
גלילה, זום או החלפת כרטיסייה נשלחים, אבל לעולם אינם מזיזים את התצוגה או את הכרטיסייה של משתמש אחר. הדבר כולל את הגלילה שמבצעת קפיצה מהסייר, את המעבר לכרטיסיית ERD כשהסייר נפתח מכרטיסייה אחרת, ואת החלפת הכרטיסייה והגלילה של קפיצה מהגיליון Checks של כרטיסיית מילון לטבלה או לעמודה. קפיצה מהגיליון הזה למילה, למונח או לתחום נשארת בכרטיסיית מילון, ולכן שום חלק ממנה אינו נשלח.

החל מגרסה 4.2.0, גם החלפה של תצוגת השמות נשלחת, והנעילה שלה קובעת מה העורכים האחרים עושים איתה. הנעילה Name View מופעלת בתרשים חדש ובכל מסמך מלפני גרסה 4.2.0.
כל עוד הנעילה מופעלת, ההחלפה מוצגת רק בעורך שביצע אותה: היא עדיין נשלחת, אבל כל עורך אחר וכל רפליקה משליכים אותה, כך שכל משתמש יכול לצפות בתצוגה אחרת בזמן ש-value שומר את התצוגה הנעולה.
כל עוד הנעילה כבויה, החלפה שבוצעה בעורך שמאפשר עריכה משנה את תצוגת השמות בכל עורך ובכל רפליקה, כשההחלפה האחרונה גוברת, וכל אחד מהם שומר אותה.
החלפה שעורך לקריאה בלבד מבצע בעצמו נשארת תמיד באותו עורך, והעורך עדיין עוקב אחרי ההחלפות המשותפות של האחרים.

החל מגרסה 5.1.0, שינוי של שפת מחולל הקוד, של סגנון שמות הטבלאות, של סגנון שמות העמודות או של סוג המירכאות כפוף באותו אופן לנעילה שלו (Language, Table Name Case, Column Name Case או Bracket Type), עם הבדל אחד: כל עוד הנעילה מופעלת, השינוי אינו נשלח כלל.
הוא מוצג רק בעורך שביצע אותו, וכרטיסיות מחולל הקוד וסכמת SQL שלו עוקבות אחריו, ושום עורך או רפליקה אחרים אינם רואים אותו. הערכים value ו-runtimeValue שומרים את הערך הנעול, ולכן גם מצטרף שאותחל מכל עורך אינו רואה אותו, וכל משתמש יכול לצפות בשפה, בסגנון שמות או בסוג מירכאות אחרים כל עוד הנעילה מופעלת.
כל עוד הנעילה כבויה, שינוי שבוצע בעורך שמאפשר עריכה נשלח מסומן כמשותף (shared: true במטען שלו). הוא משנה את ההגדרה בכל עורך ובכל רפליקה, כשהשינוי האחרון גובר, וכל אחד מהם שומר אותו. עורך או רפליקה בגרסה 5.1.0 מחילים שינוי מסומן יהיה מצב הנעילה שלהם אשר יהיה, ולכן שינוי שבוצע מיד אחרי ביטול נעילה מגיע לכל מקום, גם למקום שבו הוא מגיע לפני ביטול הנעילה.
לפני גרסה 5.1.0, שינוי כזה הגיע לכל עורך ולכל רפליקה, בין שהנעילה שלו הייתה מופעלת ובין שלא, בעוד הקובץ שמר את הערך הנעול.

החל מגרסה 5.0.0, עורך לקריאה בלבד אינו שולח שום שינוי. הגלילה, הזום, הכרטיסייה, תצוגת השמות, מסד הנתונים, שפת מחולל הקוד, סגנונות השמות, סוג המירכאות ושורות View Option שהקורא משנה נשארים על המסך שלו, יהיו הנעילות שלהם אשר יהיו; לפני גרסה 5.0.0 הגלילות, הזומים, החלפות הכרטיסיות, מסד הנתונים והגדרות הקוד שלו נשלחו כמו אלה של עורך שמאפשר עריכה.
המאגר שלו עדיין שולח את מה שהמעקבים שלו שולחים מהסמן, מהפוקוס, מהבחירה וממלבן הבחירה של הקורא, עונה על האוגרים שעורך מצטרף מבקש, ומחיל כל שינוי שהאחרים שולחים. שינוי של מסד הנתונים, של הגדרת מחולל קוד או של שורת View Option מגיע למסמך שלו, ולמסך שלו גם כן, אלא אם הקורא שינה את ההגדרה הזו שם, והחלפה משותפת של תצוגת השמות מוצגת על המסך שלו בכל מקרה. החל מגרסה 5.1.0, הוא מקבל הגדרה של מחולל הקוד רק כשההגדרה הזו שונתה כשהנעילה שלה כבויה או כשביטול נעילה נושא אותה.
ברגע שהעורך הופך לקריאה בלבד הוא שולח תחילה את מה שהמאגר עדיין מעכב מגרירה או מגלילה, כפי ש-flushStreamBuffers עושה, כך שהאחרים שומרים את סופה.

נעילות הן משותפות: הנעילה או ביטול הנעילה האחרונים של הגדרה גוברים בכל עורך, ונעילה נושאת את הערכים של העורך שהפעיל אותה, כך שכל עורך וכל רפליקה שומרים את אותו ערך.
לכן נעילת Viewport שומרת את התצוגה של העורך שהפעיל אותה, ונעילת Canvas Type את הכרטיסייה האחרונה שבה היה העורך הזה לפני כרטיסיית הגדרות, שבה מפעילים נעילות.
ביטול הנעילה של Language, Table Name Case, Column Name Case, Bracket Type או, החל מגרסה 4.2.0, Name View גם קובע את ההגדרה הזו בכל עורך לערך שמוצג בעורך שביטל אותה, כולל השינוי שלו עצמו שנעשה תחת הנעילה, כך שכל העורכים ממשיכים לשמור ערך אחד. ביטול הנעילה של Viewport או Canvas Type אינו מזיז את התצוגה או את הכרטיסייה של אף אחד.

עריכה של הסקריפט Before tables או After tables נשלחת בשלמותה כשהשדה שלו מאבד את הפוקוס. כל אחד משני הסקריפטים מוכרע בנפרד, כך שעריכה של שותף לעריכה באחד מהם לעולם אינה דורסת את השני.

שום דבר שנעשה במצב זרימה של כרטיסיית ויזואליזציה אינו שינוי במסמך, ולכן עורך שנמצא במצב זרימה אינו שולח לאחרים שום שינוי, והשינויים שהם שולחים ממשיכים לחול עליו כל עוד הוא שם.
יש שני חריגים. יציאה ממצב זרימה לכרטיסייה אחרת היא החלפת כרטיסייה, שנשלחת כמו כל החלפה אחרת. החל מגרסה 4.2.0, בחירה ברשימת תצוגת השמות בסרגל הכלים של מצב הזרימה היא החלפה של תצוגת השמות, שנשלחת ומוחלת כמו החלפה שבוצעה בבד הציור.
הלחצנים Previous table ו-Next table ומקשי ביטול הפעולה והביצוע החוזר, שצועדים בין התצוגות במצב זרימה, אינם נשלחים.
לחצן הקישור החיצוני בכרטיס, תוצאה של החיפוש המהיר שנבחרה אחרי #, @ או :, ופתיחת הסייר מעבירים כולם ממצב זרימה אל כרטיסיית ERD. גם גלילה שלחצן הכרטיס או תוצאה של החיפוש המהיר מבצעים שם נשלחת.

שני עורכים בדף אחד

החיבור מ-subscribe אל dispatch שכאן ממלא את מקום הרשת, כך שניתן לראות את צורת הסשן בלי ששכבת תעבורה מפריעה.

import '@dineug/erd-editor/erd-editor.js';

const editor1 = document.createElement('erd-editor');
const editor2 = document.createElement('erd-editor');

const sharedStore1 = editor1.getSharedStore({
  getNickname: () => 'editor1',
});
const sharedStore2 = editor2.getSharedStore({
  getNickname: () => 'editor2',
});

sharedStore1.subscribe(actions => {
  sharedStore2.dispatch(actions);
});

sharedStore2.subscribe(actions => {
  sharedStore1.dispatch(actions);
});

שני העורכים כאן מתחילים מאותו מסמך חדש וריק, כך שאין צורך לאתחל אף אחד מהם.
עם שלושה עורכים או יותר, יש לשלוח את האצוות של כל אחד מהם לכל האחרים: עורך לעולם אינו מעביר הלאה את מה שקיבל.

אתחול שותף לעריכה

מאגר משותף מעביר הלאה שינויים בזמן שהם נעשים ולעולם אינו מוסר למצטרף את המסמך במצבו הנוכחי, ולכן יש למסור תחילה את המסמך לעורך שמצטרף לסשן שכבר פועל.
החל מגרסה 4.0.0, יש לאתחל אותו באמצעות runtimeValue של עורך שכבר נמצא בסשן, ולא באמצעות value או הקובץ השמור.
חדר שחובר באמצעות @dineug/erd-editor-yjs מחזיק בעצמו את המסמך ברגע ששותף אתחל אותו, ולכן כל עורך שמחובר אליו פותח את המסמך הזה בלי ש-runtimeValue יימסר.

editor2.setInitialValue(editor1.runtimeValue);

const sharedStore2 = editor2.getSharedStore();

ערך זמן הריצה עדיין מכיל את מה שהוסר מאז שהמסמך נפתח, כך שכאשר עורך אחר מבטל מאוחר יותר הסרה, המצטרף מחזיר את הטבלה עם השם והעמודות שלה.
value הוא הצורה שנשמרת בקובץ, ללא ישויות שהוסרו, ולכן מצטרף שאותחל ממנו, או מהקובץ, היה מחזיר במקום זאת טבלה ריקה וללא שם.
החל מגרסה 4.2.0, אותו הדבר נכון גם למילה, למונח או לתחום שהוסרו מגיליון בכרטיסיית מילון: כשעורך אחר מבטל את ההסרה, מצטרף שאותחל מ-runtimeValue מחזיר את השורה לרשימה בשלמותה, ומצטרף שאותחל מ-value מחזיר שורה ריקה, שה-value שלו עצמו משמיט לאחר מכן.
יש להמשיך לכתוב את value לאחסון: runtimeValue נועד רק לאתחול עורך אחר, תצוגה שנייה או replicationStore.
העורכים ב-VS Code, ב-Obsidian, ב-IDE של JetBrains ובאפליקציית הרשת מאתחלים כך תצוגה שנייה של מסמך פתוח.

הקריאה ל-setInitialValue אינה מועברת הלאה, ולכן אתחול המצטרף אינו משנה דבר אצל האחרים.
החל מגרסה 4.0.0, היא גם משליכה את אוגרי שיתוף הפעולה של העורך, שמכריעים בין עריכות מקבילות. אם למאגר המשותף של העורך כבר היה מנוי, המאגר מבקש שוב מהעורכים האחרים את האוגרים שלהם, כמו בקריאה הראשונה שלו ל-subscribe, כך שעורך שנטען מחדש באמצע סשן מכריע בין עריכות כפי שהאחרים מכריעים.
השמה ל-value שומרת על האוגרים, אבל בניגוד ל-setInitialValue היא מועברת הלאה: ברגע שיש לעורך מאגר משותף, כל עורך בסשן טוען את המסמך שהוצב, ולכן לעולם אין לאתחל מצטרף בדרך זו.

לא value ולא runtimeValue מכילים את האוגרים או את הגרסה שהשעון של העורך הגיע אליה, ולכן מצטרף שאותחל מ-runtimeValue בלבד לוקח אותם מהתשובה שהעורכים בסשן שולחים להרשמה הראשונה שלו.
עד שהתשובה הזו מגיעה, עריכה שהמצטרף מבצע יכולה לשאת גרסה נמוכה מזו שהאחרים מחזיקים, ולכן הם דוחים אותה בעוד היא נשארת במצטרף, וכתיבה ישנה יותר שעדיין בדרך נוחתת על הכתיבה החדשה יותר שהאתחול מחזיק. במקום שבו שום עורך פעיל אינו עונה, כמו כששרת או מאגר מסמכים מחזיק את מסמך הסשן, המצטרף לעולם אינו מקבל אותם.
החל מגרסה 5.1.0, יש למסור אותם יחד עם הערך. בעורך שנמצא בסשן יש לקרוא ל-flushStreamBuffers(), כך שגרירה או שינוי צבע שהוא עדיין מעכב יוצאים תחילה, ואז לקרוא באותו רגע את runtimeValue ואת getLWW() ו-getVersion() של המאגר שלו. המצטרף טוען את הערך באמצעות setInitialValue, ואז לוקח את השאר באמצעות mergeLWW של המאגר שלו, בסדר הזה, כי כל setInitialValue משליכה את האוגרים. העריכה הבאה שלו נושאת אז גרסה שגבוהה מכל גרסה שהאתחול מחזיק, ולכן היא נוחתת בלי תשובה להמתין לה. במאגר שכבר קיים, reseed עושה את שני הדברים בקריאה אחת.

// on an editor already in the session
sharedStore1.flushStreamBuffers();
const seed = {
  value: editor1.runtimeValue,
  lww: sharedStore1.getLWW(),
  version: sharedStore1.getVersion(),
};

// on the joiner
editor2.setInitialValue(seed.value);
const sharedStore2 = editor2.getSharedStore();
sharedStore2.mergeLWW(seed.lww, seed.version);

אתחול ששומרים כך כדי לפתוח מצטרפים מאוחרים יותר מחזיק את שלושתם יחד. הוא אינו קובץ: value הוא עדיין מה שיש לכתוב לאחסון.
replicationStore אינו מוסר אוגרים, ולכן מצטרף שאותחל מ-runtimeValue שלו עדיין לוקח אותם מהתשובה של העורכים.

עריכות מקבילות

כל עורך וכל רפליקה מחזיקים, לכל שם ולכמעט כל שדה אחר, את הגרסה של הכתיבה שקבעה אותו: אלה אוגרי שיתוף הפעולה שלהם. כתיבה נוחתת רק כשהגרסה שלה אינה נמוכה מזו שמוחזקת, ולכן עורכים ששומעים את אותם שינויים בסדרים שונים מסיימים באותו מסמך.
החל מגרסה 5.1.0, כל גרסה נושאת, מתחת למונה שלה, משבצת של העורך הכותב עצמו, שנלקחת מהמזהה שלו. לכן גרסאות גדלות בקפיצות של 4,194,304 ועוברות את הגבול של מספר שלם של 32 סיביות ברגע שהמונה מגיע ל-512. JSON.stringify ו-JSON.parse נושאים אותן בשלמותן, אבל מנגנון העברה או מאגר שמנתחים אותן בשפה אחרת חייבים לשמור אותן כמספרים של 64 סיביות, ולעולם לא כמספרים שלמים של 32 סיביות.

החל מגרסה 5.1.0, שני עורכים ששינו שם אחד או שדה אחד באותו רגע, למעט החריגים שלהלן, מסיימים עם אותו ערך בכל עורך וברפליקה: כשהם כותבים באותו מונה, הם מחתימים שתי גרסאות שונות, והגבוהה מהן גוברת בכל מקום. לפני גרסה 5.1.0 שניהם יכלו להחתים גרסה אחת, וכל עורך שמר את מה ששמע אחרון, ולכן הם יכלו להסתיים במצבים שונים. שני עורכים חולקים משבצת בסיכוי של 1 מתוך 4,194,304 לכל זוג, ואז נוצר ביניהם תיקו כמו קודם.

החל מגרסה 5.1.0, מיקום של טבלה, מיקום וגודל של פתק או של קבוצת טבלאות, ונקודת המוצא ורמת הזום של התצוגה מנוהלים בגרסאות באותו אופן, ומה שמזיז אותם נשלח כמקום שבו הוא מסתיים:

• גרירה כ-table.moveTo, memo.moveTo או tableGroup.moveTo אחד לכל ישות שהוזזה, באצווה אחת, כך שגרירת קבוצה נושאת את נקודות הטבלאות שלה יחד עם זו של הקבוצה;
• ביטול או ביצוע חוזר של גרירה כנקודה שבה הוא מציב כל ישות;
• הזזת התצוגה כ-settings.scrollTo, וזום כ-settings.changeZoomLevel;
• שינוי גודל של פתק או של קבוצת טבלאות כמיקום וגודל יחד.

לכן שני משתמשים שמזיזים, או מזיזים ומשנים גודל, טבלה אחת, פתק אחד או קבוצת טבלאות אחת באותו רגע מסיימים כשהיא בנקודה אחת ובגודל אחד בכל עורך וברפליקה. הנקודה מגיעה מהכתיבה בעלת הגרסה הגבוהה יותר, שני הצירים יחד. הזזה אינה כותבת גודל, ולכן שינוי גודל שומר על הגודל שלו גם כשהזזה שנעשתה באותו רגע לוקחת את הנקודה.
לפני גרסה 5.1.0, גרירה נשלחה כמרחק שהוזז, ולכן שתי גרירות של טבלה אחת התווספו זו לזו, והזזה ושינוי גודל של פתק אחד או של קבוצת טבלאות אחת שנעשו באותו רגע יכלו להסתיים במצבים שונים.
גרירה של פחות מ-20 px, שאינה משאירה רשומת ביטול, נשלחת כמו כל גרירה אחרת, ולכן כנקודה היא יכולה לדרוס גרירה של אותה ישות שמשתמש אחר ביצע באותו רגע. אצוות של גרירה, הזזת תצוגה או זום ששכבת התעבורה מוסרת פעמיים אינה מזיזה דבר פעמיים.

שינוי צבע הוא חריג אחד. הוא יוצא בלי גרסה, וכל עורך וכל רפליקה מחתימים אותו בגרסה משלהם ושומרים את הצבע ששמעו אחרון, ולכן שני משתמשים שצובעים מחדש טבלה אחת, פתק אחד או קבוצת טבלאות אחת באותו רגע יכולים להסתיים עם צבעים שונים.
כמה שינויים אינם שומרים גרסה כלל, ולכן כל עורך וכל רפליקה מחילים אותם בסדר שבו הם שומעים אותם, ושניים שנעשו באותו רגע יכולים להסתיים במצבים שונים גם כן: עמודה שהוזזה בתוך הטבלה או האינדקס שלה (column.move, indexColumn.move), ושינוי של מסד הנתונים, של שורת View Option, או של Relationship DataType Sync, Maximum comment width או Column Order בכרטיסיית הגדרות.
ישויות ששני משתמשים מוסיפים באותו רגע, כגון שתי טבלאות או שתי עמודות של טבלה אחת, יכולות גם לעמוד בסדר שונה בכל עורך וברפליקה, וה-value של כל אחד שומר את הסדר שלו.

כל זה נכון בין עורכים ורפליקות בגרסה 5.1.0 ומעלה; שילוב גרסאות שונות מפרט מה משנה גרסה ישנה יותר.

שילוב גרסאות שונות

עורך מחיל רק את סוגי הפעולות שהגרסה שלו מכירה, ולכן בסשן שמשלב גרסאות שונות, העורכים הישנים יותר מפספסים כל מה שנשלח בסוג פעולה חדש יותר.

החל מגרסה 3.10.0, שינוי של ON DELETE או ON UPDATE של קשר עובר כאחד משני סוגי פעולות חדשים, relationship.changeOnDelete ו-relationship.changeOnUpdate, והפעולה relationship.add יכולה לשאת את שניהם. מנגנון העברה שמעביר פעולות כמות שהן אינו צריך דבר חדש עבורם.
עורך בגרסה שקודמת ל-3.10.0 מתעלם מסוגי הפעולות ומהשדות האלה: הוא לעולם אינו יודע מה ה-ON DELETE או ה-ON UPDATE של קשר, ומסמך שנשמר ממנו אינו כולל אף אחד מהם. קשר שעורך ישן יותר מוסיף מגיע בלעדיהם, ולכן שניהם מתחילים ב-Not set.

כל שינוי אחר שעורך בגרסה 3.10.0 שולח עובר בסוגי פעולות שעורכים ישנים יותר כבר מכירים.
הלחצן Replace All באיתור והחלפה שולח את העריכות שלו כאצווה אחת של אותן פעולות שינוי שם, הערה ופתק שעריכה ידנית שולחת. אפשרויות התצוגה Alternate Key ו-Referential Actions עוברות בפעולה הקיימת settings.changeShow.

החל מגרסה 4.0.0, השינויים הבאים עוברים בסוגי פעולות חדשים, ומנגנון העברה שמעביר פעולות כמות שהן אינו צריך דבר חדש עבורם:

• קבוצת טבלאות שנוספה, שהוזזה, שגודלה שונה, ששמה שונה, שצבעה שונה או שהוסרה: tableGroup.add, tableGroup.move, tableGroup.moveTo, tableGroup.resize, tableGroup.changeName, tableGroup.changeColor ו-tableGroup.remove; טבלה שמצטרפת לקבוצה או עוזבת אותה: table.changeGroup;
• לחיצה על Save במיפוי עמודות של קשר קיים, שקובעת את שתי רשימות העמודות שלו בבת אחת: relationship.changeColumns;
• נעילה שהופעלה או בוטלה: settings.changeLockSettings;
• עריכה של הסקריפט Before tables או After tables בכרטיסיית סכמת SQL: settings.changeDDLScript.

אפשרויות התצוגה Table Groups ו-Memos עוברות בפעולה הקיימת settings.changeShow.
הפעולה settings.changeIgnoreSaveSettings, שהמתגים Save Scroll Information ו-Save Zoom Information שלחו לפני שהנעילות החליפו אותם, כבר אינה נשלחת, והפעולה settings.changeRelationshipOptimization הוסרה. עורך בגרסה 4.0.0 שמקבל אחת מהן אינו משנה דבר.

עורך בגרסה שקודמת ל-4.0.0 מתעלם מסוגי הפעולות החדשים: הוא לעולם אינו רואה קבוצת טבלאות או אילו טבלאות נמצאות בה, אם כי גרירת קבוצה עדיין מזיזה בו את הטבלאות של הקבוצה, כי היא שולחת גם הזזה של כל אחת מהטבלאות האלה.
הוא שומר את העמודות הישנות של קשר אחרי לחיצה על Save במיפוי עמודות, וכשעמודה מהמיפוי הישן הזה מוסרת בו, הקשר נעלם בכל העורכים. אין בו נעילות ואין בו סקריפטים.
מסמך שנשמר ממנו אינו כולל אף אחד מאלה, ועורך בגרסה 4.0.0 פותח אותו כשכל הנעילות מופעלות.
יש לוודא שכל עורך בסשן, וכל replicationStore שמאחסן את המסמך שלו, נמצאים בגרסה 4.0.0 ומעלה.

עורך בגרסה 4.1.0 אינו שולח אף סוג פעולה חדש, ולכן עורכים ורפליקות בגרסאות 4.0.0 ו-4.1.0 חולקים סשן בלי לפספס דבר.
התכונה איתור והחלפה שלו מחפשת גם בשמות אינדקסים ובשמות קבוצות טבלאות, והלחצנים Replace ו-Replace All משנים את שמותיהם באמצעות הפעולות index.changeName ו-tableGroup.changeName, שעורך בגרסה 4.0.0 כבר מחיל.

החל מגרסה 4.2.0, השינויים הבאים עוברים בסוגי פעולות חדשים, ומנגנון העברה שמעביר פעולות כמות שהן אינו צריך דבר חדש עבורם:

• השם הלוגי של טבלה או של עמודה: table.changeLogicalName ו-column.changeLogicalName; האם השם שלה נגזר מהמילונים: table.changeNameDerived ו-column.changeNameDerived;
• עמודה שמקושרת לתחום או שהקישור שלה מבוטל: column.changeDomain;
• מילה, מונח או תחום שנוספו, שהשתנו (כולל המיקום שלהם בגיליון, כפי שמיון קובע אותו) או שהוסרו בכרטיסיית מילון: dictionary.add, dictionary.update ו-dictionary.remove;
• החלפה של תצוגת השמות: settings.changeNameViewMode.

הנעילה Name View עוברת בפעולה הקיימת settings.changeLockSettings, אפשרות התצוגה Domain בפעולה settings.changeShow, והזזה של Logical Name או של Domain בסדר העמודות בפעולה settings.changeColumnOrder.
הפעולות editor.clear ו-editor.loadJson של ייבוא סכמת SQL, GraphQL, DBML או AML מ-Import נושאות את keepDictionaries: true, ששומר את המילים, המונחים והתחומים בכל עורך. כך גם הפעולות של קריאה ל-setSchemaSQL, ל-setSchemaGraphQL, ל-setSchemaDBML או ל-setSchemaAML במצב החלפה.
שם פיזי שהמילונים גוזרים עובר בפעולה table.changeName או column.changeName, וסוג הנתונים שתחום נותן לעמודות שלו עובר בפעולה column.changeDataType, אותן פעולות שעריכה ידנית שולחת.

עורך בגרסה שקודמת ל-4.2.0 מתעלם מסוגי הפעולות החדשים: אין בו שמות לוגיים, קישורים לתחומים, מילונים או תצוגת שמות. נעילה או ביטול נעילה של Name View אינם משנים בו דבר, וכך גם הזזה של Logical Name או של Domain בסדר העמודות, או הזזה אל אחד מהם. גם נעילת Canvas Type שהופעלה על ידי עורך שהגיע לכרטיסיית הגדרות מכרטיסיית מילון אינה משנה בו דבר: העורך הישן יותר אינו מכיר את הכרטיסייה הזו, ולכן הוא משאיר את ההגדרה Canvas Type לא נעולה. הוא עדיין מציג את השמות הפיזיים שהמילונים גוזרים ואת סוגי הנתונים שתחומים נותנים.
העריכות שלו עצמו אינן יודעות דבר על שמות לוגיים, תחומים או המילונים, ולכך יש ההשפעות הבאות על העורכים החדשים יותר:

• בטבלה או בעמודה שהוא משנה את שמה ידנית, השם נשאר מסומן כנגזר, ולכן שם לוגי שנכתב עבורה מאוחר יותר בעורך חדש יותר יכול לגזור את השם מחדש ולדרוס את השם שהעורך הישן הקליד.
• סוג נתונים שהוא נותן לעמודה שמקושרת לתחום משאיר את הקישור, ולכן הגיליון Checks מציג את Domain type mismatch, והשינוי הבא בסוג של התחום נותן לעמודה שוב את הסוג של התחום.
• עמודות המפתח הזר של קשר שהוא מוסיף אינן מקבלות שם לוגי או תחום מהמפתח שלהן.
• טבלה שהוא מדביק או משכפל מגיעה בלי שמות לוגיים ובלי קישורים לתחומים.
• ייבוא של סכמת SQL, GraphQL, DBML או AML בו אינו שולח את keepDictionaries, ולכן הוא מרוקן את המילים, המונחים והתחומים בכל עורך.
• ביטול של טעינה, של ייבוא או של clear() בו טוען בכל עורך את העותק שלו של המסמך, ובעותק הזה אין שמות לוגיים, קישורים לתחומים או מילונים.
• העותק הזה, והמסמך שייבוא של סכמת SQL, GraphQL, DBML או AML בו טוען, גם מחזירים את הנעילה Name View בכל עורך למצב שבו העורך הישן מצא אותה. לאחר מכן כל עורך שומר את Physical Names כתצוגת השמות, וגם מציג אותה אם הנעילה כבויה.

מסמך שנשמר מעורך כזה אינו כולל שמות לוגיים, קישורים לתחומים, מילונים או תצוגת שמות, ולכן עורך בגרסה 4.2.0 פותח אותו בתצוגה Physical Names. העורך הישן יותר כן שומר את הנעילה Name View כפי שמצא אותה, כך שמסמך שהנעילה שלו בוטלה בעורך בגרסה 4.2.0 נשאר לא נעול.
יש לוודא שכל עורך בסשן, וכל replicationStore שמאחסן את המסמך שלו, נמצאים בגרסה 4.2.0 ומעלה.

עורך בגרסה 5.1.0 אינו שולח אף סוג פעולה חדש, ולכן עורכים ורפליקות מלפני גרסה 5.1.0 עדיין חולקים איתו סשן, ומנגנון העברה שמעביר פעולות כמות שהן אינו צריך דבר חדש. עם זאת, מה שעריכות מקבילות מתאר נכון רק בין עורכים ורפליקות בגרסה 5.1.0:

• הגרירות של עורך בגרסה 5.1.0 עוברות כנקודות ב-table.moveTo, ב-memo.moveTo וב-tableGroup.moveTo, שעורכים ישנים יותר כבר מחילים, והזזות התצוגה והזומים שלו כנקודות ב-settings.scrollTo וב-settings.changeZoomLevel, שכמו כל הזזת תצוגה וזום אף עורך אחר אינו מחיל ורק רפליקות לוקחות. עורך ישן יותר מחיל כל נקודה של גרירה בסדר שבו היא מגיעה, מחוץ לכל אוגר, ורפליקה ישנה יותר עושה את אותו הדבר עם כל נקודה של גרירה, של הזזת תצוגה או של זום, ולכן שתי נקודות שנשלחו באותו רגע לישות אחת, או לתצוגה, יכולות להסתיים שם במצבים שונים.
• גרירה של עורך ישן יותר עדיין עוברת כמרחק שהוזז, שכל עורך וכל רפליקה מוסיפים מחוץ לאוגרים שלהם, והזזת התצוגה או הזום שלו כמרחק גם כן, שכל רפליקה מוסיפה באותו אופן. מרחק ונקודה של ישות אחת שנעשו באותו רגע יכולים להסתיים במצבים שונים בעורכים וברפליקות ששומעים אותם בסדרים שונים, ומרחק ששכבת התעבורה מוסרת פעמיים מתווסף פעמיים.
• מחוץ לחריגים שעריכות מקבילות מפרט, כתיבה של שם או שדה בעורך בגרסה 5.1.0 שנעשתה באותו רגע עם כתיבה שלו בעורך ישן יותר גוברת כמעט תמיד, עם אותה תוצאה בכל עורך וברפליקה. שני עורכים ישנים יותר עדיין יכולים להסתיים במצבים שונים בגלל שדה אחד שנכתב בו זמנית.
• עורך בגרסה 5.1.0 שולח שינוי של שפת מחולל הקוד, של סגנון שמות או של סוג המירכאות רק כשהנעילה שלו כבויה, עם הסימון shared: true, שעורך ישן יותר מתעלם ממנו ומחיל את השינוי כמו קודם. עורך ישן יותר עדיין שולח שינוי שהוא מבצע תחת הנעילה, בלי סימון: עורך או רפליקה בגרסה 5.1.0 משליכים אותו כל עוד ההגדרה נעולה אצלם, ועורכים ישנים יותר מחילים אותו. לכן תחת נעילה העורכים הישנים יותר עוקבים אחרי הבחירות זה של זה, והעורכים בגרסה 5.1.0 שומרים על שלהם, והקובץ שומר את הערך הנעול בשני המקרים. ביטול נעילה שבוצע בכל אחת מהגרסאות נושא את הערך של מי שביטל אותה לכל עורך ולכל רפליקה.
• טעינה שמחליפה את המסמך, כגון value שהוצב, clear() או ייבוא מחליף, מסיימת ציור קשר שמתבצע בכל עורך בגרסה 5.1.0, בעורך שביצע אותה ובכל עורך שמקבל אותה. עורך ישן יותר משאיר את הציור מופעל גם אחריה.

יש לוודא שכל עורך בסשן, וכל replicationStore שמאחסן את המסמך שלו, נמצאים בגרסה 5.1.0 ומעלה, כדי שעריכות שנעשות באותו רגע יסתיימו באותו אופן בכל מקום, למעט החריגים שעריכות מקבילות מפרט; גרסה 4.2.0 ומעלה היא עדיין מה ששומר על שמות לוגיים ומילונים. שרת MCP בגרסה שקודמת ל-1.2.0 נחשב כאן לעורך בגרסה שקודמת ל-5.1.0, ולא ניתן כלל לחבר עורך בגרסה שקודמת ל-5.1.0 לחדר Yjs.

SharedStoreConfig

getNickname

קובע את הכינוי שמוצג ליד סמן העכבר של המשתמש הזה בעורכים האחרים.
משתמשים אחרים רואים user כשהכינוי חסר או ריק.

editor.getSharedStore({
  getNickname: () => 'nickname...',
});

mouseTracker

משדר את סמן העכבר של המשתמש הזה לעורכים האחרים. ברירת המחדל היא true.
סמני עכבר שנשלחים על ידי משתמשים אחרים מוצגים תמיד על בד הציור של ERD.

editor.getSharedStore({ mouseTracker: false });

focusTracker

משדר את מה שהמשתמש הזה עובד עליו. ברירת המחדל היא true.
הטבלה שבפוקוס והתא הפעיל, הטבלאות, הפתקים וקבוצות הטבלאות שנבחרו, ומלבן הבחירה שגוררים על בד הציור נשלחים לעורכים האחרים ומוצגים בהם.
כל משתמש מקבל צבע משלו, כך שניתן להבחין ביניהם: מסגרת סביב הטבלה שבפוקוס, קו תחתון מתחת לתא הפעיל, טבעת סביב הטבלאות, הפתקים וקבוצות הטבלאות שנבחרו, ומלבן מקווקו שמייצג את מלבן הבחירה.
החל מגרסה 4.2.0, כל משתמש יכול לצפות בתצוגת שמות אחרת כל עוד הנעילה שלה מופעלת, או אחרי החלפה שעורך לקריאה בלבד ביצע בעצמו. תא פעיל שהתצוגה הנוכחית אינה מציגה מסומן בקו תחתון על התא שהיא מציגה במקומו: השם והשם הלוגי באים זה במקום זה, כמו סוג הנתונים והתחום.
נוכחות שמגיעה ממשתמשים אחרים מוצגת תמיד על בד הציור של המשתמש, בין אם האפשרות הזו מופעלת ובין אם לא.
במצב זרימה של כרטיסיית ויזואליזציה, הפוקוס והבחירה של משתמשים אחרים מוצגים על כרטיסי הטבלאות, אבל מלבני הבחירה שלהם אינם מוצגים. הטבלאות שבוחרים שם עדיין נשלחות; מלבן הבחירה שגוררים שם אינו נשלח.

editor.getSharedStore({ focusTracker: false });

כדי להשתמש במאגר המשותף כמנגנון העברה פשוט שאינו מפרסם נוכחות משלו, יש לכבות את שני רכיבי המעקב.
נוכחות שנשלחת מעורכים אחרים עדיין מתקבלת ומוצגת.
כך פועלים העורכים ב-VS Code, ב-Obsidian, ב-IDE של JetBrains וב-Google Drive.

editor.getSharedStore({ mouseTracker: false, focusTracker: false });

סמן העכבר, הפוקוס, הבחירה ומלבן הבחירה עוברים באותו זרם כמו השינויים במסמך, אבל הם ארעיים.
הם לעולם אינם נכנסים למסמך, להיסטוריית הפעולות או ל-editor.value, ולכן שכבת התעבורה רשאית להשמיט אותם, ו-replicationStore מתעלם מהם.

SharedStore

connection, disconnect

מתודות אלה קובעות את מצב החיבור הנוכחי.
בזמן שהחיבור מנותק, השינויים נאגרים באופן פנימי.
השינויים שנאגרו משוגרים למנויים ברגע שאפשר לשלוח שוב.
מצב ברירת המחדל הוא מחובר (connection).

sharedStore.connection();
sharedStore.disconnect();

dispatch, dispatchSync

מחילות שינויים ממופעי עורך אחרים על מופע העורך הנוכחי.
כשאצווה מכילה בקשה של עורך אחר לאוגרים, כפי שההרשמה הראשונה של מצטרף שולחת, המאגר עונה דרך המנויים שלו עם האוגרים שלו ועם הגרסה שלו, אלא אם אין לו אוגרים.
החל מגרסה 5.1.0, הוא שולח תחילה כל אצוות זרם שהוא עדיין מעכב, כפי ש-flushStreamBuffers עושה, כך שכל גרסה שהתשובה שלו נושאת נשענת על כתיבה שכבר נשלחה לאחרים. לכן הגעה של מצטרף גורמת לכל עורך בסשן לשלוח בבת אחת גרירה, הזזת תצוגה, זום, שינוי צבע או שינוי גודל של פתק שהוא עדיין מעכב.

sharedStore.dispatch(actions); // async
sharedStore.dispatchSync(actions); // sync

subscribe

נרשמת לשינויים בעורך.
שום דבר אינו יוצא מהעורך עד שיש לפחות מנוי אחד, ושינויים שנעשים לפני כן נאגרים.
ההרשמה הראשונה גם מבקשת מהעורכים האחרים את אוגרי שיתוף הפעולה שלהם, שמכריעים בין עריכות מקבילות, כך שמצטרף מאוחר מכריע ביניהן באותו אופן.
היא אינה מביאה את המסמך, ולכן יש תחילה לאתחל מצטרף מאוחר; החל מגרסה 5.1.0, האתחול יכול לשאת גם את האוגרים.
החל מגרסה 4.0.0, המאגר מבקש שוב בכל פעם ש-setInitialValue, או החל מגרסה 5.1.0 reseed, טוענת מסמך לעורך שלו אחרי ההרשמה הראשונה הזו.

const unsubscribe = sharedStore.subscribe(actions => {
  // send...
});

flushStreamBuffers

שולחת עכשיו את אצוות הזרם שהמאגר הזה עדיין מעכב, במקום אחרי תקופת השקט שלהן.
החל מגרסה 3.9.2, היא פועלת במאגר שמתקבל מ-getSharedStore; בגרסה 3.9.1 המתודה קיימת בטיפוס אך אינה עושה דבר.
הזזת טבלה, פתק או קבוצת טבלאות, שינוי הצבע שלהם, שינוי גודל של פתק, וגלילה או זום של התצוגה נעשים כל אחד כזרם של שינויים קטנים. שינוי גודל של קבוצת טבלאות אינו נעשה כך: הוא נשלח פעם אחת, כשהגרירה מסתיימת.
המאגר אוסף כל זרם לאצווה אחת ומעכב אותה עד שהזרם שקט במשך 200ms, בשני שלבים. שינוי צבע או שינוי גודל של פתק עוברים את שניהם, ולכן הם יוצאים כ-400ms אחרי השינוי האחרון, כפי שיצא כל זרם לפני גרסה 5.1.0. החל מגרסה 5.1.0, גרירה, הזזת תצוגה או זום יוצאים אחרי השלב הראשון, כ-200ms אחרי הצעד האחרון שלהם, כמקום שבו הם מסתיימים (ראו עריכות מקבילות).
קריאה מסיימת את ההמתנה הזו בשני השלבים. כל עוד המאגר מחובר, מנוי מקבל את האצווה לפני שהקריאה חוזרת. קריאה כשאין דבר מעוכב אינה שולחת דבר.
המתודה destroy, של המאגר עצמו או של העורך, מוחקת אצווה שעדיין מעוכבת, ולכן יש לקרוא קודם ל-flushStreamBuffers כשמשחררים מאגר והאחרים אמורים לשמור את השינוי האחרון, כמו כשכרטיסייה נסגרת.

sharedStore.flushStreamBuffers();
sharedStore.destroy();

getLWW

החל מגרסה 5.1.0, מחזירה עותק של אוגרי שיתוף הפעולה של העורך (ראו עריכות מקבילות).
העותק נעשה דרך JSON, ולכן הוא אובייקט פשוט שמוכן ל-JSON.stringify, ושינוי בו משאיר את האוגרים של המאגר כפי שהיו.
יש למסור אותו כמות שהוא ל-mergeLWW או ל-reseed של מאגר אחר. הצורה שלו שייכת לעורך, ולכן אין לקרוא אף שדה שלו.
יש לקרוא אותו יחד עם getVersion ועם runtimeValue של העורך באותו רגע כדי לאתחל מצטרף.

const lww = sharedStore.getLWW();

mergeLWW

החל מגרסה 5.1.0, לוקחת אוגרים שמאגר אחר מסר באמצעות getLWW אל האוגרים של המאגר הזה, ושומרת את הגרסה הגבוהה יותר של כל אחד, ולוקחת את version אל השעון של העורך, ששומר את הגבוהה מבין הגרסה שלו והגרסה שנמסרה.
היא אינה משנה דבר במסמך: אף בייט של value או של runtimeValue, אף רשומת ביטול ואף אירוע change. היא רק מעלה את הגרסאות שכתיבה מאוחרת יותר צריכה לגבור עליהן, כך שכתיבה ישנה מהאוגרים שנמסרו נדחית אחר כך, והעריכה הבאה של העורך נושאת גרסה שגבוהה מ-version.
היא אינה שולחת דבר ואינה עונה על דבר. היא קולטת ישירות את מה שההרשמה הראשונה של מצטרף מקבלת מהתשובה של האחרים.
יש לקרוא לה אחרי setInitialValue, ולעולם לא לפניה: כל setInitialValue וכל reseed משליכים את האוגרים שמוחזקים, ואיתם את מה ש-mergeLWW שלפניהם לקחה.

sharedStore.mergeLWW(lww, version);

getVersion

החל מגרסה 5.1.0, מחזירה את הגרסה הגבוהה ביותר שהשעון של העורך מיזג: הגבוהה מבין הגרסאות של השינויים שהוא ביצע או לקח, של הבקשות לאוגרים ושל התשובות שהצטרפות מחליפה, ושל כל version שנמסר ל-mergeLWW או ל-reseed.
סמנים, פוקוס, בחירות ומלבני בחירה, שלו או של עורך אחר, אינם מזיזים אותה.
יש למסור אותה יחד עם getLWW(), שנקרא באותו רגע, ל-mergeLWW או ל-reseed של מצטרף. זו גרסה כמו אלה שהפעולות שלו נושאות.

const version = sharedStore.getVersion();

forgetPeer

החל מגרסה 5.1.0, מסירה מיד את הסמן, הפוקוס, הבחירה ומלבן הבחירה שהעורך עם המזהה הנתון שלח, ואת התפוגה שכל אחד מהם המתין לה. אלה של כל עורך אחר נשארים.
המזהה הוא meta.editorId שנושאת כל פעולה שהמאגר המשותף של אותו עורך שולח. מזהה שהעורך הזה אינו מחזיק ממנו דבר אינו משנה דבר.
יש לקרוא לה כששכבת התעבורה מגלה שעמית עזב. אחרת מה שהעמית שלח נשאר מוצג עד שהוא פג: הסמן שלו 30 שניות אחרי האחרון שהתקבל, הפוקוס והבחירה שלו 90 שניות אחריהם, ומלבן הבחירה שלו 3 שניות אחריו.

sharedStore.forgetPeer(editorId);

reseed

החל מגרסה 5.1.0, פותחת מחדש בעורך את המסמך של סשן, כפי שהצטרפות מחדש עושה. החיבור של Yjs קורא לה כדי לפתוח את המסמך של חדר כשהוא מתחבר לחדר שאותחל, ושוב בכל הצטרפות מחדש, ושומר את המסך מרגע שהצטרף לחדר.
היא טוענת את value כפי ש-setInitialValue עושה ולוקחת את lww ו-version כפי ש-mergeLWW עושה, כך שהמאגר מחזיק אז בדיוק את האוגרים שנמסרו, והשעון שלו מחזיק את הגבוהה מבין הגרסה שלו ו-version. היא גם מרוקנת את היסטוריית הביטול, ובניגוד ל-setInitialValue היא משליכה את הבחירה ואת הפוקוס, כי הם עשויים לציין את מה שהערך כבר אינו מחזיק.
מלבד גזירת השם הלוגי שלהלן, היא אינה יוצרת רשומת ביטול, אינה משגרת אירוע change ואינה שולחת שינוי. אחרי שלמאגר היה מנוי, היא שולחת את הבקשה לאוגרים שכל טעינה כזו שולחת, ששכבת תעבורה שכבר מסרה את האוגרים רשאית להשמיט, ובמקרה ש-focusTracker מופעל, גם את הבחירה והפוקוס שנוקו.
כמו setInitialValue, היא פועלת בזמן ש-readonly מוגדר, משליכה תצוגת זרימה, מסיימת ציור קשר שמתבצע, וסוגרת את עורכי הפתק, שם קבוצת הטבלאות והתא, ושומרת או משליכה את מה שהוקלד בהם באותו אופן; שם שתא שם לוגי שנסגר גוזר ממה שהקורא שלו הקליד הוא עריכה רגילה: נשלח, ניתן לביטול ומשוגר כאירוע change.

בלי keepScreen המסך מציג את מה שהערך מחזיק, כמו אחרי setInitialValue. עם keepScreen: true המסך של הקורא מונח בחזרה על המסמך שנטען, על המסך הזה בלבד:

• מיקום הגלילה ורמת הזום, אחרי שהאלמנט הציג אותם; כאלה שלא הוצגו מעולם, או שנטענו בזמן שהאלמנט מוסתר ולא הוצגו מאז, נפתחים במקום שהערך מציב אותם, כפי שמצטרף מאוחר עושה;
• הכרטיסייה, כשהטעינה הזיזה אותה, ובכרטיסיית הגדרות גם הכרטיסייה שהקורא הגיע ממנה, שנעילת Canvas Type שהופעלה שם מציינת;
• תצוגת השמות וכל הגדרה של מחולל הקוד שהקורא הציג בעצמו תחת הנעילה שלה, אבל רק כשהנעילה הזו הייתה מופעלת לפני הטעינה, עדיין מופעלת אחריה, ומחזיקה את אותו ערך נעול. לכן כשעמית ביטל נעילה של הגדרה, שינה אותה ונעל אותה שוב בערך אחר בינתיים, העורך נפתח על הערך הנעול החדש, וכשהנעילה כבויה לפני הטעינה או אחריה, הוא מציג את הערך שנטען;
• כל הגדרה שהקורא של עורך לקריאה בלבד שינה על המסך שלו, יהיו הנעילות אשר יהיו.

שום דבר מזה אינו נשלח, ו-value ו-runtimeValue עדיין מדווחים על המסמך שנטען. ביטול נעילה מאוחר יותר של עמית מחליף הגדרת קוד שנשמרה כך, כמו כל ביטול נעילה.
הגלילה או הזום הבאים של הקורא שנעשים בזמן שהעורך יכול לערוך הופכים שוב את מיקום הגלילה ואת רמת הזום שנשמרו לאלה של המסמך, ויוצאים כשהם מובלים על ידי המקום שבו המסך עומד, כך שרפליקות לוקחות גם את הזום הזה.

reseed משאירה את מה שהמאגר מעכב כפי שהוא. גרירה, הזזת תצוגה או זום שעדיין מעוכבים יוצאים אחריה, כשהם נקראים מהמסמך שנפתח מחדש; שינוי צבע או שינוי גודל של פתק יוצאים כפי שנעשו, אף שהעורך כבר אינו מציג אותם; ומה ש-disconnect() עיכבה יוצא ב-connection().
לכן יש לקרוא קודם ל-flushStreamBuffers, לשלוח את מה שהיא משגרת, ולבצע reseed עם ערך שמחזיק אותו. לעולם אין לבצע reseed בזמן שהחיבור מנותק.

sharedStore.reseed(seed.value, {
  lww: seed.lww,
  version: seed.version,
  keepScreen: true,
});

destroy

משמידה לחלוטין את מופע ה-sharedStore.
העורך עצמו אינו מושפע, כך שאחרי עזיבת סשן עדיין ניתן לערוך את המסמך.
רכיבי המעקב אחר העכבר והפוקוס נעצרים ברגע שה-sharedStore האחרון שהעורך מסר מושמד.
אצוות זרם שהמאגר עדיין מעכב נמחקת יחד איתו; כדי לשלוח אותה, יש לקרוא תחילה ל-flushStreamBuffers.
הסמנים, הפוקוס, הבחירות ומלבני הבחירה שעורכים אחרים שלחו נשארים מוצגים עד שהם פגים; החל מגרסה 5.1.0, forgetPeer מסירה את אלה של עורך אחד מיד.

sharedStore.destroy();