manifest 5.45.1 → 7.0.0

package/dist/chunk-DP2C4E42.js

@@ -0,0 +1,720 @@
+// src/http.ts
+import http from "http";
+import https from "https";
+import { syncBuiltinESMExports } from "module";
+import { Readable } from "stream";
+import { createBrotliDecompress, createUnzip } from "zlib";
+
+// src/wire.ts
+var secretNames = /* @__PURE__ */ new Set([
+  "api_key",
+  "apikey",
+  "api_token",
+  "key",
+  "token",
+  "access_token",
+  "refresh_token",
+  "auth",
+  "authorization",
+  "signature",
+  "sig",
+  "secret",
+  "client_secret",
+  "password",
+  "session",
+  "session_id",
+  "bearer",
+  "jwt",
+  "id_token",
+  "auth_token",
+  "pwd",
+  "passwd",
+  "private_key"
+]);
+var roots = ["auth", "key", "token", "secret", "session", "password", "passwd", "cookie", "signature", "credential", "bearer", "jwt"];
+var normalize = (name) => name.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replaceAll("-", "_").toLowerCase().replace(/^x_/, "");
+var isSecret = (name) => secretNames.has(normalize(name));
+var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+function safeUrl(raw) {
+  const url = new URL(raw);
+  url.username = "";
+  url.password = "";
+  url.hash = "";
+  const pairs = [...url.searchParams].map(([key, value]) => [key, isSecret(key) ? "REDACTED" : value]);
+  url.search = new URLSearchParams(pairs).toString();
+  return url.toString();
+}
+function safeHeaders(headers) {
+  return Object.fromEntries([...headers].map(([key, value]) => [
+    key,
+    isSecret(key) || roots.some((root) => normalize(key).includes(root)) ? "REDACTED" : value.slice(0, 1024)
+  ]));
+}
+function travelingBody(body) {
+  return isObject(body) ? Object.fromEntries(Object.entries(body).filter(([key]) => !isSecret(key))) : body;
+}
+function mergeBody(original, healed) {
+  if (!isObject(original) || !isObject(healed)) return healed;
+  return { ...Object.fromEntries(Object.entries(original).filter(([key]) => isSecret(key) && !Object.hasOwn(healed, key))), ...healed };
+}
+function boundedJson(value) {
+  const stack = [[value, 0]];
+  let count = 0;
+  while (stack.length) {
+    const [item, depth] = stack.pop();
+    if (++count > 1e5 || depth > 64) return false;
+    if (item !== null && typeof item === "object") {
+      for (const child of Object.values(item)) stack.push([child, depth + 1]);
+    }
+  }
+  return true;
+}
+function parseJson(bytes) {
+  try {
+    const value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    return boundedJson(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+var unsafeFormKeys = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+var arrayIndex = (value) => /^(0|[1-9]\d*)$/.test(value) && Number(value) <= 1e5;
+var formEncoded = (contentType) => contentType?.split(";", 1)[0]?.trim().toLowerCase() === "application/x-www-form-urlencoded";
+function formPath(key) {
+  const bracket = key.indexOf("[");
+  const root = bracket === -1 ? key : key.slice(0, bracket);
+  if (!root || root.includes("]")) return null;
+  const path = [root];
+  let offset = root.length;
+  while (offset < key.length) {
+    if (key[offset] !== "[") return null;
+    const end = key.indexOf("]", offset + 1);
+    if (end === -1) return null;
+    const part = key.slice(offset + 1, end);
+    if (part.includes("[")) return null;
+    path.push(part);
+    offset = end + 1;
+  }
+  return path.length <= 64 && path.every((part) => !unsafeFormKeys.has(part)) ? path : null;
+}
+function putFormValue(root, path, value) {
+  let current = root;
+  for (let index = 0; index < path.length; index++) {
+    const part = path[index];
+    const last = index === path.length - 1;
+    if (Array.isArray(current)) {
+      if (part !== "" && !arrayIndex(part)) return false;
+      const position = part === "" ? current.length : Number(part);
+      if (last) {
+        const existing3 = Object.hasOwn(current, position) ? current[position] : void 0;
+        if (existing3 === void 0) current[position] = value;
+        else if (typeof existing3 === "string") current[position] = [existing3, value];
+        else if (Array.isArray(existing3) && existing3.every((item) => typeof item === "string")) existing3.push(value);
+        else return false;
+        continue;
+      }
+      const next2 = path[index + 1];
+      const needsArray2 = next2 === "" || arrayIndex(next2);
+      const existing2 = Object.hasOwn(current, position) ? current[position] : void 0;
+      if (existing2 === void 0) current[position] = needsArray2 ? [] : {};
+      else if (typeof existing2 !== "object" || existing2 === null || Array.isArray(existing2) !== needsArray2) return false;
+      current = current[position];
+      continue;
+    }
+    if (!part) return false;
+    if (last) {
+      const existing2 = Object.hasOwn(current, part) ? current[part] : void 0;
+      if (existing2 === void 0) current[part] = value;
+      else if (typeof existing2 === "string") current[part] = [existing2, value];
+      else if (Array.isArray(existing2) && existing2.every((item) => typeof item === "string")) existing2.push(value);
+      else return false;
+      continue;
+    }
+    const next = path[index + 1];
+    const needsArray = next === "" || arrayIndex(next);
+    const existing = Object.hasOwn(current, part) ? current[part] : void 0;
+    if (existing === void 0) current[part] = needsArray ? [] : {};
+    else if (typeof existing !== "object" || existing === null || Array.isArray(existing) !== needsArray) return false;
+    current = current[part];
+  }
+  return true;
+}
+function parseForm(bytes) {
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    const body = {};
+    let fields = 0;
+    for (const pair of text.split("&")) {
+      if (!pair) continue;
+      if (++fields > 1e5) return { body: null, valid: false };
+      const separator = pair.indexOf("=");
+      const rawKey = separator === -1 ? pair : pair.slice(0, separator);
+      const rawValue = separator === -1 ? "" : pair.slice(separator + 1);
+      const key = decodeURIComponent(rawKey.replaceAll("+", " "));
+      const value = decodeURIComponent(rawValue.replaceAll("+", " "));
+      const path = formPath(key);
+      if (!path || !putFormValue(body, path, value)) return { body: null, valid: false };
+    }
+    return boundedJson(body) ? { body, valid: true } : { body: null, valid: false };
+  } catch {
+    return { body: null, valid: false };
+  }
+}
+function parseRequestBody(bytes, contentType) {
+  return formEncoded(contentType) ? parseForm(bytes) : { body: parseJson(bytes), valid: true };
+}
+function serializeRequestBody(body, contentType) {
+  if (!formEncoded(contentType)) return JSON.stringify(body);
+  if (!isObject(body)) throw new TypeError("Form body must be an object");
+  const params = new URLSearchParams();
+  let fields = 0;
+  const append = (value, key, depth) => {
+    if (++fields > 1e5 || depth > 64) throw new TypeError("Form body exceeds structural limits");
+    if (Array.isArray(value)) {
+      for (let index = 0; index < value.length; index++) {
+        if (Object.hasOwn(value, index)) append(value[index], `${key}[${index}]`, depth + 1);
+      }
+    } else if (isObject(value)) {
+      for (const [name, child] of Object.entries(value)) {
+        if (unsafeFormKeys.has(name)) throw new TypeError("Form body contains an unsafe key");
+        append(child, key ? `${key}[${name}]` : name, depth + 1);
+      }
+    } else if (value === null) params.append(key, "");
+    else if (typeof value === "string" || typeof value === "boolean" || typeof value === "number" && Number.isFinite(value)) params.append(key, String(value));
+    else throw new TypeError("Form body contains an unsupported value");
+  };
+  for (const [key, value] of Object.entries(body)) {
+    if (unsafeFormKeys.has(key)) throw new TypeError("Form body contains an unsafe key");
+    append(value, key, 1);
+  }
+  return params.toString();
+}
+function errorBody(bytes) {
+  const parsed = parseJson(bytes);
+  const text = Buffer.from(bytes).toString("utf8");
+  return parsed ?? new TextDecoder().decode(Buffer.from(text).subarray(0, 65536), { stream: true });
+}
+var TRANSPORT_ERROR = "Upstream retry failed before an HTTP response";
+
+// src/capture.ts
+var REQUEST_LIMIT = 262144;
+var RESPONSE_LIMIT = 65536;
+var CAPTURE_MS = 1e3;
+async function prefix(reader, limit, timeoutMs) {
+  const chunks = [];
+  let size = 0;
+  let pending;
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(null), timeoutMs);
+  });
+  let complete = false;
+  try {
+    while (size <= limit) {
+      pending = reader.read();
+      const read = await Promise.race([pending, deadline]);
+      if (read === null) break;
+      pending = void 0;
+      if (read.done) {
+        complete = true;
+        break;
+      }
+      chunks.push(read.value);
+      size += read.value.byteLength;
+    }
+  } catch {
+  } finally {
+    clearTimeout(timer);
+  }
+  return { chunks, complete, pending, bytes: Buffer.concat(chunks, size).subarray(0, limit) };
+}
+async function captureRequest(request) {
+  if (!request.body) return { body: null, complete: true };
+  const clone = request.clone();
+  const reader = clone.body.getReader();
+  try {
+    const result = await prefix(reader, REQUEST_LIMIT, CAPTURE_MS);
+    if (!result.complete) return { body: null, complete: false };
+    const parsed = parseRequestBody(result.bytes, request.headers.get("content-type"));
+    return { body: parsed.body, complete: parsed.valid };
+  } finally {
+    void reader.cancel().catch(() => {
+    });
+  }
+}
+function metadata(response, original) {
+  const clone = response.clone.bind(response);
+  Object.defineProperties(response, {
+    url: { value: original.url },
+    redirected: { value: original.redirected },
+    type: { value: original.type },
+    clone: { value: () => metadata(clone(), original) }
+  });
+  return response;
+}
+async function captureResponse(original, limit = RESPONSE_LIMIT, timeoutMs = CAPTURE_MS) {
+  if (!original.body) return { response: original, body: null, truncated: false, complete: true };
+  const reader = original.body.getReader();
+  const captured = await prefix(reader, limit, timeoutMs);
+  let index = 0;
+  let pending = captured.pending;
+  const stream = new ReadableStream({
+    async pull(controller) {
+      try {
+        if (index < captured.chunks.length) {
+          controller.enqueue(captured.chunks[index++]);
+          return;
+        }
+        const read = await (pending ?? reader.read());
+        pending = void 0;
+        if (read.done) {
+          reader.releaseLock();
+          controller.close();
+        } else controller.enqueue(read.value);
+      } catch (error) {
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      await reader.cancel(reason);
+    }
+  }, { highWaterMark: 0 });
+  const response = metadata(new Response(stream, {
+    status: original.status,
+    statusText: original.statusText,
+    headers: original.headers
+  }), original);
+  return { response, body: errorBody(captured.bytes), truncated: !captured.complete || Buffer.byteLength(Buffer.from(captured.bytes).toString("utf8")) > limit, complete: captured.complete };
+}
+
+// src/runtime.ts
+import { randomUUID } from "crypto";
+
+// src/api.ts
+var VERSION = "7.0.0";
+var warn = (message) => process.emitWarning(message, { code: "MNFST" });
+var HealApi = class {
+  constructor(rawFetch, key, url, timeoutMs = 6e4, reportTimeoutMs = 5e3) {
+    this.rawFetch = rawFetch;
+    this.key = key;
+    this.url = url;
+    this.timeoutMs = timeoutMs;
+    this.reportTimeoutMs = reportTimeoutMs;
+  }
+  rawFetch;
+  key;
+  url;
+  timeoutMs;
+  reportTimeoutMs;
+  disabledUntil = 0;
+  inFlight = 0;
+  /** @internal In-flight outcome reports; exposed so tests can await delivery. */
+  pending = /* @__PURE__ */ new Set();
+  enabled() {
+    return performance.now() >= this.disabledUntil;
+  }
+  headers() {
+    return {
+      authorization: `Bearer ${this.key}`,
+      "content-type": "application/json",
+      "user-agent": `mnfst-node/${VERSION}`,
+      "x-mnfst-source": "node-sdk"
+    };
+  }
+  async heal(capture, signal) {
+    if (!this.enabled() || this.inFlight >= 8) return null;
+    this.inFlight++;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.rawFetch(new URL("v1/heal", this.url), {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify(capture),
+        signal: AbortSignal.any([signal, controller.signal]),
+        redirect: "error"
+      });
+      if (response.status !== 200 && response.status !== 403) {
+        void response.body?.cancel().catch(() => {
+        });
+        return null;
+      }
+      const captured = await captureResponse(response, 1048576, this.timeoutMs);
+      void captured.response.body?.cancel().catch(() => {
+      });
+      if (!captured.complete || !isObject(captured.body) || !boundedJson(captured.body)) return null;
+      if (response.status === 403 && captured.body.error === "project_disabled") {
+        this.disabledUntil = performance.now() + 3e5;
+      }
+      if (response.status !== 200 || typeof captured.body.status !== "string") return null;
+      return {
+        status: captured.body.status,
+        ...typeof captured.body.healAttemptId === "string" ? { healAttemptId: captured.body.healAttemptId } : {},
+        ...Array.isArray(captured.body.operations) ? { operations: captured.body.operations } : {},
+        ...isObject(captured.body.healedRequest) ? { healedRequest: captured.body.healedRequest } : {}
+      };
+    } catch {
+      return null;
+    } finally {
+      clearTimeout(timer);
+      this.inFlight--;
+    }
+  }
+  report(id, outcome) {
+    if (!id) return;
+    if (this.pending.size >= 64) {
+      warn("Outcome report capacity reached; report dropped");
+      return;
+    }
+    const promise = this.send(id, outcome);
+    this.pending.add(promise);
+    void promise.then(() => this.pending.delete(promise));
+  }
+  async send(id, outcome) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.reportTimeoutMs);
+    try {
+      const response = await this.rawFetch(new URL(`v1/heal-attempts/${encodeURIComponent(id)}`, this.url), {
+        method: "PATCH",
+        headers: this.headers(),
+        body: JSON.stringify(outcome),
+        signal: controller.signal,
+        redirect: "error"
+      });
+      void response.body?.cancel().catch(() => {
+      });
+      if (!response.ok) warn("Outcome report rejected; attempt remains unconfirmed");
+    } catch {
+      warn("Outcome report failed; attempt remains unconfirmed");
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+};
+
+// src/runtime.ts
+var forbidden = /* @__PURE__ */ new Set([401, 402, 403, 429]);
+var eligible = (status) => status >= 400 && status < 500 && !forbidden.has(status);
+var Runtime = class {
+  constructor(options, original, api) {
+    this.options = options;
+    this.original = original;
+    this.api = api ?? new HealApi(original, options.key, options.url);
+  }
+  options;
+  original;
+  api;
+  fetch = async (input, init) => {
+    const request = new Request(input, init);
+    const extras = { ...init };
+    delete extras.body;
+    delete extras.headers;
+    const bodyPromise = captureRequest(request).catch(() => ({ body: null, complete: false }));
+    const started = performance.now();
+    const response = await this.original(request, extras);
+    const responseTimeMs = performance.now() - started;
+    if (!eligible(response.status) || response.redirected || !this.api.enabled()) return response;
+    return this.handleResponse(request, response, await bodyPromise, responseTimeMs, extras);
+  };
+  async handleResponse(request, response, body, responseTimeMs, extras = {}) {
+    if (!eligible(response.status) || response.redirected || !this.api.enabled()) return response;
+    return this.repair(request, extras, response, body, responseTimeMs);
+  }
+  async repair(request, extras, original, body, responseTimeMs) {
+    let response = original;
+    let result = null;
+    const started = performance.now();
+    let replayStatusCode = null;
+    let replayAttempted = false;
+    try {
+      const captured = await captureResponse(response);
+      response = captured.response;
+      const payload = {
+        traceId: randomUUID(),
+        request: { method: request.method, url: safeUrl(request.url), headers: safeHeaders(request.headers), body: travelingBody(body.body) },
+        response: { statusCode: response.status, body: captured.body, truncated: captured.truncated },
+        responseTimeMs: Math.round(responseTimeMs)
+      };
+      request.signal.throwIfAborted();
+      result = await this.api.heal(payload, request.signal);
+      request.signal.throwIfAborted();
+      const retry = body.complete && captured.complete ? buildRetry(request, body.body, result) : null;
+      if (!retry) {
+        this.api.report(result?.healAttemptId, { failure: { kind: "not_attempted", message: "replay_not_attempted" } });
+        return response;
+      }
+      replayAttempted = true;
+      let retried;
+      try {
+        retried = await this.original(retry, extras);
+      } catch {
+        this.api.report(result?.healAttemptId, { failure: { kind: "transport_error", message: TRANSPORT_ERROR } });
+        request.signal.throwIfAborted();
+        return response;
+      }
+      replayStatusCode = retried.status;
+      if (retried.status >= 400) {
+        const capturedRetry = await captureResponse(retried);
+        retried = capturedRetry.response;
+        this.api.report(result?.healAttemptId, { response: { statusCode: retried.status, body: capturedRetry.body, truncated: capturedRetry.truncated } });
+      } else {
+        this.api.report(result?.healAttemptId, { response: { statusCode: retried.status } });
+      }
+      void response.body?.cancel().catch(() => {
+      });
+      return retried;
+    } catch {
+      request.signal.throwIfAborted();
+      this.api.report(result?.healAttemptId, { failure: { kind: "not_attempted", message: "replay_not_attempted" } });
+      return response;
+    } finally {
+      if (this.options.onHeal) {
+        try {
+          void Promise.resolve(this.options.onHeal({
+            url: safeUrl(request.url),
+            statusCode: original.status,
+            healStatus: replayAttempted && replayStatusCode === null ? "replay_failed" : result?.status ?? "heal_unreachable",
+            replayStatusCode,
+            healMs: Math.round(performance.now() - started),
+            operations: result?.operations
+          })).catch(() => warn("onHeal callback failed"));
+        } catch {
+          warn("onHeal callback failed");
+        }
+      }
+    }
+  }
+};
+function buildRetry(request, originalBody, result) {
+  if (!result || !["patched", "unverified"].includes(result.status) || !isObject(result.healedRequest)) return null;
+  const healed = result.healedRequest;
+  if (!["url", "headers", "body"].some((key) => Object.hasOwn(healed, key))) return null;
+  try {
+    const url = new URL(healed.url ?? request.url);
+    if (url.origin !== new URL(request.url).origin || url.username || url.password) return null;
+    const headers = new Headers(request.headers);
+    const contentType = headers.get("content-type");
+    headers.delete("content-length");
+    if (healed.headers !== void 0 && !isObject(healed.headers)) return null;
+    for (const [name, value] of Object.entries(healed.headers ?? {})) {
+      if (value === null) headers.delete(name);
+      else if (typeof value === "string") headers.set(name, value);
+      else return null;
+    }
+    const body = Object.hasOwn(healed, "body") ? mergeBody(originalBody, healed.body) : originalBody;
+    if (body === null && !["GET", "HEAD"].includes(request.method)) return null;
+    return new Request(url, {
+      method: request.method,
+      headers,
+      body: ["GET", "HEAD"].includes(request.method) ? void 0 : serializeRequestBody(body, contentType),
+      signal: request.signal,
+      redirect: request.redirect,
+      credentials: request.credentials,
+      cache: request.cache,
+      integrity: request.integrity,
+      keepalive: request.keepalive,
+      mode: request.mode,
+      referrer: request.referrer,
+      referrerPolicy: request.referrerPolicy
+    });
+  } catch {
+    return null;
+  }
+}
+
+// src/http.ts
+function installHttp(runtime) {
+  const httpRequest = wrapRequest(http.request, "http:", runtime);
+  const httpsRequest = wrapRequest(https.request, "https:", runtime);
+  http.request = httpRequest;
+  https.request = httpsRequest;
+  http.get = wrapGet(httpRequest);
+  https.get = wrapGet(httpsRequest);
+  syncBuiltinESMExports();
+}
+function wrapGet(request) {
+  return ((...args) => {
+    const result = request(...args);
+    result.end();
+    return result;
+  });
+}
+function wrapRequest(original, protocol, runtime) {
+  return ((...received) => {
+    const args = [...received];
+    const callback = typeof args.at(-1) === "function" ? args.pop() : void 0;
+    const started = performance.now();
+    const request = original(...args);
+    const capture = captureBody(request);
+    const signal = cancellation(request, requestSignal(args));
+    const emit = request.emit.bind(request);
+    request.emit = ((event, ...values) => {
+      if (event !== "response") return emit(event, ...values);
+      const response = values[0];
+      if (!eligible(response.statusCode ?? 0) || !runtime.api.enabled()) {
+        return emit(event, ...values);
+      }
+      void handleResponse(runtime, request, response, protocol, capture.body(), signal, started).then((healed) => emit("response", healed)).catch((error) => {
+        response.destroy();
+        if (!request.destroyed) request.destroy(error instanceof Error ? error : void 0);
+      });
+      return true;
+    });
+    if (callback) request.once("response", callback);
+    return request;
+  });
+}
+async function handleResponse(runtime, clientRequest, incoming, protocol, body, signal, started) {
+  const request = webRequest(clientRequest, protocol, body, signal);
+  const response = webResponse(incoming, request.url);
+  const healed = await runtime.handleResponse(request, response, body, performance.now() - started);
+  return incomingResponse(healed, clientRequest);
+}
+function webRequest(request, protocol, captured, signal) {
+  const headers = new Headers();
+  for (const name of request.getHeaderNames()) {
+    const value = request.getHeader(name);
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (item !== void 0) headers.append(name, String(item));
+    }
+  }
+  const authority = String(request.getHeader("host") ?? request.host);
+  const url = new URL(request.path, `${protocol}//${authority}`);
+  const method = request.method;
+  return new Request(url, {
+    method,
+    headers,
+    signal,
+    body: ["GET", "HEAD"].includes(method) || !captured.complete || captured.body === null ? void 0 : serializeRequestBody(captured.body, headers.get("content-type"))
+  });
+}
+function webResponse(response, url) {
+  const headers = new Headers();
+  for (const [name, value] of Object.entries(response.headers)) {
+    for (const item of Array.isArray(value) ? value : [value]) {
+      if (item !== void 0) headers.append(name, String(item));
+    }
+  }
+  const encoding = headers.get("content-encoding")?.toLowerCase();
+  let body = response;
+  if (encoding === "gzip" || encoding === "x-gzip" || encoding === "deflate") {
+    body = response.pipe(createUnzip());
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+  } else if (encoding === "br") {
+    body = response.pipe(createBrotliDecompress());
+    headers.delete("content-encoding");
+    headers.delete("content-length");
+  }
+  const converted = new Response(
+    Readable.toWeb(body),
+    { status: response.statusCode, statusText: response.statusMessage, headers }
+  );
+  Object.defineProperty(converted, "url", { value: url });
+  return converted;
+}
+function incomingResponse(response, request) {
+  const stream = response.body ? Readable.fromWeb(response.body) : Readable.from([]);
+  const headers = {};
+  for (const [name, value] of response.headers) headers[name] = value;
+  if (["gzip", "x-gzip", "deflate", "br"].includes(String(headers["content-encoding"]).toLowerCase())) {
+    delete headers["content-encoding"];
+    delete headers["content-length"];
+  }
+  const cookies = response.headers.getSetCookie();
+  if (cookies.length) headers["set-cookie"] = cookies;
+  const rawHeaders = Object.entries(headers).flatMap(([name, value]) => (Array.isArray(value) ? value : [value]).flatMap((item) => item === void 0 ? [] : [name, String(item)]));
+  return Object.assign(stream, {
+    statusCode: response.status,
+    statusMessage: response.statusText,
+    headers,
+    rawHeaders,
+    trailers: {},
+    rawTrailers: [],
+    httpVersion: "1.1",
+    httpVersionMajor: 1,
+    httpVersionMinor: 1,
+    complete: true,
+    req: request
+  });
+}
+function captureBody(request) {
+  let chunks = [];
+  let size = 0;
+  let complete = true;
+  const record = (chunk, encoding) => {
+    if (chunk === void 0 || chunk === null || typeof chunk === "function" || !complete) return;
+    const bytes = typeof chunk === "string" ? Buffer.from(chunk, encoding) : Buffer.from(chunk);
+    size += bytes.byteLength;
+    if (size > REQUEST_LIMIT) {
+      complete = false;
+      chunks = [];
+      return;
+    }
+    chunks.push(bytes);
+  };
+  const write = request.write;
+  request.write = ((...args) => {
+    record(args[0], typeof args[1] === "string" ? args[1] : void 0);
+    return Reflect.apply(write, request, args);
+  });
+  const end = request.end;
+  request.end = ((...args) => {
+    record(args[0], typeof args[1] === "string" ? args[1] : void 0);
+    return Reflect.apply(end, request, args);
+  });
+  return { body: () => {
+    if (!complete) return { body: null, complete: false };
+    const header = request.getHeader("content-type");
+    const contentType = Array.isArray(header) ? header[0] : header === void 0 ? void 0 : String(header);
+    const parsed = parseRequestBody(Buffer.concat(chunks, size), contentType);
+    return { body: parsed.body, complete: parsed.valid };
+  } };
+}
+function requestSignal(args) {
+  for (const value of args.slice(0, 2)) {
+    if (value && typeof value === "object" && "signal" in value && value.signal instanceof AbortSignal) return value.signal;
+  }
+}
+function cancellation(request, external) {
+  const controller = new AbortController();
+  const destroy = request.destroy.bind(request);
+  request.destroy = ((error) => {
+    if (!controller.signal.aborted) controller.abort(error);
+    return destroy(error);
+  });
+  return external ? AbortSignal.any([external, controller.signal]) : controller.signal;
+}
+
+// src/index.ts
+var STATE = /* @__PURE__ */ Symbol.for("mnfst.node.runtime.v1");
+var globals = globalThis;
+function manifest(options = {}) {
+  const key = options.key || process.env.MNFST_KEY;
+  if (!key) {
+    warn("MNFST_KEY is not set; Manifest is disabled");
+    return;
+  }
+  const url = new URL(options.url || process.env.MNFST_URL || "https://api.manifest.build");
+  if (!["https:", "http:"].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new TypeError("Manifest URL must be an HTTP(S) base URL without credentials, query or fragment");
+  }
+  if (!url.pathname.endsWith("/")) url.pathname += "/";
+  const resolved = { ...options, key, url: url.toString() };
+  const existing = globals[STATE];
+  if (existing) {
+    if (existing.options.key !== key || existing.options.url !== resolved.url || existing.options.onHeal !== options.onHeal) {
+      warn("Manifest is already configured; changing configuration requires a process restart");
+    }
+    return;
+  }
+  const runtime = new Runtime(resolved, globalThis.fetch.bind(globalThis));
+  globalThis.fetch = runtime.fetch;
+  installHttp(runtime);
+  globals[STATE] = runtime;
+}
+
+export {
+  VERSION,
+  manifest
+};