@scolladon/tsgit 0.9.0

package/dist/types/operators/index.d.cts

@@ -0,0 +1,36 @@
+/**
+ * Callback return that may be resolved synchronously or via any thenable.
+ * Uses `PromiseLike<T>` — the exact shape `await` accepts under ES2022 —
+ * so custom thenables and test doubles compose cleanly.
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+
+declare function filter<T>(predicate: (value: T) => Awaitable<boolean>): (source: AsyncIterable<T>) => AsyncIterable<T>;
+
+declare function find<T>(predicate: (value: T) => Awaitable<boolean>): (source: AsyncIterable<T>) => Promise<T | undefined>;
+
+type FlatMapReturn<U> = Iterable<U> | AsyncIterable<U> | Promise<Iterable<U> | AsyncIterable<U>>;
+declare function flatMap<T, U>(mapper: (value: T) => FlatMapReturn<U>): (source: AsyncIterable<T>) => AsyncIterable<U>;
+
+declare function groupBy<T, K>(keyFn: (value: T) => Awaitable<K>, limit?: number): (source: AsyncIterable<T>) => Promise<ReadonlyMap<K, ReadonlyArray<T>>>;
+
+declare function map<T, U>(mapper: (value: T) => Awaitable<U>): (source: AsyncIterable<T>) => AsyncIterable<U>;
+
+type UnaryFn<A, B> = (value: A) => B;
+declare function pipe<A>(a: A): A;
+declare function pipe<A, B>(a: A, ab: UnaryFn<A, B>): B;
+declare function pipe<A, B, C>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>): C;
+declare function pipe<A, B, C, D>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>): D;
+declare function pipe<A, B, C, D, E>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>): E;
+declare function pipe<A, B, C, D, E, F>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>): F;
+declare function pipe<A, B, C, D, E, F, G>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>): G;
+declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>, ij: UnaryFn<I, J>): J;
+
+declare function take<T>(count: number): (source: AsyncIterable<T>) => AsyncIterable<T>;
+
+declare function toArray<T>(source: AsyncIterable<T>, limit?: number): Promise<T[]>;
+
+export { filter, find, flatMap, groupBy, map, pipe, take, toArray };
+export type { Awaitable };

package/dist/types/operators/index.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Callback return that may be resolved synchronously or via any thenable.
+ * Uses `PromiseLike<T>` — the exact shape `await` accepts under ES2022 —
+ * so custom thenables and test doubles compose cleanly.
+ */
+type Awaitable<T> = T | PromiseLike<T>;
+
+declare function filter<T>(predicate: (value: T) => Awaitable<boolean>): (source: AsyncIterable<T>) => AsyncIterable<T>;
+
+declare function find<T>(predicate: (value: T) => Awaitable<boolean>): (source: AsyncIterable<T>) => Promise<T | undefined>;
+
+type FlatMapReturn<U> = Iterable<U> | AsyncIterable<U> | Promise<Iterable<U> | AsyncIterable<U>>;
+declare function flatMap<T, U>(mapper: (value: T) => FlatMapReturn<U>): (source: AsyncIterable<T>) => AsyncIterable<U>;
+
+declare function groupBy<T, K>(keyFn: (value: T) => Awaitable<K>, limit?: number): (source: AsyncIterable<T>) => Promise<ReadonlyMap<K, ReadonlyArray<T>>>;
+
+declare function map<T, U>(mapper: (value: T) => Awaitable<U>): (source: AsyncIterable<T>) => AsyncIterable<U>;
+
+type UnaryFn<A, B> = (value: A) => B;
+declare function pipe<A>(a: A): A;
+declare function pipe<A, B>(a: A, ab: UnaryFn<A, B>): B;
+declare function pipe<A, B, C>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>): C;
+declare function pipe<A, B, C, D>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>): D;
+declare function pipe<A, B, C, D, E>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>): E;
+declare function pipe<A, B, C, D, E, F>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>): F;
+declare function pipe<A, B, C, D, E, F, G>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>): G;
+declare function pipe<A, B, C, D, E, F, G, H>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>): H;
+declare function pipe<A, B, C, D, E, F, G, H, I>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>): I;
+declare function pipe<A, B, C, D, E, F, G, H, I, J>(a: A, ab: UnaryFn<A, B>, bc: UnaryFn<B, C>, cd: UnaryFn<C, D>, de: UnaryFn<D, E>, ef: UnaryFn<E, F>, fg: UnaryFn<F, G>, gh: UnaryFn<G, H>, hi: UnaryFn<H, I>, ij: UnaryFn<I, J>): J;
+
+declare function take<T>(count: number): (source: AsyncIterable<T>) => AsyncIterable<T>;
+
+declare function toArray<T>(source: AsyncIterable<T>, limit?: number): Promise<T[]>;
+
+export { filter, find, flatMap, groupBy, map, pipe, take, toArray };
+export type { Awaitable };

package/dist/types/primitives/index.d.cts

@@ -0,0 +1,217 @@
+import { O as ObjectId, b as FilePath, a as Context, j as RefName } from '../chunks/context-Ku1aP8Ie.cjs';
+import { A as AuthorIdentity, F as FileMode, T as TreeDiff } from '../chunks/diff-change-BwO75AgS.cjs';
+import '../chunks/http-transport--_NdQOiw.cjs';
+
+interface Blob {
+    readonly type: 'blob';
+    readonly id: ObjectId;
+    readonly content: Uint8Array;
+}
+
+interface ExtraHeader {
+    readonly key: string;
+    readonly value: string;
+}
+interface CommitData {
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders: ReadonlyArray<ExtraHeader>;
+}
+interface Commit {
+    readonly type: 'commit';
+    readonly id: ObjectId;
+    readonly data: CommitData;
+}
+
+type ObjectType = 'blob' | 'tree' | 'commit' | 'tag';
+
+interface TagData {
+    readonly object: ObjectId;
+    readonly objectType: ObjectType;
+    readonly tagName: string;
+    readonly tagger?: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders: ReadonlyArray<ExtraHeader>;
+}
+interface Tag {
+    readonly type: 'tag';
+    readonly id: ObjectId;
+    readonly data: TagData;
+}
+
+interface TreeEntry {
+    readonly mode: FileMode;
+    readonly name: string;
+    readonly id: ObjectId;
+}
+interface Tree {
+    readonly type: 'tree';
+    readonly id: ObjectId;
+    readonly entries: ReadonlyArray<TreeEntry>;
+}
+
+type GitObject = Blob | Tree | Commit | Tag;
+
+interface IndexEntryFlags {
+    readonly assumeValid: boolean;
+    readonly extended: boolean;
+    readonly stage: 0 | 1 | 2 | 3;
+}
+interface IndexEntry {
+    readonly ctimeSeconds: number;
+    readonly ctimeNanoseconds: number;
+    readonly mtimeSeconds: number;
+    readonly mtimeNanoseconds: number;
+    readonly dev: number;
+    readonly ino: number;
+    readonly mode: FileMode;
+    readonly uid: number;
+    readonly gid: number;
+    readonly fileSize: number;
+    readonly id: ObjectId;
+    readonly flags: IndexEntryFlags;
+    readonly path: FilePath;
+}
+interface IndexExtension {
+    readonly signature: string;
+    readonly data: Uint8Array;
+}
+interface GitIndex {
+    readonly version: 2;
+    readonly entries: ReadonlyArray<IndexEntry>;
+    readonly extensions: ReadonlyArray<IndexExtension>;
+}
+
+interface RenameDetectOptions {
+    readonly limit?: number;
+    readonly maxSameIdDeletes?: number;
+}
+
+/**
+ * Phase 7 primitive option shapes, walker value types, and shared constants.
+ * Defined in one location to avoid circular imports between primitive modules.
+ */
+
+/** Max symbolic-ref dereferences resolveRef will follow. */
+declare const MAX_SYMBOLIC_REF_DEPTH = 5;
+/** Max tag-peel hops resolveRef / readTree will follow when peeling. */
+declare const MAX_PEEL_DEPTH = 5;
+/** Max seeds walkCommits.from can contain. */
+declare const MAX_WALK_SEEDS = 1024;
+/** Hard cap on walkCommits' pending queue size to prevent unbounded heap growth. */
+declare const MAX_WALK_QUEUE_SIZE: number;
+/** Max .git/index file size readIndex will accept. */
+declare const MAX_INDEX_BYTES: number;
+/** Max commit message byte length createCommit will accept. */
+declare const MAX_COMMIT_MESSAGE_BYTES: number;
+interface ReadObjectOptions {
+    readonly verifyHash?: boolean;
+}
+interface ResolveRefOptions {
+    readonly peel?: boolean;
+    readonly maxSymbolicDepth?: number;
+    readonly maxPeelDepth?: number;
+}
+interface UpdateRefOptions {
+    readonly expected?: ObjectId | 'absent';
+    readonly delete?: boolean;
+}
+interface WalkCommitsOptions {
+    readonly from: ReadonlyArray<ObjectId>;
+    readonly until?: ReadonlyArray<ObjectId>;
+    readonly order?: 'topo' | 'first-parent';
+    readonly ignoreMissing?: boolean;
+    readonly verifyHash?: boolean;
+}
+interface WalkTreeEntry {
+    readonly path: FilePath;
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}
+interface WalkTreeOptions {
+    readonly recursive?: boolean;
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+}
+interface CreateCommitInput {
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders?: ReadonlyArray<ExtraHeader>;
+}
+type DiffTreesInput = Tree | ObjectId | undefined;
+interface DiffTreesOptions {
+    readonly detectRenames?: boolean;
+    readonly renameOptions?: RenameDetectOptions;
+}
+
+declare function createCommit(ctx: Context, input: CreateCommitInput): Promise<ObjectId>;
+
+declare function diffTrees(ctx: Context, a: DiffTreesInput, b: DiffTreesInput, options?: DiffTreesOptions): Promise<TreeDiff>;
+
+/**
+ * Compute a merge base — the first commit reachable from BOTH `a` and `b`.
+ *
+ * Algorithm: bidirectional BFS with two visited sets. After each layer
+ * advance, check the intersection. When non-empty, return the
+ * lexicographically smallest oid (deterministic tie-breaker).
+ *
+ * Returns `undefined` for unrelated histories. Documented limitation: cherry-picks
+ * and criss-cross merges may yield non-optimal bases — `recursive`-strategy
+ * multi-base resolution is v2.
+ */
+declare const mergeBase: (ctx: Context, a: ObjectId, b: ObjectId) => Promise<ObjectId | undefined>;
+
+/**
+ * Pure path helpers composing `ctx.layout.gitDir` with known sub-paths.
+ * No I/O. No port access. Primitive step 3.
+ */
+
+/**
+ * Repository working-tree root. Returns the workDir from the current context;
+ * facade-tier code (Phase 10) is responsible for discovery / realpath pinning
+ * at construction time. Primitives consume the already-resolved path.
+ */
+declare const getRepoRoot: (ctx: Context) => FilePath;
+
+declare function readBlob(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<Blob>;
+
+declare function readIndex(ctx: Context): Promise<GitIndex>;
+
+declare function readObject(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<GitObject>;
+
+declare function readTree(ctx: Context, ref: RefName | ObjectId): Promise<Tree>;
+
+declare function resolveRef(ctx: Context, name: RefName | 'HEAD', options?: ResolveRefOptions): Promise<ObjectId>;
+
+declare function updateRef(ctx: Context, name: RefName, newId: ObjectId, options?: UpdateRefOptions): Promise<void>;
+
+declare function walkCommits(ctx: Context, options: WalkCommitsOptions): AsyncIterable<Commit>;
+
+declare function walkTree(ctx: Context, treeIdOrObject: ObjectId | Tree, options?: WalkTreeOptions): AsyncIterable<WalkTreeEntry>;
+
+declare function writeObject(ctx: Context, object: GitObject): Promise<ObjectId>;
+
+/**
+ * Write a symbolic ref atomically. Used for HEAD updates that point at a
+ * branch, branch renames affecting the current HEAD, and `clone`/`init`
+ * to set the initial HEAD.
+ *
+ * Single-level only in v1: target MUST be a direct ref name (no chained
+ * symrefs). Validation runs through `validateRefName` for both `name` and
+ * `target` — invalid inputs throw INVALID_REF before any I/O.
+ */
+declare const writeSymbolicRef: (ctx: Context, name: RefName, target: RefName) => Promise<void>;
+
+declare function writeTree(ctx: Context, entries: ReadonlyArray<TreeEntry>): Promise<ObjectId>;
+
+export { MAX_COMMIT_MESSAGE_BYTES, MAX_INDEX_BYTES, MAX_PEEL_DEPTH, MAX_SYMBOLIC_REF_DEPTH, MAX_WALK_QUEUE_SIZE, MAX_WALK_SEEDS, TreeDiff, createCommit, diffTrees, getRepoRoot, mergeBase, readBlob, readIndex, readObject, readTree, resolveRef, updateRef, walkCommits, walkTree, writeObject, writeSymbolicRef, writeTree };
+export type { CreateCommitInput, DiffTreesInput, DiffTreesOptions, ReadObjectOptions, ResolveRefOptions, UpdateRefOptions, WalkCommitsOptions, WalkTreeEntry, WalkTreeOptions };

package/dist/types/primitives/index.d.ts

@@ -0,0 +1,217 @@
+import { O as ObjectId, b as FilePath, a as Context, j as RefName } from '../chunks/context-C6df52Qs.js';
+import { A as AuthorIdentity, F as FileMode, T as TreeDiff } from '../chunks/diff-change-CUWN3OSK.js';
+import '../chunks/http-transport--_NdQOiw.js';
+
+interface Blob {
+    readonly type: 'blob';
+    readonly id: ObjectId;
+    readonly content: Uint8Array;
+}
+
+interface ExtraHeader {
+    readonly key: string;
+    readonly value: string;
+}
+interface CommitData {
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders: ReadonlyArray<ExtraHeader>;
+}
+interface Commit {
+    readonly type: 'commit';
+    readonly id: ObjectId;
+    readonly data: CommitData;
+}
+
+type ObjectType = 'blob' | 'tree' | 'commit' | 'tag';
+
+interface TagData {
+    readonly object: ObjectId;
+    readonly objectType: ObjectType;
+    readonly tagName: string;
+    readonly tagger?: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders: ReadonlyArray<ExtraHeader>;
+}
+interface Tag {
+    readonly type: 'tag';
+    readonly id: ObjectId;
+    readonly data: TagData;
+}
+
+interface TreeEntry {
+    readonly mode: FileMode;
+    readonly name: string;
+    readonly id: ObjectId;
+}
+interface Tree {
+    readonly type: 'tree';
+    readonly id: ObjectId;
+    readonly entries: ReadonlyArray<TreeEntry>;
+}
+
+type GitObject = Blob | Tree | Commit | Tag;
+
+interface IndexEntryFlags {
+    readonly assumeValid: boolean;
+    readonly extended: boolean;
+    readonly stage: 0 | 1 | 2 | 3;
+}
+interface IndexEntry {
+    readonly ctimeSeconds: number;
+    readonly ctimeNanoseconds: number;
+    readonly mtimeSeconds: number;
+    readonly mtimeNanoseconds: number;
+    readonly dev: number;
+    readonly ino: number;
+    readonly mode: FileMode;
+    readonly uid: number;
+    readonly gid: number;
+    readonly fileSize: number;
+    readonly id: ObjectId;
+    readonly flags: IndexEntryFlags;
+    readonly path: FilePath;
+}
+interface IndexExtension {
+    readonly signature: string;
+    readonly data: Uint8Array;
+}
+interface GitIndex {
+    readonly version: 2;
+    readonly entries: ReadonlyArray<IndexEntry>;
+    readonly extensions: ReadonlyArray<IndexExtension>;
+}
+
+interface RenameDetectOptions {
+    readonly limit?: number;
+    readonly maxSameIdDeletes?: number;
+}
+
+/**
+ * Phase 7 primitive option shapes, walker value types, and shared constants.
+ * Defined in one location to avoid circular imports between primitive modules.
+ */
+
+/** Max symbolic-ref dereferences resolveRef will follow. */
+declare const MAX_SYMBOLIC_REF_DEPTH = 5;
+/** Max tag-peel hops resolveRef / readTree will follow when peeling. */
+declare const MAX_PEEL_DEPTH = 5;
+/** Max seeds walkCommits.from can contain. */
+declare const MAX_WALK_SEEDS = 1024;
+/** Hard cap on walkCommits' pending queue size to prevent unbounded heap growth. */
+declare const MAX_WALK_QUEUE_SIZE: number;
+/** Max .git/index file size readIndex will accept. */
+declare const MAX_INDEX_BYTES: number;
+/** Max commit message byte length createCommit will accept. */
+declare const MAX_COMMIT_MESSAGE_BYTES: number;
+interface ReadObjectOptions {
+    readonly verifyHash?: boolean;
+}
+interface ResolveRefOptions {
+    readonly peel?: boolean;
+    readonly maxSymbolicDepth?: number;
+    readonly maxPeelDepth?: number;
+}
+interface UpdateRefOptions {
+    readonly expected?: ObjectId | 'absent';
+    readonly delete?: boolean;
+}
+interface WalkCommitsOptions {
+    readonly from: ReadonlyArray<ObjectId>;
+    readonly until?: ReadonlyArray<ObjectId>;
+    readonly order?: 'topo' | 'first-parent';
+    readonly ignoreMissing?: boolean;
+    readonly verifyHash?: boolean;
+}
+interface WalkTreeEntry {
+    readonly path: FilePath;
+    readonly id: ObjectId;
+    readonly mode: FileMode;
+}
+interface WalkTreeOptions {
+    readonly recursive?: boolean;
+    readonly maxDepth?: number;
+    readonly maxEntries?: number;
+}
+interface CreateCommitInput {
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+    readonly gpgSignature?: string;
+    readonly extraHeaders?: ReadonlyArray<ExtraHeader>;
+}
+type DiffTreesInput = Tree | ObjectId | undefined;
+interface DiffTreesOptions {
+    readonly detectRenames?: boolean;
+    readonly renameOptions?: RenameDetectOptions;
+}
+
+declare function createCommit(ctx: Context, input: CreateCommitInput): Promise<ObjectId>;
+
+declare function diffTrees(ctx: Context, a: DiffTreesInput, b: DiffTreesInput, options?: DiffTreesOptions): Promise<TreeDiff>;
+
+/**
+ * Compute a merge base — the first commit reachable from BOTH `a` and `b`.
+ *
+ * Algorithm: bidirectional BFS with two visited sets. After each layer
+ * advance, check the intersection. When non-empty, return the
+ * lexicographically smallest oid (deterministic tie-breaker).
+ *
+ * Returns `undefined` for unrelated histories. Documented limitation: cherry-picks
+ * and criss-cross merges may yield non-optimal bases — `recursive`-strategy
+ * multi-base resolution is v2.
+ */
+declare const mergeBase: (ctx: Context, a: ObjectId, b: ObjectId) => Promise<ObjectId | undefined>;
+
+/**
+ * Pure path helpers composing `ctx.layout.gitDir` with known sub-paths.
+ * No I/O. No port access. Primitive step 3.
+ */
+
+/**
+ * Repository working-tree root. Returns the workDir from the current context;
+ * facade-tier code (Phase 10) is responsible for discovery / realpath pinning
+ * at construction time. Primitives consume the already-resolved path.
+ */
+declare const getRepoRoot: (ctx: Context) => FilePath;
+
+declare function readBlob(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<Blob>;
+
+declare function readIndex(ctx: Context): Promise<GitIndex>;
+
+declare function readObject(ctx: Context, id: ObjectId, options?: ReadObjectOptions): Promise<GitObject>;
+
+declare function readTree(ctx: Context, ref: RefName | ObjectId): Promise<Tree>;
+
+declare function resolveRef(ctx: Context, name: RefName | 'HEAD', options?: ResolveRefOptions): Promise<ObjectId>;
+
+declare function updateRef(ctx: Context, name: RefName, newId: ObjectId, options?: UpdateRefOptions): Promise<void>;
+
+declare function walkCommits(ctx: Context, options: WalkCommitsOptions): AsyncIterable<Commit>;
+
+declare function walkTree(ctx: Context, treeIdOrObject: ObjectId | Tree, options?: WalkTreeOptions): AsyncIterable<WalkTreeEntry>;
+
+declare function writeObject(ctx: Context, object: GitObject): Promise<ObjectId>;
+
+/**
+ * Write a symbolic ref atomically. Used for HEAD updates that point at a
+ * branch, branch renames affecting the current HEAD, and `clone`/`init`
+ * to set the initial HEAD.
+ *
+ * Single-level only in v1: target MUST be a direct ref name (no chained
+ * symrefs). Validation runs through `validateRefName` for both `name` and
+ * `target` — invalid inputs throw INVALID_REF before any I/O.
+ */
+declare const writeSymbolicRef: (ctx: Context, name: RefName, target: RefName) => Promise<void>;
+
+declare function writeTree(ctx: Context, entries: ReadonlyArray<TreeEntry>): Promise<ObjectId>;
+
+export { MAX_COMMIT_MESSAGE_BYTES, MAX_INDEX_BYTES, MAX_PEEL_DEPTH, MAX_SYMBOLIC_REF_DEPTH, MAX_WALK_QUEUE_SIZE, MAX_WALK_SEEDS, TreeDiff, createCommit, diffTrees, getRepoRoot, mergeBase, readBlob, readIndex, readObject, readTree, resolveRef, updateRef, walkCommits, walkTree, writeObject, writeSymbolicRef, writeTree };
+export type { CreateCommitInput, DiffTreesInput, DiffTreesOptions, ReadObjectOptions, ResolveRefOptions, UpdateRefOptions, WalkCommitsOptions, WalkTreeEntry, WalkTreeOptions };

package/dist/types/transport/index.d.cts

@@ -0,0 +1,62 @@
+import { a as HttpRequest, b as HttpResponse, H as HttpTransport } from '../chunks/http-transport--_NdQOiw.cjs';
+
+type RetryPredicate = (info: {
+    readonly error?: unknown;
+    readonly response?: HttpResponse;
+    readonly attempt: number;
+}) => boolean;
+interface RetryConfig {
+    readonly attempts: number;
+    readonly backoff?: 'fixed' | 'exponential';
+    readonly baseMs?: number;
+    readonly maxDelayMs?: number;
+    readonly jitter?: number;
+    readonly isRetryable?: RetryPredicate;
+    readonly delay?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+type AuthConfig = {
+    readonly type: 'bearer';
+    readonly token: string;
+} | {
+    readonly type: 'basic';
+    readonly username: string;
+    readonly password: string;
+} | {
+    readonly type: 'custom';
+    readonly header: (req: HttpRequest) => string | Promise<string>;
+};
+type LogEvent = {
+    readonly kind: 'request';
+    readonly method: 'GET' | 'POST';
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly bodyBytes: number;
+} | {
+    readonly kind: 'response';
+    readonly statusCode: number;
+    readonly url: string;
+    readonly elapsedMs: number;
+    readonly headers: Readonly<Record<string, string>>;
+} | {
+    readonly kind: 'error';
+    readonly url: string;
+    readonly elapsedMs: number;
+    readonly errorMessage: string;
+};
+interface Logger {
+    readonly log: (event: LogEvent) => void;
+}
+interface LoggingConfig {
+    readonly logger: Logger;
+    readonly now?: () => number;
+    readonly redactHeaders?: ReadonlyArray<string>;
+}
+
+declare const withAuth: (config: AuthConfig) => (inner: HttpTransport) => HttpTransport;
+
+declare const withLogging: (config: LoggingConfig) => (inner: HttpTransport) => HttpTransport;
+
+declare const withRetry: (config: RetryConfig) => (inner: HttpTransport) => HttpTransport;
+
+export { withAuth, withLogging, withRetry };
+export type { AuthConfig, LogEvent, Logger, LoggingConfig, RetryConfig, RetryPredicate };

package/dist/types/transport/index.d.ts

@@ -0,0 +1,62 @@
+import { a as HttpRequest, b as HttpResponse, H as HttpTransport } from '../chunks/http-transport--_NdQOiw.js';
+
+type RetryPredicate = (info: {
+    readonly error?: unknown;
+    readonly response?: HttpResponse;
+    readonly attempt: number;
+}) => boolean;
+interface RetryConfig {
+    readonly attempts: number;
+    readonly backoff?: 'fixed' | 'exponential';
+    readonly baseMs?: number;
+    readonly maxDelayMs?: number;
+    readonly jitter?: number;
+    readonly isRetryable?: RetryPredicate;
+    readonly delay?: (ms: number, signal?: AbortSignal) => Promise<void>;
+}
+type AuthConfig = {
+    readonly type: 'bearer';
+    readonly token: string;
+} | {
+    readonly type: 'basic';
+    readonly username: string;
+    readonly password: string;
+} | {
+    readonly type: 'custom';
+    readonly header: (req: HttpRequest) => string | Promise<string>;
+};
+type LogEvent = {
+    readonly kind: 'request';
+    readonly method: 'GET' | 'POST';
+    readonly url: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly bodyBytes: number;
+} | {
+    readonly kind: 'response';
+    readonly statusCode: number;
+    readonly url: string;
+    readonly elapsedMs: number;
+    readonly headers: Readonly<Record<string, string>>;
+} | {
+    readonly kind: 'error';
+    readonly url: string;
+    readonly elapsedMs: number;
+    readonly errorMessage: string;
+};
+interface Logger {
+    readonly log: (event: LogEvent) => void;
+}
+interface LoggingConfig {
+    readonly logger: Logger;
+    readonly now?: () => number;
+    readonly redactHeaders?: ReadonlyArray<string>;
+}
+
+declare const withAuth: (config: AuthConfig) => (inner: HttpTransport) => HttpTransport;
+
+declare const withLogging: (config: LoggingConfig) => (inner: HttpTransport) => HttpTransport;
+
+declare const withRetry: (config: RetryConfig) => (inner: HttpTransport) => HttpTransport;
+
+export { withAuth, withLogging, withRetry };
+export type { AuthConfig, LogEvent, Logger, LoggingConfig, RetryConfig, RetryPredicate };