git-remote-ops 0.1.0

package/types/deps/jsr.io/@std/text/1.0.18/closest_string.d.ts

@@ -0,0 +1,42 @@
+/** Options for {@linkcode closestString}. */
+export interface ClosestStringOptions {
+    /**
+     * Whether the distance should include case.
+     *
+     * @default {false}
+     */
+    caseSensitive?: boolean;
+    /**
+     * A custom comparison function to use for comparing strings.
+     *
+     * @param a The first string for comparison.
+     * @param b The second string for comparison.
+     * @returns The distance between the two strings.
+     * @default {levenshteinDistance}
+     */
+    compareFn?: (a: string, b: string) => number;
+}
+/**
+ * Finds the most similar string from an array of strings.
+ *
+ * By default, calculates the distance between words using the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}.
+ *
+ * @example Usage
+ * ```ts
+ * import { closestString } from "@std/text/closest-string";
+ * import { assertEquals } from "@std/assert";
+ *
+ * const possibleWords = ["length", "size", "blah", "help"];
+ * const suggestion = closestString("hep", possibleWords);
+ *
+ * assertEquals(suggestion, "help");
+ * ```
+ *
+ * @param givenWord The string to measure distance against
+ * @param possibleWords The string-array to pick the closest string from
+ * @param options The options for the comparison.
+ * @returns The closest string
+ */
+export declare function closestString(givenWord: string, possibleWords: ReadonlyArray<string>, options?: ClosestStringOptions): string;
+//# sourceMappingURL=closest_string.d.ts.map

package/types/deps/jsr.io/@std/text/1.0.18/closest_string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"closest_string.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/closest_string.ts"],"names":[],"mappings":"AAIA,6CAA6C;AAC7C,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC9C;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,MAAM,EACjB,aAAa,EAAE,aAAa,CAAC,MAAM,CAAC,EACpC,OAAO,CAAC,EAAE,oBAAoB,GAC7B,MAAM,CAwBR"}

package/types/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Calculates the
+ * {@link https://en.wikipedia.org/wiki/Levenshtein_distance | Levenshtein distance}
+ * between two strings.
+ *
+ * > [!NOTE]
+ * > The complexity of this function is O(m * n), where m and n are the lengths
+ * > of the two strings. It's recommended to limit the length and validate input
+ * > if arbitrarily accepting input.
+ *
+ * @example Usage
+ * ```ts
+ * import { levenshteinDistance } from "@std/text/levenshtein-distance";
+ * import { assertEquals } from "@std/assert";
+ *
+ * assertEquals(levenshteinDistance("aa", "bb"), 2);
+ * ```
+ * @param str1 The first string.
+ * @param str2 The second string.
+ * @returns The Levenshtein distance between the two strings.
+ */
+export declare function levenshteinDistance(str1: string, str2: string): number;
+//# sourceMappingURL=levenshtein_distance.d.ts.map

package/types/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"levenshtein_distance.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/text/1.0.18/levenshtein_distance.ts"],"names":[],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAWtE"}

package/types/errors.d.ts

@@ -0,0 +1,73 @@
+declare const PackParseError_base: import("better-result").TaggedErrorClass<"PackParseError", {
+    reason: string;
+    message: string;
+    offset?: number;
+    cause?: unknown;
+}>;
+/** Anything that goes wrong while parsing a packfile or applying a delta. */
+export declare class PackParseError extends PackParseError_base {
+}
+declare const ObjectDecodeError_base: import("better-result").TaggedErrorClass<"ObjectDecodeError", {
+    reason: string;
+    message: string;
+    objectType?: string;
+    sha?: string;
+    cause?: unknown;
+}>;
+/** Raised when a commit/tree body fails structural validation. */
+export declare class ObjectDecodeError extends ObjectDecodeError_base {
+}
+declare const PktLineError_base: import("better-result").TaggedErrorClass<"PktLineError", {
+    reason: string;
+    message: string;
+    offset?: number;
+    cause?: unknown;
+}>;
+/** Malformed pkt-line framing (bad length prefix or truncation). */
+export declare class PktLineError extends PktLineError_base {
+}
+declare const UploadPackError_base: import("better-result").TaggedErrorClass<"UploadPackError", {
+    reason: string;
+    message: string;
+    cause?: unknown;
+}>;
+/** Server returned a `git-upload-pack` response we couldn't interpret. */
+export declare class UploadPackError extends UploadPackError_base {
+}
+declare const TransportError_base: import("better-result").TaggedErrorClass<"TransportError", {
+    method: string;
+    url: string;
+    message: string;
+    status?: number;
+    statusText?: string;
+    cause?: unknown;
+}>;
+/** Anything HTTP — network failure, non-2xx status, body-read error. */
+export declare class TransportError extends TransportError_base {
+}
+declare const RefNotFoundError_base: import("better-result").TaggedErrorClass<"RefNotFoundError", {
+    ref: string;
+    message: string;
+}>;
+/** The requested ref didn't appear in the server's advertisement. */
+export declare class RefNotFoundError extends RefNotFoundError_base {
+}
+declare const ObjectNotFoundError_base: import("better-result").TaggedErrorClass<"ObjectNotFoundError", {
+    sha: string;
+    message: string;
+}>;
+/** An object referenced by sha wasn't present in the materialized store. */
+export declare class ObjectNotFoundError extends ObjectNotFoundError_base {
+}
+declare const PathNotFoundError_base: import("better-result").TaggedErrorClass<"PathNotFoundError", {
+    path: string;
+    message: string;
+    treeSha?: string;
+}>;
+/** Tree-walk couldn't reach the requested path. */
+export declare class PathNotFoundError extends PathNotFoundError_base {
+}
+/** Discriminated union of every error this library returns. */
+export type GitRemoteOpsError = PackParseError | ObjectDecodeError | PktLineError | UploadPackError | TransportError | RefNotFoundError | ObjectNotFoundError | PathNotFoundError;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/types/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";YAiBU,MAAM;aACL,MAAM;aACN,MAAM;YACP,OAAO;;AALjB,6EAA6E;AAC7E,qBAAa,cAAe,SAAQ,mBAKhC;CAAG;;YAIG,MAAM;aACL,MAAM;iBACF,MAAM;UACb,MAAM;YACJ,OAAO;;AANjB,kEAAkE;AAClE,qBAAa,iBAAkB,SAAQ,sBAMnC;CAAG;;YAIG,MAAM;aACL,MAAM;aACN,MAAM;YACP,OAAO;;AALjB,oEAAoE;AACpE,qBAAa,YAAa,SAAQ,iBAK9B;CAAG;;YAIG,MAAM;aACL,MAAM;YACP,OAAO;;AAJjB,0EAA0E;AAC1E,qBAAa,eAAgB,SAAQ,oBAIjC;CAAG;;YAIG,MAAM;SACT,MAAM;aACF,MAAM;aACN,MAAM;iBACF,MAAM;YACX,OAAO;;AAPjB,wEAAwE;AACxE,qBAAa,cAAe,SAAQ,mBAOhC;CAAG;;SAIA,MAAM;aACF,MAAM;;AAHjB,qEAAqE;AACrE,qBAAa,gBAAiB,SAAQ,qBAGlC;CAAG;;SAIA,MAAM;aACF,MAAM;;AAHjB,4EAA4E;AAC5E,qBAAa,mBAAoB,SAAQ,wBAGrC;CAAG;;UAIC,MAAM;aACH,MAAM;cACL,MAAM;;AAJlB,mDAAmD;AACnD,qBAAa,iBAAkB,SAAQ,sBAInC;CAAG;AAEP,+DAA+D;AAC/D,MAAM,MAAM,iBAAiB,GACzB,cAAc,GACd,iBAAiB,GACjB,YAAY,GACZ,eAAe,GACf,cAAc,GACd,gBAAgB,GAChB,mBAAmB,GACnB,iBAAiB,CAAC"}

package/types/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @module git-remote-ops
+ *
+ * Public entry point. Re-exports the {@link RemoteGit} client, the
+ * {@link Logger}, every {@link GitRemoteOpsError} subclass, and the shared
+ * type vocabulary. The CLI ships separately under `./cli`.
+ */
+export { RemoteGit } from "./client.js";
+export { Logger, NULL_LOGGER } from "./logger.js";
+export type { LoggerOptions, LogLevel, Metrics } from "./logger.js";
+export { ObjectDecodeError, ObjectNotFoundError, PackParseError, PathNotFoundError, PktLineError, RefNotFoundError, TransportError, UploadPackError, } from "./errors.js";
+export type { GitRemoteOpsError } from "./errors.js";
+export type { CommitInfo, DiagnosticFn, FetchCommitOptions, GitObject, GitObjectMap, GitObjectType, RemoteGitOptions, ServerProfile, TreeEntry, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAClD,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,EACL,iBAAiB,EACjB,mBAAmB,EACnB,cAAc,EACd,iBAAiB,EACjB,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,eAAe,GAChB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,YAAY,EACV,UAAU,EACV,YAAY,EACZ,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,aAAa,EACb,gBAAgB,EAChB,aAAa,EACb,SAAS,GACV,MAAM,YAAY,CAAC"}

package/types/logger.d.ts

@@ -0,0 +1,70 @@
+export type LogLevel = "silent" | "info" | "debug" | "trace";
+export interface LoggerOptions {
+    level?: LogLevel;
+    sink?: (line: string) => void;
+    collectMetrics?: boolean;
+    color?: boolean;
+    timestamps?: boolean;
+}
+export interface Metrics {
+    httpRequests: number;
+    httpBytesIn: number;
+    httpBytesOut: number;
+    httpDurationMs: number;
+    packObjects: number;
+    packBytes: number;
+    packParseMs: number;
+    byType: Record<"commit" | "tree" | "blob" | "tag", number>;
+}
+/** Pretty-print a byte count with binary-prefix units. */
+export declare function formatBytes(n: number): string;
+/** Pretty-print a millisecond duration, scaling unit to magnitude. */
+export declare function formatDuration(ms: number): string;
+/**
+ * Levelled logger with namespaced children and shared metrics.
+ *
+ * Children share their parent's `metrics` object so that any `recordHttp` /
+ * `recordPack` call anywhere in the tree contributes to the same totals
+ * surfaced by {@link Logger.summary}.
+ */
+export declare class Logger {
+    readonly level: LogLevel;
+    readonly metrics: Metrics;
+    private sink;
+    private namespace;
+    private collect;
+    private color;
+    private timestamps;
+    private epoch;
+    constructor(options?: LoggerOptions, namespace?: string);
+    /** Spawn a logger that prefixes its messages with `parent.namespace + "." + namespace`. */
+    child(namespace: string): Logger;
+    private enabled;
+    private paint;
+    private emit;
+    /** Emit at `info`. No-op if level is `silent`. */
+    info(message: string): void;
+    /** Emit at `debug`. No-op unless level ≥ `debug`. */
+    debug(message: string): void;
+    /** Emit at `trace`. No-op unless level is `trace`. */
+    trace(message: string): void;
+    /** Time an async op; emits at `level` with duration. */
+    time<T>(level: Exclude<LogLevel, "silent">, label: string, fn: () => Promise<T>): Promise<T>;
+    /** Add one HTTP request's totals to {@link Logger.metrics}. */
+    recordHttp(opts: {
+        bytesIn: number;
+        bytesOut: number;
+        durationMs: number;
+    }): void;
+    /** Add one parsed pack's totals to {@link Logger.metrics}. */
+    recordPack(opts: {
+        bytes: number;
+        durationMs: number;
+        byType: Record<"commit" | "tree" | "blob" | "tag", number>;
+    }): void;
+    /** Render an aligned multi-line table of {@link Logger.metrics}. CLI uses this for `--stats`. */
+    summary(): string;
+}
+/** Shared no-op logger. Use as a default when callers don't pass one in. */
+export declare const NULL_LOGGER: Logger;
+//# sourceMappingURL=logger.d.ts.map

package/types/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAaA,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AA+B7D,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,OAAO;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,EAAE,MAAM,CAAC,CAAC;CAC5D;AAwBD,0DAA0D;AAC1D,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED,sEAAsE;AACtE,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAOjD;AAED;;;;;;GAMG;AACH,qBAAa,MAAM;IACjB,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,IAAI,CAAyB;IACrC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,UAAU,CAAU;IAC5B,OAAO,CAAC,KAAK,CAAS;gBAEV,OAAO,GAAE,aAAkB,EAAE,SAAS,SAAK;IAWvD,2FAA2F;IAC3F,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAchC,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,KAAK;IAIb,OAAO,CAAC,IAAI;IAaZ,kDAAkD;IAClD,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAG3B,qDAAqD;IACrD,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAG5B,sDAAsD;IACtD,KAAK,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAI5B,wDAAwD;IAClD,IAAI,CAAC,CAAC,EACV,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAClC,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC;IAab,+DAA+D;IAC/D,UAAU,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAQjF,8DAA8D;IAC9D,UAAU,CAAC,IAAI,EAAE;QACf,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,CAAC;QACnB,MAAM,EAAE,MAAM,CAAC,QAAQ,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,EAAE,MAAM,CAAC,CAAC;KAC5D,GAAG,IAAI;IAUR,iGAAiG;IACjG,OAAO,IAAI,MAAM;CA+BlB;AAED,4EAA4E;AAC5E,eAAO,MAAM,WAAW,QAAyD,CAAC"}

package/types/objects/commit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module objects-commit
+ *
+ * Decoder for the loose-commit object body.
+ *
+ * A commit is a header block followed by a blank line and a freeform message.
+ * Each header line is `<field> <value>` and only the first occurrence of any
+ * header is significant for our purposes (Git allows multiple `parent` lines
+ * for merge commits; this client deliberately keeps just the first since it
+ * only ever walks toward the root snapshot).
+ */
+import { Result } from "better-result";
+import { ObjectDecodeError } from "../errors.js";
+import type { CommitInfo } from "../types.js";
+/**
+ * Parse the body of a commit object.
+ *
+ * @param content Uncompressed commit bytes (no `commit <size>\0` header).
+ * @returns The decoded {@link CommitInfo}, or {@link ObjectDecodeError} if the
+ *   mandatory `tree` field is absent.
+ */
+export declare function parseCommit(content: Uint8Array): Result<CommitInfo, ObjectDecodeError>;
+//# sourceMappingURL=commit.d.ts.map

package/types/objects/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../src/objects/commit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAI9C;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,iBAAiB,CAAC,CA6BtF"}

package/types/objects/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./commit.js";
+export * from "./tree.js";
+//# sourceMappingURL=index.d.ts.map

package/types/objects/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/objects/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC"}

package/types/objects/tree.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @module objects-tree
+ *
+ * Tree decoder and helpers for walking trees / resolving paths to blobs.
+ *
+ * A tree entry on disk is `<octal-mode> <name>\0<20-byte-sha>` with no length
+ * prefix; entries are concatenated. Subtrees use mode `"40000"`; everything
+ * else (regular files, executable files, symlinks, gitlinks) is treated as a
+ * leaf by {@link walkTree}.
+ */
+import { Result } from "better-result";
+import { ObjectDecodeError, PathNotFoundError } from "../errors.js";
+import type { GitObjectMap, TreeEntry } from "../types.js";
+interface FileEntry {
+    mode: string;
+    path: string;
+    sha: string;
+}
+/**
+ * Parse a tree body into its entries, in the order they appear on disk.
+ *
+ * @param content Uncompressed tree bytes (no `tree <size>\0` header).
+ * @returns Ordered entries, or {@link ObjectDecodeError} on a malformed entry.
+ */
+export declare function parseTree(content: Uint8Array): Result<TreeEntry[], ObjectDecodeError>;
+/**
+ * Recursively flatten a tree into its leaf entries.
+ *
+ * Subtrees are followed; every other mode is treated as a file and emitted
+ * with its full path joined from `pathPrefix`. Requires that every reachable
+ * tree object is already present in `objects` — typically the case after a
+ * full (unfiltered) snapshot fetch.
+ *
+ * @param pathPrefix Internal: prefix prepended to entry names while recursing.
+ */
+export declare function walkTree(objects: GitObjectMap, treeSha: string, pathPrefix?: string): Result<FileEntry[], ObjectDecodeError>;
+/**
+ * Resolve a slash-separated path inside a tree to the SHA of its leaf entry
+ * (usually a blob).
+ *
+ * Intermediate components must be subtrees; the final component may be any
+ * mode (blob, exec, symlink). Leading/trailing/duplicate slashes are tolerated.
+ *
+ * @returns Leaf SHA-1, or {@link PathNotFoundError} when any component is
+ *   missing or an intermediate component is not a tree.
+ */
+export declare function resolvePathToBlob(objects: GitObjectMap, treeSha: string, path: string): Result<string, PathNotFoundError | ObjectDecodeError>;
+export {};
+//# sourceMappingURL=tree.d.ts.map

package/types/objects/tree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree.d.ts","sourceRoot":"","sources":["../../src/objects/tree.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAEvC,OAAO,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE3D,UAAU,SAAS;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;CACb;AAaD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,EAAE,EAAE,iBAAiB,CAAC,CAgCrF;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,EACf,UAAU,SAAK,GACd,MAAM,CAAC,SAAS,EAAE,EAAE,iBAAiB,CAAC,CA4BxC;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,CAAC,CAoDvD"}

package/types/pack/delta.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @module pack-delta
+ *
+ * Pack format varint decoders and the Git delta reconstruction routine.
+ *
+ * Two varint flavours live in pack files. The "big-endian" form used by
+ * `OBJ_OFS_DELTA` headers is decoded by {@link readVarintBe}; the
+ * little-endian form used inside the delta opcode stream is handled inline
+ * by {@link applyDelta}.
+ *
+ * Delta format spec: https://git-scm.com/docs/pack-format#_deltified_representation
+ */
+import { Result } from "better-result";
+import { PackParseError } from "../errors.js";
+import type { ReadResult } from "../types.js";
+/**
+ * Decode Git's "offset-encoded" big-endian varint (used for `OBJ_OFS_DELTA`
+ * base offsets).
+ *
+ * Each continuation byte adds an implicit `+1` before shifting, which lets the
+ * encoding represent more values in the same number of bytes than a plain MSB
+ * varint would.
+ *
+ * @returns `{ value, offset }` where `offset` points just past the last byte
+ *   consumed, or {@link PackParseError} if the buffer ends mid-varint.
+ */
+export declare function readVarintBe(data: Uint8Array, offset: number): Result<ReadResult<number>, PackParseError>;
+/**
+ * Reconstruct an object body from a delta against `base`.
+ *
+ * The delta stream begins with two little-endian varints (source size, target
+ * size). Then a sequence of opcodes follows, each either:
+ *
+ *  - **COPY** (high bit set): copy a range from `base` into the output. The
+ *    low nibble's set bits select which of up to 4 offset bytes follow; the
+ *    next 3 bits select up to 3 size bytes. A size of 0 means 64 KiB.
+ *  - **INSERT** (high bit clear, opcode `1..0x7f`): emit the next `opcode`
+ *    bytes of the delta stream verbatim into the output.
+ *  - opcode `0` is reserved and invalid.
+ *
+ * The source size is validated implicitly by every COPY's bounds check.
+ *
+ * @returns The fully reconstructed object, or {@link PackParseError} on any
+ *   truncation, invalid opcode, or size mismatch.
+ */
+export declare function applyDelta(base: Uint8Array, delta: Uint8Array): Result<Uint8Array, PackParseError>;
+//# sourceMappingURL=delta.d.ts.map

package/types/pack/delta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delta.d.ts","sourceRoot":"","sources":["../../src/pack/delta.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAiB9C;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,CA4B5C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,UAAU,EAChB,KAAK,EAAE,UAAU,GAChB,MAAM,CAAC,UAAU,EAAE,cAAc,CAAC,CA+GpC"}

package/types/pack/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./objects.js";
+export * from "./delta.js";
+export * from "./parser.js";
+//# sourceMappingURL=index.d.ts.map

package/types/pack/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pack/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/types/pack/objects.d.ts

@@ -0,0 +1,53 @@
+/**
+ * @module pack-objects
+ *
+ * Shared constants and the SHA-1 helper used by the packfile parser. Object
+ * type codes, varint flags, and pack-format magic live here so that
+ * {@link parser} and {@link delta} both reach for the same source of truth.
+ *
+ * Pack format reference:
+ * https://git-scm.com/docs/pack-format
+ */
+import { Result } from "better-result";
+import { PackParseError } from "../errors.js";
+import type { GitObjectType } from "../types.js";
+/** Magic bytes opening every packfile: ASCII `"PACK"`. */
+export declare const PACK_SIGNATURE: Uint8Array<ArrayBuffer>;
+/** Bytes consumed by the fixed pack header (signature + version + count). */
+export declare const PACK_HEADER_SIZE = 12;
+/** Size of {@link PACK_SIGNATURE} in bytes. */
+export declare const PACK_SIGNATURE_SIZE = 4;
+/** Pack format versions this parser accepts. v4 exists but is not produced by mainline Git. */
+export declare const SUPPORTED_PACK_VERSIONS: ReadonlySet<number>;
+/** Trailing SHA-1 over the rest of the pack — sits at the very end of the buffer. */
+export declare const PACK_TRAILER_SIZE = 20;
+/** High bit set on a varint byte means "another byte follows". */
+export declare const VARINT_CONTINUE = 128;
+/** Low 7 bits of a varint byte hold value bits. */
+export declare const VARINT_VALUE_MASK = 127;
+/** Packfile object type code: commit. */
+export declare const OBJ_COMMIT = 1;
+/** Packfile object type code: tree. */
+export declare const OBJ_TREE = 2;
+/** Packfile object type code: blob. */
+export declare const OBJ_BLOB = 3;
+/** Packfile object type code: annotated tag. */
+export declare const OBJ_TAG = 4;
+/** Delta object whose base is referenced by negative offset within the same pack. */
+export declare const OBJ_OFS_DELTA = 6;
+/** Delta object whose base is referenced by 20-byte SHA-1 (may be outside the pack). */
+export declare const OBJ_REF_DELTA = 7;
+/** Pack type code → loose-object type name. Excludes delta codes by design. */
+export declare const OBJ_NAMES: Map<number, GitObjectType>;
+/** Reverse of {@link OBJ_NAMES} — type name → pack type code. */
+export declare const OBJ_TYPES: Map<GitObjectType, number>;
+/**
+ * Compute the canonical Git SHA-1 of an object — `sha1("<type> <size>\0" || content)`.
+ *
+ * @param type Either a pack type code (1–4) or the loose-object type name.
+ * @param content The uncompressed object body.
+ * @returns Lowercase hex SHA-1, or {@link PackParseError} when `type` is a
+ *   delta code or otherwise unknown.
+ */
+export declare function sha1OfObject(type: number | GitObjectType, content: Uint8Array): Result<string, PackParseError>;
+//# sourceMappingURL=objects.d.ts.map

package/types/pack/objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"objects.d.ts","sourceRoot":"","sources":["../../src/pack/objects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGvC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,0DAA0D;AAC1D,eAAO,MAAM,cAAc,yBAA2C,CAAC;AACvE,6EAA6E;AAC7E,eAAO,MAAM,gBAAgB,KAAK,CAAC;AACnC,+CAA+C;AAC/C,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,+FAA+F;AAC/F,eAAO,MAAM,uBAAuB,EAAE,WAAW,CAAC,MAAM,CAAmB,CAAC;AAE5E,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,KAAK,CAAC;AAEpC,kEAAkE;AAClE,eAAO,MAAM,eAAe,MAAO,CAAC;AACpC,mDAAmD;AACnD,eAAO,MAAM,iBAAiB,MAAO,CAAC;AAEtC,yCAAyC;AACzC,eAAO,MAAM,UAAU,IAAI,CAAC;AAC5B,uCAAuC;AACvC,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,uCAAuC;AACvC,eAAO,MAAM,QAAQ,IAAI,CAAC;AAC1B,gDAAgD;AAChD,eAAO,MAAM,OAAO,IAAI,CAAC;AACzB,qFAAqF;AACrF,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,wFAAwF;AACxF,eAAO,MAAM,aAAa,IAAI,CAAC;AAE/B,+EAA+E;AAC/E,eAAO,MAAM,SAAS,4BAKpB,CAAC;AAEH,iEAAiE;AACjE,eAAO,MAAM,SAAS,4BAErB,CAAC;AAIF;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,GAAG,aAAa,EAC5B,OAAO,EAAE,UAAU,GAClB,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CAehC"}

package/types/pack/parser.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @module pack-parser
+ *
+ * Decode an in-memory packfile into a `sha → GitObject` map.
+ *
+ * The parser handles the four loose-object types directly and resolves both
+ * delta encodings (`OBJ_OFS_DELTA`, `OBJ_REF_DELTA`) by applying
+ * {@link applyDelta} against bases discovered earlier in the same pack. Ref
+ * deltas whose bases haven't appeared yet are deferred and retried in fixed
+ * point until every delta resolves or progress stalls.
+ *
+ * Optimization: passing a `targets` set lets the parser bail out as soon as
+ * every requested SHA has been materialized — useful for "fetch one object"
+ * paths where the server may have sent a much larger pack.
+ *
+ * zlib note: we reach into `node:zlib`'s `_processChunk` to learn exactly how
+ * many compressed input bytes were consumed. The public Streams API doesn't
+ * expose that, and parsing the next object requires knowing where the current
+ * one's compressed run ends.
+ */
+import { Result } from "better-result";
+import { PackParseError } from "../errors.js";
+import type { GitObjectMap, PackObjectHeader, ReadResult } from "../types.js";
+/**
+ * Decode a single pack-entry header starting at `offset`.
+ *
+ * Format: one byte holds `[MSB | type:3 | size_lo:4]`. While MSB is set,
+ * each additional byte contributes 7 more size bits. Returns the parsed
+ * type code, uncompressed size, and the offset just past the header.
+ */
+export declare function readPackObjectHeader(data: Uint8Array, offset: number): Result<PackObjectHeader, PackParseError>;
+/**
+ * Inflate one zlib stream embedded in the pack at `offset`.
+ *
+ * The pack's 20-byte trailer is sliced off before inflation so the deflate
+ * engine never sees it. `bytesWritten` on the `Inflate` engine reports how
+ * many input bytes were consumed, which is the only reliable way to advance
+ * `offset` to the next entry — multiple deflate streams sit back-to-back
+ * inside the pack and there's no length prefix at this layer.
+ *
+ * @param expectedSize Uncompressed size reported by the object header. When
+ *   provided, used to right-size the inflate chunk buffer and to assert the
+ *   output length post-hoc.
+ */
+export declare function decompressAt(data: Uint8Array, offset: number, expectedSize?: number): Result<ReadResult<Uint8Array>, PackParseError>;
+/**
+ * Walk every entry in `pack` and return a map of resolved objects keyed by
+ * SHA-1.
+ *
+ * For non-delta entries, the inflated bytes are hashed and stored. For
+ * `OBJ_OFS_DELTA` the base is looked up via `byOffset` (always present, since
+ * pack ordering guarantees the base appears earlier in the stream). For
+ * `OBJ_REF_DELTA` the base may be either earlier or later — unresolved ones
+ * accumulate in `pendingRefDeltas` and are retried until either all resolve
+ * or a pass makes no progress (cyclic / out-of-pack reference).
+ *
+ * @param targets Optional set of "wanted" SHAs. If supplied, the parser
+ *   returns as soon as every target has been materialized — even mid-pack.
+ */
+export declare function parsePackfile(pack: Uint8Array, targets?: ReadonlySet<string>): Result<GitObjectMap, PackParseError>;
+//# sourceMappingURL=parser.d.ts.map

package/types/pack/parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../../src/pack/parser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAIvC,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EAEV,YAAY,EAEZ,gBAAgB,EAChB,UAAU,EACX,MAAM,aAAa,CAAC;AA4DrB;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,GACb,MAAM,CAAC,gBAAgB,EAAE,cAAc,CAAC,CA6B1C;AAQD;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,UAAU,EAChB,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,MAAM,GACpB,MAAM,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC,CAmChD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,UAAU,EAChB,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC5B,MAAM,CAAC,YAAY,EAAE,cAAc,CAAC,CAiKtC"}

package/types/protocol/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./pkt_line.js";
+export * from "./refs.js";
+export * from "./upload_pack.js";
+//# sourceMappingURL=index.d.ts.map

package/types/protocol/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/protocol/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,kBAAkB,CAAC"}

package/types/protocol/pkt_line.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @module pkt-line
+ *
+ * Encode/decode Git's framing format. A pkt-line is a 4-byte ASCII-hex length
+ * prefix followed by `length - 4` payload bytes. Three reserved length values
+ * carry no payload and act as control markers (flush / delim / response-end).
+ *
+ * Spec: https://git-scm.com/docs/protocol-common
+ */
+import { Result } from "better-result";
+import { PktLineError } from "../errors.js";
+import type { PktLine } from "../types.js";
+/** Encoded `"0000"` flush packet — closes a section in v0 and v2. */
+export declare const FLUSH_PKT: Uint8Array<ArrayBufferLike>;
+/** Encoded `"0001"` delim packet — only valid in protocol v2. */
+export declare const DELIM_PKT: Uint8Array<ArrayBufferLike>;
+/** Encoded `"0002"` response-end packet — only valid in protocol v2. */
+export declare const RESPONSE_END_PKT: Uint8Array<ArrayBufferLike>;
+/**
+ * Wrap `payload` in a pkt-line frame.
+ *
+ * An empty payload returns the flush packet rather than a 4-byte zero-length
+ * frame, matching `git`'s convention.
+ *
+ * @param payload Raw bytes to frame. Pass any trailing `\n` you want preserved.
+ * @returns The framed bytes, or {@link PktLineError} if the total would exceed
+ *   {@link MAX_PKT_LINE_LENGTH}.
+ */
+export declare function pktLine(payload: Uint8Array): Result<Uint8Array, PktLineError>;
+/**
+ * Decode a sequence of pkt-lines from `buf`.
+ *
+ * Returns one entry per frame. Control packets (flush/delim/response-end) have
+ * `payload: null`. Data packets expose `payload` as a subarray view into `buf` —
+ * no bytes are copied. Trailing `\n` bytes inside payloads are preserved; callers
+ * that want them stripped must do so explicitly.
+ *
+ * @param buf Bytes containing zero or more concatenated pkt-lines.
+ * @param offset Starting byte index in `buf` (default `0`).
+ * @returns The decoded frames in order, or {@link PktLineError} on a bad length
+ *   prefix or a frame that runs past `buf`'s end.
+ */
+export declare function parsePktLines(buf: Uint8Array, offset?: number): Result<PktLine[], PktLineError>;
+//# sourceMappingURL=pkt_line.d.ts.map

package/types/protocol/pkt_line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pkt_line.d.ts","sourceRoot":"","sources":["../../src/protocol/pkt_line.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAmB3C,qEAAqE;AACrE,eAAO,MAAM,SAAS,6BAAyB,CAAC;AAChD,iEAAiE;AACjE,eAAO,MAAM,SAAS,6BAAyB,CAAC;AAChD,wEAAwE;AACxE,eAAO,MAAM,gBAAgB,6BAAyB,CAAC;AAEvD;;;;;;;;;GASG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAC,UAAU,EAAE,YAAY,CAAC,CAoB7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,GAAG,EAAE,UAAU,EACf,MAAM,SAAI,GACT,MAAM,CAAC,OAAO,EAAE,EAAE,YAAY,CAAC,CAqCjC"}

package/types/protocol/refs.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @module refs
+ *
+ * Decoders for the two flavours of `info/refs` response Git can return for the
+ * `git-upload-pack` service:
+ *
+ *  - **Protocol v0/v1** — a flat stream of `<sha> <ref>` pkt-lines where the
+ *    first ref also carries a NUL-separated capability list.
+ *  - **Protocol v2** — a capability advertisement (`version 2`, then one
+ *    `key[=args]` pkt-line per capability).
+ */
+import { Result } from "better-result";
+import type { PktLineError } from "../errors.js";
+import type { ParsedRefAdvertisement } from "../types.js";
+/**
+ * Parse a v0/v1 ref advertisement (response body of
+ * `GET /info/refs?service=git-upload-pack`).
+ *
+ * The first non-comment data line is special: its payload contains the ref
+ * pair, a NUL byte, then a space-separated list of capabilities. Subsequent
+ * lines are plain `<sha> <ref>\n` pairs.
+ *
+ * @param body Raw response bytes (including any `# service=...` banner).
+ * @returns The advertised refs (name → sha) and capabilities, or
+ *   {@link PktLineError} if the pkt-line framing is malformed.
+ */
+export declare function parseRefAdvertisement(body: Uint8Array): Result<ParsedRefAdvertisement, PktLineError>;
+/**
+ * Parse a v2 capability advertisement.
+ *
+ * The first data line is always `version 2`; we encode that as the synthetic
+ * capability `"version=2"` so callers can detect protocol v2 with a single
+ * lookup. For the `fetch` capability, any space-separated arguments (e.g.
+ * `shallow`, `filter`, `wait-for-done`) are added as separate set entries.
+ *
+ * @param body Raw response bytes from the `git-upload-pack` advertisement.
+ * @returns Set of capability tokens, or {@link PktLineError} on bad framing.
+ */
+export declare function parseV2CapabilityAdvertisement(body: Uint8Array): Result<Set<string>, PktLineError>;
+//# sourceMappingURL=refs.d.ts.map

package/types/protocol/refs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/protocol/refs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACvC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAkB1D;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,UAAU,GACf,MAAM,CAAC,sBAAsB,EAAE,YAAY,CAAC,CAgC9C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,UAAU,GACf,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,YAAY,CAAC,CAoBnC"}