@openmarket/rooms-client 0.1.0

package/src/merge3.ts

@@ -0,0 +1,326 @@
+/**
+ * Line-based three-way merge (diff3 semantics) for the library mirror's
+ * agent-mediated conflict resolution. Pure, no deps, byte-faithful: content
+ * is split on "\n" only and re-joined identically, so CRLF and no-trailing-
+ * newline round-trip exactly.
+ *
+ * The contract callers rely on:
+ * - `clean: true` means every collision region was one-sided or identical on
+ *   both sides; `merged` is the full merged document.
+ * - `clean: false` means at least one region genuinely diverged (or an input
+ *   bound tripped); `merged` is "" so no caller can write a half-merge, and
+ *   `regions` carries the diverging chunks for a mediator to look at.
+ * - Identical changes on BOTH sides merge clean. This is load-bearing: a
+ *   crash between the merged-file write and the manifest save re-runs the
+ *   merge with mine already containing theirs' lines, and it must converge.
+ * - Touching-or-overlapping changes from the two sides conflict (git's
+ *   conservative rule); insertions at the same anchor conflict.
+ */
+
+export interface Merge3Region {
+  base: string[];
+  mine: string[];
+  theirs: string[];
+}
+
+/** The not-clean document as resolved line chunks with placeholders where
+ *  the conflict regions go: everything a region-scoped mediator needs to
+ *  splice resolved regions back without regenerating the whole document. */
+export type MergeSkeletonPart =
+  | { kind: "lines"; lines: string[] }
+  | { kind: "region"; index: number };
+
+export interface Merge3Result {
+  clean: boolean;
+  merged: string;
+  regions: Merge3Region[];
+  /** Present exactly when regions exist. */
+  skeleton?: MergeSkeletonPart[];
+}
+
+/** Reassemble a skeleton with one resolved text per region ("" = the region
+ *  resolves to nothing). The counterpart of a region-scoped mediation. */
+export function spliceSkeleton(skeleton: MergeSkeletonPart[], resolved: string[]): string {
+  const lines: string[] = [];
+  for (const part of skeleton) {
+    if (part.kind === "lines") {
+      lines.push(...part.lines);
+    } else {
+      const text = resolved[part.index];
+      if (text === undefined) throw new Error(`missing resolution for region ${part.index}`);
+      if (text !== "") lines.push(...text.split("\n"));
+    }
+  }
+  return lines.join("\n");
+}
+
+export interface Merge3Options {
+  /** Per-side line cap; above it merge3 bails to not-clean. */
+  maxLines?: number;
+  /** Myers edit-distance bound per diff; above it merge3 bails to not-clean. */
+  maxEditDistance?: number;
+}
+
+const DEFAULT_MAX_LINES = 30_000;
+const DEFAULT_MAX_EDIT_DISTANCE = 2_048;
+
+/** Base range [aStart,aEnd) was replaced by side range [bStart,bEnd). */
+interface DiffHunk {
+  aStart: number;
+  aEnd: number;
+  bStart: number;
+  bEnd: number;
+}
+
+/**
+ * Myers O(ND) shortest-edit-script diff at line granularity, returning
+ * base-anchored replacement hunks. Returns null when the edit distance
+ * exceeds maxD (caller bails to not-clean, which degrades to the existing
+ * theirs-file behavior).
+ */
+function diffLines(a: readonly string[], b: readonly string[], maxD: number): DiffHunk[] | null {
+  // Trim the common prefix/suffix first: cheap, and it keeps the Myers band
+  // proportional to the actual change, not the file.
+  let start = 0;
+  const minLen = Math.min(a.length, b.length);
+  while (start < minLen && a[start] === b[start]) start++;
+  let endA = a.length;
+  let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+    endA--;
+    endB--;
+  }
+  const n = endA - start;
+  const m = endB - start;
+  if (n === 0 && m === 0) return [];
+  if (n === 0) return [{ aStart: start, aEnd: start, bStart: start, bEnd: endB }];
+  if (m === 0) return [{ aStart: start, aEnd: endA, bStart: start, bEnd: start }];
+
+  const max = Math.min(n + m, maxD);
+  const offset = max;
+  const width = 2 * max + 1;
+  let v = new Int32Array(width);
+  const trace: Int32Array[] = [];
+  let foundD = -1;
+
+  outer: for (let d = 0; d <= max; d++) {
+    trace.push(v.slice());
+    const next = v.slice();
+    for (let k = -d; k <= d; k += 2) {
+      if (k < -max || k > max) continue;
+      let x: number;
+      if (k === -d || (k !== d && (v[k - 1 + offset] ?? 0) < (v[k + 1 + offset] ?? 0))) {
+        x = v[k + 1 + offset] ?? 0;
+      } else {
+        x = (v[k - 1 + offset] ?? 0) + 1;
+      }
+      let y = x - k;
+      while (x < n && y < m && a[start + x] === b[start + y]) {
+        x++;
+        y++;
+      }
+      next[k + offset] = x;
+      if (x >= n && y >= m) {
+        v = next;
+        foundD = d;
+        break outer;
+      }
+    }
+    v = next;
+  }
+  if (foundD < 0) return null;
+
+  // Backtrack: one del/ins per d, snakes in between. Collect edits in
+  // reverse, then group contiguous edits into hunks.
+  interface Edit {
+    type: "del" | "ins";
+    x: number;
+    y: number;
+  }
+  const edits: Edit[] = [];
+  let x = n;
+  let y = m;
+  for (let d = foundD; d > 0; d--) {
+    const prev = trace[d];
+    if (!prev) return null;
+    const k = x - y;
+    let prevK: number;
+    if (k === -d || (k !== d && (prev[k - 1 + offset] ?? 0) < (prev[k + 1 + offset] ?? 0))) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevX = prev[prevK + offset] ?? 0;
+    const prevY = prevX - prevK;
+    if (prevK === k + 1) {
+      // Vertical move: b[prevY] was inserted at base position prevX.
+      edits.push({ type: "ins", x: prevX, y: prevY });
+    } else {
+      // Horizontal move: a[prevX] was deleted.
+      edits.push({ type: "del", x: prevX, y: prevY });
+    }
+    x = prevX;
+    y = prevY;
+  }
+  edits.reverse();
+
+  const hunks: DiffHunk[] = [];
+  let current: DiffHunk | null = null;
+  let pathX = -1;
+  let pathY = -1;
+  for (const edit of edits) {
+    const contiguous = current !== null && edit.x === pathX && edit.y === pathY;
+    if (!contiguous) {
+      if (current) hunks.push(current);
+      current = { aStart: edit.x, aEnd: edit.x, bStart: edit.y, bEnd: edit.y };
+    }
+    if (!current) continue;
+    if (edit.type === "del") {
+      current.aEnd = edit.x + 1;
+      pathX = edit.x + 1;
+      pathY = edit.y;
+    } else {
+      current.bEnd = edit.y + 1;
+      pathX = edit.x;
+      pathY = edit.y + 1;
+    }
+  }
+  if (current) hunks.push(current);
+
+  // Re-anchor to full coordinates (the prefix trim shifted everything).
+  return hunks.map((hunk) => ({
+    aStart: hunk.aStart + start,
+    aEnd: hunk.aEnd + start,
+    bStart: hunk.bStart + start,
+    bEnd: hunk.bEnd + start,
+  }));
+}
+
+/** A side's replacement lines for base range [aStart,aEnd), given the side's
+ *  cluster hunks (linear offset mapping holds between hunks). */
+function sideSlice(
+  sideLines: readonly string[],
+  baseLines: readonly string[],
+  hunks: readonly DiffHunk[],
+  aStart: number,
+  aEnd: number,
+): string[] {
+  if (hunks.length === 0) return baseLines.slice(aStart, aEnd);
+  const first = hunks[0] as DiffHunk;
+  const last = hunks[hunks.length - 1] as DiffHunk;
+  const sStart = first.bStart - (first.aStart - aStart);
+  const sEnd = last.bEnd + (aEnd - last.aEnd);
+  return sideLines.slice(sStart, sEnd);
+}
+
+function sameLines(a: readonly string[], b: readonly string[]): boolean {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+function notClean(base: string[], mine: string[], theirs: string[]): Merge3Result {
+  return {
+    clean: false,
+    merged: "",
+    regions: [{ base, mine, theirs }],
+    skeleton: [{ kind: "region", index: 0 }],
+  };
+}
+
+export function merge3(
+  base: string,
+  mine: string,
+  theirs: string,
+  options: Merge3Options = {},
+): Merge3Result {
+  if (mine === theirs) return { clean: true, merged: mine, regions: [] };
+  if (base === mine) return { clean: true, merged: theirs, regions: [] };
+  if (base === theirs) return { clean: true, merged: mine, regions: [] };
+
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const maxD = options.maxEditDistance ?? DEFAULT_MAX_EDIT_DISTANCE;
+  const baseLines = base.split("\n");
+  const mineLines = mine.split("\n");
+  const theirsLines = theirs.split("\n");
+  if (baseLines.length > maxLines || mineLines.length > maxLines || theirsLines.length > maxLines) {
+    return notClean(baseLines, mineLines, theirsLines);
+  }
+
+  const mineDiff = diffLines(baseLines, mineLines, maxD);
+  const theirsDiff = diffLines(baseLines, theirsLines, maxD);
+  if (!mineDiff || !theirsDiff) return notClean(baseLines, mineLines, theirsLines);
+
+  const out: string[] = [];
+  const regions: Merge3Region[] = [];
+  const skeleton: MergeSkeletonPart[] = [];
+  const emitLines = (lines: string[]): void => {
+    if (lines.length === 0) return;
+    out.push(...lines);
+    const last = skeleton[skeleton.length - 1];
+    if (last?.kind === "lines") last.lines.push(...lines);
+    else skeleton.push({ kind: "lines", lines: [...lines] });
+  };
+  let cursor = 0;
+  let mi = 0;
+  let ti = 0;
+
+  while (mi < mineDiff.length || ti < theirsDiff.length) {
+    const nextMine = mineDiff[mi];
+    const nextTheirs = theirsDiff[ti];
+    const clusterStart = Math.min(
+      nextMine ? nextMine.aStart : Number.POSITIVE_INFINITY,
+      nextTheirs ? nextTheirs.aStart : Number.POSITIVE_INFINITY,
+    );
+    // Copy the untouched base span before the next change.
+    emitLines(baseLines.slice(cursor, clusterStart));
+    cursor = clusterStart;
+
+    // Grow the cluster while hunks from either side touch it. Touching (not
+    // just overlapping) is deliberate: adjacent edits conflict, like git.
+    let clusterEnd = clusterStart;
+    const mineFirst = mi;
+    const theirsFirst = ti;
+    let grew = true;
+    while (grew) {
+      grew = false;
+      while (mi < mineDiff.length && (mineDiff[mi] as DiffHunk).aStart <= clusterEnd) {
+        clusterEnd = Math.max(clusterEnd, (mineDiff[mi] as DiffHunk).aEnd);
+        mi++;
+        grew = true;
+      }
+      while (ti < theirsDiff.length && (theirsDiff[ti] as DiffHunk).aStart <= clusterEnd) {
+        clusterEnd = Math.max(clusterEnd, (theirsDiff[ti] as DiffHunk).aEnd);
+        ti++;
+        grew = true;
+      }
+    }
+
+    const mineHunks = mineDiff.slice(mineFirst, mi);
+    const theirsHunks = theirsDiff.slice(theirsFirst, ti);
+    const mineChunk = sideSlice(mineLines, baseLines, mineHunks, clusterStart, clusterEnd);
+    const theirsChunk = sideSlice(theirsLines, baseLines, theirsHunks, clusterStart, clusterEnd);
+
+    if (theirsHunks.length === 0) {
+      emitLines(mineChunk);
+    } else if (mineHunks.length === 0) {
+      emitLines(theirsChunk);
+    } else if (sameLines(mineChunk, theirsChunk)) {
+      emitLines(mineChunk);
+    } else {
+      skeleton.push({ kind: "region", index: regions.length });
+      regions.push({
+        base: baseLines.slice(clusterStart, clusterEnd),
+        mine: mineChunk,
+        theirs: theirsChunk,
+      });
+    }
+    cursor = clusterEnd;
+  }
+  emitLines(baseLines.slice(cursor));
+
+  if (regions.length > 0) return { clean: false, merged: "", regions, skeleton };
+  return { clean: true, merged: out.join("\n"), regions: [] };
+}

package/src/names.ts

@@ -0,0 +1,44 @@
+export const RESERVED_ROOM_PREFIXES = ["workspace-"];
+
+const ROOM_NAME_PATTERN = /^[a-z0-9](?:[a-z0-9-]{0,78}[a-z0-9])?$/;
+const WORKSPACE_ID_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,126}[A-Za-z0-9])?$/;
+
+export function normalizeRoomNameInput(raw: string): string {
+  return raw.trim().replace(/^#/, "").toLowerCase();
+}
+
+export function normalizeCommunityRoomName(raw: string): string {
+  const name = normalizeRoomNameInput(raw);
+  assertCommunityRoomName(name);
+  return name;
+}
+
+export function assertCommunityRoomName(name: string): void {
+  assertRoomSlug(name, "Room name");
+  if (RESERVED_ROOM_PREFIXES.some((prefix) => name.startsWith(prefix))) {
+    throw new Error("Room names cannot use the reserved workspace- prefix");
+  }
+  if (/^room-[a-f0-9]{12}$/.test(name)) {
+    throw new Error("Room names cannot use the reserved generated room id format");
+  }
+}
+
+export function normalizeWorkspaceId(raw: string): string {
+  const id = raw.trim();
+  if (!WORKSPACE_ID_PATTERN.test(id)) {
+    throw new Error("Workspace ID must contain only letters, numbers, and hyphens");
+  }
+  return id;
+}
+
+export function workspaceRoomName(workspaceId: string): string {
+  return `workspace-${normalizeWorkspaceId(workspaceId).toLowerCase()}`;
+}
+
+function assertRoomSlug(value: string, label: string): void {
+  if (!ROOM_NAME_PATTERN.test(value)) {
+    throw new Error(
+      `${label} must be 1-80 characters, start and end with a letter or number, and contain only lowercase letters, numbers, and hyphens`,
+    );
+  }
+}