git-fs-s3 0.3.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nandan Varma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,272 @@
+# git-fs-s3
+
+[![npm version](https://img.shields.io/npm/v/git-fs-s3.svg)](https://www.npmjs.com/package/git-fs-s3)
+[![CI](https://github.com/nandan-varma/git-fs-s3/actions/workflows/ci.yml/badge.svg)](https://github.com/nandan-varma/git-fs-s3/actions/workflows/ci.yml)
+[![license](https://img.shields.io/npm/l/git-fs-s3.svg)](LICENSE)
+
+An [isomorphic-git](https://isomorphic-git.org) filesystem backend for S3-compatible object storage — AWS S3, Cloudflare R2, MinIO, Backblaze B2. Run git repositories on serverless platforms with **no disk, no git binary, and no state between invocations**.
+
+```
+isomorphic-git  ──fs──►  git-fs-s3  ──►  ObjectStore  ──►  S3 / R2 / MinIO / memory
+```
+
+Extracted from the git layer of a production git-hosting service, where it serves clones, pushes, and repo browsing directly against Cloudflare R2 from Vercel functions. Three layers, usable independently:
+
+- **root export** — the fs backend itself (`createGitFs`, stores, caching).
+- **`/http`** — a git smart-HTTP protocol handler (`upload-pack`/`receive-pack`) built on it.
+- **`/ops`** — higher-level git-hosting operations (branches, commits, diffs, history, merge) built on top of that.
+
+## Why
+
+isomorphic-git removed the need for a native `git` binary, but it still expects a filesystem. On Lambda, Vercel, or Cloudflare Workers you don't have a durable one. This package maps the fs contract git actually uses onto object-storage keys, so a bare repository lives entirely in a bucket:
+
+```
+repos/alice/blog/HEAD
+repos/alice/blog/refs/heads/main
+repos/alice/blog/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391
+```
+
+Use it to build git-backed CMSes, notes apps with real version history, lightweight code forges, or agent sandboxes with auditable file history.
+
+## Install
+
+```bash
+npm install git-fs-s3 isomorphic-git
+# for the S3 store (any S3-compatible provider):
+npm install @aws-sdk/client-s3
+```
+
+## Quick start
+
+### Cloudflare R2 / AWS S3 / MinIO
+
+```typescript
+import { S3Client } from "@aws-sdk/client-s3";
+import git from "isomorphic-git";
+import { createCachedStore, createGitFs } from "git-fs-s3";
+import { S3ObjectStore } from "git-fs-s3/s3";
+
+const store = new S3ObjectStore({
+  client: new S3Client({
+    region: "auto",
+    endpoint: process.env.R2_ENDPOINT, // omit for AWS S3
+    credentials: {
+      accessKeyId: process.env.R2_ACCESS_KEY_ID!,
+      secretAccessKey: process.env.R2_SECRET_ACCESS_KEY!,
+    },
+  }),
+  bucket: "my-git-repos",
+});
+
+const fs = createGitFs(createCachedStore(store), {
+  prefix: "repos/alice/blog",
+});
+
+// The bucket now behaves like a directory containing a bare repo:
+await git.init({ fs, gitdir: "/git", bare: true, defaultBranch: "main" });
+const oid = await git.resolveRef({ fs, gitdir: "/git", ref: "main" });
+const log = await git.log({ fs, gitdir: "/git", ref: "main" });
+```
+
+### In memory (tests, examples)
+
+```typescript
+import git from "isomorphic-git";
+import { createGitFs, MemoryObjectStore } from "git-fs-s3";
+
+const fs = createGitFs(new MemoryObjectStore());
+await git.init({ fs, gitdir: "/repo.git", bare: true });
+```
+
+### Any other storage
+
+Implement the five-method `ObjectStore` interface (`get`, `put`, `delete`, `head`, `list`) and pass it to `createGitFs` — that's the whole contract. Google Cloud Storage, Azure Blob, a database, anything.
+
+## Production stack
+
+The stores compose as decorators. For a serving path that hits object storage hundreds of times per page, stack them in this order — retry closest to the network so the cache never stores transient failures and coalesced callers share one retried request:
+
+```typescript
+import {
+  createCachedStore,
+  createGitFs,
+  createRetryStore,
+} from "git-fs-s3";
+import { S3ObjectStore } from "git-fs-s3/s3";
+
+const store = createCachedStore(
+  createRetryStore(
+    new S3ObjectStore({
+      client,
+      bucket: "my-git-repos",
+      // cosmetic: keeps refs/config human-readable in bucket UIs
+      contentType: (key) =>
+        /\/(HEAD|config)$|\/refs\//.test(key) ? "text/plain" : undefined,
+    }),
+  ),
+  {
+    maxBytes: 256 * 1024 * 1024,
+    ttlMs: 3_600_000,
+    cacheMisses: true, // loose-object probes on packed repos are ~always misses
+    cacheLists: true,  // caches readdir + existence probes
+    // refs and the objects/pack listing are the mutable parts of a gitdir —
+    // give them a short override instead of the long ttlMs above, or a warm
+    // process can keep serving a pre-push ref (or fail to notice a freshly
+    // pushed pack exists at all) for the rest of ttlMs. Cheap: both are one
+    // small object or a bounded listing.
+    ttlForKey: (key) =>
+      /\/(HEAD|refs(\/|$)|objects\/(pack\/)?$)/.test(key) ? 5_000 : undefined,
+  },
+);
+
+const fs = createGitFs(store, {
+  looseObjectHints: true,
+  // paths git probes constantly but this backend never writes:
+  isStructurallyAbsent: (p) => /(^|\/)git\/(packed-refs|shallow)$/.test(p),
+});
+
+// Before a full-history walk (commit log, reachability traversal):
+await fs.detectLooseObjects(gitdir);   // one bounded LIST per repo
+await fs.prefetchPacks(gitdir);        // parallel pack warm-up
+
+// After anything writes to the bucket *around* this fs (a hydrate/sync
+// pipeline, a bulk upload, another process): drop the affected state, or
+// reads can stay stale for up to ttlMs.
+fs.invalidate("repos/alice/blog");
+```
+
+## API
+
+### `createGitFs(store, options?)`
+
+Returns a promise-based fs client for isomorphic-git's `fs` option, plus git-aware maintenance methods.
+
+- `options.prefix` — key prefix all paths resolve under (e.g. `"repos/alice/blog"`). Paths that would traverse above it throw `EINVAL`.
+- `options.looseObjectHints` — remember, per gitdir, whether any loose objects exist so fully packed repos skip every guaranteed-miss loose read. Hints are only created by `detectLooseObjects`; a loose write flips them back instantly, so they can't go stale mid-push. Default off.
+- `options.isStructurallyAbsent(path)` — paths that are known never to exist answer `ENOENT` with zero store calls (e.g. `packed-refs`/`shallow` under your gitdir layout). Match precisely — `refs/heads/packed-refs` is a legal branch.
+- `options.hintTtlMs` — loose-hint TTL, default 1 h. `options.onNote` — diagnostic sink.
+
+The returned fs also exposes:
+
+- `detectLooseObjects(gitdir)` — one bounded LIST that registers the loose-object hint; call before full-history walks.
+- `prefetchPacks(gitdir, { maxPacks? })` — warm all pack files in parallel before a sequential walk (skipped past `maxPacks * 2` entries).
+- `invalidate(pathPrefix)` — drop hints under the prefix and forward to the store's `invalidate` if it has one.
+
+### `S3ObjectStore({ client, bucket, prefix?, contentType? })`
+
+`ObjectStore` over `@aws-sdk/client-s3` (optional peer dependency, loaded only via the `/s3` subpath). Reuse one `S3Client` across stores so HTTP connections are pooled — a busy repo page can mean hundreds of object reads. `contentType(key)` optionally derives a `Content-Type` header for uploads.
+
+### `MemoryObjectStore()`
+
+In-memory store; also the reference implementation of list/delimiter semantics.
+
+### `createCachedStore(store, options?)`
+
+Wraps any store with an in-process LRU read cache (git objects are content-addressed, so they cache perfectly; refs and directory listings are mutable and should use a shorter override — see `ttlForKey`). Returns a `CachedObjectStore` with an `invalidate(prefix)` method.
+
+- `maxBytes` — cache budget, default 50 MiB. `maxEntryBytes` — largest admissible entry, default a tenth of `maxBytes`, so one huge pack can't evict the working set.
+- `ttlMs` — entry TTL, default 60 s
+- `ttlForKey(key)` — per-key/prefix TTL override in ms (applies to `get`/`head`/`list`); return `undefined` to fall back to `ttlMs`. A single long `ttlMs` is right for content-addressed object keys (the same key's bytes never change) but wrong for mutable ones — a ref's value moves on every push, and a directory listing (`objects/pack/`) grows on every push, while the *key* naming them stays the same. This cache is in-process with no cross-instance invalidation, so without an override a warm instance that already cached a ref, or a pack directory's listing, can keep serving that pre-push view for the rest of `ttlMs` even though nothing is wrong with its own invalidation logic — it just never re-checked. See the [caching guide](https://nandan-varma.github.io/git-fs-s3/guides/caching/) for the full reasoning.
+- `cacheMisses` — also cache "not found" results. Big win for loose-object probes on packed repos; only safe when this process is the sole writer.
+- `cacheLists` — also cache `list()` results (readdir + existence probes). Writes through the store keep listings consistent, with one deliberate asymmetry: a non-empty `limit: 1` probe ("this directory exists") survives writes underneath it, since a write can't make a directory stop existing. After external writes, call `invalidate(prefix)`.
+- `coalesce` — collapse concurrent `get`/`head`/`list` calls for the same key into one backend request. Default on.
+- `onHit(key)` / `onMiss(key)` — instrumentation hooks.
+
+**Staleness contract:** `cacheMisses`/`cacheLists` trade read traffic for a window (bounded by `ttlMs`) in which another process's writes are invisible. Fine when each repo has one serving process, or when every external write path calls `invalidate()`.
+
+### `createRetryStore(store, options?)`
+
+Wraps any store with exponential-backoff retries and a per-instance circuit breaker. Place it directly above the network store, under the cache.
+
+- `retries` (3), `initialDelayMs` (100), `maxDelayMs` (5000), `jitter` (0.3)
+- `isRetryable(error)` — default retries network faults, throttling, and HTTP 5xx/429
+- `breaker` — `{ threshold: 5, resetMs: 30_000 }` by default, or `false` to disable. While open, calls fail fast with `CircuitOpenError` (`code: "EUNAVAILABLE"`).
+- `onRetry(info)` — logging hook.
+
+## Git smart-HTTP
+
+`git-fs-s3/http` implements the git smart-HTTP protocol (`info/refs`, `upload-pack`, `receive-pack`) as plain functions over a `Repo` — no framework assumptions, Fetch-API-shaped inputs/outputs. Extracted from the same production git-hosting service's HTTP layer, so it's what actually serves `git clone`/`git push` over HTTPS: pkt-line framing, side-band-64k packfile chunking (required once a client like isomorphic-git negotiates it — it always demuxes the response), CAS-checked ref updates, and pack consolidation.
+
+```typescript
+import {
+  handleInfoRefs,
+  handleUploadPack,
+  parseReceivePackBody,
+  applyReceivePack,
+  receivePackResponse,
+} from "git-fs-s3/http";
+
+// GET .../info/refs?service=git-upload-pack — auth/authz is the caller's job
+export async function infoRefs(repo: Repo, service: "git-upload-pack" | "git-receive-pack") {
+  const { status, headers, body } = await handleInfoRefs(repo, { service });
+  return new Response(body, { status, headers });
+}
+
+// POST .../git-upload-pack (clone/fetch)
+export async function uploadPack(repo: Repo, request: Request) {
+  const body = new Uint8Array(await request.arrayBuffer());
+  const { status, headers, body: respBody } = await handleUploadPack(repo, body);
+  return new Response(respBody, { status, headers });
+}
+
+// POST .../git-receive-pack (push)
+export async function receivePack(repo: Repo, request: Request) {
+  const body = new Uint8Array(await request.arrayBuffer());
+  const { results, stalePackPaths } = await applyReceivePack(
+    repo,
+    parseReceivePackBody(body),
+    { repack: { threshold: 4 } }, // or false to never auto-consolidate
+  );
+  // stalePackPaths were removed locally by the repack — delete them from any
+  // secondary storage this repo also lives in, same as you'd invalidate a cache.
+  const { status, headers, body: respBody } = receivePackResponse(results);
+  return new Response(respBody, { status, headers });
+}
+```
+
+Every client-supplied ref name in a push is validated with `isSafeFullRefName` (from the top-level export, see below) *inside* `applyRefUpdates`/`applyReceivePack` before it reaches any filesystem call — `git.commit`/`git.merge`/`git.deleteBranch` and the raw `git.resolveRef`/`git.deleteRef`/`git.writeRef` isomorphic-git calls this module uses internally do **not** validate ref names themselves (only `git.branch` and the top-level `git.writeRef` do), so an unvalidated `"../"`-laden ref name is a cross-repo path traversal on any shared-storage server. If you build additional git-touching endpoints on top of this package, run ref/branch names from request input through `isSafeFullRefName`/`isSafeBranchName`/`isSafeRefName`/`isSafeRepoPath` yourself first.
+
+`HttpHooks` (`{ step?, onWarn? }`), accepted by every handler, is the instrumentation seam: `step(label, fn)` wraps a timed sub-step — drop in an app's own request-scoped timer — and `onWarn(message, error)` surfaces non-fatal problems (a missing object during a reachability walk, a failed repack). `handleUploadPack`'s `beforeWalk` option is where to wire loose-object detection (`GitFs.detectLooseObjects`, above) so a fully packed repo's reachability walk doesn't pay a doomed loose-object probe per object.
+
+`repackRepository(repo, options?, hooks?)` — also exported standalone for out-of-band maintenance (clearing a backlog outside a live push) — consolidates all packs into one once `objects/pack/` crosses `options.threshold` (default `REPACK_PACK_COUNT_THRESHOLD = 4`) packs, verifying every object's SHA-1 independently before writing (isomorphic-git's *packed*-object read path never checks a resolved delta's content against the requested oid — only the loose-object branch does). Returns the gitdir-relative paths of the `.pack`/`.idx` files it removed locally; if this repo's storage is also synced elsewhere, delete those same paths there too, or a reader served by the stale copy re-fetches objects that are gone from the pack it expects them in.
+
+## App-layer git operations
+
+`git-fs-s3/ops` is a higher-level layer for building a git-hosting UI on top of `createGitFs` — the operations a repo browser / PR flow actually needs, each taking a `Repo` (`{ fs, gitdir, cache? }`) plus an optional `OpsHooks` (`{ resultCache?, step?, onNote?, prefetchPacks? }`) for the same timing/caching seam `GitFs` and `/http` use:
+
+- **Branches** — `listBranches`, `createBranchFrom`, `deleteBranchByName`.
+- **Commits** — `commitFilesToBare` (write one or more files as a single commit against a branch, creating it if new), `deleteFileFromBare`, `authorNow`.
+- **Trees** — `upsertTree`/`deleteFromTree` (overlay blobs onto a tree, return the new root oid), `listTreeEntries`, `findTreeEntry`.
+- **History** — `getCommitLog`/`getCommitHistory` (cached, resumable commit-chain walks — reuses a previously-walked prefix instead of re-walking from HEAD), `getFileContent`/`getFileFromRef`/`getTreeFromRef`, `getFileHistory` (per-file commit history), `getLastCommitsForTree` (the "last commit" column on a directory listing, batched two-phase prefetch-then-resolve).
+- **Diff** — `getCommitDiff`/`getDiffBetweenRefs`, unified-diff patches via the `diff` package (optional peer dependency).
+- **Merge** — `analyzeMerge` (fast-forward/diverged pre-check — not a real content-conflict check, see its doc comment) and `fastForwardMerge`.
+
+```typescript
+import { commitFilesToBare, authorNow, getCommitLog } from "git-fs-s3/ops";
+
+await commitFilesToBare(repo, {
+  branch: "main",
+  message: "Update README",
+  author: authorNow("Ada", "ada@example.com"),
+  files: [{ path: "README.md", content: "# hello\n" }],
+});
+
+const { entries } = await getCommitLog(repo, { ref: "main", depth: 50 });
+```
+
+`resultKeyPrefixes` (from `/ops`) lists the `ResultCache` key prefixes these functions write under — evict them after rewriting a repo's storage out of band (bulk sync, rename), or a cached walk result outlives the history it describes.
+
+## Semantics & limitations
+
+- **Bare repositories are the target.** Plumbing (`writeBlob`/`writeTree`/`writeCommit`/`readCommit`/`log`/refs/branches) is covered by the test suite. Worktree operations (`checkout`, `add`, `status`) want a real disk — hydrate to `/tmp` for those.
+- Directories are implicit (`mkdir` no-op, a dir exists when keys live under it), like object storage itself.
+- Symlinks are unsupported (`readlink`→`ENOENT`, `symlink`→`EPERM`); bare repos don't contain them.
+- Object storage has no rename and no atomic multi-key transactions. Concurrent pushes to the same repo need external serialization (a lock or single-writer queue).
+
+## Roadmap
+
+- More stores out of the box (Google Cloud Storage, Azure Blob)
+
+## License
+
+[MIT](LICENSE)

package/dist/chunk-4QPWSRYC.js

@@ -0,0 +1,123 @@
+// src/edge-utils.ts
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+function encodeUtf8(data) {
+  return textEncoder.encode(data);
+}
+function decodeUtf8(data) {
+  return textDecoder.decode(data);
+}
+function decodeAscii(data) {
+  let s = "";
+  for (let i = 0; i < data.length; i++)
+    s += String.fromCharCode(data[i]);
+  return s;
+}
+function concat(...parts) {
+  let total = 0;
+  for (const p of parts) total += p.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+function toHex(data) {
+  let hex = "";
+  for (let i = 0; i < data.length; i++)
+    hex += data[i].toString(16).padStart(2, "0");
+  return hex;
+}
+function toBase64(data) {
+  let binary = "";
+  for (let i = 0; i < data.length; i++)
+    binary += String.fromCharCode(data[i]);
+  return btoa(binary);
+}
+function fromHex(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+async function sha1(data) {
+  const bytes = typeof data === "string" ? encodeUtf8(data) : data;
+  const hash = await globalThis.crypto.subtle.digest("SHA-1", bytes);
+  return toHex(new Uint8Array(hash));
+}
+async function deflate(data) {
+  const stream = new Blob([data]).stream().pipeThrough(new CompressionStream("deflate"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function hasNullByte(data) {
+  return data.includes(0);
+}
+function readBlobContent(blob) {
+  const isBinary = hasNullByte(blob);
+  return {
+    isBinary,
+    text: isBinary ? "" : decodeUtf8(blob),
+    bytes: blob
+  };
+}
+
+// src/refs.ts
+var BAD_REF_COMPONENT = (
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: control chars are exactly what git's own ref-name rules reject — this needs to match the same range.
+  /(^|[/.])([/.]|$)|^@$|@\{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/
+);
+var FULL_SHA_RE = /^[0-9a-f]{40}$/i;
+function isSafeFullRefName(ref) {
+  if (!ref.startsWith("refs/heads/") && !ref.startsWith("refs/tags/")) {
+    return false;
+  }
+  return !BAD_REF_COMPONENT.test(ref);
+}
+function isSafeBranchName(name) {
+  if (!name || name.startsWith("refs/") || name === "HEAD") return false;
+  if (FULL_SHA_RE.test(name)) return false;
+  return !BAD_REF_COMPONENT.test(name);
+}
+function isFullSha(value) {
+  return FULL_SHA_RE.test(value);
+}
+function isSafeRefName(value) {
+  return isSafeBranchName(value) || isFullSha(value);
+}
+function isSafeRepoPath(p) {
+  if (p.startsWith("/")) return false;
+  if (p.split("/").some((segment) => segment === "..")) return false;
+  if (/^\.git(\/|$)/i.test(p)) return false;
+  if (p.includes("\0")) return false;
+  return true;
+}
+function qualifyBranchRef(ref) {
+  if (ref.startsWith("refs/") || ref === "HEAD" || FULL_SHA_RE.test(ref)) {
+    return ref;
+  }
+  return `refs/heads/${ref}`;
+}
+
+export {
+  encodeUtf8,
+  decodeUtf8,
+  decodeAscii,
+  concat,
+  toHex,
+  toBase64,
+  fromHex,
+  sha1,
+  deflate,
+  hasNullByte,
+  readBlobContent,
+  isSafeFullRefName,
+  isSafeBranchName,
+  isFullSha,
+  isSafeRefName,
+  isSafeRepoPath,
+  qualifyBranchRef
+};
+//# sourceMappingURL=chunk-4QPWSRYC.js.map

package/dist/chunk-4QPWSRYC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/edge-utils.ts","../src/refs.ts"],"sourcesContent":["/**\n * Edge-compatible utilities replacing node:crypto, node:zlib, and Buffer.\n *\n * Every function here uses only Web APIs (SubtleCrypto, CompressionStream,\n * TextEncoder/TextDecoder) — no Node built-ins. They work on Cloudflare\n * Workers, Vercel Edge, Deno Deploy, and Node >= 18.\n */\n\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder();\n\n// ---------------------------------------------------------------------------\n// Text\n// ---------------------------------------------------------------------------\n\n/**\n * Encode a UTF-8 string to bytes.\n *\n * Return type pinned to `Uint8Array<ArrayBuffer>` (not the bare `Uint8Array`,\n * whose default type argument differs across TypeScript versions) so it's\n * always assignable to Fetch API `BodyInit` regardless of a consumer's own\n * TypeScript/lib version.\n */\nexport function encodeUtf8(data: string): Uint8Array<ArrayBuffer> {\n\treturn textEncoder.encode(data);\n}\n\n/** Decode bytes as UTF-8. */\nexport function decodeUtf8(data: Uint8Array): string {\n\treturn textDecoder.decode(data);\n}\n\n/** Decode bytes as ASCII. */\nexport function decodeAscii(data: Uint8Array): string {\n\tlet s = \"\";\n\tfor (let i = 0; i < data.length; i++)\n\t\ts += String.fromCharCode(data[i] as number);\n\treturn s;\n}\n\n// ---------------------------------------------------------------------------\n// Array manipulation\n// ---------------------------------------------------------------------------\n\n/** Concatenate any number of Uint8Arrays into one. */\nexport function concat(...parts: Uint8Array[]): Uint8Array<ArrayBuffer> {\n\tlet total = 0;\n\tfor (const p of parts) total += p.length;\n\tconst out = new Uint8Array(total);\n\tlet offset = 0;\n\tfor (const p of parts) {\n\t\tout.set(p, offset);\n\t\toffset += p.length;\n\t}\n\treturn out;\n}\n\n/** Extract a subarray (alias for Uint8Array.subarray for readability). */\nexport function slice(\n\tdata: Uint8Array,\n\tstart: number,\n\tend?: number,\n): Uint8Array {\n\treturn data.subarray(start, end);\n}\n\n// ---------------------------------------------------------------------------\n// Encoding\n// ---------------------------------------------------------------------------\n\n/** Uint8Array → lowercase hex string. */\nexport function toHex(data: Uint8Array): string {\n\tlet hex = \"\";\n\tfor (let i = 0; i < data.length; i++)\n\t\thex += (data[i] as number).toString(16).padStart(2, \"0\");\n\treturn hex;\n}\n\n/** Uint8Array → base64 string. */\nexport function toBase64(data: Uint8Array): string {\n\tlet binary = \"\";\n\tfor (let i = 0; i < data.length; i++)\n\t\tbinary += String.fromCharCode(data[i] as number);\n\treturn btoa(binary);\n}\n\n/** Hex string → Uint8Array. */\nexport function fromHex(hex: string): Uint8Array<ArrayBuffer> {\n\tconst bytes = new Uint8Array(hex.length / 2);\n\tfor (let i = 0; i < bytes.length; i++) {\n\t\tbytes[i] = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);\n\t}\n\treturn bytes;\n}\n\n// ---------------------------------------------------------------------------\n// Crypto\n// ---------------------------------------------------------------------------\n\n/** SHA-1 hash via Web Crypto API. Returns a hex string. */\nexport async function sha1(data: Uint8Array | string): Promise<string> {\n\tconst bytes = typeof data === \"string\" ? encodeUtf8(data) : data;\n\tconst hash = await globalThis.crypto.subtle.digest(\"SHA-1\", bytes);\n\treturn toHex(new Uint8Array(hash));\n}\n\n// ---------------------------------------------------------------------------\n// Compression\n// ---------------------------------------------------------------------------\n\n/**\n * Deflate compress via the CompressionStream Web API.\n * Falls back to throwing if CompressionStream is unavailable (very old runtimes).\n */\nexport async function deflate(\n\tdata: Uint8Array,\n): Promise<Uint8Array<ArrayBuffer>> {\n\tconst stream = new Blob([data])\n\t\t.stream()\n\t\t.pipeThrough(new CompressionStream(\"deflate\"));\n\treturn new Uint8Array(await new Response(stream).arrayBuffer());\n}\n\n// ---------------------------------------------------------------------------\n// Binary detection (replaces Buffer.includes(0) pattern)\n// ---------------------------------------------------------------------------\n\n/** Check if a Uint8Array contains a null byte. */\nexport function hasNullByte(data: Uint8Array): boolean {\n\treturn data.includes(0);\n}\n\n/**\n * Read a blob as text or binary metadata — the edge-compatible replacement\n * for the `Buffer.from(blob)` pattern used throughout diff.ts and history.ts.\n */\nexport function readBlobContent(blob: Uint8Array): {\n\tisBinary: boolean;\n\ttext: string;\n\tbytes: Uint8Array;\n} {\n\tconst isBinary = hasNullByte(blob);\n\treturn {\n\t\tisBinary,\n\t\ttext: isBinary ? \"\" : decodeUtf8(blob),\n\t\tbytes: blob,\n\t};\n}\n","/**\n * Git ref-name validation, mirroring isomorphic-git's own internal `isValidRef`\n * character-class rules (the check `git.branch` and top-level `git.writeRef`\n * run before touching disk).\n *\n * Several of isomorphic-git's OTHER ref-touching primitives — `git.commit`,\n * `git.merge`, `git.deleteBranch`, and top-level `git.resolveRef`/\n * `git.deleteRef` — do NOT run this check internally: they resolve straight\n * through `fs.write`/`fs.rm(join(gitdir, ref))` with no jail to the gitdir.\n * On a shared-storage server (many repos under one prefix or base directory),\n * every branch/ref name that originates from request input must be validated\n * against these predicates before it reaches any of those primitives —\n * otherwise a `\"../\"`-laden name lets a caller with write access to any single\n * repo read, corrupt, or delete another repo's ref/object files.\n */\n\nconst BAD_REF_COMPONENT =\n\t// biome-ignore lint/suspicious/noControlCharactersInRegex: control chars are exactly what git's own ref-name rules reject — this needs to match the same range.\n\t/(^|[/.])([/.]|$)|^@$|@\\{|[\\x00-\\x20\\x7f~^:?*[\\\\]|\\.lock(\\/|$)/;\n\nconst FULL_SHA_RE = /^[0-9a-f]{40}$/i;\n\n/** Validates a fully-qualified ref (must start with refs/heads/ or refs/tags/). */\nexport function isSafeFullRefName(ref: string): boolean {\n\tif (!ref.startsWith(\"refs/heads/\") && !ref.startsWith(\"refs/tags/\")) {\n\t\treturn false;\n\t}\n\treturn !BAD_REF_COMPONENT.test(ref);\n}\n\n/**\n * Validates a bare branch name (no refs/ prefix). Rejects anything that looks\n * like a full ref path — a name of `\"refs/heads/x\"` would otherwise sail\n * through unprefixed at call sites that build `refs/heads/${name}` themselves\n * (doubling the prefix into something that still resolves), or be used as-is\n * at call sites that pass a name already containing `\"refs/\"` straight\n * through. Also rejects 40-hex SHA-shaped values so a stored branch name can\n * never be ambiguous with a commit SHA at write time; use\n * {@link isSafeRefName} on read paths that accept both shapes.\n */\nexport function isSafeBranchName(name: string): boolean {\n\tif (!name || name.startsWith(\"refs/\") || name === \"HEAD\") return false;\n\tif (FULL_SHA_RE.test(name)) return false;\n\treturn !BAD_REF_COMPONENT.test(name);\n}\n\n/** True for a full 40-hex-char commit SHA — the shape {@link isSafeBranchName} deliberately rejects. */\nexport function isFullSha(value: string): boolean {\n\treturn FULL_SHA_RE.test(value);\n}\n\n/**\n * Validates a \"ref\" field that may name either a branch or a commit SHA it's\n * pinned to — the shape read-path route params take (permalinks, raw links).\n * Both shapes still go through the traversal check.\n */\nexport function isSafeRefName(value: string): boolean {\n\treturn isSafeBranchName(value) || isFullSha(value);\n}\n\n/**\n * Validates a repo-relative file path from request input: relative, no `..`\n * segments, no `.git/` prefix, no null bytes. Use this anywhere a path\n * segment comes straight off a URL or form field rather than re-deriving the\n * checks ad hoc.\n */\nexport function isSafeRepoPath(p: string): boolean {\n\tif (p.startsWith(\"/\")) return false;\n\tif (p.split(\"/\").some((segment) => segment === \"..\")) return false;\n\tif (/^\\.git(\\/|$)/i.test(p)) return false;\n\tif (p.includes(\"\\0\")) return false;\n\treturn true;\n}\n\n/**\n * Qualify a bare branch name to `refs/heads/<name>` before handing it to\n * isomorphic-git. `resolveRef`/`expand` try several candidate paths in\n * sequence for a bare name — `ref`, `refs/ref`, `refs/tags/ref`,\n * `refs/heads/ref`, … — missing (and, against object storage, paying a real\n * round trip for) the first three every time. For a branch-only ref model,\n * skip straight to the winner. Left untouched: already-qualified refs,\n * `\"HEAD\"` (its own first candidate, already optimal), and 40-hex oids\n * (resolved locally by isomorphic-git with no I/O at all).\n */\nexport function qualifyBranchRef(ref: string): string {\n\tif (ref.startsWith(\"refs/\") || ref === \"HEAD\" || FULL_SHA_RE.test(ref)) {\n\t\treturn ref;\n\t}\n\treturn `refs/heads/${ref}`;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-T5NHPY7U.js

@@ -0,0 +1,118 @@
+// src/git-errors.ts
+var GitError = class extends Error {
+  statusCode;
+  retryable;
+  constructor(message, statusCode = 500, retryable = false) {
+    super(message);
+    this.name = this.constructor.name;
+    this.statusCode = statusCode;
+    this.retryable = retryable;
+    Error.captureStackTrace?.(this, this.constructor);
+  }
+  toJSON() {
+    return {
+      error: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      retryable: this.retryable
+    };
+  }
+};
+var GitPathNotFoundError = class extends GitError {
+  constructor(message) {
+    super(message, 404, false);
+  }
+};
+var GitObjectNotFoundError = class extends GitError {
+  constructor(message) {
+    super(message, 404, false);
+  }
+};
+var GitRefNotFoundError = class extends GitError {
+  constructor(message) {
+    super(message, 404, false);
+  }
+};
+var GitRepositoryNotFoundError = class extends GitError {
+  constructor(message) {
+    super(message, 404, false);
+  }
+};
+var GitConflictError = class extends GitError {
+  conflicts;
+  constructor(message, conflicts = []) {
+    super(message, 409, false);
+    this.conflicts = conflicts;
+  }
+  toJSON() {
+    return { ...super.toJSON(), conflicts: this.conflicts };
+  }
+};
+var GitAuthenticationError = class extends GitError {
+  constructor(message) {
+    super(message, 401, false);
+  }
+};
+var GitAuthorizationError = class extends GitError {
+  constructor(message) {
+    super(message, 403, false);
+  }
+};
+var GitRateLimitError = class extends GitError {
+  constructor(message) {
+    super(message, 429, false);
+  }
+};
+var GitInvalidRequestError = class extends GitError {
+  constructor(message) {
+    super(message, 400, false);
+  }
+};
+var GitProtocolError = class extends GitError {
+  constructor(message) {
+    super(message, 400, false);
+  }
+};
+function formatErrorResponse(error) {
+  if (error instanceof GitError) {
+    return {
+      status: error.statusCode,
+      body: error.toJSON(),
+      headers: error.statusCode === 401 ? { "WWW-Authenticate": 'Basic realm="Git Repository"' } : void 0
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      status: 500,
+      body: {
+        error: "InternalServerError",
+        message: "An internal error occurred",
+        retryable: true
+      }
+    };
+  }
+  return {
+    status: 500,
+    body: {
+      error: "UnknownError",
+      message: "An unknown error occurred",
+      retryable: true
+    }
+  };
+}
+
+export {
+  GitError,
+  GitPathNotFoundError,
+  GitObjectNotFoundError,
+  GitRefNotFoundError,
+  GitRepositoryNotFoundError,
+  GitConflictError,
+  GitAuthenticationError,
+  GitAuthorizationError,
+  GitRateLimitError,
+  GitInvalidRequestError,
+  GitProtocolError,
+  formatErrorResponse
+};
+//# sourceMappingURL=chunk-T5NHPY7U.js.map

package/dist/chunk-T5NHPY7U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/git-errors.ts"],"sourcesContent":["/**\n * Git-server error types carrying an HTTP status and a retryability flag, so\n * transport layers can map internal failures to responses without inspecting\n * messages. Extend {@link GitError} for app-specific cases (storage backends,\n * quota, …) and {@link formatErrorResponse} keeps working for them.\n */\nexport class GitError extends Error {\n\tstatusCode: number;\n\tretryable: boolean;\n\n\tconstructor(message: string, statusCode = 500, retryable = false) {\n\t\tsuper(message);\n\t\tthis.name = this.constructor.name;\n\t\tthis.statusCode = statusCode;\n\t\tthis.retryable = retryable;\n\t\tError.captureStackTrace?.(this, this.constructor);\n\t}\n\n\ttoJSON(): Record<string, unknown> {\n\t\treturn {\n\t\t\terror: this.name,\n\t\t\tmessage: this.message,\n\t\t\tstatusCode: this.statusCode,\n\t\t\tretryable: this.retryable,\n\t\t};\n\t}\n}\n\n/** A file/directory path not found within a tree (404). */\nexport class GitPathNotFoundError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 404, false);\n\t}\n}\n\n/** A git object not found (404). */\nexport class GitObjectNotFoundError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 404, false);\n\t}\n}\n\n/** A ref (branch/tag) not found (404). */\nexport class GitRefNotFoundError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 404, false);\n\t}\n}\n\n/** The repository itself not found (404). */\nexport class GitRepositoryNotFoundError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 404, false);\n\t}\n}\n\nexport interface MergeConflictDetail {\n\tfile: string;\n\tbaseLines?: string[];\n\tsourceLines?: string[];\n\ttargetLines?: string[];\n}\n\n/** A merge conflict (409), carrying per-file conflict detail. */\nexport class GitConflictError extends GitError {\n\tconflicts: MergeConflictDetail[];\n\n\tconstructor(message: string, conflicts: MergeConflictDetail[] = []) {\n\t\tsuper(message, 409, false);\n\t\tthis.conflicts = conflicts;\n\t}\n\n\toverride toJSON(): Record<string, unknown> {\n\t\treturn { ...super.toJSON(), conflicts: this.conflicts };\n\t}\n}\n\n/** Authentication failed (401). */\nexport class GitAuthenticationError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 401, false);\n\t}\n}\n\n/** Authorization failed (403). */\nexport class GitAuthorizationError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 403, false);\n\t}\n}\n\n/** Too many failed attempts (429). */\nexport class GitRateLimitError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 429, false);\n\t}\n}\n\n/** Malformed request (400). */\nexport class GitInvalidRequestError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 400, false);\n\t}\n}\n\n/** Git wire-protocol violation (400). */\nexport class GitProtocolError extends GitError {\n\tconstructor(message: string) {\n\t\tsuper(message, 400, false);\n\t}\n}\n\n/**\n * Map any error to an HTTP response shape. 401s carry the WWW-Authenticate\n * header git clients need before they will prompt for credentials. Non-GitError\n * failures are masked as opaque 500s — internal messages don't leak.\n */\nexport function formatErrorResponse(error: unknown): {\n\tstatus: number;\n\tbody: Record<string, unknown>;\n\theaders?: Record<string, string>;\n} {\n\tif (error instanceof GitError) {\n\t\treturn {\n\t\t\tstatus: error.statusCode,\n\t\t\tbody: error.toJSON(),\n\t\t\theaders:\n\t\t\t\terror.statusCode === 401\n\t\t\t\t\t? { \"WWW-Authenticate\": 'Basic realm=\"Git Repository\"' }\n\t\t\t\t\t: undefined,\n\t\t};\n\t}\n\n\tif (error instanceof Error) {\n\t\treturn {\n\t\t\tstatus: 500,\n\t\t\tbody: {\n\t\t\t\terror: \"InternalServerError\",\n\t\t\t\tmessage: \"An internal error occurred\",\n\t\t\t\tretryable: true,\n\t\t\t},\n\t\t};\n\t}\n\n\treturn {\n\t\tstatus: 500,\n\t\tbody: {\n\t\t\terror: \"UnknownError\",\n\t\t\tmessage: \"An unknown error occurred\",\n\t\t\tretryable: true,\n\t\t},\n\t};\n}\n"],"mappings":";AAMO,IAAM,WAAN,cAAuB,MAAM;AAAA,EACnC;AAAA,EACA;AAAA,EAEA,YAAY,SAAiB,aAAa,KAAK,YAAY,OAAO;AACjE,UAAM,OAAO;AACb,SAAK,OAAO,KAAK,YAAY;AAC7B,SAAK,aAAa;AAClB,SAAK,YAAY;AACjB,UAAM,oBAAoB,MAAM,KAAK,WAAW;AAAA,EACjD;AAAA,EAEA,SAAkC;AACjC,WAAO;AAAA,MACN,OAAO,KAAK;AAAA,MACZ,SAAS,KAAK;AAAA,MACd,YAAY,KAAK;AAAA,MACjB,WAAW,KAAK;AAAA,IACjB;AAAA,EACD;AACD;AAGO,IAAM,uBAAN,cAAmC,SAAS;AAAA,EAClD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,yBAAN,cAAqC,SAAS;AAAA,EACpD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,sBAAN,cAAkC,SAAS;AAAA,EACjD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,6BAAN,cAAyC,SAAS;AAAA,EACxD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAUO,IAAM,mBAAN,cAA+B,SAAS;AAAA,EAC9C;AAAA,EAEA,YAAY,SAAiB,YAAmC,CAAC,GAAG;AACnE,UAAM,SAAS,KAAK,KAAK;AACzB,SAAK,YAAY;AAAA,EAClB;AAAA,EAES,SAAkC;AAC1C,WAAO,EAAE,GAAG,MAAM,OAAO,GAAG,WAAW,KAAK,UAAU;AAAA,EACvD;AACD;AAGO,IAAM,yBAAN,cAAqC,SAAS;AAAA,EACpD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,wBAAN,cAAoC,SAAS;AAAA,EACnD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,oBAAN,cAAgC,SAAS;AAAA,EAC/C,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,yBAAN,cAAqC,SAAS;AAAA,EACpD,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAGO,IAAM,mBAAN,cAA+B,SAAS;AAAA,EAC9C,YAAY,SAAiB;AAC5B,UAAM,SAAS,KAAK,KAAK;AAAA,EAC1B;AACD;AAOO,SAAS,oBAAoB,OAIlC;AACD,MAAI,iBAAiB,UAAU;AAC9B,WAAO;AAAA,MACN,QAAQ,MAAM;AAAA,MACd,MAAM,MAAM,OAAO;AAAA,MACnB,SACC,MAAM,eAAe,MAClB,EAAE,oBAAoB,+BAA+B,IACrD;AAAA,IACL;AAAA,EACD;AAEA,MAAI,iBAAiB,OAAO;AAC3B,WAAO;AAAA,MACN,QAAQ;AAAA,MACR,MAAM;AAAA,QACL,OAAO;AAAA,QACP,SAAS;AAAA,QACT,WAAW;AAAA,MACZ;AAAA,IACD;AAAA,EACD;AAEA,SAAO;AAAA,IACN,QAAQ;AAAA,IACR,MAAM;AAAA,MACL,OAAO;AAAA,MACP,SAAS;AAAA,MACT,WAAW;AAAA,IACZ;AAAA,EACD;AACD;","names":[]}