nano-git 0.1.0

package/dist/transport/http/smart-http.mjs

@@ -0,0 +1,176 @@
+import { createReceivePackService } from "../server/receive-pack/service.mjs";
+import { UploadPackServiceError } from "../server/upload-pack/types.mjs";
+import { createUploadPackService } from "../server/upload-pack/service.mjs";
+//#region src/transport/http/smart-http.ts
+/**
+* Smart HTTP 服务端适配器
+*
+* 类似 git-http-backend 的职责，但基于标准 Web API 的 Request/Response：
+* - 接收标准 Request，返回标准 Response
+* - 框架无关（Bun、Deno、Node.js、Cloudflare Workers 等均可直接使用）
+* - 无自定义 HTTP 抽象层
+*
+* 当前支持：
+* - upload-pack（fetch + ls-refs）
+* - receive-pack（push）
+*
+* 路由：
+* - GET /info/refs?service=git-upload-pack   → v2 能力广告
+* - GET /info/refs?service=git-receive-pack  → v1 ref 广告
+* - POST /git-upload-pack                    → ls-refs / fetch 命令
+* - POST /git-receive-pack                   → receive-pack（push）处理
+*
+* @see https://git-scm.com/docs/git-http-backend
+*/
+/**
+* 创建 HTTP 错误响应
+*/
+function errorResponse(status, message) {
+	return new Response(`${status} ${message}\n`, {
+		status,
+		headers: { "Content-Type": "text/plain" }
+	});
+}
+/**
+* 验证 info/refs 请求
+*/
+function validateInfoRefsRequest(method, service) {
+	if (method !== "GET") return errorResponse(405, "Method Not Allowed: info/refs requires GET");
+	if (service !== "git-upload-pack" && service !== "git-receive-pack") return errorResponse(400, `Unknown service: ${service}`);
+	return null;
+}
+/**
+* 验证服务请求（/git-upload-pack 等）
+*/
+function validateServiceRequest(method, contentType) {
+	if (method !== "POST") return errorResponse(405, "Method Not Allowed: service requires POST");
+	if (!contentType || !contentType.startsWith("application/x-git-")) return errorResponse(400, "Bad Content-Type for Git service request");
+	return null;
+}
+/**
+* 处理 info/refs GET 请求
+*
+* 根据 service 类型返回相应的 ref 广告：
+* - git-upload-pack：返回 v2 能力广告
+* - git-receive-pack：始终返回 v1 ref 广告
+*
+* @param service - 服务类型（git-upload-pack 或 git-receive-pack）
+*/
+function handleInfoRefs(service, uploadPackService, receivePackService) {
+	if (service === "git-receive-pack") {
+		const advertise = receivePackService.advertise();
+		return new Response(advertise, {
+			status: 200,
+			headers: {
+				"Content-Type": "application/x-git-receive-pack-advertisement",
+				"Cache-Control": "no-cache"
+			}
+		});
+	}
+	const advertise = uploadPackService.advertise();
+	const contentType = service.startsWith("git-") ? `application/x-${service}-advertisement` : `application/x-git-${service}-advertisement`;
+	return new Response(advertise, {
+		status: 200,
+		headers: {
+			"Content-Type": contentType,
+			"Cache-Control": "no-cache"
+		}
+	});
+}
+/**
+* 处理 /git-upload-pack POST 请求
+*/
+async function handleUploadPack(body, uploadPackService) {
+	if (body.length === 0) return errorResponse(400, "Request body is required");
+	let response;
+	try {
+		response = uploadPackService.handleRequest(body);
+	} catch (err) {
+		if (err instanceof UploadPackServiceError) return errorResponse(400, err.message);
+		throw err;
+	}
+	return new Response(response, {
+		status: 200,
+		headers: {
+			"Content-Type": "application/x-git-upload-pack-result",
+			"Cache-Control": "no-cache"
+		}
+	});
+}
+/**
+* 创建 Smart HTTP 处理函数
+*
+* 类似 git-http-backend 的核心入口。
+* 接收标准 Request，返回标准 Response，框架无关。
+*
+* @param backend - 仓库后端
+* @returns HTTP 处理函数
+*
+* @example
+* ```ts
+* // Bun.serve — 直接作为 fetch 处理器
+* import { createSmartHttpHandler } from "nano-git/transport/http";
+* import { openRepository } from "nano-git/repository/file";
+* Bun.serve({ port: 8080, fetch: createSmartHttpHandler(openRepository("/repo")) });
+*
+* // Node.js http
+* import { createServer } from "node:http";
+* const handler = createSmartHttpHandler(openRepository("/repo"));
+* createServer(async (req, res) => {
+*   const url = new URL(req.url ?? "/", `http://${req.headers.host}`);
+*   const body = await new Promise<Buffer>((resolve) => {
+*     const chunks: Buffer[] = [];
+*     req.on("data", (c) => chunks.push(c));
+*     req.on("end", () => resolve(Buffer.concat(chunks)));
+*   });
+*   const response = await handler(new Request(url, {
+*     method: req.method,
+*     headers: Object.fromEntries(Object.entries(req.headers).map(([k, v]) => [k, String(v)])),
+*     body: req.method === "POST" ? body : undefined,
+*   }));
+*   res.writeHead(response.status, Object.fromEntries(response.headers));
+*   res.end(Buffer.from(await response.arrayBuffer()));
+* }).listen(8080);
+*
+* // Cloudflare Workers / Deno
+* export default { fetch: createSmartHttpHandler(openRepository("./repo")) };
+* ```
+*/
+function createSmartHttpHandler(backend) {
+	const uploadPackService = createUploadPackService(backend);
+	const receivePackService = createReceivePackService(backend);
+	return async (request) => {
+		const url = new URL(request.url);
+		const { pathname: path } = url;
+		const method = request.method;
+		if (path === "/info/refs" || path.endsWith("/info/refs")) {
+			const service = url.searchParams.get("service");
+			const validationError = validateInfoRefsRequest(method, service);
+			if (validationError) return validationError;
+			const isV2 = (request.headers.get("git-protocol") ?? "").includes("version=2");
+			if (service === "git-upload-pack" && !isV2) return errorResponse(400, "Only Git Wire Protocol v2 is supported for fetch. Set Git-Protocol: version=2 header.");
+			return handleInfoRefs(service, uploadPackService, receivePackService);
+		}
+		if (path === "/git-upload-pack" || path.endsWith("/git-upload-pack")) {
+			const validationError = validateServiceRequest(method, request.headers.get("content-type"));
+			if (validationError) return validationError;
+			return handleUploadPack(Buffer.from(await request.arrayBuffer()), uploadPackService);
+		}
+		if (path === "/git-receive-pack" || path.endsWith("/git-receive-pack")) {
+			const validationError = validateServiceRequest(method, request.headers.get("content-type"));
+			if (validationError) return validationError;
+			const body = Buffer.from(await request.arrayBuffer());
+			const response = receivePackService.handleRequest(body);
+			return new Response(response, {
+				status: 200,
+				headers: {
+					"Content-Type": "application/x-git-receive-pack-result",
+					"Cache-Control": "no-cache"
+				}
+			});
+		}
+		return errorResponse(404, `Not Found: ${path}`);
+	};
+}
+//#endregion
+export { createSmartHttpHandler };

package/dist/transport/http/types.d.mts

@@ -0,0 +1,27 @@
+//#region src/transport/http/types.d.ts
+/**
+ * Smart HTTP 适配层类型定义
+ *
+ * 基于标准 Web API 的 Request/Response，框架无关。
+ * 任何支持 Web 标准的环境均可直接使用：
+ * - Bun.serve / Deno.serve
+ * - Cloudflare Workers
+ * - Node.js 18+ (global This)
+ * - 各框架的适配层（Hono、Express 等）
+ */
+/**
+ * Smart HTTP 处理函数签名
+ *
+ * 接收标准 Request，返回标准 Response。
+ * 纯函数风格，不绑定任何 HTTP 框架。
+ *
+ * @example
+ * ```ts
+ * const handler: SmartHttpHandler = async (req: Request) => {
+ *   return new Response("OK", { status: 200 });
+ * };
+ * ```
+ */
+type SmartHttpHandler = (request: Request) => Response | Promise<Response>;
+//#endregion
+export { SmartHttpHandler };

package/dist/transport/index.d.mts

@@ -0,0 +1,9 @@
+import { ApplyRefUpdatesResult, RefMappingRule, RefUpdateRejection, RemoteRef } from "./protocol/types.mjs";
+import { PktLine, PktLineData, PktLineDelimiter, PktLineError, PktLineFlush, PktLineResponseEnd, encodeDelimiterPkt, encodeFlushPkt, encodePktLine, encodeResponseEndPkt, parsePktLines, splitPktLinesFromBuffer } from "./protocol/pkt-line.mjs";
+import { ParsedRefSpec, RefSpecError, mappingRuleToParsedSpec, parseRefSpec, parsedSpecToMappingRule } from "./protocol/refspec.mjs";
+import { getLocalRefs, remoteRefsToMap } from "./protocol/ref-collection.mjs";
+import { mapRefName, matchesRefSpec } from "./protocol/ref-match.mjs";
+import { CollectReachableMissing, collectReachable, isAncestor, peelTagChain } from "./protocol/object-graph.mjs";
+import { SideBandError, extractPackfile, extractProgress, extractRawPackfile } from "./protocol/side-band.mjs";
+import { RefUpdateError, applyRefUpdates, isRefNamespaceRequiringFastForward, resolveBranchTargetHash } from "./protocol/update-refs.mjs";
+export { type ApplyRefUpdatesResult, type CollectReachableMissing, type ParsedRefSpec, type PktLine, type PktLineData, type PktLineDelimiter, PktLineError, type PktLineFlush, type PktLineResponseEnd, type RefMappingRule, RefSpecError, RefUpdateError, type RefUpdateRejection, type RemoteRef, SideBandError, applyRefUpdates, collectReachable, encodeDelimiterPkt, encodeFlushPkt, encodePktLine, encodeResponseEndPkt, extractPackfile, extractProgress, extractRawPackfile, getLocalRefs, isAncestor, isRefNamespaceRequiringFastForward, mapRefName, mappingRuleToParsedSpec, matchesRefSpec, parsePktLines, parseRefSpec, parsedSpecToMappingRule, peelTagChain, remoteRefsToMap, resolveBranchTargetHash, splitPktLinesFromBuffer };

package/dist/transport/index.mjs

@@ -0,0 +1,8 @@
+import { PktLineError, encodeDelimiterPkt, encodeFlushPkt, encodePktLine, encodeResponseEndPkt, parsePktLines, splitPktLinesFromBuffer } from "./protocol/pkt-line.mjs";
+import { collectReachable, isAncestor, peelTagChain } from "./protocol/object-graph.mjs";
+import { getLocalRefs, remoteRefsToMap } from "./protocol/ref-collection.mjs";
+import { RefUpdateError, applyRefUpdates, isRefNamespaceRequiringFastForward, resolveBranchTargetHash } from "./protocol/update-refs.mjs";
+import { RefSpecError, mappingRuleToParsedSpec, parseRefSpec, parsedSpecToMappingRule } from "./protocol/refspec.mjs";
+import { mapRefName, matchesRefSpec } from "./protocol/ref-match.mjs";
+import { SideBandError, extractPackfile, extractProgress, extractRawPackfile } from "./protocol/side-band.mjs";
+export { PktLineError, RefSpecError, RefUpdateError, SideBandError, applyRefUpdates, collectReachable, encodeDelimiterPkt, encodeFlushPkt, encodePktLine, encodeResponseEndPkt, extractPackfile, extractProgress, extractRawPackfile, getLocalRefs, isAncestor, isRefNamespaceRequiringFastForward, mapRefName, mappingRuleToParsedSpec, matchesRefSpec, parsePktLines, parseRefSpec, parsedSpecToMappingRule, peelTagChain, remoteRefsToMap, resolveBranchTargetHash, splitPktLinesFromBuffer };

package/dist/transport/protocol/object-graph.d.mts

@@ -0,0 +1,63 @@
+import { SHA1 } from "../../core/types.mjs";
+import { ObjectSource } from "../../core/types/odb.mjs";
+
+//#region src/transport/protocol/object-graph.d.ts
+/** collectReachable 遇到缺失对象时的策略 */
+type CollectReachableMissing = "throw" | "skip" | "skip-commit-parents";
+/**
+ * 从多个起始点收集所有可达对象哈希
+ *
+ * @param source - 对象源
+ * @param roots - 起始哈希列表
+ * @param missing - 遇到缺失对象时的行为，透传给 collectReachableFrom
+ * @param shallowBoundaries - 已知 shallow 边界集合（可选）
+ * @returns 可达对象哈希集合
+ *
+ * @example
+ * ```ts
+ * const reachable = collectReachable(source, [headHash]);
+ * console.log(reachable.size);
+ * ```
+ */
+declare function collectReachable(source: ObjectSource, roots: SHA1[], missing?: CollectReachableMissing, shallowBoundaries?: Set<SHA1>): Set<SHA1>;
+/**
+ * 沿 tag 链解引用到最底层的非 tag 对象
+ *
+ * 遍历 tag → object → 直到遇到非 tag 对象（commit/tree/blob）。
+ * 用于 fast-forward 预检：refs/{heads,tags} 之外的命名空间
+ * （如 refs/custom/*）允许存储 tag 对象，解引用后才能正确比较祖先关系。
+ *
+ * @param source - 对象源
+ * @param hash - 起点哈希
+ * @param shallowBoundaries - 已知 shallow 边界集合（可选）
+ * @returns 解引用后的非 tag 对象哈希，若对象缺失返回 hash 本身
+ *
+ * @example
+ * ```ts
+ * const peeled = peelTagChain(source, tagHash);
+ * ```
+ */
+declare function peelTagChain(source: ObjectSource, hash: SHA1, shallowBoundaries?: Set<SHA1>): SHA1;
+/**
+ * 检查 oldHash 是否为 newHash 的祖先 commit（或二者相等）
+ *
+ * 从 newHash 出发沿 parent 链回溯，若能找到 oldHash 则返回 true。
+ * 支持 tag 对象解引用：非 refs/{heads,tags} 命名空间允许存储 tag 对象，
+ * 比较时将 oldHash 和 newHash 沿 tag 链解引用到最底层对象（应为 commit）。
+ *
+ * @param source - 对象源
+ * @param oldHash - 旧的（远端）对象哈希
+ * @param newHash - 新的（本地）目标对象哈希
+ * @param shallowBoundaries - 已知 shallow 边界集合（可选）
+ * @returns oldHash 是否为 newHash 的祖先
+ *
+ * @example
+ * ```ts
+ * if (isAncestor(source, oldTip, newTip)) {
+ *   console.log("Fast-forward possible");
+ * }
+ * ```
+ */
+declare function isAncestor(source: ObjectSource, oldHash: SHA1, newHash: SHA1, shallowBoundaries?: Set<SHA1>): boolean;
+//#endregion
+export { CollectReachableMissing, collectReachable, isAncestor, peelTagChain };

package/dist/transport/protocol/object-graph.mjs

@@ -0,0 +1,149 @@
+import { ObjectNotFoundError } from "../../core/errors.mjs";
+import { tryReadObject } from "../../objects/raw.mjs";
+//#region src/transport/protocol/object-graph.ts
+/**
+* 对象图算法（纯 ObjectSource 版本）
+*
+* 提供 commit ancestry / peel / reachability 等图算法基础设施，
+* 供 fetch 和 push 等上层模块共同依赖，避免基础算法挂在场景编排模块中。
+*
+* @example
+* ```ts
+* import { isAncestor, collectReachable } from "./object-graph.ts";
+*
+* const reachable = collectReachable(store, [headHash]);
+* const isFF = isAncestor(store, oldTip, newTip);
+* ```
+*/
+function throwIfMissingObject(source, hash, missing, viaCommitParent, shallowBoundaries) {
+	if (viaCommitParent && shallowBoundaries?.has(hash)) return;
+	if (missing === "throw" || missing === "skip-commit-parents") throw new ObjectNotFoundError(hash, `Object ${hash} is missing from the local store. The local repository may be incomplete or corrupted.`);
+}
+/**
+* 从指定哈希出发，递归收集所有可达对象哈希
+*
+* @param source - 对象源
+* @param hash - 起始对象哈希
+* @param reachable - 用于收集结果的可达集合
+* @param missing - 遇到缺失对象时的行为：
+*   - `"skip"`（默认）：静默跳过，用于远程排除计算
+*   - `"throw"`：任意缺失均抛出错误
+*   - `"skip-commit-parents"`：仅沿 commit parent 边缺失时跳过（shallow 场景）
+* @param viaCommitParent - 当前边是否来自 commit 的 parent 引用
+*/
+function collectReachableFrom(source, hash, reachable, missing = "skip", shallowBoundaries, viaCommitParent = false) {
+	if (reachable.has(hash)) return;
+	const obj = tryReadObject(source, hash);
+	if (obj === void 0) {
+		throwIfMissingObject(source, hash, missing, viaCommitParent, shallowBoundaries);
+		return;
+	}
+	reachable.add(hash);
+	switch (obj.type) {
+		case "blob": return;
+		case "tree":
+			for (const entry of obj.entries) collectReachableFrom(source, entry.hash, reachable, missing, shallowBoundaries, false);
+			return;
+		case "commit":
+			collectReachableFrom(source, obj.tree, reachable, missing, shallowBoundaries, false);
+			for (const parent of obj.parents) collectReachableFrom(source, parent, reachable, missing, shallowBoundaries, true);
+			return;
+		case "tag":
+			collectReachableFrom(source, obj.object, reachable, missing, shallowBoundaries, false);
+			return;
+	}
+}
+/**
+* 从多个起始点收集所有可达对象哈希
+*
+* @param source - 对象源
+* @param roots - 起始哈希列表
+* @param missing - 遇到缺失对象时的行为，透传给 collectReachableFrom
+* @param shallowBoundaries - 已知 shallow 边界集合（可选）
+* @returns 可达对象哈希集合
+*
+* @example
+* ```ts
+* const reachable = collectReachable(source, [headHash]);
+* console.log(reachable.size);
+* ```
+*/
+function collectReachable(source, roots, missing = "skip", shallowBoundaries) {
+	const reachable = /* @__PURE__ */ new Set();
+	for (const hash of roots) collectReachableFrom(source, hash, reachable, missing, shallowBoundaries, false);
+	return reachable;
+}
+/**
+* 沿 tag 链解引用到最底层的非 tag 对象
+*
+* 遍历 tag → object → 直到遇到非 tag 对象（commit/tree/blob）。
+* 用于 fast-forward 预检：refs/{heads,tags} 之外的命名空间
+* （如 refs/custom/*）允许存储 tag 对象，解引用后才能正确比较祖先关系。
+*
+* @param source - 对象源
+* @param hash - 起点哈希
+* @param shallowBoundaries - 已知 shallow 边界集合（可选）
+* @returns 解引用后的非 tag 对象哈希，若对象缺失返回 hash 本身
+*
+* @example
+* ```ts
+* const peeled = peelTagChain(source, tagHash);
+* ```
+*/
+function peelTagChain(source, hash, shallowBoundaries) {
+	let current = hash;
+	while (true) {
+		const obj = tryReadObject(source, current);
+		if (obj === void 0) {
+			if (shallowBoundaries?.has(current)) return current;
+			return current;
+		}
+		if (obj.type !== "tag") return current;
+		current = obj.object;
+	}
+}
+/**
+* 检查 oldHash 是否为 newHash 的祖先 commit（或二者相等）
+*
+* 从 newHash 出发沿 parent 链回溯，若能找到 oldHash 则返回 true。
+* 支持 tag 对象解引用：非 refs/{heads,tags} 命名空间允许存储 tag 对象，
+* 比较时将 oldHash 和 newHash 沿 tag 链解引用到最底层对象（应为 commit）。
+*
+* @param source - 对象源
+* @param oldHash - 旧的（远端）对象哈希
+* @param newHash - 新的（本地）目标对象哈希
+* @param shallowBoundaries - 已知 shallow 边界集合（可选）
+* @returns oldHash 是否为 newHash 的祖先
+*
+* @example
+* ```ts
+* if (isAncestor(source, oldTip, newTip)) {
+*   console.log("Fast-forward possible");
+* }
+* ```
+*/
+function isAncestor(source, oldHash, newHash, shallowBoundaries) {
+	if (oldHash === newHash) return true;
+	const peeledOld = peelTagChain(source, oldHash, shallowBoundaries);
+	const peeledNew = peelTagChain(source, newHash, shallowBoundaries);
+	if (peeledOld === peeledNew) return true;
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [peeledNew];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current === peeledOld) return true;
+		if (visited.has(current)) continue;
+		visited.add(current);
+		const obj = tryReadObject(source, current);
+		if (obj === void 0) {
+			if (current === peeledOld) return true;
+			if (shallowBoundaries?.has(current)) return true;
+			return false;
+		}
+		if (obj.type !== "commit") continue;
+		for (const parent of obj.parents) if (!visited.has(parent)) queue.push(parent);
+	}
+	return false;
+}
+//#endregion
+export { collectReachable, isAncestor, peelTagChain };

package/dist/transport/protocol/pkt-line.d.mts

@@ -0,0 +1,109 @@
+import { GitError } from "../../core/errors.mjs";
+
+//#region src/transport/protocol/pkt-line.d.ts
+/** pkt-line 解码结果 */
+interface PktLineData {
+  type: "data";
+  /** 负载数据（不含 4 字节长度前缀） */
+  payload: Buffer;
+}
+interface PktLineFlush {
+  type: "flush";
+}
+interface PktLineDelimiter {
+  type: "delimiter";
+}
+interface PktLineResponseEnd {
+  type: "response-end";
+}
+/** 解析后的 pkt-line 类型 */
+type PktLine = PktLineData | PktLineFlush | PktLineDelimiter | PktLineResponseEnd;
+/**
+ * pkt-line 协议错误
+ *
+ * 当 pkt-line 数据格式不符合 Git 协议规范时抛出。
+ */
+declare class PktLineError extends GitError {
+  constructor(message: string);
+}
+/**
+ * 编码 pkt-line 数据帧
+ *
+ * 将 payload 编码为 pkt-line 格式："XXXX<payload>"
+ * 其中 XXXX 是含 4 字节前缀的总长度（十六进制）。
+ *
+ * @param payload - 负载数据（字符串或 Buffer）
+ * @returns pkt-line 编码后的 Buffer
+ *
+ * @example
+ * ```ts
+ * const buf = encodePktLine("hello");
+ * console.log(buf.toString("utf-8")); // => "0009hello"
+ * ```
+ */
+declare function encodePktLine(payload: string | Buffer): Buffer;
+/**
+ * 生成 flush-pkt
+ *
+ * @returns Buffer("0000")
+ *
+ * @example
+ * ```ts
+ * const buf = encodeFlushPkt();
+ * console.log(buf.toString("utf-8")); // => "0000"
+ * ```
+ */
+declare function encodeFlushPkt(): Buffer;
+/**
+ * 生成 delimiter-pkt（协议 v2）
+ *
+ * @returns Buffer("0001")
+ */
+declare function encodeDelimiterPkt(): Buffer;
+/**
+ * 生成 response-end-pkt（协议 v2）
+ *
+ * @returns Buffer("0002")
+ */
+declare function encodeResponseEndPkt(): Buffer;
+/**
+ * 解析 pkt-line 编码的完整数据流
+ *
+ * 将包含一个或多个 pkt-line 帧的 Buffer 解析为 PktLine 数组。
+ *
+ * @param data - 完整的 pkt-line 编码数据
+ * @returns 解析后的 PktLine 列表
+ *
+ * @example
+ * ```ts
+ * const lines = parsePktLines(Buffer.from("0009hello0000", "utf-8"));
+ * // lines[0] = { type: "data", payload: Buffer("hello") }
+ * // lines[1] = { type: "flush" }
+ * ```
+ */
+declare function parsePktLines(data: Buffer): PktLine[];
+/**
+ * 解析 pkt-line 编码的数据流，将有效帧与尾部原始二进制数据分离
+ *
+ * 与 {@link parsePktLines} 不同，此函数不会因尾部存在非 pkt-line 原始数据而抛出错误，
+ * 而是将剩余数据作为 trailing 返回。适用于解析非 side-band 编码的 upload-pack 响应：
+ * pkt-line 头部（ACK/NAK）+ 尾部原始 packfile 数据。
+ *
+ * @param data - 可能包含尾部原始数据的 pkt-line 编码 buffer
+ * @returns 解析出的帧列表和尾部原始数据
+ *
+ * @example
+ * ```ts
+ * const { lines, trailing } = splitPktLinesFromBuffer(
+ *   Buffer.concat([encodePktLine("NAK\n"), rawPackfile]),
+ * );
+ * // lines[0] = { type: "data", payload: Buffer("NAK\n") }
+ * // trailing = <raw packfile>
+ * ```
+ */
+declare function splitPktLinesFromBuffer(data: Buffer): {
+  lines: PktLine[];
+  trailing: Buffer;
+};
+//#endregion
+export { PktLine, PktLineData, PktLineDelimiter, PktLineError, PktLineFlush, PktLineResponseEnd, encodeDelimiterPkt, encodeFlushPkt, encodePktLine, encodeResponseEndPkt, parsePktLines, splitPktLinesFromBuffer };