@pierre/storage 0.2.0 → 0.2.1

package/dist/index.cjs

@@ -154,257 +154,7 @@ var errorEnvelopeSchema = zod.z.object({
   error: zod.z.string()
 });
 
-// src/commit.ts
-var MAX_CHUNK_BYTES = 4 * 1024 * 1024;
-var DEFAULT_TTL_SECONDS = 60 * 60;
-var HEADS_REF_PREFIX = "refs/heads/";
-var BufferCtor = globalThis.Buffer;
-var CommitBuilderImpl = class {
-  options;
-  getAuthToken;
-  transport;
-  operations = [];
-  sent = false;
-  constructor(deps) {
-    this.options = normalizeCommitOptions(deps.options);
-    this.getAuthToken = deps.getAuthToken;
-    this.transport = deps.transport;
-    const trimmedMessage = this.options.commitMessage?.trim();
-    const trimmedAuthorName = this.options.author?.name?.trim();
-    const trimmedAuthorEmail = this.options.author?.email?.trim();
-    if (!trimmedMessage) {
-      throw new Error("createCommit commitMessage is required");
-    }
-    if (!trimmedAuthorName || !trimmedAuthorEmail) {
-      throw new Error("createCommit author name and email are required");
-    }
-    this.options.commitMessage = trimmedMessage;
-    this.options.author = {
-      name: trimmedAuthorName,
-      email: trimmedAuthorEmail
-    };
-    if (typeof this.options.expectedHeadSha === "string") {
-      this.options.expectedHeadSha = this.options.expectedHeadSha.trim();
-    }
-    if (typeof this.options.baseBranch === "string") {
-      const trimmedBase = this.options.baseBranch.trim();
-      if (trimmedBase === "") {
-        delete this.options.baseBranch;
-      } else {
-        if (trimmedBase.startsWith("refs/")) {
-          throw new Error("createCommit baseBranch must not include refs/ prefix");
-        }
-        this.options.baseBranch = trimmedBase;
-      }
-    }
-    if (this.options.ephemeralBase && !this.options.baseBranch) {
-      throw new Error("createCommit ephemeralBase requires baseBranch");
-    }
-  }
-  addFile(path, source, options) {
-    this.ensureNotSent();
-    const normalizedPath = this.normalizePath(path);
-    const contentId = randomContentId();
-    const mode = options?.mode ?? "100644";
-    this.operations.push({
-      path: normalizedPath,
-      contentId,
-      mode,
-      operation: "upsert",
-      streamFactory: () => toAsyncIterable(source)
-    });
-    return this;
-  }
-  addFileFromString(path, contents, options) {
-    const encoding = options?.encoding ?? "utf8";
-    const normalizedEncoding = encoding === "utf-8" ? "utf8" : encoding;
-    let data;
-    if (normalizedEncoding === "utf8") {
-      data = new TextEncoder().encode(contents);
-    } else if (BufferCtor) {
-      data = BufferCtor.from(
-        contents,
-        normalizedEncoding
-      );
-    } else {
-      throw new Error(
-        `Unsupported encoding "${encoding}" in this environment. Non-UTF encodings require Node.js Buffer support.`
-      );
-    }
-    return this.addFile(path, data, options);
-  }
-  deletePath(path) {
-    this.ensureNotSent();
-    const normalizedPath = this.normalizePath(path);
-    this.operations.push({
-      path: normalizedPath,
-      contentId: randomContentId(),
-      operation: "delete"
-    });
-    return this;
-  }
-  async send() {
-    this.ensureNotSent();
-    this.sent = true;
-    const metadata = this.buildMetadata();
-    const blobEntries = this.operations.filter((op) => op.operation === "upsert" && op.streamFactory).map((op) => ({
-      contentId: op.contentId,
-      chunks: chunkify(op.streamFactory())
-    }));
-    const authorization = await this.getAuthToken();
-    const ack = await this.transport.send({
-      authorization,
-      signal: this.options.signal,
-      metadata,
-      blobs: blobEntries
-    });
-    return buildCommitResult(ack);
-  }
-  buildMetadata() {
-    const files = this.operations.map((op) => {
-      const entry = {
-        path: op.path,
-        content_id: op.contentId,
-        operation: op.operation
-      };
-      if (op.mode) {
-        entry.mode = op.mode;
-      }
-      return entry;
-    });
-    const metadata = {
-      target_branch: this.options.targetBranch,
-      commit_message: this.options.commitMessage,
-      author: {
-        name: this.options.author.name,
-        email: this.options.author.email
-      },
-      files
-    };
-    if (this.options.expectedHeadSha) {
-      metadata.expected_head_sha = this.options.expectedHeadSha;
-    }
-    if (this.options.baseBranch) {
-      metadata.base_branch = this.options.baseBranch;
-    }
-    if (this.options.committer) {
-      metadata.committer = {
-        name: this.options.committer.name,
-        email: this.options.committer.email
-      };
-    }
-    if (this.options.ephemeral) {
-      metadata.ephemeral = true;
-    }
-    if (this.options.ephemeralBase) {
-      metadata.ephemeral_base = true;
-    }
-    return metadata;
-  }
-  ensureNotSent() {
-    if (this.sent) {
-      throw new Error("createCommit builder cannot be reused after send()");
-    }
-  }
-  normalizePath(path) {
-    if (!path || typeof path !== "string" || path.trim() === "") {
-      throw new Error("File path must be a non-empty string");
-    }
-    return path.replace(/^\//, "");
-  }
-};
-var FetchCommitTransport = class {
-  url;
-  constructor(config) {
-    const trimmedBase = config.baseUrl.replace(/\/+$/, "");
-    this.url = `${trimmedBase}/api/v${config.version}/repos/commit-pack`;
-  }
-  async send(request) {
-    const bodyIterable = buildMessageIterable(request.metadata, request.blobs);
-    const body = toRequestBody(bodyIterable);
-    const init = {
-      method: "POST",
-      headers: {
-        Authorization: `Bearer ${request.authorization}`,
-        "Content-Type": "application/x-ndjson",
-        Accept: "application/json"
-      },
-      body,
-      signal: request.signal
-    };
-    if (requiresDuplex(body)) {
-      init.duplex = "half";
-    }
-    const response = await fetch(this.url, init);
-    if (!response.ok) {
-      const { statusMessage, statusLabel, refUpdate } = await parseCommitPackError(response);
-      throw new RefUpdateError(statusMessage, {
-        status: statusLabel,
-        message: statusMessage,
-        refUpdate
-      });
-    }
-    const ack = commitPackAckSchema.parse(await response.json());
-    return ack;
-  }
-};
-function toRequestBody(iterable) {
-  const readableStreamCtor = globalThis.ReadableStream;
-  if (typeof readableStreamCtor === "function") {
-    const iterator = iterable[Symbol.asyncIterator]();
-    return new readableStreamCtor({
-      async pull(controller) {
-        const { value, done } = await iterator.next();
-        if (done) {
-          controller.close();
-          return;
-        }
-        controller.enqueue(value);
-      },
-      async cancel(reason) {
-        if (typeof iterator.return === "function") {
-          await iterator.return(reason);
-        }
-      }
-    });
-  }
-  return iterable;
-}
-function buildMessageIterable(metadata, blobs) {
-  const encoder = new TextEncoder();
-  return {
-    async *[Symbol.asyncIterator]() {
-      yield encoder.encode(`${JSON.stringify({ metadata })}
-`);
-      for (const blob of blobs) {
-        for await (const segment of blob.chunks) {
-          const payload = {
-            blob_chunk: {
-              content_id: blob.contentId,
-              data: base64Encode(segment.chunk),
-              eof: segment.eof
-            }
-          };
-          yield encoder.encode(`${JSON.stringify(payload)}
-`);
-        }
-      }
-    }
-  };
-}
-function requiresDuplex(body) {
-  if (!body || typeof body !== "object") {
-    return false;
-  }
-  if (typeof body[Symbol.asyncIterator] === "function") {
-    return true;
-  }
-  const readableStreamCtor = globalThis.ReadableStream;
-  if (readableStreamCtor && body instanceof readableStreamCtor) {
-    return true;
-  }
-  return false;
-}
+// src/commit-pack.ts
 function buildCommitResult(ack) {
   const refUpdate = toRefUpdate(ack.result);
   if (!ack.result.success) {
@@ -415,24 +165,98 @@ function buildCommitResult(ack) {
         message: ack.result.message,
         refUpdate
       }
-    );
+    );
+  }
+  return {
+    commitSha: ack.commit.commit_sha,
+    treeSha: ack.commit.tree_sha,
+    targetBranch: ack.commit.target_branch,
+    packBytes: ack.commit.pack_bytes,
+    blobCount: ack.commit.blob_count,
+    refUpdate
+  };
+}
+function toRefUpdate(result) {
+  return {
+    branch: result.branch,
+    oldSha: result.old_sha,
+    newSha: result.new_sha
+  };
+}
+async function parseCommitPackError(response, fallbackMessage) {
+  const cloned = response.clone();
+  let jsonBody;
+  try {
+    jsonBody = await cloned.json();
+  } catch {
+    jsonBody = void 0;
+  }
+  let textBody;
+  if (jsonBody === void 0) {
+    try {
+      textBody = await response.text();
+    } catch {
+      textBody = void 0;
+    }
+  }
+  const defaultStatus = (() => {
+    const inferred = inferRefUpdateReason(String(response.status));
+    return inferred === "unknown" ? "failed" : inferred;
+  })();
+  let statusLabel = defaultStatus;
+  let refUpdate;
+  let message;
+  if (jsonBody !== void 0) {
+    const parsedResponse = commitPackResponseSchema.safeParse(jsonBody);
+    if (parsedResponse.success) {
+      const result = parsedResponse.data.result;
+      if (typeof result.status === "string" && result.status.trim() !== "") {
+        statusLabel = result.status.trim();
+      }
+      refUpdate = toPartialRefUpdateFields(result.branch, result.old_sha, result.new_sha);
+      if (typeof result.message === "string" && result.message.trim() !== "") {
+        message = result.message.trim();
+      }
+    }
+    if (!message) {
+      const parsedError = errorEnvelopeSchema.safeParse(jsonBody);
+      if (parsedError.success) {
+        const trimmed = parsedError.data.error.trim();
+        if (trimmed) {
+          message = trimmed;
+        }
+      }
+    }
+  }
+  if (!message && typeof jsonBody === "string" && jsonBody.trim() !== "") {
+    message = jsonBody.trim();
+  }
+  if (!message && textBody && textBody.trim() !== "") {
+    message = textBody.trim();
   }
   return {
-    commitSha: ack.commit.commit_sha,
-    treeSha: ack.commit.tree_sha,
-    targetBranch: ack.commit.target_branch,
-    packBytes: ack.commit.pack_bytes,
-    blobCount: ack.commit.blob_count,
+    statusMessage: message ?? fallbackMessage,
+    statusLabel,
     refUpdate
   };
 }
-function toRefUpdate(result) {
-  return {
-    branch: result.branch,
-    oldSha: result.old_sha,
-    newSha: result.new_sha
-  };
+function toPartialRefUpdateFields(branch, oldSha, newSha) {
+  const refUpdate = {};
+  if (typeof branch === "string" && branch.trim() !== "") {
+    refUpdate.branch = branch.trim();
+  }
+  if (typeof oldSha === "string" && oldSha.trim() !== "") {
+    refUpdate.oldSha = oldSha.trim();
+  }
+  if (typeof newSha === "string" && newSha.trim() !== "") {
+    refUpdate.newSha = newSha.trim();
+  }
+  return Object.keys(refUpdate).length > 0 ? refUpdate : void 0;
 }
+
+// src/stream-utils.ts
+var BufferCtor = globalThis.Buffer;
+var MAX_CHUNK_BYTES = 4 * 1024 * 1024;
 async function* chunkify(source) {
   let pending = null;
   let produced = false;
@@ -508,7 +332,56 @@ async function* toAsyncIterable(source) {
     }
     return;
   }
-  throw new Error("Unsupported file source for createCommit");
+  throw new Error("Unsupported content source; expected binary data");
+}
+function base64Encode(bytes) {
+  if (BufferCtor) {
+    return BufferCtor.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.byteLength; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  const btoaFn = globalThis.btoa;
+  if (typeof btoaFn === "function") {
+    return btoaFn(binary);
+  }
+  throw new Error("Base64 encoding is not supported in this environment");
+}
+function requiresDuplex(body) {
+  if (!body || typeof body !== "object") {
+    return false;
+  }
+  if (typeof body[Symbol.asyncIterator] === "function") {
+    return true;
+  }
+  const readableStreamCtor = globalThis.ReadableStream;
+  if (readableStreamCtor && body instanceof readableStreamCtor) {
+    return true;
+  }
+  return false;
+}
+function toRequestBody(iterable) {
+  const readableStreamCtor = globalThis.ReadableStream;
+  if (typeof readableStreamCtor === "function") {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return new readableStreamCtor({
+      async pull(controller) {
+        const { value, done } = await iterator.next();
+        if (done) {
+          controller.close();
+          return;
+        }
+        controller.enqueue(value);
+      },
+      async cancel(reason) {
+        if (typeof iterator.return === "function") {
+          await iterator.return(reason);
+        }
+      }
+    });
+  }
+  return iterable;
 }
 async function* readReadableStream(stream) {
   const reader = stream.getReader();
@@ -568,19 +441,225 @@ function concatChunks(a, b) {
   merged.set(b, a.byteLength);
   return merged;
 }
-function base64Encode(bytes) {
-  if (BufferCtor) {
-    return BufferCtor.from(bytes).toString("base64");
+
+// src/commit.ts
+var DEFAULT_TTL_SECONDS = 60 * 60;
+var HEADS_REF_PREFIX = "refs/heads/";
+var BufferCtor2 = globalThis.Buffer;
+var CommitBuilderImpl = class {
+  options;
+  getAuthToken;
+  transport;
+  operations = [];
+  sent = false;
+  constructor(deps) {
+    this.options = normalizeCommitOptions(deps.options);
+    this.getAuthToken = deps.getAuthToken;
+    this.transport = deps.transport;
+    const trimmedMessage = this.options.commitMessage?.trim();
+    const trimmedAuthorName = this.options.author?.name?.trim();
+    const trimmedAuthorEmail = this.options.author?.email?.trim();
+    if (!trimmedMessage) {
+      throw new Error("createCommit commitMessage is required");
+    }
+    if (!trimmedAuthorName || !trimmedAuthorEmail) {
+      throw new Error("createCommit author name and email are required");
+    }
+    this.options.commitMessage = trimmedMessage;
+    this.options.author = {
+      name: trimmedAuthorName,
+      email: trimmedAuthorEmail
+    };
+    if (typeof this.options.expectedHeadSha === "string") {
+      this.options.expectedHeadSha = this.options.expectedHeadSha.trim();
+    }
+    if (typeof this.options.baseBranch === "string") {
+      const trimmedBase = this.options.baseBranch.trim();
+      if (trimmedBase === "") {
+        delete this.options.baseBranch;
+      } else {
+        if (trimmedBase.startsWith("refs/")) {
+          throw new Error("createCommit baseBranch must not include refs/ prefix");
+        }
+        this.options.baseBranch = trimmedBase;
+      }
+    }
+    if (this.options.ephemeralBase && !this.options.baseBranch) {
+      throw new Error("createCommit ephemeralBase requires baseBranch");
+    }
   }
-  let binary = "";
-  for (let i = 0; i < bytes.byteLength; i++) {
-    binary += String.fromCharCode(bytes[i]);
+  addFile(path, source, options) {
+    this.ensureNotSent();
+    const normalizedPath = this.normalizePath(path);
+    const contentId = randomContentId();
+    const mode = options?.mode ?? "100644";
+    this.operations.push({
+      path: normalizedPath,
+      contentId,
+      mode,
+      operation: "upsert",
+      streamFactory: () => toAsyncIterable(source)
+    });
+    return this;
+  }
+  addFileFromString(path, contents, options) {
+    const encoding = options?.encoding ?? "utf8";
+    const normalizedEncoding = encoding === "utf-8" ? "utf8" : encoding;
+    let data;
+    if (normalizedEncoding === "utf8") {
+      data = new TextEncoder().encode(contents);
+    } else if (BufferCtor2) {
+      data = BufferCtor2.from(
+        contents,
+        normalizedEncoding
+      );
+    } else {
+      throw new Error(
+        `Unsupported encoding "${encoding}" in this environment. Non-UTF encodings require Node.js Buffer support.`
+      );
+    }
+    return this.addFile(path, data, options);
+  }
+  deletePath(path) {
+    this.ensureNotSent();
+    const normalizedPath = this.normalizePath(path);
+    this.operations.push({
+      path: normalizedPath,
+      contentId: randomContentId(),
+      operation: "delete"
+    });
+    return this;
+  }
+  async send() {
+    this.ensureNotSent();
+    this.sent = true;
+    const metadata = this.buildMetadata();
+    const blobEntries = this.operations.filter((op) => op.operation === "upsert" && op.streamFactory).map((op) => ({
+      contentId: op.contentId,
+      chunks: chunkify(op.streamFactory())
+    }));
+    const authorization = await this.getAuthToken();
+    const ack = await this.transport.send({
+      authorization,
+      signal: this.options.signal,
+      metadata,
+      blobs: blobEntries
+    });
+    return buildCommitResult(ack);
+  }
+  buildMetadata() {
+    const files = this.operations.map((op) => {
+      const entry = {
+        path: op.path,
+        content_id: op.contentId,
+        operation: op.operation
+      };
+      if (op.mode) {
+        entry.mode = op.mode;
+      }
+      return entry;
+    });
+    const metadata = {
+      target_branch: this.options.targetBranch,
+      commit_message: this.options.commitMessage,
+      author: {
+        name: this.options.author.name,
+        email: this.options.author.email
+      },
+      files
+    };
+    if (this.options.expectedHeadSha) {
+      metadata.expected_head_sha = this.options.expectedHeadSha;
+    }
+    if (this.options.baseBranch) {
+      metadata.base_branch = this.options.baseBranch;
+    }
+    if (this.options.committer) {
+      metadata.committer = {
+        name: this.options.committer.name,
+        email: this.options.committer.email
+      };
+    }
+    if (this.options.ephemeral) {
+      metadata.ephemeral = true;
+    }
+    if (this.options.ephemeralBase) {
+      metadata.ephemeral_base = true;
+    }
+    return metadata;
+  }
+  ensureNotSent() {
+    if (this.sent) {
+      throw new Error("createCommit builder cannot be reused after send()");
+    }
+  }
+  normalizePath(path) {
+    if (!path || typeof path !== "string" || path.trim() === "") {
+      throw new Error("File path must be a non-empty string");
+    }
+    return path.replace(/^\//, "");
+  }
+};
+var FetchCommitTransport = class {
+  url;
+  constructor(config) {
+    const trimmedBase = config.baseUrl.replace(/\/+$/, "");
+    this.url = `${trimmedBase}/api/v${config.version}/repos/commit-pack`;
   }
-  const btoaFn = globalThis.btoa;
-  if (typeof btoaFn === "function") {
-    return btoaFn(binary);
+  async send(request) {
+    const bodyIterable = buildMessageIterable(request.metadata, request.blobs);
+    const body = toRequestBody(bodyIterable);
+    const init = {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${request.authorization}`,
+        "Content-Type": "application/x-ndjson",
+        Accept: "application/json"
+      },
+      body,
+      signal: request.signal
+    };
+    if (requiresDuplex(body)) {
+      init.duplex = "half";
+    }
+    const response = await fetch(this.url, init);
+    if (!response.ok) {
+      const fallbackMessage = `createCommit request failed (${response.status} ${response.statusText})`;
+      const { statusMessage, statusLabel, refUpdate } = await parseCommitPackError(
+        response,
+        fallbackMessage
+      );
+      throw new RefUpdateError(statusMessage, {
+        status: statusLabel,
+        message: statusMessage,
+        refUpdate
+      });
+    }
+    const ack = commitPackAckSchema.parse(await response.json());
+    return ack;
   }
-  throw new Error("Base64 encoding is not supported in this environment");
+};
+function buildMessageIterable(metadata, blobs) {
+  const encoder = new TextEncoder();
+  return {
+    async *[Symbol.asyncIterator]() {
+      yield encoder.encode(`${JSON.stringify({ metadata })}
+`);
+      for (const blob of blobs) {
+        for await (const segment of blob.chunks) {
+          const payload = {
+            blob_chunk: {
+              content_id: blob.contentId,
+              data: base64Encode(segment.chunk),
+              eof: segment.eof
+            }
+          };
+          yield encoder.encode(`${JSON.stringify(payload)}
+`);
+        }
+      }
+    }
+  };
 }
 function randomContentId() {
   const cryptoObj = globalThis.crypto;
@@ -657,76 +736,208 @@ function resolveCommitTtlSeconds(options) {
   }
   return DEFAULT_TTL_SECONDS;
 }
-async function parseCommitPackError(response) {
-  const fallbackMessage = `createCommit request failed (${response.status} ${response.statusText})`;
-  const cloned = response.clone();
-  let jsonBody;
-  try {
-    jsonBody = await cloned.json();
-  } catch {
-    jsonBody = void 0;
-  }
-  let textBody;
-  if (jsonBody === void 0) {
-    try {
-      textBody = await response.text();
-    } catch {
-      textBody = void 0;
+
+// src/diff-commit.ts
+var DiffCommitExecutor = class {
+  options;
+  getAuthToken;
+  transport;
+  diffFactory;
+  sent = false;
+  constructor(deps) {
+    this.options = normalizeDiffCommitOptions(deps.options);
+    this.getAuthToken = deps.getAuthToken;
+    this.transport = deps.transport;
+    const trimmedMessage = this.options.commitMessage?.trim();
+    const trimmedAuthorName = this.options.author?.name?.trim();
+    const trimmedAuthorEmail = this.options.author?.email?.trim();
+    if (!trimmedMessage) {
+      throw new Error("createCommitFromDiff commitMessage is required");
     }
-  }
-  const defaultStatus = (() => {
-    const inferred = inferRefUpdateReason(String(response.status));
-    return inferred === "unknown" ? "failed" : inferred;
-  })();
-  let statusLabel = defaultStatus;
-  let refUpdate;
-  let message;
-  if (jsonBody !== void 0) {
-    const parsedResponse = commitPackResponseSchema.safeParse(jsonBody);
-    if (parsedResponse.success) {
-      const result = parsedResponse.data.result;
-      if (typeof result.status === "string" && result.status.trim() !== "") {
-        statusLabel = result.status.trim();
-      }
-      refUpdate = toPartialRefUpdateFields(result.branch, result.old_sha, result.new_sha);
-      if (typeof result.message === "string" && result.message.trim() !== "") {
-        message = result.message.trim();
-      }
+    if (!trimmedAuthorName || !trimmedAuthorEmail) {
+      throw new Error("createCommitFromDiff author name and email are required");
     }
-    if (!message) {
-      const parsedError = errorEnvelopeSchema.safeParse(jsonBody);
-      if (parsedError.success) {
-        const trimmed = parsedError.data.error.trim();
-        if (trimmed) {
-          message = trimmed;
+    this.options.commitMessage = trimmedMessage;
+    this.options.author = {
+      name: trimmedAuthorName,
+      email: trimmedAuthorEmail
+    };
+    if (typeof this.options.expectedHeadSha === "string") {
+      this.options.expectedHeadSha = this.options.expectedHeadSha.trim();
+    }
+    if (typeof this.options.baseBranch === "string") {
+      const trimmedBase = this.options.baseBranch.trim();
+      if (trimmedBase === "") {
+        delete this.options.baseBranch;
+      } else {
+        if (trimmedBase.startsWith("refs/")) {
+          throw new Error("createCommitFromDiff baseBranch must not include refs/ prefix");
         }
+        this.options.baseBranch = trimmedBase;
       }
     }
+    if (this.options.ephemeralBase && !this.options.baseBranch) {
+      throw new Error("createCommitFromDiff ephemeralBase requires baseBranch");
+    }
+    this.diffFactory = () => toAsyncIterable(this.options.initialDiff);
   }
-  if (!message && typeof jsonBody === "string" && jsonBody.trim() !== "") {
-    message = jsonBody.trim();
+  async send() {
+    this.ensureNotSent();
+    this.sent = true;
+    const metadata = this.buildMetadata();
+    const diffIterable = chunkify(this.diffFactory());
+    const authorization = await this.getAuthToken();
+    const ack = await this.transport.send({
+      authorization,
+      signal: this.options.signal,
+      metadata,
+      diffChunks: diffIterable
+    });
+    return buildCommitResult(ack);
   }
-  if (!message && textBody && textBody.trim() !== "") {
-    message = textBody.trim();
+  buildMetadata() {
+    const metadata = {
+      target_branch: this.options.targetBranch,
+      commit_message: this.options.commitMessage,
+      author: {
+        name: this.options.author.name,
+        email: this.options.author.email
+      }
+    };
+    if (this.options.expectedHeadSha) {
+      metadata.expected_head_sha = this.options.expectedHeadSha;
+    }
+    if (this.options.baseBranch) {
+      metadata.base_branch = this.options.baseBranch;
+    }
+    if (this.options.committer) {
+      metadata.committer = {
+        name: this.options.committer.name,
+        email: this.options.committer.email
+      };
+    }
+    if (this.options.ephemeral) {
+      metadata.ephemeral = true;
+    }
+    if (this.options.ephemeralBase) {
+      metadata.ephemeral_base = true;
+    }
+    return metadata;
+  }
+  ensureNotSent() {
+    if (this.sent) {
+      throw new Error("createCommitFromDiff cannot be reused after send()");
+    }
+  }
+};
+var FetchDiffCommitTransport = class {
+  url;
+  constructor(config) {
+    const trimmedBase = config.baseUrl.replace(/\/+$/, "");
+    this.url = `${trimmedBase}/api/v${config.version}/repos/diff-commit`;
+  }
+  async send(request) {
+    const bodyIterable = buildMessageIterable2(request.metadata, request.diffChunks);
+    const body = toRequestBody(bodyIterable);
+    const init = {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${request.authorization}`,
+        "Content-Type": "application/x-ndjson",
+        Accept: "application/json"
+      },
+      body,
+      signal: request.signal
+    };
+    if (requiresDuplex(body)) {
+      init.duplex = "half";
+    }
+    const response = await fetch(this.url, init);
+    if (!response.ok) {
+      const fallbackMessage = `createCommitFromDiff request failed (${response.status} ${response.statusText})`;
+      const { statusMessage, statusLabel, refUpdate } = await parseCommitPackError(
+        response,
+        fallbackMessage
+      );
+      throw new RefUpdateError(statusMessage, {
+        status: statusLabel,
+        message: statusMessage,
+        refUpdate
+      });
+    }
+    return commitPackAckSchema.parse(await response.json());
   }
+};
+function buildMessageIterable2(metadata, diffChunks) {
+  const encoder = new TextEncoder();
   return {
-    statusMessage: message ?? fallbackMessage,
-    statusLabel,
-    refUpdate
+    async *[Symbol.asyncIterator]() {
+      yield encoder.encode(`${JSON.stringify({ metadata })}
+`);
+      for await (const segment of diffChunks) {
+        const payload = {
+          diff_chunk: {
+            data: base64Encode(segment.chunk),
+            eof: segment.eof
+          }
+        };
+        yield encoder.encode(`${JSON.stringify(payload)}
+`);
+      }
+    }
   };
 }
-function toPartialRefUpdateFields(branch, oldSha, newSha) {
-  const refUpdate = {};
-  if (typeof branch === "string" && branch.trim() !== "") {
-    refUpdate.branch = branch.trim();
+function normalizeDiffCommitOptions(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("createCommitFromDiff options are required");
+  }
+  if (options.diff === void 0 || options.diff === null) {
+    throw new Error("createCommitFromDiff diff is required");
+  }
+  const targetBranch = normalizeBranchName2(options.targetBranch);
+  let committer;
+  if (options.committer) {
+    const name = options.committer.name?.trim();
+    const email = options.committer.email?.trim();
+    if (!name || !email) {
+      throw new Error("createCommitFromDiff committer name and email are required when provided");
+    }
+    committer = { name, email };
   }
-  if (typeof oldSha === "string" && oldSha.trim() !== "") {
-    refUpdate.oldSha = oldSha.trim();
+  return {
+    targetBranch,
+    commitMessage: options.commitMessage,
+    expectedHeadSha: options.expectedHeadSha,
+    baseBranch: options.baseBranch,
+    ephemeral: options.ephemeral === true,
+    ephemeralBase: options.ephemeralBase === true,
+    author: options.author,
+    committer,
+    signal: options.signal,
+    ttl: options.ttl,
+    initialDiff: options.diff
+  };
+}
+function normalizeBranchName2(value) {
+  const trimmed = value?.trim();
+  if (!trimmed) {
+    throw new Error("createCommitFromDiff targetBranch is required");
   }
-  if (typeof newSha === "string" && newSha.trim() !== "") {
-    refUpdate.newSha = newSha.trim();
+  if (trimmed.startsWith("refs/heads/")) {
+    const branch = trimmed.slice("refs/heads/".length).trim();
+    if (!branch) {
+      throw new Error("createCommitFromDiff targetBranch must include a branch name");
+    }
+    return branch;
   }
-  return Object.keys(refUpdate).length > 0 ? refUpdate : void 0;
+  if (trimmed.startsWith("refs/")) {
+    throw new Error("createCommitFromDiff targetBranch must not include refs/ prefix");
+  }
+  return trimmed;
+}
+async function sendCommitFromDiff(deps) {
+  const executor = new DiffCommitExecutor(deps);
+  return executor.send();
 }
 
 // src/fetch.ts
@@ -1519,6 +1730,25 @@ var RepoImpl = class {
       transport
     });
   }
+  async createCommitFromDiff(options) {
+    const version = this.options.apiVersion ?? API_VERSION;
+    const baseUrl = this.options.apiBaseUrl ?? API_BASE_URL;
+    const transport = new FetchDiffCommitTransport({ baseUrl, version });
+    const ttl = resolveCommitTtlSeconds(options);
+    const requestOptions = {
+      ...options,
+      ttl
+    };
+    const getAuthToken = () => this.generateJWT(this.id, {
+      permissions: ["git:write"],
+      ttl
+    });
+    return sendCommitFromDiff({
+      options: requestOptions,
+      getAuthToken,
+      transport
+    });
+  }
 };
 var GitStorage = class _GitStorage {
   static overrides = {};