@gitkraken/core-gitlens 0.6.0 → 0.7.0

package/dist/plus/git-github/providers/github/graph.js

@@ -1,455 +1,403 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { GitSearchError } from '../../../../git/errors.js';
-import { getBranchNameWithoutRemote } from '../../../../git/utils/branch.utils.js';
-import { getChangedFilesCount } from '../../../../git/utils/commit.utils.js';
-import { appendRowsAtCursor, mergeAvatarsForward } from '../../../../git/utils/graph.utils.js';
-import { isUncommitted } from '../../../../git/utils/revision.utils.js';
-import { getSearchQueryComparisonKey, parseSearchQueryGitHubCommand } from '../../../../git/utils/search.utils.js';
-import { debug } from '../../../../utils/decorators/log.js';
-import { first, map } from '../../../../utils/iterable.js';
-import { getSettledValue } from '../../../../utils/promise.js';
-import { toTokenInfo } from '../../api/tokenUtils.js';
+import { first, map } from "../../../../utils/iterable.js";
+import { getSettledValue } from "../../../../utils/promise.js";
+import { debug } from "../../../../utils/decorators/log.js";
+import { getBranchNameWithoutRemote } from "../../../../utils/gitRefs.js";
+import { isUncommitted } from "../../../../git/utils/revision.utils.js";
+import __decorate from "../../../../_virtual/@oxc-project+runtime/helpers/esm/decorate.js";
+import { GitSearchError } from "../../../../git/errors.js";
+import { getChangedFilesCount } from "../../../../git/utils/commit.utils.js";
+import { getSearchQueryComparisonKey, parseSearchQueryGitHubCommand } from "../../../../git/utils/search.utils.js";
+import { GraphSessionWriteQueue } from "../../../../git/models/graphSession.js";
+import { appendRowsAtCursor, mergeAvatarsForward } from "../../../../git/utils/graph.utils.js";
+import { toTokenInfo } from "../../api/tokenUtils.js";
+//#region ../plus/git-github/src/providers/github/graph.ts
 const quoteRegex = /"/g;
-export class GraphGitSubProvider {
-    provider;
-    constructor(provider) {
-        this.provider = provider;
-    }
-    async openGraphSession(repoPath, options, cancellation) {
-        // GitHub-backed graphs have no incremental machinery (and `getGraph` takes no row processor); the
-        // session is a thin window accumulator over full fetches. `rowProcessor` is accepted for interface
-        // parity and ignored — always a full walk.
-        const session = new GraphSession(this, repoPath);
-        await session.initialize(options, cancellation);
-        return session;
-    }
-    async getGraph(repoPath, rev, options, _cancellation) {
-        const defaultLimit = options?.limit ?? 5000;
-        const ordering = 'date';
-        const [logResult, headBranchResult, branchesResult, remotesResult, tagsResult, currentUserResult] = await Promise.allSettled([
-            this.provider.commits.getLog(repoPath, !rev || isUncommitted(rev) ? 'HEAD' : rev, {
-                all: true,
-                ordering: ordering,
-                limit: defaultLimit,
-            }),
-            this.provider.branches.getBranch(repoPath),
-            this.provider.branches.getBranches(repoPath, { filter: b => b.remote }),
-            this.provider.remotes.getRemotes(repoPath),
-            this.provider.tags.getTags(repoPath),
-            this.provider.config.getCurrentUser(repoPath),
-        ]);
-        const avatars = new Map();
-        const headBranch = getSettledValue(headBranchResult);
-        const branchMap = new Map();
-        const branchTips = new Map();
-        if (headBranch != null) {
-            branchMap.set(headBranch.name, headBranch);
-            if (headBranch.sha != null) {
-                branchTips.set(headBranch.sha, [headBranch.name]);
-            }
-        }
-        const branches = getSettledValue(branchesResult)?.values;
-        if (branches != null) {
-            for (const branch of branches) {
-                branchMap.set(branch.name, branch);
-                if (branch.sha == null)
-                    continue;
-                const bts = branchTips.get(branch.sha);
-                if (bts == null) {
-                    branchTips.set(branch.sha, [branch.name]);
-                }
-                else {
-                    bts.push(branch.name);
-                }
-            }
-        }
-        const ids = new Set();
-        const remote = getSettledValue(remotesResult)?.[0];
-        const remoteMap = remote != null ? new Map([[remote.name, remote]]) : new Map();
-        const rowStats = new Map();
-        const tagTips = new Map();
-        const tags = getSettledValue(tagsResult)?.values;
-        if (tags != null) {
-            for (const tag of tags) {
-                if (tag.sha == null)
-                    continue;
-                const tts = tagTips.get(tag.sha);
-                if (tts == null) {
-                    tagTips.set(tag.sha, [tag.name]);
-                }
-                else {
-                    tts.push(tag.name);
-                }
-            }
-        }
-        return this.getGraphCore(repoPath, getSettledValue(logResult), headBranch, branchMap, branchTips, remote, remoteMap, rowStats, tagTips, getSettledValue(currentUserResult), avatars, ids, undefined, undefined, undefined, options);
-    }
-    getGraphCore(repoPath, log, headBranch, branchMap, branchTips, remote, remoteMap, rowStats, tagTips, currentUser, avatars, ids, stashes, worktrees, worktreesByBranch, options) {
-        const includes = { ...options?.include, stats: true }; // stats are always available, so force it
-        const downstreamMap = new Map();
-        if (log == null) {
-            return {
-                repoPath: repoPath,
-                avatars: avatars,
-                ids: ids,
-                includes: includes,
-                branches: branchMap,
-                remotes: remoteMap,
-                downstreams: downstreamMap,
-                stashes: stashes,
-                worktrees: worktrees,
-                worktreesByBranch: worktreesByBranch,
-                rows: [],
-            };
-        }
-        const commits = (log.pagedCommits?.() ?? log.commits)?.values();
-        if (commits == null) {
-            return {
-                repoPath: repoPath,
-                avatars: avatars,
-                ids: ids,
-                includes: includes,
-                branches: branchMap,
-                remotes: remoteMap,
-                downstreams: downstreamMap,
-                stashes: stashes,
-                worktrees: worktrees,
-                worktreesByBranch: worktreesByBranch,
-                rows: [],
-            };
-        }
-        const rows = [];
-        let head;
-        let refHeads;
-        let refRemoteHeads;
-        let refTags;
-        const headRefUpstreamName = headBranch?.upstream?.name;
-        for (const commit of commits) {
-            ids.add(commit.sha);
-            head = commit.sha === headBranch?.sha;
-            if (head) {
-                refHeads = [
-                    {
-                        name: headBranch.name,
-                        isCurrentHead: true,
-                    },
-                ];
-                if (headBranch.upstream != null && remote != null) {
-                    refRemoteHeads = [
-                        {
-                            name: headBranch.name,
-                            owner: remote.name,
-                            url: remote.url,
-                        },
-                    ];
-                    if (headRefUpstreamName != null) {
-                        let downstreams = downstreamMap.get(headRefUpstreamName);
-                        if (downstreams == null) {
-                            downstreams = [];
-                            downstreamMap.set(headRefUpstreamName, downstreams);
-                        }
-                        downstreams.push(headBranch.name);
-                    }
-                }
-                else {
-                    refRemoteHeads = [];
-                }
-            }
-            else {
-                refHeads = [];
-                refRemoteHeads = [];
-                const bts = branchTips.get(commit.sha);
-                if (bts != null && remote != null) {
-                    for (const b of bts) {
-                        refRemoteHeads.push({
-                            name: getBranchNameWithoutRemote(b),
-                            owner: remote.name,
-                            url: remote.url,
-                        });
-                    }
-                }
-            }
-            refTags = [];
-            const tts = tagTips.get(commit.sha);
-            if (tts != null) {
-                for (const t of tts) {
-                    refTags.push({
-                        name: t,
-                        // Not currently used, so don't bother looking it up
-                        annotated: true,
-                    });
-                }
-            }
-            if (commit.author.email && commit.author.avatarUrl && !avatars.has(commit.author.email)) {
-                avatars.set(commit.author.email, commit.author.avatarUrl);
-            }
-            rows.push({
-                sha: commit.sha,
-                parents: commit.parents,
-                author: commit.author.name,
-                email: commit.author.email ?? '',
-                date: commit.committer.date.getTime(),
-                commitDate: commit.committer.date.getTime(),
-                message: commit.message?.length ? commit.message : commit.summary,
-                kind: commit.parents.length > 1 ? 'merge' : 'commit',
-                // Omitted rather than empty: an empty array still counts as "present" to the splice
-                // fingerprint, which defeats its bare-row skip and makes every ref-less row look changeable.
-                heads: refHeads.length ? refHeads : undefined,
-                remotes: refRemoteHeads.length ? refRemoteHeads : undefined,
-                tags: refTags.length ? refTags : undefined,
-            });
-            if (commit.stats != null) {
-                rowStats.set(commit.sha, {
-                    files: getChangedFilesCount(commit.stats.files),
-                    additions: commit.stats.additions,
-                    deletions: commit.stats.deletions,
-                });
-            }
-        }
-        const opts = { ...options };
-        if (opts?.ref === 'HEAD') {
-            opts.ref = first(log.commits.values())?.sha;
-        }
-        else if (opts?.ref != null) {
-            opts.ref = undefined;
-        }
-        return {
-            repoPath: repoPath,
-            avatars: avatars,
-            ids: ids,
-            includes: includes,
-            branches: branchMap,
-            remotes: remoteMap,
-            downstreams: downstreamMap,
-            stashes: stashes,
-            worktrees: worktrees,
-            worktreesByBranch: worktreesByBranch,
-            rows: rows,
-            id: opts?.ref ?? first(log.commits.values())?.sha,
-            rowsStats: rowStats.size > 0 ? rowStats : undefined,
-            paging: {
-                limit: log.limit,
-                startingCursor: log.startingCursor,
-                hasMore: log.hasMore,
-            },
-            more: async (limit, _id, _cancellation) => {
-                const moreLog = await log.more?.(limit);
-                return this.getGraphCore(repoPath, moreLog, headBranch, branchMap, branchTips, remote, remoteMap, rowStats, tagTips, currentUser, avatars, ids, stashes, worktrees, worktreesByBranch, opts);
-            },
-        };
-    }
-    async *searchGraph(repoPath, search, options, cancellation) {
-        return yield* this.searchGraphCore(repoPath, search, undefined, undefined, options, cancellation);
-    }
-    async *continueSearchGraph(repoPath, cursor, existingResults, options, cancellation) {
-        return yield* this.searchGraphCore(repoPath, cursor.search, cursor, existingResults, options, cancellation);
-    }
-    async *searchGraphCore(repoPath, search, cursor, existingResults, options, cancellation) {
-        search = { matchAll: false, matchCase: false, matchRegex: true, matchWholeWord: false, ...search };
-        const comparisonKey = getSearchQueryComparisonKey(search);
-        try {
-            const currentUser = search.query.includes('@me')
-                ? await this.provider.config.getCurrentUser(repoPath)
-                : undefined;
-            const results = existingResults ?? new Map();
-            const { args: queryArgs, filters, operations } = parseSearchQueryGitHubCommand(search, currentUser);
-            const values = operations.get('commit:');
-            if (values != null) {
-                const commitsResults = await Promise.allSettled(map(values, v => this.provider.commits.getCommit(repoPath, v.replace(quoteRegex, ''))));
-                let i = 0;
-                for (const commitResult of commitsResults) {
-                    const commit = getSettledValue(commitResult);
-                    if (commit == null)
-                        continue;
-                    results.set(commit.sha, {
-                        i: i++,
-                        date: Number(options?.ordering === 'author-date' ? commit.author.date : commit.committer.date),
-                        files: commit.fileset?.files,
-                    });
-                }
-                return {
-                    repoPath: repoPath,
-                    query: search,
-                    queryFilters: filters,
-                    comparisonKey: comparisonKey,
-                    results: results,
-                    hasMore: false,
-                };
-            }
-            if (!queryArgs.length) {
-                return {
-                    repoPath: repoPath,
-                    query: search,
-                    queryFilters: filters,
-                    comparisonKey: comparisonKey,
-                    results: results,
-                    hasMore: false,
-                };
-            }
-            const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
-            const query = `repo:${metadata.repo.owner}/${metadata.repo.name}+${queryArgs.join('+').trim()}`;
-            const limit = this.provider.getPagingLimit(options?.limit);
-            // Use state from cursor, if provided
-            let apiCursor = cursor?.state != null && typeof cursor.state === 'string' ? cursor.state : undefined;
-            let hasMore = true;
-            while (hasMore && !cancellation?.aborted) {
-                const result = await github.searchCommitShas(toTokenInfo(this.provider.authenticationProviderId, session), query, {
-                    cursor: apiCursor,
-                    limit: limit,
-                    sort: options?.ordering === 'date'
-                        ? 'committer-date'
-                        : options?.ordering === 'author-date'
-                            ? 'author-date'
-                            : undefined,
-                });
-                if (result == null || cancellation?.aborted) {
-                    break;
-                }
-                // Collect incremental results for this page
-                const incrementalResults = new Map();
-                for (const commit of result.values) {
-                    const data = {
-                        i: results.size,
-                        date: options?.ordering === 'author-date' ? commit.authorDate : commit.committerDate,
-                        files: undefined,
-                    };
-                    results.set(commit.sha, data);
-                    incrementalResults.set(commit.sha, data);
-                }
-                hasMore = result.pageInfo?.hasNextPage ?? false;
-                apiCursor = result.pageInfo?.endCursor ?? undefined;
-                // Yield progress with incremental results from this page
-                if (incrementalResults.size) {
-                    yield {
-                        repoPath: repoPath,
-                        query: search,
-                        queryFilters: filters,
-                        comparisonKey: comparisonKey,
-                        results: incrementalResults,
-                        runningTotal: results.size,
-                        hasMore: hasMore,
-                    };
-                }
-            }
-            return {
-                repoPath: repoPath,
-                query: search,
-                queryFilters: filters,
-                comparisonKey: comparisonKey,
-                results: results,
-                hasMore: hasMore,
-                paging: hasMore
-                    ? {
-                        limit: limit,
-                        cursor: apiCursor ? { search: search, state: apiCursor } : undefined,
-                    }
-                    : undefined,
-            };
-        }
-        catch (ex) {
-            if (ex instanceof GitSearchError)
-                throw ex;
-            throw new GitSearchError(ex);
-        }
-    }
-}
-__decorate([
-    debug()
-], GraphGitSubProvider.prototype, "getGraph", null);
-__decorate([
-    debug({
-        args: (repoPath, s, o) => ({
-            repoPath: repoPath,
-            search: `[${s.matchAll ? 'A' : ''}${s.matchCase ? 'C' : ''}${s.matchRegex ? 'R' : ''}${s.matchWholeWord ? 'W' : ''}]: ${s.query.length > 500 ? `${s.query.substring(0, 500)}...` : s.query}`,
-            options: `limit=${o?.limit}, ordering=${o?.ordering}`,
-        }),
-    })
-], GraphGitSubProvider.prototype, "searchGraph", null);
-__decorate([
-    debug({
-        args: (repoPath, c, r, o) => ({
-            repoPath: repoPath,
-            cursor: `[${c.search.matchAll ? 'A' : ''}${c.search.matchCase ? 'C' : ''}${c.search.matchRegex ? 'R' : ''}${c.search.matchWholeWord ? 'W' : ''}]: ${c.search.query.length > 500 ? `${c.search.query.substring(0, 500)}...` : c.search.query} (continue)`,
-            existingResults: `results=${r.size}`,
-            options: `limit=${o?.limit}`,
-        }),
-    })
-], GraphGitSubProvider.prototype, "continueSearchGraph", null);
+var GraphGitSubProvider = class {
+	provider;
+	constructor(provider) {
+		this.provider = provider;
+	}
+	async openGraphSession(repoPath, options, cancellation) {
+		const session = new GraphSession(this, repoPath);
+		await session.initialize(options, cancellation);
+		return session;
+	}
+	async getGraph(repoPath, rev, options, _cancellation) {
+		const defaultLimit = options?.limit ?? 5e3;
+		const [logResult, headBranchResult, branchesResult, remotesResult, tagsResult, currentUserResult] = await Promise.allSettled([
+			this.provider.commits.getLog(repoPath, !rev || isUncommitted(rev) ? "HEAD" : rev, {
+				all: true,
+				ordering: "date",
+				limit: defaultLimit
+			}),
+			this.provider.branches.getBranch(repoPath),
+			this.provider.branches.getBranches(repoPath, { filter: (b) => b.remote }),
+			this.provider.remotes.getRemotes(repoPath),
+			this.provider.tags.getTags(repoPath),
+			this.provider.config.getCurrentUser(repoPath)
+		]);
+		const avatars = /* @__PURE__ */ new Map();
+		const headBranch = getSettledValue(headBranchResult);
+		const branchMap = /* @__PURE__ */ new Map();
+		const branchTips = /* @__PURE__ */ new Map();
+		if (headBranch != null) {
+			branchMap.set(headBranch.name, headBranch);
+			if (headBranch.sha != null) branchTips.set(headBranch.sha, [headBranch.name]);
+		}
+		const branches = getSettledValue(branchesResult)?.values;
+		if (branches != null) for (const branch of branches) {
+			branchMap.set(branch.name, branch);
+			if (branch.sha == null) continue;
+			const bts = branchTips.get(branch.sha);
+			if (bts == null) branchTips.set(branch.sha, [branch.name]);
+			else bts.push(branch.name);
+		}
+		const ids = /* @__PURE__ */ new Set();
+		const remote = getSettledValue(remotesResult)?.[0];
+		const remoteMap = remote != null ? /* @__PURE__ */ new Map([[remote.name, remote]]) : /* @__PURE__ */ new Map();
+		const rowStats = /* @__PURE__ */ new Map();
+		const tagTips = /* @__PURE__ */ new Map();
+		const tags = getSettledValue(tagsResult)?.values;
+		if (tags != null) for (const tag of tags) {
+			if (tag.sha == null) continue;
+			const tts = tagTips.get(tag.sha);
+			if (tts == null) tagTips.set(tag.sha, [tag.name]);
+			else tts.push(tag.name);
+		}
+		return this.getGraphCore(repoPath, getSettledValue(logResult), headBranch, branchMap, branchTips, remote, remoteMap, rowStats, tagTips, getSettledValue(currentUserResult), avatars, ids, void 0, void 0, void 0, options);
+	}
+	getGraphCore(repoPath, log, headBranch, branchMap, branchTips, remote, remoteMap, rowStats, tagTips, currentUser, avatars, ids, stashes, worktrees, worktreesByBranch, options) {
+		const includes = {
+			...options?.include,
+			stats: true
+		};
+		const downstreamMap = /* @__PURE__ */ new Map();
+		if (log == null) return {
+			repoPath,
+			avatars,
+			ids,
+			includes,
+			branches: branchMap,
+			remotes: remoteMap,
+			downstreams: downstreamMap,
+			stashes,
+			worktrees,
+			worktreesByBranch,
+			rows: []
+		};
+		const commits = (log.pagedCommits?.() ?? log.commits)?.values();
+		if (commits == null) return {
+			repoPath,
+			avatars,
+			ids,
+			includes,
+			branches: branchMap,
+			remotes: remoteMap,
+			downstreams: downstreamMap,
+			stashes,
+			worktrees,
+			worktreesByBranch,
+			rows: []
+		};
+		const rows = [];
+		let head;
+		let refHeads;
+		let refRemoteHeads;
+		let refTags;
+		const headRefUpstreamName = headBranch?.upstream?.name;
+		for (const commit of commits) {
+			ids.add(commit.sha);
+			head = commit.sha === headBranch?.sha;
+			if (head) {
+				refHeads = [{
+					name: headBranch.name,
+					isCurrentHead: true
+				}];
+				if (headBranch.upstream != null && remote != null) {
+					refRemoteHeads = [{
+						name: headBranch.name,
+						owner: remote.name,
+						url: remote.url
+					}];
+					if (headRefUpstreamName != null) {
+						let downstreams = downstreamMap.get(headRefUpstreamName);
+						if (downstreams == null) {
+							downstreams = [];
+							downstreamMap.set(headRefUpstreamName, downstreams);
+						}
+						downstreams.push(headBranch.name);
+					}
+				} else refRemoteHeads = [];
+			} else {
+				refHeads = [];
+				refRemoteHeads = [];
+				const bts = branchTips.get(commit.sha);
+				if (bts != null && remote != null) for (const b of bts) refRemoteHeads.push({
+					name: getBranchNameWithoutRemote(b),
+					owner: remote.name,
+					url: remote.url
+				});
+			}
+			refTags = [];
+			const tts = tagTips.get(commit.sha);
+			if (tts != null) for (const t of tts) refTags.push({
+				name: t,
+				annotated: true
+			});
+			if (commit.author.email && commit.author.avatarUrl && !avatars.has(commit.author.email)) avatars.set(commit.author.email, commit.author.avatarUrl);
+			rows.push({
+				sha: commit.sha,
+				parents: commit.parents,
+				author: commit.author.name,
+				email: commit.author.email ?? "",
+				date: commit.committer.date.getTime(),
+				commitDate: commit.committer.date.getTime(),
+				message: commit.message?.length ? commit.message : commit.summary,
+				kind: commit.parents.length > 1 ? "merge" : "commit",
+				heads: refHeads.length ? refHeads : void 0,
+				remotes: refRemoteHeads.length ? refRemoteHeads : void 0,
+				tags: refTags.length ? refTags : void 0
+			});
+			if (commit.stats != null) rowStats.set(commit.sha, {
+				files: getChangedFilesCount(commit.stats.files),
+				additions: commit.stats.additions,
+				deletions: commit.stats.deletions
+			});
+		}
+		const opts = { ...options };
+		if (opts?.ref === "HEAD") opts.ref = first(log.commits.values())?.sha;
+		else if (opts?.ref != null) opts.ref = void 0;
+		return {
+			repoPath,
+			avatars,
+			ids,
+			includes,
+			branches: branchMap,
+			remotes: remoteMap,
+			downstreams: downstreamMap,
+			stashes,
+			worktrees,
+			worktreesByBranch,
+			rows,
+			id: opts?.ref ?? first(log.commits.values())?.sha,
+			rowsStats: rowStats.size > 0 ? rowStats : void 0,
+			paging: {
+				limit: log.limit,
+				startingCursor: log.startingCursor,
+				hasMore: log.hasMore
+			},
+			more: async (limit, _id, _cancellation) => {
+				const moreLog = await log.more?.(limit);
+				return this.getGraphCore(repoPath, moreLog, headBranch, branchMap, branchTips, remote, remoteMap, rowStats, tagTips, currentUser, avatars, ids, stashes, worktrees, worktreesByBranch, opts);
+			}
+		};
+	}
+	async *searchGraph(repoPath, search, options, cancellation) {
+		return yield* this.searchGraphCore(repoPath, search, void 0, void 0, options, cancellation);
+	}
+	async *continueSearchGraph(repoPath, cursor, existingResults, options, cancellation) {
+		return yield* this.searchGraphCore(repoPath, cursor.search, cursor, existingResults, options, cancellation);
+	}
+	async *searchGraphCore(repoPath, search, cursor, existingResults, options, cancellation) {
+		search = {
+			matchAll: false,
+			matchCase: false,
+			matchRegex: true,
+			matchWholeWord: false,
+			...search
+		};
+		const comparisonKey = getSearchQueryComparisonKey(search);
+		try {
+			const currentUser = search.query.includes("@me") ? await this.provider.config.getCurrentUser(repoPath) : void 0;
+			const results = existingResults ?? /* @__PURE__ */ new Map();
+			const { args: queryArgs, filters, operations } = parseSearchQueryGitHubCommand(search, currentUser);
+			const values = operations.get("commit:");
+			if (values != null) {
+				const commitsResults = await Promise.allSettled(map(values, (v) => this.provider.commits.getCommit(repoPath, v.replace(quoteRegex, ""))));
+				let i = 0;
+				for (const commitResult of commitsResults) {
+					const commit = getSettledValue(commitResult);
+					if (commit == null) continue;
+					results.set(commit.sha, {
+						i: i++,
+						date: Number(options?.ordering === "author-date" ? commit.author.date : commit.committer.date),
+						files: commit.fileset?.files
+					});
+				}
+				return {
+					repoPath,
+					query: search,
+					queryFilters: filters,
+					comparisonKey,
+					results,
+					hasMore: false
+				};
+			}
+			if (!queryArgs.length) return {
+				repoPath,
+				query: search,
+				queryFilters: filters,
+				comparisonKey,
+				results,
+				hasMore: false
+			};
+			const { metadata, github, session } = await this.provider.ensureRepositoryContext(repoPath);
+			const query = `repo:${metadata.repo.owner}/${metadata.repo.name}+${queryArgs.join("+").trim()}`;
+			const limit = this.provider.getPagingLimit(options?.limit);
+			let apiCursor = cursor?.state != null && typeof cursor.state === "string" ? cursor.state : void 0;
+			let hasMore = true;
+			while (hasMore && !cancellation?.aborted) {
+				const result = await github.searchCommitShas(toTokenInfo(this.provider.authenticationProviderId, session), query, {
+					cursor: apiCursor,
+					limit,
+					sort: options?.ordering === "date" ? "committer-date" : options?.ordering === "author-date" ? "author-date" : void 0
+				});
+				if (result == null || cancellation?.aborted) break;
+				const incrementalResults = /* @__PURE__ */ new Map();
+				for (const commit of result.values) {
+					const data = {
+						i: results.size,
+						date: options?.ordering === "author-date" ? commit.authorDate : commit.committerDate,
+						files: void 0
+					};
+					results.set(commit.sha, data);
+					incrementalResults.set(commit.sha, data);
+				}
+				hasMore = result.pageInfo?.hasNextPage ?? false;
+				apiCursor = result.pageInfo?.endCursor ?? void 0;
+				if (incrementalResults.size) yield {
+					repoPath,
+					query: search,
+					queryFilters: filters,
+					comparisonKey,
+					results: incrementalResults,
+					runningTotal: results.size,
+					hasMore
+				};
+			}
+			return {
+				repoPath,
+				query: search,
+				queryFilters: filters,
+				comparisonKey,
+				results,
+				hasMore,
+				paging: hasMore ? {
+					limit,
+					cursor: apiCursor ? {
+						search,
+						state: apiCursor
+					} : void 0
+				} : void 0
+			};
+		} catch (ex) {
+			if (ex instanceof GitSearchError) throw ex;
+			throw new GitSearchError(ex);
+		}
+	}
+};
+__decorate([debug()], GraphGitSubProvider.prototype, "getGraph", null);
+__decorate([debug({ args: (repoPath, s, o) => ({
+	repoPath,
+	search: `[${s.matchAll ? "A" : ""}${s.matchCase ? "C" : ""}${s.matchRegex ? "R" : ""}${s.matchWholeWord ? "W" : ""}]: ${s.query.length > 500 ? `${s.query.substring(0, 500)}...` : s.query}`,
+	options: `limit=${o?.limit}, ordering=${o?.ordering}`
+}) })], GraphGitSubProvider.prototype, "searchGraph", null);
+__decorate([debug({ args: (repoPath, c, r, o) => ({
+	repoPath,
+	cursor: `[${c.search.matchAll ? "A" : ""}${c.search.matchCase ? "C" : ""}${c.search.matchRegex ? "R" : ""}${c.search.matchWholeWord ? "W" : ""}]: ${c.search.query.length > 500 ? `${c.search.query.substring(0, 500)}...` : c.search.query} (continue)`,
+	existingResults: `results=${r.size}`,
+	options: `limit=${o?.limit}`
+}) })], GraphGitSubProvider.prototype, "continueSearchGraph", null);
 /**
- * GitHub-backed {@link GitGraphSession}: a thin window accumulator over {@link GraphGitSubProvider.getGraph}.
- * There's no incremental head-walk yet, so every {@link refresh} is a full fetch (`path: 'full'`); the
- * window accumulates across {@link more} via the shared cursor-anchored helper, and prior avatar URLs are
- * carried forward write-once — matching the CLI session's observable window/avatar behavior.
- */
-class GraphSession {
-    provider;
-    repoPath;
-    // Assigned by `initialize` before the session is handed out; never read before then.
-    _current;
-    _window = [];
-    constructor(provider, repoPath) {
-        this.provider = provider;
-        this.repoPath = repoPath;
-    }
-    get window() {
-        return this._window;
-    }
-    get current() {
-        return this._current;
-    }
-    async initialize(options, cancellation) {
-        const graph = await this.provider.getGraph(this.repoPath, options?.rev, { include: options?.include, limit: options?.limit }, cancellation);
-        this.apply(graph);
-    }
-    async refresh(options, cancellation) {
-        const prior = this._current;
-        let graph = await this.provider.getGraph(this.repoPath, options?.rev, { include: options?.include, limit: options?.limit }, cancellation);
-        // Host-serialization backstop: the host serializes refresh against more() per repo. Should a more() still
-        // land mid-refresh (`_current` swapped out from under this await), the rebuild predates that appended page
-        // — refresh carries newer repo truth so we still apply it, but when the accumulated window outran the
-        // rebuild the dropped page must re-page, not vanish. `paging.hasMore` is readonly, so re-wrap it truthful.
-        if (this._current !== prior && graph.paging != null && this._window.length > graph.rows.length) {
-            graph = { ...graph, paging: { ...graph.paging, hasMore: true } };
-        }
-        mergeAvatarsForward(prior.avatars, graph.avatars);
-        this.apply(graph);
-        // The GitHub provider always does a full walk (no incremental fast path), so every channel changed.
-        const changed = {
-            rows: true,
-            reachability: true,
-            rowsStats: true,
-            avatars: true,
-            downstreams: true,
-        };
-        return { path: 'full', changed: changed };
-    }
-    async more(limit, targetId, cancellation) {
-        const prior = this._current;
-        const updated = await prior.more?.(limit ?? 0, targetId, cancellation);
-        if (this._current !== prior || updated == null)
-            return false;
-        // A more() past the end returns a degenerate empty graph (no rows, no paging) — nothing to add, so don't
-        // let it REPLACE the accumulated window with empty.
-        if (updated.rows.length === 0 && updated.paging == null)
-            return false;
-        mergeAvatarsForward(prior.avatars, updated.avatars);
-        this.apply(updated);
-        return true;
-    }
-    dispose() {
-        // No-op — the window lives entirely in memory.
-    }
-    /** Cursor-less graph IS the full window; a paged graph appends at its cursor. */
-    apply(graph) {
-        this._current = graph;
-        const startingCursor = graph.paging?.startingCursor;
-        this._window =
-            startingCursor == null ? graph.rows : appendRowsAtCursor(this._window, startingCursor, graph.rows);
-    }
-}
+* GitHub-backed {@link GitGraphSession}: a thin window accumulator over {@link GraphGitSubProvider.getGraph}.
+* There's no incremental head-walk yet, so every {@link refresh} is a full fetch (`path: 'full'`); the
+* window accumulates across {@link more} via the shared cursor-anchored helper, and prior avatar URLs are
+* carried forward write-once — matching the CLI session's observable window/avatar behavior.
+*/
+var GraphSession = class {
+	provider;
+	repoPath;
+	_current;
+	_window = [];
+	/**
+	* The SAME serialization + generation machinery the CLI session uses — see
+	* {@link GraphSessionWriteQueue}, which owns the contract so the two implementations cannot drift.
+	* This session has no incremental walk, but the contract is about window ownership, not walk strategy:
+	* a page here is just as capable of landing on a window a refresh already replaced.
+	*/
+	writes = new GraphSessionWriteQueue();
+	constructor(provider, repoPath) {
+		this.provider = provider;
+		this.repoPath = repoPath;
+	}
+	get window() {
+		return this._window;
+	}
+	get current() {
+		return this._current;
+	}
+	/** See {@link GitGraphSession.tainted}. Never raised here: this session replaces the window wholesale
+	*  from a fetched graph and has no in-place row mutation that could fail part-way through. */
+	get tainted() {
+		return this.writes.tainted;
+	}
+	async initialize(options, cancellation) {
+		const graph = await this.provider.getGraph(this.repoPath, options?.rev, {
+			include: options?.include,
+			limit: options?.limit
+		}, cancellation);
+		this.apply(graph);
+	}
+	refresh(options, cancellation) {
+		return this.writes.run(() => this.refreshCore(options, cancellation));
+	}
+	async refreshCore(options, cancellation) {
+		const prior = this._current;
+		const graph = await this.provider.getGraph(this.repoPath, options?.rev, {
+			include: options?.include,
+			limit: options?.limit
+		}, cancellation);
+		mergeAvatarsForward(prior.avatars, graph.avatars);
+		this.apply(graph);
+		return {
+			path: "full",
+			changed: {
+				rows: true,
+				reachability: true,
+				rowsStats: true,
+				avatars: true,
+				downstreams: true
+			}
+		};
+	}
+	rebind(_repoPath, cancellation) {
+		return this.refresh(void 0, cancellation);
+	}
+	more(limit, targetId, cancellation) {
+		return this.writes.runPage(() => this.moreCore(limit, targetId, cancellation));
+	}
+	async moreCore(limit, targetId, cancellation) {
+		if (cancellation?.aborted === true) return "none";
+		const prior = this._current;
+		const updated = await prior.more?.(limit ?? 0, targetId, cancellation);
+		if (updated == null) return "none";
+		if (updated.rows.length === 0 && updated.paging == null) return "none";
+		mergeAvatarsForward(prior.avatars, updated.avatars);
+		this.apply(updated);
+		return "added";
+	}
+	dispose() {}
+	/** Cursor-less graph IS the full window; a paged graph appends at its cursor. */
+	apply(graph) {
+		this._current = graph;
+		const startingCursor = graph.paging?.startingCursor;
+		if (startingCursor == null) {
+			this._window = graph.rows;
+			this.writes.invalidate();
+		} else this._window = appendRowsAtCursor(this._window, startingCursor, graph.rows);
+	}
+};
+//#endregion
+export { GraphGitSubProvider };
+
 //# sourceMappingURL=graph.js.map