nano-git 0.1.0

package/dist/repository/ops/fetch-url.mjs

@@ -0,0 +1,82 @@
+import { createRepoImportOperations } from "../import/import-session.mjs";
+import { parseRefSpec } from "../../transport/protocol/refspec.mjs";
+//#region src/repository/ops/fetch-url.ts
+/**
+* 仓库 fetch 内部编排
+*
+* 将 repo.fetch(url) 委托给 ImportSession 完成实际工作。
+*/
+/**
+* 按 URL fetch
+*/
+async function runFetchToUrl(backend, url, options) {
+	const ops = createRepoImportOperations(backend);
+	const source = {
+		url,
+		token: options?.token,
+		headers: options?.headers
+	};
+	const session = await ops.openImportSession(source);
+	if (options?.refSpecs) return applyCustomRefSpecs(session, options);
+	return applyDefaultMapping(session, options);
+}
+/**
+* 默认 fetch 映射：远端所有 refs → 本地同名 refs + HEAD 更新
+*/
+async function applyDefaultMapping(session, options) {
+	const plan = session.plan();
+	const branches = session.select("refs/heads/*");
+	if (branches.refs.length > 0) plan.materialize(branches).toNamespace("refs/heads/*", {
+		policy: { mode: "fast-forward" },
+		prune: options?.prune
+	});
+	if (!options?.noTags) {
+		const tags = session.select("refs/tags/*");
+		if (tags.refs.length > 0) plan.materialize(tags).toNamespace("refs/tags/*", { policy: { mode: "fast-forward" } });
+	}
+	const defaultBranch = session.defaultBranch();
+	if (defaultBranch.refs.length > 0) plan.materialize(defaultBranch).setHead();
+	return convertToFetchResult(await plan.apply());
+}
+/**
+* 自定义 refSpec 映射
+*/
+async function applyCustomRefSpecs(session, options) {
+	const plan = session.plan();
+	for (const specStr of options.refSpecs ?? []) {
+		const spec = parseRefSpec(specStr);
+		const srcPattern = spec.isWildcard ? `${spec.srcPattern}*` : spec.srcPattern;
+		const dstPattern = spec.isWildcard ? `${spec.dstPattern}*` : spec.dstPattern;
+		const isForce = specStr.startsWith("+") || spec.force || options.force;
+		const view = session.select(srcPattern);
+		if (view.refs.length > 0) {
+			const policy = isForce ? { mode: "replace" } : { mode: "fast-forward" };
+			plan.materialize(view).toNamespace(dstPattern, { policy });
+		}
+	}
+	return convertToFetchResult(await plan.apply());
+}
+function convertToFetchResult(result) {
+	const updatedRefs = [];
+	for (const [refName, newHash] of result.updatedRefs) updatedRefs.push({
+		refName,
+		oldHash: null,
+		newHash,
+		success: true,
+		forced: false
+	});
+	for (const refName of result.deletedRefs) updatedRefs.push({
+		refName,
+		oldHash: null,
+		newHash: null,
+		success: true,
+		forced: false
+	});
+	return {
+		updatedRefs,
+		objectCount: result.importedObjects,
+		progress: []
+	};
+}
+//#endregion
+export { runFetchToUrl };

package/dist/repository/ops/fs-object-operations.mjs

@@ -0,0 +1,31 @@
+import { writeTreeRecursive } from "../tree/tree-writer.mjs";
+import { readFileSync } from "node:fs";
+//#region src/repository/ops/fs-object-operations.ts
+/**
+* 仓库文件系统对象操作组装
+*/
+/**
+* 创建文件系统对象操作集合
+*
+* @param objects - 对象数据库
+* @param writeBlob - 基础 blob 写入能力
+* @returns 文件系统对象操作集合
+*
+* @example
+* ```ts
+* const fsOps = createRepositoryFsObjectOperations(objects, writeBlob);
+* const hash = fsOps.writeBlobFile("/tmp/file.txt");
+* ```
+*/
+function createRepositoryFsObjectOperations(objects, writeBlob) {
+	return {
+		writeBlobFile(filePath) {
+			return writeBlob(readFileSync(filePath));
+		},
+		writeTree(dirPath) {
+			return writeTreeRecursive(objects, dirPath);
+		}
+	};
+}
+//#endregion
+export { createRepositoryFsObjectOperations };

package/dist/repository/ops/maintenance-operations.mjs

@@ -0,0 +1,62 @@
+import { listReachableObjects } from "./reachability.mjs";
+//#region src/repository/ops/maintenance-operations.ts
+/**
+* 仓库打包与维护操作组装
+*
+* GC 编排策略：
+* 1. 如果有 pack 支持，先 repack 可达对象（替换旧 pack）
+* 2. 如果后端 ObjectDatabase 支持 delete，清理不可达的 loose 对象
+* 3. 刷新 pack 视图
+*
+* 不再依赖 RepositoryPackSupport.gc()——GC 是仓库层的编排职责，
+* RepositoryPackSupport 只负责 packfile 层面的读写。
+*/
+/**
+* 创建仓库维护相关操作
+*
+* @example
+* ```ts
+* const ops = createMaintenanceRepositoryOperations(objects, refs, packs);
+* const reachable = ops.listReachableObjects();
+* ```
+*/
+function createMaintenanceRepositoryOperations(objects, refs, packs) {
+	return {
+		writePack(hashes) {
+			if (!packs) throw new Error("Backend does not support packfile writes");
+			return packs.writeFromSource(objects, hashes ?? objects.list());
+		},
+		repack(options) {
+			if (!packs) throw new Error("Backend does not support repack");
+			const hashes = options?.hashes ? Array.from(options.hashes) : Array.from(objects.list());
+			const result = packs.repack(objects, {
+				hashes,
+				replaceExistingPacks: options?.replaceExistingPacks
+			});
+			if (options?.pruneLoose) for (const hash of hashes) objects.delete?.(hash);
+			packs.source.refresh();
+			return result;
+		},
+		listReachableObjects() {
+			return listReachableObjects(objects, refs);
+		},
+		gc(options) {
+			const reachable = listReachableObjects(objects, refs);
+			const reachableSet = new Set(reachable);
+			let result;
+			if (packs) {
+				result = packs.repack(objects, {
+					hashes: reachable,
+					replaceExistingPacks: options?.replaceExistingPacks
+				});
+				packs.source.refresh();
+			}
+			if (options?.pruneLoose ?? true) {
+				for (const hash of objects.list()) if (!reachableSet.has(hash)) objects.delete?.(hash);
+			}
+			return result;
+		}
+	};
+}
+//#endregion
+export { createMaintenanceRepositoryOperations };

package/dist/repository/ops/maintenance-types.d.mts

@@ -0,0 +1,42 @@
+import { SHA1 } from "../../core/types.mjs";
+import { PackBuildResult } from "../../pack/pack-builder-types.mjs";
+import { RepositoryGCOptions, RepositoryRepackOptions } from "../../backend/types.mjs";
+
+//#region src/repository/ops/maintenance-types.d.ts
+/**
+ * 仓库维护相关操作
+ */
+interface RepositoryMaintenanceOperations {
+  /**
+   * 将指定对象写入新的 packfile
+   *
+   * 未提供哈希列表时，默认打包仓库当前可见的全部对象。
+   */
+  writePack(hashes?: SHA1[]): PackBuildResult;
+  /**
+   * 重写仓库 pack 布局
+   *
+   * 默认行为：
+   * - 打包当前可见的全部对象
+   * - 删除旧 pack 文件
+   * - 保留 loose objects
+   */
+  repack(options?: RepositoryRepackOptions): PackBuildResult;
+  /**
+   * 列出从 HEAD、所有分支和所有标签可达的对象
+   */
+  listReachableObjects(): SHA1[];
+  /**
+   * 执行基于可达对象的 gc
+   *
+   * 默认行为：
+   * - 只保留从 HEAD、分支、标签可达的对象
+   * - 如果有 pack 支持：删除旧 pack 文件，创建包含可达对象的新 pack
+   * - 如果没有 pack 支持（如内存仓库）：只删除不可达对象
+   *
+   * @returns 有 pack 支持时返回新 pack 的构建结果，否则返回 undefined
+   */
+  gc(options?: RepositoryGCOptions): PackBuildResult | undefined;
+}
+//#endregion
+export { RepositoryMaintenanceOperations };

package/dist/repository/ops/object-operations.mjs

@@ -0,0 +1,65 @@
+import { hashObject } from "../../core/hash-digest.mjs";
+import { readObject, writeObject } from "../../objects/raw.mjs";
+import { createV2HttpTransport } from "../../transport/client/upload-pack/http.mjs";
+import { objectInfo } from "../../transport/client/upload-pack/object-info.mjs";
+import { patchTree } from "../tree/tree-patch.mjs";
+//#region src/repository/ops/object-operations.ts
+/**
+* 仓库对象操作组装
+*/
+/**
+* 创建仓库对象相关操作
+*
+* @example
+* ```ts
+* const ops = createObjectRepositoryOperations(store);
+* const hash = ops.writeBlob(Buffer.from("hello"));
+* ```
+*/
+function createObjectRepositoryOperations(objects) {
+	function writeBlob(data) {
+		return writeObject(objects, {
+			type: "blob",
+			content: data
+		});
+	}
+	return {
+		hashObject(data) {
+			return hashObject("blob", data);
+		},
+		writeBlob,
+		catFile(hash) {
+			return readObject(objects, hash);
+		},
+		catFileType(hash) {
+			return readObject(objects, hash).type;
+		},
+		listObjects() {
+			return objects.list();
+		},
+		createTree(entries) {
+			return writeObject(objects, {
+				type: "tree",
+				entries
+			});
+		},
+		createCommit(tree, parents, message, author, committer) {
+			return writeObject(objects, {
+				type: "commit",
+				tree,
+				parents,
+				author,
+				committer: committer ?? author,
+				message
+			});
+		},
+		patchTree(rootHash, ops) {
+			return patchTree(objects, rootHash, ops);
+		},
+		async fetchObjectInfo(url, oids, token) {
+			return objectInfo(createV2HttpTransport(url, { token }), oids);
+		}
+	};
+}
+//#endregion
+export { createObjectRepositoryOperations };

package/dist/repository/ops/object-types.d.mts

@@ -0,0 +1,109 @@
+import { GitAuthor, GitObject, SHA1, TreeEntry } from "../../core/types.mjs";
+import { ObjectInfoQueryResult } from "../../transport/client/upload-pack/object-info.mjs";
+import { TreePatchOp, TreePatchResult } from "../tree/tree-patch.mjs";
+
+//#region src/repository/ops/object-types.d.ts
+/**
+ * 仓库对象核心操作
+ */
+interface RepositoryObjectOperations {
+  /**
+   * 计算数据的 blob 哈希（不写入存储）
+   *
+   * 等价于 `git hash-object --stdin`
+   */
+  hashObject(data: Buffer): SHA1;
+  /**
+   * 将数据作为 blob 写入对象存储
+   *
+   * 等价于 `git hash-object -w --stdin`
+   */
+  writeBlob(data: Buffer): SHA1;
+  /**
+   * 读取对象
+   *
+   * 等价于 `git cat-file -p <hash>`
+   */
+  catFile(hash: SHA1): GitObject;
+  /**
+   * 获取对象类型
+   *
+   * 等价于 `git cat-file -t <hash>`
+   */
+  catFileType(hash: SHA1): string;
+  /**
+   * 列出仓库当前可见的所有对象哈希
+   *
+   * 返回值同时包含 loose objects 和 packed objects。
+   */
+  listObjects(): SHA1[];
+  /**
+   * 从 tree 条目列表创建 tree 对象
+   */
+  createTree(entries: TreeEntry[]): SHA1;
+  /**
+   * 创建 commit 对象
+   *
+   * 等价于 `git commit-tree <tree> -p <parent> -m <message>`
+   */
+  createCommit(tree: SHA1, parents: SHA1[], message: string, author: GitAuthor, committer?: GitAuthor): SHA1;
+  /**
+   * 对已有 tree 执行增量 patch 操作
+   *
+   * 无需完整重构整棵树，只更新受影响的路径。
+   * 支持增（upsert）、删（delete）、改（upsert）文件及符号链接，
+   * 自动创建缺失的中间目录。
+   *
+   * @param rootHash - 根 tree 哈希
+   * @param ops - patch 操作列表（同路径多次操作最后一个生效）
+   * @returns patch 结果
+   *
+   * @example
+   * ```ts
+   * const result = repo.patchTree(rootHash, [
+   *   { op: "upsert", path: "src/main.ts", mode: "100644", hash: blobHash },
+   *   { op: "delete", path: "old.ts" },
+   * ]);
+   * ```
+   */
+  patchTree(rootHash: SHA1, ops: TreePatchOp[]): TreePatchResult;
+  /**
+   * 查询远端对象信息（协议 v2 object-info）
+   *
+   * 批量查询远端对象的元数据（如 size），无需下载对象内容。
+   * 仅在远端支持 Git Wire 协议 v2 时可用。
+   *
+   * @param url - 远端仓库 URL
+   * @param oids - 要查询的 OID 列表
+   * @param token - 可选认证 token
+   * @returns 对象信息列表（含 size 等元数据）
+   *
+   * @example
+   * ```ts
+   * const result = await repo.fetchObjectInfo("https://github.com/user/repo", [
+   *   "95d09f2b10159347eece71399a7e2e907ea3df4f",
+   * ]);
+   * console.log(result.objects[0]?.size); // 文件大小
+   * ```
+   */
+  fetchObjectInfo(url: string, oids: string[], token?: string): Promise<ObjectInfoQueryResult>;
+}
+/**
+ * 文件系统对象操作扩展
+ */
+interface RepositoryFsObjectOperations {
+  /**
+   * 将文件作为 blob 写入对象存储
+   *
+   * 等价于 `git hash-object -w <file>`
+   */
+  writeBlobFile(filePath: string): SHA1;
+  /**
+   * 将目录递归写入 tree 对象
+   *
+   * 等价于 `git write-tree`（但基于指定目录而非暂存区）
+   */
+  writeTree(dirPath: string): SHA1;
+}
+//#endregion
+export { RepositoryFsObjectOperations, RepositoryObjectOperations };

package/dist/repository/ops/push-operations.mjs

@@ -0,0 +1,16 @@
+import "../../transport/client/receive-pack/push-error.mjs";
+import { runPushToUrl } from "./push-url.mjs";
+//#region src/repository/ops/push-operations.ts
+/**
+* 创建仓库 push 操作集合
+*
+* @param backend - 仓库后端
+* @returns push 操作集合
+*/
+function createPushRepositoryOperations(backend) {
+	return { async push(url, options) {
+		return runPushToUrl(backend, url, options);
+	} };
+}
+//#endregion
+export { createPushRepositoryOperations };

package/dist/repository/ops/push-resolution.mjs

@@ -0,0 +1,17 @@
+//#region src/repository/ops/push-resolution.ts
+/**
+* 解析 effective push shallow 边界
+*
+* 三态规则（`pushShallowBoundaries` 为 override，勿将 `[]` 当 falsy）：
+* - `options.pushShallowBoundaries === undefined`：回退 `backendShallow`（即 `backend.shallow.read()`）
+* - `options.pushShallowBoundaries === []`：显式无边界，不使用 `backend.shallow`
+* - `options.pushShallowBoundaries === [...]`：显式边界集合
+*
+* 输出为最终传给 transport 的 `shallowBoundaries` 数组；仅当 options 与 backend 均未提供时为 `undefined`。
+*/
+function resolveEffectivePushBoundaries(options, backendShallow) {
+	if (options?.pushShallowBoundaries !== void 0) return options.pushShallowBoundaries;
+	if (backendShallow !== void 0) return backendShallow;
+}
+//#endregion
+export { resolveEffectivePushBoundaries };

package/dist/repository/ops/push-types.d.mts

@@ -0,0 +1,72 @@
+import { SHA1 } from "../../core/types.mjs";
+
+//#region src/repository/ops/push-types.d.ts
+/**
+ * 仓库 push 操作选项
+ *
+ * 纯 push 行为参数，不包含传输层细节。
+ *
+ * 认证：支持 token/headers 透传到 transport。
+ * 边界：pushShallowBoundaries 是 repository 层语义（不是 transport 泄漏），优先级高于 backend.shallow。
+ */
+interface RepositoryPushOptions {
+  /**
+   * refspec 列表，格式如 "refs/heads/main:refs/heads/main"
+   * 默认为将当前分支推送到远端同名分支（等价于 `git push <url>`）
+   */
+  readonly refSpecs?: string[];
+  /** 是否强制推送（--force），等价于 refspec 的 + 前缀 */
+  readonly force?: boolean;
+  /** 认证 token（用于 bearer 或 basic auth），由 repository 层透传 */
+  readonly token?: string;
+  /** 自定义请求头，由 repository 层透传 */
+  readonly headers?: Record<string, string>;
+  /**
+   * 推送时已知的浅克隆边界（repository 层 override，非 transport 泄漏）。
+   * - 传入（含空数组 `[]`）即覆盖 `backend.shallow`，不再回退
+   * - 传 `[]` 表示显式不使用 `backend.shallow` 中的边界
+   * - 不传（`undefined`）才回退 `backend.shallow.read()`
+   */
+  readonly pushShallowBoundaries?: SHA1[];
+}
+/**
+ * 单条引用更新结果（repository 自有语义）
+ */
+interface PushRefUpdateResult {
+  /** 引用名称，如 "refs/heads/main" */
+  readonly refName: string;
+  /** 更新前的哈希（服务端原有值） */
+  readonly oldHash: SHA1 | null;
+  /** 更新后的哈希 */
+  readonly newHash: SHA1 | null;
+  /** 是否成功 */
+  readonly success: boolean;
+  /** 失败时的错误消息 */
+  readonly error?: string;
+  /** 是否强制更新 */
+  readonly forced: boolean;
+}
+/**
+ * 仓库 push 操作结果（repository 自有语义）
+ */
+interface RepositoryPushResult {
+  /** 已更新的引用列表 */
+  readonly pushedRefs: readonly PushRefUpdateResult[];
+  /** 推送的对象数量 */
+  readonly objectCount: number;
+  /** 服务端返回的进度消息 */
+  readonly progress: readonly string[];
+}
+/**
+ * 仓库 push 操作接口
+ */
+interface RepositoryPushOperations {
+  /**
+   * 推送到远端仓库
+   *
+   * 等价于 `git push <url>`。
+   */
+  push(url: string, options?: RepositoryPushOptions): Promise<RepositoryPushResult>;
+}
+//#endregion
+export { RepositoryPushOperations };

package/dist/repository/ops/push-url.mjs

@@ -0,0 +1,45 @@
+import { createReceivePackHttpClient } from "../../transport/client/receive-pack/http.mjs";
+import { push } from "../../transport/client/receive-pack/push.mjs";
+import { resolveEffectivePushBoundaries } from "./push-resolution.mjs";
+//#region src/repository/ops/push-url.ts
+/**
+* 仓库 push 内部编排
+*
+* 支持 preAdvertised、transportFactory 注入。
+* 使用 v1 receive-pack 协议进行推送。
+*/
+/**
+* 按 URL push（不依赖任何命名 endpoint 配置）
+*/
+async function runPushToUrl(backend, url, options, preAdvertised, transportFactory) {
+	return runPushWithUrl(backend, url, options, preAdvertised, transportFactory);
+}
+async function runPushWithUrl(backend, pushUrl, options, preAdvertised, transportFactory) {
+	const transport = (transportFactory ?? ((url) => createReceivePackHttpClient(url, {
+		token: options?.token,
+		headers: options?.headers
+	})))(pushUrl, options);
+	const advertisement = preAdvertised ?? await transport.advertise();
+	const transportResult = await push(backend.objects, backend.refs, transport, advertisement, {
+		refSpecs: options?.refSpecs,
+		force: options?.force,
+		shallowBoundaries: resolveEffectivePushBoundaries(options, backend.shallow.read())
+	});
+	return convertPushResult(transportResult.refUpdates, transportResult.objectCount, transportResult.progress);
+}
+function convertPushResult(refUpdates, objectCount, progress) {
+	return {
+		pushedRefs: refUpdates.map((u) => ({
+			refName: u.refName,
+			oldHash: u.oldHash,
+			newHash: u.newHash,
+			success: u.success,
+			error: u.error,
+			forced: u.forced ?? false
+		})),
+		objectCount,
+		progress
+	};
+}
+//#endregion
+export { runPushToUrl };

package/dist/repository/ops/reachability.mjs

@@ -0,0 +1,60 @@
+import { readObject } from "../../objects/raw.mjs";
+import { HEADS_PREFIX, HEAD_REF, TAGS_PREFIX } from "../../core/types/refs.mjs";
+import { resolveRefHash } from "../../refs/resolve.mjs";
+//#region src/repository/ops/reachability.ts
+/**
+* 仓库可达性遍历工具
+*
+* 负责从 refs 出发遍历所有可达 Git 对象。
+*/
+function listRootRefs(refs) {
+	const rootRefs = /* @__PURE__ */ new Set([HEAD_REF]);
+	for (const ref of refs.list(HEADS_PREFIX)) rootRefs.add(ref);
+	for (const ref of refs.list(TAGS_PREFIX)) rootRefs.add(ref);
+	return Array.from(rootRefs).sort();
+}
+function collectReachableObjectHashesFrom(source, hash, reachable) {
+	const stack = [hash];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (reachable.has(current)) continue;
+		reachable.add(current);
+		const obj = readObject(source, current);
+		switch (obj.type) {
+			case "blob": break;
+			case "tree":
+				for (const entry of obj.entries) if (!reachable.has(entry.hash)) stack.push(entry.hash);
+				break;
+			case "commit":
+				if (!reachable.has(obj.tree)) stack.push(obj.tree);
+				for (const parent of obj.parents) if (!reachable.has(parent)) stack.push(parent);
+				break;
+			case "tag":
+				if (!reachable.has(obj.object)) stack.push(obj.object);
+				break;
+		}
+	}
+}
+/**
+* 列出从 HEAD、所有分支和所有标签可达的对象哈希
+*
+* @param source - 对象源
+* @param refs - 引用存储
+* @returns 排序后的可达对象哈希列表
+*
+* @example
+* ```ts
+* const hashes = listReachableObjects(source, refs);
+* console.log(hashes.length);
+* ```
+*/
+function listReachableObjects(source, refs) {
+	const reachable = /* @__PURE__ */ new Set();
+	for (const ref of listRootRefs(refs)) {
+		const hash = resolveRefHash(refs, ref);
+		if (hash) collectReachableObjectHashesFrom(source, hash, reachable);
+	}
+	return Array.from(reachable).sort();
+}
+//#endregion
+export { listReachableObjects };

package/dist/repository/ops/ref-operations.mjs

@@ -0,0 +1,86 @@
+import { RepositoryError } from "../../core/errors.mjs";
+import { readObject, writeObject } from "../../objects/raw.mjs";
+import { HEADS_PREFIX, HEAD_REF, TAGS_PREFIX } from "../../core/types/refs.mjs";
+import { branchNameToRef, tagNameToRef } from "../../refs/names.mjs";
+import { resolveRefHash, resolveSymbolicRef, resolveTargetHash } from "../../refs/resolve.mjs";
+//#region src/repository/ops/ref-operations.ts
+/**
+* 仓库引用操作组装
+*/
+function ensureRefDoesNotExist(backend, ref, kind, name) {
+	if (backend.refs.read(ref) !== null) throw new RepositoryError(`${kind} already exists: ${name}`);
+}
+function listShortRefs(backend, prefix) {
+	return backend.refs.list(prefix).map((ref) => ref.slice(prefix.length));
+}
+/**
+* 创建仓库引用相关操作
+*
+* @example
+* ```ts
+* const ops = createRefRepositoryOperations(backend);
+* ops.createBranch("main");
+* ```
+*/
+function createRefRepositoryOperations(backend) {
+	const { objects, refs } = backend;
+	function getCurrentBranch() {
+		const symbolicRef = resolveSymbolicRef(refs, HEAD_REF);
+		if (!symbolicRef || !symbolicRef.startsWith("refs/heads/")) return null;
+		return symbolicRef.slice(HEADS_PREFIX.length);
+	}
+	return {
+		updateRef(ref, hash) {
+			refs.write(ref, hash);
+		},
+		readRef(ref) {
+			return resolveRefHash(refs, ref);
+		},
+		getCurrentBranch,
+		createBranch(name, hash) {
+			const ref = branchNameToRef(name);
+			ensureRefDoesNotExist(backend, ref, "Branch", name);
+			refs.write(ref, resolveTargetHash(refs, hash));
+		},
+		readBranch(name) {
+			return resolveRefHash(refs, branchNameToRef(name));
+		},
+		listBranches() {
+			return listShortRefs(backend, HEADS_PREFIX);
+		},
+		deleteBranch(name) {
+			if (getCurrentBranch() === name) throw new RepositoryError(`Cannot delete current branch: ${name}`);
+			refs.delete(branchNameToRef(name));
+		},
+		createTag(name, hash) {
+			const ref = tagNameToRef(name);
+			ensureRefDoesNotExist(backend, ref, "Tag", name);
+			refs.write(ref, resolveTargetHash(refs, hash));
+		},
+		createAnnotatedTag(name, target, message, tagger, objectType) {
+			const ref = tagNameToRef(name);
+			ensureRefDoesNotExist(backend, ref, "Tag", name);
+			const tagHash = writeObject(objects, {
+				type: "tag",
+				object: target,
+				objectType: objectType ?? readObject(objects, target).type,
+				tag: name,
+				tagger,
+				message
+			});
+			refs.write(ref, tagHash);
+			return tagHash;
+		},
+		readTag(name) {
+			return resolveRefHash(refs, tagNameToRef(name));
+		},
+		listTags() {
+			return listShortRefs(backend, TAGS_PREFIX);
+		},
+		deleteTag(name) {
+			refs.delete(tagNameToRef(name));
+		}
+	};
+}
+//#endregion
+export { createRefRepositoryOperations };