Saves that merge, or refuse

/** `mine` and `theirs`, both changed from `base`, as one text; undefined where they clash. */
export function merge(base: string, mine: string, theirs: string): string | undefined {
  if (mine === theirs || theirs === base) return mine;
  if (mine === base) return theirs;
  const lines = linesOf(base);
  const all = [
    ...hunksOf(lines, linesOf(mine), "mine"),
    ...hunksOf(lines, linesOf(theirs), "theirs"),
  ].sort((a, b) => a.start - b.start || (a.end - a.start) - (b.end - b.start));
  // Changes that overlap go together: each group is a stretch of the base both may have changed.
  const groups: { start: number; end: number; hunks: Hunk[] }[] = [];
  for (const h of all) {
    const last = groups.at(-1);
    const insertion = h.start === h.end;
    const over = last && (
      h.start < last.end ||
      // Both adding lines at the same place: which goes first is a choice.
      (insertion && last.start === last.end && h.start === last.start)
    );
    if (over) {
      last.end = Math.max(last.end, h.end);
      last.hunks.push(h);
    } else groups.push({ start: h.start, end: h.end, hunks: [h] });
  }
  const out: string[] = [];
  let at = 0;
  for (const g of groups) {
    out.push(...lines.slice(at, g.start));
    const of = (side: Hunk["side"]) => g.hunks.filter((h) => h.side === side);
    const ours = applied(lines, g.start, g.end, of("mine"));
    const others = applied(lines, g.start, g.end, of("theirs"));
    if (!of("theirs").length || equal(ours, others)) out.push(...ours);
    else if (!of("mine").length) out.push(...others);
    else return undefined;
    at = g.end;
  }
  return [...out, ...lines.slice(at)].join("\n");
}

let text = input.text;
let title = asked ?? doc.title;
const merging = input.base < doc.version;
if (merging) {
  const base = await tx.db.collection<DocumentVersion>("documentVersion").findOne({
    _id: versionId(doc._id, input.base),
  });
  const merged = base ? merge(base.text, input.text, doc.text) : undefined;
  const named = asked === undefined
    ? doc.title
    : base
    ? mergeField(base.title, asked, doc.title)
    : undefined;
  if (merged === undefined || named === undefined) {
    const who = await nameOf({ db: tx.db, resources: ctx.resources }, doc.savedBy);
    throw fail(
      `${who} saved version ${doc.version} since you started from version ` +
        `${input.base}, changing the same ${merged === undefined ? "lines" : "title"}. ` +
        "Nothing was saved: keep yours over theirs, take theirs, or merge them by hand.",
      "conflict",
      { version: doc.version, by: doc.savedBy, at: doc.savedAt },
    );
  }
  text = merged;
  title = named;
}
const written = await commit(tx, doc, {
  title,
  text,
  kind: "save",
  ...(merging ? { merged: true, base: input.base } : {}),
}, { by: keyOf(ctx.actor!) });
return { ...written, ...(merging ? { merged: true, text, title } : {}) };

export const documentPresence = defineCollection({
  durable: false,
  schema: {
    type: "object",
    properties: {
      document: { type: "string" },
      in: { type: "string" },
      /** Who: `person:ana`. */
      who: { type: "string" },
      /** `open`: reading it, or with nothing unsaved; `editing`: with changes not yet saved. */
      state: { enum: ["open", "editing"] },
      /** When the page last said so. */
      at: { type: "string" },
    },
    required: ["document", "in", "who", "state", "at"],
  },
});

export const presenceAction = defineAction({
  description: "Says who has a document open, and whether they're editing it",
  record: false,
  // … input: document, page, state (open, editing, gone)
  run: async (ctx, input) => {
    const doc = await ctx.db.collection<Document>("document").findOne({ _id: input.document });
    if (!doc) return { present: false };
    const who = keyOf(ctx.actor!);
    const _id = presenceId(doc._id, who, input.page);
    const presence = ctx.db.collection("documentPresence");
    if (input.state === "gone") await presence.deleteOne({ _id });
    else {
      await presence.replaceOne(
        { _id },
        { document: doc._id, in: doc.in, who, state: input.state, at: new Date().toISOString() },
        { upsert: true },
      );
    }
    await presence.deleteMany({
      document: doc._id,
      at: { $lt: new Date(Date.now() - STALE_MS).toISOString() },
    });
    return { present: input.state !== "gone" };
  },
});

// Reading, or a write that only takes reading (saying you have a document open).
if (access === "read" || shared[collection].write === "read") return true;

await runtime.call("document.save", {
  document,
  base: 1,
  text: "Film the trailer.\nReview the page.",
}, { actor });

{ document: '<id>', title: 'Launch plan', version: 1, added: 2, removed: 0 }
{ document: '<id>', title: 'Launch plan', version: 2, added: 1, removed: 0 }
{ document: '<id>', title: 'Launch plan', version: 3, added: 1, removed: 1, merged: true, text: 'Film the trailer.\nReview the page.\nShip it on Monday.' }
conflict: Ana saved version 3 since you started from version 1, changing the same lines. Nothing was saved: keep yours over theirs, take theirs, or merge them by hand.
{ document: '<id>', title: 'Launch plan', version: 4, added: 1, removed: 2 }
v4 restore from v1 by person:ana: +1 −2
v3 save (merged) by person:ana: +1 −1
v2 save by person:ana: +1 −0
v1 create by person:ana: +2 −0