@openvcs/sdk 0.2.4 → 0.2.6

package/src/lib/runtime/vcs-delegate-base.ts

@@ -0,0 +1,481 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import type * as VcsTypes from '../types';
+
+import type { PluginRuntimeContext } from './contracts';
+import {
+  type VcsDelegateAssignments,
+  type VcsDelegateBindings,
+  type VcsDelegateMethodName,
+  type VcsDelegatePrototype,
+  type VcsDelegateRpcMethodName,
+  VCS_DELEGATE_METHOD_MAPPINGS,
+} from './vcs-delegate-metadata';
+
+/** Describes one synchronous or asynchronous VCS delegate return value. */
+type VcsHandlerResult<TResult> = TResult | Promise<TResult>;
+
+/** Builds exact `vcs.*` delegates from ordinary class methods. */
+export abstract class VcsDelegateBase<
+  TDeps,
+  TContext = PluginRuntimeContext,
+> {
+  /** Stores the runtime services exposed to the delegate implementation. */
+  protected readonly deps: TDeps;
+
+  /** Creates one delegate base with the provided runtime dependencies. */
+  constructor(deps: TDeps) {
+    this.deps = deps;
+  }
+
+  /** Builds an SDK `vcs.*` delegate map from the subclass overrides. */
+  toDelegates(): VcsDelegateAssignments<TContext> {
+    const delegates: VcsDelegateAssignments<TContext> = {};
+    const delegatePrototype = Object.getPrototypeOf(this) as VcsDelegatePrototype<TContext> | null;
+    const basePrototype = VcsDelegateBase.prototype as VcsDelegatePrototype<TContext>;
+
+    for (const delegateMethod of Object.keys(
+      VCS_DELEGATE_METHOD_MAPPINGS,
+    ) as VcsDelegateMethodName[]) {
+      const handler = delegatePrototype?.[delegateMethod];
+      if (typeof handler !== 'function' || handler === basePrototype[delegateMethod]) {
+        continue;
+      }
+
+      this.assignDelegate(delegates, delegateMethod, handler);
+    }
+
+    return delegates;
+  }
+
+  /** Assigns one typed class method to its exact `vcs.*` delegate name. */
+  private assignDelegate<TMethodName extends VcsDelegateMethodName>(
+    delegates: VcsDelegateAssignments<TContext>,
+    delegateMethod: TMethodName,
+    handler: VcsDelegateBindings<TContext>[TMethodName],
+  ): void {
+    const rpcMethod = VCS_DELEGATE_METHOD_MAPPINGS[
+      delegateMethod
+    ] as VcsDelegateRpcMethodName<TMethodName>;
+    // `bind` loses the method-specific key correlation here; the cast is
+    // safe because `assignDelegate` is only called with handlers that were
+    // verified against `VcsDelegateBindings<TContext>` in the loop above.
+    const boundHandler = handler.bind(this) as VcsDelegateAssignments<TContext>[typeof rpcMethod];
+
+    delegates[rpcMethod] = boundHandler;
+  }
+
+  /**
+   * Throws when a subclass does not implement one required delegate method.
+   *
+   * The `never` return type is intentional: base stubs should never contribute
+   * a usable value, and subclasses should override the method with the exact
+   * signature inherited from `VcsDelegateBase`.
+   */
+  protected unimplemented(methodName: VcsDelegateMethodName): never {
+    throw new Error(
+      `VCS delegate method '${methodName}' must be overridden before registration`,
+    );
+  }
+
+  /** Handles `vcs.get_caps`. */
+  getCaps(
+    _params: VcsTypes.RequestParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.VcsCapabilities> {
+    return this.unimplemented('getCaps');
+  }
+
+  /** Handles `vcs.open`. */
+  open(
+    _params: VcsTypes.VcsOpenParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.VcsSessionResult> {
+    return this.unimplemented('open');
+  }
+
+  /** Handles `vcs.close`. */
+  close(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('close');
+  }
+
+  /** Handles `vcs.clone_repo`. */
+  cloneRepo(
+    _params: VcsTypes.VcsCloneRepoParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('cloneRepo');
+  }
+
+  /** Handles `vcs.get_workdir`. */
+  getWorkdir(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<string> {
+    return this.unimplemented('getWorkdir');
+  }
+
+  /** Handles `vcs.get_current_branch`. */
+  getCurrentBranch(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<string | null> {
+    return this.unimplemented('getCurrentBranch');
+  }
+
+  /** Handles `vcs.list_branches`. */
+  listBranches(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.VcsBranchEntry[]> {
+    return this.unimplemented('listBranches');
+  }
+
+  /** Handles `vcs.list_local_branches`. */
+  listLocalBranches(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<string[]> {
+    return this.unimplemented('listLocalBranches');
+  }
+
+  /** Handles `vcs.create_branch`. */
+  createBranch(
+    _params: VcsTypes.VcsCreateBranchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('createBranch');
+  }
+
+  /** Handles `vcs.checkout_branch`. */
+  checkoutBranch(
+    _params: VcsTypes.VcsCheckoutBranchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('checkoutBranch');
+  }
+
+  /** Handles `vcs.ensure_remote`. */
+  ensureRemote(
+    _params: VcsTypes.VcsEnsureRemoteParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('ensureRemote');
+  }
+
+  /** Handles `vcs.list_remotes`. */
+  listRemotes(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.VcsRemoteEntry[]> {
+    return this.unimplemented('listRemotes');
+  }
+
+  /** Handles `vcs.remove_remote`. */
+  removeRemote(
+    _params: VcsTypes.VcsRemoveRemoteParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('removeRemote');
+  }
+
+  /** Handles `vcs.fetch`. */
+  fetch(
+    _params: VcsTypes.VcsFetchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('fetch');
+  }
+
+  /** Handles `vcs.fetch_with_options`. */
+  fetchWithOptions(
+    _params: VcsTypes.VcsFetchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('fetchWithOptions');
+  }
+
+  /** Handles `vcs.push`. */
+  push(
+    _params: VcsTypes.VcsPushParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('push');
+  }
+
+  /** Handles `vcs.pull_ff_only`. */
+  pullFfOnly(
+    _params: VcsTypes.VcsPullFfOnlyParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('pullFfOnly');
+  }
+
+  /** Handles `vcs.commit`. */
+  commit(
+    _params: VcsTypes.VcsCommitParams,
+    _context: TContext,
+  ): VcsHandlerResult<string> {
+    return this.unimplemented('commit');
+  }
+
+  /** Handles `vcs.commit_index`. */
+  commitIndex(
+    _params: VcsTypes.VcsCommitParams,
+    _context: TContext,
+  ): VcsHandlerResult<string> {
+    return this.unimplemented('commitIndex');
+  }
+
+  /** Handles `vcs.get_status_summary`. */
+  getStatusSummary(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.StatusSummary> {
+    return this.unimplemented('getStatusSummary');
+  }
+
+  /** Handles `vcs.get_status_payload`. */
+  getStatusPayload(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.StatusPayload> {
+    return this.unimplemented('getStatusPayload');
+  }
+
+  /** Handles `vcs.list_commits`. */
+  listCommits(
+    _params: VcsTypes.VcsListCommitsParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.CommitEntry[]> {
+    return this.unimplemented('listCommits');
+  }
+
+  /** Handles `vcs.diff_file`. */
+  diffFile(
+    _params: VcsTypes.VcsDiffFileParams,
+    _context: TContext,
+  ): VcsHandlerResult<string[]> {
+    return this.unimplemented('diffFile');
+  }
+
+  /** Handles `vcs.diff_commit`. */
+  diffCommit(
+    _params: VcsTypes.VcsDiffCommitParams,
+    _context: TContext,
+  ): VcsHandlerResult<string[]> {
+    return this.unimplemented('diffCommit');
+  }
+
+  /** Handles `vcs.get_conflict_details`. */
+  getConflictDetails(
+    _params: VcsTypes.VcsGetConflictDetailsParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.VcsConflictDetails> {
+    return this.unimplemented('getConflictDetails');
+  }
+
+  /** Handles `vcs.checkout_conflict_side`. */
+  checkoutConflictSide(
+    _params: VcsTypes.VcsCheckoutConflictSideParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('checkoutConflictSide');
+  }
+
+  /** Handles `vcs.write_merge_result`. */
+  writeMergeResult(
+    _params: VcsTypes.VcsWriteMergeResultParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('writeMergeResult');
+  }
+
+  /** Handles `vcs.stage_patch`. */
+  stagePatch(
+    _params: VcsTypes.VcsStagePatchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('stagePatch');
+  }
+
+  /** Handles `vcs.discard_paths`. */
+  discardPaths(
+    _params: VcsTypes.VcsDiscardPathsParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('discardPaths');
+  }
+
+  /** Handles `vcs.apply_reverse_patch`. */
+  applyReversePatch(
+    _params: VcsTypes.VcsApplyReversePatchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('applyReversePatch');
+  }
+
+  /** Handles `vcs.delete_branch`. */
+  deleteBranch(
+    _params: VcsTypes.VcsDeleteBranchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('deleteBranch');
+  }
+
+  /** Handles `vcs.rename_branch`. */
+  renameBranch(
+    _params: VcsTypes.VcsRenameBranchParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('renameBranch');
+  }
+
+  /** Handles `vcs.merge_into_current`. */
+  mergeIntoCurrent(
+    _params: VcsTypes.VcsMergeIntoCurrentParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('mergeIntoCurrent');
+  }
+
+  /** Handles `vcs.merge_abort`. */
+  mergeAbort(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('mergeAbort');
+  }
+
+  /** Handles `vcs.merge_continue`. */
+  mergeContinue(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('mergeContinue');
+  }
+
+  /** Handles `vcs.is_merge_in_progress`. */
+  isMergeInProgress(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<boolean> {
+    return this.unimplemented('isMergeInProgress');
+  }
+
+  /** Handles `vcs.set_branch_upstream`. */
+  setBranchUpstream(
+    _params: VcsTypes.VcsSetBranchUpstreamParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('setBranchUpstream');
+  }
+
+  /** Handles `vcs.get_branch_upstream`. */
+  getBranchUpstream(
+    _params: VcsTypes.VcsGetBranchUpstreamParams,
+    _context: TContext,
+  ): VcsHandlerResult<string | null> {
+    return this.unimplemented('getBranchUpstream');
+  }
+
+  /** Handles `vcs.hard_reset_head`. */
+  hardResetHead(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('hardResetHead');
+  }
+
+  /** Handles `vcs.reset_soft_to`. */
+  resetSoftTo(
+    _params: VcsTypes.VcsResetSoftToParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('resetSoftTo');
+  }
+
+  /** Handles `vcs.get_identity`. */
+  getIdentity(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.VcsIdentity | null> {
+    return this.unimplemented('getIdentity');
+  }
+
+  /** Handles `vcs.set_identity_local`. */
+  setIdentityLocal(
+    _params: VcsTypes.VcsSetIdentityLocalParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('setIdentityLocal');
+  }
+
+  /** Handles `vcs.list_stashes`. */
+  listStashes(
+    _params: VcsTypes.VcsSessionParams,
+    _context: TContext,
+  ): VcsHandlerResult<VcsTypes.StashEntry[]> {
+    return this.unimplemented('listStashes');
+  }
+
+  /** Handles `vcs.stash_push`. */
+  stashPush(
+    _params: VcsTypes.VcsStashPushParams,
+    _context: TContext,
+  ): VcsHandlerResult<string> {
+    return this.unimplemented('stashPush');
+  }
+
+  /** Handles `vcs.stash_apply`. */
+  stashApply(
+    _params: VcsTypes.VcsStashSelectorParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('stashApply');
+  }
+
+  /** Handles `vcs.stash_pop`. */
+  stashPop(
+    _params: VcsTypes.VcsStashSelectorParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('stashPop');
+  }
+
+  /** Handles `vcs.stash_drop`. */
+  stashDrop(
+    _params: VcsTypes.VcsStashSelectorParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('stashDrop');
+  }
+
+  /** Handles `vcs.stash_show`. */
+  stashShow(
+    _params: VcsTypes.VcsStashSelectorParams,
+    _context: TContext,
+  ): VcsHandlerResult<string> {
+    return this.unimplemented('stashShow');
+  }
+
+  /** Handles `vcs.cherry_pick`. */
+  cherryPick(
+    _params: VcsTypes.VcsCherryPickParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('cherryPick');
+  }
+
+  /** Handles `vcs.revert_commit`. */
+  revertCommit(
+    _params: VcsTypes.VcsRevertCommitParams,
+    _context: TContext,
+  ): VcsHandlerResult<null> {
+    return this.unimplemented('revertCommit');
+  }
+}

package/src/lib/runtime/vcs-delegate-metadata.ts

@@ -0,0 +1,165 @@
+// Copyright © 2025-2026 OpenVCS Contributors
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+import type * as VcsTypes from '../types';
+
+import type { PluginRuntimeContext } from './contracts';
+
+/** Stores the typed class-method signatures supported by `VcsDelegateBase`. */
+export type VcsDelegateBindings<TContext> = {
+  getCaps: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.get_caps']>;
+  open: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.open']>;
+  close: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.close']>;
+  cloneRepo: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.clone_repo']>;
+  getWorkdir: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.get_workdir']>;
+  getCurrentBranch: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.get_current_branch']
+  >;
+  listBranches: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.list_branches']>;
+  listLocalBranches: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.list_local_branches']
+  >;
+  createBranch: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.create_branch']>;
+  checkoutBranch: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.checkout_branch']
+  >;
+  ensureRemote: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.ensure_remote']>;
+  listRemotes: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.list_remotes']>;
+  removeRemote: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.remove_remote']>;
+  fetch: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.fetch']>;
+  fetchWithOptions: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.fetch_with_options']
+  >;
+  push: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.push']>;
+  pullFfOnly: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.pull_ff_only']>;
+  commit: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.commit']>;
+  commitIndex: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.commit_index']>;
+  getStatusSummary: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.get_status_summary']
+  >;
+  getStatusPayload: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.get_status_payload']
+  >;
+  listCommits: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.list_commits']>;
+  diffFile: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.diff_file']>;
+  diffCommit: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.diff_commit']>;
+  getConflictDetails: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.get_conflict_details']
+  >;
+  checkoutConflictSide: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.checkout_conflict_side']
+  >;
+  writeMergeResult: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.write_merge_result']
+  >;
+  stagePatch: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.stage_patch']>;
+  discardPaths: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.discard_paths']>;
+  applyReversePatch: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.apply_reverse_patch']
+  >;
+  deleteBranch: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.delete_branch']>;
+  renameBranch: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.rename_branch']>;
+  mergeIntoCurrent: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.merge_into_current']
+  >;
+  mergeAbort: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.merge_abort']>;
+  mergeContinue: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.merge_continue']>;
+  isMergeInProgress: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.is_merge_in_progress']
+  >;
+  setBranchUpstream: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.set_branch_upstream']
+  >;
+  getBranchUpstream: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.get_branch_upstream']
+  >;
+  hardResetHead: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.hard_reset_head']>;
+  resetSoftTo: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.reset_soft_to']>;
+  getIdentity: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.get_identity']>;
+  setIdentityLocal: NonNullable<
+    VcsTypes.VcsDelegates<TContext>['vcs.set_identity_local']
+  >;
+  listStashes: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.list_stashes']>;
+  stashPush: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.stash_push']>;
+  stashApply: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.stash_apply']>;
+  stashPop: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.stash_pop']>;
+  stashDrop: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.stash_drop']>;
+  stashShow: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.stash_show']>;
+  cherryPick: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.cherry_pick']>;
+  revertCommit: NonNullable<VcsTypes.VcsDelegates<TContext>['vcs.revert_commit']>;
+};
+
+/** Enumerates the class-friendly method names recognized by `VcsDelegateBase`. */
+export type VcsDelegateMethodName = keyof VcsDelegateBindings<PluginRuntimeContext>;
+
+/** Maps one delegate class method to the SDK runtime RPC key it implements. */
+export const VCS_DELEGATE_METHOD_MAPPINGS = {
+  getCaps: 'vcs.get_caps',
+  open: 'vcs.open',
+  close: 'vcs.close',
+  cloneRepo: 'vcs.clone_repo',
+  getWorkdir: 'vcs.get_workdir',
+  getCurrentBranch: 'vcs.get_current_branch',
+  listBranches: 'vcs.list_branches',
+  listLocalBranches: 'vcs.list_local_branches',
+  createBranch: 'vcs.create_branch',
+  checkoutBranch: 'vcs.checkout_branch',
+  ensureRemote: 'vcs.ensure_remote',
+  listRemotes: 'vcs.list_remotes',
+  removeRemote: 'vcs.remove_remote',
+  fetch: 'vcs.fetch',
+  fetchWithOptions: 'vcs.fetch_with_options',
+  push: 'vcs.push',
+  pullFfOnly: 'vcs.pull_ff_only',
+  commit: 'vcs.commit',
+  commitIndex: 'vcs.commit_index',
+  getStatusSummary: 'vcs.get_status_summary',
+  getStatusPayload: 'vcs.get_status_payload',
+  listCommits: 'vcs.list_commits',
+  diffFile: 'vcs.diff_file',
+  diffCommit: 'vcs.diff_commit',
+  getConflictDetails: 'vcs.get_conflict_details',
+  checkoutConflictSide: 'vcs.checkout_conflict_side',
+  writeMergeResult: 'vcs.write_merge_result',
+  stagePatch: 'vcs.stage_patch',
+  discardPaths: 'vcs.discard_paths',
+  applyReversePatch: 'vcs.apply_reverse_patch',
+  deleteBranch: 'vcs.delete_branch',
+  renameBranch: 'vcs.rename_branch',
+  mergeIntoCurrent: 'vcs.merge_into_current',
+  mergeAbort: 'vcs.merge_abort',
+  mergeContinue: 'vcs.merge_continue',
+  isMergeInProgress: 'vcs.is_merge_in_progress',
+  setBranchUpstream: 'vcs.set_branch_upstream',
+  getBranchUpstream: 'vcs.get_branch_upstream',
+  hardResetHead: 'vcs.hard_reset_head',
+  resetSoftTo: 'vcs.reset_soft_to',
+  getIdentity: 'vcs.get_identity',
+  setIdentityLocal: 'vcs.set_identity_local',
+  listStashes: 'vcs.list_stashes',
+  stashPush: 'vcs.stash_push',
+  stashApply: 'vcs.stash_apply',
+  stashPop: 'vcs.stash_pop',
+  stashDrop: 'vcs.stash_drop',
+  stashShow: 'vcs.stash_show',
+  cherryPick: 'vcs.cherry_pick',
+  revertCommit: 'vcs.revert_commit',
+} as const satisfies Record<
+  VcsDelegateMethodName,
+  keyof VcsTypes.VcsDelegates<PluginRuntimeContext>
+>;
+
+/** Resolves the RPC method implemented by one class-friendly delegate method. */
+export type VcsDelegateRpcMethodName<TMethodName extends VcsDelegateMethodName> =
+  (typeof VCS_DELEGATE_METHOD_MAPPINGS)[TMethodName];
+
+/** Describes the callable prototype surface required by `toDelegates()`. */
+export type VcsDelegatePrototype<TContext> = {
+  [TMethodName in keyof VcsDelegateBindings<TContext>]: VcsDelegateBindings<TContext>[TMethodName];
+};
+
+/** Stores the exact `vcs.*` delegate object shape produced from class methods. */
+export type VcsDelegateAssignments<TContext> = {
+  [TMethodName in VcsDelegateMethodName as VcsDelegateRpcMethodName<TMethodName>]?:
+    VcsDelegateBindings<TContext>[TMethodName];
+};