@zlink-systems/http-client 0.10.0

package/dist/browser/index.mjs

@@ -0,0 +1,818 @@
+// packages/framework/src/contracts/Common/ZLinkMessageMetadata.ts
+var ImmutableZLinkMessageMetadata = class {
+  values;
+  constructor(values = /* @__PURE__ */ new Map()) {
+    this.values = Object.freeze(new ImmutableMetadataMap(values));
+  }
+  find(key) {
+    return this.values.get(key);
+  }
+};
+var ImmutableMetadataMap = class {
+  #values;
+  constructor(values) {
+    this.#values = new Map(
+      typeof values[Symbol.iterator] === "function" ? values : Object.entries(values)
+    );
+  }
+  get size() {
+    return this.#values.size;
+  }
+  get(key) {
+    return this.#values.get(key);
+  }
+  has(key) {
+    return this.#values.has(key);
+  }
+  forEach(callbackfn, thisArg) {
+    this.#values.forEach((value, key) => callbackfn.call(thisArg, value, key, this));
+  }
+  entries() {
+    return this.#values.entries();
+  }
+  keys() {
+    return this.#values.keys();
+  }
+  values() {
+    return this.#values.values();
+  }
+  [Symbol.iterator]() {
+    return this.#values[Symbol.iterator]();
+  }
+};
+var ZLinkMessageMetadataEmpty = Object.freeze(new ImmutableZLinkMessageMetadata());
+
+// packages/framework/src/contracts/Errors/ZLinkFrameworkException.ts
+var ZLinkFrameworkException = class extends Error {
+  constructor(kind, message, cause) {
+    super(message, { cause });
+    this.kind = kind;
+    this.name = "ZLinkFrameworkException";
+  }
+};
+
+// packages/framework/src/contracts/Eventing/Metrics.ts
+var ZLinkMeters = Object.freeze({ Framework: "zlink.framework" });
+
+// packages/framework/src/contracts/Handlers/JsonContract.ts
+var ZLINK_PACKET_JSON_CONTRACTS = Symbol.for("@zlink-systems/framework:packet-json-contracts");
+
+// packages/framework/src/contracts/Handlers/Attributes.ts
+var ZLINK_DECORATOR_METADATA = Symbol.for("@zlink-systems/framework:decorator");
+
+// packages/http-client/src/runtime/redirect-policy.ts
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function isRedirectStatus(status) {
+  return REDIRECT_STATUSES.has(status);
+}
+function makeTarget(prefix, path) {
+  if (prefix.length === 0 || prefix === "/") {
+    return path;
+  }
+  return prefix.endsWith("/") ? prefix.slice(0, -1) + path : prefix + path;
+}
+function rewriteForRedirect(status, method, body) {
+  if (status === 303 || (status === 301 || status === 302) && method === "POST") {
+    return { method: "GET", body: void 0 };
+  }
+  return { method, body };
+}
+function resolveLocation(current, location) {
+  try {
+    if (location.startsWith("http://") || location.startsWith("https://")) {
+      return new URL(location);
+    }
+    if (location.startsWith("//")) {
+      return new URL(current.protocol + location);
+    }
+    if (location.startsWith("/")) {
+      return new URL(current.origin + location);
+    }
+  } catch {
+    throw new ZLinkFrameworkException(
+      5 /* Unavailable */,
+      `HTTP redirect location is malformed: ${location}`
+    );
+  }
+  throw new ZLinkFrameworkException(
+    5 /* Unavailable */,
+    `HTTP redirect location is not supported: ${location}`
+  );
+}
+
+// packages/http-client/src/runtime/retry-policy.ts
+function delayMsFor(attempt) {
+  const ceiling = Math.min(1e3, 50 << Math.min(attempt, 5));
+  return Math.floor(Math.random() * (ceiling + 1));
+}
+var RetryPolicy = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async execute(spec, perform) {
+    const maxRetries = spec.sink !== void 0 || spec.bodyProvider !== void 0 ? 0 : this.options.retryAttempts;
+    const timeoutMs = spec.timeoutMs ?? this.options.timeoutMs;
+    for (let attempt = 0; ; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => {
+        controller.abort();
+      }, timeoutMs);
+      try {
+        return await perform(spec, controller.signal);
+      } catch (error) {
+        const failure = mapFailure(error, controller.signal.aborted);
+        if (isRetriableHttpFailure(failure) && attempt < maxRetries) {
+          await delay(delayMsFor(attempt));
+          continue;
+        }
+        throw failure;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+  }
+};
+function mapFailure(error, aborted) {
+  if (error instanceof ZLinkFrameworkException) {
+    return error;
+  }
+  if (aborted || error instanceof Error && error.name === "AbortError") {
+    return new ZLinkFrameworkException(
+      7 /* DeadlineExceeded */,
+      "HTTP request exceeded timeout",
+      error
+    );
+  }
+  const message = error instanceof Error ? error.message : "HTTP transport failure";
+  return new ZLinkFrameworkException(5 /* Unavailable */, message, error);
+}
+function isRetriableHttpFailure(error) {
+  return error.kind === 5 /* Unavailable */ || error.kind === 7 /* DeadlineExceeded */;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// packages/http-client/src/runtime/browser-runtime.ts
+var HttpClientRuntime = class {
+  constructor(options) {
+    this.options = options;
+    rejectUnsupportedTransportOptions(options);
+    this.retryPolicy = new RetryPolicy(options);
+  }
+  retryPolicy;
+  async executeAsync(spec) {
+    return await this.retryPolicy.execute(spec, (request, signal) => this.perform(request, signal));
+  }
+  async close() {
+  }
+  async perform(spec, signal) {
+    const baseUri = new URL(this.options.baseUrl);
+    const origin = baseUri.origin;
+    let current = new URL(origin + makeTarget(baseUri.pathname, spec.target));
+    let method = spec.method;
+    let body = spec.body;
+    let bodyProvider = spec.bodyProvider;
+    let redirectsLeft = this.options.followRedirects;
+    for (; ; ) {
+      const headers = this.buildHeaders(spec, current.origin === origin, body !== void 0 || bodyProvider !== void 0);
+      const response = await fetch(current, {
+        method,
+        headers,
+        body: body ?? bodyStream(bodyProvider),
+        credentials: this.options.cookies ? "include" : "same-origin",
+        redirect: "manual",
+        signal
+      });
+      const location = response.headers.get("location");
+      if (this.options.followRedirects > 0 && isRedirectStatus(response.status) && location !== null) {
+        if (redirectsLeft === 0) {
+          await response.body?.cancel();
+          throw requestError("HTTP request exceeded the redirect limit");
+        }
+        redirectsLeft--;
+        ({ method, body } = rewriteForRedirect(response.status, method, body));
+        bodyProvider = void 0;
+        await response.body?.cancel();
+        current = resolveLocation(current, location);
+        continue;
+      }
+      const headersResult = collectHeaders(response.headers);
+      if (spec.sink !== void 0) {
+        await streamResponse(response, spec.sink, this.options.maxResponseBodySize);
+        return { status: response.status, headers: headersResult, body: "" };
+      }
+      const text = await response.text();
+      if (new TextEncoder().encode(text).length > this.options.maxResponseBodySize) {
+        throw requestError("HTTP response exceeded the maximum body size");
+      }
+      return { status: response.status, headers: headersResult, body: text };
+    }
+  }
+  buildHeaders(spec, keepAuthorization, hasBody) {
+    const headers = { accept: "application/json" };
+    applyHeaders(headers, this.options.headers, keepAuthorization);
+    applyHeaders(headers, spec.headers, keepAuthorization);
+    if (!hasBody) delete headers["content-type"];
+    return headers;
+  }
+};
+function rejectUnsupportedTransportOptions(options) {
+  if (options.trustCertificateFile !== void 0 || options.clientCertificate !== void 0 || options.proxy !== void 0) {
+    throw new ZLinkFrameworkException(
+      9 /* ProtocolError */,
+      "Browser HTTP clients cannot configure certificate files or a transport proxy."
+    );
+  }
+}
+function bodyStream(provider) {
+  if (provider === void 0) return void 0;
+  return new ReadableStream({
+    pull(controller) {
+      const chunk = provider();
+      if (chunk === null) controller.close();
+      else controller.enqueue(chunk);
+    }
+  });
+}
+async function streamResponse(response, sink, maximumSize) {
+  if (response.body === null) return;
+  const reader = response.body.getReader();
+  let total = 0;
+  for (; ; ) {
+    const result = await reader.read();
+    if (result.done) return;
+    total += result.value.length;
+    if (total > maximumSize) {
+      await reader.cancel();
+      throw requestError("HTTP response exceeded the maximum body size");
+    }
+    sink(result.value);
+  }
+}
+function collectHeaders(headers) {
+  const result = {};
+  headers.forEach((value, name) => {
+    result[name.toLowerCase()] = value;
+  });
+  return result;
+}
+function applyHeaders(target, source, keepAuthorization) {
+  for (const [name, value] of Object.entries(source)) {
+    const lower = name.toLowerCase();
+    if (keepAuthorization || lower !== "authorization") target[lower] = value;
+  }
+}
+function requestError(message) {
+  return new ZLinkFrameworkException(5 /* Unavailable */, message);
+}
+
+// packages/http-client/src/runtime/text.ts
+function isBlank(value) {
+  return value.length === 0 || /^[\s]*$/u.test(value);
+}
+function requireNonBlank(value, message) {
+  if (isBlank(value)) {
+    throw new ZLinkFrameworkException(9 /* ProtocolError */, message);
+  }
+}
+function requirePositiveTimeout(value) {
+  if (!(value > 0)) {
+    throw new ZLinkFrameworkException(
+      9 /* ProtocolError */,
+      "HTTP client timeout must be greater than zero"
+    );
+  }
+}
+var unreserved = /[A-Za-z0-9\-_.~]/u;
+function percentEncode(value) {
+  const bytes = new TextEncoder().encode(value);
+  let encoded = "";
+  for (const byte of bytes) {
+    const char = String.fromCharCode(byte);
+    if (unreserved.test(char)) {
+      encoded += char;
+    } else {
+      encoded += "%" + byte.toString(16).toUpperCase().padStart(2, "0");
+    }
+  }
+  return encoded;
+}
+function basicAuthorization(user, password) {
+  return "Basic " + Buffer.from(`${user}:${password}`, "utf8").toString("base64");
+}
+function makeMultipartBoundary() {
+  return "zlink-boundary-" + Math.random().toString(16).slice(2).padEnd(16, "0").slice(0, 16);
+}
+
+// packages/http-client/src/request-builder.ts
+var ZLinkHttpRequestBuilder = class {
+  constructor(client, method, path, clientFactory) {
+    this.method = method;
+    this.path = path;
+    this.clientInstance = client;
+    this.clientFactory = clientFactory;
+    this.ownsClient = clientFactory !== void 0;
+    this.executionScheduler = client?.executionScheduler;
+    this.executionTurn = client?.executionScheduler?.capture() ?? clientFactory?.captureExecutionTurn();
+    if (path.length === 0 || path[0] !== "/") {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP request path must start with /"
+      );
+    }
+  }
+  bodyValue;
+  bodyProviderValue;
+  headersValue = {};
+  timeoutMsValue;
+  queryValue = [];
+  formValue = [];
+  multipartValue = [];
+  clientInstance;
+  clientFactory;
+  ownsClient;
+  executionTurn;
+  executionScheduler;
+  consumed = false;
+  // Resolves the client to run on, building a one-shot client lazily. A one-shot request builder is
+  // single-use so its lazily-built client is closed exactly once.
+  resolveClient() {
+    if (this.ownsClient && this.consumed) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "A one-shot HTTP request can only be submitted once"
+      );
+    }
+    this.consumed = true;
+    if (this.clientInstance === void 0) {
+      if (this.clientFactory === void 0) {
+        throw new ZLinkFrameworkException(
+          9 /* ProtocolError */,
+          "HTTP request has no client"
+        );
+      }
+      this.clientInstance = this.clientFactory.build();
+    }
+    return this.clientInstance;
+  }
+  async closeIfOwned() {
+    if (this.ownsClient && this.clientInstance !== void 0) {
+      await this.clientInstance.close().catch(() => void 0);
+    }
+  }
+  header(name, value) {
+    requireNonBlank(name, "HTTP request header name is required");
+    this.headersValue[name.toLowerCase()] = value;
+    return this;
+  }
+  query(name, value) {
+    requireNonBlank(name, "HTTP request query name is required");
+    this.queryValue.push([name, value]);
+    return this;
+  }
+  timeout(milliseconds) {
+    requirePositiveTimeout(milliseconds);
+    this.timeoutMsValue = milliseconds;
+    return this;
+  }
+  body(value, contentType) {
+    if (contentType !== void 0) {
+      if (typeof value !== "string") {
+        throw new ZLinkFrameworkException(
+          9 /* ProtocolError */,
+          "HTTP request raw body content is required"
+        );
+      }
+      requireNonBlank(contentType, "HTTP request body content type is required");
+      this.bodyValue = value;
+      this.headersValue["content-type"] = contentType;
+      return this;
+    }
+    this.bodyValue = JSON.stringify(value);
+    this.headersValue["content-type"] ??= "application/json";
+    return this;
+  }
+  /**
+   * Streams the request body chunk by chunk with chunked transfer-encoding; the provider returns
+   * `null` when the body is complete. Streamed requests are excluded from retry.
+   */
+  bodyStream(provider, contentType) {
+    if (typeof provider !== "function") {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP request body stream provider is required"
+      );
+    }
+    requireNonBlank(contentType, "HTTP request body content type is required");
+    this.bodyProviderValue = provider;
+    this.headersValue["content-type"] = contentType;
+    return this;
+  }
+  form(name, value) {
+    requireNonBlank(name, "HTTP request form field name is required");
+    this.formValue.push([name, value]);
+    return this;
+  }
+  multipart(name, value) {
+    requireNonBlank(name, "HTTP request multipart field name is required");
+    this.multipartValue.push({ name, filename: "", content: value, contentType: "" });
+    return this;
+  }
+  multipartFile(name, filename, content, contentType) {
+    requireNonBlank(name, "HTTP request multipart field name is required");
+    requireNonBlank(filename, "HTTP request multipart filename is required");
+    requireNonBlank(contentType, "HTTP request multipart content type is required");
+    this.multipartValue.push({ name, filename, content, contentType });
+    return this;
+  }
+  /** Executes the request and returns the raw response while retaining the current turn. */
+  async submitRaw() {
+    const request = this.makeRequest(void 0);
+    const client = this.resolveClient();
+    try {
+      return await client.runtime.executeAsync(request);
+    } finally {
+      await this.closeIfOwned();
+    }
+  }
+  /**
+   * Streams the response body to `sink` chunk by chunk instead of buffering it; the returned
+   * response carries status and headers with an empty body (no decompression of chunks).
+   */
+  async download(sink) {
+    if (typeof sink !== "function") {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP request download sink is required"
+      );
+    }
+    const request = this.makeRequest(sink);
+    const client = this.resolveClient();
+    try {
+      return await client.runtime.executeAsync(request);
+    } finally {
+      await this.closeIfOwned();
+    }
+  }
+  async(callback) {
+    const pending = this.executeTyped();
+    if (callback === void 0) {
+      return pending;
+    }
+    void pending.then(
+      (response) => this.completeCallback(() => callback(void 0, response)),
+      (error) => this.completeCallback(() => callback(error, void 0))
+    );
+  }
+  async executeTyped() {
+    const raw = await this.submitRaw();
+    if (raw.status >= 400) {
+      throw new ZLinkFrameworkException(
+        12 /* InternalFailure */,
+        `HTTP request failed with status ${raw.status}`
+      );
+    }
+    let body;
+    if (raw.body.length === 0) {
+      body = null;
+    } else {
+      try {
+        body = JSON.parse(raw.body, safeJsonReviver);
+      } catch (cause) {
+        throw new ZLinkFrameworkException(
+          9 /* ProtocolError */,
+          cause instanceof Error ? cause.message : "HTTP response body decode failed",
+          cause
+        );
+      }
+    }
+    return { status: raw.status, headers: raw.headers, body, rawBody: raw.body };
+  }
+  /** Returns only the decoded body for client-side scenarios that do not need the HTTP envelope. */
+  async fetch() {
+    return (await this.executeTyped()).body;
+  }
+  completeCallback(callback) {
+    if (this.executionTurn === void 0) {
+      callback();
+      return;
+    }
+    this.executionTurn.post(callback);
+  }
+  makeRequest(sink) {
+    const { body, headers } = this.resolveBodyAndHeaders();
+    return {
+      method: this.method,
+      target: this.resolveTarget(),
+      ...body !== void 0 ? { body } : {},
+      ...this.bodyProviderValue !== void 0 ? { bodyProvider: this.bodyProviderValue } : {},
+      headers,
+      ...this.timeoutMsValue !== void 0 ? { timeoutMs: this.timeoutMsValue } : {},
+      ...sink !== void 0 ? { sink } : {}
+    };
+  }
+  resolveTarget() {
+    if (this.queryValue.length === 0) {
+      return this.path;
+    }
+    let target = this.path;
+    let separator = this.path.includes("?") ? "&" : "?";
+    for (const [name, value] of this.queryValue) {
+      target += `${separator}${percentEncode(name)}=${percentEncode(value)}`;
+      separator = "&";
+    }
+    return target;
+  }
+  resolveBodyAndHeaders() {
+    if (this.countBodySources() > 1) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP request accepts a single body source: body, body_stream, form, or multipart"
+      );
+    }
+    const headers = { ...this.headersValue };
+    if (this.bodyValue !== void 0) {
+      return { body: this.bodyValue, headers };
+    }
+    if (this.formValue.length > 0) {
+      headers["content-type"] = "application/x-www-form-urlencoded";
+      return { body: this.encodeFormBody(), headers };
+    }
+    if (this.multipartValue.length > 0) {
+      const boundary = makeMultipartBoundary();
+      headers["content-type"] = `multipart/form-data; boundary=${boundary}`;
+      return { body: this.encodeMultipartBody(boundary), headers };
+    }
+    return { body: void 0, headers };
+  }
+  countBodySources() {
+    return (this.bodyValue !== void 0 ? 1 : 0) + (this.bodyProviderValue !== void 0 ? 1 : 0) + (this.formValue.length > 0 ? 1 : 0) + (this.multipartValue.length > 0 ? 1 : 0);
+  }
+  encodeFormBody() {
+    return this.formValue.map(([name, value]) => `${percentEncode(name)}=${percentEncode(value)}`).join("&");
+  }
+  encodeMultipartBody(boundary) {
+    let encoded = "";
+    for (const part of this.multipartValue) {
+      encoded += `--${boundary}\r
+`;
+      encoded += `Content-Disposition: form-data; name="${part.name}"`;
+      if (part.filename.length > 0) {
+        encoded += `; filename="${part.filename}"`;
+      }
+      encoded += "\r\n";
+      if (part.contentType.length > 0) {
+        encoded += `Content-Type: ${part.contentType}\r
+`;
+      }
+      encoded += "\r\n";
+      encoded += part.content;
+      encoded += "\r\n";
+    }
+    encoded += `--${boundary}--\r
+`;
+    return encoded;
+  }
+};
+var ZLinkFrameworkHttpRequestBuilder = class extends ZLinkHttpRequestBuilder {
+  /** Starts a server-side one-way request and ignores its response body. */
+  async submit() {
+    if (this.executionScheduler === void 0) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP submit requires a framework server client"
+      );
+    }
+    await this.submitRaw();
+  }
+  /** Executes a typed request while yielding the current Spot turn. */
+  yield() {
+    if (this.executionTurn === void 0) {
+      return Promise.reject(new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP yield requires a framework Spot turn"
+      ));
+    }
+    return this.executionTurn.yieldPromise(this.executeTyped());
+  }
+};
+function createZLinkHttpRequestBuilder(client, method, path) {
+  return client.executionScheduler === void 0 ? new ZLinkHttpRequestBuilder(client, method, path) : new ZLinkFrameworkHttpRequestBuilder(client, method, path);
+}
+var prototypeKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function safeJsonReviver(key, value) {
+  if (prototypeKeys.has(key)) {
+    return void 0;
+  }
+  return value;
+}
+
+// packages/http-client/src/client.ts
+var ZLinkHttpClient = class {
+  constructor(runtimeInstance, executionScheduler) {
+    this.runtimeInstance = runtimeInstance;
+    this.executionScheduler = executionScheduler;
+  }
+  /** @internal */
+  get runtime() {
+    return this.runtimeInstance;
+  }
+  static create(baseUrl) {
+    const builder = new ZLinkHttpClientBuilder();
+    return baseUrl === void 0 ? builder : builder.baseUrl(baseUrl);
+  }
+  get(path) {
+    return createZLinkHttpRequestBuilder(this, "GET", path);
+  }
+  post(path) {
+    return createZLinkHttpRequestBuilder(this, "POST", path);
+  }
+  put(path) {
+    return createZLinkHttpRequestBuilder(this, "PUT", path);
+  }
+  delete(path) {
+    return createZLinkHttpRequestBuilder(this, "DELETE", path);
+  }
+  patch(path) {
+    return createZLinkHttpRequestBuilder(this, "PATCH", path);
+  }
+  head(path) {
+    return createZLinkHttpRequestBuilder(this, "HEAD", path);
+  }
+  options(path) {
+    return createZLinkHttpRequestBuilder(this, "OPTIONS", path);
+  }
+  /** Releases the underlying dispatcher (connection pool). */
+  async close() {
+    await this.runtimeInstance.close();
+  }
+};
+var ZLinkHttpClientBuilder = class {
+  baseUrlValue = "";
+  timeoutMsValue = 3e3;
+  maxResponseBodySizeValue = 16 * 1024 * 1024;
+  headersValue = {};
+  trustCertificateFileValue;
+  clientCertificateValue;
+  followRedirectsValue = 0;
+  retryAttemptsValue = 0;
+  cookiesValue = false;
+  proxyValue;
+  proxyAuthorizationValue;
+  compressionValue = false;
+  executionSchedulerValue;
+  baseUrl(value) {
+    requireNonBlank(value, "HTTP client base_url is required");
+    this.baseUrlValue = value;
+    return this;
+  }
+  timeout(milliseconds) {
+    requirePositiveTimeout(milliseconds);
+    this.timeoutMsValue = milliseconds;
+    return this;
+  }
+  defaultHeader(name, value) {
+    requireNonBlank(name, "HTTP client default header name is required");
+    this.headersValue[name.toLowerCase()] = value;
+    return this;
+  }
+  basicAuth(user, password) {
+    requireNonBlank(user, "HTTP client basic auth user is required");
+    this.headersValue["authorization"] = basicAuthorization(user, password);
+    return this;
+  }
+  bearerToken(token) {
+    requireNonBlank(token, "HTTP client bearer token is required");
+    this.headersValue["authorization"] = `Bearer ${token}`;
+    return this;
+  }
+  maxResponseBodySize(bytes) {
+    if (!(bytes > 0)) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP client max response body size must be greater than zero"
+      );
+    }
+    this.maxResponseBodySizeValue = bytes;
+    return this;
+  }
+  trustCertificateFile(path) {
+    requireNonBlank(path, "HTTP client trust certificate file is required");
+    this.trustCertificateFileValue = path;
+    return this;
+  }
+  clientCertificateFile(certificatePath, keyPath) {
+    requireNonBlank(certificatePath, "HTTP client certificate file is required");
+    requireNonBlank(keyPath, "HTTP client certificate key file is required");
+    this.clientCertificateValue = { certificatePath, keyPath };
+    return this;
+  }
+  followRedirects(maxRedirects = 5) {
+    if (!(maxRedirects > 0)) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP client follow_redirects must be greater than zero"
+      );
+    }
+    this.followRedirectsValue = maxRedirects;
+    return this;
+  }
+  retry(attempts) {
+    if (!(attempts > 0)) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP client retry attempts must be greater than zero"
+      );
+    }
+    this.retryAttemptsValue = attempts;
+    return this;
+  }
+  cookies() {
+    this.cookiesValue = true;
+    return this;
+  }
+  proxy(url) {
+    requireNonBlank(url, "HTTP client proxy url is required");
+    if (!url.startsWith("http://")) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP client proxy url must start with http://"
+      );
+    }
+    this.proxyValue = url;
+    return this;
+  }
+  proxyBasicAuth(user, password) {
+    requireNonBlank(user, "HTTP client proxy auth user is required");
+    this.proxyAuthorizationValue = basicAuthorization(user, password);
+    return this;
+  }
+  compression() {
+    this.compressionValue = true;
+    return this;
+  }
+  /** Supplies the framework turn scheduler used by server-side terminators. */
+  executionScheduler(scheduler) {
+    this.executionSchedulerValue = scheduler;
+    return this;
+  }
+  /** @internal Captures a turn for one-shot requests before the client is built. */
+  captureExecutionTurn() {
+    return this.executionSchedulerValue?.capture();
+  }
+  build() {
+    requireNonBlank(this.baseUrlValue, "HTTP client base_url is required");
+    requirePositiveTimeout(this.timeoutMsValue);
+    const lower = this.baseUrlValue.toLowerCase();
+    if (!lower.startsWith("http://") && !lower.startsWith("https://")) {
+      throw new ZLinkFrameworkException(
+        9 /* ProtocolError */,
+        "HTTP client base_url must start with http:// or https://"
+      );
+    }
+    const options = {
+      baseUrl: this.baseUrlValue,
+      timeoutMs: this.timeoutMsValue,
+      maxResponseBodySize: this.maxResponseBodySizeValue,
+      headers: { ...this.headersValue },
+      ...this.trustCertificateFileValue !== void 0 ? { trustCertificateFile: this.trustCertificateFileValue } : {},
+      ...this.clientCertificateValue !== void 0 ? { clientCertificate: this.clientCertificateValue } : {},
+      followRedirects: this.followRedirectsValue,
+      retryAttempts: this.retryAttemptsValue,
+      cookies: this.cookiesValue,
+      ...this.proxyValue !== void 0 ? { proxy: this.proxyValue } : {},
+      ...this.proxyAuthorizationValue !== void 0 ? { proxyAuthorization: this.proxyAuthorizationValue } : {},
+      compression: this.compressionValue
+    };
+    return new ZLinkHttpClient(new HttpClientRuntime(options), this.executionSchedulerValue);
+  }
+  get(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "GET", path, this);
+  }
+  post(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "POST", path, this);
+  }
+  put(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "PUT", path, this);
+  }
+  delete(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "DELETE", path, this);
+  }
+  patch(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "PATCH", path, this);
+  }
+  head(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "HEAD", path, this);
+  }
+  options(path) {
+    return new ZLinkHttpRequestBuilder(void 0, "OPTIONS", path, this);
+  }
+};
+export {
+  ZLinkHttpClient,
+  ZLinkHttpClientBuilder,
+  ZLinkHttpRequestBuilder
+};