@lapis-notes/history 0.1.4 → 0.2.0

package/dist/repository/controllers/backup.d.ts

@@ -0,0 +1,39 @@
+export type BackupCheckpoint = {
+    operation: string;
+    commit: string;
+    change_id: string;
+    description: string;
+    timestamp_millis: number;
+};
+export type BackupStatus = {
+    phase: "saving" | "ready" | "failed" | "closed";
+    checkpoint: BackupCheckpoint | null;
+    error: string | null;
+};
+export interface BackupService {
+    /** Optional native selection persists the setting; start/stop only observe. */
+    setEnabled?(enabled: boolean): Promise<void>;
+    start(changed: (status: BackupStatus) => void): Promise<BackupStatus>;
+    capture(): Promise<BackupStatus>;
+    stop(): Promise<void>;
+}
+/** Plugin owns this independently of the optional status-bar contribution. */
+export declare class BackupController {
+    #private;
+    readonly service: BackupService;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(service: BackupService, feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    });
+    subscribe(listener: (status: BackupStatus) => void): () => boolean;
+    start(): Promise<void>;
+    /** Reattach after a cancelled leave without consuming the retained worker. */
+    resume(): Promise<void>;
+    refresh(): Promise<void>;
+    pause(): Promise<void>;
+    close(): Promise<void>;
+}

package/dist/repository/controllers/backup.js

@@ -0,0 +1,129 @@
+/** Plugin owns this independently of the optional status-bar contribution. */
+export class BackupController {
+    #state = { phase: "saving", checkpoint: null, error: null };
+    #listeners = new Set();
+    #closed = false;
+    #running = false;
+    #attempted = false;
+    #epoch = 0;
+    #starting;
+    service;
+    feedback;
+    constructor(service, feedback) {
+        this.service = service;
+        this.feedback = feedback;
+    }
+    subscribe(listener) {
+        this.#listeners.add(listener);
+        listener(this.#state);
+        return () => this.#listeners.delete(listener);
+    }
+    #set(status) {
+        if (this.#closed)
+            return;
+        this.#state = status;
+        if (status.phase === "failed")
+            this.feedback.report(new Error(status.error ?? "Vault backup failed"));
+        else if (status.phase === "ready")
+            this.feedback.recovered();
+        for (const listener of this.#listeners)
+            listener(status);
+    }
+    async start() {
+        await this.#start(true);
+    }
+    /** Reattach after a cancelled leave without consuming the retained worker. */
+    async resume() {
+        await this.#start(false);
+    }
+    async #start(drain) {
+        if (this.#running || this.#closed)
+            return;
+        // A lost response can leave a native owner. Drain it before admitting a
+        // replacement rather than treating an unknown stop as successful.
+        if (drain && this.#attempted)
+            await this.pause();
+        if (this.#closed)
+            return;
+        this.#running = true;
+        this.#attempted = true;
+        const epoch = ++this.#epoch;
+        try {
+            let events = 0;
+            const opening = this.service.start((state) => {
+                if (epoch !== this.#epoch)
+                    return;
+                events++;
+                this.#set(state);
+            });
+            this.#starting = opening;
+            const initial = await opening;
+            if (this.#starting === opening)
+                this.#starting = undefined;
+            if (events === 0 && epoch === this.#epoch)
+                this.#set(initial);
+        }
+        catch (error) {
+            this.#starting = undefined;
+            if (epoch !== this.#epoch)
+                return;
+            this.#running = false;
+            this.#set({
+                ...this.#state,
+                phase: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async refresh() {
+        if (this.#closed)
+            return;
+        this.#set({ ...this.#state, phase: "saving", error: null });
+        if (!this.#running) {
+            await this.start();
+            return;
+        }
+        const epoch = this.#epoch;
+        try {
+            const result = await this.service.capture();
+            if (epoch === this.#epoch)
+                this.#set(result);
+        }
+        catch (error) {
+            if (epoch !== this.#epoch)
+                return;
+            this.#set({
+                ...this.#state,
+                phase: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async pause() {
+        this.#epoch++;
+        this.#running = false;
+        try {
+            // A startup already admitted by the host must finish before its stop;
+            // otherwise a late start could outlive the close barrier.
+            if (this.#starting)
+                await Promise.allSettled([this.#starting]);
+            if (this.#attempted)
+                await this.service.stop();
+        }
+        catch (error) {
+            this.#set({
+                ...this.#state,
+                phase: "failed",
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw error;
+        }
+        this.#attempted = false;
+        this.#set({ ...this.#state, phase: "closed", error: null });
+    }
+    async close() {
+        await this.pause();
+        this.#closed = true;
+        this.#listeners.clear();
+    }
+}

package/dist/repository/controllers/blame-chunks.d.ts

@@ -0,0 +1,13 @@
+import type { BlameRange } from "./blame-model.js";
+export declare const BLAME_UNAVAILABLE = "Blame is not available on this server yet. Source remains available.";
+export declare function sourceLines(contents: string): string[];
+/** Matches the recorded-file admission of the shared JJ annotation adapter. */
+export declare function blameSizeReason(contents: string): string | undefined;
+export interface BlameChunk {
+    start: number;
+    end: number;
+    commitId?: string;
+    continued: boolean;
+}
+/** Split long groups into bounded render chunks, retaining continuation attribution. */
+export declare function blameChunks(lineCount: number, ranges: readonly BlameRange[]): BlameChunk[];

package/dist/repository/controllers/blame-chunks.js

@@ -0,0 +1,51 @@
+export const BLAME_UNAVAILABLE = "Blame is not available on this server yet. Source remains available.";
+export function sourceLines(contents) {
+    if (!contents)
+        return [];
+    const lines = contents.split("\n");
+    if (lines.at(-1) === "")
+        lines.pop();
+    return lines;
+}
+/** Matches the recorded-file admission of the shared JJ annotation adapter. */
+export function blameSizeReason(contents) {
+    return new TextEncoder().encode(contents).byteLength > 256 * 1024 ||
+        sourceLines(contents).length > 32_768
+        ? "Blame is unavailable for files larger than 256 KiB or 32,768 lines."
+        : undefined;
+}
+/** Split long groups into bounded render chunks, retaining continuation attribution. */
+export function blameChunks(lineCount, ranges) {
+    const groups = [];
+    let cursor = 1;
+    for (const native of ranges) {
+        const range = {
+            start: native.start,
+            end: native.end,
+            commitId: native.commit_id,
+        };
+        if (range.start > cursor)
+            groups.push({ start: cursor, end: range.start });
+        const previous = groups.at(-1);
+        if (previous &&
+            previous.commitId === range.commitId &&
+            previous.end === range.start)
+            previous.end = range.end;
+        else
+            groups.push({ ...range });
+        cursor = range.end;
+    }
+    if (cursor <= lineCount)
+        groups.push({ start: cursor, end: lineCount + 1 });
+    return groups.flatMap((group) => {
+        const chunks = [];
+        for (let start = group.start; start < group.end; start += 32)
+            chunks.push({
+                ...group,
+                start,
+                end: Math.min(start + 32, group.end),
+                continued: start !== group.start,
+            });
+        return chunks;
+    });
+}

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

@@ -0,0 +1,17 @@
+import type { HistoryReader } from "./history-reader.js";
+import { type BlameSelection, type BlameState } from "./blame-model.js";
+/** An explicit main-panel file selection owns its pin, worker progress and drain. */
+export declare class BlameController {
+    #private;
+    readonly reader: HistoryReader;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(reader: HistoryReader, feedback: BlameController["feedback"]);
+    get state(): BlameState;
+    subscribe(listener: (state: BlameState) => void): () => void;
+    open(selection: BlameSelection): Promise<void>;
+    refresh(): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,148 @@
+import { HistoryLifetime } from "./history-lifetime.js";
+import { check, prepared } from "./history-selection.js";
+import { sourceLines, blameSizeReason } from "./blame-chunks.js";
+import { validateBlame, } from "./blame-model.js";
+/** An explicit main-panel file selection owns its pin, worker progress and drain. */
+export class BlameController {
+    #state = { status: "loading", busy: false };
+    #listeners = new Set();
+    #generation = 0;
+    #abort = new AbortController();
+    #handle;
+    #closed = false;
+    #closing;
+    #lifetime;
+    reader;
+    feedback;
+    constructor(reader, feedback) {
+        this.reader = reader;
+        this.feedback = feedback;
+        this.#lifetime = new HistoryLifetime(reader);
+    }
+    get state() {
+        return this.#state;
+    }
+    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);
+    }
+    #valid(generation) {
+        return !this.#closed && generation === this.#generation;
+    }
+    open(selection) {
+        if (this.#closed)
+            return Promise.resolve();
+        const generation = ++this.#generation;
+        this.#abort.abort();
+        const abort = (this.#abort = new AbortController());
+        const prior = this.#handle;
+        this.#handle = undefined;
+        this.#set({
+            selection,
+            contents: undefined,
+            progress: undefined,
+            busy: true,
+            status: "loading",
+        });
+        return this.#lifetime.run(async () => {
+            try {
+                if (prior)
+                    await this.#lifetime.closeHandle(prior);
+                if (!this.#valid(generation))
+                    return;
+                if (!this.reader.blame)
+                    throw new Error("Blame is unavailable for this repository reader.");
+                const handle = await this.reader.open(selection.operation);
+                this.#lifetime.handles.add(handle);
+                if (!this.#valid(generation)) {
+                    await this.#lifetime.closeHandle(handle);
+                    return;
+                }
+                this.#handle = handle;
+                const snapshot = await prepared(this.reader, handle, abort.signal);
+                check(snapshot.operation === selection.operation);
+                const cursors = new Set();
+                let continuation = null;
+                let file;
+                for (let page = 0; page < 128 && this.#valid(generation); page++) {
+                    const reply = await this.reader.blame(handle, {
+                        commit: selection.commit,
+                        path: selection.path,
+                        continuation,
+                    });
+                    if (!this.#valid(generation))
+                        return;
+                    const progress = validateBlame(reply, selection);
+                    check(progress.repository === snapshot.repository);
+                    if (!file) {
+                        file = progress.file_id;
+                        const response = await this.reader.read(handle, {
+                            kind: "file_at",
+                            query: { commit: selection.commit, path: selection.path, file },
+                        });
+                        if (!this.#valid(generation))
+                            return;
+                        check(response.kind === "file_at");
+                        const contents = response.data.text;
+                        if (response.data.binary ||
+                            response.data.too_large ||
+                            typeof contents !== "string")
+                            throw new Error("Blame requires a bounded recorded text file.");
+                        const reason = blameSizeReason(contents);
+                        if (reason)
+                            throw new Error(reason);
+                        check(sourceLines(contents).length === progress.line_count);
+                        this.#set({ contents });
+                    }
+                    check(progress.file_id === file);
+                    this.#set({ progress });
+                    if (progress.complete) {
+                        this.#set({ status: "ready" });
+                        this.feedback.recovered();
+                        return;
+                    }
+                    check(progress.continuation && !cursors.has(progress.continuation));
+                    continuation = progress.continuation;
+                    cursors.add(continuation);
+                }
+                if (this.#valid(generation))
+                    throw new Error("Blame exceeded its bounded progress window. Refresh to try again.");
+            }
+            catch (error) {
+                if (this.#valid(generation)) {
+                    this.#set({ status: "failed" });
+                    this.feedback.report(error);
+                }
+            }
+            finally {
+                if (this.#valid(generation))
+                    this.#set({ busy: false });
+            }
+        });
+    }
+    refresh() {
+        return this.#state.selection
+            ? this.open(this.#state.selection)
+            : Promise.resolve();
+    }
+    close() {
+        this.#closed = true;
+        this.#generation++;
+        this.#abort.abort();
+        this.#listeners.clear();
+        return (this.#closing ??= this.#lifetime.drain().catch((error) => {
+            this.#closing = undefined;
+            throw error;
+        }));
+    }
+}

package/dist/repository/controllers/blame-model.d.ts

@@ -0,0 +1,25 @@
+import type { BlamePage } from "@lapismd/jj-history";
+export type { BlameCommit } from "@lapismd/jj-history";
+export type BlameRange = {
+    start: number;
+    end: number;
+    commit_id: string;
+};
+export type BlameProgress = Omit<BlamePage, "line_count" | "ranges"> & {
+    line_count: number;
+    ranges: BlameRange[];
+};
+export type BlameSelection = {
+    operation: string;
+    commit: string;
+    path: string;
+};
+export type BlameState = {
+    selection?: BlameSelection;
+    contents?: string;
+    progress?: BlameProgress;
+    status: "loading" | "ready" | "failed";
+    busy: boolean;
+};
+/** Keep the copied presentation boundary exact even for injected host readers. */
+export declare function validateBlame(page: BlamePage, selection: BlameSelection): BlameProgress;

package/dist/repository/controllers/blame-model.js

@@ -0,0 +1,31 @@
+import { check } from "./history-selection.js";
+/** Keep the copied presentation boundary exact even for injected host readers. */
+export function validateBlame(page, selection) {
+    const line = (value) => {
+        check(typeof value === "bigint" || Number.isSafeInteger(value));
+        check(BigInt(value) >= 0n && BigInt(value) <= 32769n);
+        return Number(value);
+    };
+    const lineCount = line(page.line_count);
+    check(page.operation === selection.operation &&
+        page.commit === selection.commit &&
+        page.path === selection.path &&
+        lineCount <= 32_768 &&
+        page.complete === (page.continuation === null));
+    let end = 1;
+    const ranges = page.ranges.map((range) => ({
+        ...range,
+        start: line(range.start),
+        end: line(range.end),
+    }));
+    for (const range of ranges) {
+        check(Number.isSafeInteger(range.start) &&
+            Number.isSafeInteger(range.end) &&
+            range.start >= end &&
+            range.end > range.start &&
+            range.end <= lineCount + 1 &&
+            page.commits[range.commit_id]?.id === range.commit_id);
+        end = range.end;
+    }
+    return { ...page, line_count: lineCount, ranges };
+}

package/dist/repository/controllers/blame-preferences.d.ts

@@ -0,0 +1,3 @@
+/** A local display preference shared by blame files, independent of the vault. */
+export declare function readBlameWrap(): boolean;
+export declare function saveBlameWrap(wrap: boolean): void;

package/dist/repository/controllers/blame-preferences.js

@@ -0,0 +1,18 @@
+const key = "lapis.desktop.repository.blame.wrap";
+/** A local display preference shared by blame files, independent of the vault. */
+export function readBlameWrap() {
+    try {
+        return localStorage.getItem(key) !== "false";
+    }
+    catch {
+        return true;
+    }
+}
+export function saveBlameWrap(wrap) {
+    try {
+        localStorage.setItem(key, String(wrap));
+    }
+    catch {
+        // Optional browser persistence must not prevent reading recorded source.
+    }
+}

package/dist/repository/controllers/commit-cards.d.ts

@@ -0,0 +1,4 @@
+import type { LocalGraphCommit } from "@lapismd/jj-history";
+import type { TagListItem } from "@lapismd/design-core/shadcn/tag-list";
+export declare function commitCardTags(commit?: LocalGraphCommit): TagListItem[];
+export declare function commitCardSearch(id: string, commit?: LocalGraphCommit): string;

package/dist/repository/controllers/commit-cards.js

@@ -0,0 +1,38 @@
+import { encodeJjChangeId } from "./graph/repository-log-graph.js";
+export function commitCardTags(commit) {
+    if (!commit)
+        return [];
+    return [
+        ...commit.bookmarks
+            .filter((b) => b.added && !b.removed)
+            .map((b) => ({
+            id: `bookmark:${JSON.stringify([b.name, b.remote])}`,
+            label: b.remote ? `${b.name}@${b.remote}` : b.name,
+            variant: "secondary",
+        })),
+        ...commit.workspaces.map((name) => ({
+            id: `workspace:${name}`,
+            label: name,
+            tone: "success",
+        })),
+        ...(commit.conflicted
+            ? [{ id: "conflict", label: "Conflict", tone: "warning" }]
+            : []),
+        ...(commit.divergent
+            ? [{ id: "divergent", label: "Divergent", tone: "warning" }]
+            : []),
+    ];
+}
+export function commitCardSearch(id, commit) {
+    return [
+        id,
+        commit?.description,
+        commit?.author.name,
+        commit?.author.email,
+        commit ? encodeJjChangeId(commit.change_id) : "",
+        ...commitCardTags(commit).map((tag) => tag.label),
+    ]
+        .filter(Boolean)
+        .join(" ")
+        .toLocaleLowerCase();
+}

package/dist/repository/controllers/conflict-menu.d.ts

@@ -0,0 +1,2 @@
+export declare const conflictMenuContext: unique symbol;
+export type ConflictMenuState = (id: symbol, open: boolean) => void;

package/dist/repository/controllers/conflict-menu.js

@@ -0,0 +1 @@
+export const conflictMenuContext = Symbol("conflict-surface-menu");

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

@@ -0,0 +1,29 @@
+import type { LocalCodeObjectKey, LocalGraphCommit } from "@lapismd/jj-history";
+import type { HistoryReader } from "./history-reader.js";
+export type FileHistoryState = {
+    path?: string;
+    phase: "idle" | "loading" | "ready" | "unavailable";
+    busy: boolean;
+    heads: string[];
+    operation?: string;
+    workspaceCommit?: string;
+    commits: LocalGraphCommit[];
+    next?: LocalCodeObjectKey | null;
+};
+/** Independent file scope; new editor selections fence every delayed response. */
+export declare class FileHistoryController {
+    #private;
+    readonly reader: HistoryReader;
+    readonly feedback: {
+        report(error: unknown): void;
+        recovered(): void;
+    };
+    constructor(reader: HistoryReader, feedback: FileHistoryController["feedback"]);
+    get state(): FileHistoryState;
+    subscribe(listener: (state: FileHistoryState) => void): () => void;
+    follow(path?: string): Promise<void>;
+    refresh(operation?: string): Promise<void>;
+    checkpointChanged(operation: string): Promise<void>;
+    more(): Promise<void>;
+    close(): Promise<void>;
+}