@pierre/storage 0.2.0 → 0.2.2

package/dist/index.js

@@ -104,6 +104,12 @@ var commitDiffResponseSchema = z.object({
   files: z.array(diffFileRawSchema),
   filtered_files: z.array(filteredFileRawSchema)
 });
+var createBranchResponseSchema = z.object({
+  message: z.string(),
+  target_branch: z.string(),
+  target_is_ephemeral: z.boolean(),
+  commit_sha: z.string().nullable().optional()
+});
 var refUpdateResultSchema = z.object({
   branch: z.string(),
   old_sha: z.string(),
@@ -148,11 +154,298 @@ var errorEnvelopeSchema = z.object({
   error: z.string()
 });
 
+// src/commit-pack.ts
+function buildCommitResult(ack) {
+  const refUpdate = toRefUpdate(ack.result);
+  if (!ack.result.success) {
+    throw new RefUpdateError(
+      ack.result.message ?? `Commit failed with status ${ack.result.status}`,
+      {
+        status: ack.result.status,
+        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 {
+    statusMessage: message ?? fallbackMessage,
+    statusLabel,
+    refUpdate
+  };
+}
+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;
+  for await (const value of source) {
+    const bytes = value;
+    if (pending && pending.byteLength === MAX_CHUNK_BYTES) {
+      yield { chunk: pending, eof: false };
+      produced = true;
+      pending = null;
+    }
+    const merged = pending ? concatChunks(pending, bytes) : bytes;
+    pending = null;
+    let cursor = merged;
+    while (cursor.byteLength > MAX_CHUNK_BYTES) {
+      const chunk = cursor.slice(0, MAX_CHUNK_BYTES);
+      cursor = cursor.slice(MAX_CHUNK_BYTES);
+      yield { chunk, eof: false };
+      produced = true;
+    }
+    pending = cursor;
+  }
+  if (pending) {
+    yield { chunk: pending, eof: true };
+    produced = true;
+  }
+  if (!produced) {
+    yield { chunk: new Uint8Array(0), eof: true };
+  }
+}
+async function* toAsyncIterable(source) {
+  if (typeof source === "string") {
+    yield new TextEncoder().encode(source);
+    return;
+  }
+  if (source instanceof Uint8Array) {
+    yield source;
+    return;
+  }
+  if (source instanceof ArrayBuffer) {
+    yield new Uint8Array(source);
+    return;
+  }
+  if (ArrayBuffer.isView(source)) {
+    yield new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    return;
+  }
+  if (isBlobLike(source)) {
+    const stream = source.stream();
+    if (isAsyncIterable(stream)) {
+      for await (const chunk of stream) {
+        yield ensureUint8Array(chunk);
+      }
+      return;
+    }
+    if (isReadableStreamLike(stream)) {
+      yield* readReadableStream(stream);
+      return;
+    }
+  }
+  if (isReadableStreamLike(source)) {
+    yield* readReadableStream(source);
+    return;
+  }
+  if (isAsyncIterable(source)) {
+    for await (const chunk of source) {
+      yield ensureUint8Array(chunk);
+    }
+    return;
+  }
+  if (isIterable(source)) {
+    for (const chunk of source) {
+      yield ensureUint8Array(chunk);
+    }
+    return;
+  }
+  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();
+  try {
+    while (true) {
+      const { value, done } = await reader.read();
+      if (done) {
+        break;
+      }
+      if (value !== void 0) {
+        yield ensureUint8Array(value);
+      }
+    }
+  } finally {
+    reader.releaseLock?.();
+  }
+}
+function ensureUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (typeof value === "string") {
+    return new TextEncoder().encode(value);
+  }
+  if (BufferCtor && BufferCtor.isBuffer(value)) {
+    return value;
+  }
+  throw new Error("Unsupported chunk type; expected binary data");
+}
+function isBlobLike(value) {
+  return typeof value === "object" && value !== null && typeof value.stream === "function";
+}
+function isReadableStreamLike(value) {
+  return typeof value === "object" && value !== null && typeof value.getReader === "function";
+}
+function isAsyncIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
+}
+function isIterable(value) {
+  return typeof value === "object" && value !== null && Symbol.iterator in value;
+}
+function concatChunks(a, b) {
+  if (a.byteLength === 0) {
+    return b;
+  }
+  if (b.byteLength === 0) {
+    return a;
+  }
+  const merged = new Uint8Array(a.byteLength + b.byteLength);
+  merged.set(a, 0);
+  merged.set(b, a.byteLength);
+  return merged;
+}
+
 // 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 BufferCtor2 = globalThis.Buffer;
 var CommitBuilderImpl = class {
   options;
   getAuthToken;
@@ -215,8 +508,8 @@ var CommitBuilderImpl = class {
     let data;
     if (normalizedEncoding === "utf8") {
       data = new TextEncoder().encode(contents);
-    } else if (BufferCtor) {
-      data = BufferCtor.from(
+    } else if (BufferCtor2) {
+      data = BufferCtor2.from(
         contents,
         normalizedEncoding
       );
@@ -324,257 +617,49 @@ var FetchCommitTransport = class {
         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;
-}
-function buildCommitResult(ack) {
-  const refUpdate = toRefUpdate(ack.result);
-  if (!ack.result.success) {
-    throw new RefUpdateError(
-      ack.result.message ?? `Commit failed with status ${ack.result.status}`,
-      {
-        status: ack.result.status,
-        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* chunkify(source) {
-  let pending = null;
-  let produced = false;
-  for await (const value of source) {
-    const bytes = value;
-    if (pending && pending.byteLength === MAX_CHUNK_BYTES) {
-      yield { chunk: pending, eof: false };
-      produced = true;
-      pending = null;
-    }
-    const merged = pending ? concatChunks(pending, bytes) : bytes;
-    pending = null;
-    let cursor = merged;
-    while (cursor.byteLength > MAX_CHUNK_BYTES) {
-      const chunk = cursor.slice(0, MAX_CHUNK_BYTES);
-      cursor = cursor.slice(MAX_CHUNK_BYTES);
-      yield { chunk, eof: false };
-      produced = true;
-    }
-    pending = cursor;
-  }
-  if (pending) {
-    yield { chunk: pending, eof: true };
-    produced = true;
-  }
-  if (!produced) {
-    yield { chunk: new Uint8Array(0), eof: true };
-  }
-}
-async function* toAsyncIterable(source) {
-  if (typeof source === "string") {
-    yield new TextEncoder().encode(source);
-    return;
-  }
-  if (source instanceof Uint8Array) {
-    yield source;
-    return;
-  }
-  if (source instanceof ArrayBuffer) {
-    yield new Uint8Array(source);
-    return;
-  }
-  if (ArrayBuffer.isView(source)) {
-    yield new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    return;
-  }
-  if (isBlobLike(source)) {
-    const stream = source.stream();
-    if (isAsyncIterable(stream)) {
-      for await (const chunk of stream) {
-        yield ensureUint8Array(chunk);
-      }
-      return;
-    }
-    if (isReadableStreamLike(stream)) {
-      yield* readReadableStream(stream);
-      return;
-    }
-  }
-  if (isReadableStreamLike(source)) {
-    yield* readReadableStream(source);
-    return;
-  }
-  if (isAsyncIterable(source)) {
-    for await (const chunk of source) {
-      yield ensureUint8Array(chunk);
-    }
-    return;
-  }
-  if (isIterable(source)) {
-    for (const chunk of source) {
-      yield ensureUint8Array(chunk);
-    }
-    return;
-  }
-  throw new Error("Unsupported file source for createCommit");
-}
-async function* readReadableStream(stream) {
-  const reader = stream.getReader();
-  try {
-    while (true) {
-      const { value, done } = await reader.read();
-      if (done) {
-        break;
-      }
-      if (value !== void 0) {
-        yield ensureUint8Array(value);
-      }
-    }
-  } finally {
-    reader.releaseLock?.();
-  }
-}
-function ensureUint8Array(value) {
-  if (value instanceof Uint8Array) {
-    return value;
-  }
-  if (value instanceof ArrayBuffer) {
-    return new Uint8Array(value);
-  }
-  if (ArrayBuffer.isView(value)) {
-    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-  }
-  if (typeof value === "string") {
-    return new TextEncoder().encode(value);
-  }
-  if (BufferCtor && BufferCtor.isBuffer(value)) {
-    return value;
-  }
-  throw new Error("Unsupported chunk type; expected binary data");
-}
-function isBlobLike(value) {
-  return typeof value === "object" && value !== null && typeof value.stream === "function";
-}
-function isReadableStreamLike(value) {
-  return typeof value === "object" && value !== null && typeof value.getReader === "function";
-}
-function isAsyncIterable(value) {
-  return typeof value === "object" && value !== null && Symbol.asyncIterator in value;
-}
-function isIterable(value) {
-  return typeof value === "object" && value !== null && Symbol.iterator in value;
-}
-function concatChunks(a, b) {
-  if (a.byteLength === 0) {
-    return b;
-  }
-  if (b.byteLength === 0) {
-    return a;
-  }
-  const merged = new Uint8Array(a.byteLength + b.byteLength);
-  merged.set(a, 0);
-  merged.set(b, a.byteLength);
-  return merged;
-}
-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);
+      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;
@@ -651,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
@@ -1274,6 +1491,14 @@ function transformCommitDiffResult(raw) {
     filteredFiles: raw.filtered_files.map(transformFilteredFile)
   };
 }
+function transformCreateBranchResult(raw) {
+  return {
+    message: raw.message,
+    targetBranch: raw.target_branch,
+    targetIsEphemeral: raw.target_is_ephemeral,
+    commitSha: raw.commit_sha ?? void 0
+  };
+}
 var RepoImpl = class {
   constructor(id, options, generateJWT) {
     this.id = id;
@@ -1409,7 +1634,7 @@ var RepoImpl = class {
     const raw = commitDiffResponseSchema.parse(await response.json());
     return transformCommitDiffResult(raw);
   }
-  async pullUpstream(options) {
+  async pullUpstream(options = {}) {
     const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
     const jwt = await this.generateJWT(this.id, {
       permissions: ["git:write"],
@@ -1425,6 +1650,34 @@ var RepoImpl = class {
     }
     return;
   }
+  async createBranch(options) {
+    const baseBranch = options?.baseBranch?.trim();
+    if (!baseBranch) {
+      throw new Error("createBranch baseBranch is required");
+    }
+    const targetBranch = options?.targetBranch?.trim();
+    if (!targetBranch) {
+      throw new Error("createBranch targetBranch is required");
+    }
+    const ttl = resolveInvocationTtlSeconds(options, DEFAULT_TOKEN_TTL_SECONDS);
+    const jwt = await this.generateJWT(this.id, {
+      permissions: ["git:write"],
+      ttl
+    });
+    const body = {
+      base_branch: baseBranch,
+      target_branch: targetBranch
+    };
+    if (options.baseIsEphemeral === true) {
+      body.base_is_ephemeral = true;
+    }
+    if (options.targetIsEphemeral === true) {
+      body.target_is_ephemeral = true;
+    }
+    const response = await this.api.post({ path: "repos/branches/create", body }, jwt);
+    const raw = createBranchResponseSchema.parse(await response.json());
+    return transformCreateBranchResult(raw);
+  }
   async restoreCommit(options) {
     const targetBranch = options?.targetBranch?.trim();
     if (!targetBranch) {
@@ -1513,6 +1766,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 = {};