@scolladon/tsgit 0.9.0

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

@@ -0,0 +1,336 @@
+import { b as FilePath, a as Context, j as RefName, O as ObjectId } from '../chunks/context-C6df52Qs.js';
+import { A as AuthorIdentity, T as TreeDiff } from '../chunks/diff-change-CUWN3OSK.js';
+import '../chunks/http-transport--_NdQOiw.js';
+
+interface AddOptions {
+    readonly force?: boolean;
+    readonly all?: boolean;
+    readonly breakStaleLockMs?: number;
+}
+interface AddResult {
+    readonly added: ReadonlyArray<FilePath>;
+    readonly modified: ReadonlyArray<FilePath>;
+    readonly removed: ReadonlyArray<FilePath>;
+}
+/**
+ * Add the given pathspecs to the index. Performs:
+ * 1. Repo + bare + pending-op preflight checks.
+ * 2. Path validation for every input (no I/O on rejection).
+ * 3. Read working-tree contents → write blob → produce IndexEntry.
+ * 4. Atomically replace `.git/index` under the index lock.
+ *
+ * Bulk mode (`all: true`) is not yet implemented — this is the literal-paths
+ * happy path used by `init`/`commit` integration tests.
+ */
+declare const add: (ctx: Context, paths: ReadonlyArray<string>, opts?: AddOptions) => Promise<AddResult>;
+
+type BranchAction = {
+    readonly kind: 'list';
+} | {
+    readonly kind: 'create';
+    readonly name: string;
+    readonly startPoint?: string;
+    readonly force?: boolean;
+} | {
+    readonly kind: 'delete';
+    readonly name: string;
+    readonly force?: boolean;
+} | {
+    readonly kind: 'rename';
+    readonly from: string;
+    readonly to: string;
+    readonly force?: boolean;
+};
+interface BranchInfo {
+    readonly name: RefName;
+    readonly id: ObjectId;
+    readonly current: boolean;
+}
+type BranchResult = {
+    readonly kind: 'list';
+    readonly branches: ReadonlyArray<BranchInfo>;
+} | {
+    readonly kind: 'create';
+    readonly name: RefName;
+    readonly id: ObjectId;
+} | {
+    readonly kind: 'delete';
+    readonly name: RefName;
+} | {
+    readonly kind: 'rename';
+    readonly from: RefName;
+    readonly to: RefName;
+};
+declare const branch: (ctx: Context, action: BranchAction) => Promise<BranchResult>;
+
+interface CheckoutOptions {
+    readonly target: string;
+    readonly detach?: boolean;
+    readonly force?: boolean;
+}
+interface CheckoutResult {
+    readonly branch: RefName | undefined;
+    readonly id: ObjectId;
+    readonly detached: boolean;
+}
+declare const checkout: (ctx: Context, opts: CheckoutOptions) => Promise<CheckoutResult>;
+
+/** Pluggable DNS resolver. Returns the addresses for `host`, in order. */
+type DnsResolver = (host: string) => Promise<ReadonlyArray<string>>;
+
+interface CloneOptions {
+    readonly url: string;
+    readonly bare?: boolean;
+    readonly initialBranch?: string;
+    readonly depth?: number;
+    /** DNS resolver injected by the caller; required to enforce SSRF guards. */
+    readonly resolver?: DnsResolver;
+    readonly allowInsecure?: boolean;
+    readonly allowPrivateNetworks?: boolean;
+}
+interface CloneResult {
+    readonly path: FilePath;
+    readonly head: RefName | undefined;
+    readonly fetchedRefs: ReadonlyArray<{
+        readonly name: RefName;
+        readonly id: ObjectId;
+    }>;
+}
+declare const clone: (ctx: Context, opts: CloneOptions) => Promise<CloneResult>;
+
+interface CommitOptions {
+    readonly message: string;
+    readonly author?: AuthorIdentity;
+    readonly committer?: AuthorIdentity;
+    readonly allowEmpty?: boolean;
+    readonly allowEmptyMessage?: boolean;
+}
+interface CommitResult {
+    readonly id: ObjectId;
+    readonly tree: ObjectId;
+    readonly branch: RefName | undefined;
+    readonly parents: ReadonlyArray<ObjectId>;
+}
+/**
+ * Create a new commit from the current index. Resolves author/committer from
+ * options or `.git/config` `[user]`, writes a tree from the index, builds the
+ * commit object, and updates HEAD's target ref (or detached HEAD itself).
+ *
+ * Throws `NOTHING_TO_COMMIT` when the new tree matches the parent's tree and
+ * `allowEmpty` is not set; `EMPTY_COMMIT_MESSAGE` when the message is blank
+ * and `allowEmptyMessage` is not set.
+ */
+declare const commit: (ctx: Context, opts: CommitOptions) => Promise<CommitResult>;
+
+interface DiffOptions {
+    /** Resolve to a tree. Accepts ref name, oid, or 'HEAD'. */
+    readonly from?: string;
+    readonly to?: string;
+    readonly detectRenames?: boolean;
+}
+/**
+ * Diff two tree-like targets and return the resulting `TreeDiff`. When `from`
+ * is omitted, defaults to HEAD's tree; when `to` is omitted, defaults to
+ * `undefined` (interpreted by `diffTrees` as the empty tree).
+ */
+declare const diff: (ctx: Context, opts?: DiffOptions) => Promise<TreeDiff>;
+
+interface FetchOptions {
+    readonly remote?: string;
+    readonly refspecs?: ReadonlyArray<string>;
+    readonly prune?: boolean;
+}
+interface FetchResult {
+    readonly remote: string;
+    readonly url: string;
+    readonly updatedRefs: ReadonlyArray<{
+        readonly name: RefName;
+        readonly oldId: ObjectId | undefined;
+        readonly newId: ObjectId;
+    }>;
+}
+declare const fetch: (ctx: Context, opts?: FetchOptions) => Promise<FetchResult>;
+
+interface InitOptions {
+    readonly initialBranch?: string;
+    readonly bare?: boolean;
+}
+interface InitResult {
+    readonly path: FilePath;
+    readonly initialBranch: RefName;
+    readonly bare: boolean;
+}
+/**
+ * Initialize a fresh repository at `ctx.layout.gitDir`. Throws
+ * `ALREADY_INITIALIZED` when the target gitDir already exists; otherwise
+ * delegates to `bootstrapRepository` for the standard layout.
+ *
+ * For non-bare repos, the gitDir is `<workDir>/.git`. For bare, gitDir IS the
+ * working dir — callers must construct a Context with `bare: true` for that
+ * shape (Phase 10 facade will derive this automatically).
+ */
+declare const init: (ctx: Context, opts?: InitOptions) => Promise<InitResult>;
+
+interface LogOptions {
+    readonly from?: string;
+    readonly limit?: number;
+    readonly excluding?: ReadonlyArray<string>;
+    readonly before?: Date;
+}
+interface LogEntry {
+    readonly id: ObjectId;
+    readonly tree: ObjectId;
+    readonly parents: ReadonlyArray<ObjectId>;
+    readonly author: AuthorIdentity;
+    readonly committer: AuthorIdentity;
+    readonly message: string;
+}
+/**
+ * Walk first-parent commits starting from `from` (default: HEAD), yielding
+ * ordered `LogEntry` records. Honors `limit`, `excluding` (oid stops), and
+ * `before` (only commits with `committer.timestamp < before`).
+ */
+declare const log: (ctx: Context, opts?: LogOptions) => Promise<ReadonlyArray<LogEntry>>;
+
+interface MergeOptions {
+    readonly target: string;
+    readonly message?: string;
+    readonly fastForwardOnly?: boolean;
+    readonly noFastForward?: boolean;
+    readonly author?: AuthorIdentity;
+    readonly committer?: AuthorIdentity;
+}
+type MergeResult = {
+    readonly kind: 'up-to-date';
+    readonly id: ObjectId;
+} | {
+    readonly kind: 'fast-forward';
+    readonly id: ObjectId;
+    readonly branch: RefName;
+} | {
+    readonly kind: 'merge';
+    readonly id: ObjectId;
+    readonly branch: RefName;
+    readonly parents: ReadonlyArray<ObjectId>;
+};
+/**
+ * Merge `target` into the current HEAD branch. v1 supports:
+ * - Up-to-date detection (target is ancestor of HEAD).
+ * - Fast-forward (HEAD is ancestor of target → branch advances).
+ * - True merge for diverged histories: writes a merge commit using HEAD's tree
+ *   (callers must run `add` to incorporate target's content). Conflict
+ *   resolution and three-way tree merge land in Phase 11.
+ */
+declare const merge: (ctx: Context, opts: MergeOptions) => Promise<MergeResult>;
+
+interface PushOptions {
+    readonly remote?: string;
+    readonly refspecs?: ReadonlyArray<string>;
+    readonly force?: boolean;
+    readonly forceWithLease?: ObjectId | 'auto';
+}
+interface PushResult {
+    readonly remote: string;
+    readonly url: string;
+    readonly pushedRefs: ReadonlyArray<{
+        readonly name: RefName;
+        readonly newId: ObjectId;
+        readonly status: 'ok' | 'rejected';
+    }>;
+}
+declare const push: (ctx: Context, opts?: PushOptions) => Promise<PushResult>;
+
+type ResetMode = 'soft' | 'mixed' | 'hard';
+interface ResetOptions {
+    readonly mode: ResetMode;
+    readonly target: string;
+}
+interface ResetResult {
+    readonly mode: ResetMode;
+    readonly id: ObjectId;
+    readonly branch: RefName | undefined;
+}
+/**
+ * Reset HEAD (and optionally index/working tree) to `target`.
+ *
+ * - `soft`:  HEAD only.
+ * - `mixed`: HEAD + clears the index (Phase 9 stub: index cleared via lock release).
+ * - `hard`:  HEAD + index + working tree (working-tree mutation deferred to Phase 11).
+ *
+ * v1 implements the HEAD-update path; index/working-tree side effects beyond
+ * the HEAD move land in subsequent passes once `materializeFile`/`removeFile`
+ * orchestration is in place.
+ */
+declare const reset: (ctx: Context, opts: ResetOptions) => Promise<ResetResult>;
+
+declare const revParse: (ctx: Context, expression: string) => Promise<ObjectId>;
+
+interface RmOptions {
+    readonly cached?: boolean;
+    readonly breakStaleLockMs?: number;
+}
+interface RmResult {
+    readonly removed: ReadonlyArray<FilePath>;
+}
+/**
+ * Remove the given paths from the index (and from the working tree unless
+ * `cached: true`). Refuses when a path isn't tracked, matches `git rm`'s default.
+ */
+declare const rm: (ctx: Context, paths: ReadonlyArray<string>, opts?: RmOptions) => Promise<RmResult>;
+
+type ChangeKind = 'modified' | 'added' | 'deleted' | 'untracked';
+interface ChangeEntry {
+    readonly kind: ChangeKind;
+    readonly path: FilePath;
+}
+interface StatusResult {
+    readonly branch: RefName | undefined;
+    readonly detached: boolean;
+    readonly indexChanges: ReadonlyArray<ChangeEntry>;
+    readonly workingTreeChanges: ReadonlyArray<ChangeEntry>;
+    readonly clean: boolean;
+}
+/**
+ * Summarize the state of the working tree relative to the index, and the
+ * branch HEAD points at. Working-tree-vs-HEAD diff (Git's "staged" column)
+ * is approximated via index-vs-working-tree comparisons until Phase 11
+ * adds the stat-cache fast path.
+ *
+ * Progress reporting (Phase 10 §6.2): emits `status:scan` start before the
+ * fan-out, updates at every 100 lstat completions, and end in a finally
+ * block so the consumer always pairs start with end. `total` is undefined
+ * — design choice that prevents revealing repository size to non-trusted
+ * progress sinks.
+ */
+declare const status: (ctx: Context) => Promise<StatusResult>;
+
+type TagAction = {
+    readonly kind: 'list';
+} | {
+    readonly kind: 'create';
+    readonly name: string;
+    readonly target?: string;
+    readonly force?: boolean;
+} | {
+    readonly kind: 'delete';
+    readonly name: string;
+};
+interface TagInfo {
+    readonly name: RefName;
+    readonly id: ObjectId;
+}
+type TagResult = {
+    readonly kind: 'list';
+    readonly tags: ReadonlyArray<TagInfo>;
+} | {
+    readonly kind: 'create';
+    readonly name: RefName;
+    readonly id: ObjectId;
+} | {
+    readonly kind: 'delete';
+    readonly name: RefName;
+};
+declare const tag: (ctx: Context, action: TagAction) => Promise<TagResult>;
+
+export { add, branch, checkout, clone, commit, diff, fetch, init, log, merge, push, reset, revParse, rm, status, tag };
+export type { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, StatusResult, TagAction, TagInfo, TagResult };

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

@@ -0,0 +1,26 @@
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-Cv4Y0T9t.cjs';
+export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.cjs';
+export { P as ProgressReporter } from './chunks/context-Ku1aP8Ie.cjs';
+import './commands/index.cjs';
+import './chunks/diff-change-BwO75AgS.cjs';
+import './primitives/index.cjs';
+import './chunks/http-transport--_NdQOiw.cjs';
+
+/**
+ * Browser-runtime extension to `OpenRepositoryOptions`. The browser cannot
+ * derive a default `rootHandle` (no equivalent of `process.cwd()`), so the
+ * caller must provide it. `gitDirName` controls the in-OPFS directory name
+ * used for `.git` (escapes the dot when running under hosts that disallow
+ * dot-prefixed names).
+ */
+interface OpenBrowserRepositoryOptions extends OpenRepositoryOptions {
+    readonly rootHandle: FileSystemDirectoryHandle;
+    readonly gitDirName?: string;
+    readonly bare?: boolean;
+    readonly deltaCacheMaxBytes?: number;
+    readonly deltaCacheMaxEntries?: number;
+}
+declare const openRepository: (opts: OpenBrowserRepositoryOptions) => Promise<Repository>;
+
+export { OpenRepositoryOptions, Repository, openRepository };
+export type { OpenBrowserRepositoryOptions };

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

@@ -0,0 +1,26 @@
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-BBKJnr8a.js';
+export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.js';
+export { P as ProgressReporter } from './chunks/context-C6df52Qs.js';
+import './commands/index.js';
+import './chunks/diff-change-CUWN3OSK.js';
+import './primitives/index.js';
+import './chunks/http-transport--_NdQOiw.js';
+
+/**
+ * Browser-runtime extension to `OpenRepositoryOptions`. The browser cannot
+ * derive a default `rootHandle` (no equivalent of `process.cwd()`), so the
+ * caller must provide it. `gitDirName` controls the in-OPFS directory name
+ * used for `.git` (escapes the dot when running under hosts that disallow
+ * dot-prefixed names).
+ */
+interface OpenBrowserRepositoryOptions extends OpenRepositoryOptions {
+    readonly rootHandle: FileSystemDirectoryHandle;
+    readonly gitDirName?: string;
+    readonly bare?: boolean;
+    readonly deltaCacheMaxBytes?: number;
+    readonly deltaCacheMaxEntries?: number;
+}
+declare const openRepository: (opts: OpenBrowserRepositoryOptions) => Promise<Repository>;
+
+export { OpenRepositoryOptions, Repository, openRepository };
+export type { OpenBrowserRepositoryOptions };

package/dist/types/index.d.cts

@@ -0,0 +1,68 @@
+import { F as FileSystem, H as HashService, C as Compressor, P as ProgressReporter } from './chunks/context-Ku1aP8Ie.cjs';
+export { A as AuthStrategy, f as AuthorIdentity, a as Context, g as CreateContextParts, D as DirEntry, c as FileStat, e as Hasher, L as Logger, R as RepositoryConfig, h as RepositoryLayout, i as createContext, n as noopLogger, w as wrapLoggerSanitizer } from './chunks/context-Ku1aP8Ie.cjs';
+import { H as HttpTransport } from './chunks/http-transport--_NdQOiw.cjs';
+export { a as HttpRequest, b as HttpResponse } from './chunks/http-transport--_NdQOiw.cjs';
+export { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, StatusResult, TagAction, TagInfo, TagResult, add, branch, checkout, clone, commit, diff, fetch, init, log, merge, push, reset, revParse, rm, status, tag } from './commands/index.cjs';
+import './chunks/diff-change-BwO75AgS.cjs';
+
+/**
+ * The four adapter ports the facade plumbs into the Context. Each runtime
+ * shim (`index.node.ts`, `index.browser.ts`, `index.default.ts` — wired in
+ * Step 5) provides a `detectAdapter(): AdapterSet` that returns the runtime-
+ * appropriate set.
+ */
+interface AdapterSet {
+    readonly fs: FileSystem;
+    readonly hash: HashService;
+    readonly compressor: Compressor;
+    readonly transport: HttpTransport;
+}
+/**
+ * Prototype-pollution-safe runtime check. Returns true only when `process` is
+ * an object that owns BOTH `versions` and `versions.node` as own properties —
+ * an attacker who pollutes `Object.prototype.versions` cannot make this
+ * return true.
+ *
+ * Used as a manual fallback only; the primary detection mechanism is
+ * `package.json` conditional exports (resolved at bundle time, immune to
+ * runtime pollution).
+ */
+declare const isNode: () => boolean;
+/**
+ * Returns true when both `window` and `navigator` exist AS OWN globals on
+ * `globalThis` AND have non-undefined values. Two-stage check:
+ * - `hasOwn` rejects properties inherited from a polluted `Object.prototype`.
+ * - `typeof` rejects own properties that have been assigned `undefined`
+ *   (e.g., test harnesses that stub the global to undefined).
+ */
+declare const isBrowser: () => boolean;
+/**
+ * Three-way runtime classification used by manual call sites. Node takes
+ * precedence over browser when both look present (e.g., test environments
+ * with jsdom + a real Node process).
+ */
+declare const detectRuntime: () => "node" | "browser" | "memory";
+
+/** No-op reporter — default when the caller does not provide one. */
+declare const noopProgress: ProgressReporter;
+/**
+ * Built-in reporter that emits one line per call to a user-supplied `sink`.
+ *
+ * Format:
+ *   start(op)             → "<safeOp>: start"
+ *   start(op, total)      → "<safeOp>: start/<total>"
+ *   update(op, c)         → "<safeOp>: <c>"
+ *   update(op, c, t)      → "<safeOp>: <c>/<t>"
+ *   update(op, c, t, txt) → "<safeOp>: <c>/<t> <safeText>"
+ *   end(op)               → "<safeOp>: done"
+ *
+ * `op` is sanitized identically to `text` (defense-in-depth: a programming bug
+ * that wires a sideband-derived string into `op` cannot inject control characters).
+ *
+ * A throwing `sink` cannot crash the reporter — every call is wrapped in
+ * try/catch.
+ */
+declare const consoleProgress: (sink: (line: string) => void) => ProgressReporter;
+
+export { Compressor, FileSystem, HashService, HttpTransport, ProgressReporter, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress };
+export type { AdapterSet };

package/dist/types/index.d.ts

@@ -0,0 +1,68 @@
+import { F as FileSystem, H as HashService, C as Compressor, P as ProgressReporter } from './chunks/context-C6df52Qs.js';
+export { A as AuthStrategy, f as AuthorIdentity, a as Context, g as CreateContextParts, D as DirEntry, c as FileStat, e as Hasher, L as Logger, R as RepositoryConfig, h as RepositoryLayout, i as createContext, n as noopLogger, w as wrapLoggerSanitizer } from './chunks/context-C6df52Qs.js';
+import { H as HttpTransport } from './chunks/http-transport--_NdQOiw.js';
+export { a as HttpRequest, b as HttpResponse } from './chunks/http-transport--_NdQOiw.js';
+export { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, StatusResult, TagAction, TagInfo, TagResult, add, branch, checkout, clone, commit, diff, fetch, init, log, merge, push, reset, revParse, rm, status, tag } from './commands/index.js';
+import './chunks/diff-change-CUWN3OSK.js';
+
+/**
+ * The four adapter ports the facade plumbs into the Context. Each runtime
+ * shim (`index.node.ts`, `index.browser.ts`, `index.default.ts` — wired in
+ * Step 5) provides a `detectAdapter(): AdapterSet` that returns the runtime-
+ * appropriate set.
+ */
+interface AdapterSet {
+    readonly fs: FileSystem;
+    readonly hash: HashService;
+    readonly compressor: Compressor;
+    readonly transport: HttpTransport;
+}
+/**
+ * Prototype-pollution-safe runtime check. Returns true only when `process` is
+ * an object that owns BOTH `versions` and `versions.node` as own properties —
+ * an attacker who pollutes `Object.prototype.versions` cannot make this
+ * return true.
+ *
+ * Used as a manual fallback only; the primary detection mechanism is
+ * `package.json` conditional exports (resolved at bundle time, immune to
+ * runtime pollution).
+ */
+declare const isNode: () => boolean;
+/**
+ * Returns true when both `window` and `navigator` exist AS OWN globals on
+ * `globalThis` AND have non-undefined values. Two-stage check:
+ * - `hasOwn` rejects properties inherited from a polluted `Object.prototype`.
+ * - `typeof` rejects own properties that have been assigned `undefined`
+ *   (e.g., test harnesses that stub the global to undefined).
+ */
+declare const isBrowser: () => boolean;
+/**
+ * Three-way runtime classification used by manual call sites. Node takes
+ * precedence over browser when both look present (e.g., test environments
+ * with jsdom + a real Node process).
+ */
+declare const detectRuntime: () => "node" | "browser" | "memory";
+
+/** No-op reporter — default when the caller does not provide one. */
+declare const noopProgress: ProgressReporter;
+/**
+ * Built-in reporter that emits one line per call to a user-supplied `sink`.
+ *
+ * Format:
+ *   start(op)             → "<safeOp>: start"
+ *   start(op, total)      → "<safeOp>: start/<total>"
+ *   update(op, c)         → "<safeOp>: <c>"
+ *   update(op, c, t)      → "<safeOp>: <c>/<t>"
+ *   update(op, c, t, txt) → "<safeOp>: <c>/<t> <safeText>"
+ *   end(op)               → "<safeOp>: done"
+ *
+ * `op` is sanitized identically to `text` (defense-in-depth: a programming bug
+ * that wires a sideband-derived string into `op` cannot inject control characters).
+ *
+ * A throwing `sink` cannot crash the reporter — every call is wrapped in
+ * try/catch.
+ */
+declare const consoleProgress: (sink: (line: string) => void) => ProgressReporter;
+
+export { Compressor, FileSystem, HashService, HttpTransport, ProgressReporter, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress };
+export type { AdapterSet };

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

@@ -0,0 +1,35 @@
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-Cv4Y0T9t.cjs';
+export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.cjs';
+export { P as ProgressReporter } from './chunks/context-Ku1aP8Ie.cjs';
+import './commands/index.cjs';
+import './chunks/diff-change-BwO75AgS.cjs';
+import './primitives/index.cjs';
+import './chunks/http-transport--_NdQOiw.cjs';
+
+/**
+ * Memory-runtime entry point. Selected by `package.json` `"exports"` for
+ * non-Node, non-browser runtimes — and explicitly available at
+ * `tsgit/auto/memory` for tests and deterministic fixtures regardless of
+ * the active runtime.
+ *
+ * Builds the runtime fallback (memory adapters + a `/repo`-rooted layout)
+ * and forwards every `openRepository(opts)` call to the core factory with
+ * the fallback pre-bound.
+ */
+
+/**
+ * Memory-runtime extension to `OpenRepositoryOptions`. Adds the deterministic-
+ * algorithm switch (sha1 vs sha256) and the optional initial in-memory FS
+ * seed used by tests and lab harnesses. Anything not listed here is
+ * forwarded verbatim to the core `openRepository`.
+ */
+interface OpenMemoryRepositoryOptions extends OpenRepositoryOptions {
+    /** Initial in-memory FS seed. Maps absolute paths to file bytes. */
+    readonly files?: Readonly<Record<string, Uint8Array>>;
+    /** Hash algorithm used by the runtime adapter. Default 'sha1'. */
+    readonly algorithm?: 'sha1' | 'sha256';
+}
+declare const openRepository: (opts?: OpenMemoryRepositoryOptions) => Promise<Repository>;
+
+export { OpenRepositoryOptions, Repository, openRepository };
+export type { OpenMemoryRepositoryOptions };

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

@@ -0,0 +1,35 @@
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-BBKJnr8a.js';
+export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.js';
+export { P as ProgressReporter } from './chunks/context-C6df52Qs.js';
+import './commands/index.js';
+import './chunks/diff-change-CUWN3OSK.js';
+import './primitives/index.js';
+import './chunks/http-transport--_NdQOiw.js';
+
+/**
+ * Memory-runtime entry point. Selected by `package.json` `"exports"` for
+ * non-Node, non-browser runtimes — and explicitly available at
+ * `tsgit/auto/memory` for tests and deterministic fixtures regardless of
+ * the active runtime.
+ *
+ * Builds the runtime fallback (memory adapters + a `/repo`-rooted layout)
+ * and forwards every `openRepository(opts)` call to the core factory with
+ * the fallback pre-bound.
+ */
+
+/**
+ * Memory-runtime extension to `OpenRepositoryOptions`. Adds the deterministic-
+ * algorithm switch (sha1 vs sha256) and the optional initial in-memory FS
+ * seed used by tests and lab harnesses. Anything not listed here is
+ * forwarded verbatim to the core `openRepository`.
+ */
+interface OpenMemoryRepositoryOptions extends OpenRepositoryOptions {
+    /** Initial in-memory FS seed. Maps absolute paths to file bytes. */
+    readonly files?: Readonly<Record<string, Uint8Array>>;
+    /** Hash algorithm used by the runtime adapter. Default 'sha1'. */
+    readonly algorithm?: 'sha1' | 'sha256';
+}
+declare const openRepository: (opts?: OpenMemoryRepositoryOptions) => Promise<Repository>;
+
+export { OpenRepositoryOptions, Repository, openRepository };
+export type { OpenMemoryRepositoryOptions };

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

@@ -0,0 +1,23 @@
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-Cv4Y0T9t.cjs';
+export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.cjs';
+export { P as ProgressReporter } from './chunks/context-Ku1aP8Ie.cjs';
+import './commands/index.cjs';
+import './chunks/diff-change-BwO75AgS.cjs';
+import './primitives/index.cjs';
+import './chunks/http-transport--_NdQOiw.cjs';
+
+/**
+ * Node-runtime extension to `OpenRepositoryOptions`. Adds `allowInsecureHttp`
+ * (forwarded to the Node HTTP transport — separate from the facade-tier
+ * `config.allowInsecure` which controls the SSRF guard). Adds delta-cache
+ * tuning for callers with non-standard memory budgets.
+ */
+interface OpenNodeRepositoryOptions extends OpenRepositoryOptions {
+    readonly allowInsecureHttp?: boolean;
+    readonly deltaCacheMaxBytes?: number;
+    readonly deltaCacheMaxEntries?: number;
+}
+declare const openRepository: (opts?: OpenNodeRepositoryOptions) => Promise<Repository>;
+
+export { OpenRepositoryOptions, Repository, openRepository };
+export type { OpenNodeRepositoryOptions };

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

@@ -0,0 +1,23 @@
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-BBKJnr8a.js';
+export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.js';
+export { P as ProgressReporter } from './chunks/context-C6df52Qs.js';
+import './commands/index.js';
+import './chunks/diff-change-CUWN3OSK.js';
+import './primitives/index.js';
+import './chunks/http-transport--_NdQOiw.js';
+
+/**
+ * Node-runtime extension to `OpenRepositoryOptions`. Adds `allowInsecureHttp`
+ * (forwarded to the Node HTTP transport — separate from the facade-tier
+ * `config.allowInsecure` which controls the SSRF guard). Adds delta-cache
+ * tuning for callers with non-standard memory budgets.
+ */
+interface OpenNodeRepositoryOptions extends OpenRepositoryOptions {
+    readonly allowInsecureHttp?: boolean;
+    readonly deltaCacheMaxBytes?: number;
+    readonly deltaCacheMaxEntries?: number;
+}
+declare const openRepository: (opts?: OpenNodeRepositoryOptions) => Promise<Repository>;
+
+export { OpenRepositoryOptions, Repository, openRepository };
+export type { OpenNodeRepositoryOptions };