nano-git 0.1.0

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

@@ -0,0 +1,70 @@
+import { GitAuthor, ObjectType, SHA1 } from "../../core/types.mjs";
+
+//#region src/repository/ops/ref-types.d.ts
+/**
+ * 仓库引用相关操作
+ */
+interface RepositoryRefOperations {
+  /**
+   * 更新引用（ref）
+   *
+   * 等价于 `git update-ref <ref> <hash>`
+   */
+  updateRef(ref: string, hash: SHA1): void;
+  /**
+   * 读取引用（ref）
+   *
+   * 等价于 `git rev-parse <ref>`
+   */
+  readRef(ref: string): SHA1 | null;
+  /**
+   * 获取当前检出的分支名
+   *
+   * detached HEAD 时返回 null。
+   */
+  getCurrentBranch(): string | null;
+  /**
+   * 创建分支
+   *
+   * 未提供目标哈希时，默认基于当前 HEAD。
+   */
+  createBranch(name: string, hash?: SHA1): void;
+  /**
+   * 读取分支引用
+   */
+  readBranch(name: string): SHA1 | null;
+  /**
+   * 列出所有分支名
+   */
+  listBranches(): string[];
+  /**
+   * 删除分支
+   */
+  deleteBranch(name: string): void;
+  /**
+   * 创建轻量标签
+   *
+   * 未提供目标哈希时，默认指向当前 HEAD。
+   */
+  createTag(name: string, hash?: SHA1): void;
+  /**
+   * 创建附注标签（annotated tag）
+   *
+   * 返回 tag 对象自身的哈希。
+   */
+  createAnnotatedTag(name: string, target: SHA1, message: string, tagger: GitAuthor, objectType?: ObjectType): SHA1;
+  /**
+   * 读取标签引用
+   */
+  readTag(name: string): SHA1 | null;
+  /**
+   * 列出所有标签名
+   */
+  listTags(): string[];
+  /**
+   * 删除标签
+   */
+  deleteTag(name: string): void;
+}
+//#endregion
+export { RepositoryRefOperations };

package/dist/repository/tree/tree-patch.d.mts

@@ -0,0 +1,64 @@
+import { SHA1 } from "../../core/types.mjs";
+import { ObjectDatabase } from "../../core/types/odb.mjs";
+
+//#region src/repository/tree/tree-patch.d.ts
+/**
+ * Tree patch 操作定义
+ *
+ * - `upsert`: 路径不存在则创建，存在则覆盖。通过 mode 区分文件类型：
+ *   - `"100644"` 普通文件
+ *   - `"100755"` 可执行文件
+ *   - `"120000"` 符号链接
+ * - `delete`: 删除文件、符号链接或目录条目。目录条目删除仅移除 parent tree 引用。
+ * - `rename`: 移动文件、符号链接或目录到新路径。源路径不存在则抛出异常。
+ *   目录 rename 只移动 tree entry 引用，子树内容（tree hash）不变。
+ */
+type TreePatchOp = {
+  readonly op: "upsert";
+  readonly path: string;
+  readonly mode: string;
+  readonly hash: SHA1;
+} | {
+  readonly op: "delete";
+  readonly path: string;
+} | {
+  readonly op: "rename";
+  readonly from: string;
+  readonly to: string;
+};
+/**
+ * Tree patch 结果
+ */
+interface TreePatchResult {
+  /** 新的根 tree 哈希 */
+  readonly rootHash: SHA1;
+  /** 本次操作新写入的所有 tree 对象哈希（包含中间节点） */
+  readonly writtenTrees: readonly SHA1[];
+}
+/**
+ * 对已有 tree 执行增量 patch 操作
+ *
+ * 算法描述：
+ * 1. 验证所有操作的路径格式
+ * 2. 将 ops 按 rename 操作分割为若干连续段
+ * 3. 段内 upsert/delete 保持现有 batch 算法（去重 + 递归）
+ * 4. rename 依次单独执行：查找源路径条目 → upsert(to) + delete(from) → batch 算法
+ * 5. 所有新/更新的条目按名称排序后写出新 tree
+ *
+ * @param objects - 对象存储
+ * @param rootHash - 根 tree 哈希
+ * @param ops - patch 操作列表（同路径多次操作最后一个生效，rename 按顺序逐一执行）
+ * @returns patch 结果
+ *
+ * @example
+ * ```ts
+ * const result = patchTree(objects, rootHash, [
+ *   { op: "upsert", path: "src/main.ts", mode: "100644", hash: blobHash },
+ *   { op: "delete", path: "old.ts" },
+ *   { op: "rename", from: "src/utils", to: "lib/utils" },
+ * ]);
+ * ```
+ */
+declare function patchTree(objects: ObjectDatabase, rootHash: SHA1, ops: TreePatchOp[]): TreePatchResult;
+//#endregion
+export { TreePatchOp, TreePatchResult, patchTree };

package/dist/repository/tree/tree-patch.mjs

@@ -0,0 +1,268 @@
+import { readObject, writeObject } from "../../objects/raw.mjs";
+//#region src/repository/tree/tree-patch.ts
+/**
+* 增量式 Tree Patch 操作
+*
+* 在不完整重新构造整棵树的前提下，对现有 tree 打补丁，
+* 只更新受影响的路径，支持增、删、改、重命名操作。
+*
+* 核心策略：
+* - 声明式 patch 列表，同路径多次操作最后一个生效
+* - 自动创建缺失的中间目录（类似 mkdir -p）
+* - delete 支持文件/符号链接/目录条目
+* - rename 支持文件/符号链接/目录（直接移动 tree 引用，无需递归重写子树）
+* - rename 按顺序逐一处理，upsert/delete 段内保持 batch 算法
+* - 不存在的路径 delete/rename 会抛出异常
+*/
+/**
+* 对已有 tree 执行增量 patch 操作
+*
+* 算法描述：
+* 1. 验证所有操作的路径格式
+* 2. 将 ops 按 rename 操作分割为若干连续段
+* 3. 段内 upsert/delete 保持现有 batch 算法（去重 + 递归）
+* 4. rename 依次单独执行：查找源路径条目 → upsert(to) + delete(from) → batch 算法
+* 5. 所有新/更新的条目按名称排序后写出新 tree
+*
+* @param objects - 对象存储
+* @param rootHash - 根 tree 哈希
+* @param ops - patch 操作列表（同路径多次操作最后一个生效，rename 按顺序逐一执行）
+* @returns patch 结果
+*
+* @example
+* ```ts
+* const result = patchTree(objects, rootHash, [
+*   { op: "upsert", path: "src/main.ts", mode: "100644", hash: blobHash },
+*   { op: "delete", path: "old.ts" },
+*   { op: "rename", from: "src/utils", to: "lib/utils" },
+* ]);
+* ```
+*/
+function patchTree(objects, rootHash, ops) {
+	if (ops.length === 0) return {
+		rootHash,
+		writtenTrees: []
+	};
+	for (const op of ops) if (op.op === "rename") {
+		validatePath(op.from);
+		validatePath(op.to);
+	} else validatePath(op.path);
+	const result = processOpsSequentially(objects, rootHash, ops);
+	return {
+		rootHash: result.hash,
+		writtenTrees: result.written
+	};
+}
+/**
+* 顺序执行 ops，rename 打断 batch
+*
+* 将连续的非 rename op 聚合成 batch，用现有递归算法处理；
+* rename op 单独执行，每次在当前 tree 状态上查找源路径并转换为 upsert+delete。
+*/
+function processOpsSequentially(objects, rootHash, ops) {
+	let currentHash = rootHash;
+	const allWritten = [];
+	let currentBatch = [];
+	function flushBatch() {
+		if (currentBatch.length === 0) return;
+		const result = applyPatchBatch(objects, currentHash, currentBatch);
+		currentHash = result.hash;
+		allWritten.push(...result.written);
+		currentBatch = [];
+	}
+	for (const op of ops) if (op.op === "rename") {
+		flushBatch();
+		if (op.from === op.to) continue;
+		const entry = findEntryByPath(objects, currentHash, op.from);
+		if (entry === null) throw new Error(`Cannot rename '${op.from}': path does not exist`);
+		const renameOps = [{
+			op: "upsert",
+			path: op.to,
+			mode: entry.mode,
+			hash: entry.hash
+		}, {
+			op: "delete",
+			path: op.from
+		}];
+		const result = applyPatchBatch(objects, currentHash, renameOps);
+		currentHash = result.hash;
+		allWritten.push(...result.written);
+	} else currentBatch.push(op);
+	flushBatch();
+	return {
+		hash: currentHash,
+		written: allWritten
+	};
+}
+/**
+* 在 tree 中查找路径对应的条目
+*
+* 沿路径依次读取 tree 对象，最后一段返回目标条目。
+* 中间段必须为目录（mode "40000"），否则抛出异常。
+*/
+function findEntryByPath(objects, treeHash, path) {
+	const segments = path.split("/");
+	let currentHash = treeHash;
+	for (let i = 0; i < segments.length; i++) {
+		const obj = readObject(objects, currentHash);
+		if (obj.type !== "tree") throw new Error(`Expected tree at '${segments.slice(0, i).join("/") || "/"}', got '${obj.type}'`);
+		const entry = obj.entries.find((e) => e.name === segments[i]);
+		if (!entry) return null;
+		if (i === segments.length - 1) return entry;
+		if (entry.mode !== "40000") throw new Error(`Cannot access '${segments.slice(0, i + 1).join("/")}': not a directory (mode: ${entry.mode})`);
+		currentHash = entry.hash;
+	}
+	return null;
+}
+/**
+* 验证 Git tree 路径格式
+*/
+function validatePath(path) {
+	if (path === "") throw new Error("Path must not be empty");
+	if (path.startsWith("/")) throw new Error(`Path must not start with '/': ${path}`);
+	if (path.endsWith("/")) throw new Error(`Path must not end with '/': ${path}`);
+	if (path.includes("//")) throw new Error(`Path must not contain consecutive slashes: ${path}`);
+	const segments = path.split("/");
+	for (const segment of segments) if (segment === "." || segment === "..") throw new Error(`Path must not contain '.' or '..': ${path}`);
+}
+/**
+* 按路径去重，同路径最后一个操作生效
+*
+* 仅处理 upsert/delete（rename 由顺序执行引擎单独处理，不会传给此函数）。
+*/
+function dedupOpsByPath(ops) {
+	const map = /* @__PURE__ */ new Map();
+	for (const op of ops) {
+		if (op.op === "rename") continue;
+		map.set(op.path, op);
+	}
+	return Array.from(map.values());
+}
+/**
+* 对一批 upsert/delete 操作执行增量 patch
+*
+* 这是原先的 patchTree 实现，提取为内部函数供顺序执行引擎调用。
+* 该函数不处理 rename 操作——调用方保证传入的 ops 不含 rename。
+*/
+function applyPatchBatch(objects, rootHash, ops) {
+	if (ops.length === 0) return {
+		hash: rootHash,
+		written: []
+	};
+	const upsertedPaths = /* @__PURE__ */ new Set();
+	for (const op of ops) if (op.op === "upsert") upsertedPaths.add(op.path);
+	const result = applyPatchRecursive(objects, rootHash, dedupOpsByPath(ops), "", upsertedPaths);
+	return {
+		hash: result.hash,
+		written: result.written
+	};
+}
+/**
+* 递归应用 patch 操作到指定子树
+*
+* @param objects - 对象存储
+* @param treeHash - 当前子树哈希（null 表示新建空树）
+* @param ops - 去重后的操作列表（作用域为当前子树）
+* @param prefix - 当前路径前缀（用于错误消息和 upsertedPaths 匹配）
+* @param upsertedPaths - 原始操作列表中所有 upsert 的全路径集合
+*/
+function applyPatchRecursive(objects, treeHash, ops, prefix, upsertedPaths) {
+	const existingEntries = readTreeEntries(objects, treeHash);
+	const { directOps, deeperOps } = groupOpsByDepth(ops);
+	const finalEntryMap = /* @__PURE__ */ new Map();
+	const writtenTrees = [];
+	for (const [name, childOps] of deeperOps) {
+		const existingEntry = existingEntries.find((e) => e.name === name);
+		const existingHash = existingEntry?.hash ?? null;
+		if (existingEntry !== void 0 && existingEntry.mode !== "40000") throw new Error(`Cannot access '${prefix}${name}': existing entry is not a directory (mode: ${existingEntry.mode})`);
+		if (existingHash === null) {
+			const hasUpsertInBatch = childOps.some((op) => op.op === "upsert") || childOps.some((op) => op.op === "delete" && upsertedPaths.has(`${prefix}${name}/${op.path}`));
+			if (childOps.every((op) => op.op === "delete") && !hasUpsertInBatch) {
+				const samplePath = `${prefix}${name}/${childOps[0].path}`;
+				throw new Error(`Cannot delete '${samplePath}': path does not exist`);
+			}
+		}
+		const result = applyPatchRecursive(objects, existingHash, childOps, `${prefix}${name}/`, upsertedPaths);
+		writtenTrees.push(...result.written);
+		finalEntryMap.set(name, {
+			mode: "40000",
+			name,
+			hash: result.hash
+		});
+	}
+	const deletedNames = /* @__PURE__ */ new Set();
+	for (const op of directOps) if (op.op === "upsert") finalEntryMap.set(op.path, {
+		mode: op.mode,
+		name: op.path,
+		hash: op.hash
+	});
+	else if (op.op === "delete") {
+		const fullPath = prefix + op.path;
+		const existsInExisting = existingEntries.some((e) => e.name === op.path);
+		const existsInCreated = finalEntryMap.has(op.path);
+		const existsInBatch = upsertedPaths.has(fullPath);
+		if (!existsInExisting && !existsInCreated && !existsInBatch) throw new Error(`Cannot delete '${prefix}${op.path}': path does not exist`);
+		deletedNames.add(op.path);
+		finalEntryMap.delete(op.path);
+	}
+	const finalEntries = [];
+	for (const entry of existingEntries) if (!finalEntryMap.has(entry.name) && !deletedNames.has(entry.name)) finalEntries.push(entry);
+	for (const [, entry] of finalEntryMap) finalEntries.push(entry);
+	finalEntries.sort((a, b) => a.name.localeCompare(b.name));
+	const newHash = writeObject(objects, {
+		type: "tree",
+		entries: finalEntries
+	});
+	writtenTrees.push(newHash);
+	return {
+		hash: newHash,
+		written: writtenTrees
+	};
+}
+/**
+* 读取 tree 对象的条目列表
+*/
+function readTreeEntries(objects, treeHash) {
+	if (treeHash === null) return [];
+	const obj = readObject(objects, treeHash);
+	if (obj.type !== "tree") throw new Error(`Expected tree object, got '${obj.type}' for hash '${treeHash}'`);
+	return obj.entries;
+}
+/**
+* 将操作列表按路径深度分组
+*
+* 返回：
+* - directOps: 路径只有一段的操作（直接作用于当前层）
+* - deeperOps: 路径有多段的操作，按首段分组
+*/
+function groupOpsByDepth(ops) {
+	const directOps = [];
+	const deeperOps = /* @__PURE__ */ new Map();
+	for (const op of ops) {
+		if (op.op === "rename") continue;
+		const segments = op.path.split("/");
+		const first = segments[0];
+		if (segments.length === 1) directOps.push(op);
+		else {
+			const rest = segments.slice(1).join("/");
+			const childOp = op.op === "upsert" ? {
+				op: "upsert",
+				path: rest,
+				mode: op.mode,
+				hash: op.hash
+			} : {
+				op: "delete",
+				path: rest
+			};
+			const existing = deeperOps.get(first) ?? [];
+			existing.push(childOp);
+			deeperOps.set(first, existing);
+		}
+	}
+	return {
+		directOps,
+		deeperOps
+	};
+}
+//#endregion
+export { patchTree };

package/dist/repository/tree/tree-walk.d.mts

@@ -0,0 +1,46 @@
+import { SHA1, TreeEntry } from "../../core/types.mjs";
+import { ObjectDatabase } from "../../core/types/odb.mjs";
+
+//#region src/repository/tree/tree-walk.d.ts
+/**
+ * 带完整路径的 tree 条目
+ */
+interface TreeEntryWithPath extends TreeEntry {
+  /** 相对于根 tree 的完整路径 */
+  readonly path: string;
+}
+/**
+ * 递归遍历 tree，返回所有条目的展平列表（深度优先，按目录排序）
+ *
+ * @param objects - 对象存储
+ * @param rootHash - 根 tree 哈希
+ * @returns 带完整路径的条目列表
+ *
+ * @example
+ * ```ts
+ * const files = readTree(objects, treeHash);
+ * for (const entry of files) {
+ *   console.log(entry.path, entry.mode, entry.hash);
+ * }
+ * ```
+ */
+declare function readTree(objects: ObjectDatabase, rootHash: SHA1): TreeEntryWithPath[];
+/**
+ * 递归遍历 tree，对每个条目调用回调函数
+ *
+ * 深度优先，先遍历子目录（所有条目按目录分组输出）。
+ *
+ * @param objects - 对象存储
+ * @param rootHash - 根 tree 哈希
+ * @param visit - 对每个条目的回调
+ *
+ * @example
+ * ```ts
+ * walkTree(objects, treeHash, (entry) => {
+ *   console.log(entry.path);
+ * });
+ * ```
+ */
+declare function walkTree(objects: ObjectDatabase, rootHash: SHA1, visit: (entry: TreeEntryWithPath) => void): void;
+//#endregion
+export { TreeEntryWithPath, readTree, walkTree };

package/dist/repository/tree/tree-walk.mjs

@@ -0,0 +1,65 @@
+import { readObject } from "../../objects/raw.mjs";
+//#region src/repository/tree/tree-walk.ts
+/**
+* Tree 遍历工具
+*
+* 提供展平的 tree 视图和递归遍历能力，
+* 补充 patchTree 只有增量修改能力的不足。
+*/
+/**
+* 递归遍历 tree，返回所有条目的展平列表（深度优先，按目录排序）
+*
+* @param objects - 对象存储
+* @param rootHash - 根 tree 哈希
+* @returns 带完整路径的条目列表
+*
+* @example
+* ```ts
+* const files = readTree(objects, treeHash);
+* for (const entry of files) {
+*   console.log(entry.path, entry.mode, entry.hash);
+* }
+* ```
+*/
+function readTree(objects, rootHash) {
+	const result = [];
+	walkTreeRecursive(objects, rootHash, "", result);
+	return result;
+}
+/**
+* 递归遍历 tree，对每个条目调用回调函数
+*
+* 深度优先，先遍历子目录（所有条目按目录分组输出）。
+*
+* @param objects - 对象存储
+* @param rootHash - 根 tree 哈希
+* @param visit - 对每个条目的回调
+*
+* @example
+* ```ts
+* walkTree(objects, treeHash, (entry) => {
+*   console.log(entry.path);
+* });
+* ```
+*/
+function walkTree(objects, rootHash, visit) {
+	walkTreeRecursive(objects, rootHash, "", void 0, visit);
+}
+function walkTreeRecursive(objects, treeHash, prefix, result, visit) {
+	const obj = readObject(objects, treeHash);
+	if (obj.type !== "tree") throw new Error(`Expected tree object, got '${obj.type}' for hash '${treeHash}'`);
+	for (const entry of obj.entries) {
+		const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+		const entryWithPath = {
+			mode: entry.mode,
+			name: entry.name,
+			hash: entry.hash,
+			path
+		};
+		if (result) result.push(entryWithPath);
+		if (visit) visit(entryWithPath);
+		if (entry.mode === "40000") walkTreeRecursive(objects, entry.hash, path, result, visit);
+	}
+}
+//#endregion
+export { readTree, walkTree };

package/dist/repository/tree/tree-writer.mjs

@@ -0,0 +1,68 @@
+import { writeObject } from "../../objects/raw.mjs";
+import { lstatSync, readFileSync, readdirSync, readlinkSync } from "node:fs";
+import { join } from "node:path";
+//#region src/repository/tree/tree-writer.ts
+/**
+* 工作目录到 tree 对象的写入工具
+*/
+/**
+* 递归将目录写入 tree 对象
+*
+* 遍历目录，为每个文件创建 blob，为每个子目录递归创建 tree，
+* 为符号链接创建包含目标路径的 blob，最后将所有条目组合成一个 tree 对象。
+*
+* @param store - 对象存储
+* @param dirPath - 要写入的目录路径
+* @returns 根 tree 对象哈希
+*
+* @example
+* ```ts
+* const hash = writeTreeRecursive(repo.objects, "/tmp/project");
+* console.log(hash);
+* ```
+*/
+function writeTreeRecursive(store, dirPath) {
+	const entries = [];
+	const items = readdirSync(dirPath).sort();
+	for (const name of items) {
+		if (name === ".git") continue;
+		const fullPath = join(dirPath, name);
+		const stat = lstatSync(fullPath);
+		if (stat.isDirectory()) {
+			const subtreeHash = writeTreeRecursive(store, fullPath);
+			entries.push({
+				mode: "40000",
+				name,
+				hash: subtreeHash
+			});
+		} else if (stat.isSymbolicLink()) {
+			const target = readlinkSync(fullPath);
+			const blobHash = writeObject(store, {
+				type: "blob",
+				content: Buffer.from(target, "utf-8")
+			});
+			entries.push({
+				mode: "120000",
+				name,
+				hash: blobHash
+			});
+		} else if (stat.isFile()) {
+			const blobHash = writeObject(store, {
+				type: "blob",
+				content: readFileSync(fullPath)
+			});
+			const mode = stat.mode & 73 ? "100755" : "100644";
+			entries.push({
+				mode,
+				name,
+				hash: blobHash
+			});
+		}
+	}
+	return writeObject(store, {
+		type: "tree",
+		entries
+	});
+}
+//#endregion
+export { writeTreeRecursive };

package/dist/repository/types.d.mts

@@ -0,0 +1,36 @@
+import { RefStore } from "../core/types/refs.mjs";
+import { ShallowStore } from "../core/types/shallow.mjs";
+import { ObjectDatabase } from "../core/types/odb.mjs";
+import { RepositoryPackSupport } from "../backend/types.mjs";
+import { RepoImportOperations } from "./import/import-session-types.mjs";
+import { RepositoryFetchOperations } from "./ops/fetch-types.mjs";
+import { RepositoryMaintenanceOperations } from "./ops/maintenance-types.mjs";
+import { RepositoryFsObjectOperations, RepositoryObjectOperations } from "./ops/object-types.mjs";
+import { RepositoryPushOperations } from "./ops/push-types.mjs";
+import { RepositoryRefOperations } from "./ops/ref-types.mjs";
+
+//#region src/repository/types.d.ts
+/**
+ * Git 仓库接口
+ */
+interface Repository extends RepositoryObjectOperations, RepositoryRefOperations, RepositoryMaintenanceOperations, RepositoryPushOperations, RepositoryFetchOperations, RepoImportOperations {
+  /** Git 对象数据库（raw-first） */
+  readonly objects: ObjectDatabase;
+  /** Git 引用存储 */
+  readonly refs: RefStore;
+  /** Packfile 支持 */
+  readonly packs: RepositoryPackSupport | null;
+  /** Git shallow 边界存储 */
+  readonly shallow: ShallowStore;
+  /** .git 目录路径（内存仓库为 null） */
+  readonly gitDir: string | null;
+}
+/**
+ * 带文件系统扩展能力的仓库接口
+ */
+interface FileRepository extends Repository, RepositoryFsObjectOperations {
+  /** .git 目录路径 */
+  readonly gitDir: string;
+}
+//#endregion
+export { FileRepository, Repository };

package/dist/sha1.d.mts

@@ -0,0 +1,4 @@
+import { ObjectType, SHA1, assertObjectType, sha1 } from "./core/types.mjs";
+import { hashData, hashObject } from "./core/hash-digest.mjs";
+import { isValidSHA1 } from "./core/hash-path.mjs";
+export { type ObjectType, type SHA1, assertObjectType, hashData, hashObject, isValidSHA1, sha1 };

package/dist/sha1.mjs

@@ -0,0 +1,4 @@
+import { assertObjectType, sha1 } from "./core/types.mjs";
+import { hashData, hashObject } from "./core/hash-digest.mjs";
+import { isValidSHA1 } from "./core/hash-path.mjs";
+export { assertObjectType, hashData, hashObject, isValidSHA1, sha1 };

package/dist/transport/client/receive-pack/http.d.mts

@@ -0,0 +1,33 @@
+import { GitError } from "../../../core/errors.mjs";
+import { GitServiceTransport } from "../../protocol/types.mjs";
+
+//#region src/transport/client/receive-pack/http.d.ts
+/**
+ * Smart HTTP 传输错误
+ *
+ * 当 HTTP 层面的传输出错时抛出（网络错误、非预期状态码等）。
+ */
+declare class SmartHttpError extends GitError {
+  readonly statusCode?: number | undefined;
+  constructor(message: string, statusCode?: number | undefined);
+}
+/**
+ * Smart HTTP 认证配置
+ */
+interface SmartHttpAuth {
+  readonly token?: string;
+  readonly headers?: Record<string, string>;
+}
+/**
+ * 创建 receive-pack HTTP 客户端
+ *
+ * @example
+ * ```ts
+ * const client = createReceivePackHttpClient("https://github.com/user/repo");
+ * const adv = await client.advertise();
+ * const raw = await client.request(body);
+ * ```
+ */
+declare function createReceivePackHttpClient(baseUrl: string, auth?: SmartHttpAuth): GitServiceTransport;
+//#endregion
+export { SmartHttpAuth, SmartHttpError, createReceivePackHttpClient };