@scolladon/tsgit 1.0.0 → 1.1.0

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

@@ -1,217 +1,254 @@
-import { O as ObjectId, d as FilePath, b as Context, R as RefName } from '../chunks/context-CTaXSPiP.js';
-import { A as AuthorIdentity, F as FileMode, T as TreeDiff } from '../chunks/diff-change-D7xSeCn9.js';
-import '../chunks/http-transport-DirKfK2S.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;
-}
+import { G as GitIndex, I as IndexEntry } from '../chunks/write-tree-DNjhjS3t.js';
+export { C as CreateCommitInput, D as DiffTreesInput, a as DiffTreesOptions, M as MAX_COMMIT_MESSAGE_BYTES, b as MAX_GITIGNORE_BYTES, c as MAX_HAVES, d as MAX_INDEX_BYTES, e as MAX_PEEL_DEPTH, f as MAX_PUSH_OBJECTS, g as MAX_SYMBOLIC_REF_DEPTH, h as MAX_WALK_QUEUE_SIZE, i as MAX_WALK_SEEDS, j as MAX_WORKING_TREE_BLOB_BYTES, R as ReadObjectOptions, k as ResolveRefOptions, U as UpdateRefOptions, W as WalkCommitsOptions, l as WalkIgnorePredicate, m as WalkTreeEntry, n as WalkTreeOptions, o as WalkWorkingTreeEntry, p as WalkWorkingTreeOptions, q as createCommit, r as diffTrees, s as getRepoRoot, t as mergeBase, u as readBlob, v as readIndex, w as readObject, x as readTree, y as resolveRef, z as updateRef, A as walkCommits, B as walkTree, E as walkWorkingTree, F as writeObject, H as writeSymbolicRef, J as writeTree } from '../chunks/write-tree-DNjhjS3t.js';
+import { d as FilePath, O as ObjectId, b as Context } from '../chunks/context-o5TPfMB2.js';
+import { F as FileMode } from '../chunks/diff-change-alGRzD_j.js';
+export { T as TreeDiff } from '../chunks/diff-change-alGRzD_j.js';
+import { b as HttpTransport } from '../chunks/http-transport-DirKfK2S.js';
 
 /**
- * Phase 7 primitive option shapes, walker value types, and shared constants.
- * Defined in one location to avoid circular imports between primitive modules.
+ * Pure helper that diffs a current GitIndex against a target tree's flat
+ * entry list and emits an ordered ChangesetEntry list. No FS, no ctx; the
+ * impure write side lives in `apply-changeset.ts`.
+ *
+ * Stage-0 entries only — unmerged stages are invisible to checkout (Phase
+ * 13.1 design step 5).
  */
 
-/** 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 ChangesetEntry {
+    readonly kind: 'add' | 'update' | 'delete' | 'noop';
+    readonly path: FilePath;
+    readonly mode: FileMode;
+    readonly id: ObjectId | undefined;
+    readonly previousId: ObjectId | undefined;
+    readonly previousMode: FileMode | undefined;
 }
-interface UpdateRefOptions {
-    readonly expected?: ObjectId | 'absent';
-    readonly delete?: boolean;
+interface ChangesetStats {
+    readonly add: number;
+    readonly update: number;
+    readonly delete: number;
+    readonly noop: number;
 }
-interface WalkCommitsOptions {
-    readonly from: ReadonlyArray<ObjectId>;
-    readonly until?: ReadonlyArray<ObjectId>;
-    readonly order?: 'topo' | 'first-parent';
-    readonly ignoreMissing?: boolean;
-    readonly verifyHash?: boolean;
+interface Changeset {
+    readonly entries: ReadonlyArray<ChangesetEntry>;
+    readonly stats: ChangesetStats;
 }
-interface WalkTreeEntry {
+interface TargetEntry {
     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>;
+declare const computeChangeset: (currentIndex: GitIndex, targetTree: ReadonlyArray<TargetEntry>) => Changeset;
+
+interface ApplyChangesetOpts {
+    readonly changeset: Changeset;
+    readonly force: boolean;
+    readonly workdir: string;
 }
-type DiffTreesInput = Tree | ObjectId | undefined;
-interface DiffTreesOptions {
-    readonly detectRenames?: boolean;
-    readonly renameOptions?: RenameDetectOptions;
+interface ApplyChangesetResult {
+    readonly writtenEntries: ReadonlyArray<IndexEntry>;
+    readonly written: number;
+    readonly deleted: number;
 }
+declare const applyChangeset: (ctx: Context, opts: ApplyChangesetOpts) => Promise<ApplyChangesetResult>;
 
-declare function createCommit(ctx: Context, input: CreateCommitInput): Promise<ObjectId>;
+/**
+ * Project a target tree onto a fresh stage-0 IndexEntry list, preserving
+ * stat-cache fields from the prior index where the path's `id` AND `mode`
+ * both match (the "stat-cache donor" strategy).
+ *
+ * Pure with respect to the working tree: this primitive never calls
+ * `fs.lstat`, `fs.read`, or any working-tree-side API. It only reads git
+ * objects via `walkTree` → `readObject` for nested trees.
+ *
+ * Used by `reset --mixed` to rebuild the index from a target
+ * commit's tree. Will be re-used by `reset --hard` composed
+ * with `materializeTree` to also write the working tree.
+ *
+ * ## Preconditions
+ *
+ * `currentIndex` MUST be read under the same `acquireIndexLock` that will
+ * later commit the result. Reading the index BEFORE the lock is acquired
+ * lets a concurrent writer mutate it between the donor-map build and the
+ * commit, producing a result that reflects neither the pre-reset nor the
+ * post-reset state. See `reset.ts:rebuildIndexFromCommit` for the
+ * canonical pattern: acquire → read → build → commit → release-in-finally.
+ */
 
-declare function diffTrees(ctx: Context, a: DiffTreesInput, b: DiffTreesInput, options?: DiffTreesOptions): Promise<TreeDiff>;
+interface BuildIndexFromTreeOpts {
+    readonly targetTree: ObjectId;
+    readonly currentIndex: GitIndex;
+}
+declare const buildIndexFromTree: (ctx: Context, opts: BuildIndexFromTreeOpts) => Promise<ReadonlyArray<IndexEntry>>;
+
+interface BuildPackInput {
+    readonly oids: ReadonlyArray<ObjectId>;
+}
+interface BuildPackResult {
+    readonly bytes: Uint8Array;
+    /** Hex SHA of the pack body, also the trailer (last 20 bytes). */
+    readonly sha: string;
+    readonly objectCount: number;
+}
+declare const buildPack: (ctx: Context, input: BuildPackInput) => Promise<BuildPackResult>;
+
+interface EnumeratePushObjectsInput {
+    /**
+     * Object ids the caller wants on the remote. Each MUST resolve to a
+     * commit or an annotated tag (tags are unwrapped to commits before the
+     * commit walk).
+     */
+    readonly wants: ReadonlyArray<ObjectId>;
+    /** Object ids the remote already has (server's advertised ref tips). */
+    readonly haves: ReadonlyArray<ObjectId>;
+    /** Hard cap on objects emitted. Defaults to MAX_PUSH_OBJECTS. */
+    readonly maxObjects?: number;
+}
+declare function enumeratePushObjects(ctx: Context, input: EnumeratePushObjectsInput): AsyncIterable<ObjectId>;
+
+interface FetchPackInput {
+    /** Advertised refs the caller wants. MUST be non-empty (server-side requirement). */
+    readonly wants: ReadonlyArray<ObjectId>;
+    /** Objects the caller already has (negotiation). Empty for clone, populated for fetch. */
+    readonly haves: ReadonlyArray<ObjectId>;
+    /** Negotiated capabilities (intersection of advertised + supported). */
+    readonly capabilities: ReadonlyArray<string>;
+    /** Base remote URL (the same URL passed to clone). */
+    readonly url: string;
+    /** Progress op label — clone uses 'clone:write-objects', fetch uses 'fetch:write-objects'. */
+    readonly progressOp: string;
+    /**
+     * Shallow clone depth. When set, sends `deepen N` and consumes the
+     * accompanying `shallow <oid>` / `unshallow <oid>` response block.
+     *
+     */
+    readonly depth?: number;
+}
+interface FetchPackResult {
+    readonly packPath: string;
+    readonly idxPath: string;
+    readonly objectCount: number;
+    /** Hex-encoded SHA of the pack trailer; also the on-disk filename stem. */
+    readonly packSha: string;
+    /** Commits the server advertised as new shallow boundaries (empty when depth is unset). */
+    readonly shallow: ReadonlyArray<ObjectId>;
+    /** Commits the server advertised as no-longer-shallow (empty when depth is unset). */
+    readonly unshallow: ReadonlyArray<ObjectId>;
+}
+declare const fetchPack: (ctx: Context, transport: HttpTransport, input: FetchPackInput) => Promise<FetchPackResult>;
 
 /**
- * Compute a merge base — the first commit reachable from BOTH `a` and `b`.
+ * Compose `walkTree → computeChangeset → applyChangeset` to update the
+ * working tree to a target tree's contents.
+ *
+ * - Branch switch mode: `paths === undefined` — diff the entire current
+ *  index against the entire target tree.
+ * - Path-restore mode: `paths !== undefined` — restrict both sides of
+ *  the diff to those paths.
  *
- * 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 the new IndexEntry list for the caller to commit, plus
+ * written/deleted counts. The primitive does NOT commit the index — the
+ * caller decides.
  *
- * 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.
+ * ## Stat-source contract for `newIndexEntries` (load-bearing for)
+ *
+ * - **Paths that were written/added** (`add` or `update` changeset entries):
+ *  the IndexEntry carries **post-write `lstat`-derived stat fields**
+ *  (ctime/mtime/dev/ino/uid/gid/fileSize). These reflect the file we just
+ *  wrote, so the next `status` runs the fast `isStatClean` path.
+ * - **Paths whose changeset classification was `noop`** (skipped — index
+ *  already matched target by `id + mode`): the IndexEntry is the caller's
+ *  `currentIndex` entry verbatim. Donor stats survive across the call.
+ * - `reset --hard` therefore MUST set `forceRewriteAll: true` so every noop
+ *  upgrades to update and the post-write stats land in the output. Without
+ *  that, a locally-modified working-tree file that the index still records
+ *  as clean would survive the reset, AND the donor stats would be stale
+ *  relative to the actual disk state.
  */
-declare const mergeBase: (ctx: Context, a: ObjectId, b: ObjectId) => Promise<ObjectId | undefined>;
+
+interface MaterializeTreeOpts {
+    readonly targetTree: ObjectId;
+    readonly currentIndex: GitIndex;
+    readonly force?: boolean;
+    readonly paths?: ReadonlySet<FilePath>;
+    /**
+     * When true, every target-tree path is written to the working tree
+     * unconditionally — even paths the index→target diff classified as `noop`
+     * (same `id` AND `mode`). Required by `reset --hard`, where the working
+     * tree may diverge from the index (uncommitted local modifications); the
+     * standard index→target diff cannot see that drift, so noops would skip
+     * paths the caller wants overwritten. Default `false` keeps the Phase
+     * 13.1 checkout behaviour: clean files are never spuriously rewritten.
+     */
+    readonly forceRewriteAll?: boolean;
+}
+interface MaterializeTreeResult {
+    readonly newIndexEntries: ReadonlyArray<IndexEntry>;
+    readonly written: number;
+    readonly deleted: number;
+}
+declare const materializeTree: (ctx: Context, opts: MaterializeTreeOpts) => Promise<MaterializeTreeResult>;
 
 /**
- * Pure path helpers composing `ctx.layout.gitDir` with known sub-paths.
- * No I/O. No port access. Primitive step 3.
+ * Read `.git/shallow`. Returns an empty set when the file does not exist or
+ * contains no oids. Malformed lines are tolerated (skipped) — canonical
+ * git behaves the same; a corrupted shallow file should not block a fetch.
  */
-
+declare const readShallow: (ctx: Context) => Promise<ReadonlySet<ObjectId>>;
+interface ShallowUpdate {
+    readonly shallow: ReadonlyArray<ObjectId>;
+    readonly unshallow: ReadonlyArray<ObjectId>;
+}
 /**
- * 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.
+ * Apply a set of shallow / unshallow updates to `.git/shallow`. Writes
+ * atomically via lock-rename; deletes the file when the resulting set is
+ * empty.
  */
-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>;
+declare const updateShallow: (ctx: Context, updates: ShallowUpdate) => Promise<void>;
 
 /**
- * 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.
+ * Synthesise a nested `Tree` object from a flat `GitIndex` and return the
+ * root tree's `ObjectId`. Sub-trees are written to the object store as a
+ * side-effect of the recursive descent — only stage-0 entries contribute.
+ *
+ * Used by `checkout({ paths, source: 'index' })` to restore
+ * the working tree from staged content even when the index has diverged
+ * from HEAD via `add` / `rm`. The previous placeholder fell back to
+ * HEAD's tree, which silently lost the divergence.
+ *
+ * The synthesis is the inverse of `buildIndexFromTree`:
+ * "tree → index" and "index → tree" form a round-trip identity for any
+ * stage-0-only index.
+ *
+ * Pure with respect to the working tree — never calls `fs.lstat`,
+ * `fs.read`, or any working-tree-side API. Only writes git objects via
+ * the existing `writeTree` primitive.
  *
- * 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.
+ * ## Safety
+ *
+ * - **Path validation**:.7 hoisted segment-level validation into
+ *  `parseIndex` (`src/domain/git-index/path-validator.ts`). Every
+ *  `IndexEntry` reaching this primitive THROUGH THE CANONICAL PARSER
+ *  carries a `FilePath` value already free of `..`, `.`, empty segments,
+ *  and leading-slash absolute paths. However, the primitive is also
+ *  reachable from callers that construct `IndexEntry` records outside
+ *  the parser (test fixtures, in-memory adapters, future synthesisers).
+ *  Defence-in-depth: every entry is re-validated here so the primitive
+ *  stays safe even when the parser-trusted path is bypassed.
+ * - **Depth cap**: synthesis bounds recursion at `MAX_TREE_DEPTH` (4096,
+ *  matching git's canonical limit). The cap is enforced at the input
+ *  boundary by counting slashes — by the time recursion would catch a
+ *  pathological depth, the JS engine has already exhausted its call
+ *  stack. Path validation does NOT subsume this check: a path can be
+ *  safe segment-by-segment (no `..`/`.`/empty) and still be 10 000
+ *  levels deep.
  */
-declare const writeSymbolicRef: (ctx: Context, name: RefName, target: RefName) => Promise<void>;
 
-declare function writeTree(ctx: Context, entries: ReadonlyArray<TreeEntry>): Promise<ObjectId>;
+/**
+ * Public entry: pass the `entries` array directly (typically
+ * `index.entries`, but callers holding a filtered list may supply it
+ * without wrapping in a fake `GitIndex`).
+ */
+declare const synthesizeTreeFromIndex: (ctx: Context, entries: ReadonlyArray<IndexEntry>) => 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 };
+export { applyChangeset, buildIndexFromTree, buildPack, computeChangeset, enumeratePushObjects, fetchPack, materializeTree, readShallow, synthesizeTreeFromIndex, updateShallow };
+export type { ApplyChangesetOpts, ApplyChangesetResult, BuildIndexFromTreeOpts, BuildPackInput, BuildPackResult, Changeset, ChangesetEntry, ChangesetStats, EnumeratePushObjectsInput, FetchPackInput, FetchPackResult, MaterializeTreeOpts, MaterializeTreeResult };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scolladon/tsgit",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Lightning-fast git, pure TypeScript, everywhere.",
   "type": "module",
   "license": "MIT",
@@ -176,12 +176,16 @@
     "test": "wireit",
     "test:unit": "wireit",
     "test:integration": "wireit",
+    "test:posix-integration": "wireit",
+    "test:win-integration": "wireit",
     "test:e2e": "wireit",
     "test:coverage": "wireit",
     "test:mutation": "wireit",
     "test:mutation:incremental": "wireit",
     "test:bench": "wireit",
     "bench:summary": "wireit",
+    "bench:fixture": "node --experimental-strip-types scripts/gen-bench-fixture.ts",
+    "profile": "npm run build && node --experimental-strip-types scripts/profile.ts",
     "docs": "wireit",
     "docs:check": "wireit",
     "verify:tarball": "wireit",
@@ -313,6 +317,30 @@
       ],
       "output": []
     },
+    "test:posix-integration": {
+      "command": "vitest run --project posix-integration",
+      "dependencies": [
+        "check:types"
+      ],
+      "files": [
+        "src/**/*.ts",
+        "test/integration/posix-only/**/*.ts",
+        "vitest.config.ts"
+      ],
+      "output": []
+    },
+    "test:win-integration": {
+      "command": "vitest run --project win-integration",
+      "dependencies": [
+        "check:types"
+      ],
+      "files": [
+        "src/**/*.ts",
+        "test/integration/win-only/**/*.ts",
+        "vitest.config.ts"
+      ],
+      "output": []
+    },
     "test:e2e": {
       "command": "npx playwright test",
       "dependencies": [
@@ -329,7 +357,7 @@
       ]
     },
     "test:coverage": {
-      "command": "vitest run --coverage",
+      "command": "vitest run --project unit --coverage",
       "dependencies": [
         "check:types"
       ],
@@ -503,8 +531,8 @@
   },
   "lint-staged": {
     "*.ts": [
-      "biome check --write",
-      "vitest related --run"
+      "biome check --write --no-errors-on-unmatched",
+      "vitest related --run --project unit"
     ]
   },
   "devDependencies": {
@@ -521,14 +549,14 @@
     "@stryker-mutator/core": "9.6.1",
     "@stryker-mutator/typescript-checker": "9.6.1",
     "@stryker-mutator/vitest-runner": "9.6.1",
-    "@types/node": "25.8.0",
-    "@vitest/coverage-v8": "4.1.6",
+    "@types/node": "25.9.1",
+    "@vitest/coverage-v8": "4.1.7",
     "cspell": "10.0.0",
     "dependency-cruiser": "17.4.0",
     "fast-check": "4.8.0",
     "husky": "9.1.7",
-    "isomorphic-git": "1.38.0",
-    "jscpd": "4.2.2",
+    "isomorphic-git": "1.38.1",
+    "jscpd": "4.2.3",
     "knip": "6.14.1",
     "lint-staged": "17.0.5",
     "rollup": "4.60.4",
@@ -537,7 +565,7 @@
     "size-limit": "12.1.0",
     "typedoc": "0.28.19",
     "typescript": "6.0.3",
-    "vitest": "4.1.6",
+    "vitest": "4.1.7",
     "wireit": "0.14.12"
   }
 }

package/dist/cjs/chunks/error-DL4SHCBJ.cjs

@@ -1,2 +0,0 @@
-"use strict";class e extends Error{data;name="TsgitError";constructor(e){super(`${e.code}: ${function(e){switch(e.code){case"INVALID_OBJECT_ID":case"INVALID_FILE_MODE":return e.value;case"INVALID_OBJECT_HEADER":case"INVALID_TREE_ENTRY":case"INVALID_COMMIT":case"INVALID_TAG":case"INVALID_IDENTITY":case"INVALID_PACK_HEADER":case"INVALID_PACK_INDEX":case"INVALID_PACK_ENTRY":case"INVALID_DELTA":case"INVALID_REF":case"INVALID_PACKED_REFS":case"INVALID_INDEX_HEADER":case"INVALID_INDEX_ENTRY":return e.reason;case"FILE_NOT_FOUND":return`file not found: ${r(e.path)}`;case"FILE_EXISTS":return`file already exists: ${r(e.path)}`;case"NOT_A_DIRECTORY":return`not a directory: ${r(e.path)}`;case"PERMISSION_DENIED":return`permission denied: ${r(e.path)}`;case"UNSUPPORTED_OPERATION":return`unsupported operation: ${e.operation}: ${e.reason}`;case"HASH_FAILED":return`hash computation failed: ${e.reason}`;case"COMPRESS_FAILED":return`compression failed: ${e.reason}`;case"DECOMPRESS_FAILED":return`decompression failed: ${e.reason}`;case"HTTP_ERROR":return`HTTP ${e.statusCode}: ${e.reason}`;case"NETWORK_ERROR":return`network error: ${e.reason}`;case"INVALID_TREE_FOR_DIFF":return`invalid tree for diff: ${e.reason}`;case"INVALID_DIFF_INPUT":return`invalid diff input: ${e.reason}`;case"INVALID_MERGE_TREE":return`invalid merge tree: ${e.reason}`;case"INVALID_MERGE_INPUT":return`invalid merge input: ${e.reason}`;case"OBJECT_NOT_FOUND":return`object not found: ${e.id}`;case"OBJECT_HASH_MISMATCH":return`object hash mismatch: expected=${e.expected} actual=${e.actual}`;case"UNEXPECTED_OBJECT_TYPE":return`unexpected object type: expected=${e.expected} actual=${e.actual} id=${e.id}`;case"TREE_CYCLE_DETECTED":return`tree cycle detected: ${e.id}`;case"TREE_DEPTH_EXCEEDED":return`tree depth exceeded: ${e.depth}`;case"TREE_ENTRY_LIMIT_EXCEEDED":return`tree entry limit exceeded: count=${e.count} limit=${e.limit}`;case"DELTA_CHAIN_TOO_DEEP":return`delta chain too deep: ${e.depth}`;case"REF_NOT_FOUND":return`ref not found: ${e.name}`;case"REF_CHAIN_TOO_DEEP":return`ref chain too deep: depth=${e.depth} chain=${e.chain.join("->")}`;case"REF_CYCLE_DETECTED":return`ref cycle detected: ${e.chain.join("->")}`;case"REF_LOCKED":return`ref locked: ${e.name}`;case"REF_UPDATE_CONFLICT":return`ref update conflict: name=${e.name} expected=${e.expected} actual=${e.actual}`;case"INVALID_WALK_INPUT":return`invalid walk input: ${e.reason}`;case"OPERATION_ABORTED":return"operation aborted";case"INVALID_PKT_LENGTH":return`invalid pkt-line length: ${e.value}`;case"PKT_LENGTH_RESERVED":return`reserved pkt-line length: ${e.value}`;case"PKT_TOO_LARGE":return`pkt-line too large: ${e.value} bytes (max 65520)`;case"PKT_TRUNCATED":return`pkt-line truncated: ${e.remaining} bytes remaining`;case"INVALID_BASE_URL":return`invalid base URL: ${e.reason}`;case"MISSING_SERVICE_HEADER":return`missing service header: expected=${e.expected} actual=${e.actual}`;case"MISSING_CAPABILITIES":return"missing capabilities in advertisement";case"INVALID_REF_LINE":return`invalid ref line: ${e.line}`;case"DUPLICATE_REF":return`duplicate ref: ${e.name}`;case"INVALID_SIDEBAND_CHANNEL":return`invalid sideband channel: ${e.channel}`;case"SIDEBAND_FATAL":return`sideband fatal: ${e.message}`;case"UNKNOWN_ACK_STATUS":return`unknown ack status: ${e.value}`;case"INVALID_REPORT_STATUS":return`invalid report-status line: ${e.line}`;case"EMPTY_WANTS":return"upload-pack request has no wants";case"EMPTY_RECEIVE_UPDATES":return"receive-pack request has no updates";case"RESOURCE_LOCKED":return`${e.resource} locked: ${r(e.path)}`;case"PACK_TOO_LARGE":return`pack contains ${e.objectCount} objects, exceeds limit ${e.limit}`;case"NOT_A_REPOSITORY":return`not a git repository: ${r(e.path)}`;case"BARE_REPOSITORY":return`operation requires a working tree: ${e.operation}`;case"ALREADY_INITIALIZED":return`repository already exists: ${r(e.path)}`;case"WORKING_TREE_DIRTY":return`working tree has uncommitted changes: ${e.paths.length} files`;case"PATHSPEC_NO_MATCH":return`pathspec did not match any files: ${e.pattern}`;case"PATHSPEC_OUTSIDE_REPO":return`pathspec resolves outside repository: ${r(e.path)}`;case"NOTHING_TO_COMMIT":return"nothing to commit (use allowEmpty: true to commit anyway)";case"EMPTY_COMMIT_MESSAGE":return"commit message is empty (use allowEmptyMessage: true to commit anyway)";case"AUTHOR_UNCONFIGURED":return"author identity not configured (set ctx.config.user or pass author/committer)";case"BRANCH_EXISTS":return`branch already exists: ${e.name}`;case"BRANCH_NOT_FOUND":return`branch not found: ${e.name}`;case"TAG_EXISTS":return`tag already exists: ${e.name}`;case"TAG_NOT_FOUND":return`tag not found: ${e.name}`;case"CANNOT_DELETE_CHECKED_OUT_BRANCH":return`cannot delete branch currently checked out: ${e.name}`;case"INVALID_URL":return`invalid URL: ${e.reason}`;case"BLOCKED_HOST":return`host blocked: ${e.host} (${e.reason})`;case"TOO_MANY_REDIRECTS":return`too many redirects: ${e.count}`;case"UNSUPPORTED_SCHEME":return`unsupported URL scheme: ${e.scheme}`;case"TARGET_DIRECTORY_NOT_EMPTY":return`target directory is not empty: ${r(e.path)}`;case"REMOTE_ADVERTISES_NO_REFS":return"remote advertised no refs";case"NON_FAST_FORWARD":return`non-fast-forward update for ${e.ref}: local=${e.local} remote=${e.remote}`;case"PUSH_REJECTED":return`push rejected for ${e.ref}: ${e.reason}`;case"MERGE_HAS_CONFLICTS":return`merge has unresolved conflicts: ${e.count} files`;case"CHECKOUT_OVERWRITE_DIRTY":return`checkout would overwrite uncommitted changes: ${e.paths.length} files`;case"REVPARSE_AMBIGUOUS":return`revision expression "${e.expression}" is ambiguous (${e.candidates.length} candidates)`;case"REVPARSE_UNRESOLVED":return`cannot resolve revision: ${e.expression}`;case"EMPTY_PATHSPEC":return'pathspec is empty (use "." to mean "all paths")';case"OPERATION_IN_PROGRESS":return`${e.operation} in progress; complete or abort it before running this command`;case"MAX_REFSPECS_EXCEEDED":return`${e.count} refspecs exceeds limit ${e.limit}`;case"REMOTE_NOT_CONFIGURED":return`remote not configured: ${e.remote}`;case"REFSPEC_INVALID":return`invalid refspec "${e.raw}": ${e.reason}`;case"INVALID_OPTION":return`invalid option: ${e.option} — ${e.reason}`;case"REPOSITORY_DISPOSED":return"repository has been disposed; create a new one with openRepository()";case"ADAPTER_UNAVAILABLE":return`adapter unavailable for runtime ${e.runtime}: ${e.reason}`;default:return String(e)}}(e)}`),this.data=e}}function r(e){const r=e.split(/[/\\]/);for(let e=r.length-1;e>=0;e--){const t=r[e];if(void 0!==t&&""!==t)return t}return e}exports.TsgitError=e,exports.compressFailed=r=>new e({code:"COMPRESS_FAILED",reason:r}),exports.decompressFailed=r=>new e({code:"DECOMPRESS_FAILED",reason:r}),exports.fileExists=r=>new e({code:"FILE_EXISTS",path:r}),exports.fileNotFound=r=>new e({code:"FILE_NOT_FOUND",path:r}),exports.hashFailed=r=>new e({code:"HASH_FAILED",reason:r}),exports.invalidWalkInput=r=>new e({code:"INVALID_WALK_INPUT",reason:r}),exports.networkError=r=>new e({code:"NETWORK_ERROR",reason:r}),exports.notADirectory=r=>new e({code:"NOT_A_DIRECTORY",path:r}),exports.operationAborted=()=>new e({code:"OPERATION_ABORTED"}),exports.permissionDenied=r=>new e({code:"PERMISSION_DENIED",path:r}),exports.unsupportedOperation=(r,t)=>new e({code:"UNSUPPORTED_OPERATION",operation:r,reason:t});
-//# sourceMappingURL=error-DL4SHCBJ.cjs.map

package/dist/cjs/chunks/error-DL4SHCBJ.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-DL4SHCBJ.cjs","sources":["../../../src/domain/error.ts"],"sourcesContent":[null],"names":["TsgitError","Error","data","name","constructor","super","code","value","reason","basename","path","operation","statusCode","id","expected","actual","depth","count","limit","chain","join","remaining","line","channel","message","resource","objectCount","paths","length","pattern","host","scheme","ref","local","remote","expression","candidates","raw","option","runtime","String","extractDetail","this","segments","split","i","segment","undefined"],"mappings":"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"}

package/dist/cjs/chunks/error-DN8Vnwr4.cjs

@@ -1,2 +0,0 @@
-"use strict";var r=require("./error-DL4SHCBJ.cjs");const e=r=>{let e="";for(let o=0;o<r.length;o+=1){const t=r.charCodeAt(o);e+=9===t||10===t||t>=32&&t<=126?r[o]:`\\x${t.toString(16).toUpperCase().padStart(2,"0")}`}return e},o=e;exports.adapterUnavailable=(o,t)=>new r.TsgitError({code:"ADAPTER_UNAVAILABLE",runtime:o,reason:e(t)}),exports.authorUnconfigured=()=>new r.TsgitError({code:"AUTHOR_UNCONFIGURED"}),exports.blockedHost=(o,t)=>new r.TsgitError({code:"BLOCKED_HOST",host:e(o),reason:e(t)}),exports.branchExists=e=>new r.TsgitError({code:"BRANCH_EXISTS",name:e}),exports.branchNotFound=e=>new r.TsgitError({code:"BRANCH_NOT_FOUND",name:e}),exports.cannotDeleteCheckedOutBranch=e=>new r.TsgitError({code:"CANNOT_DELETE_CHECKED_OUT_BRANCH",name:e}),exports.checkoutOverwriteDirty=e=>new r.TsgitError({code:"CHECKOUT_OVERWRITE_DIRTY",paths:e}),exports.emptyCommitMessage=()=>new r.TsgitError({code:"EMPTY_COMMIT_MESSAGE"}),exports.emptyPathspec=()=>new r.TsgitError({code:"EMPTY_PATHSPEC"}),exports.invalidOption=(o,t)=>new r.TsgitError({code:"INVALID_OPTION",option:o,reason:e(t)}),exports.invalidUrl=e=>new r.TsgitError({code:"INVALID_URL",reason:e}),exports.nonFastForward=(e,o,t)=>new r.TsgitError({code:"NON_FAST_FORWARD",ref:e,local:o,remote:t}),exports.nothingToCommit=()=>new r.TsgitError({code:"NOTHING_TO_COMMIT"}),exports.operationInProgress=e=>new r.TsgitError({code:"OPERATION_IN_PROGRESS",operation:e}),exports.pathspecNoMatch=e=>new r.TsgitError({code:"PATHSPEC_NO_MATCH",pattern:e}),exports.pathspecOutsideRepo=e=>new r.TsgitError({code:"PATHSPEC_OUTSIDE_REPO",path:e}),exports.remoteAdvertisesNoRefs=()=>new r.TsgitError({code:"REMOTE_ADVERTISES_NO_REFS"}),exports.remoteNotConfigured=e=>new r.TsgitError({code:"REMOTE_NOT_CONFIGURED",remote:e}),exports.repositoryDisposed=()=>new r.TsgitError({code:"REPOSITORY_DISPOSED"}),exports.revparseUnresolved=e=>new r.TsgitError({code:"REVPARSE_UNRESOLVED",expression:e}),exports.sanitize=o,exports.tagExists=e=>new r.TsgitError({code:"TAG_EXISTS",name:e}),exports.tagNotFound=e=>new r.TsgitError({code:"TAG_NOT_FOUND",name:e}),exports.targetDirectoryNotEmpty=e=>new r.TsgitError({code:"TARGET_DIRECTORY_NOT_EMPTY",path:e}),exports.unsupportedScheme=e=>new r.TsgitError({code:"UNSUPPORTED_SCHEME",scheme:e});
-//# sourceMappingURL=error-DN8Vnwr4.cjs.map

package/dist/cjs/chunks/error-DN8Vnwr4.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"error-DN8Vnwr4.cjs","sources":["../../../src/domain/commands/error.ts"],"sourcesContent":[null],"names":["sanitizeForDisplay","s","out","i","length","code","charCodeAt","toString","toUpperCase","padStart","sanitize","runtime","reason","TsgitError","host","name","paths","option","ref","local","remote","operation","pattern","path","expression","scheme"],"mappings":"mDAyDA,MAAMA,EAAsBC,IAC1B,IAAIC,EAAM,GACV,IAAK,IAAIC,EAAI,EAAGA,EAAIF,EAAEG,OAAQD,GAAK,EAAG,CACpC,MAAME,EAAOJ,EAAEK,WAAWH,GAExBD,GADW,IAATG,GAA0B,KAATA,GAAkBA,GAAQ,IAAQA,GAAQ,IACtDJ,EAAEE,GAEF,MAAME,EAAKE,SAAS,IAAIC,cAAcC,SAAS,EAAG,MAE7D,CACA,OAAOP,GAGIQ,EAAWV,6BA+FU,CAChCW,EACAC,IAEA,IAAIC,EAAAA,WAAW,CACbR,KAAM,sBACNM,UACAC,OAAQZ,EAAmBY,gCAtFG,IAAkB,IAAIC,EAAAA,WAAW,CAAER,KAAM,4CAoBhD,CAACS,EAAcF,IACxC,IAAIC,EAAAA,WAAW,CACbR,KAAM,eACNS,KAAMd,EAAmBc,GACzBF,OAAQZ,EAAmBY,0BAtBFG,GAC3B,IAAIF,EAAAA,WAAW,CAAER,KAAM,gBAAiBU,gCAEXA,GAC7B,IAAIF,EAAAA,WAAW,CAAER,KAAM,mBAAoBU,8CAQAA,GAC3C,IAAIF,EAAAA,WAAW,CAAER,KAAM,mCAAoCU,wCAoCtBC,GACrC,IAAIH,EAAAA,WAAW,CAAER,KAAM,2BAA4BW,qCAvDnB,IAChC,IAAIH,EAAAA,WAAW,CAAER,KAAM,+CAgEI,IAAkB,IAAIQ,EAAAA,WAAW,CAAER,KAAM,yCAYzC,CAACY,EAAgBL,IAC5C,IAAIC,EAAAA,WAAW,CAAER,KAAM,iBAAkBY,SAAQL,OAAQZ,EAAmBY,wBA1DnDA,GACzB,IAAIC,EAAAA,WAAW,CAAER,KAAM,cAAeO,kCAqBV,CAACM,EAAcC,EAAiBC,IAC5D,IAAIP,EAAAA,WAAW,CAAER,KAAM,mBAAoBa,MAAKC,QAAOC,mCA7C1B,IAAkB,IAAIP,EAAAA,WAAW,CAAER,KAAM,kDAsEtEgB,GACe,IAAIR,EAAAA,WAAW,CAAER,KAAM,wBAAyBgB,sCA7EjCC,GAC9B,IAAIT,EAAAA,WAAW,CAAER,KAAM,oBAAqBiB,wCAEVC,GAClC,IAAIV,EAAAA,WAAW,CAAER,KAAM,wBAAyBkB,wCA2CZ,IACpC,IAAIV,EAAAA,WAAW,CAAER,KAAM,0DAkCWe,GAClC,IAAIP,EAAAA,WAAW,CAAER,KAAM,wBAAyBe,sCAKhB,IAAkB,IAAIP,EAAAA,WAAW,CAAER,KAAM,mDAlBxCmB,GACjC,IAAIX,EAAAA,WAAW,CAAER,KAAM,sBAAuBmB,oDApDtBT,GACxB,IAAIF,EAAAA,WAAW,CAAER,KAAM,aAAcU,6BAEXA,GAC1B,IAAIF,EAAAA,WAAW,CAAER,KAAM,gBAAiBU,yCAqBFQ,GACtC,IAAIV,EAAAA,WAAW,CAAER,KAAM,6BAA8BkB,mCAJrBE,GAChC,IAAIZ,EAAAA,WAAW,CAAER,KAAM,qBAAsBoB"}