@openmarket/rooms-client 0.1.0

package/dist/merge3.js

@@ -0,0 +1,280 @@
+/**
+ * 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.
+ */
+/** 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, resolved) {
+    const lines = [];
+    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");
+}
+const DEFAULT_MAX_LINES = 30_000;
+const DEFAULT_MAX_EDIT_DISTANCE = 2_048;
+/**
+ * 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, b, maxD) {
+    // 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 = [];
+    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;
+            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;
+    const edits = [];
+    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;
+        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 = [];
+    let current = 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, baseLines, hunks, aStart, aEnd) {
+    if (hunks.length === 0)
+        return baseLines.slice(aStart, aEnd);
+    const first = hunks[0];
+    const last = hunks[hunks.length - 1];
+    const sStart = first.bStart - (first.aStart - aStart);
+    const sEnd = last.bEnd + (aEnd - last.aEnd);
+    return sideLines.slice(sStart, sEnd);
+}
+function sameLines(a, b) {
+    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, mine, theirs) {
+    return {
+        clean: false,
+        merged: "",
+        regions: [{ base, mine, theirs }],
+        skeleton: [{ kind: "region", index: 0 }],
+    };
+}
+export function merge3(base, mine, theirs, options = {}) {
+    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 = [];
+    const regions = [];
+    const skeleton = [];
+    const emitLines = (lines) => {
+        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].aStart <= clusterEnd) {
+                clusterEnd = Math.max(clusterEnd, mineDiff[mi].aEnd);
+                mi++;
+                grew = true;
+            }
+            while (ti < theirsDiff.length && theirsDiff[ti].aStart <= clusterEnd) {
+                clusterEnd = Math.max(clusterEnd, theirsDiff[ti].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/dist/names.d.ts

@@ -0,0 +1,6 @@
+export declare const RESERVED_ROOM_PREFIXES: string[];
+export declare function normalizeRoomNameInput(raw: string): string;
+export declare function normalizeCommunityRoomName(raw: string): string;
+export declare function assertCommunityRoomName(name: string): void;
+export declare function normalizeWorkspaceId(raw: string): string;
+export declare function workspaceRoomName(workspaceId: string): string;

package/dist/names.js

@@ -0,0 +1,35 @@
+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) {
+    return raw.trim().replace(/^#/, "").toLowerCase();
+}
+export function normalizeCommunityRoomName(raw) {
+    const name = normalizeRoomNameInput(raw);
+    assertCommunityRoomName(name);
+    return name;
+}
+export function assertCommunityRoomName(name) {
+    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) {
+    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) {
+    return `workspace-${normalizeWorkspaceId(workspaceId).toLowerCase()}`;
+}
+function assertRoomSlug(value, label) {
+    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`);
+    }
+}

package/dist/shared/emoji-data.d.ts

@@ -0,0 +1,22 @@
+export type EmojiCategory = "smileys" | "people" | "nature" | "food" | "travel" | "activities" | "objects" | "symbols" | "flags";
+export interface EmojiEntry {
+    /** The native glyph, e.g. "🔥" */
+    glyph: string;
+    /** Canonical shortcode without colons, e.g. "fire" */
+    shortcode: string;
+    /** Search keywords (lowercase), including the shortcode */
+    keywords: string[];
+    /** One of the 9 category keys in EMOJI_CATEGORIES */
+    category: EmojiCategory;
+}
+/** Picker display order for categories; matches the dataset's sort order. */
+export declare const EMOJI_CATEGORIES: readonly EmojiCategory[];
+export declare const EMOJI: readonly EmojiEntry[];
+/** The hover-toolbar reaction trio; every glyph exists in EMOJI. */
+export declare const QUICK_REACTIONS: readonly string[];
+/**
+ * Prefix + substring search over shortcodes and keywords. Shortcode-prefix
+ * matches rank first (shortest shortcode wins ties), then keyword-prefix,
+ * then shortcode/keyword substring matches.
+ */
+export declare function searchEmoji(query: string, limit?: number): EmojiEntry[];