git-fs-s3 0.4.0 → 0.5.0

package/dist/ops.d.ts

@@ -1,302 +0,0 @@
-import { R as Repo, O as OpsHooks } from './types-BHoHOaQt.js';
-export { I as IsoGitFs, a as ResultCache, r as resultKeyPrefixes } from './types-BHoHOaQt.js';
-import * as git from 'isomorphic-git';
-
-interface Branch {
-    name: string;
-    commit: string;
-    isDefault: boolean;
-}
-/**
- * Defense in depth for every branch-name argument below: `git.deleteBranch`
- * and raw resolveRef/writeRef reads don't validate ref names internally the
- * way `git.branch` does (see refs.ts) — guard at the point the primitives are
- * actually called, not just at an API boundary far above.
- */
-declare function assertSafeBranchName(name: string): void;
-/**
- * Resolve a fully-qualified ref's oid with one read instead of isomorphic-
- * git's own `resolveRef`, which does a stat *then* a read for a loose ref
- * (two round trips against object storage) — wasteful specifically here,
- * where the caller already knows the ref exists (it came from a directory
- * listing moments earlier). Reads the loose file directly and falls back to
- * `git.resolveRef` only when that doesn't pan out (packed-refs, or anything
- * else the plain-loose-file assumption doesn't cover), so correctness for
- * those cases is unchanged — this only removes the redundant round trip on
- * the common path.
- */
-declare function resolveLooseRefFast(repo: Repo, ref: string): Promise<string>;
-/** All branches with their tip commits; [] for an empty repository. */
-declare function listBranches(repo: Repo): Promise<Branch[]>;
-/** Create `name` pointing at the tip of `startPoint` (no checkout). */
-declare function createBranchFrom(repo: Repo, name: string, startPoint?: string): Promise<void>;
-/** Delete a branch ref (validated — deleteBranch has no internal ref check). */
-declare function deleteBranchByName(repo: Repo, name: string): Promise<void>;
-/** Throws (NotFoundError) unless the branch resolves. */
-declare function assertBranchExists(repo: Repo, name: string): Promise<void>;
-
-interface CommitAuthor {
-    name: string;
-    email: string;
-    timestamp: number;
-    timezoneOffset: number;
-}
-/** An author stamped with the current time. */
-declare function authorNow(name: string, email: string): CommitAuthor;
-/**
- * Write a commit directly to a bare repository — no worktree, no checkout.
- * `buildTree` receives the parent commit's tree oid (undefined on an empty
- * repo / unborn branch) and returns the new root tree oid; this function
- * writes the commit object and force-updates `refs/heads/<branch>`.
- *
- * Serialize concurrent writers externally (a per-repo lock): the
- * resolve-ref → write-ref sequence is not atomic on object storage.
- */
-declare function writeCommitToBare(repo: Repo, options: {
-    branch: string;
-    message: string;
-    author: CommitAuthor;
-    buildTree: (parentTreeOid: string | undefined) => Promise<string>;
-}): Promise<string>;
-/**
- * Commit a set of files onto a branch, straight to the bare repo. Each blob
- * is written to its own content-addressed key — no shared state between
- * files, so they're written in parallel.
- */
-declare function commitFilesToBare(repo: Repo, options: {
-    branch: string;
-    message: string;
-    author: CommitAuthor;
-    files: Array<{
-        path: string;
-        content: string | Uint8Array;
-    }>;
-}): Promise<string>;
-/** Commit the removal of one file from a branch, straight to the bare repo. */
-declare function deleteFileFromBare(repo: Repo, options: {
-    branch: string;
-    filePath: string;
-    message: string;
-    author: CommitAuthor;
-}): Promise<string>;
-
-interface DiffFile {
-    path: string;
-    status: "added" | "modified" | "deleted" | "renamed";
-    additions: number;
-    deletions: number;
-    patch: string;
-    oldPath?: string;
-    isBinary?: boolean;
-    oldContent?: string;
-    newContent?: string;
-    oldSize?: number;
-    newSize?: number;
-}
-interface DiffResult {
-    files: DiffFile[];
-    totalAdditions: number;
-    totalDeletions: number;
-    totalFiles: number;
-}
-/** The diff a single commit introduced (against its first parent). */
-declare function getCommitDiff(repo: Repo, commitSha: string): Promise<DiffResult>;
-/** The diff between two refs (base -> compare). */
-declare function getDiffBetweenRefs(repo: Repo, baseRef: string, compareRef: string): Promise<DiffResult>;
-
-interface FileHistoryEntry {
-    sha: string;
-    message: string;
-    authorName: string;
-    authorEmail: string;
-    createdAt: string;
-}
-interface FileHistoryResult {
-    entries: FileHistoryEntry[];
-    /**
-     * True when the walk hit its depth budget (or the requested `limit`)
-     * before exhausting the branch's full commit chain — there may be older
-     * commits touching this file that a deeper walk would surface.
-     */
-    truncated: boolean;
-}
-/**
- * Default walk bound for a caller that actually wants deep history (a file's
- * "History" tab). Walking the full chain is round-trip-bound on object
- * storage, so cap how far back a single request will look.
- */
-declare const HISTORY_WALK_DEPTH = 400;
-/**
- * Much shallower default for a "latest commit touching this file" banner that
- * only displays `entries[0]` — trades "always finds the true last-touching
- * commit" for "finds it if it's reasonably recent", the right call for a
- * banner with a full History view a click away.
- */
-declare const BANNER_WALK_DEPTH = 60;
-/**
- * All commits (newest first) that changed a single file's blob oid, walking
- * the first-parent chain — same approach as getLastCommitsForTree but for one
- * path and collecting every match instead of stopping at the first.
- */
-declare function getFileHistory(repo: Repo, options: {
-    ref: string;
-    filePath: string;
-    limit?: number;
-    maxDepth?: number;
-}, hooks?: OpsHooks): Promise<FileHistoryResult>;
-
-interface TreeEntry {
-    path: string;
-    mode: string;
-    type: "blob" | "tree";
-    oid: string;
-    size?: number;
-}
-/**
- * Build/update a git tree by overlaying new blobs onto an existing tree,
- * returning the new root tree oid. `entries` maps relative paths to blob oids.
- */
-declare function upsertTree(repo: Repo, treeOid: string | undefined, entries: Map<string, string>): Promise<string>;
-/** Remove a file path from a tree, returning the new root tree oid. */
-declare function deleteFromTree(repo: Repo, treeOid: string, filePath: string): Promise<string>;
-/** Resolve a path inside a tree to its entry, or null when absent. */
-declare function findTreeEntry(repo: Repo, rootTreeOid: string, treePath: string): Promise<TreeEntry | null>;
-/** List a tree's direct entries, with paths prefixed by `prefix`. */
-declare function listTreeEntries(repo: Repo, treeOid: string, prefix?: string): Promise<TreeEntry[]>;
-
-interface CommitInfo {
-    oid: string;
-    commit: {
-        message: string;
-        tree: string;
-        parent: string[];
-        author: {
-            name: string;
-            email: string;
-            timestamp: number;
-            timezoneOffset: number;
-        };
-        committer: {
-            name: string;
-            email: string;
-            timestamp: number;
-            timezoneOffset: number;
-        };
-    };
-    payload: string;
-}
-/**
- * Resolve a branch name / full ref / sha to its commit. The ref not
- * resolving (unborn branch, genuinely empty repo) and the ref resolving but
- * its commit object being unreadable (storage inconsistency — see
- * `wrapMissingObject` above) are different failures with different meanings,
- * so only the first is left as a raw isomorphic-git NotFoundError for
- * callers to treat as "empty"; the second is wrapped into
- * GitObjectNotFoundError specifically so it can't be mistaken for the first
- * by an `isNotFound`-style check downstream (see getTreeFromRef/getCommitLog).
- */
-declare function resolveCommit(repo: Repo, ref: string): Promise<{
-    oid: string;
-    commit: git.CommitObject;
-}>;
-/** Read a blob's bytes by oid. */
-declare function getBlob(repo: Repo, sha: string): Promise<Uint8Array>;
-/** Read a file's bytes at a ref. Throws GitPathNotFoundError when absent. */
-declare function getFileContent(repo: Repo, filePath: string, ref?: string, hooks?: OpsHooks): Promise<Uint8Array>;
-/** Read one commit by sha. */
-declare function getCommit(repo: Repo, sha: string): Promise<CommitInfo>;
-interface CommitLogOptions {
-    ref?: string;
-    depth?: number;
-    /**
-     * Pass the head sha when the caller already resolved `ref` — resolveRef
-     * tries several candidate paths in sequence and misses the first few every
-     * time for a normal branch name, which is pure waste when the sha is known.
-     */
-    knownHeadSha?: string;
-}
-/**
- * The commit chain from a ref, newest first. Walking is inherently sequential
- * (each commit's oid is only discoverable by reading its child first) and
- * network-round-trip-bound against object storage, so the deepest walk seen
- * per head is memoized in `hooks.resultCache` and sliced for shallower or
- * repeated requests — don't bypass this by calling `git.log` directly.
- */
-declare function getCommitLog(repo: Repo, options?: CommitLogOptions, hooks?: OpsHooks): Promise<CommitInfo[]>;
-/** A file at a ref, decoded for display: utf8 text or base64 when binary. */
-declare function getFileFromRef(repo: Repo, filePath: string, ref: string, hooks?: OpsHooks): Promise<{
-    content: string;
-    size: number;
-    isBinary: boolean;
-}>;
-/**
- * List a directory at the tip of a ref. Returns [] for an empty repo/unborn
- * branch; throws GitPathNotFoundError when `treePath` doesn't exist. Results
- * are memoized per head sha (auto-invalidates on push).
- */
-declare function getTreeFromRef(repo: Repo, options?: {
-    ref?: string;
-    treePath?: string;
-}, hooks?: OpsHooks): Promise<TreeEntry[]>;
-/**
- * A page of commit history from a branch tip. Memoized per head sha; builds
- * on {@link getCommitLog}'s walk cache for the underlying chain.
- */
-declare function getCommitHistory(repo: Repo, options: {
-    ref: string;
-    limit?: number;
-    skip?: number;
-}, hooks?: OpsHooks): Promise<CommitInfo[]>;
-
-interface LastCommitInfo {
-    sha: string;
-    message: string;
-    authorName: string;
-    authorEmail: string;
-    createdAt: string;
-}
-/**
- * For each direct child of `treePath` (at the tip of `ref`), find the most
- * recent commit that changed it — the tree view's "last commit" column. Walks
- * history newest-to-oldest, comparing the directory's tree oid
- * commit-to-commit and only descending one level to diff child oids when
- * something under the directory actually changed. Preserve the two-phase
- * structure (parallel prefetch, then sequential resolve) when touching this —
- * the "which entries are still unresolved" state must advance
- * commit-by-commit.
- */
-declare function getLastCommitsForTree(repo: Repo, options: {
-    ref: string;
-    treePath?: string;
-    depth?: number;
-}, hooks?: OpsHooks): Promise<Record<string, LastCommitInfo>>;
-
-interface MergeAnalysis {
-    canMerge: boolean;
-    hasConflicts: boolean;
-    conflictingFiles: string[];
-    fastForward: boolean;
-}
-/**
- * Cheap pre-merge check: do both branches exist, and is this a fast-forward?
- * `canMerge`/`fastForward` are the only fields this actually determines —
- * `hasConflicts`/`conflictingFiles` are NOT a real content-conflict check
- * (isomorphic-git's `git.merge` doesn't expose a dry-run), they only ever
- * reflect "one of the branches couldn't be resolved" (`canMerge: false`).
- * Real merge conflicts are only discoverable by actually attempting the
- * merge.
- */
-declare function analyzeMerge(repo: Repo, sourceBranch: string, targetBranch: string): Promise<MergeAnalysis>;
-/**
- * Attempt a fast-forward merge directly against the bare repo: when source is
- * a descendant of target, just move the target ref — no worktree, no new
- * commit. Returns null when the merge is not a fast-forward (callers fall
- * back to a real three-way merge, which needs a worktree). Serialize with a
- * per-repo lock: resolve → writeRef is not atomic.
- */
-declare function fastForwardMerge(repo: Repo, sourceBranch: string, targetBranch: string): Promise<{
-    success: true;
-    commitSha: string;
-} | null>;
-
-export { BANNER_WALK_DEPTH, type Branch, type CommitAuthor, type CommitInfo, type CommitLogOptions, type DiffFile, type DiffResult, type FileHistoryEntry, type FileHistoryResult, HISTORY_WALK_DEPTH, type LastCommitInfo, type MergeAnalysis, OpsHooks, Repo, type TreeEntry, analyzeMerge, assertBranchExists, assertSafeBranchName, authorNow, commitFilesToBare, createBranchFrom, deleteBranchByName, deleteFileFromBare, deleteFromTree, fastForwardMerge, findTreeEntry, getBlob, getCommit, getCommitDiff, getCommitHistory, getCommitLog, getDiffBetweenRefs, getFileContent, getFileFromRef, getFileHistory, getLastCommitsForTree, getTreeFromRef, listBranches, listTreeEntries, resolveCommit, resolveLooseRefFast, upsertTree, writeCommitToBare };

package/dist/s3.cjs

@@ -1,123 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/stores/s3.ts
-var s3_exports = {};
-__export(s3_exports, {
-  S3ObjectStore: () => S3ObjectStore
-});
-module.exports = __toCommonJS(s3_exports);
-var import_client_s3 = require("@aws-sdk/client-s3");
-function isNotFound(error) {
-  if (typeof error !== "object" || error === null) return false;
-  const err = error;
-  return err.name === "NoSuchKey" || err.name === "NotFound" || err.$metadata?.httpStatusCode === 404;
-}
-var S3ObjectStore = class {
-  client;
-  bucket;
-  prefix;
-  contentType;
-  constructor(options) {
-    this.client = options.client;
-    this.bucket = options.bucket;
-    this.contentType = options.contentType;
-    this.prefix = options.prefix ? options.prefix.replace(/\/+$/, "").concat("/") : "";
-  }
-  fullKey(key) {
-    return this.prefix + key;
-  }
-  async get(key) {
-    try {
-      const response = await this.client.send(
-        new import_client_s3.GetObjectCommand({ Bucket: this.bucket, Key: this.fullKey(key) })
-      );
-      if (!response.Body) return new Uint8Array(0);
-      return await response.Body.transformToByteArray();
-    } catch (error) {
-      if (isNotFound(error)) return null;
-      throw error;
-    }
-  }
-  async put(key, data) {
-    await this.client.send(
-      new import_client_s3.PutObjectCommand({
-        Bucket: this.bucket,
-        Key: this.fullKey(key),
-        Body: data,
-        ContentType: this.contentType?.(key)
-      })
-    );
-  }
-  async delete(key) {
-    await this.client.send(
-      new import_client_s3.DeleteObjectCommand({ Bucket: this.bucket, Key: this.fullKey(key) })
-    );
-  }
-  async head(key) {
-    try {
-      const response = await this.client.send(
-        new import_client_s3.HeadObjectCommand({ Bucket: this.bucket, Key: this.fullKey(key) })
-      );
-      return { size: response.ContentLength ?? 0 };
-    } catch (error) {
-      if (isNotFound(error)) return null;
-      throw error;
-    }
-  }
-  async list(prefix, options) {
-    const fullPrefix = this.fullKey(prefix);
-    const limit = options?.limit;
-    const objects = [];
-    const prefixes = /* @__PURE__ */ new Set();
-    let continuationToken;
-    do {
-      const response = await this.client.send(
-        new import_client_s3.ListObjectsV2Command({
-          Bucket: this.bucket,
-          Prefix: fullPrefix,
-          Delimiter: options?.delimiter,
-          ContinuationToken: continuationToken,
-          MaxKeys: limit !== void 0 ? Math.min(limit, 1e3) : void 0
-        })
-      );
-      for (const item of response.Contents ?? []) {
-        if (item.Key === void 0) continue;
-        objects.push({
-          key: item.Key.slice(this.prefix.length),
-          size: item.Size ?? 0
-        });
-      }
-      for (const p of response.CommonPrefixes ?? []) {
-        if (p.Prefix === void 0) continue;
-        prefixes.add(p.Prefix.slice(this.prefix.length));
-      }
-      if (limit !== void 0 && objects.length + prefixes.size >= limit) {
-        break;
-      }
-      continuationToken = response.NextContinuationToken;
-    } while (continuationToken);
-    return { objects, prefixes: [...prefixes] };
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  S3ObjectStore
-});
-//# sourceMappingURL=s3.cjs.map

package/dist/s3.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/stores/s3.ts"],"sourcesContent":["import {\n\tDeleteObjectCommand,\n\tGetObjectCommand,\n\tHeadObjectCommand,\n\tListObjectsV2Command,\n\tPutObjectCommand,\n\ttype S3Client,\n} from \"@aws-sdk/client-s3\";\nimport type {\n\tListOptions,\n\tListResult,\n\tObjectStat,\n\tObjectStore,\n} from \"../types.js\";\n\nexport interface S3ObjectStoreOptions {\n\t/** A configured S3Client. Works with AWS S3, Cloudflare R2, MinIO, Backblaze B2, … */\n\tclient: S3Client;\n\tbucket: string;\n\t/** Key prefix for every object, e.g. `\"git\"`. Optional. */\n\tprefix?: string;\n\t/**\n\t * Derive a Content-Type header for uploads from the (un-prefixed) key.\n\t * Return `undefined` to let S3 apply its default. Cosmetic — git never\n\t * reads it back — but keeps refs and config human-readable in bucket UIs.\n\t */\n\tcontentType?: (key: string) => string | undefined;\n}\n\nfunction isNotFound(error: unknown): boolean {\n\tif (typeof error !== \"object\" || error === null) return false;\n\tconst err = error as {\n\t\tname?: string;\n\t\t$metadata?: { httpStatusCode?: number };\n\t};\n\treturn (\n\t\terr.name === \"NoSuchKey\" ||\n\t\terr.name === \"NotFound\" ||\n\t\terr.$metadata?.httpStatusCode === 404\n\t);\n}\n\n/**\n * {@link ObjectStore} over any S3-compatible API via `@aws-sdk/client-s3`\n * (peer dependency). One instance per bucket/prefix; reuse a single\n * `S3Client` across stores so HTTP connections are pooled.\n */\nexport class S3ObjectStore implements ObjectStore {\n\tprivate readonly client: S3Client;\n\tprivate readonly bucket: string;\n\tprivate readonly prefix: string;\n\tprivate readonly contentType?: (key: string) => string | undefined;\n\n\tconstructor(options: S3ObjectStoreOptions) {\n\t\tthis.client = options.client;\n\t\tthis.bucket = options.bucket;\n\t\tthis.contentType = options.contentType;\n\t\tthis.prefix = options.prefix\n\t\t\t? options.prefix.replace(/\\/+$/, \"\").concat(\"/\")\n\t\t\t: \"\";\n\t}\n\n\tprivate fullKey(key: string): string {\n\t\treturn this.prefix + key;\n\t}\n\n\tasync get(key: string): Promise<Uint8Array | null> {\n\t\ttry {\n\t\t\tconst response = await this.client.send(\n\t\t\t\tnew GetObjectCommand({ Bucket: this.bucket, Key: this.fullKey(key) }),\n\t\t\t);\n\t\t\tif (!response.Body) return new Uint8Array(0);\n\t\t\treturn await response.Body.transformToByteArray();\n\t\t} catch (error) {\n\t\t\tif (isNotFound(error)) return null;\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync put(key: string, data: Uint8Array): Promise<void> {\n\t\tawait this.client.send(\n\t\t\tnew PutObjectCommand({\n\t\t\t\tBucket: this.bucket,\n\t\t\t\tKey: this.fullKey(key),\n\t\t\t\tBody: data,\n\t\t\t\tContentType: this.contentType?.(key),\n\t\t\t}),\n\t\t);\n\t}\n\n\tasync delete(key: string): Promise<void> {\n\t\tawait this.client.send(\n\t\t\tnew DeleteObjectCommand({ Bucket: this.bucket, Key: this.fullKey(key) }),\n\t\t);\n\t}\n\n\tasync head(key: string): Promise<ObjectStat | null> {\n\t\ttry {\n\t\t\tconst response = await this.client.send(\n\t\t\t\tnew HeadObjectCommand({ Bucket: this.bucket, Key: this.fullKey(key) }),\n\t\t\t);\n\t\t\treturn { size: response.ContentLength ?? 0 };\n\t\t} catch (error) {\n\t\t\tif (isNotFound(error)) return null;\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync list(prefix: string, options?: ListOptions): Promise<ListResult> {\n\t\tconst fullPrefix = this.fullKey(prefix);\n\t\tconst limit = options?.limit;\n\t\tconst objects: ListResult[\"objects\"] = [];\n\t\tconst prefixes = new Set<string>();\n\t\tlet continuationToken: string | undefined;\n\n\t\tdo {\n\t\t\tconst response = await this.client.send(\n\t\t\t\tnew ListObjectsV2Command({\n\t\t\t\t\tBucket: this.bucket,\n\t\t\t\t\tPrefix: fullPrefix,\n\t\t\t\t\tDelimiter: options?.delimiter,\n\t\t\t\t\tContinuationToken: continuationToken,\n\t\t\t\t\tMaxKeys: limit !== undefined ? Math.min(limit, 1000) : undefined,\n\t\t\t\t}),\n\t\t\t);\n\t\t\tfor (const item of response.Contents ?? []) {\n\t\t\t\tif (item.Key === undefined) continue;\n\t\t\t\tobjects.push({\n\t\t\t\t\tkey: item.Key.slice(this.prefix.length),\n\t\t\t\t\tsize: item.Size ?? 0,\n\t\t\t\t});\n\t\t\t}\n\t\t\tfor (const p of response.CommonPrefixes ?? []) {\n\t\t\t\tif (p.Prefix === undefined) continue;\n\t\t\t\tprefixes.add(p.Prefix.slice(this.prefix.length));\n\t\t\t}\n\t\t\tif (limit !== undefined && objects.length + prefixes.size >= limit) {\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tcontinuationToken = response.NextContinuationToken;\n\t\t} while (continuationToken);\n\n\t\treturn { objects, prefixes: [...prefixes] };\n\t}\n}\n"],"mappings":"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","names":[]}

package/dist/s3.d.cts

@@ -1,36 +0,0 @@
-import { S3Client } from '@aws-sdk/client-s3';
-import { O as ObjectStore, c as ObjectStat, L as ListOptions, d as ListResult } from './types-dbHzZ4ed.cjs';
-
-interface S3ObjectStoreOptions {
-    /** A configured S3Client. Works with AWS S3, Cloudflare R2, MinIO, Backblaze B2, … */
-    client: S3Client;
-    bucket: string;
-    /** Key prefix for every object, e.g. `"git"`. Optional. */
-    prefix?: string;
-    /**
-     * Derive a Content-Type header for uploads from the (un-prefixed) key.
-     * Return `undefined` to let S3 apply its default. Cosmetic — git never
-     * reads it back — but keeps refs and config human-readable in bucket UIs.
-     */
-    contentType?: (key: string) => string | undefined;
-}
-/**
- * {@link ObjectStore} over any S3-compatible API via `@aws-sdk/client-s3`
- * (peer dependency). One instance per bucket/prefix; reuse a single
- * `S3Client` across stores so HTTP connections are pooled.
- */
-declare class S3ObjectStore implements ObjectStore {
-    private readonly client;
-    private readonly bucket;
-    private readonly prefix;
-    private readonly contentType?;
-    constructor(options: S3ObjectStoreOptions);
-    private fullKey;
-    get(key: string): Promise<Uint8Array | null>;
-    put(key: string, data: Uint8Array): Promise<void>;
-    delete(key: string): Promise<void>;
-    head(key: string): Promise<ObjectStat | null>;
-    list(prefix: string, options?: ListOptions): Promise<ListResult>;
-}
-
-export { S3ObjectStore, type S3ObjectStoreOptions };

package/dist/types-BHoHOaQt.d.ts

@@ -1,53 +0,0 @@
-import git__default from 'isomorphic-git';
-
-/** The fs shape isomorphic-git accepts, derived from its own signatures. */
-type IsoGitFs = Parameters<typeof git__default.readTree>[0]["fs"];
-/**
- * A repository handle: everything isomorphic-git needs to address one bare
- * repo. Create it once per request (sharing `cache` across calls is what lets
- * isomorphic-git reuse parsed pack indexes) and pass it to every op.
- */
-interface Repo {
-    fs: IsoGitFs;
-    gitdir: string;
-    /** isomorphic-git's shared parse cache — strongly recommended per repo. */
-    cache?: object;
-}
-/**
- * Key/value store for memoizing expensive walk results (commit logs, tree
- * listings, per-file history). Keys are namespaced `kind:gitdir:headSha:…`,
- * so entries self-invalidate on push (new head, new key) — but evict entries
- * under {@link resultKeyPrefixes} after rewriting a repo's storage out of
- * band, or stale walks leak until your store's own eviction.
- */
-interface ResultCache {
-    get<T>(key: string): T | null | undefined;
-    set(key: string, value: unknown): void;
-}
-/** Optional instrumentation and tuning hooks accepted by every op. */
-interface OpsHooks {
-    resultCache?: ResultCache;
-    /** Wrap a timed sub-step (network walk, tree listing). Default: run directly. */
-    step?: <T>(label: string, fn: () => Promise<T>) => Promise<T>;
-    /** Diagnostic sink for cache hit/miss and walk summaries. */
-    onNote?: (message: string) => void;
-    /**
-     * Wire pack prefetching (e.g. `GitFs.prefetchPacks`) here so a sequential
-     * walk doesn't pay one network round trip per commit. Called once before
-     * history walks of depth >= `prefetchMinDepth` (see below), and
-     * unconditionally on every cache-miss tree read ({@link getTreeFromRef}) —
-     * a tree read has no shallow case, it always needs at least the head
-     * commit's tree object.
-     */
-    prefetch?: () => Promise<void>;
-    /** Minimum walk depth before `prefetch` fires for history walks. Default 5. */
-    prefetchMinDepth?: number;
-}
-/**
- * The result-cache key prefixes holding entries for `gitdir` — evict these
- * from your {@link ResultCache} when the repo's storage was rewritten outside
- * a normal push (bulk sync, rename, repack cleanup).
- */
-declare function resultKeyPrefixes(gitdir: string): string[];
-
-export { type IsoGitFs as I, type OpsHooks as O, type Repo as R, type ResultCache as a, resultKeyPrefixes as r };

package/dist/types-dbHzZ4ed.d.cts

@@ -1,131 +0,0 @@
-/**
- * Minimal key/value object-storage contract the git filesystem is built on.
- *
- * Implement this interface to back git with any storage system. Two
- * implementations ship with the package: {@link ../stores/memory.MemoryObjectStore}
- * and {@link ../stores/s3.S3ObjectStore}.
- */
-interface ObjectStore {
-    /** Return the object's bytes, or `null` if the key does not exist. */
-    get(key: string): Promise<Uint8Array | null>;
-    /** Create or overwrite the object at `key`. */
-    put(key: string, data: Uint8Array): Promise<void>;
-    /** Delete the object at `key`. Must succeed silently if it does not exist. */
-    delete(key: string): Promise<void>;
-    /** Return object metadata without fetching the body, or `null` if absent. */
-    head(key: string): Promise<ObjectStat | null>;
-    /**
-     * List keys under `prefix`.
-     *
-     * With `delimiter: "/"` the result groups keys the way S3 ListObjectsV2
-     * does: `objects` holds direct children, `prefixes` holds the common
-     * prefixes ("subdirectories"). With `limit`, implementations may return
-     * early after finding that many entries (used for cheap existence checks).
-     */
-    list(prefix: string, options?: ListOptions): Promise<ListResult>;
-}
-interface ObjectStat {
-    size: number;
-}
-interface ListOptions {
-    delimiter?: string;
-    limit?: number;
-}
-interface ListResult {
-    objects: {
-        key: string;
-        size: number;
-    }[];
-    prefixes: string[];
-}
-/** What a caller knows about a gitdir it registers with `registerGitdir`. */
-interface GitdirFacts {
-    /**
-     * Top-level gitdir files this backend never writes, such as
-     * `packed-refs` or `shallow`; reading or statting them answers ENOENT
-     * with zero store calls. isomorphic-git probes both on most commands.
-     */
-    absentFiles?: readonly string[];
-}
-/** Options accepted by {@link ../git-fs.createGitFs}. */
-interface GitFsOptions {
-    /**
-     * Key prefix all paths are stored under, e.g. `"repos/alice/blog"`.
-     * Defaults to `""` (paths map directly to keys).
-     */
-    prefix?: string;
-    /**
-     * Track, per git directory, whether any loose objects exist at all.
-     * Fully packed repositories then skip the doomed round trip probing a
-     * loose-object path that is guaranteed to miss. The first loose-object
-     * read under a gitdir detects its hint (one listing) if no explicit
-     * `detectLooseObjects(gitdir)` call already has.
-     * Default false.
-     */
-    looseObjectHints?: boolean;
-    /**
-     * Paths (relative to the fs, before `prefix` is applied) that are known
-     * never to exist; `readFile`/`stat` answer ENOENT for them with zero
-     * store calls. Useful for files git probes on every operation but this
-     * backend never writes, such as `packed-refs` or `shallow` under a known
-     * gitdir layout. Match precisely — a plain suffix check is wrong, since
-     * e.g. `refs/heads/packed-refs` is a legal branch ref.
-     */
-    isStructurallyAbsent?: (path: string) => boolean;
-    /** Time-to-live for loose-object hints in milliseconds. Default 3 600 000. */
-    hintTtlMs?: number;
-    /** Diagnostic sink for notable fs events (hint detection results). */
-    onNote?: (message: string) => void;
-}
-type Encoding = "utf8";
-interface ReadFileOptions {
-    encoding?: Encoding;
-}
-interface WriteFileOptions {
-    encoding?: Encoding;
-    mode?: number;
-}
-/**
- * The stat shape isomorphic-git expects. Object storage has no inodes,
- * owners, or modification times, so numeric fields are zero.
- */
-interface Stat {
-    type: "file" | "dir";
-    mode: number;
-    size: number;
-    ino: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    uid: number;
-    gid: number;
-    dev: number;
-    mtime: Date;
-    ctime: Date;
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isSymbolicLink(): boolean;
-}
-/**
- * Promise-based filesystem client compatible with isomorphic-git's `fs`
- * option. Declared locally so the package has no dependency on
- * isomorphic-git itself.
- */
-interface GitFsClient {
-    promises: {
-        readFile(filepath: string, options?: ReadFileOptions | Encoding): Promise<Uint8Array | string>;
-        writeFile(filepath: string, data: Uint8Array | string, options?: WriteFileOptions | Encoding): Promise<void>;
-        unlink(filepath: string): Promise<void>;
-        readdir(dirpath: string): Promise<string[]>;
-        mkdir(dirpath: string, options?: {
-            mode?: number;
-        }): Promise<void>;
-        rmdir(dirpath: string): Promise<void>;
-        stat(filepath: string): Promise<Stat>;
-        lstat(filepath: string): Promise<Stat>;
-        readlink(filepath: string): Promise<never>;
-        symlink(target: string, filepath: string): Promise<never>;
-        chmod(filepath: string, mode: number): Promise<void>;
-    };
-}
-
-export type { GitFsClient as G, ListOptions as L, ObjectStore as O, Stat as S, GitdirFacts as a, GitFsOptions as b, ObjectStat as c, ListResult as d };