@scolladon/tsgit 1.3.0 → 2.0.1

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

@@ -1,10 +1,11 @@
-import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-DCR_3RVt.cjs';
-export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.cjs';
-export { P as ProgressReporter } from './chunks/context-CMrHCVwK.cjs';
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-BeifCqp0.cjs';
+export { A as AdapterSet, c as consoleProgress, d as detectRuntime, i as isBrowser, a as isNode, n as noopProgress } from './chunks/progress-By8yFaUE.cjs';
+export { P as ProgressReporter } from './chunks/context-YDw6qicq.cjs';
 import './commands/index.cjs';
-import './chunks/reflog-entry-DNvSz7S5.cjs';
-import './chunks/write-tree-CuhpWKFo.cjs';
-import './chunks/http-transport-DirKfK2S.cjs';
+import './chunks/reflog-entry-BbNnXCTC.cjs';
+import './chunks/write-tree-C3oNxOlX.cjs';
+import './chunks/index-entry-DtEbVpOG.cjs';
+import './chunks/http-transport--_NdQOiw.cjs';
 
 /**
  * Browser-runtime extension to `OpenRepositoryOptions`. The browser cannot

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

@@ -1,10 +1,11 @@
-import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-DFxFeYi3.js';
-export { AdapterSet, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress } from './index.js';
-export { P as ProgressReporter } from './chunks/context-BORy7yXb.js';
+import { O as OpenRepositoryOptions, R as Repository } from './chunks/repository-FoS_Laoy.js';
+export { A as AdapterSet, c as consoleProgress, d as detectRuntime, i as isBrowser, a as isNode, n as noopProgress } from './chunks/progress-7KKiXXfX.js';
+export { P as ProgressReporter } from './chunks/context-CCL0_F8R.js';
 import './commands/index.js';
-import './chunks/reflog-entry-C2Hsdobk.js';
-import './chunks/write-tree-Dn1LtIh7.js';
-import './chunks/http-transport-DirKfK2S.js';
+import './chunks/reflog-entry-CSzjnZd4.js';
+import './chunks/write-tree-DRI-LzSr.js';
+import './chunks/index-entry-UD4dvtKh.js';
+import './chunks/http-transport--_NdQOiw.js';
 
 /**
  * Browser-runtime extension to `OpenRepositoryOptions`. The browser cannot

package/dist/types/index.d.cts

@@ -1,68 +1,293 @@
-import { f as FileSystem, H as HashService, C as Compressor, P as ProgressReporter } from './chunks/context-CMrHCVwK.cjs';
-export { A as AuthStrategy, a as AuthorIdentity, b as Context, c as CreateContextParts, D as DirEntry, e as FileStat, g as Hasher, h as HookName, i as HookRequest, j as HookResult, k as HookRunner, L as Logger, l as PromisorFetchOutcome, m as PromisorRemote, n as RepositoryConfig, o as RepositoryLayout, p as createContext, q as noopLogger, w as wrapLoggerSanitizer } from './chunks/context-CMrHCVwK.cjs';
-import { b as HttpTransport } from './chunks/http-transport-DirKfK2S.cjs';
-export { H as HttpRequest, a as HttpResponse } from './chunks/http-transport-DirKfK2S.cjs';
-export { AddOptions, AddResult, BranchAction, BranchInfo, BranchResult, CatFileInput, CatFileResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CloneOptions, CloneResult, CommitOptions, CommitResult, DiffOptions, FetchMissingOptions, FetchMissingResult, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, PushOptions, PushResult, ReflogAction, ReflogResult, ReflogShowEntry, ResetMode, ResetOptions, ResetResult, RmOptions, RmResult, SparseCheckoutAction, SparseCheckoutResult, StatusResult, SubmodulesAction, SubmodulesResult, TagAction, TagInfo, TagResult, add, branch, catFile, checkout, clone, commit, createPromisorRemote, diff, fetch, fetchMissing, init, log, merge, push, reflog, reset, revParse, rm, sparseCheckout, status, submodules, tag } from './commands/index.cjs';
-export { C as CatFileBatchEntry, S as SubmoduleEntry } from './chunks/reflog-entry-DNvSz7S5.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;
+import { I as IndexResolver, b as Snapshot, e as IndexEntry, f as SnapshotEntry, T as TreeResolver, g as TreeEntry } from './chunks/progress-By8yFaUE.cjs';
+export { A as AdapterSet, h as IndexSnapshot, R as ResolveOptions, S as SnapshotFactory, j as SnapshotFactoryDeps, k as SnapshotOptions, l as StashSnapshot, m as TreeSnapshot, W as WalkIgnorePredicate, o as WorkdirEntry, p as WorkdirEnumOptions, q as WorkdirEnumerator, r as WorkdirSnapshot, s as WorkdirSnapshotDeps, t as WorkdirSnapshotOptions, c as consoleProgress, u as createSnapshotFactory, v as createStashSnapshot, w as createWorkdirSnapshot, d as detectRuntime, i as isBrowser, a as isNode, n as noopProgress } from './chunks/progress-By8yFaUE.cjs';
+export { AbortMergeResult, AddOptions, AddResult, BranchCreateInput, BranchCreateResult, BranchDeleteInput, BranchDeleteResult, BranchInfo, BranchListResult, BranchNamespace, BranchRenameInput, BranchRenameResult, CatFileInput, CatFileResult, ChangeEntry, ChangeKind, CheckoutOptions, CheckoutResult, CherryPickAbortResult, CherryPickConflict, CherryPickContinueInput, CherryPickNamespace, CherryPickResult, CherryPickRunInput, CherryPickedCommit, CloneOptions, CloneResult, CommitOptions, CommitResult, ConfigEntryView, ConfigGetAllInput, ConfigGetAllResult, ConfigGetInput, ConfigGetRegexpInput, ConfigGetRegexpResult, ConfigGetResult, ConfigListInput, ConfigListResult, ConfigNamespace, ConfigRemoveSectionInput, ConfigRemoveSectionResult, ConfigRenameSectionInput, ConfigRenameSectionResult, ConfigSetInput, ConfigSetResult, ConfigUnsetAllInput, ConfigUnsetAllResult, ConfigUnsetInput, ConfigUnsetResult, ContinueMergeOptions, ContinueMergeResult, DiffFormat, DiffOptions, DiffResult, FetchMissingOptions, FetchMissingResult, FetchOptions, FetchResult, InitOptions, InitResult, LogEntry, LogOptions, MergeOptions, MergeResult, MvMove, MvOptions, MvResult, MvSkipReason, MvSkipped, PatchResult, PullOptions, PullResult, PushOptions, PushResult, RebaseAbortResult, RebaseConflict, RebaseInstruction, RebaseInteractiveAction, RebaseNamespace, RebaseResult, RebaseRunInput, RebasedCommit, ReflogAction, ReflogResult, ReflogShowEntry, RemoteAddInput, RemoteAddResult, RemoteInfo, RemoteListResult, RemoteNamespace, RemoteRemoveInput, RemoteRemoveResult, RemoteRenameInput, RemoteRenameResult, RemoteSetUrlInput, RemoteSetUrlResult, RemoteShow, RemoteShowInput, RemoteShowResult, ResetMode, ResetOptions, ResetResult, RevertAbortResult, RevertConflict, RevertNamespace, RevertResult, RevertRunInput, RevertedCommit, RmOptions, RmResult, SparseCheckoutAddInput, SparseCheckoutAppliedResult, SparseCheckoutDisableInput, SparseCheckoutListResult, SparseCheckoutNamespace, SparseCheckoutReapplyInput, SparseCheckoutSetInput, StashApplyInput, StashApplyResult, StashConflict, StashDropInput, StashDropResult, StashListEntry, StashListResult, StashNamespace, StashPopResult, StashPushInput, StashPushResult, StatusResult, SubmodulesAction, SubmodulesResult, TagCreateInput, TagCreateResult, TagDeleteInput, TagDeleteResult, TagInfo, TagListResult, TagNamespace, abortMerge, add, bindBranchNamespace, bindCherryPickNamespace, bindConfigNamespace, bindRebaseNamespace, bindRemoteNamespace, bindRevertNamespace, bindSparseCheckoutNamespace, bindStashNamespace, bindTagNamespace, branchCreate, branchDelete, branchList, branchRename, catFile, checkout, cherryPickAbort, cherryPickContinue, cherryPickRun, cherryPickSkip, clone, commit, configGet, configGetAll, configGetRegexp, configList, configRemoveSection, configRenameSection, configSet, configUnset, configUnsetAll, continueMerge, createPromisorRemote, diff, fetch, fetchMissing, init, log, merge, mv, pull, push, rebaseAbort, rebaseContinue, rebaseRun, rebaseSkip, reflog, remoteAdd, remoteList, remoteRemove, remoteRename, remoteSetUrl, remoteShow, reset, revParse, revertAbort, revertContinue, revertRun, revertSkip, rm, sparseCheckoutAdd, sparseCheckoutDisable, sparseCheckoutList, sparseCheckoutReapply, sparseCheckoutSet, stashApply, stashDrop, stashList, stashPop, stashPush, status, submodules, tagCreate, tagDelete, tagList } from './commands/index.cjs';
+import { c as FilePath, b as Context, O as ObjectId } from './chunks/context-YDw6qicq.cjs';
+export { A as AuthStrategy, k as AuthorIdentity, C as Compressor, l as CreateContextParts, D as DirEntry, d as FileStat, F as FileSystem, H as HashService, f as Hasher, g as HookName, i as HookRequest, h as HookResult, a as HookRunner, L as Logger, P as ProgressReporter, m as PromisorFetchOutcome, n as PromisorRemote, R as RepositoryConfig, o as RepositoryLayout, p as createContext, q as noopLogger, w as wrapLoggerSanitizer } from './chunks/context-YDw6qicq.cjs';
+export { a as HttpRequest, b as HttpResponse, H as HttpTransport } from './chunks/http-transport--_NdQOiw.cjs';
+export { C as CatFileBatchEntry, S as SubmoduleEntry } from './chunks/reflog-entry-BbNnXCTC.cjs';
+import './chunks/index-entry-DtEbVpOG.cjs';
+
+/**
+ * Extracts the entry shape `E` from a `Snapshot<E>` constraint. Used by
+ * the join row types to project each slot's entry shape onto the merged
+ * row.
+ */
+type EntryOf<X> = X extends {
+    entries(opts?: unknown): AsyncIterable<infer E>;
+} ? E : never;
+/**
+ * Outer-join row — `path` is mandatory, every named slot is OPTIONAL.
+ * A slot is `undefined` for rows where that source did not contribute
+ * an entry at the given path.
+ */
+type OuterJoinRow<S> = {
+    readonly path: FilePath;
+} & {
+    readonly [K in keyof S]?: EntryOf<S[K]>;
+};
+/**
+ * Inner-join row — `path` is mandatory and every named slot is REQUIRED
+ * (no `?`). Only rows where every source contributed an entry at the
+ * given path are emitted.
+ */
+type InnerJoinRow<S> = {
+    readonly path: FilePath;
+} & {
+    readonly [K in keyof S]: EntryOf<S[K]>;
+};
+
+/**
+ * Discriminator for write-target categories used across the CQS port triple
+ * — `WriteEventEmitter` (command), `WriteEventStream` (subscribe), and
+ * `GenerationView` (query). See ADR-157 for the rationale of splitting
+ * those three concerns across separate port files; `WriteScope` lives in
+ * its own file so none of the three ports needs to import another's
+ * declaration, preserving the CQS split at the import-graph level.
+ */
+type WriteScope = 'index' | 'refs' | 'objects';
+
+/**
+ * Query side of the write-event triple (ADR-157). Read primitives depend on
+ * this interface only — they query the current generation per scope but
+ * cannot emit or subscribe.
+ *
+ * `current(scope)` is monotonic per scope: each successful `WriteEventEmitter.emit(scope)`
+ * increments the corresponding counter exactly once. Scopes are independent
+ * — `emit('index')` does not affect `current('refs')` or `current('objects')`.
+ */
+interface GenerationView {
+    current(scope: WriteScope): number;
+}
+
+/**
+ * Command side of the write-event triple (ADR-157). Write-boundary primitives
+ * depend on this interface only — they cannot observe events, only emit them.
+ *
+ * Implementations MUST be called AFTER a successful write but BEFORE
+ * releasing any acquired lock. See `docs/understand/caching.md` for the
+ * lock-ordering protocol; in-process readers rely on the
+ * emit-before-release ordering to avoid TOCTOU windows.
+ */
+interface WriteEventEmitter {
+    emit(scope: WriteScope): void;
+}
+
+/**
+ * Disposable handle returned from `WriteEventStream.subscribe`. Matches the
+ * shape of TC39 Explicit Resource Management's `Disposable` so callers can
+ * use `using` syntax once the project's TS target supports it.
+ */
+interface Disposable {
+    dispose(): void;
+}
+/**
+ * Subscribe side of the write-event triple (ADR-157). Cache adapters depend
+ * on this interface only — they observe events but cannot emit them.
+ *
+ * Subscribers receive identical event sequences regardless of subscription
+ * order. Disposing a subscription removes the listener; the next event is
+ * not delivered to that listener.
+ */
+interface WriteEventStream {
+    subscribe(listener: (scope: WriteScope) => void): Disposable;
+}
+
+/**
+ * Emits a deprecation warning at most once per `callsite`. The set-based
+ * dedup keeps long-running daemons (e.g. an editor LSP) from spamming the
+ * log when the same deprecated path is hit thousands of times.
+ *
+ * Output is suppressed entirely when the `TSGIT_SUPPRESS_DEPRECATIONS=1`
+ * environment variable is set (per ADR-160). Defensive against browser
+ * contexts where `process` is undefined — the lookup never throws.
+ *
+ * See `docs/use/snapshots.md` for the deprecation policy that drives
+ * Wave 8 (legacy walker removal in tsgit 2.0).
+ */
+declare const warnDeprecated: (callsite: string, message: string) => void;
+
+interface IndexSnapshotDeps {
+    readonly ctx: Context;
+    readonly indexResolver: IndexResolver;
+}
+/**
+ * Lazily evaluates `.git/index` via `IndexResolver`. The parsed `GitIndex`
+ * is captured on the first iteration and reused across subsequent
+ * iterations of the same handle (design §8.0 iteration stability):
+ *
+ *   - First `entries()` call → resolver.resolve(ctx) → captured reference
+ *   - All subsequent `entries()` calls → stream from captured reference,
+ *     bypassing the resolver entirely; `emit('index')` events on the bus
+ *     never disturb an in-flight iteration.
+ *   - A fresh `repo.snapshot.index()` returns a new handle whose own first
+ *     iteration sees the resolver's post-invalidation state.
+ *
+ * `bypassCache` forwards to the resolver only for the *first* resolve on
+ * this handle; once captured, subsequent calls use the captured reference.
+ */
+declare const createIndexSnapshot: (deps: IndexSnapshotDeps) => Snapshot<IndexEntry>;
+
+type SnapshotMap = {
+    readonly [k: string]: Snapshot<SnapshotEntry>;
+};
+interface JoinOptions {
+    readonly concurrency?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Outer-join over an arbitrary record of snapshots, keyed by path. Every
+ * row carries the path plus one or more populated slot entries (a slot
+ * is `undefined` when that source had no entry at the path).
+ *
+ * Single-source joins take the short-circuit path (one alloc per row);
+ * multi-source joins delegate to the k-way merge in `path-merge.ts`.
+ */
+declare const join: <S extends SnapshotMap>(sources: S, opts?: JoinOptions) => AsyncIterable<OuterJoinRow<S>>;
+/**
+ * Inner-join — yields rows only when every named slot has an entry at
+ * the given path. Useful for "files present in both X and Y" queries
+ * (e.g. unmerged paths in both index and workdir).
+ */
+declare const innerJoin: <S extends SnapshotMap>(sources: S, opts?: JoinOptions) => AsyncIterable<InnerJoinRow<S>>;
+
+/**
+ * Unwrap a `Promise<T | null>` from a compound-state snapshot factory
+ * (`mergeHead`, `cherryPickHead`, `revertHead`, `fetchHead`, `stashEntry`).
+ *
+ * Calls that require the state to exist (e.g. `abortMerge` when no merge
+ * is in progress) use this helper to fail loudly with a `SNAPSHOT_REQUIRED`
+ * code carrying the caller's reason. Calls that tolerate absence keep the
+ * null-check in their own flow.
+ *
+ * Example:
+ *
+ * ```ts
+ * const theirs = await requireSnapshot(
+ *   repo.snapshot.mergeHead(),
+ *   'no merge in progress',
+ * );
+ * ```
+ */
+declare const requireSnapshot: <T>(promise: Promise<T | null>, reason: string) => Promise<T>;
+
+interface TreeSnapshotDeps {
+    readonly ctx: Context;
+    readonly treeResolver: TreeResolver;
 }
 /**
- * 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.
+ * Lazily evaluates a tree by its oid via `TreeResolver`. The root tree is
+ * resolved on the first iteration and reused across subsequent iterations
+ * for stability. Trees are content-addressed, so the captured reference
+ * is independent of any external cache invalidation.
  *
- * Used as a manual fallback only; the primary detection mechanism is
- * `package.json` conditional exports (resolved at bundle time, immune to
- * runtime pollution).
+ * Only leaf entries (files, symlinks, gitlinks/submodules) are yielded.
+ * Directories are descended into but never yielded as their own row —
+ * `kind` is therefore narrowed to `'file' | 'symlink' | 'submodule'`.
+ */
+declare const createTreeSnapshot: (deps: TreeSnapshotDeps, treeId: ObjectId) => Snapshot<TreeEntry>;
+
+interface DirGroup<R> {
+    readonly path: FilePath;
+    readonly rows: ReadonlyArray<R>;
+}
+/**
+ * Groups consecutive rows by their parent directory. Because the row
+ * stream is sorted by path (`assertOrdered` enforced upstream), entries
+ * sharing a directory always arrive contiguously — no buffering of
+ * unrelated rows is required.
  */
-declare const isNode: () => boolean;
+declare const groupByDir: <R extends {
+    readonly path: FilePath;
+}>() => (source: AsyncIterable<R>) => AsyncIterable<DirGroup<R>>;
+
+interface HashSlotOptions {
+    readonly concurrency?: number;
+    readonly signal?: AbortSignal;
+}
+type SlotKeyedRow$2 = {
+    readonly path: FilePath;
+};
 /**
- * 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).
+ * Generic slot-hashing operator. For each row whose named slot has an
+ * entry exposing `hash()`, invokes the method to warm the entry's
+ * hash (most relevant for WorkdirEntry, where `hash()` reads the file
+ * and computes the git blob hash).
+ *
+ * Row typing is intentionally loose (`R extends { path: FilePath }`):
+ * the operator is a pure pipeline stage and does not constrain the
+ * shape of slot entries beyond an optional `hash()` method. Concrete
+ * join callers narrow at the type-projection boundary.
  */
-declare const isBrowser: () => boolean;
+declare const hashSlot: <R extends SlotKeyedRow$2>(slot: string, opts?: HashSlotOptions) => (source: AsyncIterable<R>) => AsyncIterable<R>;
 /**
- * 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).
+ * Conventional wrapper for the 95% case (slot named `workdir`).
+ * See design §12.1.
  */
-declare const detectRuntime: () => "node" | "browser" | "memory";
+declare const hashWorkdir: <R extends SlotKeyedRow$2>(opts?: HashSlotOptions) => ((source: AsyncIterable<R>) => AsyncIterable<R>);
 
-/** No-op reporter — default when the caller does not provide one. */
-declare const noopProgress: ProgressReporter;
+interface LoadBlobOptions {
+    readonly concurrency?: number;
+    readonly maxInflightBytes?: number;
+    readonly signal?: AbortSignal;
+}
+type SlotKeyedRow$1 = {
+    readonly path: FilePath;
+};
 /**
- * Built-in reporter that emits one line per call to a user-supplied `sink`.
+ * Reads the blob bytes for a named slot, with a bounded in-flight byte
+ * budget. The operator preserves order and forwards rows verbatim;
+ * downstream consumers can rely on the `read()` cache being warm.
  *
- * 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"
+ * `maxInflightBytes` (default: 64 MiB) caps the total size of in-flight
+ * reads. When the budget is exhausted, oldest reads are awaited before
+ * issuing new ones. This protects against memory blow-up on repos with
+ * occasional multi-GiB blobs.
+ */
+declare const loadBlob: <R extends SlotKeyedRow$1>(slot: string, opts?: LoadBlobOptions) => (source: AsyncIterable<R>) => AsyncIterable<R>;
+
+interface TerminalOptions {
+    readonly signal?: AbortSignal;
+}
+declare const count: <T>(source: AsyncIterable<T>, opts?: TerminalOptions) => Promise<number>;
+declare const toArray: <T>(source: AsyncIterable<T>, opts?: TerminalOptions) => Promise<ReadonlyArray<T>>;
+declare const first: <T>(source: AsyncIterable<T>, opts?: TerminalOptions) => Promise<T | null>;
+
+type VerifyRaceAction = 'throw' | 'skip' | 'emit';
+interface VerifyOptions {
+    readonly onRace?: VerifyRaceAction;
+    readonly signal?: AbortSignal;
+}
+type SlotKeyedRow = {
+    readonly path: FilePath;
+};
+/**
+ * Marker added to a row by `verifyWorkdir({ onRace: 'emit' })` when the
+ * per-row `verify()` rejects. Consumers narrow with `'_raced' in row` to
+ * branch on race status without an unsafe cast.
+ */
+interface RacedRow {
+    readonly _raced: true;
+}
+/**
+ * Output row type for `verifyWorkdir`. In `'throw'` and `'skip'` modes
+ * the operator only ever yields the original `R`. In `'emit'` mode it
+ * may additionally yield `R & RacedRow` for rows whose `verify()`
+ * rejected.
+ */
+type VerifyOutput<R> = R | (R & RacedRow);
+/**
+ * Re-lstats workdir entries during iteration via `WorkdirEntry.verify()`.
  *
- * `op` is sanitized identically to `text` (defense-in-depth: a programming bug
- * that wires a sideband-derived string into `op` cannot inject control characters).
+ * - `'throw'` (default) — propagate the `WORKDIR_RACE` error.
+ * - `'skip'` — silently drop racy rows.
+ * - `'emit'` — yield the row unchanged plus a `_raced: true` marker;
+ *   consumers narrow with `'_raced' in row` to branch on race status.
  *
- * A throwing `sink` cannot crash the reporter — every call is wrapped in
- * try/catch.
+ * Workdir snapshot remains race-prone by design (ADR-153); this operator
+ * is the opt-in guard for "no race tolerated" workflows like
+ * `add -p` and `checkout --detect-races`.
  */
-declare const consoleProgress: (sink: (line: string) => void) => ProgressReporter;
+declare const verifyWorkdir: <R extends SlotKeyedRow>(opts?: VerifyOptions) => (source: AsyncIterable<R>) => AsyncIterable<VerifyOutput<R>>;
 
-export { Compressor, FileSystem, HashService, HttpTransport, ProgressReporter, consoleProgress, detectRuntime, isBrowser, isNode, noopProgress };
-export type { AdapterSet };
+export { Context, IndexEntry, IndexResolver, Snapshot, SnapshotEntry, TreeEntry, TreeResolver, count, createIndexSnapshot, createTreeSnapshot, first, groupByDir, hashSlot, hashWorkdir, innerJoin, join, loadBlob, requireSnapshot, toArray, verifyWorkdir, warnDeprecated };
+export type { DirGroup, Disposable, GenerationView, HashSlotOptions, IndexSnapshotDeps, JoinOptions, LoadBlobOptions, TerminalOptions, TreeSnapshotDeps, VerifyOptions, VerifyRaceAction, WriteEventEmitter, WriteEventStream, WriteScope };