privateer-agent 0.15.4 → 0.15.6

package/dist-boot/c-EX4YVWAT.mjs

@@ -0,0 +1,378 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  FormData,
+  file_default,
+  init_esm_min,
+  init_from
+} from "./c-5XY6MFKN.mjs";
+import {
+  __esm,
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/node-fetch/src/utils/multipart-parser.js
+function _fileName(headerValue) {
+  const m = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
+  if (!m) {
+    return;
+  }
+  const match = m[2] || m[3] || "";
+  let filename = match.slice(match.lastIndexOf("\\") + 1);
+  filename = filename.replace(/%22/g, '"');
+  filename = filename.replace(/&#(\d{4});/g, (m2, code) => {
+    return String.fromCharCode(code);
+  });
+  return filename;
+}
+async function toFormData(Body, ct) {
+  if (!/multipart/i.test(ct)) {
+    throw new TypeError("Failed to fetch");
+  }
+  const m = ct.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+  if (!m) {
+    throw new TypeError("no or bad content-type header, no multipart boundary");
+  }
+  const parser = new MultipartParser(m[1] || m[2]);
+  let headerField;
+  let headerValue;
+  let entryValue;
+  let entryName;
+  let contentType;
+  let filename;
+  const entryChunks = [];
+  const formData = new FormData();
+  const onPartData = /* @__PURE__ */ __name((ui8a) => {
+    entryValue += decoder.decode(ui8a, { stream: true });
+  }, "onPartData");
+  const appendToFile = /* @__PURE__ */ __name((ui8a) => {
+    entryChunks.push(ui8a);
+  }, "appendToFile");
+  const appendFileToFormData = /* @__PURE__ */ __name(() => {
+    const file = new file_default(entryChunks, filename, { type: contentType });
+    formData.append(entryName, file);
+  }, "appendFileToFormData");
+  const appendEntryToFormData = /* @__PURE__ */ __name(() => {
+    formData.append(entryName, entryValue);
+  }, "appendEntryToFormData");
+  const decoder = new TextDecoder("utf-8");
+  decoder.decode();
+  parser.onPartBegin = function() {
+    parser.onPartData = onPartData;
+    parser.onPartEnd = appendEntryToFormData;
+    headerField = "";
+    headerValue = "";
+    entryValue = "";
+    entryName = "";
+    contentType = "";
+    filename = null;
+    entryChunks.length = 0;
+  };
+  parser.onHeaderField = function(ui8a) {
+    headerField += decoder.decode(ui8a, { stream: true });
+  };
+  parser.onHeaderValue = function(ui8a) {
+    headerValue += decoder.decode(ui8a, { stream: true });
+  };
+  parser.onHeaderEnd = function() {
+    headerValue += decoder.decode();
+    headerField = headerField.toLowerCase();
+    if (headerField === "content-disposition") {
+      const m2 = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
+      if (m2) {
+        entryName = m2[2] || m2[3] || "";
+      }
+      filename = _fileName(headerValue);
+      if (filename) {
+        parser.onPartData = appendToFile;
+        parser.onPartEnd = appendFileToFormData;
+      }
+    } else if (headerField === "content-type") {
+      contentType = headerValue;
+    }
+    headerValue = "";
+    headerField = "";
+  };
+  for await (const chunk of Body) {
+    parser.write(chunk);
+  }
+  parser.end();
+  return formData;
+}
+var s, S, f, F, LF, CR, SPACE, HYPHEN, COLON, A, Z, lower, noop, MultipartParser;
+var init_multipart_parser = __esm({
+  "node_modules/node-fetch/src/utils/multipart-parser.js"() {
+    init_from();
+    init_esm_min();
+    s = 0;
+    S = {
+      START_BOUNDARY: s++,
+      HEADER_FIELD_START: s++,
+      HEADER_FIELD: s++,
+      HEADER_VALUE_START: s++,
+      HEADER_VALUE: s++,
+      HEADER_VALUE_ALMOST_DONE: s++,
+      HEADERS_ALMOST_DONE: s++,
+      PART_DATA_START: s++,
+      PART_DATA: s++,
+      END: s++
+    };
+    f = 1;
+    F = {
+      PART_BOUNDARY: f,
+      LAST_BOUNDARY: f *= 2
+    };
+    LF = 10;
+    CR = 13;
+    SPACE = 32;
+    HYPHEN = 45;
+    COLON = 58;
+    A = 97;
+    Z = 122;
+    lower = /* @__PURE__ */ __name((c) => c | 32, "lower");
+    noop = /* @__PURE__ */ __name(() => {
+    }, "noop");
+    MultipartParser = class {
+      static {
+        __name(this, "MultipartParser");
+      }
+      /**
+       * @param {string} boundary
+       */
+      constructor(boundary) {
+        this.index = 0;
+        this.flags = 0;
+        this.onHeaderEnd = noop;
+        this.onHeaderField = noop;
+        this.onHeadersEnd = noop;
+        this.onHeaderValue = noop;
+        this.onPartBegin = noop;
+        this.onPartData = noop;
+        this.onPartEnd = noop;
+        this.boundaryChars = {};
+        boundary = "\r\n--" + boundary;
+        const ui8a = new Uint8Array(boundary.length);
+        for (let i = 0; i < boundary.length; i++) {
+          ui8a[i] = boundary.charCodeAt(i);
+          this.boundaryChars[ui8a[i]] = true;
+        }
+        this.boundary = ui8a;
+        this.lookbehind = new Uint8Array(this.boundary.length + 8);
+        this.state = S.START_BOUNDARY;
+      }
+      /**
+       * @param {Uint8Array} data
+       */
+      write(data) {
+        let i = 0;
+        const length_ = data.length;
+        let previousIndex = this.index;
+        let { lookbehind, boundary, boundaryChars, index, state, flags } = this;
+        const boundaryLength = this.boundary.length;
+        const boundaryEnd = boundaryLength - 1;
+        const bufferLength = data.length;
+        let c;
+        let cl;
+        const mark = /* @__PURE__ */ __name((name) => {
+          this[name + "Mark"] = i;
+        }, "mark");
+        const clear = /* @__PURE__ */ __name((name) => {
+          delete this[name + "Mark"];
+        }, "clear");
+        const callback = /* @__PURE__ */ __name((callbackSymbol, start, end, ui8a) => {
+          if (start === void 0 || start !== end) {
+            this[callbackSymbol](ui8a && ui8a.subarray(start, end));
+          }
+        }, "callback");
+        const dataCallback = /* @__PURE__ */ __name((name, clear2) => {
+          const markSymbol = name + "Mark";
+          if (!(markSymbol in this)) {
+            return;
+          }
+          if (clear2) {
+            callback(name, this[markSymbol], i, data);
+            delete this[markSymbol];
+          } else {
+            callback(name, this[markSymbol], data.length, data);
+            this[markSymbol] = 0;
+          }
+        }, "dataCallback");
+        for (i = 0; i < length_; i++) {
+          c = data[i];
+          switch (state) {
+            case S.START_BOUNDARY:
+              if (index === boundary.length - 2) {
+                if (c === HYPHEN) {
+                  flags |= F.LAST_BOUNDARY;
+                } else if (c !== CR) {
+                  return;
+                }
+                index++;
+                break;
+              } else if (index - 1 === boundary.length - 2) {
+                if (flags & F.LAST_BOUNDARY && c === HYPHEN) {
+                  state = S.END;
+                  flags = 0;
+                } else if (!(flags & F.LAST_BOUNDARY) && c === LF) {
+                  index = 0;
+                  callback("onPartBegin");
+                  state = S.HEADER_FIELD_START;
+                } else {
+                  return;
+                }
+                break;
+              }
+              if (c !== boundary[index + 2]) {
+                index = -2;
+              }
+              if (c === boundary[index + 2]) {
+                index++;
+              }
+              break;
+            case S.HEADER_FIELD_START:
+              state = S.HEADER_FIELD;
+              mark("onHeaderField");
+              index = 0;
+            // falls through
+            case S.HEADER_FIELD:
+              if (c === CR) {
+                clear("onHeaderField");
+                state = S.HEADERS_ALMOST_DONE;
+                break;
+              }
+              index++;
+              if (c === HYPHEN) {
+                break;
+              }
+              if (c === COLON) {
+                if (index === 1) {
+                  return;
+                }
+                dataCallback("onHeaderField", true);
+                state = S.HEADER_VALUE_START;
+                break;
+              }
+              cl = lower(c);
+              if (cl < A || cl > Z) {
+                return;
+              }
+              break;
+            case S.HEADER_VALUE_START:
+              if (c === SPACE) {
+                break;
+              }
+              mark("onHeaderValue");
+              state = S.HEADER_VALUE;
+            // falls through
+            case S.HEADER_VALUE:
+              if (c === CR) {
+                dataCallback("onHeaderValue", true);
+                callback("onHeaderEnd");
+                state = S.HEADER_VALUE_ALMOST_DONE;
+              }
+              break;
+            case S.HEADER_VALUE_ALMOST_DONE:
+              if (c !== LF) {
+                return;
+              }
+              state = S.HEADER_FIELD_START;
+              break;
+            case S.HEADERS_ALMOST_DONE:
+              if (c !== LF) {
+                return;
+              }
+              callback("onHeadersEnd");
+              state = S.PART_DATA_START;
+              break;
+            case S.PART_DATA_START:
+              state = S.PART_DATA;
+              mark("onPartData");
+            // falls through
+            case S.PART_DATA:
+              previousIndex = index;
+              if (index === 0) {
+                i += boundaryEnd;
+                while (i < bufferLength && !(data[i] in boundaryChars)) {
+                  i += boundaryLength;
+                }
+                i -= boundaryEnd;
+                c = data[i];
+              }
+              if (index < boundary.length) {
+                if (boundary[index] === c) {
+                  if (index === 0) {
+                    dataCallback("onPartData", true);
+                  }
+                  index++;
+                } else {
+                  index = 0;
+                }
+              } else if (index === boundary.length) {
+                index++;
+                if (c === CR) {
+                  flags |= F.PART_BOUNDARY;
+                } else if (c === HYPHEN) {
+                  flags |= F.LAST_BOUNDARY;
+                } else {
+                  index = 0;
+                }
+              } else if (index - 1 === boundary.length) {
+                if (flags & F.PART_BOUNDARY) {
+                  index = 0;
+                  if (c === LF) {
+                    flags &= ~F.PART_BOUNDARY;
+                    callback("onPartEnd");
+                    callback("onPartBegin");
+                    state = S.HEADER_FIELD_START;
+                    break;
+                  }
+                } else if (flags & F.LAST_BOUNDARY) {
+                  if (c === HYPHEN) {
+                    callback("onPartEnd");
+                    state = S.END;
+                    flags = 0;
+                  } else {
+                    index = 0;
+                  }
+                } else {
+                  index = 0;
+                }
+              }
+              if (index > 0) {
+                lookbehind[index - 1] = c;
+              } else if (previousIndex > 0) {
+                const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
+                callback("onPartData", 0, previousIndex, _lookbehind);
+                previousIndex = 0;
+                mark("onPartData");
+                i--;
+              }
+              break;
+            case S.END:
+              break;
+            default:
+              throw new Error(`Unexpected state entered: ${state}`);
+          }
+        }
+        dataCallback("onHeaderField");
+        dataCallback("onHeaderValue");
+        dataCallback("onPartData");
+        this.index = index;
+        this.state = state;
+        this.flags = flags;
+      }
+      end() {
+        if (this.state === S.HEADER_FIELD_START && this.index === 0 || this.state === S.PART_DATA && this.index === this.boundary.length) {
+          this.onPartEnd();
+        } else if (this.state !== S.END) {
+          throw new Error("MultipartParser.end(): stream ended unexpectedly");
+        }
+      }
+    };
+    __name(_fileName, "_fileName");
+    __name(toFormData, "toFormData");
+  }
+});
+init_multipart_parser();
+export {
+  toFormData
+};

package/dist-boot/c-EYZGSAJU.mjs

@@ -0,0 +1,98 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  __name
+} from "./c-CN77DCGF.mjs";
+
+// node_modules/@earendil-works/pi-ai/dist/utils/provider-retry.js
+var DEFAULT_MAX_RETRY_DELAY_MS = 6e4;
+function isProviderError(error) {
+  if (!(error instanceof Error) || !("status" in error) || !("headers" in error))
+    return false;
+  return (error.status === void 0 || typeof error.status === "number") && (error.headers === void 0 || error.headers instanceof Headers);
+}
+__name(isProviderError, "isProviderError");
+function isRetryableProviderError(error) {
+  const shouldRetry = error.headers?.get("x-should-retry");
+  if (shouldRetry === "true")
+    return true;
+  if (shouldRetry === "false")
+    return false;
+  if (error.status === void 0)
+    return true;
+  return error.status === 408 || error.status === 409 || error.status === 429 || typeof error.status === "number" && error.status >= 500;
+}
+__name(isRetryableProviderError, "isRetryableProviderError");
+function validateServerRetryDelayMs(delayMs, maxRetryDelayMs, providerErrorMessage) {
+  const maxDelayMs = maxRetryDelayMs ?? DEFAULT_MAX_RETRY_DELAY_MS;
+  if (maxDelayMs > 0 && delayMs > maxDelayMs) {
+    throw new Error(`Server requested ${Math.ceil(delayMs / 1e3)}s retry delay (max: ${Math.ceil(maxDelayMs / 1e3)}s). ${providerErrorMessage}`);
+  }
+  return delayMs;
+}
+__name(validateServerRetryDelayMs, "validateServerRetryDelayMs");
+function getRetryDelayMs(error, retryIndex, maxRetryDelayMs) {
+  const retryAfterMs = error.headers?.get("retry-after-ms");
+  if (retryAfterMs) {
+    const value = Number.parseFloat(retryAfterMs);
+    if (Number.isFinite(value))
+      return validateServerRetryDelayMs(value, maxRetryDelayMs, error.message);
+  }
+  const retryAfter = error.headers?.get("retry-after");
+  if (retryAfter) {
+    const seconds = Number.parseFloat(retryAfter);
+    const delayMs = Number.isNaN(seconds) ? Date.parse(retryAfter) - Date.now() : seconds * 1e3;
+    if (Number.isFinite(delayMs))
+      return validateServerRetryDelayMs(delayMs, maxRetryDelayMs, error.message);
+  }
+  const exponentialDelay = Math.min(0.5 * 2 ** retryIndex, 8) * 1e3;
+  return exponentialDelay * (1 - Math.random() * 0.25);
+}
+__name(getRetryDelayMs, "getRetryDelayMs");
+function createAbortError() {
+  const error = new Error("Request aborted");
+  error.name = "AbortError";
+  return error;
+}
+__name(createAbortError, "createAbortError");
+function abortableSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(createAbortError());
+      return;
+    }
+    const onAbort = /* @__PURE__ */ __name(() => {
+      clearTimeout(timeout);
+      reject(createAbortError());
+    }, "onAbort");
+    const timeout = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, ms));
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+__name(abortableSleep, "abortableSleep");
+async function retryProviderRequest(request, options = {}) {
+  const maxRetries = options.maxRetries ?? 0;
+  let retriesRemaining = maxRetries;
+  for (; ; ) {
+    try {
+      return await request();
+    } catch (error) {
+      if (options.signal?.aborted)
+        throw createAbortError();
+      if (retriesRemaining <= 0 || !isProviderError(error) || !isRetryableProviderError(error))
+        throw error;
+      if (error.status !== void 0 && options.noRetryStatuses?.includes(error.status))
+        throw error;
+      const retryIndex = maxRetries - retriesRemaining;
+      retriesRemaining--;
+      await abortableSleep(getRetryDelayMs(error, retryIndex, options.maxRetryDelayMs), options.signal);
+    }
+  }
+}
+__name(retryProviderRequest, "retryProviderRequest");
+
+export {
+  retryProviderRequest
+};

package/dist-boot/c-F75VRKY4.mjs

@@ -0,0 +1,172 @@
+import{createRequire as __pvCR}from"node:module";import{fileURLToPath as __pvF}from"node:url";import{dirname as __pvD}from"node:path";const require=__pvCR(import.meta.url);const __pvUrl=(r)=>new URL(r,import.meta.url).href;const __pvFile=(r)=>__pvF(new URL(r,import.meta.url));
+import {
+  AllOf,
+  AnyOf,
+  CertificateChainVerifier,
+  CertificateError,
+  EXTENSION_OID_BUILD_CONFIG_DIGEST,
+  EXTENSION_OID_BUILD_CONFIG_URI,
+  EXTENSION_OID_BUILD_SIGNER_DIGEST,
+  EXTENSION_OID_BUILD_SIGNER_URI,
+  EXTENSION_OID_BUILD_TRIGGER,
+  EXTENSION_OID_FULCIO_ISSUER_V1,
+  EXTENSION_OID_FULCIO_ISSUER_V2,
+  EXTENSION_OID_GITHUB_WORKFLOW_NAME,
+  EXTENSION_OID_GITHUB_WORKFLOW_REF,
+  EXTENSION_OID_GITHUB_WORKFLOW_REPOSITORY,
+  EXTENSION_OID_GITHUB_WORKFLOW_SHA,
+  EXTENSION_OID_GITHUB_WORKFLOW_TRIGGER,
+  EXTENSION_OID_OTHERNAME,
+  EXTENSION_OID_RUNNER_ENVIRONMENT,
+  EXTENSION_OID_RUN_INVOCATION_URI,
+  EXTENSION_OID_SCT,
+  EXTENSION_OID_SOURCE_REPOSITORY_DIGEST,
+  EXTENSION_OID_SOURCE_REPOSITORY_IDENTIFIER,
+  EXTENSION_OID_SOURCE_REPOSITORY_OWNER_IDENTIFIER,
+  EXTENSION_OID_SOURCE_REPOSITORY_OWNER_URI,
+  EXTENSION_OID_SOURCE_REPOSITORY_REF,
+  EXTENSION_OID_SOURCE_REPOSITORY_URI,
+  EXTENSION_OID_SOURCE_REPOSITORY_VISIBILITY,
+  GITHUB_OIDC_ISSUER,
+  GitHubWorkflowName,
+  GitHubWorkflowRef,
+  GitHubWorkflowRepository,
+  GitHubWorkflowSHA,
+  GitHubWorkflowTrigger,
+  Identity,
+  OIDCBuildConfigDigest,
+  OIDCBuildConfigURI,
+  OIDCBuildSignerDigest,
+  OIDCBuildSignerURI,
+  OIDCBuildTrigger,
+  OIDCIssuer,
+  OIDCIssuerV2,
+  OIDCRunInvocationURI,
+  OIDCRunnerEnvironment,
+  OIDCSourceRepositoryDigest,
+  OIDCSourceRepositoryIdentifier,
+  OIDCSourceRepositoryOwnerIdentifier,
+  OIDCSourceRepositoryOwnerURI,
+  OIDCSourceRepositoryRef,
+  OIDCSourceRepositoryURI,
+  OIDCSourceRepositoryVisibility,
+  PolicyError,
+  SignatureError,
+  SigstoreVerifier,
+  TLogError,
+  TimestampError,
+  TrustedRootProvider,
+  VerificationError,
+  X509BuildConfigDigestExtension,
+  X509BuildConfigURIExtension,
+  X509BuildSignerDigestExtension,
+  X509BuildSignerURIExtension,
+  X509BuildTriggerExtension,
+  X509Certificate,
+  X509Extension,
+  X509FulcioIssuerV1,
+  X509FulcioIssuerV2,
+  X509GitHubWorkflowNameExtension,
+  X509GitHubWorkflowRefExtension,
+  X509GitHubWorkflowRepositoryExtension,
+  X509GitHubWorkflowSHAExtension,
+  X509GitHubWorkflowTriggerExtension,
+  X509RunInvocationURIExtension,
+  X509RunnerEnvironmentExtension,
+  X509SourceRepositoryDigestExtension,
+  X509SourceRepositoryIdentifierExtension,
+  X509SourceRepositoryOwnerIdentifierExtension,
+  X509SourceRepositoryOwnerURIExtension,
+  X509SourceRepositoryRefExtension,
+  X509SourceRepositoryURIExtension,
+  X509SourceRepositoryVisibilityExtension,
+  verifyBundleTimestamp,
+  verifyRFC3161Timestamp
+} from "./c-65UZIZC7.mjs";
+import "./c-U4ITOXAN.mjs";
+import "./c-4WVR32AP.mjs";
+import "./c-CN77DCGF.mjs";
+export {
+  AllOf,
+  AnyOf,
+  CertificateChainVerifier,
+  CertificateError,
+  EXTENSION_OID_BUILD_CONFIG_DIGEST,
+  EXTENSION_OID_BUILD_CONFIG_URI,
+  EXTENSION_OID_BUILD_SIGNER_DIGEST,
+  EXTENSION_OID_BUILD_SIGNER_URI,
+  EXTENSION_OID_BUILD_TRIGGER,
+  EXTENSION_OID_FULCIO_ISSUER_V1,
+  EXTENSION_OID_FULCIO_ISSUER_V2,
+  EXTENSION_OID_GITHUB_WORKFLOW_NAME,
+  EXTENSION_OID_GITHUB_WORKFLOW_REF,
+  EXTENSION_OID_GITHUB_WORKFLOW_REPOSITORY,
+  EXTENSION_OID_GITHUB_WORKFLOW_SHA,
+  EXTENSION_OID_GITHUB_WORKFLOW_TRIGGER,
+  EXTENSION_OID_OTHERNAME,
+  EXTENSION_OID_RUNNER_ENVIRONMENT,
+  EXTENSION_OID_RUN_INVOCATION_URI,
+  EXTENSION_OID_SCT,
+  EXTENSION_OID_SOURCE_REPOSITORY_DIGEST,
+  EXTENSION_OID_SOURCE_REPOSITORY_IDENTIFIER,
+  EXTENSION_OID_SOURCE_REPOSITORY_OWNER_IDENTIFIER,
+  EXTENSION_OID_SOURCE_REPOSITORY_OWNER_URI,
+  EXTENSION_OID_SOURCE_REPOSITORY_REF,
+  EXTENSION_OID_SOURCE_REPOSITORY_URI,
+  EXTENSION_OID_SOURCE_REPOSITORY_VISIBILITY,
+  GITHUB_OIDC_ISSUER,
+  GitHubWorkflowName,
+  GitHubWorkflowRef,
+  GitHubWorkflowRepository,
+  GitHubWorkflowSHA,
+  GitHubWorkflowTrigger,
+  Identity,
+  OIDCBuildConfigDigest,
+  OIDCBuildConfigURI,
+  OIDCBuildSignerDigest,
+  OIDCBuildSignerURI,
+  OIDCBuildTrigger,
+  OIDCIssuer,
+  OIDCIssuerV2,
+  OIDCRunInvocationURI,
+  OIDCRunnerEnvironment,
+  OIDCSourceRepositoryDigest,
+  OIDCSourceRepositoryIdentifier,
+  OIDCSourceRepositoryOwnerIdentifier,
+  OIDCSourceRepositoryOwnerURI,
+  OIDCSourceRepositoryRef,
+  OIDCSourceRepositoryURI,
+  OIDCSourceRepositoryVisibility,
+  PolicyError,
+  SignatureError,
+  SigstoreVerifier,
+  TLogError,
+  TimestampError,
+  TrustedRootProvider,
+  VerificationError,
+  X509BuildConfigDigestExtension,
+  X509BuildConfigURIExtension,
+  X509BuildSignerDigestExtension,
+  X509BuildSignerURIExtension,
+  X509BuildTriggerExtension,
+  X509Certificate,
+  X509Extension,
+  X509FulcioIssuerV1,
+  X509FulcioIssuerV2,
+  X509GitHubWorkflowNameExtension,
+  X509GitHubWorkflowRefExtension,
+  X509GitHubWorkflowRepositoryExtension,
+  X509GitHubWorkflowSHAExtension,
+  X509GitHubWorkflowTriggerExtension,
+  X509RunInvocationURIExtension,
+  X509RunnerEnvironmentExtension,
+  X509SourceRepositoryDigestExtension,
+  X509SourceRepositoryIdentifierExtension,
+  X509SourceRepositoryOwnerIdentifierExtension,
+  X509SourceRepositoryOwnerURIExtension,
+  X509SourceRepositoryRefExtension,
+  X509SourceRepositoryURIExtension,
+  X509SourceRepositoryVisibilityExtension,
+  verifyBundleTimestamp,
+  verifyRFC3161Timestamp
+};