@bryanhu/codexly 0.3.0 → 0.5.0

package/dist/{chunk-Y7HG5THF.js → chunk-4PA52XB7.js}

@@ -1,14 +1,14 @@
 import { createRequire } from 'node:module';
-import { PendingRequestResolutionError } from './chunk-3OBVX5TN.js';
-import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_TEXT_BYTES } from './chunk-DR6HEQ7V.js';
+import { WorkbenchPetProviderError, PendingRequestResolutionError } from './chunk-RNTA4MFS.js';
+import { TEMPORARY_TASK_SCOPE_ID, MAX_AGENT_HISTORY_IMAGE_TOTAL_BYTES, isAgentFastModeAvailable, MAX_REALTIME_FILE_CHANGES, MAX_REALTIME_DIFF_BYTES, stripLeadingAgentSkillReferences, MAX_AGENT_HISTORY_IMAGES, MAX_AGENT_TEXT_BYTES } from './chunk-ZSWNUDDK.js';
 import { __commonJS, __require, __toESM } from './chunk-K6J42667.js';
 import { execFile, spawn } from 'child_process';
 import { constants, mkdtempSync, rmSync, createReadStream, mkdirSync, unlinkSync, renameSync, writeFileSync, openSync, readSync, closeSync, statSync } from 'fs';
-import { access, readdir, lstat, readFile, realpath, opendir, stat } from 'fs/promises';
+import { readFile, mkdir, writeFile, rename, rm, readdir, realpath, stat, access, lstat, opendir } from 'fs/promises';
 import { createRequire as createRequire$1 } from 'module';
-import { resolve, basename, dirname, win32, posix, join, isAbsolute, relative, extname } from 'path';
+import { resolve, basename, dirname, join, relative, sep, win32, posix, isAbsolute, extname } from 'path';
 import { promisify } from 'util';
-import { createHash, randomUUID } from 'crypto';
+import { randomUUID, createHash } from 'crypto';
 import { Buffer as Buffer$1 } from 'buffer';
 import { tmpdir, homedir } from 'os';
 import { StringDecoder } from 'string_decoder';
@@ -1250,7 +1250,7 @@ var require_sonic_boom = __commonJS({
       if (!(this instanceof SonicBoom)) {
         return new SonicBoom(opts);
       }
-      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {};
+      let { fd, dest, minLength, maxLength, maxWrite, periodicFlush, sync, append = true, mkdir: mkdir2, retryEAGAIN, fsync, contentMode, mode } = opts || {};
       fd = fd || dest;
       this._len = 0;
       this.fd = -1;
@@ -1275,7 +1275,7 @@ var require_sonic_boom = __commonJS({
       this.append = append || false;
       this.mode = mode;
       this.retryEAGAIN = retryEAGAIN || (() => true);
-      this.mkdir = mkdir || false;
+      this.mkdir = mkdir2 || false;
       let fsWriteSync;
       let fsWrite;
       if (contentMode === kContentModeBuffer) {
@@ -1983,7 +1983,7 @@ var require_thread_stream = __commonJS({
     var { version } = require_package();
     var { EventEmitter } = __require("events");
     var { Worker: Worker2 } = __require("worker_threads");
-    var { join: join5 } = __require("path");
+    var { join: join6 } = __require("path");
     var { pathToFileURL } = __require("url");
     var { wait } = require_wait();
     var {
@@ -2034,7 +2034,7 @@ var require_thread_stream = __commonJS({
     function createWorker(stream, opts) {
       const { filename, workerData } = opts;
       const bundlerOverrides = "__bundlerPathsOverrides" in globalThis ? globalThis.__bundlerPathsOverrides : {};
-      const toExecute = bundlerOverrides["thread-stream-worker"] || join5(__dirname, "lib", "worker.js");
+      const toExecute = bundlerOverrides["thread-stream-worker"] || join6(__dirname, "lib", "worker.js");
       const worker = new Worker2(toExecute, {
         ...opts.workerOpts,
         name: opts.workerOpts?.name || "thread-stream",
@@ -2501,7 +2501,7 @@ var require_transport = __commonJS({
     var { createRequire: createRequire2 } = __require("module");
     var { existsSync } = __require("fs");
     var getCallers = require_caller();
-    var { join: join5, isAbsolute: isAbsolute6, sep } = __require("path");
+    var { join: join6, isAbsolute: isAbsolute7, sep: sep3 } = __require("path");
     var { fileURLToPath } = __require("url");
     var sleep = require_atomic_sleep();
     var onExit = require_on_exit_leak_free();
@@ -2573,7 +2573,7 @@ var require_transport = __commonJS({
           return false;
         }
       }
-      return isAbsolute6(path) && !existsSync(path);
+      return isAbsolute7(path) && !existsSync(path);
     }
     function stripQuotes(value) {
       const first = value[0];
@@ -2654,7 +2654,7 @@ var require_transport = __commonJS({
         throw new Error("only one of target or targets can be specified");
       }
       if (targets) {
-        target = bundlerOverrides["pino-worker"] || join5(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join6(__dirname, "worker.js");
         options.targets = targets.filter((dest) => dest.target).map((dest) => {
           return {
             ...dest,
@@ -2672,7 +2672,7 @@ var require_transport = __commonJS({
           });
         });
       } else if (pipeline) {
-        target = bundlerOverrides["pino-worker"] || join5(__dirname, "worker.js");
+        target = bundlerOverrides["pino-worker"] || join6(__dirname, "worker.js");
         options.pipelines = [pipeline.map((dest) => {
           return {
             ...dest,
@@ -2691,16 +2691,16 @@ var require_transport = __commonJS({
       return buildStream(fixTarget(target), options, worker, sync, name);
       function fixTarget(origin) {
         origin = bundlerOverrides[origin] || origin;
-        if (isAbsolute6(origin) || origin.indexOf("file://") === 0) {
+        if (isAbsolute7(origin) || origin.indexOf("file://") === 0) {
           return origin;
         }
         if (origin === "pino/file") {
-          return join5(__dirname, "..", "file.js");
+          return join6(__dirname, "..", "file.js");
         }
         let fixTarget2;
         for (const filePath of callers) {
           try {
-            const context = filePath === "node:repl" ? process.cwd() + sep : filePath;
+            const context = filePath === "node:repl" ? process.cwd() + sep3 : filePath;
             fixTarget2 = createRequire2(context).resolve(origin);
             break;
           } catch (err) {
@@ -3670,7 +3670,7 @@ var require_safe_stable_stringify = __commonJS({
               return circularValue;
             }
             let res = "";
-            let join5 = ",";
+            let join6 = ",";
             const originalIndentation = indentation;
             if (Array.isArray(value)) {
               if (value.length === 0) {
@@ -3684,7 +3684,7 @@ var require_safe_stable_stringify = __commonJS({
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join5 = `,
+                join6 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3692,13 +3692,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join5;
+                res += join6;
               }
               const tmp = stringifyFnReplacer(String(i), value, stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join5}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join6}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3719,7 +3719,7 @@ ${originalIndentation}`;
             let separator = "";
             if (spacer !== "") {
               indentation += spacer;
-              join5 = `,
+              join6 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3733,13 +3733,13 @@ ${indentation}`;
               const tmp = stringifyFnReplacer(key2, value, stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join5;
+                separator = join6;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...":${whitespace}"${getItemCount(removedKeys)} not stringified"`;
-              separator = join5;
+              separator = join6;
             }
             if (spacer !== "" && separator.length > 1) {
               res = `
@@ -3780,7 +3780,7 @@ ${originalIndentation}`;
             }
             const originalIndentation = indentation;
             let res = "";
-            let join5 = ",";
+            let join6 = ",";
             if (Array.isArray(value)) {
               if (value.length === 0) {
                 return "[]";
@@ -3793,7 +3793,7 @@ ${originalIndentation}`;
                 indentation += spacer;
                 res += `
 ${indentation}`;
-                join5 = `,
+                join6 = `,
 ${indentation}`;
               }
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
@@ -3801,13 +3801,13 @@ ${indentation}`;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
                 res += tmp2 !== void 0 ? tmp2 : "null";
-                res += join5;
+                res += join6;
               }
               const tmp = stringifyArrayReplacer(String(i), value[i], stack, replacer, spacer, indentation);
               res += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res += `${join5}"... ${getItemCount(removedKeys)} not stringified"`;
+                res += `${join6}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               if (spacer !== "") {
                 res += `
@@ -3820,7 +3820,7 @@ ${originalIndentation}`;
             let whitespace = "";
             if (spacer !== "") {
               indentation += spacer;
-              join5 = `,
+              join6 = `,
 ${indentation}`;
               whitespace = " ";
             }
@@ -3829,7 +3829,7 @@ ${indentation}`;
               const tmp = stringifyArrayReplacer(key2, value[key2], stack, replacer, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}:${whitespace}${tmp}`;
-                separator = join5;
+                separator = join6;
               }
             }
             if (spacer !== "" && separator.length > 1) {
@@ -3887,20 +3887,20 @@ ${originalIndentation}`;
               indentation += spacer;
               let res2 = `
 ${indentation}`;
-              const join6 = `,
+              const join7 = `,
 ${indentation}`;
               const maximumValuesToStringify = Math.min(value.length, maximumBreadth);
               let i = 0;
               for (; i < maximumValuesToStringify - 1; i++) {
                 const tmp2 = stringifyIndent(String(i), value[i], stack, spacer, indentation);
                 res2 += tmp2 !== void 0 ? tmp2 : "null";
-                res2 += join6;
+                res2 += join7;
               }
               const tmp = stringifyIndent(String(i), value[i], stack, spacer, indentation);
               res2 += tmp !== void 0 ? tmp : "null";
               if (value.length - 1 > maximumBreadth) {
                 const removedKeys = value.length - maximumBreadth - 1;
-                res2 += `${join6}"... ${getItemCount(removedKeys)} not stringified"`;
+                res2 += `${join7}"... ${getItemCount(removedKeys)} not stringified"`;
               }
               res2 += `
 ${originalIndentation}`;
@@ -3916,16 +3916,16 @@ ${originalIndentation}`;
               return '"[Object]"';
             }
             indentation += spacer;
-            const join5 = `,
+            const join6 = `,
 ${indentation}`;
             let res = "";
             let separator = "";
             let maximumPropertiesToStringify = Math.min(keyLength, maximumBreadth);
             if (isTypedArrayWithEntries(value)) {
-              res += stringifyTypedArray(value, join5, maximumBreadth);
+              res += stringifyTypedArray(value, join6, maximumBreadth);
               keys = keys.slice(value.length);
               maximumPropertiesToStringify -= value.length;
-              separator = join5;
+              separator = join6;
             }
             if (deterministic) {
               keys = sort(keys, comparator);
@@ -3936,13 +3936,13 @@ ${indentation}`;
               const tmp = stringifyIndent(key2, value[key2], stack, spacer, indentation);
               if (tmp !== void 0) {
                 res += `${separator}${strEscape(key2)}: ${tmp}`;
-                separator = join5;
+                separator = join6;
               }
             }
             if (keyLength > maximumBreadth) {
               const removedKeys = keyLength - maximumBreadth;
               res += `${separator}"...": "${getItemCount(removedKeys)} not stringified"`;
-              separator = join5;
+              separator = join6;
             }
             if (separator !== "") {
               res = `
@@ -5434,38 +5434,73 @@ function mapFileChangeKind(value) {
   }
   throw new CodexProtocolMappingError("Codex file change kind is invalid");
 }
-function sliceUtf8Tail(value, maxBytes) {
+function countNewlines(value) {
+  let count = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    if (value.charCodeAt(index) === 10) count += 1;
+  }
+  return count;
+}
+function retainHeadTailLines(value, totalNewlines) {
+  const totalLines = value.length === 0 ? 0 : totalNewlines + 1;
+  if (totalLines <= MAX_COMMAND_OUTPUT_LINES) return value;
+  const headLines = Math.ceil(MAX_COMMAND_OUTPUT_LINES / 2);
+  const tailLines = MAX_COMMAND_OUTPUT_LINES - headLines;
+  let prefixEnd = 0;
+  let seenHeadNewlines = 0;
+  for (; prefixEnd < value.length; prefixEnd += 1) {
+    if (value.charCodeAt(prefixEnd) !== 10) continue;
+    seenHeadNewlines += 1;
+    if (seenHeadNewlines === headLines) break;
+  }
+  let suffixStart = value.length;
+  let seenTailNewlines = 0;
+  for (; suffixStart > 0; suffixStart -= 1) {
+    if (value.charCodeAt(suffixStart - 1) !== 10) continue;
+    seenTailNewlines += 1;
+    if (seenTailNewlines === tailLines) break;
+  }
+  return `${value.slice(0, prefixEnd)}
+${value.slice(suffixStart)}`;
+}
+function trimTrailingPartialUtf8(value) {
+  let index = value.length - 1;
+  while (index >= 0 && ((value[index] ?? 0) & 192) === 128 && value.length - index <= 3) {
+    index -= 1;
+  }
+  if (index < 0) return value;
+  const lead = value[index] ?? 0;
+  const expected = lead < 128 ? 1 : lead < 224 ? 2 : lead < 240 ? 3 : lead < 248 ? 4 : 0;
+  return expected > 0 && value.length - index < expected ? value.subarray(0, index) : value;
+}
+function trimLeadingContinuationUtf8(value) {
+  let index = 0;
+  while (index < value.length && ((value[index] ?? 0) & 192) === 128) index += 1;
+  return value.subarray(index);
+}
+function retainHeadTailBytes(value) {
   const encoded = Buffer$1.from(value, "utf8");
-  let start = Math.max(0, encoded.length - maxBytes);
-  while (start < encoded.length) {
-    const byte = encoded[start];
-    if (byte === void 0 || (byte & 192) !== 128) {
-      break;
-    }
-    start += 1;
-  }
-  return encoded.subarray(start).toString("utf8");
+  if (encoded.length <= MAX_COMMAND_OUTPUT_BYTES) return value;
+  const headBytes = Math.ceil(MAX_COMMAND_OUTPUT_BYTES / 2);
+  const tailBytes = MAX_COMMAND_OUTPUT_BYTES - headBytes;
+  const head = trimTrailingPartialUtf8(encoded.subarray(0, headBytes)).toString("utf8");
+  const tail = trimLeadingContinuationUtf8(encoded.subarray(encoded.length - tailBytes)).toString(
+    "utf8"
+  );
+  return `${head}${tail}`;
 }
 function boundCommandOutput(value) {
-  let output = value;
-  let outputTruncated = false;
-  let newlineCount = 0;
-  for (let index = output.length - 1; index >= 0; index -= 1) {
-    if (output.charCodeAt(index) !== 10) {
-      continue;
-    }
-    newlineCount += 1;
-    if (newlineCount === MAX_COMMAND_OUTPUT_LINES) {
-      output = output.slice(index + 1);
-      outputTruncated = true;
-      break;
+  const originalBytes = Buffer$1.byteLength(value, "utf8");
+  const originalLines = countNewlines(value);
+  const lineBounded = retainHeadTailLines(value, originalLines);
+  const output = retainHeadTailBytes(lineBounded);
+  return {
+    output,
+    outputOmitted: {
+      bytes: originalBytes - Buffer$1.byteLength(output, "utf8"),
+      lines: originalLines - countNewlines(output)
     }
-  }
-  if (Buffer$1.byteLength(output, "utf8") > MAX_COMMAND_OUTPUT_BYTES) {
-    output = sliceUtf8Tail(output, MAX_COMMAND_OUTPUT_BYTES);
-    outputTruncated = true;
-  }
-  return { output, outputTruncated };
+  };
 }
 function mapToolError(value) {
   if (value === null || value === void 0) {
@@ -6304,7 +6339,7 @@ function mapAgentItem(value, subagentNicknames = /* @__PURE__ */ new Map(), mapI
         ...exitCode === void 0 ? {} : { exitCode },
         id,
         ...output === void 0 ? {} : { output: output.output },
-        outputTruncated: output?.outputTruncated ?? false,
+        outputOmitted: output?.outputOmitted ?? { bytes: 0, lines: 0 },
         status: mapItemStatus(item["status"]),
         type: "command"
       };
@@ -7070,8 +7105,8 @@ var JsonlFrameProcessor = class {
     const id = this.#nextRequestId++;
     const transferable = Uint8Array.from(frame);
     const transferredBuffer = transferable.buffer;
-    return new Promise((resolve5, reject) => {
-      this.#pending.set(id, { reject, resolve: resolve5 });
+    return new Promise((resolve7, reject) => {
+      this.#pending.set(id, { reject, resolve: resolve7 });
       this.#worker.postMessage({ frame: transferredBuffer, id }, [transferredBuffer]);
     });
   }
@@ -7181,7 +7216,7 @@ function parseRpcError(value) {
 function writeRpcMessage(output, message, timeoutMs) {
   const frame = `${JSON.stringify(message)}
 `;
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve7, reject) => {
     const timer = setTimeout(() => {
       reject(new RpcConnectionClosedError(`RPC write timed out after ${String(timeoutMs)}ms`));
     }, timeoutMs);
@@ -7192,7 +7227,7 @@ function writeRpcMessage(output, message, timeoutMs) {
         reject(new RpcConnectionClosedError(`RPC write failed: ${error.message}`));
         return;
       }
-      resolve5();
+      resolve7();
     });
   });
 }
@@ -7366,7 +7401,7 @@ var JsonlRpcClient = class {
     }
     const id = this.#nextRequestId++;
     const request = params === void 0 ? { id, method } : { id, method, params };
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       const pending = new RpcPendingRequest({
         onTimeout: () => {
           if (this.#removePending(id, pending)) {
@@ -7375,7 +7410,7 @@ var JsonlRpcClient = class {
         },
         reject,
         request,
-        resolve: resolve5,
+        resolve: resolve7,
         timeoutMs
       });
       this.#pending.set(id, pending);
@@ -9427,6 +9462,7 @@ var CodexAgentProviderQueue = class extends CodexAgentProviderBase {
       ),
       id: expectString(queued["id"], "thread queue submission id"),
       skills,
+      status: "queued",
       text: content.text
     };
   }
@@ -9579,8 +9615,8 @@ var CodexAgentProviderTurns = class extends CodexAgentProviderQueue {
         );
       }
       let resolveStartedTurn = () => void 0;
-      const startedTurn = new Promise((resolve5) => {
-        resolveStartedTurn = resolve5;
+      const startedTurn = new Promise((resolve7) => {
+        resolveStartedTurn = resolve7;
       });
       const listener = (event) => {
         if (event.taskId === taskId && event.type === "turn.started") {
@@ -11401,7 +11437,7 @@ var CodexFuzzyFileSearchService = class {
       throw abortError("File search request was aborted");
     }
     this.#clearIdleTimer(session);
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve7, reject) => {
       const cachedSnapshot = session.lastSnapshot?.query === input.query ? session.lastSnapshot : void 0;
       const request = {
         data: cachedSnapshot?.data ?? [],
@@ -11409,7 +11445,7 @@ var CodexFuzzyFileSearchService = class {
         query: input.query,
         receivedUpdate: cachedSnapshot !== void 0,
         reject,
-        resolve: resolve5,
+        resolve: resolve7,
         settled: false
       };
       request.detachAbort = this.#listenForAbort(session, request, input.signal);
@@ -12143,8 +12179,8 @@ var CodexAppServerShutdownError = class extends RpcConnectionClosedError {
   }
 };
 function delay(milliseconds) {
-  return new Promise((resolve5) => {
-    const timer = setTimeout(resolve5, milliseconds);
+  return new Promise((resolve7) => {
+    const timer = setTimeout(resolve7, milliseconds);
     timer.unref();
   });
 }
@@ -12177,8 +12213,8 @@ var CodexAppServerProcess = class {
     child.stderr.on("data", (chunk) => {
       this.#appendStderr(typeof chunk === "string" ? chunk : chunk.toString("utf8"));
     });
-    this.#spawnPromise = new Promise((resolve5, reject) => {
-      child.once("spawn", resolve5);
+    this.#spawnPromise = new Promise((resolve7, reject) => {
+      child.once("spawn", resolve7);
       child.once("error", (error) => {
         const spawnError = new CodexAppServerSpawnError(
           `Failed to start Codex App Server: ${error.message}`,
@@ -12194,10 +12230,10 @@ var CodexAppServerProcess = class {
         this.client.close(new CodexAppServerExitedError({ code, signal }, this.#stderr.trim()));
       }
     });
-    this.#exitPromise = new Promise((resolve5) => {
+    this.#exitPromise = new Promise((resolve7) => {
       child.once("close", (code, signal) => {
         this.#closed = true;
-        resolve5({ code, signal });
+        resolve7({ code, signal });
       });
     });
     this.client.onError(() => {
@@ -12662,4 +12698,823 @@ var CodexProjectRepository = class {
   }
 };
 
-export { CodexAppServerExitedError, CodexAppServerProcess, CodexAppServerShutdownError, CodexAppServerSpawnError, CodexProjectRepository, CodexProtocolMappingError, CodexProviderConnectionError, CodexProviderConnectionService, CodexRuntimeProvider, JsonlRpcClient, RpcConnectionClosedError, RpcProtocolError, RpcResponseError, RpcTimeoutError, SUPPORTED_CODEX_VERSION, checkCodexVersion, createCodexRuntimeProvider, locateCodexBinary, require_pino, startCodexAppServer };
+// packages/provider-codex/src/workbench-pet-catalog.ts
+var PET_PACK_VERSION = "v1";
+var PET_CDN_BASE_URL = "https://persistent.oaistatic.com/codex/pets/v1";
+var PET_FRAME = { columns: 8, height: 208, rows: 9, width: 192 };
+var PET_SPRITESHEET = { height: 1872, width: 1536 };
+var BUILTIN_PETS = [
+  {
+    description: "The original Codex companion",
+    displayName: "Codex",
+    file: "codex-spritesheet-v4.webp",
+    id: "codex"
+  },
+  {
+    description: "A tidy duck for calm workspace days",
+    displayName: "Dewey",
+    file: "dewey-spritesheet-v4.webp",
+    id: "dewey"
+  },
+  {
+    description: "Hot path energy for fast iteration",
+    displayName: "Fireball",
+    file: "fireball-spritesheet-v4.webp",
+    id: "fireball"
+  },
+  {
+    description: "A steady rock when the diff gets large",
+    displayName: "Rocky",
+    file: "rocky-spritesheet-v4.webp",
+    id: "rocky"
+  },
+  {
+    description: "Small green shoots for new ideas",
+    displayName: "Seedy",
+    file: "seedy-spritesheet-v4.webp",
+    id: "seedy"
+  },
+  {
+    description: "A balanced stack for deep work",
+    displayName: "Stacky",
+    file: "stacky-spritesheet-v4.webp",
+    id: "stacky"
+  },
+  {
+    description: "A tiny blue-screen gremlin",
+    displayName: "BSOD",
+    file: "bsod-spritesheet-v4.webp",
+    id: "bsod"
+  },
+  {
+    description: "Quiet signal from the void",
+    displayName: "Null Signal",
+    file: "null-signal-spritesheet-v4.webp",
+    id: "null-signal"
+  }
+];
+var idleFrames = [
+  [0, 1680],
+  [1, 660],
+  [2, 660],
+  [3, 840],
+  [4, 840],
+  [5, 1920]
+];
+function idleAnimation() {
+  return {
+    fallback: "idle",
+    frames: idleFrames.map(([spriteIndex, durationMs]) => ({ durationMs, spriteIndex })),
+    loopStart: 0
+  };
+}
+function stateAnimation(row, frameCount, durationMs, finalDurationMs) {
+  const primary = Array.from({ length: frameCount }, (_, column) => ({
+    durationMs: column === frameCount - 1 ? finalDurationMs : durationMs,
+    spriteIndex: row * PET_FRAME.columns + column
+  }));
+  return {
+    fallback: "idle",
+    frames: [...primary, ...primary, ...primary, ...idleAnimation().frames],
+    loopStart: primary.length * 3
+  };
+}
+function createDefaultPetAnimations() {
+  const tracks = {
+    failed: stateAnimation(5, 8, 140, 240),
+    idle: idleAnimation(),
+    jumping: stateAnimation(4, 5, 140, 280),
+    review: stateAnimation(8, 6, 150, 280),
+    "running-left": stateAnimation(2, 8, 120, 220),
+    "running-right": stateAnimation(1, 8, 120, 220),
+    running: stateAnimation(7, 6, 120, 220),
+    waiting: stateAnimation(6, 6, 150, 260),
+    waving: stateAnimation(3, 4, 140, 280)
+  };
+  return {
+    ...tracks,
+    bounce: tracks.jumping,
+    move_left: tracks["running-left"],
+    move_right: tracks["running-right"],
+    sad: tracks.failed,
+    wave: tracks.waving
+  };
+}
+function createBuiltinDescriptor(pet, assetId, availability) {
+  return {
+    animations: createDefaultPetAnimations(),
+    assetId,
+    availability,
+    description: pet.description,
+    displayName: pet.displayName,
+    frame: PET_FRAME,
+    id: pet.id,
+    source: "builtin"
+  };
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/utilities.js
+function isValidOffsetToRead(dataView, offset, bytesToRead) {
+  return dataView.byteLength >= offset + bytesToRead;
+}
+function getUint32(dataView, offset, littleEndian = false) {
+  if (isValidOffsetToRead(dataView, offset, 4)) {
+    return dataView.getUint32(offset, littleEndian);
+  }
+}
+function getUint16(dataView, offset, littleEndian = false) {
+  if (isValidOffsetToRead(dataView, offset, 2)) {
+    return dataView.getUint16(offset, littleEndian);
+  }
+}
+function getIsobmffFtypBrands(bytes) {
+  if (bytes.length < 16) {
+    return;
+  }
+  const isFtyp = bytes[4] === 102 && bytes[5] === 116 && bytes[6] === 121 && bytes[7] === 112;
+  if (!isFtyp) {
+    return;
+  }
+  const dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const size = getUint32(dataView, 0);
+  if (size === void 0 || size < 16 || size > bytes.length) {
+    return;
+  }
+  const brands = [];
+  brands.push(String.fromCodePoint(...bytes.slice(8, 12)));
+  for (let i = 16; i + 4 <= size; i += 4) {
+    brands.push(String.fromCodePoint(...bytes.slice(i, i + 4)));
+  }
+  return brands;
+}
+function unboxIsobmffBox(data, offset) {
+  const dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  const size = getUint32(dataView, offset);
+  if (size === void 0) {
+    return;
+  }
+  if (data.length < size + offset || size < 8) {
+    return;
+  }
+  return {
+    type: String.fromCodePoint(...data.slice(offset + 4, offset + 8)),
+    data: data.slice(offset + 8, offset + size),
+    tail: offset + size
+  };
+}
+function getIsobmffIspeSizesFromMeta(data) {
+  const sizes = [];
+  let offset = 0;
+  while (offset < data.length) {
+    const box = unboxIsobmffBox(data, offset);
+    if (!box) {
+      break;
+    }
+    if (box.type === "meta") {
+      parseIsobmffMetaBox(box.data, sizes);
+    }
+    offset = box.tail;
+  }
+  return sizes;
+}
+function parseIsobmffMetaBox(data, sizes) {
+  let offset = 4;
+  while (offset < data.length) {
+    const box = unboxIsobmffBox(data, offset);
+    if (!box) {
+      break;
+    }
+    if (box.type === "iprp") {
+      parseIsobmffIprpBox(box.data, sizes);
+    }
+    offset = box.tail;
+  }
+  return sizes;
+}
+function parseIsobmffIprpBox(data, sizes) {
+  let offset = 0;
+  while (offset < data.length) {
+    const box = unboxIsobmffBox(data, offset);
+    if (!box) {
+      break;
+    }
+    if (box.type === "ipco") {
+      parseIsobmffIpcoBox(box.data, sizes);
+    }
+    offset = box.tail;
+  }
+}
+function parseIsobmffIpcoBox(data, sizes) {
+  let offset = 0;
+  while (offset < data.length) {
+    const box = unboxIsobmffBox(data, offset);
+    if (!box) {
+      break;
+    }
+    if (box.type === "ispe") {
+      const dataView = new DataView(box.data.buffer, box.data.byteOffset, box.data.byteLength);
+      const width = getUint32(dataView, 4);
+      const height = getUint32(dataView, 8);
+      if (width === void 0 || height === void 0) {
+        return;
+      }
+      sizes.push({
+        width,
+        height
+      });
+    }
+    offset = box.tail;
+  }
+}
+function getLargestAreaSize(sizes) {
+  let maxSize = sizes[0];
+  for (const size of sizes) {
+    if (size.width * size.height > maxSize.width * maxSize.height) {
+      maxSize = size;
+    }
+  }
+  return maxSize;
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/types/png.js
+var isPng = (bytes) => bytes[0] === 137 && bytes[1] === 80 && bytes[2] === 78 && bytes[3] === 71 && bytes[4] === 13 && bytes[5] === 10 && bytes[6] === 26 && bytes[7] === 10;
+var isAppleMinifiedPng = (bytes) => bytes[12] === 67 && bytes[13] === 103 && bytes[14] === 66 && bytes[15] === 73;
+function png(bytes) {
+  if (!isPng(bytes)) {
+    return;
+  }
+  const dataView = new DataView(bytes.buffer);
+  const isAppleMinified = isAppleMinifiedPng(bytes);
+  const width = getUint32(dataView, isAppleMinified ? 32 : 16, false);
+  const height = getUint32(dataView, isAppleMinified ? 36 : 20, false);
+  if (width === void 0 || height === void 0) {
+    return;
+  }
+  return {
+    width,
+    height,
+    type: "png"
+  };
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/types/jpeg.js
+var SOF0 = 65472;
+var SOF3 = 65475;
+var jsJpeg = (bytes) => bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255;
+function jpeg(bytes) {
+  if (!jsJpeg(bytes)) {
+    return;
+  }
+  const dataView = new DataView(bytes.buffer);
+  let offset = 2;
+  while (isValidOffsetToRead(dataView, offset, 2)) {
+    const marker = dataView.getUint16(offset);
+    offset += 2;
+    if (marker >= SOF0 && marker <= SOF3) {
+      const height = getUint16(dataView, offset + 3, false);
+      const width = getUint16(dataView, offset + 5, false);
+      if (height === void 0 || width === void 0) {
+        return;
+      }
+      return {
+        height,
+        width,
+        type: "jpeg"
+      };
+    }
+    const segmentLength = getUint16(dataView, offset);
+    if (segmentLength === void 0) {
+      return;
+    }
+    offset += segmentLength;
+    if (offset > dataView.byteLength) {
+      return;
+    }
+  }
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/types/gif.js
+var isGif = (bytes) => bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 56 && (bytes[4] === 55 || bytes[4] === 57) && bytes[5] === 97;
+function gif(bytes) {
+  if (!isGif(bytes)) {
+    return;
+  }
+  const dataView = new DataView(bytes.buffer);
+  const width = getUint16(dataView, 6, true);
+  const height = getUint16(dataView, 8, true);
+  if (width === void 0 || height === void 0) {
+    return;
+  }
+  return {
+    width,
+    height,
+    type: "gif"
+  };
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/types/webp.js
+var isWebp = (bytes) => (
+  // RIFF
+  bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80
+);
+var isVP8Lossy = (bytes) => (
+  // `VP8 ` (note the space)
+  bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 32
+);
+var isVP8Lossless = (bytes) => (
+  // `VP8L`
+  bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 76
+);
+var isVP8Extended = (bytes) => (
+  // `VP8X`
+  bytes[12] === 86 && bytes[13] === 80 && bytes[14] === 56 && bytes[15] === 88
+);
+function readUInt24LE(dataView, offset) {
+  const byte1 = dataView.getUint8(offset);
+  const byte2 = dataView.getUint8(offset + 1);
+  const byte3 = dataView.getUint8(offset + 2);
+  return byte3 << 16 | byte2 << 8 | byte1;
+}
+function webp(bytes) {
+  if (!isWebp(bytes)) {
+    return;
+  }
+  const dataView = new DataView(bytes.buffer);
+  const maxSize = 16383;
+  if (isVP8Lossy(bytes)) {
+    if (!isValidOffsetToRead(dataView, 28, 2)) {
+      return;
+    }
+    return {
+      // eslint-disable-next-line no-bitwise
+      width: dataView.getUint16(26, true) & maxSize,
+      // eslint-disable-next-line no-bitwise
+      height: dataView.getUint16(28, true) & maxSize,
+      type: "webp"
+    };
+  }
+  if (isVP8Lossless(bytes)) {
+    const bits = getUint32(dataView, 21, true);
+    if (bits === void 0) {
+      return;
+    }
+    return {
+      // eslint-disable-next-line no-bitwise
+      width: (bits & maxSize) + 1,
+      // eslint-disable-next-line no-bitwise
+      height: (bits >> 14 & maxSize) + 1,
+      type: "webp"
+    };
+  }
+  if (isVP8Extended(bytes)) {
+    if (!isValidOffsetToRead(dataView, 27, 3)) {
+      return;
+    }
+    return {
+      width: readUInt24LE(dataView, 24) + 1,
+      height: readUInt24LE(dataView, 27) + 1,
+      type: "webp"
+    };
+  }
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/types/avif.js
+var avifBrands = /* @__PURE__ */ new Set([
+  "avif",
+  "avis",
+  "avio"
+]);
+var isAvif = (bytes) => {
+  const brands = getIsobmffFtypBrands(bytes);
+  if (!brands) {
+    return false;
+  }
+  return brands.some((brand) => avifBrands.has(brand));
+};
+function avif(bytes) {
+  if (!isAvif(bytes)) {
+    return;
+  }
+  const sizes = getIsobmffIspeSizesFromMeta(bytes);
+  if (sizes.length === 0) {
+    return;
+  }
+  return {
+    ...getLargestAreaSize(sizes),
+    type: "avif"
+  };
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/types/heic.js
+var heifBrands = /* @__PURE__ */ new Set([
+  "mif1",
+  "msf1",
+  "heic",
+  "heix",
+  "hevc",
+  "hevx",
+  "heim",
+  "heis",
+  "hevm",
+  "hevs"
+]);
+var isHeic = (bytes) => {
+  const brands = getIsobmffFtypBrands(bytes);
+  if (!brands) {
+    return false;
+  }
+  return brands.some((brand) => heifBrands.has(brand));
+};
+function heic(bytes) {
+  if (!isHeic(bytes)) {
+    return;
+  }
+  const sizes = getIsobmffIspeSizesFromMeta(bytes);
+  if (sizes.length === 0) {
+    return;
+  }
+  return {
+    ...getLargestAreaSize(sizes),
+    type: "heic"
+  };
+}
+
+// node_modules/.pnpm/image-dimensions@2.5.1/node_modules/image-dimensions/index.js
+function imageDimensionsFromData(bytes) {
+  if (bytes.length < 3) {
+    return;
+  }
+  bytes = new Uint8Array(bytes);
+  return png(bytes) ?? gif(bytes) ?? jpeg(bytes) ?? webp(bytes) ?? avif(bytes) ?? heic(bytes);
+}
+
+// packages/provider-codex/src/workbench-pet-image.ts
+function readWebpDimensions(data) {
+  const dimensions = imageDimensionsFromData(data);
+  if (dimensions?.type !== "webp") {
+    throw new Error("Pet spritesheet must be a valid WebP image");
+  }
+  return dimensions;
+}
+async function readWebpDimensionsFromFile(path) {
+  return readWebpDimensions(await readFile(path));
+}
+var MAX_MANIFEST_BYTES = 64 * 1024;
+var MAX_CUSTOM_ASSET_BYTES = 16 * 1024 * 1024;
+var MAX_FRAMES = 256;
+var MAX_FPS = 60;
+async function loadCustomPet(input) {
+  const baseDirectory = await realpath(input.directory);
+  const manifestPath = resolve(baseDirectory, input.manifestName);
+  const manifestStats = await stat(manifestPath);
+  if (!manifestStats.isFile() || manifestStats.size > MAX_MANIFEST_BYTES) {
+    throw new Error("Pet manifest is missing or too large");
+  }
+  const raw = await readFile(manifestPath, "utf8");
+  const manifest = parseRecord(JSON.parse(raw), "Pet manifest");
+  const spritesheetPath = readOptionalString(manifest, "spritesheetPath") ?? "spritesheet.webp";
+  if (isAbsolute(spritesheetPath) || spritesheetPath.split(/[\\/]/u).includes("..")) {
+    throw new Error("Pet spritesheet must stay inside its directory");
+  }
+  const path = await realpath(resolve(baseDirectory, spritesheetPath));
+  assertContained(baseDirectory, path);
+  const assetStats = await stat(path);
+  if (!assetStats.isFile() || assetStats.size > MAX_CUSTOM_ASSET_BYTES) {
+    throw new Error("Pet spritesheet is missing or too large");
+  }
+  const dimensions = await readWebpDimensionsFromFile(path);
+  const frame = parseFrame(manifest["frame"]);
+  const frameCount = validateFrame(frame, dimensions.width, dimensions.height);
+  const animations = parseAnimations(manifest["animations"], frameCount);
+  const manifestId = readOptionalString(manifest, "id");
+  return {
+    assetId: input.assetId,
+    baseDirectory,
+    descriptor: {
+      animations,
+      assetId: input.assetId,
+      availability: "ready",
+      description: readOptionalString(manifest, "description") ?? "",
+      displayName: readOptionalString(manifest, "displayName") ?? manifestId ?? input.folder,
+      frame,
+      id: `custom:${input.folder}`,
+      source: input.source
+    },
+    path
+  };
+}
+async function validatePetAsset(record) {
+  const [baseDirectory, resolved] = await Promise.all([
+    realpath(record.baseDirectory),
+    realpath(record.path)
+  ]);
+  assertContained(baseDirectory, resolved);
+  const assetStats = await stat(resolved);
+  if (!assetStats.isFile() || assetStats.size > MAX_CUSTOM_ASSET_BYTES) {
+    throw new Error("Pet spritesheet is unavailable");
+  }
+  const dimensions = await readWebpDimensionsFromFile(resolved);
+  validateFrame(record.descriptor.frame, dimensions.width, dimensions.height);
+  return { mtimeMs: assetStats.mtimeMs, size: assetStats.size };
+}
+function parseFrame(value) {
+  if (value === void 0 || value === null) return PET_FRAME;
+  const frame = parseRecord(value, "Pet frame");
+  return {
+    columns: readPositiveInteger(frame, "columns"),
+    height: readPositiveInteger(frame, "height"),
+    rows: readPositiveInteger(frame, "rows"),
+    width: readPositiveInteger(frame, "width")
+  };
+}
+function validateFrame(frame, width, height) {
+  if (width === void 0 || height === void 0 || frame.width * frame.columns !== width || frame.height * frame.rows !== height) {
+    throw new Error("Pet frame grid must cover the spritesheet exactly");
+  }
+  const frameCount = frame.columns * frame.rows;
+  if (frameCount > MAX_FRAMES) throw new Error("Pet frame count exceeds the maximum");
+  return frameCount;
+}
+function parseAnimations(value, frameCount) {
+  const defaults = createDefaultPetAnimations();
+  if (value === void 0 || value === null) return defaults;
+  const source = parseRecord(value, "Pet animations");
+  if (Object.keys(source).length === 0) return defaults;
+  const animations = { ...defaults };
+  for (const [name, raw] of Object.entries(source)) {
+    const spec = parseRecord(raw, `Pet animation ${name}`);
+    const frames = spec["frames"];
+    if (!Array.isArray(frames) || frames.length === 0) {
+      throw new Error(`Pet animation ${name} requires frames`);
+    }
+    const spriteIndices = frames.map((frame) => {
+      if (!Number.isInteger(frame) || Number(frame) < 0 || Number(frame) >= frameCount) {
+        throw new Error(`Pet animation ${name} has an invalid frame`);
+      }
+      return Number(frame);
+    });
+    const fps = spec["fps"] === void 0 ? 8 : Number(spec["fps"]);
+    if (!Number.isFinite(fps) || fps <= 0 || fps > MAX_FPS) {
+      throw new Error(`Pet animation ${name} has an invalid fps`);
+    }
+    const loops = spec["loop"] === void 0 ? true : spec["loop"];
+    if (typeof loops !== "boolean") throw new Error(`Pet animation ${name} has an invalid loop`);
+    animations[name] = {
+      fallback: readOptionalString(spec, "fallback") ?? "idle",
+      frames: spriteIndices.map((spriteIndex) => ({
+        durationMs: Math.max(1, Math.round(1e3 / fps)),
+        spriteIndex
+      })),
+      loopStart: loops ? 0 : null
+    };
+  }
+  for (const [name, animation] of Object.entries(animations)) {
+    if (animations[animation.fallback] === void 0) {
+      throw new Error(`Pet animation ${name} has an unknown fallback`);
+    }
+  }
+  return animations;
+}
+function assertContained(base, target) {
+  const child = relative(base, target);
+  if (child === "" || !child.startsWith(`..${sep}`) && child !== ".." && !isAbsolute(child)) {
+    return;
+  }
+  throw new Error("Pet asset escapes its directory");
+}
+function parseRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function readOptionalString(record, key) {
+  const value = record[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error(`Pet ${key} must be a string`);
+  const normalized = value.trim();
+  return normalized.length === 0 ? void 0 : normalized;
+}
+function readPositiveInteger(record, key) {
+  const value = record[key];
+  if (!Number.isInteger(value) || Number(value) <= 0) {
+    throw new Error(`Pet frame ${key} must be a positive integer`);
+  }
+  return Number(value);
+}
+
+// packages/provider-codex/src/workbench-pets.ts
+var MAX_DOWNLOAD_BYTES = 4 * 1024 * 1024;
+var DOWNLOAD_TIMEOUT_MS = 6e4;
+var MAX_CONCURRENT_DOWNLOADS = 2;
+var CodexWorkbenchPetProvider = class {
+  #assetRecords = /* @__PURE__ */ new Map();
+  #codexHome;
+  #fetch;
+  #inFlight = /* @__PURE__ */ new Map();
+  #logger;
+  #downloadWaiters = [];
+  #activeDownloads = 0;
+  constructor(options) {
+    this.#codexHome = resolve(options.codexHome);
+    this.#fetch = options.fetch ?? globalThis.fetch;
+    this.#logger = options.logger;
+  }
+  async listPets() {
+    this.#assetRecords.clear();
+    const builtins = await Promise.all(BUILTIN_PETS.map((pet) => this.#describeBuiltin(pet)));
+    const preferred = await this.#scanCustomRoot("pets", "pet.json", "custom");
+    const preferredFolders = new Set(preferred.map((record) => record.descriptor.id));
+    const legacy = (await this.#scanCustomRoot("avatars", "avatar.json", "legacy")).filter(
+      (record) => !preferredFolders.has(record.descriptor.id)
+    );
+    for (const record of [...preferred, ...legacy]) this.#assetRecords.set(record.assetId, record);
+    return [...builtins, ...preferred, ...legacy].map(
+      (item) => "descriptor" in item ? item.descriptor : item
+    );
+  }
+  ensurePetAsset(petId) {
+    if (petId.startsWith("custom:")) {
+      return Promise.reject(
+        new WorkbenchPetProviderError("invalid", "Only built-in pets can be downloaded")
+      );
+    }
+    const pet = BUILTIN_PETS.find((candidate) => candidate.id === petId);
+    if (pet === void 0) {
+      return Promise.reject(new WorkbenchPetProviderError("not_found", "Unknown built-in pet"));
+    }
+    const existing = this.#inFlight.get(petId);
+    if (existing !== void 0) return existing;
+    const promise = this.#ensureBuiltin(pet).finally(() => this.#inFlight.delete(petId));
+    this.#inFlight.set(petId, promise);
+    return promise;
+  }
+  async openPetAsset(assetId) {
+    let record = this.#assetRecords.get(assetId);
+    if (record === void 0) {
+      await this.listPets();
+      record = this.#assetRecords.get(assetId);
+    }
+    if (record?.descriptor.availability !== "ready") return void 0;
+    try {
+      const metadata = await validatePetAsset(record);
+      const content = await readFile(record.path);
+      return {
+        content,
+        contentType: "image/webp",
+        etag: `W/"${String(metadata.size)}-${String(Math.trunc(metadata.mtimeMs))}"`,
+        size: metadata.size
+      };
+    } catch {
+      throw new WorkbenchPetProviderError("invalid", "Pet asset is invalid");
+    }
+  }
+  async #describeBuiltin(pet) {
+    const assetId = stableAssetId(`builtin:${PET_PACK_VERSION}:${pet.id}:${pet.file}`);
+    const path = this.#builtinPath(pet);
+    const baseDirectory = dirname(path);
+    let availability = "downloadable";
+    try {
+      await validateBuiltinFile(path);
+      availability = "ready";
+    } catch {
+    }
+    const descriptor = createBuiltinDescriptor(pet, assetId, availability);
+    this.#assetRecords.set(assetId, { assetId, baseDirectory, descriptor, path });
+    return descriptor;
+  }
+  async #ensureBuiltin(pet) {
+    const cached = await this.#describeBuiltin(pet);
+    if (cached.availability === "ready") return cached;
+    await this.#acquireDownloadSlot();
+    const destination = this.#builtinPath(pet);
+    const staging = join(dirname(destination), `.${pet.file}.download-${randomUUID()}.webp`);
+    try {
+      const secondCheck = await this.#describeBuiltin(pet);
+      if (secondCheck.availability === "ready") return secondCheck;
+      const bytes = await this.#download(pet);
+      await mkdir(dirname(destination), { recursive: true });
+      await writeFile(staging, bytes, { flag: "wx" });
+      await validateBuiltinFile(staging);
+      try {
+        await rename(staging, destination);
+      } catch {
+        await rm(destination, { force: true });
+        await rename(staging, destination);
+      }
+      return await this.#describeBuiltin(pet);
+    } catch (cause) {
+      throw new WorkbenchPetProviderError(
+        "download_failed",
+        cause instanceof Error ? cause.message : "Pet asset download failed"
+      );
+    } finally {
+      await rm(staging, { force: true });
+      this.#releaseDownloadSlot();
+    }
+  }
+  async #download(pet) {
+    const url = `${PET_CDN_BASE_URL}/${pet.file}`;
+    const response = await this.#fetch(url, {
+      redirect: "follow",
+      signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+    });
+    if (!response.ok) throw new Error(`Pet asset download failed with ${String(response.status)}`);
+    if (response.url.length > 0) validateDownloadUrl(response.url);
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > MAX_DOWNLOAD_BYTES) {
+      throw new Error("Pet asset download exceeded 4MiB");
+    }
+    if (response.body === null) throw new Error("Pet asset download returned no body");
+    const body = response.body;
+    const reader = body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (; ; ) {
+      const result = await reader.read();
+      if (result.done) break;
+      size += result.value.byteLength;
+      if (size > MAX_DOWNLOAD_BYTES) {
+        await reader.cancel();
+        throw new Error("Pet asset download exceeded 4MiB");
+      }
+      chunks.push(result.value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+      bytes.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    const dimensions = readWebpDimensions(bytes);
+    if (dimensions.width !== PET_SPRITESHEET.width || dimensions.height !== PET_SPRITESHEET.height) {
+      throw new Error("Pet asset has invalid dimensions");
+    }
+    return bytes;
+  }
+  async #scanCustomRoot(rootName, manifestName, source) {
+    const root = join(this.#codexHome, rootName);
+    let entries;
+    try {
+      entries = await readdir(root, { withFileTypes: true });
+    } catch {
+      return [];
+    }
+    const records = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      try {
+        const directory = join(root, entry.name);
+        const assetId = stableAssetId(`${source}:${entry.name}`);
+        records.push(
+          await loadCustomPet({ assetId, directory, folder: entry.name, manifestName, source })
+        );
+      } catch {
+        this.#logger?.warn(`Skipped invalid ${source} pet ${entry.name}`);
+      }
+    }
+    return records;
+  }
+  #builtinPath(pet) {
+    return join(this.#codexHome, "cache", "tui-pets", PET_PACK_VERSION, "assets", pet.file);
+  }
+  async #acquireDownloadSlot() {
+    if (this.#activeDownloads < MAX_CONCURRENT_DOWNLOADS) {
+      this.#activeDownloads += 1;
+      return;
+    }
+    await new Promise((resolveWaiter) => this.#downloadWaiters.push(resolveWaiter));
+    this.#activeDownloads += 1;
+  }
+  #releaseDownloadSlot() {
+    this.#activeDownloads -= 1;
+    this.#downloadWaiters.shift()?.();
+  }
+};
+function createCodexWorkbenchPetProvider(options) {
+  return new CodexWorkbenchPetProvider(options);
+}
+async function validateBuiltinFile(path) {
+  const [root, resolved] = await Promise.all([realpath(dirname(path)), realpath(path)]);
+  const child = relative(root, resolved);
+  if (child === ".." || child.startsWith(`..${sep}`)) throw new Error("Pet cache path escaped");
+  const metadata = await stat(resolved);
+  if (!metadata.isFile() || metadata.size > MAX_DOWNLOAD_BYTES) {
+    throw new Error("Pet cache file is invalid");
+  }
+  const dimensions = await readWebpDimensionsFromFile(resolved);
+  if (dimensions.width !== PET_SPRITESHEET.width || dimensions.height !== PET_SPRITESHEET.height) {
+    throw new Error("Pet cache file has invalid dimensions");
+  }
+}
+function stableAssetId(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function validateDownloadUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" || url.hostname !== "persistent.oaistatic.com") {
+    throw new Error("Pet asset download redirected outside the allowed host");
+  }
+}
+
+export { CodexAppServerExitedError, CodexAppServerProcess, CodexAppServerShutdownError, CodexAppServerSpawnError, CodexProjectRepository, CodexProtocolMappingError, CodexProviderConnectionError, CodexProviderConnectionService, CodexRuntimeProvider, CodexWorkbenchPetProvider, JsonlRpcClient, RpcConnectionClosedError, RpcProtocolError, RpcResponseError, RpcTimeoutError, SUPPORTED_CODEX_VERSION, checkCodexVersion, createCodexRuntimeProvider, createCodexWorkbenchPetProvider, locateCodexBinary, require_pino, require_safe_stable_stringify, startCodexAppServer };