@lapis-notes/history 0.1.4 → 0.2.0

package/dist/repository/controllers/graph/repository-log-graph.js

@@ -0,0 +1,182 @@
+import * as laneState from "./repository-log-lanes.js";
+export const REPOSITORY_LOG_ROW_HEIGHT = 76;
+export const REPOSITORY_LOG_LANE_WIDTH = 12;
+export const REPOSITORY_LOG_NODE_RADIUS = 4;
+export const REPOSITORY_LOG_LEFT_PAD = 8;
+export const REPOSITORY_LOG_STROKE_WIDTH = 2.5;
+export const REPOSITORY_LOG_LANE_COLORS = [
+    "var(--ui-log-lane-1, #2563eb)",
+    "var(--ui-log-lane-2, #16a34a)",
+    "var(--ui-log-lane-3, #d97706)",
+    "var(--ui-log-lane-4, #dc2626)",
+    "var(--ui-log-lane-5, #7c3aed)",
+    "var(--ui-log-lane-6, #0891b2)",
+    "var(--ui-log-lane-7, #db2777)",
+    "var(--ui-log-lane-8, #65a30d)",
+];
+const JJ_REVERSE_HEX = "zyxwvutsrqponmlk";
+export const REPOSITORY_LOG_ID_PREFIX = 8;
+export function encodeJjChangeId(hex) {
+    if (!/^[0-9a-fA-F]+$/u.test(hex) || hex.length % 2 !== 0)
+        return "";
+    return [...hex.toLowerCase()]
+        .map((digit) => JJ_REVERSE_HEX[Number.parseInt(digit, 16)] ?? "")
+        .join("");
+}
+export function shortestRepositoryLogPrefix(values, min = REPOSITORY_LOG_ID_PREFIX) {
+    const prefixes = new Map();
+    for (const value of values) {
+        if (!value)
+            continue;
+        let length = Math.min(Math.max(min, 1), value.length);
+        while (length < value.length &&
+            values.some((other) => other !== value && other.startsWith(value.slice(0, length)))) {
+            length += 1;
+        }
+        prefixes.set(value, value.slice(0, length));
+    }
+    return prefixes;
+}
+export function repositoryLogRowLabel(row) {
+    return [
+        row.revision.message,
+        row.changeIdShort,
+        row.commitIdShort,
+        row.revision.reason === "merge" ? "Merge" : "",
+    ]
+        .filter(Boolean)
+        .join(" ");
+}
+export function tipRevisionIds(revisions) {
+    const referenced = new Set();
+    for (const revision of revisions) {
+        for (const parent of revision.parents)
+            referenced.add(parent);
+    }
+    return revisions
+        .filter((revision) => !referenced.has(revision.eventId))
+        .map((revision) => revision.eventId);
+}
+export function repositoryLogLaneX(lane) {
+    return (REPOSITORY_LOG_LEFT_PAD +
+        lane * REPOSITORY_LOG_LANE_WIDTH +
+        REPOSITORY_LOG_LANE_WIDTH / 2);
+}
+export function repositoryLogLaneStem(row, lane, rowHeight = REPOSITORY_LOG_ROW_HEIGHT) {
+    if (row.lanes[lane]?.hash == null)
+        return { y1: 0, y2: 0 };
+    const center = rowHeight / 2;
+    const isSplitCommitLane = row.splitFromLane != null && lane === row.commitLane;
+    const starts = row.commitStartsLane && row.commitLane === lane && !isSplitCommitLane;
+    const converge = row.convergingLanes.includes(lane);
+    return {
+        y1: row.isFirst || starts ? center : 0,
+        y2: isSplitCommitLane ? center : converge ? 0 : rowHeight,
+    };
+}
+export function repositoryLogSplitPath(parentX, commitX, rowHeight = REPOSITORY_LOG_ROW_HEIGHT) {
+    const centerY = rowHeight / 2;
+    return `M ${parentX} ${rowHeight} C ${parentX} ${rowHeight - 10}, ${commitX} ${centerY + 10}, ${commitX} ${centerY}`;
+}
+export function repositoryLogMergePath(commitX, parentX, rowHeight = REPOSITORY_LOG_ROW_HEIGHT) {
+    const centerY = rowHeight / 2;
+    return `M ${commitX} ${centerY} C ${commitX} ${centerY + 14}, ${parentX} ${centerY + 6}, ${parentX} ${rowHeight}`;
+}
+export function repositoryLogConvergePath(fromX, commitX, rowHeight = REPOSITORY_LOG_ROW_HEIGHT) {
+    const centerY = rowHeight / 2;
+    return `M ${fromX} 0 C ${fromX} 10, ${commitX} ${centerY - 10}, ${commitX} ${centerY}`;
+}
+export function repositoryLogContentLeft(row) {
+    const rightmost = Math.max(row.lanes.length - 1, row.mergeFromLanes.length ? Math.max(...row.mergeFromLanes) : 0, row.commitLane);
+    return (REPOSITORY_LOG_LEFT_PAD +
+        (rightmost + 1) * REPOSITORY_LOG_LANE_WIDTH +
+        REPOSITORY_LOG_LANE_WIDTH);
+}
+export function repositoryLogSvgWidth(rows) {
+    let maxLanes = 1;
+    for (const row of rows) {
+        maxLanes = Math.max(maxLanes, row.lanes.length, row.mergeFromLanes.length ? Math.max(...row.mergeFromLanes) + 1 : 0, row.commitLane + 1);
+    }
+    return (REPOSITORY_LOG_LEFT_PAD +
+        maxLanes * REPOSITORY_LOG_LANE_WIDTH +
+        REPOSITORY_LOG_LANE_WIDTH);
+}
+export function buildRepositoryLogGraph(revisions, devices = []) {
+    const lanes = [];
+    let colorIndex = 0;
+    const rows = [];
+    const tips = new Set(tipRevisionIds(revisions));
+    const aliasesByHead = new Map();
+    for (const device of devices) {
+        const aliases = aliasesByHead.get(device.revisionEventId) ?? [];
+        aliases.push(device.alias);
+        aliasesByHead.set(device.revisionEventId, aliases);
+    }
+    const changeIds = revisions.map((revision) => encodeJjChangeId(revision.changeId));
+    const changeShorts = shortestRepositoryLogPrefix(changeIds);
+    const commitShorts = shortestRepositoryLogPrefix(revisions.map((revision) => revision.eventId));
+    for (let commitIndex = 0; commitIndex < revisions.length; commitIndex += 1) {
+        const revision = revisions[commitIndex];
+        if (!revision)
+            continue;
+        let commitLane = lanes.findIndex((lane) => lane.hash === revision.eventId);
+        let commitStartsLane = false;
+        if (commitLane === -1) {
+            commitStartsLane = true;
+            commitLane = laneState.occupyRepositoryLogLane(lanes, revision.eventId, REPOSITORY_LOG_LANE_COLORS[colorIndex++ % REPOSITORY_LOG_LANE_COLORS.length] ?? REPOSITORY_LOG_LANE_COLORS[0]);
+        }
+        const currentLanes = lanes.map((lane) => ({ ...lane }));
+        const convergingLanes = currentLanes.flatMap((lane, index) => lane.hash === revision.eventId && index !== commitLane ? [index] : []);
+        const firstParent = revision.parents[0];
+        const otherParents = revision.parents.slice(1);
+        const firstParentLane = firstParent
+            ? currentLanes.findIndex((lane) => lane.hash === firstParent)
+            : -1;
+        const splitFromLane = commitStartsLane &&
+            firstParentLane !== -1 &&
+            firstParentLane !== commitLane
+            ? firstParentLane
+            : null;
+        const currentColor = lanes[commitLane]?.color ?? REPOSITORY_LOG_LANE_COLORS[0];
+        const continueLane = commitLane;
+        for (let index = lanes.length - 1; index >= 0; index -= 1) {
+            if (index !== continueLane && lanes[index]?.hash === revision.eventId) {
+                laneState.vacateRepositoryLogLane(lanes, index);
+            }
+        }
+        if (firstParent) {
+            lanes[continueLane] = { hash: firstParent, color: currentColor };
+        }
+        else {
+            laneState.vacateRepositoryLogLane(lanes, continueLane);
+        }
+        laneState.trimRepositoryLogLanes(lanes);
+        const mergeFromLanes = [];
+        for (const parent of otherParents) {
+            const existing = lanes.findIndex((lane) => lane.hash === parent);
+            if (existing !== -1) {
+                mergeFromLanes.push(existing);
+                continue;
+            }
+            const parentLane = laneState.occupyRepositoryLogLane(lanes, parent, REPOSITORY_LOG_LANE_COLORS[colorIndex++ % REPOSITORY_LOG_LANE_COLORS.length] ?? REPOSITORY_LOG_LANE_COLORS[0]);
+            mergeFromLanes.push(parentLane);
+        }
+        rows.push({
+            revision,
+            commitLane,
+            lanes: currentLanes,
+            mergeFromLanes,
+            convergingLanes,
+            splitFromLane,
+            commitStartsLane,
+            isFirst: commitIndex === 0,
+            isTip: tips.has(revision.eventId),
+            deviceAliases: aliasesByHead.get(revision.eventId) ?? [],
+            changeIdShort: changeShorts.get(changeIds[commitIndex] ?? "") ?? "",
+            changeIdEncoded: changeIds[commitIndex] ?? "",
+            commitIdShort: commitShorts.get(revision.eventId) ??
+                revision.eventId.slice(0, REPOSITORY_LOG_ID_PREFIX),
+        });
+    }
+    return rows;
+}

package/dist/repository/controllers/graph/repository-log-lanes.d.ts

@@ -0,0 +1,7 @@
+export type RepositoryLogGraphLane = {
+    hash: string | null;
+    color: string;
+};
+export declare function occupyRepositoryLogLane(lanes: RepositoryLogGraphLane[], hash: string, color: string): number;
+export declare function vacateRepositoryLogLane(lanes: RepositoryLogGraphLane[], index: number): void;
+export declare function trimRepositoryLogLanes(lanes: RepositoryLogGraphLane[]): void;

package/dist/repository/controllers/graph/repository-log-lanes.js

@@ -0,0 +1,19 @@
+export function occupyRepositoryLogLane(lanes, hash, color) {
+    const vacant = lanes.findIndex((lane) => lane.hash == null);
+    const index = vacant === -1 ? lanes.length : vacant;
+    const lane = { hash, color };
+    if (vacant === -1)
+        lanes.push(lane);
+    else
+        lanes[index] = lane;
+    return index;
+}
+export function vacateRepositoryLogLane(lanes, index) {
+    const lane = lanes[index];
+    if (lane)
+        lanes[index] = { ...lane, hash: null };
+}
+export function trimRepositoryLogLanes(lanes) {
+    while (lanes.length > 0 && lanes.at(-1)?.hash == null)
+        lanes.pop();
+}

package/dist/repository/controllers/graph/revision-id.d.ts

@@ -0,0 +1,3 @@
+/** Keep a recognisable prefix and the final two characters without lengthening short IDs. */
+export declare function abbreviateRevisionId(value: string, leadingChars?: number): string;
+export declare function revisionLeadingChars(value: number, fallback: number): number;

package/dist/repository/controllers/graph/revision-id.js

@@ -0,0 +1,10 @@
+/** Keep a recognisable prefix and the final two characters without lengthening short IDs. */
+export function abbreviateRevisionId(value, leadingChars = 5) {
+    const leading = revisionLeadingChars(leadingChars, 5);
+    return value.length <= leading + 4
+        ? value
+        : `${value.slice(0, leading)}..${value.slice(-2)}`;
+}
+export function revisionLeadingChars(value, fallback) {
+    return Number.isFinite(value) ? Math.max(1, Math.floor(value)) : fallback;
+}

package/dist/repository/controllers/history-canvas.d.ts

@@ -0,0 +1,2 @@
+/** Adaptation of jj-store's log/diff/evolution geometry. */
+export declare function createHistoryCanvas(): import("@lapismd/design-core/shadcn/column-canvas").ColumnCanvasController;

package/dist/repository/controllers/history-canvas.js

@@ -0,0 +1,45 @@
+import { createColumnCanvasController } from "@lapismd/design-core/shadcn/column-canvas";
+/** Adaptation of jj-store's log/diff/evolution geometry. */
+export function createHistoryCanvas() {
+    return createColumnCanvasController({
+        columns: {
+            revisions: {
+                defaultWidth: 480,
+                minWidth: 360,
+                maxWidth: 720,
+                collapsible: true,
+                resizable: true,
+            },
+            diff: {
+                defaultWidth: 560,
+                minWidth: 360,
+                maxWidth: 980,
+                pathLevel: 1,
+                closeable: true,
+                closed: true,
+                openOnSelect: false,
+                resizable: true,
+            },
+            evolution: {
+                defaultWidth: 480,
+                minWidth: 360,
+                maxWidth: 720,
+                pathLevel: 1,
+                closeable: true,
+                closed: true,
+                openOnSelect: false,
+                resizable: true,
+            },
+            "evolution-diff": {
+                defaultWidth: 560,
+                minWidth: 360,
+                maxWidth: 980,
+                pathLevel: 1,
+                closeable: true,
+                closed: true,
+                openOnSelect: false,
+                resizable: true,
+            },
+        },
+    });
+}

package/dist/repository/controllers/history-controller.d.ts

@@ -0,0 +1,31 @@
+import type { LocalGraphCommit } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+import { type HistoryState } from "./history-state.js";
+import { pause } from "./history-selection.js";
+export declare class HistoryController {
+    #private;
+    readonly reader: HistoryReader;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    readonly wait: typeof pause;
+    constructor(reader: HistoryReader, feedback: HistoryController["feedback"], wait?: typeof pause);
+    get state(): HistoryState;
+    get pinned(): boolean;
+    subscribe(listener: (state: HistoryState) => void): () => void;
+    refresh(preferred?: string): Promise<void>;
+    selectOperation(operation: string): Promise<void>;
+    checkpointChanged(operation: string): Promise<void>;
+    selectWorkspace(workspace: string | null): Promise<void>;
+    moreCommits(): Promise<void>;
+    clearRevision(): Promise<void>;
+    selectRevision(revision: LocalGraphCommit): Promise<void>;
+    openRevision(id: string): Promise<void>;
+    loadParents(): Promise<void>;
+    loadConflicts(): Promise<void>;
+    selectBase(base: string): Promise<void>;
+    morePaths(): Promise<void>;
+    selectPath(path: string): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/repository/controllers/history-controller.js

@@ -0,0 +1,238 @@
+import { RevisionComparison } from "./revision-comparison.js";
+import { HistoryGraph } from "./history-graph.js";
+import { parentCandidates } from "./parent-candidates.js";
+import { initialHistoryState, resetHistoryComparison, } from "./history-state.js";
+import { check, pause, prepared } from "./history-selection.js";
+import { HistoryLifetime } from "./history-lifetime.js";
+export class HistoryController {
+    #state = initialHistoryState();
+    #listeners = new Set();
+    #lifetime;
+    #graph;
+    #files;
+    reader;
+    feedback;
+    wait;
+    #handle;
+    #selection = 0;
+    #comparison = 0;
+    #request = 0;
+    #abort = new AbortController();
+    #closed = false;
+    #pinned = false;
+    #closing;
+    constructor(reader, feedback, wait = pause) {
+        this.reader = reader;
+        this.feedback = feedback;
+        this.wait = wait;
+        this.#lifetime = new HistoryLifetime(reader);
+        this.#files = new RevisionComparison(reader, () => ({
+            handle: this.#handle,
+            state: this.#state,
+            closed: this.#closed,
+        }), (patch) => this.#set(patch));
+        this.#graph = new HistoryGraph(reader, () => ({
+            handle: this.#handle,
+            state: this.#state,
+            closed: this.#closed,
+        }), (patch) => this.#set(patch));
+    }
+    get state() {
+        return this.#state;
+    }
+    get pinned() {
+        return this.#pinned || !!this.#state.revision;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => this.#listeners.delete(listener);
+    }
+    #set(patch) {
+        if (this.#closed)
+            return;
+        this.#state = { ...this.#state, ...patch };
+        for (const listener of this.#listeners)
+            listener(this.#state);
+    }
+    #run(action) {
+        if (this.#closed)
+            return Promise.resolve();
+        return this.#lifetime.run(action);
+    }
+    async #action(action) {
+        const request = ++this.#request;
+        this.#set({ busy: true });
+        try {
+            await action();
+            if (!this.#closed && request === this.#request)
+                this.feedback.recovered();
+        }
+        catch (error) {
+            if (!this.#closed && request === this.#request) {
+                this.#set({ phase: this.#state.snapshot ? "ready" : "unavailable" });
+                this.feedback.report(error);
+            }
+        }
+        finally {
+            if (request === this.#request)
+                this.#set({ busy: false });
+        }
+    }
+    refresh(preferred) {
+        if (preferred)
+            this.#pinned = true;
+        return this.#run(() => this.#action(async () => {
+            const selection = this.#selection;
+            const heads = await this.reader.heads();
+            if (selection !== this.#selection || this.#closed)
+                return;
+            this.#set({
+                heads: heads.heads,
+                headsReady: true,
+                phase: this.#state.snapshot ? "ready" : "idle",
+            });
+            if (preferred && !this.#state.operation)
+                await this.#selectOperation(preferred);
+            else if (this.#state.operation && !this.#state.snapshot)
+                await this.#selectOperation(this.#state.operation);
+            else if (this.#state.operation && !this.#state.commitsReady)
+                await this.#graph.load(false);
+            else if (!this.#state.operation && heads.heads.length === 1)
+                await this.#selectOperation(heads.heads[0]);
+        }));
+    }
+    selectOperation(operation) {
+        this.#pinned = true;
+        return this.#run(() => this.#action(() => this.#selectOperation(operation)));
+    }
+    checkpointChanged(operation) {
+        if (this.#closed ||
+            this.#pinned ||
+            this.#state.revision ||
+            this.#state.operation === operation)
+            return Promise.resolve();
+        return this.#run(() => this.#action(() => this.#selectOperation(operation)));
+    }
+    async #selectOperation(operation) {
+        const selection = ++this.#selection;
+        this.#comparison++;
+        this.#files.reset();
+        this.#abort.abort();
+        const abort = (this.#abort = new AbortController());
+        const prior = this.#handle;
+        this.#handle = undefined;
+        this.#set({
+            ...initialHistoryState(),
+            heads: this.#state.heads,
+            headsReady: this.#state.headsReady,
+            operation,
+            phase: "loading",
+            busy: true,
+        });
+        if (prior)
+            await this.#lifetime.closeHandle(prior);
+        const handle = await this.reader.open(operation);
+        this.#lifetime.handles.add(handle);
+        if (this.#closed)
+            return;
+        if (selection !== this.#selection) {
+            await this.#lifetime.closeHandle(handle);
+            return;
+        }
+        this.#handle = handle;
+        const snapshot = await prepared(this.reader, handle, abort.signal, this.wait);
+        check(snapshot.operation === operation);
+        if (selection !== this.#selection || this.#closed)
+            return;
+        this.#set({ snapshot, phase: "ready" });
+        await this.#graph.load(false);
+    }
+    selectWorkspace(workspace) {
+        this.#comparison++;
+        this.#files.reset();
+        return this.#run(() => this.#action(async () => {
+            this.#set({ ...resetHistoryComparison(), workspace });
+            await this.#graph.load(false);
+        }));
+    }
+    moreCommits() {
+        return this.#run(() => this.#action(() => this.#graph.load(true)));
+    }
+    clearRevision() {
+        this.#comparison++;
+        this.#files.reset();
+        this.#request++;
+        return this.#run(async () => this.#set({ ...resetHistoryComparison(), busy: false }));
+    }
+    selectRevision(revision) {
+        this.#comparison++;
+        this.#files.reset();
+        return this.#run(() => this.#action(async () => {
+            check(this.#state.commits.some((item) => item.id === revision.id));
+            this.#set({ ...resetHistoryComparison(), revision });
+            if (revision.parents.length === 1)
+                await this.#paths(revision.parents[0], false);
+        }));
+    }
+    openRevision(id) {
+        const comparison = ++this.#comparison;
+        this.#files.reset();
+        return this.#run(() => this.#action(async () => {
+            const revision = await this.#graph.exact(id, () => comparison === this.#comparison);
+            if (!revision)
+                return;
+            this.#set({ ...resetHistoryComparison(), revision });
+            if (revision.parents.length === 1)
+                await this.#paths(revision.parents[0], false);
+        }));
+    }
+    loadParents() {
+        return this.#run(() => this.#action(async () => {
+            const handle = this.#handle, revision = this.#state.revision, generation = this.#comparison;
+            if (!handle || !revision)
+                return;
+            const parentCommits = await parentCandidates(this.reader, handle, revision.parents, [...this.#state.commits, ...this.#state.parentCommits], () => !this.#closed &&
+                handle === this.#handle &&
+                generation === this.#comparison);
+            if (parentCommits)
+                this.#set({ parentCommits });
+        }));
+    }
+    loadConflicts() {
+        const comparison = this.#comparison;
+        return this.#run(() => this.#action(() => this.#graph.conflicts(() => comparison === this.#comparison)));
+    }
+    selectBase(base) {
+        return this.#run(() => this.#action(async () => {
+            check(this.#state.revision?.parents.includes(base));
+            await this.#paths(base, false);
+        }));
+    }
+    morePaths() {
+        return this.#run(() => this.#action(async () => {
+            if (this.#state.base && this.#state.nextPath)
+                await this.#paths(this.#state.base, true);
+        }));
+    }
+    async #paths(base, append) {
+        if (!append)
+            this.#comparison++;
+        await this.#files.paths(base, append);
+    }
+    selectPath(path) {
+        return this.#run(() => this.#action(() => this.#files.selectPath(path)));
+    }
+    close() {
+        this.#closed = true;
+        this.#selection++;
+        this.#abort.abort();
+        this.#listeners.clear();
+        return (this.#closing ??= (async () => {
+            await this.#lifetime.drain();
+        })().catch((error) => {
+            this.#closing = undefined;
+            throw error;
+        }));
+    }
+}

package/dist/repository/controllers/history-files.d.ts

@@ -0,0 +1,7 @@
+import type { LocalFileDiffChange } from "@lapismd/jj-history";
+import type { FileListingFile } from "@lapismd/design-core/diff";
+export declare function changeStats(change?: LocalFileDiffChange): {
+    additions: number;
+    deletions: number;
+} | undefined;
+export declare function listingFiles(paths: LocalFileDiffChange[], selected?: LocalFileDiffChange): FileListingFile[];

package/dist/repository/controllers/history-files.js

@@ -0,0 +1,18 @@
+export function changeStats(change) {
+    if (!change || change.content.status !== "text")
+        return undefined;
+    const lines = (value) => value ? value.split("\n").length - (value.endsWith("\n") ? 1 : 0) : 0;
+    return change.content.hunks.reduce((stats, hunk) => {
+        if (hunk.kind === "different") {
+            stats.additions += lines(hunk.after);
+            stats.deletions += lines(hunk.before);
+        }
+        return stats;
+    }, { additions: 0, deletions: 0 });
+}
+export function listingFiles(paths, selected) {
+    return paths.map((change) => ({
+        path: change.path,
+        ...changeStats(selected?.path === change.path ? selected : change),
+    }));
+}

package/dist/repository/controllers/history-graph.d.ts

@@ -0,0 +1,20 @@
+import type { Handle } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+import type { HistoryState } from "./history-state.js";
+type Scope = {
+    handle?: Handle;
+    state: HistoryState;
+    closed: boolean;
+};
+/** Bounded commit paging; the controller retains its reader/lifetime authority. */
+export declare class HistoryGraph {
+    #private;
+    readonly reader: HistoryReader;
+    readonly scope: () => Scope;
+    readonly publish: (state: Partial<HistoryState>) => void;
+    constructor(reader: HistoryReader, scope: () => Scope, publish: HistoryGraph["publish"]);
+    exact(id: string, current: () => boolean): Promise<import("@lapismd/jj-history").LocalGraphCommit | undefined>;
+    conflicts(current: () => boolean): Promise<void>;
+    load(append: boolean): Promise<void>;
+}
+export {};

package/dist/repository/controllers/history-graph.js

@@ -0,0 +1,89 @@
+import { check } from "./history-selection.js";
+/** Bounded commit paging; the controller retains its reader/lifetime authority. */
+export class HistoryGraph {
+    #epoch = 0;
+    reader;
+    scope;
+    publish;
+    constructor(reader, scope, publish) {
+        this.reader = reader;
+        this.scope = scope;
+        this.publish = publish;
+    }
+    async exact(id, current) {
+        const epoch = ++this.#epoch;
+        const { handle } = this.scope();
+        if (!handle || this.scope().closed)
+            return;
+        const response = await this.reader.read(handle, {
+            kind: "commit",
+            query: { commit: id },
+        });
+        if (epoch !== this.#epoch ||
+            this.scope().handle !== handle ||
+            this.scope().closed ||
+            !current())
+            return;
+        check(response.kind === "commit" &&
+            response.data.commit.id === id &&
+            response.data.object.key.id === id &&
+            response.data.object.data.kind === "commit");
+        this.publish({
+            commits: [response.data.commit],
+            commitsReady: true,
+            next: null,
+        });
+        return response.data.commit;
+    }
+    async conflicts(current) {
+        const { handle, state } = this.scope();
+        const revision = state.revision;
+        if (!handle || !revision?.conflicted || this.scope().closed)
+            return;
+        const response = await this.reader.read(handle, {
+            kind: "conflicts",
+            query: { commit: revision.id, path: "" },
+        });
+        if (!current() || this.scope().handle !== handle || this.scope().closed)
+            return;
+        check(response.kind === "conflicts" &&
+            response.data.commit === revision.id &&
+            response.data.change === revision.change_id);
+        this.publish({ conflicts: response.data.conflicts, conflictsReady: true });
+    }
+    async load(append) {
+        const epoch = append ? this.#epoch : ++this.#epoch;
+        const { handle, state, closed } = this.scope();
+        const operation = state.operation;
+        if (closed || !handle || !operation || (append && !state.next))
+            return;
+        const response = await this.reader.read(handle, {
+            kind: "graph",
+            query: [
+                {
+                    graph: "log",
+                    revset: "all()",
+                    workspace: state.workspace,
+                    user_email: "",
+                    at_time_millis: Date.now(),
+                },
+                { limit: 50, after: append ? state.next : null },
+            ],
+        });
+        const current = this.scope();
+        if (epoch !== this.#epoch || current.handle !== handle || current.closed)
+            return;
+        check(response.kind === "graph" &&
+            response.data.operation === operation &&
+            response.data.data.graph === "log");
+        const commits = response.data.data.nodes.map((node) => node.commit);
+        const retained = append ? current.state.commits : [];
+        check(!commits.some((commit) => retained.some((item) => item.id === commit.id)));
+        const combined = [...retained, ...commits].slice(0, 200);
+        this.publish({
+            commits: combined,
+            commitsReady: true,
+            next: combined.length < 200 ? response.data.next : null,
+        });
+    }
+}