@infersec/conduit 1.99.2 → 1.101.0

package/dist/cli.sea.cjs

@@ -42,10 +42,10 @@ var require$$1$8 = require('node:async_hooks');
 var require$$1$9 = require('node:console');
 var require$$0$m = require('node:fs/promises');
 var require$$2$5 = require('node:timers');
-var node_string_decoder = require('node:string_decoder');
-var promises = require('node:stream/promises');
 require('fs/promises');
 require('stream/promises');
+var node_string_decoder = require('node:string_decoder');
+var promises = require('node:stream/promises');
 var os = require('node:os');
 var tty = require('node:tty');
 var require$$3$9 = require('child_process');
@@ -20001,7 +20001,39 @@ object$1({
     supportsVision: boolean$1()
 });
 const LLMModelTaskTypeSchema = _enum$1(["text-generation", "embeddings"]);
+const ReasoningEffortSchema = _enum$1(["none", "minimal", "low", "medium", "high", "xhigh"]);
+const CHAT_TEMPLATE_DEFAULT_FILE_PATH = "chat_template.jinja";
+const CHAT_TEMPLATE_LOCAL_FILE_NAME = "infersec-chat-template.jinja";
+const ChatTemplateOverrideSchema = discriminatedUnion("type", [
+    object$1({
+        filePath: string$2().min(1).default(CHAT_TEMPLATE_DEFAULT_FILE_PATH),
+        repo: string$2().min(1),
+        type: literal("huggingface")
+    }),
+    object$1({
+        content: string$2().min(1),
+        type: literal("inline")
+    })
+]);
+const ThinkingConfigSchema = object$1({
+    enabled: boolean$1().optional(),
+    effort: ReasoningEffortSchema.optional()
+});
+const ANTHROPIC_THINKING_BUDGET_EFFORT_TIERS = [
+    { effort: "low", maxBudgetTokens: 2048 },
+    { effort: "medium", maxBudgetTokens: 8192 },
+    { effort: "high", maxBudgetTokens: Number.POSITIVE_INFINITY }
+];
+function reasoningEffortForAnthropicBudget(budgetTokens) {
+    for (const tier of ANTHROPIC_THINKING_BUDGET_EFFORT_TIERS) {
+        if (budgetTokens <= tier.maxBudgetTokens) {
+            return tier.effort;
+        }
+    }
+    return "high";
+}
 const LLMModelSchema = object$1({
+    chatTemplate: ChatTemplateOverrideSchema.nullable().optional(),
     format: LLMModelFormatSchema,
     id: string$2().min(1),
     multimodalEnabled: boolean$1(),
@@ -20016,7 +20048,8 @@ const LLMModelSchema = object$1({
             type: literal("huggingface")
         })
     ]),
-    taskType: LLMModelTaskTypeSchema
+    taskType: LLMModelTaskTypeSchema,
+    thinkingConfig: ThinkingConfigSchema.nullable().optional()
 });
 object$1({
     filePath: string$2().min(1),
@@ -20135,7 +20168,8 @@ const ConduitStateSchema = z
 ])
     .and(z.object({
     activeRequestCount: z.number().int().nonnegative().optional(),
-    timestamp: z.string().datetime()
+    timestamp: z.string().datetime(),
+    warnings: z.array(z.string()).optional()
 }));
 const ConduitState = z.preprocess(value => {
     if (value === null) {
@@ -20674,6 +20708,10 @@ const ChatCompletionMessageSchema = object$1({
 const ChatCompletionCreateParamsSchema = object$1({
     messages: array(ChatCompletionMessageParamSchema),
     model: string$2(),
+    chat_template_kwargs: record(string$2(), unknown())
+        .nullable()
+        .optional()
+        .describe("Additional chat template variables passed to the model's chat template at render time (e.g. reasoning_effort)"),
     frequency_penalty: number$1().min(-2).max(2).nullable().optional(),
     function_call: union([literal("none"), literal("auto"), object$1({ name: string$2() })])
         .optional(),
@@ -20689,6 +20727,9 @@ const ChatCompletionCreateParamsSchema = object$1({
     max_tokens: number$1().positive().nullable().optional(),
     n: number$1().positive().nullable().optional(),
     presence_penalty: number$1().min(-2).max(2).nullable().optional(),
+    reasoning_effort: ReasoningEffortSchema.nullable()
+        .optional()
+        .describe("Reasoning effort hint for thinking models. Forwarded to the chat template when one is configured"),
     response_format: object$1({
         type: _enum$1(["text", "json_object"])
     })
@@ -20970,6 +21011,7 @@ RoutingMethod.FirstAvailable;
 });
 
 object$1({
+    chatTemplate: ChatTemplateOverrideSchema.nullable().optional(),
     format: LLMModelFormatSchema,
     multimodalEnabled: boolean$1().optional(),
     name: ResourceNameSchema,
@@ -20979,7 +21021,8 @@ object$1({
         .refine(value => value.includes("/"), {
         message: "Slug must be fully qualified (owner/repo)"
     }),
-    taskType: LLMModelTaskTypeSchema.optional()
+    taskType: LLMModelTaskTypeSchema.optional(),
+    thinkingConfig: ThinkingConfigSchema.nullable().optional()
 });
 object$1({
     results: array(object$1({
@@ -20995,6 +21038,7 @@ object$1({
     }))
 });
 object$1({
+    chatTemplate: ChatTemplateOverrideSchema.nullable(),
     created: string$2(),
     id: ULIDSchema,
     modelFormat: LLMModelFormatSchema,
@@ -21012,12 +21056,15 @@ object$1({
         updated: string$2()
     })),
     taskType: LLMModelTaskTypeSchema,
+    thinkingConfig: ThinkingConfigSchema.nullable(),
     updated: string$2()
 });
 object$1({
+    chatTemplate: ChatTemplateOverrideSchema.nullable().optional(),
     multimodalEnabled: boolean$1().optional(),
     name: ResourceNameSchema.optional(),
-    taskType: LLMModelTaskTypeSchema.optional()
+    taskType: LLMModelTaskTypeSchema.optional(),
+    thinkingConfig: ThinkingConfigSchema.nullable().optional()
 });
 object$1({
     success: literal(true)
@@ -112947,653 +112994,1858 @@ var createRouter = /*@__PURE__*/getDefaultExportFromCjs(expressPromiseRouterExpo
 
 const SERVED_MODEL_NAME = "default";
 
-const SECRET_FLAGS = new Set([
-    "api-key",
-    "auth-token",
-    "hf-token",
-    "key",
-    "password",
-    "secret",
-    "token"
-]);
-function redactSecretArgs(args) {
-    return args.map((arg, index) => {
-        const equalsIndex = arg.indexOf("=");
-        if (arg.startsWith("--") && equalsIndex > 0) {
-            const flag = arg.slice(2, equalsIndex);
-            if (SECRET_FLAGS.has(flag)) {
-                return `${arg.slice(0, equalsIndex + 1)}***`;
-            }
-        }
-        const previous = args[index - 1];
-        if (previous &&
-            previous.startsWith("--") &&
-            !previous.includes("=") &&
-            SECRET_FLAGS.has(previous.slice(2))) {
-            return "***";
-        }
-        return arg;
-    });
-}
-async function createEngineProcess({ args, bin, logger }) {
-    logger.info("Starting engine process", {
-        command: { args: redactSecretArgs(args), bin }
-    });
-    const processManager = new ProcessManager({ args, command: bin });
-    await processManager.start();
-    return processManager;
-}
+// src/lib/cache-management.ts
 
-function parseExtraArgs(extraArgs) {
-    if (!Array.isArray(extraArgs) ||
-        !extraArgs.every((value) => typeof value === "string")) {
-        return [];
+// src/consts.ts
+var HUB_URL = "https://huggingface.co";
+
+// src/error.ts
+async function createApiError(response, opts) {
+  const error = new HubApiError(response.url, response.status, response.headers.get("X-Request-Id") ?? opts?.requestId);
+  error.message = `Api error with status ${error.statusCode}${""}`;
+  const trailer = [`URL: ${error.url}`, error.requestId ? `Request ID: ${error.requestId}` : void 0].filter(Boolean).join(". ");
+  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
+    const json = await response.json();
+    error.message = json.error || json.message || error.message;
+    if (json.error_description) {
+      error.message = error.message ? error.message + `: ${json.error_description}` : json.error_description;
     }
-    return extraArgs.flatMap(tokenizeShellLine);
+    error.data = json;
+  } else {
+    error.data = { message: await response.text() };
+  }
+  error.message += `. ${trailer}`;
+  throw error;
 }
-function tokenizeShellLine(input) {
-    const tokens = [];
-    let buffer = "";
-    let inQuote = null;
-    let hasBuffer = false;
-    for (let index = 0; index < input.length; index += 1) {
-        const char = input[index];
-        if (inQuote) {
-            if (char === inQuote) {
-                inQuote = null;
-            }
-            else {
-                buffer += char;
-            }
-            hasBuffer = true;
-        }
-        else if (char === '"' || char === "'") {
-            inQuote = char;
-            hasBuffer = true;
-        }
-        else if (char === " " || char === "\t") {
-            if (hasBuffer) {
-                tokens.push(buffer);
-                buffer = "";
-                hasBuffer = false;
-            }
-        }
-        else {
-            buffer += char;
-            hasBuffer = true;
-        }
+var HubApiError = class extends Error {
+  statusCode;
+  url;
+  requestId;
+  data;
+  constructor(url, statusCode, requestId, message) {
+    super(message);
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.url = url;
+  }
+};
+var InvalidApiResponseFormatError = class extends Error {
+};
+
+// src/utils/checkCredentials.ts
+function checkAccessToken(accessToken) {
+  if (!accessToken.startsWith("hf_")) {
+    throw new TypeError("Your access token must start with 'hf_'");
+  }
+}
+function checkCredentials(params) {
+  if (params.accessToken) {
+    checkAccessToken(params.accessToken);
+    return params.accessToken;
+  }
+  if (params.credentials?.accessToken) {
+    checkAccessToken(params.credentials.accessToken);
+    return params.credentials.accessToken;
+  }
+}
+
+// src/utils/toRepoId.ts
+function toRepoId(repo) {
+  if (typeof repo !== "string") {
+    return repo;
+  }
+  if (repo.startsWith("model/") || repo.startsWith("models/")) {
+    throw new TypeError(
+      "A repo designation for a model should not start with 'models/', directly specify the model namespace / name"
+    );
+  }
+  if (repo.startsWith("space/")) {
+    throw new TypeError("Spaces should start with 'spaces/', plural, not 'space/'");
+  }
+  if (repo.startsWith("dataset/")) {
+    throw new TypeError("Datasets should start with 'dataset/', plural, not 'dataset/'");
+  }
+  const slashes = repo.split("/").length - 1;
+  if (repo.startsWith("spaces/")) {
+    if (slashes !== 2) {
+      throw new TypeError("Space Id must include namespace and name of the space");
     }
-    if (hasBuffer) {
-        tokens.push(buffer);
+    return {
+      type: "space",
+      name: repo.slice("spaces/".length)
+    };
+  }
+  if (repo.startsWith("datasets/")) {
+    if (slashes > 2) {
+      throw new TypeError("Too many slashes in repo designation: " + repo);
     }
-    return tokens;
+    return {
+      type: "dataset",
+      name: repo.slice("datasets/".length)
+    };
+  }
+  if (slashes > 1) {
+    throw new TypeError("Too many slashes in repo designation: " + repo);
+  }
+  return {
+    type: "model",
+    name: repo
+  };
 }
+new Promise((r) => {
+});
 
-const balanced = (a, b, str) => {
-    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
-    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-    const r = ma !== null && mb != null && range(ma, mb, str);
-    return (r && {
-        start: r[0],
-        end: r[1],
-        pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + ma.length, r[1]),
-        post: str.slice(r[1] + mb.length),
-    });
-};
-const maybeMatch = (reg, str) => {
-    const m = str.match(reg);
-    return m ? m[0] : null;
+// src/utils/combineUint8Arrays.ts
+function combineUint8Arrays(a, b) {
+  const aLength = a.length;
+  const combinedBytes = new Uint8Array(aLength + b.length);
+  combinedBytes.set(a);
+  combinedBytes.set(b, aLength);
+  return combinedBytes;
+}
+function readU64(b, n) {
+  let x = 0;
+  x |= b[n++] << 0;
+  x |= b[n++] << 8;
+  x |= b[n++] << 16;
+  x |= b[n++] << 24;
+  x |= b[n++] << 32;
+  x |= b[n++] << 40;
+  x |= b[n++] << 48;
+  x |= b[n++] << 56;
+  return x;
+}
+function readU32(b, n) {
+  let x = 0;
+  x |= b[n++] << 0;
+  x |= b[n++] << 8;
+  x |= b[n++] << 16;
+  x |= b[n++] << 24;
+  return x;
+}
+
+// src/vendor/lz4js/index.ts
+var minMatch = 4;
+var hashSize = 1 << 16;
+makeHashTable();
+var magicNum = 407708164;
+var fdContentChksum = 4;
+var fdContentSize = 8;
+var fdBlockChksum = 16;
+var fdVersion = 64;
+var fdVersionMask = 192;
+var bsUncompressed = 2147483648;
+var bsShift = 4;
+var bsMask = 7;
+var bsMap = {
+  4: 65536,
+  5: 262144,
+  6: 1048576,
+  7: 4194304
 };
-const range = (a, b, str) => {
-    let begs, beg, left, right = undefined, result;
-    let ai = str.indexOf(a);
-    let bi = str.indexOf(b, ai + 1);
-    let i = ai;
-    if (ai >= 0 && bi > 0) {
-        if (a === b) {
-            return [ai, bi];
-        }
-        begs = [];
-        left = str.length;
-        while (i >= 0 && !result) {
-            if (i === ai) {
-                begs.push(i);
-                ai = str.indexOf(a, i + 1);
-            }
-            else if (begs.length === 1) {
-                const r = begs.pop();
-                if (r !== undefined)
-                    result = [r, bi];
-            }
-            else {
-                beg = begs.pop();
-                if (beg !== undefined && beg < left) {
-                    left = beg;
-                    right = bi;
-                }
-                bi = str.indexOf(b, i + 1);
-            }
-            i = ai < bi && ai >= 0 ? ai : bi;
-        }
-        if (begs.length && right !== undefined) {
-            result = [left, right];
-        }
+function makeHashTable() {
+  try {
+    return new Uint32Array(hashSize);
+  } catch (error) {
+    const hashTable2 = new Array(hashSize);
+    for (let i = 0; i < hashSize; i++) {
+      hashTable2[i] = 0;
     }
-    return result;
-};
-
-const escSlash = '\0SLASH' + Math.random() + '\0';
-const escOpen = '\0OPEN' + Math.random() + '\0';
-const escClose = '\0CLOSE' + Math.random() + '\0';
-const escComma = '\0COMMA' + Math.random() + '\0';
-const escPeriod = '\0PERIOD' + Math.random() + '\0';
-const escSlashPattern = new RegExp(escSlash, 'g');
-const escOpenPattern = new RegExp(escOpen, 'g');
-const escClosePattern = new RegExp(escClose, 'g');
-const escCommaPattern = new RegExp(escComma, 'g');
-const escPeriodPattern = new RegExp(escPeriod, 'g');
-const slashPattern = /\\\\/g;
-const openPattern = /\\{/g;
-const closePattern = /\\}/g;
-const commaPattern = /\\,/g;
-const periodPattern = /\\\./g;
-const EXPANSION_MAX = 100_000;
-// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An
-// input like `'{a,b}'.repeat(1500)` stays under that count - its output is
-// truncated to 100k results - while making every result ~1500 characters
-// long. The result set, and the intermediate arrays built while combining
-// brace sets, then grow large enough to exhaust memory and crash the process
-// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of
-// characters the accumulator may hold at any point, so memory stays flat no
-// matter how many brace groups are chained. The limit sits well above any
-// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M
-// characters) so legitimate input is unaffected.
-const EXPANSION_MAX_LENGTH = 4_000_000;
-function numeric(str) {
-    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+    return hashTable2;
+  }
 }
-function escapeBraces(str) {
-    return str
-        .replace(slashPattern, escSlash)
-        .replace(openPattern, escOpen)
-        .replace(closePattern, escClose)
-        .replace(commaPattern, escComma)
-        .replace(periodPattern, escPeriod);
+function makeBuffer(size) {
+  return new Uint8Array(size);
 }
-function unescapeBraces(str) {
-    return str
-        .replace(escSlashPattern, '\\')
-        .replace(escOpenPattern, '{')
-        .replace(escClosePattern, '}')
-        .replace(escCommaPattern, ',')
-        .replace(escPeriodPattern, '.');
+function sliceArray(array, start, end) {
+  return array.slice(start, end);
 }
-/**
- * Basically just str.split(","), but handling cases
- * where we have nested braced sections, which should be
- * treated as individual members, like {a,{b,c},d}
- */
-function parseCommaParts(str) {
-    if (!str) {
-        return [''];
+function decompressBound(src) {
+  let sIndex = 0;
+  if (readU32(src, sIndex) !== magicNum) {
+    throw new Error("invalid magic number");
+  }
+  sIndex += 4;
+  const descriptor = src[sIndex++];
+  if ((descriptor & fdVersionMask) !== fdVersion) {
+    throw new Error("incompatible descriptor version " + (descriptor & fdVersionMask));
+  }
+  const useBlockSum = (descriptor & fdBlockChksum) !== 0;
+  const useContentSize = (descriptor & fdContentSize) !== 0;
+  const bsIdx = src[sIndex++] >> bsShift & bsMask;
+  if (bsMap[bsIdx] === void 0) {
+    throw new Error("invalid block size " + bsIdx);
+  }
+  const maxBlockSize = bsMap[bsIdx];
+  if (useContentSize) {
+    return readU64(src, sIndex);
+  }
+  sIndex++;
+  let maxSize = 0;
+  while (true) {
+    let blockSize = readU32(src, sIndex);
+    sIndex += 4;
+    if (blockSize & bsUncompressed) {
+      blockSize &= ~bsUncompressed;
+      maxSize += blockSize;
+    } else if (blockSize > 0) {
+      maxSize += maxBlockSize;
     }
-    const parts = [];
-    const m = balanced('{', '}', str);
-    if (!m) {
-        return str.split(',');
+    if (blockSize === 0) {
+      return maxSize;
     }
-    const { pre, body, post } = m;
-    const p = pre.split(',');
-    p[p.length - 1] += '{' + body + '}';
-    const postParts = parseCommaParts(post);
-    if (post.length) {
-        p[p.length - 1] += postParts.shift();
-        p.push.apply(p, postParts);
+    if (useBlockSum) {
+      sIndex += 4;
     }
-    parts.push.apply(parts, p);
-    return parts;
+    sIndex += blockSize;
+  }
 }
-function expand(str, options = {}) {
-    if (!str) {
-        return [];
+function decompressBlock(src, dst, sIndex, sLength, dIndex) {
+  let mLength, mOffset, sEnd, n, i;
+  const hasCopyWithin = dst.copyWithin !== void 0 && dst.fill !== void 0;
+  sEnd = sIndex + sLength;
+  while (sIndex < sEnd) {
+    const token = src[sIndex++];
+    let literalCount = token >> 4;
+    if (literalCount > 0) {
+      if (literalCount === 15) {
+        while (true) {
+          literalCount += src[sIndex];
+          if (src[sIndex++] !== 255) {
+            break;
+          }
+        }
+      }
+      for (n = sIndex + literalCount; sIndex < n; ) {
+        dst[dIndex++] = src[sIndex++];
+      }
     }
-    const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH } = options;
-    // I don't know why Bash 4.3 does this, but it does.
-    // Anything starting with {} will have the first two bytes preserved
-    // but *only* at the top level, so {},a}b will not expand to anything,
-    // but a{},b}c will be expanded to [a}c,abc].
-    // One could argue that this is a bug in Bash, but since the goal of
-    // this module is to match Bash's rules, we escape a leading {}
-    if (str.slice(0, 2) === '{}') {
-        str = '\\{\\}' + str.slice(2);
+    if (sIndex >= sEnd) {
+      break;
     }
-    return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
-}
-function embrace(str) {
-    return '{' + str + '}';
-}
-function isPadded(el) {
-    return /^-?0\d/.test(el);
-}
-function lte(i, y) {
-    return i <= y;
-}
-function gte(i, y) {
-    return i >= y;
-}
-// Build `{ acc[a] + pre + values[v] }` for every combination, capping the
-// number of results at `max` and the total number of characters at `maxLength`.
-// This is the one place output grows, so bounding it here keeps the single
-// accumulator - and therefore memory - flat regardless of how many brace groups
-// are combined (CVE-2026-14257).
-function combine(acc, pre, values, max, maxLength, dropEmpties) {
-    const out = [];
-    let length = 0;
-    for (let a = 0; a < acc.length; a++) {
-        for (let v = 0; v < values.length; v++) {
-            if (out.length >= max)
-                return out;
-            const expansion = acc[a] + pre + values[v];
-            // Bash drops empty results at the top level. Skip them before they count
-            // against `max`, so `max` bounds the number of *kept* results.
-            if (dropEmpties && !expansion)
-                continue;
-            if (length + expansion.length > maxLength)
-                return out;
-            out.push(expansion);
-            length += expansion.length;
+    mLength = token & 15;
+    mOffset = src[sIndex++] | src[sIndex++] << 8;
+    if (mLength === 15) {
+      while (true) {
+        mLength += src[sIndex];
+        if (src[sIndex++] !== 255) {
+          break;
         }
+      }
     }
-    return out;
+    mLength += minMatch;
+    if (hasCopyWithin && mOffset === 1) {
+      dst.fill(dst[dIndex - 1] | 0, dIndex, dIndex + mLength);
+      dIndex += mLength;
+    } else if (hasCopyWithin && mOffset > mLength && mLength > 31) {
+      dst.copyWithin(dIndex, dIndex - mOffset, dIndex - mOffset + mLength);
+      dIndex += mLength;
+    } else {
+      for (i = dIndex - mOffset, n = i + mLength; i < n; ) {
+        dst[dIndex++] = dst[i++] | 0;
+      }
+    }
+  }
+  return dIndex;
 }
-// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)
-// sequence body.
-function expandSequence(body, isAlphaSequence, max, maxLength) {
-    const n = body.split(/\.\./);
-    const N = [];
-    // A sequence body always splits into two or three parts, but the compiler
-    // can't know that.
-    /* c8 ignore start */
-    if (n[0] === undefined || n[1] === undefined) {
-        return N;
+function decompressFrame(src, dst) {
+  let useBlockSum, useContentSum, useContentSize, descriptor;
+  let sIndex = 0;
+  let dIndex = 0;
+  if (readU32(src, sIndex) !== magicNum) {
+    throw new Error("invalid magic number");
+  }
+  sIndex += 4;
+  descriptor = src[sIndex++];
+  if ((descriptor & fdVersionMask) !== fdVersion) {
+    throw new Error("incompatible descriptor version");
+  }
+  useBlockSum = (descriptor & fdBlockChksum) !== 0;
+  useContentSum = (descriptor & fdContentChksum) !== 0;
+  useContentSize = (descriptor & fdContentSize) !== 0;
+  const bsIdx = src[sIndex++] >> bsShift & bsMask;
+  if (bsMap[bsIdx] === void 0) {
+    throw new Error("invalid block size");
+  }
+  if (useContentSize) {
+    sIndex += 8;
+  }
+  sIndex++;
+  while (true) {
+    var compSize;
+    compSize = readU32(src, sIndex);
+    sIndex += 4;
+    if (compSize === 0) {
+      break;
     }
-    /* c8 ignore stop */
-    const x = numeric(n[0]);
-    const y = numeric(n[1]);
-    const width = Math.max(n[0].length, n[1].length);
-    let incr = n.length === 3 && n[2] !== undefined ?
-        Math.max(Math.abs(numeric(n[2])), 1)
-        : 1;
-    let test = lte;
-    const reverse = y < x;
-    if (reverse) {
-        incr *= -1;
-        test = gte;
+    if (useBlockSum) {
+      sIndex += 4;
     }
-    const pad = n.some(isPadded);
-    let length = 0;
-    for (let i = x; test(i, y) && N.length < max; i += incr) {
-        let c;
-        if (isAlphaSequence) {
-            c = String.fromCharCode(i);
-            if (c === '\\') {
-                c = '';
-            }
-        }
-        else {
-            c = String(i);
-            if (pad) {
-                const need = width - c.length;
-                if (need > 0) {
-                    const z = new Array(need + 1).join('0');
-                    if (i < 0) {
-                        c = '-' + z + c.slice(1);
-                    }
-                    else {
-                        c = z + c;
-                    }
-                }
-            }
-        }
-        if (length + c.length > maxLength)
-            break;
-        N.push(c);
-        length += c.length;
+    if ((compSize & bsUncompressed) !== 0) {
+      compSize &= ~bsUncompressed;
+      for (let j = 0; j < compSize; j++) {
+        dst[dIndex++] = src[sIndex++];
+      }
+    } else {
+      dIndex = decompressBlock(src, dst, sIndex, compSize, dIndex);
+      sIndex += compSize;
     }
-    return N;
+  }
+  if (useContentSum) {
+    sIndex += 4;
+  }
+  return dIndex;
 }
-function expand_(str, max, maxLength, isTop) {
-    // Consume the string's top-level brace groups left to right, threading a
-    // running set of combined prefixes (`acc`). Expanding the tail iteratively -
-    // rather than recursing on `m.post` once per group - keeps the native stack
-    // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no
-    // longer overflow the stack, and leaves a single accumulator whose size
-    // `maxLength` bounds directly (CVE-2026-14257).
-    let acc = [''];
-    // Bash drops empty results, but only when the *first* top-level group is a
-    // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop
-    // is on the final strings, so it is applied to whichever `combine` produces
-    // them (the one with no brace set left in the tail).
-    let dropEmpties = false;
-    let firstGroup = true;
-    for (;;) {
-        const m = balanced('{', '}', str);
-        // No brace set left: the rest of the string is literal.
-        if (!m) {
-            return combine(acc, str, [''], max, maxLength, dropEmpties);
-        }
-        // no need to expand pre, since it is guaranteed to be free of brace-sets
-        const pre = m.pre;
-        if (/\$$/.test(pre)) {
-            acc = combine(acc, pre + '{' + m.body + '}', [''], max, maxLength, dropEmpties && !m.post.length);
-            firstGroup = false;
-            if (!m.post.length)
-                break;
-            str = m.post;
-            continue;
-        }
-        const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        const isSequence = isNumericSequence || isAlphaSequence;
-        const isOptions = m.body.indexOf(',') >= 0;
-        if (!isSequence && !isOptions) {
-            // {a},b}
-            if (m.post.match(/,(?!,).*\}/)) {
-                str = m.pre + '{' + m.body + escClose + m.post;
-                isTop = true;
-                continue;
-            }
-            // Nothing here expands, so the whole remaining string is literal.
-            return combine(acc, pre + '{' + m.body + '}' + m.post, [''], max, maxLength, dropEmpties);
-        }
-        if (firstGroup) {
-            dropEmpties = isTop && !isSequence;
-            firstGroup = false;
-        }
-        let values;
-        if (isSequence) {
-            values = expandSequence(m.body, isAlphaSequence, max, maxLength);
-        }
-        else {
-            let n = parseCommaParts(m.body);
-            if (n.length === 1 && n[0] !== undefined) {
-                // x{{a,b}}y ==> x{a}y x{b}y
-                n = expand_(n[0], max, maxLength, false).map(embrace);
-                //XXX is this necessary? Can't seem to hit it in tests.
-                /* c8 ignore start */
-                if (n.length === 1) {
-                    acc = combine(acc, pre + n[0], [''], max, maxLength, dropEmpties && !m.post.length);
-                    if (!m.post.length)
-                        break;
-                    str = m.post;
-                    continue;
-                }
-                /* c8 ignore stop */
-            }
-            // Values that `combine` is going to drop as empty produce no result, so
-            // they must not count against `max` - otherwise `{a,,b}` with `max: 2`
-            // would stop at `['a', '']` and yield one result instead of two. Skipping
-            // them outright keeps `values` bounded while leaving `max` a bound on
-            // *kept* results.
-            let dropsEmpties = dropEmpties && !m.post.length && !pre;
-            for (let d = 0; dropsEmpties && d < acc.length; d++) {
-                if (acc[d]) {
-                    dropsEmpties = false;
-                }
-            }
-            values = [];
-            let valuesLength = 0;
-            outer: for (let j = 0; j < n.length; j++) {
-                const expanded = expand_(n[j], max, maxLength, false);
-                for (let k = 0; k < expanded.length; k++) {
-                    const v = expanded[k];
-                    if (dropsEmpties && !v)
-                        continue;
-                    if (values.length >= max || valuesLength + v.length > maxLength) {
-                        break outer;
-                    }
-                    values.push(v);
-                    valuesLength += v.length;
-                }
-            }
-        }
-        acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
-        if (!m.post.length)
-            break;
-        str = m.post;
-    }
-    return acc;
+function decompress(src, maxSize) {
+  let dst, size;
+  if (maxSize === void 0) {
+    maxSize = decompressBound(src);
+  }
+  dst = makeBuffer(maxSize);
+  size = decompressFrame(src, dst);
+  if (size !== maxSize) {
+    dst = sliceArray(dst, 0, size);
+  }
+  return dst;
 }
 
-const MAX_PATTERN_LENGTH = 1024 * 64;
-const assertValidPattern = (pattern) => {
-    if (typeof pattern !== 'string') {
-        throw new TypeError('invalid pattern');
+// src/utils/RangeList.ts
+var RangeList = class {
+  ranges = [];
+  /**
+   * Add a range to the list. If it overlaps with existing ranges,
+   * it will split them and increment reference counts accordingly.
+   */
+  add(start, end) {
+    if (end <= start) {
+      throw new TypeError("End must be greater than start");
     }
-    if (pattern.length > MAX_PATTERN_LENGTH) {
-        throw new TypeError('pattern is too long');
+    const overlappingRanges = [];
+    for (let i = 0; i < this.ranges.length; i++) {
+      const range2 = this.ranges[i];
+      if (start < range2.end && end > range2.start) {
+        overlappingRanges.push({ index: i, range: range2 });
+      }
+      if (range2.data !== null) {
+        throw new Error("Overlapping range already has data");
+      }
     }
-};
-
-// translate the various posix character classes into unicode properties
-// this works across all unicode locales
-// { <posix class>: [<translation>, /u flag required, negated]
-const posixClasses = {
-    '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}', true],
-    '[:alpha:]': ['\\p{L}\\p{Nl}', true],
-    '[:ascii:]': ['\\x' + '00-\\x' + '7f', false],
-    '[:blank:]': ['\\p{Zs}\\t', true],
-    '[:cntrl:]': ['\\p{Cc}', true],
-    '[:digit:]': ['\\p{Nd}', true],
-    '[:graph:]': ['\\p{Z}\\p{C}', true, true],
-    '[:lower:]': ['\\p{Ll}', true],
-    '[:print:]': ['\\p{C}', true],
-    '[:punct:]': ['\\p{P}', true],
-    '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f', true],
-    '[:upper:]': ['\\p{Lu}', true],
-    '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}', true],
-    '[:xdigit:]': ['A-Fa-f0-9', false],
-};
-// only need to escape a few things inside of brace expressions
-// escapes: [ \ ] -
-const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
-// escape all regexp magic characters
-const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
-// everything has already been escaped, we just have to join
-const rangesToString = (ranges) => ranges.join('');
-// takes a glob string at a posix brace expression, and returns
-// an equivalent regular expression source, and boolean indicating
-// whether the /u flag needs to be applied, and the number of chars
-// consumed to parse the character class.
-// This also removes out of order ranges, and returns ($.) if the
-// entire class just no good.
-const parseClass = (glob, position) => {
-    const pos = position;
-    /* c8 ignore start */
-    if (glob.charAt(pos) !== '[') {
-        throw new Error('not in a brace expression');
+    if (overlappingRanges.length === 0) {
+      this.ranges.push({ start, end, refCount: 1, data: null });
+      this.ranges.sort((a, b) => a.start - b.start);
+      return;
     }
-    /* c8 ignore stop */
-    const ranges = [];
-    const negs = [];
-    let i = pos + 1;
-    let sawStart = false;
-    let uflag = false;
-    let escaping = false;
-    let negate = false;
-    let endPos = pos;
-    let rangeStart = '';
-    WHILE: while (i < glob.length) {
-        const c = glob.charAt(i);
-        if ((c === '!' || c === '^') && i === pos + 1) {
-            negate = true;
-            i++;
-            continue;
-        }
-        if (c === ']' && sawStart && !escaping) {
-            endPos = i + 1;
-            break;
-        }
-        sawStart = true;
-        if (c === '\\') {
-            if (!escaping) {
-                escaping = true;
-                i++;
-                continue;
-            }
-            // escaped \ char, fall through and treat like normal char
-        }
-        if (c === '[' && !escaping) {
-            // either a posix class, a collation equivalent, or just a [
-            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
-                if (glob.startsWith(cls, i)) {
-                    // invalid, [a-[] is fine, but not [a-[:alpha]]
-                    if (rangeStart) {
-                        return ['$.', false, glob.length - pos, true];
-                    }
-                    i += cls.length;
-                    if (neg)
-                        negs.push(unip);
-                    else
-                        ranges.push(unip);
-                    uflag = uflag || u;
-                    continue WHILE;
-                }
-            }
-        }
-        // now it's just a normal character, effectively
-        escaping = false;
-        if (rangeStart) {
-            // throw this range away if it's not valid, but others
-            // can still match.
-            if (c > rangeStart) {
-                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
-            }
-            else if (c === rangeStart) {
-                ranges.push(braceEscape(c));
-            }
-            rangeStart = '';
-            i++;
-            continue;
-        }
-        // now might be the start of a range.
-        // can be either c-d or c-] or c<more...>] or c] at this point
-        if (glob.startsWith('-]', i + 1)) {
-            ranges.push(braceEscape(c + '-'));
-            i += 2;
-            continue;
-        }
-        if (glob.startsWith('-', i + 1)) {
-            rangeStart = c;
-            i += 2;
-            continue;
-        }
-        // not the start of a range, just a single character
-        ranges.push(braceEscape(c));
-        i++;
+    const newRanges = [];
+    let currentPos = start;
+    for (let i = 0; i < overlappingRanges.length; i++) {
+      const { range: range2 } = overlappingRanges[i];
+      if (currentPos < range2.start) {
+        newRanges.push({
+          start: currentPos,
+          end: range2.start,
+          refCount: 1,
+          data: null
+        });
+      } else if (range2.start < currentPos) {
+        newRanges.push({
+          start: range2.start,
+          end: currentPos,
+          refCount: range2.refCount,
+          data: null
+        });
+      }
+      newRanges.push({
+        start: Math.max(currentPos, range2.start),
+        end: Math.min(end, range2.end),
+        refCount: range2.refCount + 1,
+        data: null
+      });
+      if (range2.end > end) {
+        newRanges.push({
+          start: end,
+          end: range2.end,
+          refCount: range2.refCount,
+          data: null
+        });
+      }
+      currentPos = Math.max(currentPos, range2.end);
     }
-    if (endPos < i) {
-        // didn't see the end of the class, not a valid class,
-        // but might still be valid as a literal match.
-        return ['', false, 0, false];
+    if (currentPos < end) {
+      newRanges.push({
+        start: currentPos,
+        end,
+        refCount: 1,
+        data: null
+      });
     }
-    // if we got no ranges and no negates, then we have a range that
-    // cannot possibly match anything, and that poisons the whole glob
-    if (!ranges.length && !negs.length) {
-        return ['$.', false, glob.length - pos, true];
+    const firstIndex = overlappingRanges[0].index;
+    const lastIndex = overlappingRanges[overlappingRanges.length - 1].index;
+    this.ranges.splice(firstIndex, lastIndex - firstIndex + 1, ...newRanges);
+    this.ranges.sort((a, b) => a.start - b.start);
+  }
+  /**
+   * Remove a range from the list. The range must start and end at existing boundaries.
+   */
+  remove(start, end) {
+    if (end <= start) {
+      throw new TypeError("End must be greater than start");
     }
-    // if we got one positive range, and it's a single character, then that's
-    // not actually a magic pattern, it's just that one literal character.
-    // we should not treat that as "magic", we should just return the literal
-    // character. [_] is a perfectly valid way to escape glob magic chars.
-    if (negs.length === 0 &&
-        ranges.length === 1 &&
-        /^\\?.$/.test(ranges[0]) &&
-        !negate) {
-        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
-        return [regexpEscape(r), false, endPos - pos, false];
+    const affectedRanges = [];
+    for (let i = 0; i < this.ranges.length; i++) {
+      const range2 = this.ranges[i];
+      if (start < range2.end && end > range2.start) {
+        affectedRanges.push({ index: i, range: range2 });
+      }
     }
-    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
-    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
-    const comb = ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'
-        : ranges.length ? sranges
-            : snegs;
-    return [comb, uflag, endPos - pos, true];
-};
-
-/**
- * Un-escape a string that has been escaped with {@link escape}.
- *
- * If the {@link MinimatchOptions.windowsPathsNoEscape} option is used, then
- * square-bracket escapes are removed, but not backslash escapes.
- *
- * For example, it will turn the string `'[*]'` into `*`, but it will not
- * turn `'\\*'` into `'*'`, because `\` is a path separator in
- * `windowsPathsNoEscape` mode.
- *
- * When `windowsPathsNoEscape` is not set, then both square-bracket escapes and
- * backslash escapes are removed.
- *
- * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
- * or unescaped.
- *
- * When `magicalBraces` is not set, escapes of braces (`{` and `}`) will not be
- * unescaped.
- */
-const unescape$1 = (s, { windowsPathsNoEscape = false, magicalBraces = true, } = {}) => {
-    if (magicalBraces) {
-        return windowsPathsNoEscape ?
-            s.replace(/\[([^/\\])\]/g, '$1')
-            : s
-                .replace(/((?!\\).|^)\[([^/\\])\]/g, '$1$2')
-                .replace(/\\([^/])/g, '$1');
+    if (affectedRanges.length === 0) {
+      throw new Error("No ranges found to remove");
     }
-    return windowsPathsNoEscape ?
-        s.replace(/\[([^/\\{}])\]/g, '$1')
-        : s
-            .replace(/((?!\\).|^)\[([^/\\{}])\]/g, '$1$2')
-            .replace(/\\([^/{}])/g, '$1');
+    if (start !== affectedRanges[0].range.start || end !== affectedRanges[affectedRanges.length - 1].range.end) {
+      throw new Error("Range boundaries must match existing boundaries");
+    }
+    for (let i = 0; i < affectedRanges.length; i++) {
+      const { range: range2 } = affectedRanges[i];
+      range2.refCount--;
+    }
+    this.ranges = this.ranges.filter((range2) => range2.refCount > 0);
+  }
+  /**
+   * Get all ranges within the specified boundaries.
+   */
+  getRanges(start, end) {
+    if (end <= start) {
+      throw new TypeError("End must be greater than start");
+    }
+    return this.ranges.filter((range2) => start < range2.end && end > range2.start);
+  }
+  /**
+   * Get all ranges in the list
+   */
+  getAllRanges() {
+    return [...this.ranges];
+  }
 };
 
-// parse a single path portion
-var _a;
-const types$2 = new Set(['!', '?', '+', '*', '@']);
-const isExtglobType = (c) => types$2.has(c);
-const isExtglobAST = (c) => isExtglobType(c.type);
-// Map of which extglob types can adopt the children of a nested extglob
-//
-// anything but ! can adopt a matching type:
-// +(a|+(b|c)|d) => +(a|b|c|d)
-// *(a|*(b|c)|d) => *(a|b|c|d)
-// @(a|@(b|c)|d) => @(a|b|c|d)
-// ?(a|?(b|c)|d) => ?(a|b|c|d)
-//
-// * can adopt anything, because 0 or repetition is allowed
-// *(a|?(b|c)|d) => *(a|b|c|d)
-// *(a|+(b|c)|d) => *(a|b|c|d)
-// *(a|@(b|c)|d) => *(a|b|c|d)
-//
-// + can adopt @, because 1 or repetition is allowed
-// +(a|@(b|c)|d) => +(a|b|c|d)
-//
-// + and @ CANNOT adopt *, because 0 would be allowed
-// +(a|*(b|c)|d) => would match "", on *(b|c)
-// @(a|*(b|c)|d) => would match "", on *(b|c)
-//
-// + and @ CANNOT adopt ?, because 0 would be allowed
-// +(a|?(b|c)|d) => would match "", on ?(b|c)
-// @(a|?(b|c)|d) => would match "", on ?(b|c)
-//
-// ? can adopt @, because 0 or 1 is allowed
-// ?(a|@(b|c)|d) => ?(a|b|c|d)
-//
-// ? and @ CANNOT adopt * or +, because >1 would be allowed
-// ?(a|*(b|c)|d) => would match bbb on *(b|c)
-// @(a|*(b|c)|d) => would match bbb on *(b|c)
-// ?(a|+(b|c)|d) => would match bbb on +(b|c)
-// @(a|+(b|c)|d) => would match bbb on +(b|c)
-//
+// src/utils/XetBlob.ts
+var JWT_SAFETY_PERIOD = 6e4;
+var JWT_CACHE_SIZE = 1e3;
+var compressionSchemeLabels = {
+  [0 /* None */]: "None",
+  [1 /* LZ4 */]: "LZ4",
+  [2 /* ByteGroupingLZ4 */]: "ByteGroupingLZ4"
+};
+var XET_CHUNK_HEADER_BYTES = 8;
+var XetBlob = class extends Blob {
+  fetch;
+  accessToken;
+  refreshUrl;
+  reconstructionUrl;
+  hash;
+  start = 0;
+  end = 0;
+  internalLogging = false;
+  reconstructionInfo;
+  listener;
+  constructor(params) {
+    super([]);
+    this.fetch = params.fetch ?? fetch.bind(globalThis);
+    this.accessToken = checkCredentials(params);
+    this.refreshUrl = params.refreshUrl;
+    this.end = params.size;
+    this.reconstructionUrl = params.reconstructionUrl;
+    this.hash = params.hash;
+    this.listener = params.listener;
+    this.internalLogging = params.internalLogging ?? false;
+    this.refreshUrl;
+  }
+  get size() {
+    return this.end - this.start;
+  }
+  #clone() {
+    const blob = new XetBlob({
+      fetch: this.fetch,
+      hash: this.hash,
+      refreshUrl: this.refreshUrl,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      reconstructionUrl: this.reconstructionUrl,
+      size: this.size
+    });
+    blob.accessToken = this.accessToken;
+    blob.start = this.start;
+    blob.end = this.end;
+    blob.reconstructionInfo = this.reconstructionInfo;
+    blob.listener = this.listener;
+    blob.internalLogging = this.internalLogging;
+    return blob;
+  }
+  slice(start = 0, end = this.size) {
+    const slice = this.#clone();
+    slice.start = this.start + start;
+    slice.end = Math.min(this.start + end, this.end);
+    if (slice.start !== this.start || slice.end !== this.end) {
+      slice.reconstructionInfo = void 0;
+    }
+    return slice;
+  }
+  #reconstructionInfoPromise;
+  #loadReconstructionInfo() {
+    if (this.#reconstructionInfoPromise) {
+      return this.#reconstructionInfoPromise;
+    }
+    this.#reconstructionInfoPromise = (async () => {
+      const connParams = await getAccessToken(this.accessToken, this.fetch, this.refreshUrl);
+      const resp = await this.fetch(this.reconstructionUrl ?? `${connParams.casUrl}/v1/reconstructions/${this.hash}`, {
+        headers: {
+          Authorization: `Bearer ${connParams.accessToken}`,
+          Range: `bytes=${this.start}-${this.end - 1}`
+        }
+      });
+      if (!resp.ok) {
+        throw await createApiError(resp);
+      }
+      this.reconstructionInfo = await resp.json();
+      return this.reconstructionInfo;
+    })().finally(() => this.#reconstructionInfoPromise = void 0);
+    return this.#reconstructionInfoPromise;
+  }
+  async #fetch() {
+    if (!this.reconstructionInfo) {
+      await this.#loadReconstructionInfo();
+    }
+    const rangeLists = /* @__PURE__ */ new Map();
+    if (!this.reconstructionInfo) {
+      throw new Error("Failed to load reconstruction info");
+    }
+    for (const term of this.reconstructionInfo.terms) {
+      let rangeList = rangeLists.get(term.hash);
+      if (!rangeList) {
+        rangeList = new RangeList();
+        rangeLists.set(term.hash, rangeList);
+      }
+      rangeList.add(term.range.start, term.range.end);
+    }
+    const listener = this.listener;
+    const log = this.internalLogging ? (...args) => console.log(...args) : () => {
+    };
+    async function* readData(reconstructionInfo, customFetch, maxBytes, reloadReconstructionInfo) {
+      let totalBytesRead = 0;
+      let readBytesToSkip = reconstructionInfo.offset_into_first_range;
+      for (const term of reconstructionInfo.terms) {
+        if (totalBytesRead >= maxBytes) {
+          break;
+        }
+        const rangeList = rangeLists.get(term.hash);
+        if (!rangeList) {
+          throw new Error(`Failed to find range list for term ${term.hash}`);
+        }
+        {
+          const termRanges = rangeList.getRanges(term.range.start, term.range.end);
+          if (termRanges.every((range2) => range2.data)) {
+            log("all data available for term", term.hash, readBytesToSkip);
+            rangeLoop:
+              for (const range2 of termRanges) {
+                for (let chunk2 of range2.data) {
+                  if (readBytesToSkip) {
+                    const skipped = Math.min(readBytesToSkip, chunk2.byteLength);
+                    chunk2 = chunk2.slice(skipped);
+                    readBytesToSkip -= skipped;
+                    if (!chunk2.byteLength) {
+                      continue;
+                    }
+                  }
+                  if (chunk2.byteLength > maxBytes - totalBytesRead) {
+                    chunk2 = chunk2.slice(0, maxBytes - totalBytesRead);
+                  }
+                  totalBytesRead += chunk2.byteLength;
+                  yield range2.refCount > 1 ? chunk2.slice() : chunk2;
+                  listener?.({ event: "progress", progress: { read: totalBytesRead, total: maxBytes } });
+                  if (totalBytesRead >= maxBytes) {
+                    break rangeLoop;
+                  }
+                }
+              }
+            rangeList.remove(term.range.start, term.range.end);
+            continue;
+          }
+        }
+        const fetchInfo = reconstructionInfo.fetch_info[term.hash].find(
+          (info) => info.range.start <= term.range.start && info.range.end >= term.range.end
+        );
+        if (!fetchInfo) {
+          throw new Error(
+            `Failed to find fetch info for term ${term.hash} and range ${term.range.start}-${term.range.end}`
+          );
+        }
+        log("term", term);
+        log("fetchinfo", fetchInfo);
+        log("readBytesToSkip", readBytesToSkip);
+        let resp = await customFetch(fetchInfo.url, {
+          headers: {
+            Range: `bytes=${fetchInfo.url_range.start}-${fetchInfo.url_range.end}`
+          }
+        });
+        if (resp.status === 403) {
+          reconstructionInfo = await reloadReconstructionInfo();
+          resp = await customFetch(fetchInfo.url, {
+            headers: {
+              Range: `bytes=${fetchInfo.url_range.start}-${fetchInfo.url_range.end}`
+            }
+          });
+        }
+        if (!resp.ok) {
+          throw await createApiError(resp);
+        }
+        log(
+          "expected content length",
+          resp.headers.get("content-length"),
+          "range",
+          fetchInfo.url_range,
+          resp.headers.get("content-range")
+        );
+        const reader = resp.body?.getReader();
+        if (!reader) {
+          throw new Error("Failed to get reader from response body");
+        }
+        let done = false;
+        let chunkIndex = fetchInfo.range.start;
+        const ranges = rangeList.getRanges(fetchInfo.range.start, fetchInfo.range.end);
+        let leftoverBytes = void 0;
+        let totalFetchBytes = 0;
+        fetchData:
+          while (!done && totalBytesRead < maxBytes) {
+            const result = await reader.read();
+            listener?.({ event: "read" });
+            done = result.done;
+            log("read", result.value?.byteLength, "bytes", "total read", totalBytesRead, "toSkip", readBytesToSkip);
+            if (!result.value) {
+              log("no data in result, cancelled", result);
+              continue;
+            }
+            totalFetchBytes += result.value.byteLength;
+            if (leftoverBytes) {
+              result.value = combineUint8Arrays(leftoverBytes, result.value);
+              leftoverBytes = void 0;
+            }
+            while (totalBytesRead < maxBytes && result.value?.byteLength) {
+              if (result.value.byteLength < 8) {
+                leftoverBytes = result.value;
+                continue fetchData;
+              }
+              const header = new DataView(result.value.buffer, result.value.byteOffset, XET_CHUNK_HEADER_BYTES);
+              const chunkHeader = {
+                version: header.getUint8(0),
+                compressed_length: header.getUint8(1) | header.getUint8(2) << 8 | header.getUint8(3) << 16,
+                compression_scheme: header.getUint8(4),
+                uncompressed_length: header.getUint8(5) | header.getUint8(6) << 8 | header.getUint8(7) << 16
+              };
+              log("chunk header", chunkHeader, "to skip", readBytesToSkip);
+              if (chunkHeader.version !== 0) {
+                throw new Error(`Unsupported chunk version ${chunkHeader.version}`);
+              }
+              if (chunkHeader.compression_scheme !== 0 /* None */ && chunkHeader.compression_scheme !== 1 /* LZ4 */ && chunkHeader.compression_scheme !== 2 /* ByteGroupingLZ4 */) {
+                throw new Error(
+                  `Unsupported compression scheme ${compressionSchemeLabels[chunkHeader.compression_scheme] ?? chunkHeader.compression_scheme}`
+                );
+              }
+              if (result.value.byteLength < chunkHeader.compressed_length + XET_CHUNK_HEADER_BYTES) {
+                leftoverBytes = result.value;
+                continue fetchData;
+              }
+              result.value = result.value.slice(XET_CHUNK_HEADER_BYTES);
+              let uncompressed = chunkHeader.compression_scheme === 1 /* LZ4 */ ? decompress(result.value.slice(0, chunkHeader.compressed_length), chunkHeader.uncompressed_length) : chunkHeader.compression_scheme === 2 /* ByteGroupingLZ4 */ ? bg4_regroup_bytes(
+                decompress(
+                  result.value.slice(0, chunkHeader.compressed_length),
+                  chunkHeader.uncompressed_length
+                )
+              ) : result.value.slice(0, chunkHeader.compressed_length);
+              const range2 = ranges.find((range3) => chunkIndex >= range3.start && chunkIndex < range3.end);
+              const shouldYield = chunkIndex >= term.range.start && chunkIndex < term.range.end;
+              const minRefCountToStore = shouldYield ? 2 : 1;
+              let stored = false;
+              if (range2 && range2.refCount >= minRefCountToStore) {
+                range2.data ??= [];
+                range2.data.push(uncompressed);
+                stored = true;
+              }
+              if (shouldYield) {
+                if (readBytesToSkip) {
+                  const skipped = Math.min(readBytesToSkip, uncompressed.byteLength);
+                  uncompressed = uncompressed.slice(readBytesToSkip);
+                  readBytesToSkip -= skipped;
+                }
+                if (uncompressed.byteLength > maxBytes - totalBytesRead) {
+                  uncompressed = uncompressed.slice(0, maxBytes - totalBytesRead);
+                }
+                if (uncompressed.byteLength) {
+                  log(
+                    "yield",
+                    uncompressed.byteLength,
+                    "bytes",
+                    result.value.byteLength,
+                    "total read",
+                    totalBytesRead,
+                    stored
+                  );
+                  totalBytesRead += uncompressed.byteLength;
+                  yield stored ? uncompressed.slice() : uncompressed;
+                  listener?.({ event: "progress", progress: { read: totalBytesRead, total: maxBytes } });
+                }
+              }
+              chunkIndex++;
+              result.value = result.value.slice(chunkHeader.compressed_length);
+            }
+          }
+        if (done && totalBytesRead < maxBytes && totalFetchBytes < fetchInfo.url_range.end - fetchInfo.url_range.start + 1) {
+          log("done", done, "total read", totalBytesRead, maxBytes, totalFetchBytes);
+          log("failed to fetch all data for term", term.hash);
+          throw new Error(
+            `Failed to fetch all data for term ${term.hash}, fetched ${totalFetchBytes} bytes out of ${fetchInfo.url_range.end - fetchInfo.url_range.start + 1}`
+          );
+        }
+        log("done", done, "total read", totalBytesRead, maxBytes, totalFetchBytes);
+        log("cancel reader");
+        await reader.cancel();
+      }
+    }
+    const iterator = readData(
+      this.reconstructionInfo,
+      this.fetch,
+      this.end - this.start,
+      this.#loadReconstructionInfo.bind(this)
+    );
+    return new ReadableStream(
+      {
+        // todo: when Safari supports it, type controller as ReadableByteStreamController
+        async pull(controller) {
+          const result = await iterator.next();
+          if (result.value) {
+            controller.enqueue(result.value);
+          }
+          if (result.done) {
+            controller.close();
+          }
+        },
+        type: "bytes"
+        // todo: when Safari supports it, add autoAllocateChunkSize param
+      },
+      // todo : use ByteLengthQueuingStrategy when there's good support for it, currently in Node.js it fails due to size being a function
+      {
+        highWaterMark: 1e3
+        // 1_000 chunks for ~1MB of RAM
+      }
+    );
+  }
+  async arrayBuffer() {
+    const result = await this.#fetch();
+    return new Response(result).arrayBuffer();
+  }
+  async text() {
+    const result = await this.#fetch();
+    return new Response(result).text();
+  }
+  async response() {
+    const result = await this.#fetch();
+    return new Response(result);
+  }
+  stream() {
+    const stream = new TransformStream();
+    this.#fetch().then((response) => response.pipeThrough(stream)).catch((error) => stream.writable.abort(error.message));
+    return stream.readable;
+  }
+};
+var jwtPromises = /* @__PURE__ */ new Map();
+var jwts = /* @__PURE__ */ new Map();
+function cacheKey(params) {
+  return JSON.stringify([params.refreshUrl, params.initialAccessToken]);
+}
+function bg4_regroup_bytes(bytes) {
+  const split = Math.floor(bytes.byteLength / 4);
+  const rem = bytes.byteLength % 4;
+  const g1_pos = split + (rem >= 1 ? 1 : 0);
+  const g2_pos = g1_pos + split + (rem >= 2 ? 1 : 0);
+  const g3_pos = g2_pos + split + (rem == 3 ? 1 : 0);
+  const ret = new Uint8Array(bytes.byteLength);
+  for (let i = 0, j = 0; i < bytes.byteLength; i += 4, j++) {
+    ret[i] = bytes[j];
+  }
+  for (let i = 1, j = g1_pos; i < bytes.byteLength; i += 4, j++) {
+    ret[i] = bytes[j];
+  }
+  for (let i = 2, j = g2_pos; i < bytes.byteLength; i += 4, j++) {
+    ret[i] = bytes[j];
+  }
+  for (let i = 3, j = g3_pos; i < bytes.byteLength; i += 4, j++) {
+    ret[i] = bytes[j];
+  }
+  return ret;
+}
+async function getAccessToken(initialAccessToken, customFetch, refreshUrl) {
+  const key = cacheKey({ refreshUrl, initialAccessToken });
+  const jwt = jwts.get(key);
+  if (jwt && jwt.expiresAt > new Date(Date.now() + JWT_SAFETY_PERIOD)) {
+    return { accessToken: jwt.accessToken, casUrl: jwt.casUrl };
+  }
+  const existingPromise = jwtPromises.get(key);
+  if (existingPromise) {
+    return existingPromise;
+  }
+  const promise = (async () => {
+    const resp = await customFetch(refreshUrl, {
+      headers: {
+        ...initialAccessToken ? {
+          Authorization: `Bearer ${initialAccessToken}`
+        } : {}
+      }
+    });
+    if (!resp.ok) {
+      throw new Error(`Failed to get JWT token: ${resp.status} ${await resp.text()}`);
+    }
+    const json = await resp.json();
+    const jwt2 = {
+      accessToken: json.accessToken,
+      expiresAt: new Date(json.exp * 1e3),
+      casUrl: json.casUrl
+    };
+    jwtPromises.delete(key);
+    for (const [key2, value] of jwts.entries()) {
+      if (value.expiresAt < new Date(Date.now() + JWT_SAFETY_PERIOD)) {
+        jwts.delete(key2);
+      } else {
+        break;
+      }
+    }
+    if (jwts.size >= JWT_CACHE_SIZE) {
+      const keyToDelete = jwts.keys().next().value;
+      if (keyToDelete) {
+        jwts.delete(keyToDelete);
+      }
+    }
+    jwts.set(key, jwt2);
+    return {
+      accessToken: json.accessToken,
+      casUrl: json.casUrl
+    };
+  })();
+  jwtPromises.set(key, promise);
+  return promise;
+}
+
+// src/utils/WebBlob.ts
+var WebBlob = class extends Blob {
+  static async create(url, opts) {
+    const customFetch = opts?.fetch ?? fetch;
+    const response = await customFetch(url, {
+      method: "HEAD",
+      ...opts?.accessToken && {
+        headers: {
+          Authorization: `Bearer ${opts.accessToken}`
+        }
+      }
+    });
+    const size = Number(response.headers.get("content-length"));
+    const contentType = response.headers.get("content-type") || "";
+    const supportRange = response.headers.get("accept-ranges") === "bytes";
+    if (!supportRange || size < (opts?.cacheBelow ?? 1e6)) {
+      return await (await customFetch(url)).blob();
+    }
+    return new WebBlob(url, 0, size, contentType, true, customFetch, opts?.accessToken);
+  }
+  url;
+  start;
+  end;
+  contentType;
+  full;
+  fetch;
+  accessToken;
+  constructor(url, start, end, contentType, full, customFetch, accessToken) {
+    super([]);
+    this.url = url;
+    this.start = start;
+    this.end = end;
+    this.contentType = contentType;
+    this.full = full;
+    this.fetch = customFetch;
+    this.accessToken = accessToken;
+  }
+  get size() {
+    return this.end - this.start;
+  }
+  get type() {
+    return this.contentType;
+  }
+  slice(start = 0, end = this.size) {
+    const slice = new WebBlob(
+      this.url,
+      this.start + start,
+      Math.min(this.start + end, this.end),
+      this.contentType,
+      start === 0 && end === this.size ? this.full : false,
+      this.fetch,
+      this.accessToken
+    );
+    return slice;
+  }
+  async arrayBuffer() {
+    const result = await this.fetchRange();
+    return result.arrayBuffer();
+  }
+  async text() {
+    const result = await this.fetchRange();
+    return result.text();
+  }
+  stream() {
+    const stream = new TransformStream();
+    this.fetchRange().then((response) => response.body?.pipeThrough(stream)).catch((error) => stream.writable.abort(error.message));
+    return stream.readable;
+  }
+  fetchRange() {
+    const fetch2 = this.fetch;
+    if (this.full) {
+      return fetch2(this.url, {
+        ...this.accessToken && {
+          headers: {
+            Authorization: `Bearer ${this.accessToken}`
+          }
+        }
+      }).then((resp) => resp.ok ? resp : createApiError(resp));
+    }
+    return fetch2(this.url, {
+      headers: {
+        Range: `bytes=${this.start}-${this.end - 1}`,
+        ...this.accessToken && { Authorization: `Bearer ${this.accessToken}` }
+      }
+    }).then((resp) => resp.ok ? resp : createApiError(resp));
+  }
+};
+
+// src/utils/parseLinkHeader.ts
+function parseLinkHeader(header) {
+  const regex = /<(https?:[/][/][^>]+)>;\s+rel="([^"]+)"/g;
+  return Object.fromEntries([...header.matchAll(regex)].map(([, url, rel]) => [rel, url]));
+}
+
+// src/lib/file-download-info.ts
+async function fileDownloadInfo(params) {
+  const accessToken = checkCredentials(params);
+  const repoId = toRepoId(params.repo);
+  const hubUrl = params.hubUrl ?? HUB_URL;
+  const url = `${hubUrl}/${repoId.type === "model" ? "" : `${repoId.type}s/`}${repoId.name}/${params.raw ? "raw" : "resolve"}/${encodeURIComponent(params.revision ?? "main")}/${params.path}` + (params.noContentDisposition ? "?noContentDisposition=1" : "");
+  const resp = await (params.fetch ?? fetch)(url, {
+    method: "GET",
+    headers: {
+      ...accessToken && {
+        Authorization: `Bearer ${accessToken}`
+      },
+      Range: "bytes=0-0",
+      Accept: "application/vnd.xet-fileinfo+json, */*"
+    }
+  });
+  if (resp.status === 404 && resp.headers.get("X-Error-Code") === "EntryNotFound") {
+    return null;
+  }
+  if (!resp.ok) {
+    throw await createApiError(resp);
+  }
+  let size;
+  let xetInfo;
+  if (resp.headers.get("Content-Type")?.includes("application/vnd.xet-fileinfo+json")) {
+    size = parseInt(resp.headers.get("X-Linked-Size") ?? "invalid");
+    if (isNaN(size)) {
+      throw new InvalidApiResponseFormatError("Invalid file size received in X-Linked-Size header");
+    }
+    const hash2 = resp.headers.get("X-Xet-Hash");
+    const links = parseLinkHeader(resp.headers.get("Link") ?? "");
+    const reconstructionUrl = (() => {
+      try {
+        return new URL(links["xet-reconstruction-info"]);
+      } catch {
+        return null;
+      }
+    })();
+    const refreshUrl = (() => {
+      try {
+        return new URL(links["xet-auth"]);
+      } catch {
+        return null;
+      }
+    })();
+    if (!hash2) {
+      throw new InvalidApiResponseFormatError("No hash received in X-Xet-Hash header");
+    }
+    if (!reconstructionUrl || !refreshUrl) {
+      throw new InvalidApiResponseFormatError("No xet-reconstruction-info or xet-auth link header");
+    }
+    xetInfo = {
+      hash: hash2,
+      refreshUrl,
+      reconstructionUrl
+    };
+  }
+  if (size === void 0 || isNaN(size)) {
+    const contentRangeHeader = resp.headers.get("content-range");
+    if (!contentRangeHeader) {
+      throw new InvalidApiResponseFormatError("Expected size information");
+    }
+    const [, parsedSize] = contentRangeHeader.split("/");
+    size = parseInt(parsedSize);
+    if (isNaN(size)) {
+      throw new InvalidApiResponseFormatError("Invalid file size received");
+    }
+  }
+  const etag = resp.headers.get("X-Linked-ETag") ?? resp.headers.get("ETag") ?? void 0;
+  if (!etag) {
+    throw new InvalidApiResponseFormatError("Expected ETag");
+  }
+  return {
+    etag,
+    size,
+    xet: xetInfo,
+    // Cannot use resp.url in case it's a S3 url and the user adds an Authorization header to it.
+    url: resp.url && (new URL(resp.url).origin === new URL(hubUrl).origin || resp.headers.get("X-Cache")?.endsWith(" cloudfront")) ? resp.url : url
+  };
+}
+
+// src/lib/download-file.ts
+async function downloadFile(params) {
+  const accessToken = checkCredentials(params);
+  const info = params.downloadInfo ?? await fileDownloadInfo({
+    accessToken,
+    repo: params.repo,
+    path: params.path,
+    revision: params.revision,
+    hubUrl: params.hubUrl,
+    fetch: params.fetch,
+    raw: params.raw
+  });
+  if (!info) {
+    return null;
+  }
+  if (info.xet && params.xet) {
+    return new XetBlob({
+      refreshUrl: info.xet.refreshUrl.href,
+      reconstructionUrl: info.xet.reconstructionUrl.href,
+      fetch: params.fetch,
+      accessToken,
+      size: info.size
+    });
+  }
+  return new WebBlob(new URL(info.url), 0, info.size, "", true, params.fetch ?? fetch, accessToken);
+}
+
+// src/lib/list-files.ts
+async function* listFiles(params) {
+  const accessToken = checkCredentials(params);
+  const repoId = toRepoId(params.repo);
+  let url = `${params.hubUrl || HUB_URL}/api/${repoId.type}s/${repoId.name}/tree/${params.revision || "main"}${params.path ? "/" + params.path : ""}?recursive=${!!params.recursive}&expand=${!!params.expand}`;
+  while (url) {
+    const res = await (params.fetch ?? fetch)(url, {
+      headers: {
+        accept: "application/json",
+        ...accessToken ? { Authorization: `Bearer ${accessToken}` } : void 0
+      }
+    });
+    if (!res.ok) {
+      throw await createApiError(res);
+    }
+    const items = await res.json();
+    for (const item of items) {
+      yield item;
+    }
+    const linkHeader = res.headers.get("Link");
+    url = linkHeader ? parseLinkHeader(linkHeader).next : void 0;
+  }
+}
+
+const DIR_BASED_ENGINES = new Set(["exllamav3", "mlx-lm"]);
+const FLAG_BASED_ENGINE_ARGS = {
+    "llama.cpp": "--chat-template-file",
+    sglang: "--chat-template",
+    vllm: "--chat-template"
+};
+function getChatTemplateLocalPath(targetDirectory) {
+    return path$1.join(targetDirectory, CHAT_TEMPLATE_LOCAL_FILE_NAME);
+}
+async function fetchTemplateContent({ huggingFaceToken, override }) {
+    const accessToken = huggingFaceToken ?? process.env.HF_TOKEN ?? undefined;
+    const filePath = override.filePath || CHAT_TEMPLATE_DEFAULT_FILE_PATH;
+    const blob = await downloadFile({
+        accessToken,
+        path: filePath,
+        repo: override.repo
+    });
+    if (!blob) {
+        throw new Error(`Chat template file not found: ${override.repo}/${filePath}`);
+    }
+    const content = await blob.text();
+    if (!content.trim()) {
+        throw new Error(`Chat template file is empty: ${override.repo}/${filePath}`);
+    }
+    return content;
+}
+/**
+ * Materializes the model's chat template override into the model directory:
+ * - Always writes the canonical copy for flag-based engines.
+ * - For engines that read the model directory (exllamav3, mlx-lm), also writes
+ *   the transformers-style `chat_template.jinja` drop-in.
+ * - When no override is configured, removes any previously materialized files,
+ *   restoring the model repo's own `chat_template.jinja` if we replaced it.
+ */
+async function materializeChatTemplate({ engine, huggingFaceToken, model, targetDirectory }) {
+    const override = model.chatTemplate ?? null;
+    const canonicalPath = getChatTemplateLocalPath(targetDirectory);
+    const dropInPath = path$1.join(targetDirectory, CHAT_TEMPLATE_DEFAULT_FILE_PATH);
+    if (!override) {
+        const markerPath = `${canonicalPath}.override`;
+        if (require$$3$4.existsSync(markerPath)) {
+            await require$$0$m.rm(dropInPath, { force: true });
+            await require$$0$m.rm(markerPath, { force: true });
+            if (model.source.type === "huggingface") {
+                await restoreOriginalTemplate({
+                    huggingFaceToken,
+                    modelSlug: model.source.slug,
+                    targetDirectory
+                });
+            }
+        }
+        await require$$0$m.rm(canonicalPath, { force: true });
+        return;
+    }
+    const content = override.type === "inline"
+        ? override.content
+        : await fetchTemplateContent({ huggingFaceToken, override });
+    await require$$0$m.mkdir(targetDirectory, { recursive: true });
+    await require$$0$m.writeFile(canonicalPath, content, "utf8");
+    if (DIR_BASED_ENGINES.has(engine)) {
+        await require$$0$m.writeFile(dropInPath, content, "utf8");
+        await require$$0$m.writeFile(`${canonicalPath}.override`, "1", "utf8");
+    }
+}
+async function restoreOriginalTemplate({ huggingFaceToken, modelSlug, targetDirectory }) {
+    const accessToken = huggingFaceToken ?? process.env.HF_TOKEN ?? undefined;
+    try {
+        const blob = await downloadFile({
+            accessToken,
+            path: CHAT_TEMPLATE_DEFAULT_FILE_PATH,
+            repo: modelSlug.split(":")[0].split("@")[0]
+        });
+        if (blob) {
+            const content = await blob.text();
+            if (content.trim()) {
+                await require$$0$m.writeFile(path$1.join(targetDirectory, CHAT_TEMPLATE_DEFAULT_FILE_PATH), content, "utf8");
+            }
+        }
+    }
+    catch (error) {
+        console.warn("[chatTemplate] Failed to restore original chat_template.jinja after override removal:", asError(error).message);
+    }
+}
+/**
+ * CLI arguments applying the materialized chat template for flag-based engines.
+ * Returns an empty array when no override exists, the engine applies templates
+ * from the model directory, or the engine does not support overrides.
+ */
+async function getChatTemplateEngineArgs({ engine, model, targetDirectory }) {
+    if (!model.chatTemplate)
+        return [];
+    const flag = FLAG_BASED_ENGINE_ARGS[engine];
+    if (!flag) {
+        if (engine === "tensorrt-llm") {
+            console.warn("[chatTemplate] TensorRT-LLM does not support chat template overrides; ignoring");
+        }
+        return [];
+    }
+    const templatePath = getChatTemplateLocalPath(targetDirectory);
+    if (!require$$3$4.existsSync(templatePath)) {
+        console.warn(`[chatTemplate] Template file missing for ${engine}; continuing with embedded template`);
+        return [];
+    }
+    return [flag, templatePath];
+}
+/**
+ * Post-start verification for llama.cpp: compares the template the server
+ * reports via `/props` against the materialized override file. Returns a
+ * warning message on mismatch, or null when the template applied cleanly
+ * (or verification is not applicable).
+ */
+async function verifyEngineChatTemplate({ engine, enginePort, logger, model, targetDirectory }) {
+    if (!model.chatTemplate || engine !== "llama.cpp")
+        return null;
+    try {
+        const templatePath = getChatTemplateLocalPath(targetDirectory);
+        if (!require$$3$4.existsSync(templatePath)) {
+            return "Chat template override file missing on disk";
+        }
+        const [propsResponse, expected] = await Promise.all([
+            fetch(`http://localhost:${enginePort}/props`, {
+                signal: AbortSignal.timeout(5000)
+            }),
+            require$$0$m.readFile(templatePath, "utf8")
+        ]);
+        if (!propsResponse.ok) {
+            return `Chat template verification unavailable: /props returned ${propsResponse.status}`;
+        }
+        const props = (await propsResponse.json());
+        const served = typeof props.chat_template === "string" ? props.chat_template.trim() : "";
+        if (served !== expected.trim()) {
+            return "Chat template override did not apply: served template differs from configured template";
+        }
+        return null;
+    }
+    catch (error) {
+        logger.warn("Chat template verification failed", {
+            error: asError(error)
+        });
+        return null;
+    }
+}
+
+const SECRET_FLAGS = new Set([
+    "api-key",
+    "auth-token",
+    "hf-token",
+    "key",
+    "password",
+    "secret",
+    "token"
+]);
+function redactSecretArgs(args) {
+    return args.map((arg, index) => {
+        const equalsIndex = arg.indexOf("=");
+        if (arg.startsWith("--") && equalsIndex > 0) {
+            const flag = arg.slice(2, equalsIndex);
+            if (SECRET_FLAGS.has(flag)) {
+                return `${arg.slice(0, equalsIndex + 1)}***`;
+            }
+        }
+        const previous = args[index - 1];
+        if (previous &&
+            previous.startsWith("--") &&
+            !previous.includes("=") &&
+            SECRET_FLAGS.has(previous.slice(2))) {
+            return "***";
+        }
+        return arg;
+    });
+}
+async function createEngineProcess({ args, bin, logger }) {
+    logger.info("Starting engine process", {
+        command: { args: redactSecretArgs(args), bin }
+    });
+    const processManager = new ProcessManager({ args, command: bin });
+    await processManager.start();
+    return processManager;
+}
+
+function parseExtraArgs(extraArgs) {
+    if (!Array.isArray(extraArgs) ||
+        !extraArgs.every((value) => typeof value === "string")) {
+        return [];
+    }
+    return extraArgs.flatMap(tokenizeShellLine);
+}
+function tokenizeShellLine(input) {
+    const tokens = [];
+    let buffer = "";
+    let inQuote = null;
+    let hasBuffer = false;
+    for (let index = 0; index < input.length; index += 1) {
+        const char = input[index];
+        if (inQuote) {
+            if (char === inQuote) {
+                inQuote = null;
+            }
+            else {
+                buffer += char;
+            }
+            hasBuffer = true;
+        }
+        else if (char === '"' || char === "'") {
+            inQuote = char;
+            hasBuffer = true;
+        }
+        else if (char === " " || char === "\t") {
+            if (hasBuffer) {
+                tokens.push(buffer);
+                buffer = "";
+                hasBuffer = false;
+            }
+        }
+        else {
+            buffer += char;
+            hasBuffer = true;
+        }
+    }
+    if (hasBuffer) {
+        tokens.push(buffer);
+    }
+    return tokens;
+}
+
+const balanced = (a, b, str) => {
+    const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+    const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+    const r = ma !== null && mb != null && range(ma, mb, str);
+    return (r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + ma.length, r[1]),
+        post: str.slice(r[1] + mb.length),
+    });
+};
+const maybeMatch = (reg, str) => {
+    const m = str.match(reg);
+    return m ? m[0] : null;
+};
+const range = (a, b, str) => {
+    let begs, beg, left, right = undefined, result;
+    let ai = str.indexOf(a);
+    let bi = str.indexOf(b, ai + 1);
+    let i = ai;
+    if (ai >= 0 && bi > 0) {
+        if (a === b) {
+            return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+            if (i === ai) {
+                begs.push(i);
+                ai = str.indexOf(a, i + 1);
+            }
+            else if (begs.length === 1) {
+                const r = begs.pop();
+                if (r !== undefined)
+                    result = [r, bi];
+            }
+            else {
+                beg = begs.pop();
+                if (beg !== undefined && beg < left) {
+                    left = beg;
+                    right = bi;
+                }
+                bi = str.indexOf(b, i + 1);
+            }
+            i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length && right !== undefined) {
+            result = [left, right];
+        }
+    }
+    return result;
+};
+
+const escSlash = '\0SLASH' + Math.random() + '\0';
+const escOpen = '\0OPEN' + Math.random() + '\0';
+const escClose = '\0CLOSE' + Math.random() + '\0';
+const escComma = '\0COMMA' + Math.random() + '\0';
+const escPeriod = '\0PERIOD' + Math.random() + '\0';
+const escSlashPattern = new RegExp(escSlash, 'g');
+const escOpenPattern = new RegExp(escOpen, 'g');
+const escClosePattern = new RegExp(escClose, 'g');
+const escCommaPattern = new RegExp(escComma, 'g');
+const escPeriodPattern = new RegExp(escPeriod, 'g');
+const slashPattern = /\\\\/g;
+const openPattern = /\\{/g;
+const closePattern = /\\}/g;
+const commaPattern = /\\,/g;
+const periodPattern = /\\\./g;
+const EXPANSION_MAX = 100_000;
+// `EXPANSION_MAX` caps the *number* of expansions, but not their length. An
+// input like `'{a,b}'.repeat(1500)` stays under that count - its output is
+// truncated to 100k results - while making every result ~1500 characters
+// long. The result set, and the intermediate arrays built while combining
+// brace sets, then grow large enough to exhaust memory and crash the process
+// (CVE-2026-14257). `EXPANSION_MAX_LENGTH` bounds the total number of
+// characters the accumulator may hold at any point, so memory stays flat no
+// matter how many brace groups are chained. The limit sits well above any
+// realistic expansion (100k results hitting `EXPANSION_MAX` measure ~1M
+// characters) so legitimate input is unaffected.
+const EXPANSION_MAX_LENGTH = 4_000_000;
+function numeric(str) {
+    return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+    return str
+        .replace(slashPattern, escSlash)
+        .replace(openPattern, escOpen)
+        .replace(closePattern, escClose)
+        .replace(commaPattern, escComma)
+        .replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+    return str
+        .replace(escSlashPattern, '\\')
+        .replace(escOpenPattern, '{')
+        .replace(escClosePattern, '}')
+        .replace(escCommaPattern, ',')
+        .replace(escPeriodPattern, '.');
+}
+/**
+ * Basically just str.split(","), but handling cases
+ * where we have nested braced sections, which should be
+ * treated as individual members, like {a,{b,c},d}
+ */
+function parseCommaParts(str) {
+    if (!str) {
+        return [''];
+    }
+    const parts = [];
+    const m = balanced('{', '}', str);
+    if (!m) {
+        return str.split(',');
+    }
+    const { pre, body, post } = m;
+    const p = pre.split(',');
+    p[p.length - 1] += '{' + body + '}';
+    const postParts = parseCommaParts(post);
+    if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+    }
+    parts.push.apply(parts, p);
+    return parts;
+}
+function expand(str, options = {}) {
+    if (!str) {
+        return [];
+    }
+    const { max = EXPANSION_MAX, maxLength = EXPANSION_MAX_LENGTH } = options;
+    // I don't know why Bash 4.3 does this, but it does.
+    // Anything starting with {} will have the first two bytes preserved
+    // but *only* at the top level, so {},a}b will not expand to anything,
+    // but a{},b}c will be expanded to [a}c,abc].
+    // One could argue that this is a bug in Bash, but since the goal of
+    // this module is to match Bash's rules, we escape a leading {}
+    if (str.slice(0, 2) === '{}') {
+        str = '\\{\\}' + str.slice(2);
+    }
+    return expand_(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
+}
+function embrace(str) {
+    return '{' + str + '}';
+}
+function isPadded(el) {
+    return /^-?0\d/.test(el);
+}
+function lte(i, y) {
+    return i <= y;
+}
+function gte(i, y) {
+    return i >= y;
+}
+// Build `{ acc[a] + pre + values[v] }` for every combination, capping the
+// number of results at `max` and the total number of characters at `maxLength`.
+// This is the one place output grows, so bounding it here keeps the single
+// accumulator - and therefore memory - flat regardless of how many brace groups
+// are combined (CVE-2026-14257).
+function combine(acc, pre, values, max, maxLength, dropEmpties) {
+    const out = [];
+    let length = 0;
+    for (let a = 0; a < acc.length; a++) {
+        for (let v = 0; v < values.length; v++) {
+            if (out.length >= max)
+                return out;
+            const expansion = acc[a] + pre + values[v];
+            // Bash drops empty results at the top level. Skip them before they count
+            // against `max`, so `max` bounds the number of *kept* results.
+            if (dropEmpties && !expansion)
+                continue;
+            if (length + expansion.length > maxLength)
+                return out;
+            out.push(expansion);
+            length += expansion.length;
+        }
+    }
+    return out;
+}
+// The expansion values of a single numeric (`1..5`) or alphabetic (`a..e..2`)
+// sequence body.
+function expandSequence(body, isAlphaSequence, max, maxLength) {
+    const n = body.split(/\.\./);
+    const N = [];
+    // A sequence body always splits into two or three parts, but the compiler
+    // can't know that.
+    /* c8 ignore start */
+    if (n[0] === undefined || n[1] === undefined) {
+        return N;
+    }
+    /* c8 ignore stop */
+    const x = numeric(n[0]);
+    const y = numeric(n[1]);
+    const width = Math.max(n[0].length, n[1].length);
+    let incr = n.length === 3 && n[2] !== undefined ?
+        Math.max(Math.abs(numeric(n[2])), 1)
+        : 1;
+    let test = lte;
+    const reverse = y < x;
+    if (reverse) {
+        incr *= -1;
+        test = gte;
+    }
+    const pad = n.some(isPadded);
+    let length = 0;
+    for (let i = x; test(i, y) && N.length < max; i += incr) {
+        let c;
+        if (isAlphaSequence) {
+            c = String.fromCharCode(i);
+            if (c === '\\') {
+                c = '';
+            }
+        }
+        else {
+            c = String(i);
+            if (pad) {
+                const need = width - c.length;
+                if (need > 0) {
+                    const z = new Array(need + 1).join('0');
+                    if (i < 0) {
+                        c = '-' + z + c.slice(1);
+                    }
+                    else {
+                        c = z + c;
+                    }
+                }
+            }
+        }
+        if (length + c.length > maxLength)
+            break;
+        N.push(c);
+        length += c.length;
+    }
+    return N;
+}
+function expand_(str, max, maxLength, isTop) {
+    // Consume the string's top-level brace groups left to right, threading a
+    // running set of combined prefixes (`acc`). Expanding the tail iteratively -
+    // rather than recursing on `m.post` once per group - keeps the native stack
+    // depth constant, so deeply chained input (`'{a,b}'.repeat(3000)`) can no
+    // longer overflow the stack, and leaves a single accumulator whose size
+    // `maxLength` bounds directly (CVE-2026-14257).
+    let acc = [''];
+    // Bash drops empty results, but only when the *first* top-level group is a
+    // comma set - a sequence like `{a..\}` may legitimately yield ''. The drop
+    // is on the final strings, so it is applied to whichever `combine` produces
+    // them (the one with no brace set left in the tail).
+    let dropEmpties = false;
+    let firstGroup = true;
+    for (;;) {
+        const m = balanced('{', '}', str);
+        // No brace set left: the rest of the string is literal.
+        if (!m) {
+            return combine(acc, str, [''], max, maxLength, dropEmpties);
+        }
+        // no need to expand pre, since it is guaranteed to be free of brace-sets
+        const pre = m.pre;
+        if (/\$$/.test(pre)) {
+            acc = combine(acc, pre + '{' + m.body + '}', [''], max, maxLength, dropEmpties && !m.post.length);
+            firstGroup = false;
+            if (!m.post.length)
+                break;
+            str = m.post;
+            continue;
+        }
+        const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        const isSequence = isNumericSequence || isAlphaSequence;
+        const isOptions = m.body.indexOf(',') >= 0;
+        if (!isSequence && !isOptions) {
+            // {a},b}
+            if (m.post.match(/,(?!,).*\}/)) {
+                str = m.pre + '{' + m.body + escClose + m.post;
+                isTop = true;
+                continue;
+            }
+            // Nothing here expands, so the whole remaining string is literal.
+            return combine(acc, pre + '{' + m.body + '}' + m.post, [''], max, maxLength, dropEmpties);
+        }
+        if (firstGroup) {
+            dropEmpties = isTop && !isSequence;
+            firstGroup = false;
+        }
+        let values;
+        if (isSequence) {
+            values = expandSequence(m.body, isAlphaSequence, max, maxLength);
+        }
+        else {
+            let n = parseCommaParts(m.body);
+            if (n.length === 1 && n[0] !== undefined) {
+                // x{{a,b}}y ==> x{a}y x{b}y
+                n = expand_(n[0], max, maxLength, false).map(embrace);
+                //XXX is this necessary? Can't seem to hit it in tests.
+                /* c8 ignore start */
+                if (n.length === 1) {
+                    acc = combine(acc, pre + n[0], [''], max, maxLength, dropEmpties && !m.post.length);
+                    if (!m.post.length)
+                        break;
+                    str = m.post;
+                    continue;
+                }
+                /* c8 ignore stop */
+            }
+            // Values that `combine` is going to drop as empty produce no result, so
+            // they must not count against `max` - otherwise `{a,,b}` with `max: 2`
+            // would stop at `['a', '']` and yield one result instead of two. Skipping
+            // them outright keeps `values` bounded while leaving `max` a bound on
+            // *kept* results.
+            let dropsEmpties = dropEmpties && !m.post.length && !pre;
+            for (let d = 0; dropsEmpties && d < acc.length; d++) {
+                if (acc[d]) {
+                    dropsEmpties = false;
+                }
+            }
+            values = [];
+            let valuesLength = 0;
+            outer: for (let j = 0; j < n.length; j++) {
+                const expanded = expand_(n[j], max, maxLength, false);
+                for (let k = 0; k < expanded.length; k++) {
+                    const v = expanded[k];
+                    if (dropsEmpties && !v)
+                        continue;
+                    if (values.length >= max || valuesLength + v.length > maxLength) {
+                        break outer;
+                    }
+                    values.push(v);
+                    valuesLength += v.length;
+                }
+            }
+        }
+        acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
+        if (!m.post.length)
+            break;
+        str = m.post;
+    }
+    return acc;
+}
+
+const MAX_PATTERN_LENGTH = 1024 * 64;
+const assertValidPattern = (pattern) => {
+    if (typeof pattern !== 'string') {
+        throw new TypeError('invalid pattern');
+    }
+    if (pattern.length > MAX_PATTERN_LENGTH) {
+        throw new TypeError('pattern is too long');
+    }
+};
+
+// translate the various posix character classes into unicode properties
+// this works across all unicode locales
+// { <posix class>: [<translation>, /u flag required, negated]
+const posixClasses = {
+    '[:alnum:]': ['\\p{L}\\p{Nl}\\p{Nd}', true],
+    '[:alpha:]': ['\\p{L}\\p{Nl}', true],
+    '[:ascii:]': ['\\x' + '00-\\x' + '7f', false],
+    '[:blank:]': ['\\p{Zs}\\t', true],
+    '[:cntrl:]': ['\\p{Cc}', true],
+    '[:digit:]': ['\\p{Nd}', true],
+    '[:graph:]': ['\\p{Z}\\p{C}', true, true],
+    '[:lower:]': ['\\p{Ll}', true],
+    '[:print:]': ['\\p{C}', true],
+    '[:punct:]': ['\\p{P}', true],
+    '[:space:]': ['\\p{Z}\\t\\r\\n\\v\\f', true],
+    '[:upper:]': ['\\p{Lu}', true],
+    '[:word:]': ['\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}', true],
+    '[:xdigit:]': ['A-Fa-f0-9', false],
+};
+// only need to escape a few things inside of brace expressions
+// escapes: [ \ ] -
+const braceEscape = (s) => s.replace(/[[\]\\-]/g, '\\$&');
+// escape all regexp magic characters
+const regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+// everything has already been escaped, we just have to join
+const rangesToString = (ranges) => ranges.join('');
+// takes a glob string at a posix brace expression, and returns
+// an equivalent regular expression source, and boolean indicating
+// whether the /u flag needs to be applied, and the number of chars
+// consumed to parse the character class.
+// This also removes out of order ranges, and returns ($.) if the
+// entire class just no good.
+const parseClass = (glob, position) => {
+    const pos = position;
+    /* c8 ignore start */
+    if (glob.charAt(pos) !== '[') {
+        throw new Error('not in a brace expression');
+    }
+    /* c8 ignore stop */
+    const ranges = [];
+    const negs = [];
+    let i = pos + 1;
+    let sawStart = false;
+    let uflag = false;
+    let escaping = false;
+    let negate = false;
+    let endPos = pos;
+    let rangeStart = '';
+    WHILE: while (i < glob.length) {
+        const c = glob.charAt(i);
+        if ((c === '!' || c === '^') && i === pos + 1) {
+            negate = true;
+            i++;
+            continue;
+        }
+        if (c === ']' && sawStart && !escaping) {
+            endPos = i + 1;
+            break;
+        }
+        sawStart = true;
+        if (c === '\\') {
+            if (!escaping) {
+                escaping = true;
+                i++;
+                continue;
+            }
+            // escaped \ char, fall through and treat like normal char
+        }
+        if (c === '[' && !escaping) {
+            // either a posix class, a collation equivalent, or just a [
+            for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+                if (glob.startsWith(cls, i)) {
+                    // invalid, [a-[] is fine, but not [a-[:alpha]]
+                    if (rangeStart) {
+                        return ['$.', false, glob.length - pos, true];
+                    }
+                    i += cls.length;
+                    if (neg)
+                        negs.push(unip);
+                    else
+                        ranges.push(unip);
+                    uflag = uflag || u;
+                    continue WHILE;
+                }
+            }
+        }
+        // now it's just a normal character, effectively
+        escaping = false;
+        if (rangeStart) {
+            // throw this range away if it's not valid, but others
+            // can still match.
+            if (c > rangeStart) {
+                ranges.push(braceEscape(rangeStart) + '-' + braceEscape(c));
+            }
+            else if (c === rangeStart) {
+                ranges.push(braceEscape(c));
+            }
+            rangeStart = '';
+            i++;
+            continue;
+        }
+        // now might be the start of a range.
+        // can be either c-d or c-] or c<more...>] or c] at this point
+        if (glob.startsWith('-]', i + 1)) {
+            ranges.push(braceEscape(c + '-'));
+            i += 2;
+            continue;
+        }
+        if (glob.startsWith('-', i + 1)) {
+            rangeStart = c;
+            i += 2;
+            continue;
+        }
+        // not the start of a range, just a single character
+        ranges.push(braceEscape(c));
+        i++;
+    }
+    if (endPos < i) {
+        // didn't see the end of the class, not a valid class,
+        // but might still be valid as a literal match.
+        return ['', false, 0, false];
+    }
+    // if we got no ranges and no negates, then we have a range that
+    // cannot possibly match anything, and that poisons the whole glob
+    if (!ranges.length && !negs.length) {
+        return ['$.', false, glob.length - pos, true];
+    }
+    // if we got one positive range, and it's a single character, then that's
+    // not actually a magic pattern, it's just that one literal character.
+    // we should not treat that as "magic", we should just return the literal
+    // character. [_] is a perfectly valid way to escape glob magic chars.
+    if (negs.length === 0 &&
+        ranges.length === 1 &&
+        /^\\?.$/.test(ranges[0]) &&
+        !negate) {
+        const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+        return [regexpEscape(r), false, endPos - pos, false];
+    }
+    const sranges = '[' + (negate ? '^' : '') + rangesToString(ranges) + ']';
+    const snegs = '[' + (negate ? '' : '^') + rangesToString(negs) + ']';
+    const comb = ranges.length && negs.length ? '(' + sranges + '|' + snegs + ')'
+        : ranges.length ? sranges
+            : snegs;
+    return [comb, uflag, endPos - pos, true];
+};
+
+/**
+ * Un-escape a string that has been escaped with {@link escape}.
+ *
+ * If the {@link MinimatchOptions.windowsPathsNoEscape} option is used, then
+ * square-bracket escapes are removed, but not backslash escapes.
+ *
+ * For example, it will turn the string `'[*]'` into `*`, but it will not
+ * turn `'\\*'` into `'*'`, because `\` is a path separator in
+ * `windowsPathsNoEscape` mode.
+ *
+ * When `windowsPathsNoEscape` is not set, then both square-bracket escapes and
+ * backslash escapes are removed.
+ *
+ * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
+ * or unescaped.
+ *
+ * When `magicalBraces` is not set, escapes of braces (`{` and `}`) will not be
+ * unescaped.
+ */
+const unescape$1 = (s, { windowsPathsNoEscape = false, magicalBraces = true, } = {}) => {
+    if (magicalBraces) {
+        return windowsPathsNoEscape ?
+            s.replace(/\[([^/\\])\]/g, '$1')
+            : s
+                .replace(/((?!\\).|^)\[([^/\\])\]/g, '$1$2')
+                .replace(/\\([^/])/g, '$1');
+    }
+    return windowsPathsNoEscape ?
+        s.replace(/\[([^/\\{}])\]/g, '$1')
+        : s
+            .replace(/((?!\\).|^)\[([^/\\{}])\]/g, '$1$2')
+            .replace(/\\([^/{}])/g, '$1');
+};
+
+// parse a single path portion
+var _a;
+const types$2 = new Set(['!', '?', '+', '*', '@']);
+const isExtglobType = (c) => types$2.has(c);
+const isExtglobAST = (c) => isExtglobType(c.type);
+// Map of which extglob types can adopt the children of a nested extglob
+//
+// anything but ! can adopt a matching type:
+// +(a|+(b|c)|d) => +(a|b|c|d)
+// *(a|*(b|c)|d) => *(a|b|c|d)
+// @(a|@(b|c)|d) => @(a|b|c|d)
+// ?(a|?(b|c)|d) => ?(a|b|c|d)
+//
+// * can adopt anything, because 0 or repetition is allowed
+// *(a|?(b|c)|d) => *(a|b|c|d)
+// *(a|+(b|c)|d) => *(a|b|c|d)
+// *(a|@(b|c)|d) => *(a|b|c|d)
+//
+// + can adopt @, because 1 or repetition is allowed
+// +(a|@(b|c)|d) => +(a|b|c|d)
+//
+// + and @ CANNOT adopt *, because 0 would be allowed
+// +(a|*(b|c)|d) => would match "", on *(b|c)
+// @(a|*(b|c)|d) => would match "", on *(b|c)
+//
+// + and @ CANNOT adopt ?, because 0 would be allowed
+// +(a|?(b|c)|d) => would match "", on ?(b|c)
+// @(a|?(b|c)|d) => would match "", on ?(b|c)
+//
+// ? can adopt @, because 0 or 1 is allowed
+// ?(a|@(b|c)|d) => ?(a|b|c|d)
+//
+// ? and @ CANNOT adopt * or +, because >1 would be allowed
+// ?(a|*(b|c)|d) => would match bbb on *(b|c)
+// @(a|*(b|c)|d) => would match bbb on *(b|c)
+// ?(a|+(b|c)|d) => would match bbb on +(b|c)
+// @(a|+(b|c)|d) => would match bbb on +(b|c)
+//
 // ! CANNOT adopt ! (nothing else can either)
 // !(a|!(b|c)|d) => !(a|b|c|d) would fail to match on b (not not b|c)
 //
@@ -120965,1568 +122217,511 @@ class GlobUtil {
             this.matchSync(m, absolute, ifDir);
         }
         for (const t of processor.subwalkTargets()) {
-            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
-                continue;
-            }
-            tasks++;
-            const children = t.readdirSync();
-            this.walkCB3Sync(t, children, processor, next);
-        }
-        next();
-    }
-    walkCB3Sync(target, entries, processor, cb) {
-        processor = processor.filterEntries(target, entries);
-        let tasks = 1;
-        const next = () => {
-            if (--tasks === 0)
-                cb();
-        };
-        for (const [m, absolute, ifDir] of processor.matches.entries()) {
-            if (this.#ignored(m))
-                continue;
-            this.matchSync(m, absolute, ifDir);
-        }
-        for (const [target, patterns] of processor.subwalks.entries()) {
-            tasks++;
-            this.walkCB2Sync(target, patterns, processor.child(), next);
-        }
-        next();
-    }
-}
-class GlobWalker extends GlobUtil {
-    matches = new Set();
-    constructor(patterns, path, opts) {
-        super(patterns, path, opts);
-    }
-    matchEmit(e) {
-        this.matches.add(e);
-    }
-    async walk() {
-        if (this.signal?.aborted)
-            throw this.signal.reason;
-        if (this.path.isUnknown()) {
-            await this.path.lstat();
-        }
-        await new Promise((res, rej) => {
-            this.walkCB(this.path, this.patterns, () => {
-                if (this.signal?.aborted) {
-                    rej(this.signal.reason);
-                }
-                else {
-                    res(this.matches);
-                }
-            });
-        });
-        return this.matches;
-    }
-    walkSync() {
-        if (this.signal?.aborted)
-            throw this.signal.reason;
-        if (this.path.isUnknown()) {
-            this.path.lstatSync();
-        }
-        // nothing for the callback to do, because this never pauses
-        this.walkCBSync(this.path, this.patterns, () => {
-            if (this.signal?.aborted)
-                throw this.signal.reason;
-        });
-        return this.matches;
-    }
-}
-class GlobStream extends GlobUtil {
-    results;
-    constructor(patterns, path, opts) {
-        super(patterns, path, opts);
-        this.results = new Minipass({
-            signal: this.signal,
-            objectMode: true,
-        });
-        this.results.on('drain', () => this.resume());
-        this.results.on('resume', () => this.resume());
-    }
-    matchEmit(e) {
-        this.results.write(e);
-        if (!this.results.flowing)
-            this.pause();
-    }
-    stream() {
-        const target = this.path;
-        if (target.isUnknown()) {
-            target.lstat().then(() => {
-                this.walkCB(target, this.patterns, () => this.results.end());
-            });
-        }
-        else {
-            this.walkCB(target, this.patterns, () => this.results.end());
-        }
-        return this.results;
-    }
-    streamSync() {
-        if (this.path.isUnknown()) {
-            this.path.lstatSync();
-        }
-        this.walkCBSync(this.path, this.patterns, () => this.results.end());
-        return this.results;
-    }
-}
-
-// if no process global, just call it linux.
-// so we default to case-sensitive, / separators
-const defaultPlatform = (typeof process === 'object' &&
-    process &&
-    typeof process.platform === 'string') ?
-    process.platform
-    : 'linux';
-/**
- * An object that can perform glob pattern traversals.
- */
-class Glob {
-    absolute;
-    cwd;
-    root;
-    dot;
-    dotRelative;
-    follow;
-    ignore;
-    magicalBraces;
-    mark;
-    matchBase;
-    maxDepth;
-    nobrace;
-    nocase;
-    nodir;
-    noext;
-    noglobstar;
-    pattern;
-    platform;
-    realpath;
-    scurry;
-    stat;
-    signal;
-    windowsPathsNoEscape;
-    withFileTypes;
-    includeChildMatches;
-    /**
-     * The options provided to the constructor.
-     */
-    opts;
-    /**
-     * An array of parsed immutable {@link Pattern} objects.
-     */
-    patterns;
-    /**
-     * All options are stored as properties on the `Glob` object.
-     *
-     * See {@link GlobOptions} for full options descriptions.
-     *
-     * Note that a previous `Glob` object can be passed as the
-     * `GlobOptions` to another `Glob` instantiation to re-use settings
-     * and caches with a new pattern.
-     *
-     * Traversal functions can be called multiple times to run the walk
-     * again.
-     */
-    constructor(pattern, opts) {
-        /* c8 ignore start */
-        if (!opts)
-            throw new TypeError('glob options required');
-        /* c8 ignore stop */
-        this.withFileTypes = !!opts.withFileTypes;
-        this.signal = opts.signal;
-        this.follow = !!opts.follow;
-        this.dot = !!opts.dot;
-        this.dotRelative = !!opts.dotRelative;
-        this.nodir = !!opts.nodir;
-        this.mark = !!opts.mark;
-        if (!opts.cwd) {
-            this.cwd = '';
-        }
-        else if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) {
-            opts.cwd = require$$0$l.fileURLToPath(opts.cwd);
-        }
-        this.cwd = opts.cwd || '';
-        this.root = opts.root;
-        this.magicalBraces = !!opts.magicalBraces;
-        this.nobrace = !!opts.nobrace;
-        this.noext = !!opts.noext;
-        this.realpath = !!opts.realpath;
-        this.absolute = opts.absolute;
-        this.includeChildMatches = opts.includeChildMatches !== false;
-        this.noglobstar = !!opts.noglobstar;
-        this.matchBase = !!opts.matchBase;
-        this.maxDepth =
-            typeof opts.maxDepth === 'number' ? opts.maxDepth : Infinity;
-        this.stat = !!opts.stat;
-        this.ignore = opts.ignore;
-        if (this.withFileTypes && this.absolute !== undefined) {
-            throw new Error('cannot set absolute and withFileTypes:true');
-        }
-        if (typeof pattern === 'string') {
-            pattern = [pattern];
-        }
-        this.windowsPathsNoEscape =
-            !!opts.windowsPathsNoEscape ||
-                opts.allowWindowsEscape ===
-                    false;
-        if (this.windowsPathsNoEscape) {
-            pattern = pattern.map(p => p.replace(/\\/g, '/'));
-        }
-        if (this.matchBase) {
-            if (opts.noglobstar) {
-                throw new TypeError('base matching requires globstar');
-            }
-            pattern = pattern.map(p => (p.includes('/') ? p : `./**/${p}`));
-        }
-        this.pattern = pattern;
-        this.platform = opts.platform || defaultPlatform;
-        this.opts = { ...opts, platform: this.platform };
-        if (opts.scurry) {
-            this.scurry = opts.scurry;
-            if (opts.nocase !== undefined &&
-                opts.nocase !== opts.scurry.nocase) {
-                throw new Error('nocase option contradicts provided scurry option');
-            }
-        }
-        else {
-            const Scurry = opts.platform === 'win32' ? PathScurryWin32
-                : opts.platform === 'darwin' ? PathScurryDarwin
-                    : opts.platform ? PathScurryPosix
-                        : PathScurry;
-            this.scurry = new Scurry(this.cwd, {
-                nocase: opts.nocase,
-                fs: opts.fs,
-            });
-        }
-        this.nocase = this.scurry.nocase;
-        // If you do nocase:true on a case-sensitive file system, then
-        // we need to use regexps instead of strings for non-magic
-        // path portions, because statting `aBc` won't return results
-        // for the file `AbC` for example.
-        const nocaseMagicOnly = this.platform === 'darwin' || this.platform === 'win32';
-        const mmo = {
-            // default nocase based on platform
-            ...opts,
-            dot: this.dot,
-            matchBase: this.matchBase,
-            nobrace: this.nobrace,
-            nocase: this.nocase,
-            nocaseMagicOnly,
-            nocomment: true,
-            noext: this.noext,
-            nonegate: true,
-            optimizationLevel: 2,
-            platform: this.platform,
-            windowsPathsNoEscape: this.windowsPathsNoEscape,
-            debug: !!this.opts.debug,
-        };
-        const mms = this.pattern.map(p => new Minimatch(p, mmo));
-        const [matchSet, globParts] = mms.reduce((set, m) => {
-            set[0].push(...m.set);
-            set[1].push(...m.globParts);
-            return set;
-        }, [[], []]);
-        this.patterns = matchSet.map((set, i) => {
-            const g = globParts[i];
-            /* c8 ignore start */
-            if (!g)
-                throw new Error('invalid pattern object');
-            /* c8 ignore stop */
-            return new Pattern(set, g, 0, this.platform);
-        });
-    }
-    async walk() {
-        // Walkers always return array of Path objects, so we just have to
-        // coerce them into the right shape.  It will have already called
-        // realpath() if the option was set to do so, so we know that's cached.
-        // start out knowing the cwd, at least
-        return [
-            ...(await new GlobWalker(this.patterns, this.scurry.cwd, {
-                ...this.opts,
-                maxDepth: this.maxDepth !== Infinity ?
-                    this.maxDepth + this.scurry.cwd.depth()
-                    : Infinity,
-                platform: this.platform,
-                nocase: this.nocase,
-                includeChildMatches: this.includeChildMatches,
-            }).walk()),
-        ];
-    }
-    walkSync() {
-        return [
-            ...new GlobWalker(this.patterns, this.scurry.cwd, {
-                ...this.opts,
-                maxDepth: this.maxDepth !== Infinity ?
-                    this.maxDepth + this.scurry.cwd.depth()
-                    : Infinity,
-                platform: this.platform,
-                nocase: this.nocase,
-                includeChildMatches: this.includeChildMatches,
-            }).walkSync(),
-        ];
-    }
-    stream() {
-        return new GlobStream(this.patterns, this.scurry.cwd, {
-            ...this.opts,
-            maxDepth: this.maxDepth !== Infinity ?
-                this.maxDepth + this.scurry.cwd.depth()
-                : Infinity,
-            platform: this.platform,
-            nocase: this.nocase,
-            includeChildMatches: this.includeChildMatches,
-        }).stream();
-    }
-    streamSync() {
-        return new GlobStream(this.patterns, this.scurry.cwd, {
-            ...this.opts,
-            maxDepth: this.maxDepth !== Infinity ?
-                this.maxDepth + this.scurry.cwd.depth()
-                : Infinity,
-            platform: this.platform,
-            nocase: this.nocase,
-            includeChildMatches: this.includeChildMatches,
-        }).streamSync();
-    }
-    /**
-     * Default sync iteration function. Returns a Generator that
-     * iterates over the results.
-     */
-    iterateSync() {
-        return this.streamSync()[Symbol.iterator]();
-    }
-    [Symbol.iterator]() {
-        return this.iterateSync();
-    }
-    /**
-     * Default async iteration function. Returns an AsyncGenerator that
-     * iterates over the results.
-     */
-    iterate() {
-        return this.stream()[Symbol.asyncIterator]();
-    }
-    [Symbol.asyncIterator]() {
-        return this.iterate();
-    }
-}
-
-/**
- * Return true if the patterns provided contain any magic glob characters,
- * given the options provided.
- *
- * Brace expansion is not considered "magic" unless the `magicalBraces` option
- * is set, as brace expansion just turns one string into an array of strings.
- * So a pattern like `'x{a,b}y'` would return `false`, because `'xay'` and
- * `'xby'` both do not contain any magic glob characters, and it's treated the
- * same as if you had called it on `['xay', 'xby']`. When `magicalBraces:true`
- * is in the options, brace expansion _is_ treated as a pattern having magic.
- */
-const hasMagic = (pattern, options = {}) => {
-    if (!Array.isArray(pattern)) {
-        pattern = [pattern];
-    }
-    for (const p of pattern) {
-        if (new Minimatch(p, options).hasMagic())
-            return true;
-    }
-    return false;
-};
-
-function globStreamSync(pattern, options = {}) {
-    return new Glob(pattern, options).streamSync();
-}
-function globStream(pattern, options = {}) {
-    return new Glob(pattern, options).stream();
-}
-function globSync(pattern, options = {}) {
-    return new Glob(pattern, options).walkSync();
-}
-async function glob_(pattern, options = {}) {
-    return new Glob(pattern, options).walk();
-}
-function globIterateSync(pattern, options = {}) {
-    return new Glob(pattern, options).iterateSync();
-}
-function globIterate(pattern, options = {}) {
-    return new Glob(pattern, options).iterate();
-}
-// aliases: glob.sync.stream() glob.stream.sync() glob.sync() etc
-const streamSync = globStreamSync;
-const stream = Object.assign(globStream, { sync: globStreamSync });
-const iterateSync = globIterateSync;
-const iterate = Object.assign(globIterate, {
-    sync: globIterateSync,
-});
-const sync = Object.assign(globSync, {
-    stream: globStreamSync,
-    iterate: globIterateSync,
-});
-const glob = Object.assign(glob_, {
-    glob: glob_,
-    globSync,
-    sync,
-    globStream,
-    stream,
-    globStreamSync,
-    streamSync,
-    globIterate,
-    iterate,
-    globIterateSync,
-    iterateSync,
-    Glob,
-    hasMagic,
-    escape: escape$1,
-    unescape: unescape$1,
-});
-glob.glob = glob;
-
-function matchesQuantizationVariant({ filePath, variant }) {
-    if (!variant) {
-        return false;
-    }
-    const escapedVariant = variant.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const matcher = new RegExp(`(^|[\\-./_])${escapedVariant}(?=[\\-./]|$)`, "i");
-    const normalizedPath = filePath.replace(/\\/g, "/");
-    const segments = normalizedPath.split("/").filter(Boolean);
-    if (segments.length === 0) {
-        return false;
-    }
-    const filename = segments[segments.length - 1].replace(/\.gguf$/i, "");
-    if (matcher.test(filename)) {
-        return true;
-    }
-    return segments.slice(0, -1).some(segment => matcher.test(segment));
-}
-async function findQuantizedModelTarget({ model, path }) {
-    if (model.source.type === "storage") {
-        throw new Error("Model storage not supported yet");
-    }
-    if (model.format !== "gguf") {
-        throw new Error(`Model format not supported: ${model.format}`);
-    }
-    const [, variant = null] = model.source.slug.split(":");
-    const modelFiles = (await glob("**/*.gguf", {
-        absolute: true,
-        cwd: path,
-        nodir: true
-    })).filter(file => !/(mmproj|clip)/i.test(file));
-    if (modelFiles.length <= 0) {
-        throw new Error(`No models found for format: ${model.format}`);
-    }
-    modelFiles.sort((left, right) => left.localeCompare(right, undefined, { sensitivity: "base" }));
-    if (!variant) {
-        return modelFiles[0];
-    }
-    const matches = modelFiles.filter(fileName => matchesQuantizationVariant({ filePath: fileName, variant: variant ?? "" }));
-    if (matches.length === 0) {
-        throw new Error(`No model found for format and variant: ${model.format} / ${variant}`);
-    }
-    return matches[0];
-}
-
-const VLLM_START_ARGS = ["-m", "vllm.entrypoints.openai.api_server", "--host", "0.0.0.0"];
-const VLLM_EXECUTABLE = "python3";
-const DEFAULT_VLLM_CONTEXT_LENGTH = 2048;
-async function startVLLM({ enginePort, targetDirectory }) {
-    const contextLength = Math.max(1, this.contextLength ?? DEFAULT_VLLM_CONTEXT_LENGTH);
-    let modelPath = targetDirectory;
-    if (this.model.format === "gguf") {
-        modelPath = await findQuantizedModelTarget({ model: this.model, path: targetDirectory });
-    }
-    const engineConfig = this.engineConfig;
-    const device = typeof engineConfig?.device === "string" ? engineConfig.device : process.env.VLLM_DEVICE;
-    const dtype = typeof engineConfig?.dtype === "string" ? engineConfig.dtype : process.env.VLLM_DTYPE;
-    const tensorParallelSize = typeof engineConfig?.tensorParallelSize === "number" ? engineConfig.tensorParallelSize : 1;
-    const args = [
-        ...VLLM_START_ARGS,
-        "--port",
-        String(enginePort),
-        "--model",
-        modelPath,
-        "--served-model-name",
-        SERVED_MODEL_NAME,
-        "--max-model-len",
-        String(contextLength),
-        "--tensor-parallel-size",
-        String(tensorParallelSize)
-    ];
-    if (this.model.taskType === "embeddings") {
-        args.push("--task", "embed");
-    }
-    if (device) {
-        args.push("--device", device);
-    }
-    if (dtype) {
-        args.push("--dtype", dtype);
-    }
-    args.push(...parseExtraArgs(engineConfig?.extraArgs));
-    if (this.model.multimodalEnabled) {
-        args.push("--limit-mm-per-prompt", process.env.VLLM_MM_LIMIT ?? '{"image":5}');
-    }
-    if (process.env.VLLM_TRUST_REMOTE_CODE === "true") {
-        args.push("--trust-remote-code");
-    }
-    return createEngineProcess({ args, bin: VLLM_EXECUTABLE, logger: this.logger });
-}
-
-// src/lib/cache-management.ts
-
-// src/consts.ts
-var HUB_URL = "https://huggingface.co";
-
-// src/error.ts
-async function createApiError(response, opts) {
-  const error = new HubApiError(response.url, response.status, response.headers.get("X-Request-Id") ?? opts?.requestId);
-  error.message = `Api error with status ${error.statusCode}${""}`;
-  const trailer = [`URL: ${error.url}`, error.requestId ? `Request ID: ${error.requestId}` : void 0].filter(Boolean).join(". ");
-  if (response.headers.get("Content-Type")?.startsWith("application/json")) {
-    const json = await response.json();
-    error.message = json.error || json.message || error.message;
-    if (json.error_description) {
-      error.message = error.message ? error.message + `: ${json.error_description}` : json.error_description;
-    }
-    error.data = json;
-  } else {
-    error.data = { message: await response.text() };
-  }
-  error.message += `. ${trailer}`;
-  throw error;
-}
-var HubApiError = class extends Error {
-  statusCode;
-  url;
-  requestId;
-  data;
-  constructor(url, statusCode, requestId, message) {
-    super(message);
-    this.statusCode = statusCode;
-    this.requestId = requestId;
-    this.url = url;
-  }
-};
-var InvalidApiResponseFormatError = class extends Error {
-};
-
-// src/utils/checkCredentials.ts
-function checkAccessToken(accessToken) {
-  if (!accessToken.startsWith("hf_")) {
-    throw new TypeError("Your access token must start with 'hf_'");
-  }
-}
-function checkCredentials(params) {
-  if (params.accessToken) {
-    checkAccessToken(params.accessToken);
-    return params.accessToken;
-  }
-  if (params.credentials?.accessToken) {
-    checkAccessToken(params.credentials.accessToken);
-    return params.credentials.accessToken;
-  }
-}
-
-// src/utils/toRepoId.ts
-function toRepoId(repo) {
-  if (typeof repo !== "string") {
-    return repo;
-  }
-  if (repo.startsWith("model/") || repo.startsWith("models/")) {
-    throw new TypeError(
-      "A repo designation for a model should not start with 'models/', directly specify the model namespace / name"
-    );
-  }
-  if (repo.startsWith("space/")) {
-    throw new TypeError("Spaces should start with 'spaces/', plural, not 'space/'");
-  }
-  if (repo.startsWith("dataset/")) {
-    throw new TypeError("Datasets should start with 'dataset/', plural, not 'dataset/'");
-  }
-  const slashes = repo.split("/").length - 1;
-  if (repo.startsWith("spaces/")) {
-    if (slashes !== 2) {
-      throw new TypeError("Space Id must include namespace and name of the space");
-    }
-    return {
-      type: "space",
-      name: repo.slice("spaces/".length)
-    };
-  }
-  if (repo.startsWith("datasets/")) {
-    if (slashes > 2) {
-      throw new TypeError("Too many slashes in repo designation: " + repo);
-    }
-    return {
-      type: "dataset",
-      name: repo.slice("datasets/".length)
-    };
-  }
-  if (slashes > 1) {
-    throw new TypeError("Too many slashes in repo designation: " + repo);
-  }
-  return {
-    type: "model",
-    name: repo
-  };
-}
-new Promise((r) => {
-});
-
-// src/utils/combineUint8Arrays.ts
-function combineUint8Arrays(a, b) {
-  const aLength = a.length;
-  const combinedBytes = new Uint8Array(aLength + b.length);
-  combinedBytes.set(a);
-  combinedBytes.set(b, aLength);
-  return combinedBytes;
-}
-function readU64(b, n) {
-  let x = 0;
-  x |= b[n++] << 0;
-  x |= b[n++] << 8;
-  x |= b[n++] << 16;
-  x |= b[n++] << 24;
-  x |= b[n++] << 32;
-  x |= b[n++] << 40;
-  x |= b[n++] << 48;
-  x |= b[n++] << 56;
-  return x;
-}
-function readU32(b, n) {
-  let x = 0;
-  x |= b[n++] << 0;
-  x |= b[n++] << 8;
-  x |= b[n++] << 16;
-  x |= b[n++] << 24;
-  return x;
-}
-
-// src/vendor/lz4js/index.ts
-var minMatch = 4;
-var hashSize = 1 << 16;
-makeHashTable();
-var magicNum = 407708164;
-var fdContentChksum = 4;
-var fdContentSize = 8;
-var fdBlockChksum = 16;
-var fdVersion = 64;
-var fdVersionMask = 192;
-var bsUncompressed = 2147483648;
-var bsShift = 4;
-var bsMask = 7;
-var bsMap = {
-  4: 65536,
-  5: 262144,
-  6: 1048576,
-  7: 4194304
-};
-function makeHashTable() {
-  try {
-    return new Uint32Array(hashSize);
-  } catch (error) {
-    const hashTable2 = new Array(hashSize);
-    for (let i = 0; i < hashSize; i++) {
-      hashTable2[i] = 0;
-    }
-    return hashTable2;
-  }
-}
-function makeBuffer(size) {
-  return new Uint8Array(size);
-}
-function sliceArray(array, start, end) {
-  return array.slice(start, end);
-}
-function decompressBound(src) {
-  let sIndex = 0;
-  if (readU32(src, sIndex) !== magicNum) {
-    throw new Error("invalid magic number");
-  }
-  sIndex += 4;
-  const descriptor = src[sIndex++];
-  if ((descriptor & fdVersionMask) !== fdVersion) {
-    throw new Error("incompatible descriptor version " + (descriptor & fdVersionMask));
-  }
-  const useBlockSum = (descriptor & fdBlockChksum) !== 0;
-  const useContentSize = (descriptor & fdContentSize) !== 0;
-  const bsIdx = src[sIndex++] >> bsShift & bsMask;
-  if (bsMap[bsIdx] === void 0) {
-    throw new Error("invalid block size " + bsIdx);
-  }
-  const maxBlockSize = bsMap[bsIdx];
-  if (useContentSize) {
-    return readU64(src, sIndex);
-  }
-  sIndex++;
-  let maxSize = 0;
-  while (true) {
-    let blockSize = readU32(src, sIndex);
-    sIndex += 4;
-    if (blockSize & bsUncompressed) {
-      blockSize &= ~bsUncompressed;
-      maxSize += blockSize;
-    } else if (blockSize > 0) {
-      maxSize += maxBlockSize;
-    }
-    if (blockSize === 0) {
-      return maxSize;
-    }
-    if (useBlockSum) {
-      sIndex += 4;
-    }
-    sIndex += blockSize;
-  }
-}
-function decompressBlock(src, dst, sIndex, sLength, dIndex) {
-  let mLength, mOffset, sEnd, n, i;
-  const hasCopyWithin = dst.copyWithin !== void 0 && dst.fill !== void 0;
-  sEnd = sIndex + sLength;
-  while (sIndex < sEnd) {
-    const token = src[sIndex++];
-    let literalCount = token >> 4;
-    if (literalCount > 0) {
-      if (literalCount === 15) {
-        while (true) {
-          literalCount += src[sIndex];
-          if (src[sIndex++] !== 255) {
-            break;
-          }
-        }
-      }
-      for (n = sIndex + literalCount; sIndex < n; ) {
-        dst[dIndex++] = src[sIndex++];
-      }
-    }
-    if (sIndex >= sEnd) {
-      break;
-    }
-    mLength = token & 15;
-    mOffset = src[sIndex++] | src[sIndex++] << 8;
-    if (mLength === 15) {
-      while (true) {
-        mLength += src[sIndex];
-        if (src[sIndex++] !== 255) {
-          break;
-        }
-      }
-    }
-    mLength += minMatch;
-    if (hasCopyWithin && mOffset === 1) {
-      dst.fill(dst[dIndex - 1] | 0, dIndex, dIndex + mLength);
-      dIndex += mLength;
-    } else if (hasCopyWithin && mOffset > mLength && mLength > 31) {
-      dst.copyWithin(dIndex, dIndex - mOffset, dIndex - mOffset + mLength);
-      dIndex += mLength;
-    } else {
-      for (i = dIndex - mOffset, n = i + mLength; i < n; ) {
-        dst[dIndex++] = dst[i++] | 0;
-      }
-    }
-  }
-  return dIndex;
-}
-function decompressFrame(src, dst) {
-  let useBlockSum, useContentSum, useContentSize, descriptor;
-  let sIndex = 0;
-  let dIndex = 0;
-  if (readU32(src, sIndex) !== magicNum) {
-    throw new Error("invalid magic number");
-  }
-  sIndex += 4;
-  descriptor = src[sIndex++];
-  if ((descriptor & fdVersionMask) !== fdVersion) {
-    throw new Error("incompatible descriptor version");
-  }
-  useBlockSum = (descriptor & fdBlockChksum) !== 0;
-  useContentSum = (descriptor & fdContentChksum) !== 0;
-  useContentSize = (descriptor & fdContentSize) !== 0;
-  const bsIdx = src[sIndex++] >> bsShift & bsMask;
-  if (bsMap[bsIdx] === void 0) {
-    throw new Error("invalid block size");
-  }
-  if (useContentSize) {
-    sIndex += 8;
-  }
-  sIndex++;
-  while (true) {
-    var compSize;
-    compSize = readU32(src, sIndex);
-    sIndex += 4;
-    if (compSize === 0) {
-      break;
-    }
-    if (useBlockSum) {
-      sIndex += 4;
-    }
-    if ((compSize & bsUncompressed) !== 0) {
-      compSize &= ~bsUncompressed;
-      for (let j = 0; j < compSize; j++) {
-        dst[dIndex++] = src[sIndex++];
-      }
-    } else {
-      dIndex = decompressBlock(src, dst, sIndex, compSize, dIndex);
-      sIndex += compSize;
-    }
-  }
-  if (useContentSum) {
-    sIndex += 4;
-  }
-  return dIndex;
-}
-function decompress(src, maxSize) {
-  let dst, size;
-  if (maxSize === void 0) {
-    maxSize = decompressBound(src);
-  }
-  dst = makeBuffer(maxSize);
-  size = decompressFrame(src, dst);
-  if (size !== maxSize) {
-    dst = sliceArray(dst, 0, size);
-  }
-  return dst;
-}
-
-// src/utils/RangeList.ts
-var RangeList = class {
-  ranges = [];
-  /**
-   * Add a range to the list. If it overlaps with existing ranges,
-   * it will split them and increment reference counts accordingly.
-   */
-  add(start, end) {
-    if (end <= start) {
-      throw new TypeError("End must be greater than start");
-    }
-    const overlappingRanges = [];
-    for (let i = 0; i < this.ranges.length; i++) {
-      const range2 = this.ranges[i];
-      if (start < range2.end && end > range2.start) {
-        overlappingRanges.push({ index: i, range: range2 });
-      }
-      if (range2.data !== null) {
-        throw new Error("Overlapping range already has data");
-      }
-    }
-    if (overlappingRanges.length === 0) {
-      this.ranges.push({ start, end, refCount: 1, data: null });
-      this.ranges.sort((a, b) => a.start - b.start);
-      return;
-    }
-    const newRanges = [];
-    let currentPos = start;
-    for (let i = 0; i < overlappingRanges.length; i++) {
-      const { range: range2 } = overlappingRanges[i];
-      if (currentPos < range2.start) {
-        newRanges.push({
-          start: currentPos,
-          end: range2.start,
-          refCount: 1,
-          data: null
-        });
-      } else if (range2.start < currentPos) {
-        newRanges.push({
-          start: range2.start,
-          end: currentPos,
-          refCount: range2.refCount,
-          data: null
-        });
-      }
-      newRanges.push({
-        start: Math.max(currentPos, range2.start),
-        end: Math.min(end, range2.end),
-        refCount: range2.refCount + 1,
-        data: null
-      });
-      if (range2.end > end) {
-        newRanges.push({
-          start: end,
-          end: range2.end,
-          refCount: range2.refCount,
-          data: null
-        });
-      }
-      currentPos = Math.max(currentPos, range2.end);
-    }
-    if (currentPos < end) {
-      newRanges.push({
-        start: currentPos,
-        end,
-        refCount: 1,
-        data: null
-      });
-    }
-    const firstIndex = overlappingRanges[0].index;
-    const lastIndex = overlappingRanges[overlappingRanges.length - 1].index;
-    this.ranges.splice(firstIndex, lastIndex - firstIndex + 1, ...newRanges);
-    this.ranges.sort((a, b) => a.start - b.start);
-  }
-  /**
-   * Remove a range from the list. The range must start and end at existing boundaries.
-   */
-  remove(start, end) {
-    if (end <= start) {
-      throw new TypeError("End must be greater than start");
-    }
-    const affectedRanges = [];
-    for (let i = 0; i < this.ranges.length; i++) {
-      const range2 = this.ranges[i];
-      if (start < range2.end && end > range2.start) {
-        affectedRanges.push({ index: i, range: range2 });
-      }
-    }
-    if (affectedRanges.length === 0) {
-      throw new Error("No ranges found to remove");
-    }
-    if (start !== affectedRanges[0].range.start || end !== affectedRanges[affectedRanges.length - 1].range.end) {
-      throw new Error("Range boundaries must match existing boundaries");
-    }
-    for (let i = 0; i < affectedRanges.length; i++) {
-      const { range: range2 } = affectedRanges[i];
-      range2.refCount--;
-    }
-    this.ranges = this.ranges.filter((range2) => range2.refCount > 0);
-  }
-  /**
-   * Get all ranges within the specified boundaries.
-   */
-  getRanges(start, end) {
-    if (end <= start) {
-      throw new TypeError("End must be greater than start");
-    }
-    return this.ranges.filter((range2) => start < range2.end && end > range2.start);
-  }
-  /**
-   * Get all ranges in the list
-   */
-  getAllRanges() {
-    return [...this.ranges];
-  }
-};
-
-// src/utils/XetBlob.ts
-var JWT_SAFETY_PERIOD = 6e4;
-var JWT_CACHE_SIZE = 1e3;
-var compressionSchemeLabels = {
-  [0 /* None */]: "None",
-  [1 /* LZ4 */]: "LZ4",
-  [2 /* ByteGroupingLZ4 */]: "ByteGroupingLZ4"
-};
-var XET_CHUNK_HEADER_BYTES = 8;
-var XetBlob = class extends Blob {
-  fetch;
-  accessToken;
-  refreshUrl;
-  reconstructionUrl;
-  hash;
-  start = 0;
-  end = 0;
-  internalLogging = false;
-  reconstructionInfo;
-  listener;
-  constructor(params) {
-    super([]);
-    this.fetch = params.fetch ?? fetch.bind(globalThis);
-    this.accessToken = checkCredentials(params);
-    this.refreshUrl = params.refreshUrl;
-    this.end = params.size;
-    this.reconstructionUrl = params.reconstructionUrl;
-    this.hash = params.hash;
-    this.listener = params.listener;
-    this.internalLogging = params.internalLogging ?? false;
-    this.refreshUrl;
-  }
-  get size() {
-    return this.end - this.start;
-  }
-  #clone() {
-    const blob = new XetBlob({
-      fetch: this.fetch,
-      hash: this.hash,
-      refreshUrl: this.refreshUrl,
-      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-      reconstructionUrl: this.reconstructionUrl,
-      size: this.size
-    });
-    blob.accessToken = this.accessToken;
-    blob.start = this.start;
-    blob.end = this.end;
-    blob.reconstructionInfo = this.reconstructionInfo;
-    blob.listener = this.listener;
-    blob.internalLogging = this.internalLogging;
-    return blob;
-  }
-  slice(start = 0, end = this.size) {
-    const slice = this.#clone();
-    slice.start = this.start + start;
-    slice.end = Math.min(this.start + end, this.end);
-    if (slice.start !== this.start || slice.end !== this.end) {
-      slice.reconstructionInfo = void 0;
+            if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+                continue;
+            }
+            tasks++;
+            const children = t.readdirSync();
+            this.walkCB3Sync(t, children, processor, next);
+        }
+        next();
     }
-    return slice;
-  }
-  #reconstructionInfoPromise;
-  #loadReconstructionInfo() {
-    if (this.#reconstructionInfoPromise) {
-      return this.#reconstructionInfoPromise;
+    walkCB3Sync(target, entries, processor, cb) {
+        processor = processor.filterEntries(target, entries);
+        let tasks = 1;
+        const next = () => {
+            if (--tasks === 0)
+                cb();
+        };
+        for (const [m, absolute, ifDir] of processor.matches.entries()) {
+            if (this.#ignored(m))
+                continue;
+            this.matchSync(m, absolute, ifDir);
+        }
+        for (const [target, patterns] of processor.subwalks.entries()) {
+            tasks++;
+            this.walkCB2Sync(target, patterns, processor.child(), next);
+        }
+        next();
     }
-    this.#reconstructionInfoPromise = (async () => {
-      const connParams = await getAccessToken(this.accessToken, this.fetch, this.refreshUrl);
-      const resp = await this.fetch(this.reconstructionUrl ?? `${connParams.casUrl}/v1/reconstructions/${this.hash}`, {
-        headers: {
-          Authorization: `Bearer ${connParams.accessToken}`,
-          Range: `bytes=${this.start}-${this.end - 1}`
+}
+class GlobWalker extends GlobUtil {
+    matches = new Set();
+    constructor(patterns, path, opts) {
+        super(patterns, path, opts);
+    }
+    matchEmit(e) {
+        this.matches.add(e);
+    }
+    async walk() {
+        if (this.signal?.aborted)
+            throw this.signal.reason;
+        if (this.path.isUnknown()) {
+            await this.path.lstat();
         }
-      });
-      if (!resp.ok) {
-        throw await createApiError(resp);
-      }
-      this.reconstructionInfo = await resp.json();
-      return this.reconstructionInfo;
-    })().finally(() => this.#reconstructionInfoPromise = void 0);
-    return this.#reconstructionInfoPromise;
-  }
-  async #fetch() {
-    if (!this.reconstructionInfo) {
-      await this.#loadReconstructionInfo();
+        await new Promise((res, rej) => {
+            this.walkCB(this.path, this.patterns, () => {
+                if (this.signal?.aborted) {
+                    rej(this.signal.reason);
+                }
+                else {
+                    res(this.matches);
+                }
+            });
+        });
+        return this.matches;
     }
-    const rangeLists = /* @__PURE__ */ new Map();
-    if (!this.reconstructionInfo) {
-      throw new Error("Failed to load reconstruction info");
+    walkSync() {
+        if (this.signal?.aborted)
+            throw this.signal.reason;
+        if (this.path.isUnknown()) {
+            this.path.lstatSync();
+        }
+        // nothing for the callback to do, because this never pauses
+        this.walkCBSync(this.path, this.patterns, () => {
+            if (this.signal?.aborted)
+                throw this.signal.reason;
+        });
+        return this.matches;
     }
-    for (const term of this.reconstructionInfo.terms) {
-      let rangeList = rangeLists.get(term.hash);
-      if (!rangeList) {
-        rangeList = new RangeList();
-        rangeLists.set(term.hash, rangeList);
-      }
-      rangeList.add(term.range.start, term.range.end);
+}
+class GlobStream extends GlobUtil {
+    results;
+    constructor(patterns, path, opts) {
+        super(patterns, path, opts);
+        this.results = new Minipass({
+            signal: this.signal,
+            objectMode: true,
+        });
+        this.results.on('drain', () => this.resume());
+        this.results.on('resume', () => this.resume());
     }
-    const listener = this.listener;
-    const log = this.internalLogging ? (...args) => console.log(...args) : () => {
-    };
-    async function* readData(reconstructionInfo, customFetch, maxBytes, reloadReconstructionInfo) {
-      let totalBytesRead = 0;
-      let readBytesToSkip = reconstructionInfo.offset_into_first_range;
-      for (const term of reconstructionInfo.terms) {
-        if (totalBytesRead >= maxBytes) {
-          break;
+    matchEmit(e) {
+        this.results.write(e);
+        if (!this.results.flowing)
+            this.pause();
+    }
+    stream() {
+        const target = this.path;
+        if (target.isUnknown()) {
+            target.lstat().then(() => {
+                this.walkCB(target, this.patterns, () => this.results.end());
+            });
         }
-        const rangeList = rangeLists.get(term.hash);
-        if (!rangeList) {
-          throw new Error(`Failed to find range list for term ${term.hash}`);
+        else {
+            this.walkCB(target, this.patterns, () => this.results.end());
         }
-        {
-          const termRanges = rangeList.getRanges(term.range.start, term.range.end);
-          if (termRanges.every((range2) => range2.data)) {
-            log("all data available for term", term.hash, readBytesToSkip);
-            rangeLoop:
-              for (const range2 of termRanges) {
-                for (let chunk2 of range2.data) {
-                  if (readBytesToSkip) {
-                    const skipped = Math.min(readBytesToSkip, chunk2.byteLength);
-                    chunk2 = chunk2.slice(skipped);
-                    readBytesToSkip -= skipped;
-                    if (!chunk2.byteLength) {
-                      continue;
-                    }
-                  }
-                  if (chunk2.byteLength > maxBytes - totalBytesRead) {
-                    chunk2 = chunk2.slice(0, maxBytes - totalBytesRead);
-                  }
-                  totalBytesRead += chunk2.byteLength;
-                  yield range2.refCount > 1 ? chunk2.slice() : chunk2;
-                  listener?.({ event: "progress", progress: { read: totalBytesRead, total: maxBytes } });
-                  if (totalBytesRead >= maxBytes) {
-                    break rangeLoop;
-                  }
-                }
-              }
-            rangeList.remove(term.range.start, term.range.end);
-            continue;
-          }
+        return this.results;
+    }
+    streamSync() {
+        if (this.path.isUnknown()) {
+            this.path.lstatSync();
         }
-        const fetchInfo = reconstructionInfo.fetch_info[term.hash].find(
-          (info) => info.range.start <= term.range.start && info.range.end >= term.range.end
-        );
-        if (!fetchInfo) {
-          throw new Error(
-            `Failed to find fetch info for term ${term.hash} and range ${term.range.start}-${term.range.end}`
-          );
+        this.walkCBSync(this.path, this.patterns, () => this.results.end());
+        return this.results;
+    }
+}
+
+// if no process global, just call it linux.
+// so we default to case-sensitive, / separators
+const defaultPlatform = (typeof process === 'object' &&
+    process &&
+    typeof process.platform === 'string') ?
+    process.platform
+    : 'linux';
+/**
+ * An object that can perform glob pattern traversals.
+ */
+class Glob {
+    absolute;
+    cwd;
+    root;
+    dot;
+    dotRelative;
+    follow;
+    ignore;
+    magicalBraces;
+    mark;
+    matchBase;
+    maxDepth;
+    nobrace;
+    nocase;
+    nodir;
+    noext;
+    noglobstar;
+    pattern;
+    platform;
+    realpath;
+    scurry;
+    stat;
+    signal;
+    windowsPathsNoEscape;
+    withFileTypes;
+    includeChildMatches;
+    /**
+     * The options provided to the constructor.
+     */
+    opts;
+    /**
+     * An array of parsed immutable {@link Pattern} objects.
+     */
+    patterns;
+    /**
+     * All options are stored as properties on the `Glob` object.
+     *
+     * See {@link GlobOptions} for full options descriptions.
+     *
+     * Note that a previous `Glob` object can be passed as the
+     * `GlobOptions` to another `Glob` instantiation to re-use settings
+     * and caches with a new pattern.
+     *
+     * Traversal functions can be called multiple times to run the walk
+     * again.
+     */
+    constructor(pattern, opts) {
+        /* c8 ignore start */
+        if (!opts)
+            throw new TypeError('glob options required');
+        /* c8 ignore stop */
+        this.withFileTypes = !!opts.withFileTypes;
+        this.signal = opts.signal;
+        this.follow = !!opts.follow;
+        this.dot = !!opts.dot;
+        this.dotRelative = !!opts.dotRelative;
+        this.nodir = !!opts.nodir;
+        this.mark = !!opts.mark;
+        if (!opts.cwd) {
+            this.cwd = '';
         }
-        log("term", term);
-        log("fetchinfo", fetchInfo);
-        log("readBytesToSkip", readBytesToSkip);
-        let resp = await customFetch(fetchInfo.url, {
-          headers: {
-            Range: `bytes=${fetchInfo.url_range.start}-${fetchInfo.url_range.end}`
-          }
-        });
-        if (resp.status === 403) {
-          reconstructionInfo = await reloadReconstructionInfo();
-          resp = await customFetch(fetchInfo.url, {
-            headers: {
-              Range: `bytes=${fetchInfo.url_range.start}-${fetchInfo.url_range.end}`
-            }
-          });
+        else if (opts.cwd instanceof URL || opts.cwd.startsWith('file://')) {
+            opts.cwd = require$$0$l.fileURLToPath(opts.cwd);
         }
-        if (!resp.ok) {
-          throw await createApiError(resp);
+        this.cwd = opts.cwd || '';
+        this.root = opts.root;
+        this.magicalBraces = !!opts.magicalBraces;
+        this.nobrace = !!opts.nobrace;
+        this.noext = !!opts.noext;
+        this.realpath = !!opts.realpath;
+        this.absolute = opts.absolute;
+        this.includeChildMatches = opts.includeChildMatches !== false;
+        this.noglobstar = !!opts.noglobstar;
+        this.matchBase = !!opts.matchBase;
+        this.maxDepth =
+            typeof opts.maxDepth === 'number' ? opts.maxDepth : Infinity;
+        this.stat = !!opts.stat;
+        this.ignore = opts.ignore;
+        if (this.withFileTypes && this.absolute !== undefined) {
+            throw new Error('cannot set absolute and withFileTypes:true');
         }
-        log(
-          "expected content length",
-          resp.headers.get("content-length"),
-          "range",
-          fetchInfo.url_range,
-          resp.headers.get("content-range")
-        );
-        const reader = resp.body?.getReader();
-        if (!reader) {
-          throw new Error("Failed to get reader from response body");
+        if (typeof pattern === 'string') {
+            pattern = [pattern];
         }
-        let done = false;
-        let chunkIndex = fetchInfo.range.start;
-        const ranges = rangeList.getRanges(fetchInfo.range.start, fetchInfo.range.end);
-        let leftoverBytes = void 0;
-        let totalFetchBytes = 0;
-        fetchData:
-          while (!done && totalBytesRead < maxBytes) {
-            const result = await reader.read();
-            listener?.({ event: "read" });
-            done = result.done;
-            log("read", result.value?.byteLength, "bytes", "total read", totalBytesRead, "toSkip", readBytesToSkip);
-            if (!result.value) {
-              log("no data in result, cancelled", result);
-              continue;
-            }
-            totalFetchBytes += result.value.byteLength;
-            if (leftoverBytes) {
-              result.value = combineUint8Arrays(leftoverBytes, result.value);
-              leftoverBytes = void 0;
+        this.windowsPathsNoEscape =
+            !!opts.windowsPathsNoEscape ||
+                opts.allowWindowsEscape ===
+                    false;
+        if (this.windowsPathsNoEscape) {
+            pattern = pattern.map(p => p.replace(/\\/g, '/'));
+        }
+        if (this.matchBase) {
+            if (opts.noglobstar) {
+                throw new TypeError('base matching requires globstar');
             }
-            while (totalBytesRead < maxBytes && result.value?.byteLength) {
-              if (result.value.byteLength < 8) {
-                leftoverBytes = result.value;
-                continue fetchData;
-              }
-              const header = new DataView(result.value.buffer, result.value.byteOffset, XET_CHUNK_HEADER_BYTES);
-              const chunkHeader = {
-                version: header.getUint8(0),
-                compressed_length: header.getUint8(1) | header.getUint8(2) << 8 | header.getUint8(3) << 16,
-                compression_scheme: header.getUint8(4),
-                uncompressed_length: header.getUint8(5) | header.getUint8(6) << 8 | header.getUint8(7) << 16
-              };
-              log("chunk header", chunkHeader, "to skip", readBytesToSkip);
-              if (chunkHeader.version !== 0) {
-                throw new Error(`Unsupported chunk version ${chunkHeader.version}`);
-              }
-              if (chunkHeader.compression_scheme !== 0 /* None */ && chunkHeader.compression_scheme !== 1 /* LZ4 */ && chunkHeader.compression_scheme !== 2 /* ByteGroupingLZ4 */) {
-                throw new Error(
-                  `Unsupported compression scheme ${compressionSchemeLabels[chunkHeader.compression_scheme] ?? chunkHeader.compression_scheme}`
-                );
-              }
-              if (result.value.byteLength < chunkHeader.compressed_length + XET_CHUNK_HEADER_BYTES) {
-                leftoverBytes = result.value;
-                continue fetchData;
-              }
-              result.value = result.value.slice(XET_CHUNK_HEADER_BYTES);
-              let uncompressed = chunkHeader.compression_scheme === 1 /* LZ4 */ ? decompress(result.value.slice(0, chunkHeader.compressed_length), chunkHeader.uncompressed_length) : chunkHeader.compression_scheme === 2 /* ByteGroupingLZ4 */ ? bg4_regroup_bytes(
-                decompress(
-                  result.value.slice(0, chunkHeader.compressed_length),
-                  chunkHeader.uncompressed_length
-                )
-              ) : result.value.slice(0, chunkHeader.compressed_length);
-              const range2 = ranges.find((range3) => chunkIndex >= range3.start && chunkIndex < range3.end);
-              const shouldYield = chunkIndex >= term.range.start && chunkIndex < term.range.end;
-              const minRefCountToStore = shouldYield ? 2 : 1;
-              let stored = false;
-              if (range2 && range2.refCount >= minRefCountToStore) {
-                range2.data ??= [];
-                range2.data.push(uncompressed);
-                stored = true;
-              }
-              if (shouldYield) {
-                if (readBytesToSkip) {
-                  const skipped = Math.min(readBytesToSkip, uncompressed.byteLength);
-                  uncompressed = uncompressed.slice(readBytesToSkip);
-                  readBytesToSkip -= skipped;
-                }
-                if (uncompressed.byteLength > maxBytes - totalBytesRead) {
-                  uncompressed = uncompressed.slice(0, maxBytes - totalBytesRead);
-                }
-                if (uncompressed.byteLength) {
-                  log(
-                    "yield",
-                    uncompressed.byteLength,
-                    "bytes",
-                    result.value.byteLength,
-                    "total read",
-                    totalBytesRead,
-                    stored
-                  );
-                  totalBytesRead += uncompressed.byteLength;
-                  yield stored ? uncompressed.slice() : uncompressed;
-                  listener?.({ event: "progress", progress: { read: totalBytesRead, total: maxBytes } });
-                }
-              }
-              chunkIndex++;
-              result.value = result.value.slice(chunkHeader.compressed_length);
+            pattern = pattern.map(p => (p.includes('/') ? p : `./**/${p}`));
+        }
+        this.pattern = pattern;
+        this.platform = opts.platform || defaultPlatform;
+        this.opts = { ...opts, platform: this.platform };
+        if (opts.scurry) {
+            this.scurry = opts.scurry;
+            if (opts.nocase !== undefined &&
+                opts.nocase !== opts.scurry.nocase) {
+                throw new Error('nocase option contradicts provided scurry option');
             }
-          }
-        if (done && totalBytesRead < maxBytes && totalFetchBytes < fetchInfo.url_range.end - fetchInfo.url_range.start + 1) {
-          log("done", done, "total read", totalBytesRead, maxBytes, totalFetchBytes);
-          log("failed to fetch all data for term", term.hash);
-          throw new Error(
-            `Failed to fetch all data for term ${term.hash}, fetched ${totalFetchBytes} bytes out of ${fetchInfo.url_range.end - fetchInfo.url_range.start + 1}`
-          );
         }
-        log("done", done, "total read", totalBytesRead, maxBytes, totalFetchBytes);
-        log("cancel reader");
-        await reader.cancel();
-      }
+        else {
+            const Scurry = opts.platform === 'win32' ? PathScurryWin32
+                : opts.platform === 'darwin' ? PathScurryDarwin
+                    : opts.platform ? PathScurryPosix
+                        : PathScurry;
+            this.scurry = new Scurry(this.cwd, {
+                nocase: opts.nocase,
+                fs: opts.fs,
+            });
+        }
+        this.nocase = this.scurry.nocase;
+        // If you do nocase:true on a case-sensitive file system, then
+        // we need to use regexps instead of strings for non-magic
+        // path portions, because statting `aBc` won't return results
+        // for the file `AbC` for example.
+        const nocaseMagicOnly = this.platform === 'darwin' || this.platform === 'win32';
+        const mmo = {
+            // default nocase based on platform
+            ...opts,
+            dot: this.dot,
+            matchBase: this.matchBase,
+            nobrace: this.nobrace,
+            nocase: this.nocase,
+            nocaseMagicOnly,
+            nocomment: true,
+            noext: this.noext,
+            nonegate: true,
+            optimizationLevel: 2,
+            platform: this.platform,
+            windowsPathsNoEscape: this.windowsPathsNoEscape,
+            debug: !!this.opts.debug,
+        };
+        const mms = this.pattern.map(p => new Minimatch(p, mmo));
+        const [matchSet, globParts] = mms.reduce((set, m) => {
+            set[0].push(...m.set);
+            set[1].push(...m.globParts);
+            return set;
+        }, [[], []]);
+        this.patterns = matchSet.map((set, i) => {
+            const g = globParts[i];
+            /* c8 ignore start */
+            if (!g)
+                throw new Error('invalid pattern object');
+            /* c8 ignore stop */
+            return new Pattern(set, g, 0, this.platform);
+        });
     }
-    const iterator = readData(
-      this.reconstructionInfo,
-      this.fetch,
-      this.end - this.start,
-      this.#loadReconstructionInfo.bind(this)
-    );
-    return new ReadableStream(
-      {
-        // todo: when Safari supports it, type controller as ReadableByteStreamController
-        async pull(controller) {
-          const result = await iterator.next();
-          if (result.value) {
-            controller.enqueue(result.value);
-          }
-          if (result.done) {
-            controller.close();
-          }
-        },
-        type: "bytes"
-        // todo: when Safari supports it, add autoAllocateChunkSize param
-      },
-      // todo : use ByteLengthQueuingStrategy when there's good support for it, currently in Node.js it fails due to size being a function
-      {
-        highWaterMark: 1e3
-        // 1_000 chunks for ~1MB of RAM
-      }
-    );
-  }
-  async arrayBuffer() {
-    const result = await this.#fetch();
-    return new Response(result).arrayBuffer();
-  }
-  async text() {
-    const result = await this.#fetch();
-    return new Response(result).text();
-  }
-  async response() {
-    const result = await this.#fetch();
-    return new Response(result);
-  }
-  stream() {
-    const stream = new TransformStream();
-    this.#fetch().then((response) => response.pipeThrough(stream)).catch((error) => stream.writable.abort(error.message));
-    return stream.readable;
-  }
-};
-var jwtPromises = /* @__PURE__ */ new Map();
-var jwts = /* @__PURE__ */ new Map();
-function cacheKey(params) {
-  return JSON.stringify([params.refreshUrl, params.initialAccessToken]);
-}
-function bg4_regroup_bytes(bytes) {
-  const split = Math.floor(bytes.byteLength / 4);
-  const rem = bytes.byteLength % 4;
-  const g1_pos = split + (rem >= 1 ? 1 : 0);
-  const g2_pos = g1_pos + split + (rem >= 2 ? 1 : 0);
-  const g3_pos = g2_pos + split + (rem == 3 ? 1 : 0);
-  const ret = new Uint8Array(bytes.byteLength);
-  for (let i = 0, j = 0; i < bytes.byteLength; i += 4, j++) {
-    ret[i] = bytes[j];
-  }
-  for (let i = 1, j = g1_pos; i < bytes.byteLength; i += 4, j++) {
-    ret[i] = bytes[j];
-  }
-  for (let i = 2, j = g2_pos; i < bytes.byteLength; i += 4, j++) {
-    ret[i] = bytes[j];
-  }
-  for (let i = 3, j = g3_pos; i < bytes.byteLength; i += 4, j++) {
-    ret[i] = bytes[j];
-  }
-  return ret;
-}
-async function getAccessToken(initialAccessToken, customFetch, refreshUrl) {
-  const key = cacheKey({ refreshUrl, initialAccessToken });
-  const jwt = jwts.get(key);
-  if (jwt && jwt.expiresAt > new Date(Date.now() + JWT_SAFETY_PERIOD)) {
-    return { accessToken: jwt.accessToken, casUrl: jwt.casUrl };
-  }
-  const existingPromise = jwtPromises.get(key);
-  if (existingPromise) {
-    return existingPromise;
-  }
-  const promise = (async () => {
-    const resp = await customFetch(refreshUrl, {
-      headers: {
-        ...initialAccessToken ? {
-          Authorization: `Bearer ${initialAccessToken}`
-        } : {}
-      }
-    });
-    if (!resp.ok) {
-      throw new Error(`Failed to get JWT token: ${resp.status} ${await resp.text()}`);
+    async walk() {
+        // Walkers always return array of Path objects, so we just have to
+        // coerce them into the right shape.  It will have already called
+        // realpath() if the option was set to do so, so we know that's cached.
+        // start out knowing the cwd, at least
+        return [
+            ...(await new GlobWalker(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: this.maxDepth !== Infinity ?
+                    this.maxDepth + this.scurry.cwd.depth()
+                    : Infinity,
+                platform: this.platform,
+                nocase: this.nocase,
+                includeChildMatches: this.includeChildMatches,
+            }).walk()),
+        ];
     }
-    const json = await resp.json();
-    const jwt2 = {
-      accessToken: json.accessToken,
-      expiresAt: new Date(json.exp * 1e3),
-      casUrl: json.casUrl
-    };
-    jwtPromises.delete(key);
-    for (const [key2, value] of jwts.entries()) {
-      if (value.expiresAt < new Date(Date.now() + JWT_SAFETY_PERIOD)) {
-        jwts.delete(key2);
-      } else {
-        break;
-      }
+    walkSync() {
+        return [
+            ...new GlobWalker(this.patterns, this.scurry.cwd, {
+                ...this.opts,
+                maxDepth: this.maxDepth !== Infinity ?
+                    this.maxDepth + this.scurry.cwd.depth()
+                    : Infinity,
+                platform: this.platform,
+                nocase: this.nocase,
+                includeChildMatches: this.includeChildMatches,
+            }).walkSync(),
+        ];
     }
-    if (jwts.size >= JWT_CACHE_SIZE) {
-      const keyToDelete = jwts.keys().next().value;
-      if (keyToDelete) {
-        jwts.delete(keyToDelete);
-      }
+    stream() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ?
+                this.maxDepth + this.scurry.cwd.depth()
+                : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches,
+        }).stream();
+    }
+    streamSync() {
+        return new GlobStream(this.patterns, this.scurry.cwd, {
+            ...this.opts,
+            maxDepth: this.maxDepth !== Infinity ?
+                this.maxDepth + this.scurry.cwd.depth()
+                : Infinity,
+            platform: this.platform,
+            nocase: this.nocase,
+            includeChildMatches: this.includeChildMatches,
+        }).streamSync();
+    }
+    /**
+     * Default sync iteration function. Returns a Generator that
+     * iterates over the results.
+     */
+    iterateSync() {
+        return this.streamSync()[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+        return this.iterateSync();
+    }
+    /**
+     * Default async iteration function. Returns an AsyncGenerator that
+     * iterates over the results.
+     */
+    iterate() {
+        return this.stream()[Symbol.asyncIterator]();
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterate();
     }
-    jwts.set(key, jwt2);
-    return {
-      accessToken: json.accessToken,
-      casUrl: json.casUrl
-    };
-  })();
-  jwtPromises.set(key, promise);
-  return promise;
 }
 
-// src/utils/WebBlob.ts
-var WebBlob = class extends Blob {
-  static async create(url, opts) {
-    const customFetch = opts?.fetch ?? fetch;
-    const response = await customFetch(url, {
-      method: "HEAD",
-      ...opts?.accessToken && {
-        headers: {
-          Authorization: `Bearer ${opts.accessToken}`
-        }
-      }
-    });
-    const size = Number(response.headers.get("content-length"));
-    const contentType = response.headers.get("content-type") || "";
-    const supportRange = response.headers.get("accept-ranges") === "bytes";
-    if (!supportRange || size < (opts?.cacheBelow ?? 1e6)) {
-      return await (await customFetch(url)).blob();
+/**
+ * Return true if the patterns provided contain any magic glob characters,
+ * given the options provided.
+ *
+ * Brace expansion is not considered "magic" unless the `magicalBraces` option
+ * is set, as brace expansion just turns one string into an array of strings.
+ * So a pattern like `'x{a,b}y'` would return `false`, because `'xay'` and
+ * `'xby'` both do not contain any magic glob characters, and it's treated the
+ * same as if you had called it on `['xay', 'xby']`. When `magicalBraces:true`
+ * is in the options, brace expansion _is_ treated as a pattern having magic.
+ */
+const hasMagic = (pattern, options = {}) => {
+    if (!Array.isArray(pattern)) {
+        pattern = [pattern];
     }
-    return new WebBlob(url, 0, size, contentType, true, customFetch, opts?.accessToken);
-  }
-  url;
-  start;
-  end;
-  contentType;
-  full;
-  fetch;
-  accessToken;
-  constructor(url, start, end, contentType, full, customFetch, accessToken) {
-    super([]);
-    this.url = url;
-    this.start = start;
-    this.end = end;
-    this.contentType = contentType;
-    this.full = full;
-    this.fetch = customFetch;
-    this.accessToken = accessToken;
-  }
-  get size() {
-    return this.end - this.start;
-  }
-  get type() {
-    return this.contentType;
-  }
-  slice(start = 0, end = this.size) {
-    const slice = new WebBlob(
-      this.url,
-      this.start + start,
-      Math.min(this.start + end, this.end),
-      this.contentType,
-      start === 0 && end === this.size ? this.full : false,
-      this.fetch,
-      this.accessToken
-    );
-    return slice;
-  }
-  async arrayBuffer() {
-    const result = await this.fetchRange();
-    return result.arrayBuffer();
-  }
-  async text() {
-    const result = await this.fetchRange();
-    return result.text();
-  }
-  stream() {
-    const stream = new TransformStream();
-    this.fetchRange().then((response) => response.body?.pipeThrough(stream)).catch((error) => stream.writable.abort(error.message));
-    return stream.readable;
-  }
-  fetchRange() {
-    const fetch2 = this.fetch;
-    if (this.full) {
-      return fetch2(this.url, {
-        ...this.accessToken && {
-          headers: {
-            Authorization: `Bearer ${this.accessToken}`
-          }
-        }
-      }).then((resp) => resp.ok ? resp : createApiError(resp));
+    for (const p of pattern) {
+        if (new Minimatch(p, options).hasMagic())
+            return true;
     }
-    return fetch2(this.url, {
-      headers: {
-        Range: `bytes=${this.start}-${this.end - 1}`,
-        ...this.accessToken && { Authorization: `Bearer ${this.accessToken}` }
-      }
-    }).then((resp) => resp.ok ? resp : createApiError(resp));
-  }
+    return false;
 };
 
-// src/utils/parseLinkHeader.ts
-function parseLinkHeader(header) {
-  const regex = /<(https?:[/][/][^>]+)>;\s+rel="([^"]+)"/g;
-  return Object.fromEntries([...header.matchAll(regex)].map(([, url, rel]) => [rel, url]));
+function globStreamSync(pattern, options = {}) {
+    return new Glob(pattern, options).streamSync();
+}
+function globStream(pattern, options = {}) {
+    return new Glob(pattern, options).stream();
+}
+function globSync(pattern, options = {}) {
+    return new Glob(pattern, options).walkSync();
+}
+async function glob_(pattern, options = {}) {
+    return new Glob(pattern, options).walk();
+}
+function globIterateSync(pattern, options = {}) {
+    return new Glob(pattern, options).iterateSync();
+}
+function globIterate(pattern, options = {}) {
+    return new Glob(pattern, options).iterate();
 }
+// aliases: glob.sync.stream() glob.stream.sync() glob.sync() etc
+const streamSync = globStreamSync;
+const stream = Object.assign(globStream, { sync: globStreamSync });
+const iterateSync = globIterateSync;
+const iterate = Object.assign(globIterate, {
+    sync: globIterateSync,
+});
+const sync = Object.assign(globSync, {
+    stream: globStreamSync,
+    iterate: globIterateSync,
+});
+const glob = Object.assign(glob_, {
+    glob: glob_,
+    globSync,
+    sync,
+    globStream,
+    stream,
+    globStreamSync,
+    streamSync,
+    globIterate,
+    iterate,
+    globIterateSync,
+    iterateSync,
+    Glob,
+    hasMagic,
+    escape: escape$1,
+    unescape: unescape$1,
+});
+glob.glob = glob;
 
-// src/lib/file-download-info.ts
-async function fileDownloadInfo(params) {
-  const accessToken = checkCredentials(params);
-  const repoId = toRepoId(params.repo);
-  const hubUrl = params.hubUrl ?? HUB_URL;
-  const url = `${hubUrl}/${repoId.type === "model" ? "" : `${repoId.type}s/`}${repoId.name}/${params.raw ? "raw" : "resolve"}/${encodeURIComponent(params.revision ?? "main")}/${params.path}` + (params.noContentDisposition ? "?noContentDisposition=1" : "");
-  const resp = await (params.fetch ?? fetch)(url, {
-    method: "GET",
-    headers: {
-      ...accessToken && {
-        Authorization: `Bearer ${accessToken}`
-      },
-      Range: "bytes=0-0",
-      Accept: "application/vnd.xet-fileinfo+json, */*"
+function matchesQuantizationVariant({ filePath, variant }) {
+    if (!variant) {
+        return false;
     }
-  });
-  if (resp.status === 404 && resp.headers.get("X-Error-Code") === "EntryNotFound") {
-    return null;
-  }
-  if (!resp.ok) {
-    throw await createApiError(resp);
-  }
-  let size;
-  let xetInfo;
-  if (resp.headers.get("Content-Type")?.includes("application/vnd.xet-fileinfo+json")) {
-    size = parseInt(resp.headers.get("X-Linked-Size") ?? "invalid");
-    if (isNaN(size)) {
-      throw new InvalidApiResponseFormatError("Invalid file size received in X-Linked-Size header");
+    const escapedVariant = variant.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const matcher = new RegExp(`(^|[\\-./_])${escapedVariant}(?=[\\-./]|$)`, "i");
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    const segments = normalizedPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+        return false;
     }
-    const hash2 = resp.headers.get("X-Xet-Hash");
-    const links = parseLinkHeader(resp.headers.get("Link") ?? "");
-    const reconstructionUrl = (() => {
-      try {
-        return new URL(links["xet-reconstruction-info"]);
-      } catch {
-        return null;
-      }
-    })();
-    const refreshUrl = (() => {
-      try {
-        return new URL(links["xet-auth"]);
-      } catch {
-        return null;
-      }
-    })();
-    if (!hash2) {
-      throw new InvalidApiResponseFormatError("No hash received in X-Xet-Hash header");
+    const filename = segments[segments.length - 1].replace(/\.gguf$/i, "");
+    if (matcher.test(filename)) {
+        return true;
     }
-    if (!reconstructionUrl || !refreshUrl) {
-      throw new InvalidApiResponseFormatError("No xet-reconstruction-info or xet-auth link header");
+    return segments.slice(0, -1).some(segment => matcher.test(segment));
+}
+async function findQuantizedModelTarget({ model, path }) {
+    if (model.source.type === "storage") {
+        throw new Error("Model storage not supported yet");
     }
-    xetInfo = {
-      hash: hash2,
-      refreshUrl,
-      reconstructionUrl
-    };
-  }
-  if (size === void 0 || isNaN(size)) {
-    const contentRangeHeader = resp.headers.get("content-range");
-    if (!contentRangeHeader) {
-      throw new InvalidApiResponseFormatError("Expected size information");
+    if (model.format !== "gguf") {
+        throw new Error(`Model format not supported: ${model.format}`);
     }
-    const [, parsedSize] = contentRangeHeader.split("/");
-    size = parseInt(parsedSize);
-    if (isNaN(size)) {
-      throw new InvalidApiResponseFormatError("Invalid file size received");
+    const [, variant = null] = model.source.slug.split(":");
+    const modelFiles = (await glob("**/*.gguf", {
+        absolute: true,
+        cwd: path,
+        nodir: true
+    })).filter(file => !/(mmproj|clip)/i.test(file));
+    if (modelFiles.length <= 0) {
+        throw new Error(`No models found for format: ${model.format}`);
     }
-  }
-  const etag = resp.headers.get("X-Linked-ETag") ?? resp.headers.get("ETag") ?? void 0;
-  if (!etag) {
-    throw new InvalidApiResponseFormatError("Expected ETag");
-  }
-  return {
-    etag,
-    size,
-    xet: xetInfo,
-    // Cannot use resp.url in case it's a S3 url and the user adds an Authorization header to it.
-    url: resp.url && (new URL(resp.url).origin === new URL(hubUrl).origin || resp.headers.get("X-Cache")?.endsWith(" cloudfront")) ? resp.url : url
-  };
-}
-
-// src/lib/download-file.ts
-async function downloadFile(params) {
-  const accessToken = checkCredentials(params);
-  const info = params.downloadInfo ?? await fileDownloadInfo({
-    accessToken,
-    repo: params.repo,
-    path: params.path,
-    revision: params.revision,
-    hubUrl: params.hubUrl,
-    fetch: params.fetch,
-    raw: params.raw
-  });
-  if (!info) {
-    return null;
-  }
-  if (info.xet && params.xet) {
-    return new XetBlob({
-      refreshUrl: info.xet.refreshUrl.href,
-      reconstructionUrl: info.xet.reconstructionUrl.href,
-      fetch: params.fetch,
-      accessToken,
-      size: info.size
-    });
-  }
-  return new WebBlob(new URL(info.url), 0, info.size, "", true, params.fetch ?? fetch, accessToken);
+    modelFiles.sort((left, right) => left.localeCompare(right, undefined, { sensitivity: "base" }));
+    if (!variant) {
+        return modelFiles[0];
+    }
+    const matches = modelFiles.filter(fileName => matchesQuantizationVariant({ filePath: fileName, variant: variant ?? "" }));
+    if (matches.length === 0) {
+        throw new Error(`No model found for format and variant: ${model.format} / ${variant}`);
+    }
+    return matches[0];
 }
 
-// src/lib/list-files.ts
-async function* listFiles(params) {
-  const accessToken = checkCredentials(params);
-  const repoId = toRepoId(params.repo);
-  let url = `${params.hubUrl || HUB_URL}/api/${repoId.type}s/${repoId.name}/tree/${params.revision || "main"}${params.path ? "/" + params.path : ""}?recursive=${!!params.recursive}&expand=${!!params.expand}`;
-  while (url) {
-    const res = await (params.fetch ?? fetch)(url, {
-      headers: {
-        accept: "application/json",
-        ...accessToken ? { Authorization: `Bearer ${accessToken}` } : void 0
-      }
-    });
-    if (!res.ok) {
-      throw await createApiError(res);
+const VLLM_START_ARGS = ["-m", "vllm.entrypoints.openai.api_server", "--host", "0.0.0.0"];
+const VLLM_EXECUTABLE = "python3";
+const DEFAULT_VLLM_CONTEXT_LENGTH = 2048;
+async function startVLLM({ enginePort, targetDirectory }) {
+    const contextLength = Math.max(1, this.contextLength ?? DEFAULT_VLLM_CONTEXT_LENGTH);
+    let modelPath = targetDirectory;
+    if (this.model.format === "gguf") {
+        modelPath = await findQuantizedModelTarget({ model: this.model, path: targetDirectory });
     }
-    const items = await res.json();
-    for (const item of items) {
-      yield item;
+    const engineConfig = this.engineConfig;
+    const device = typeof engineConfig?.device === "string" ? engineConfig.device : process.env.VLLM_DEVICE;
+    const dtype = typeof engineConfig?.dtype === "string" ? engineConfig.dtype : process.env.VLLM_DTYPE;
+    const tensorParallelSize = typeof engineConfig?.tensorParallelSize === "number" ? engineConfig.tensorParallelSize : 1;
+    const args = [
+        ...VLLM_START_ARGS,
+        "--port",
+        String(enginePort),
+        "--model",
+        modelPath,
+        "--served-model-name",
+        SERVED_MODEL_NAME,
+        "--max-model-len",
+        String(contextLength),
+        "--tensor-parallel-size",
+        String(tensorParallelSize)
+    ];
+    if (this.model.taskType === "embeddings") {
+        args.push("--task", "embed");
     }
-    const linkHeader = res.headers.get("Link");
-    url = linkHeader ? parseLinkHeader(linkHeader).next : void 0;
-  }
+    args.push(...(await getChatTemplateEngineArgs({
+        engine: this.engine,
+        model: this.model,
+        targetDirectory
+    })));
+    if (device) {
+        args.push("--device", device);
+    }
+    if (dtype) {
+        args.push("--dtype", dtype);
+    }
+    args.push(...parseExtraArgs(engineConfig?.extraArgs));
+    if (this.model.multimodalEnabled) {
+        args.push("--limit-mm-per-prompt", process.env.VLLM_MM_LIMIT ?? '{"image":5}');
+    }
+    if (process.env.VLLM_TRUST_REMOTE_CODE === "true") {
+        args.push("--trust-remote-code");
+    }
+    return createEngineProcess({ args, bin: VLLM_EXECUTABLE, logger: this.logger });
 }
 
 const ModelDownloadProgressSchema = object$1({
@@ -123129,6 +123324,11 @@ async function startLlamacpp({ enginePort, targetDirectory }) {
         "--ctx-size",
         String(contextLength)
     ];
+    args.push(...(await getChatTemplateEngineArgs({
+        engine: this.engine,
+        model: this.model,
+        targetDirectory
+    })));
     if (this.model.taskType === "embeddings") {
         args.push("--embedding");
     }
@@ -123268,6 +123468,11 @@ async function startSGLang({ enginePort, targetDirectory }) {
     if (this.model.taskType === "embeddings") {
         args.push("--task", "embed");
     }
+    args.push(...(await getChatTemplateEngineArgs({
+        engine: this.engine,
+        model: this.model,
+        targetDirectory
+    })));
     if (device) {
         args.push("--device", device);
     }
@@ -123348,6 +123553,15 @@ class ModelManager extends EventEmitter {
         this.uniqueName = createModelStorageKey(this.model);
         this.modelsDirectory = path$1.join(root, "models");
     }
+    async verifyChatTemplate() {
+        return verifyEngineChatTemplate({
+            engine: this.engine,
+            enginePort: this.enginePort,
+            logger: this.logger,
+            model: this.model,
+            targetDirectory: path$1.join(this.modelsDirectory, this.uniqueName)
+        });
+    }
     async fetchOpenAI(path, opts) {
         switch (this.engine) {
             case "exllamav3":
@@ -123425,6 +123639,12 @@ class ModelManager extends EventEmitter {
                 finally {
                     await this.releaseDownloadLock();
                 }
+                await materializeChatTemplate({
+                    engine: this.engine,
+                    huggingFaceToken: this.model.source.modelSecret,
+                    model: this.model,
+                    targetDirectory: path$1.join(this.modelsDirectory, this.uniqueName)
+                });
                 break;
             default: {
                 const engineType = this.engine;
@@ -124408,7 +124628,50 @@ function stripImagesFromBody(body) {
 function isPlainObject$3(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function serializeRequestBody$1(body) {
+/**
+ * Builds `chat_template_kwargs` for engines that read template variables at
+ * render time. Only active when the model carries a template override or
+ * thinking config; otherwise the body forwards untouched (engines like vLLM
+ * consume top-level `reasoning_effort` natively for supported models).
+ *
+ * Precedence (highest wins):
+ * 1. Request `chat_template_kwargs` (per key)
+ * 2. Request top-level `reasoning_effort`
+ * 3. Model thinking config defaults
+ */
+function applyChatTemplateKwargs({ body, model }) {
+    const hasTemplateOverride = Boolean(model.chatTemplate);
+    const thinkingConfig = model.thinkingConfig ?? null;
+    if (!hasTemplateOverride && !thinkingConfig)
+        return body;
+    const requestKwargs = isPlainObject$3(body.chat_template_kwargs)
+        ? body.chat_template_kwargs
+        : null;
+    const requestEffort = typeof body.reasoning_effort === "string" ? body.reasoning_effort : null;
+    const mergedKwargs = {};
+    if (thinkingConfig?.enabled === false) {
+        mergedKwargs.enable_thinking = false;
+    }
+    if (thinkingConfig?.effort) {
+        mergedKwargs.reasoning_effort = thinkingConfig.effort;
+    }
+    if (requestKwargs) {
+        Object.assign(mergedKwargs, requestKwargs);
+    }
+    const hasRequestReasoningEffort = requestKwargs !== null && "reasoning_effort" in requestKwargs;
+    if (requestEffort && !hasRequestReasoningEffort) {
+        mergedKwargs.reasoning_effort = requestEffort;
+    }
+    const payload = { ...body };
+    if (Object.keys(mergedKwargs).length > 0) {
+        payload.chat_template_kwargs = mergedKwargs;
+    }
+    if (requestEffort !== null) {
+        delete payload.reasoning_effort;
+    }
+    return payload;
+}
+function serializeRequestBody$1(body, { model, path } = {}) {
     if (!isPlainObject$3(body)) {
         const payload = typeof body === "string" ? body : JSON.stringify(body);
         return {
@@ -124416,7 +124679,10 @@ function serializeRequestBody$1(body) {
             payload
         };
     }
-    const requestPayload = { ...body };
+    let requestPayload = { ...body };
+    if (path === "/v1/chat/completions" && model) {
+        requestPayload = applyChatTemplateKwargs({ body: requestPayload, model });
+    }
     if (requestPayload.stream === true) {
         const streamOptions = requestPayload.stream_options;
         const normalizedStreamOptions = isPlainObject$3(streamOptions)
@@ -124615,7 +124881,7 @@ async function proxyOpenAIStreamingRoute({ body, conduitConfiguration, endpointI
     const engineType = conduitConfiguration.engineConfig?.type ?? null;
     const engineConfig = conduitConfiguration.engineConfig?.config ?? null;
     const effectiveBody = modelManager.model.multimodalEnabled ? body : stripImagesFromBody(body);
-    const { bytes: requestBodyBytes, payload: serializedBody } = serializeRequestBody$1(effectiveBody);
+    const { bytes: requestBodyBytes, payload: serializedBody } = serializeRequestBody$1(effectiveBody, { model: modelManager.model, path });
     const requestStartedAt = Date.now();
     const requestBody = JSON.parse(serializedBody);
     const streamRequested = requestBody.stream === true;
@@ -125001,6 +125267,17 @@ function translateAnthropicRequestToOpenAI(body) {
         result.top_p = parsed.top_p;
     if (Array.isArray(parsed.stop_sequences))
         result.stop = parsed.stop_sequences;
+    if (parsed.thinking && typeof parsed.thinking === "object") {
+        const thinking = parsed.thinking;
+        if (thinking.type === "enabled") {
+            const budgetTokens = typeof thinking.budget_tokens === "number" ? thinking.budget_tokens : null;
+            result.chat_template_kwargs = {
+                reasoning_effort: budgetTokens
+                    ? reasoningEffortForAnthropicBudget(budgetTokens)
+                    : "high"
+            };
+        }
+    }
     if (Array.isArray(parsed.tools)) {
         result.tools = parsed.tools.map((tool) => {
             const t = tool;
@@ -125272,11 +125549,13 @@ async function proxyAnthropicStreamingRoute({ body, conduitConfiguration, endpoi
     const requestStartedAt = Date.now();
     const requestBody = JSON.parse(serializedBody);
     const streamRequested = requestBody.stream === true;
-    const targetPath = needsTranslation
-        ? translateAnthropicRequestToOpenAI(serializedBody).path
-        : "/v1/messages";
-    const targetBody = needsTranslation
-        ? translateAnthropicRequestToOpenAI(serializedBody).body
+    const translated = needsTranslation ? translateAnthropicRequestToOpenAI(serializedBody) : null;
+    const targetPath = translated?.path ?? "/v1/messages";
+    const targetBody = translated
+        ? JSON.stringify(applyChatTemplateKwargs({
+            body: JSON.parse(translated.body),
+            model: modelManager.model
+        }))
         : serializedBody;
     const onMonitoringComplete = ({ durationMs, error, responseBytes, timeToFirstTokenMs, usage }) => {
         const promptTokens = normalizeTokenCount(usage?.inputTokens);
@@ -156174,13 +156453,14 @@ async function createApplication({ abortController, apiClient, configuration, lo
         });
         conduitStateReportManager.reportStateChange();
     };
-    const setOnlineState = () => {
-        if (conduitStateManager.getState().state === "online") {
+    const setOnlineState = ({ warnings } = {}) => {
+        if (conduitStateManager.getState().state === "online" && warnings === undefined) {
             return;
         }
         conduitStateManager.setState({
             modelName,
-            state: "online"
+            state: "online",
+            ...(warnings !== undefined ? { warnings } : {})
         });
         conduitStateReportManager.reportStateChange();
     };
@@ -156202,6 +156482,23 @@ async function createApplication({ abortController, apiClient, configuration, lo
         });
         modelManager.on("engineReady", () => {
             setOnlineState();
+            const readyModelManager = modelManager;
+            readyModelManager
+                .verifyChatTemplate()
+                .then(warning => {
+                if (modelManager !== readyModelManager) {
+                    return;
+                }
+                if (warning) {
+                    logger.warn("Chat template verification", { warning });
+                    setOnlineState({ warnings: [warning] });
+                }
+            })
+                .catch(error => {
+                logger.warn("Chat template verification failed", {
+                    error: asError(error)
+                });
+            });
         });
         modelManager.on("engineTerminated", () => {
             if (stopRequestedByControl) {