manifest 7.0.0 → 7.2.0

package/dist/{chunk-DP2C4E42.js → chunk-NHEF7GUP.js}

@@ -1,10 +1,3 @@
-// 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",
@@ -44,6 +37,19 @@ function safeUrl(raw) {
   url.search = new URLSearchParams(pairs).toString();
   return url.toString();
 }
+function trackedUrl(raw) {
+  try {
+    const url = new URL(raw);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    url.username = "";
+    url.password = "";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return null;
+  }
+}
 function safeHeaders(headers) {
   return Object.fromEntries([...headers].map(([key, value]) => [
     key,
@@ -287,11 +293,9 @@ async function captureResponse(original, limit = RESPONSE_LIMIT, timeoutMs = CAP
   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 VERSION = "7.2.0";
+var MAX_HEALS_IN_FLIGHT = 8;
 var warn = (message) => process.emitWarning(message, { code: "MNFST" });
 var HealApi = class {
   constructor(rawFetch, key, url, timeoutMs = 6e4, reportTimeoutMs = 5e3) {
@@ -313,16 +317,23 @@ var HealApi = class {
   enabled() {
     return performance.now() >= this.disabledUntil;
   }
+  /**
+   * Whether a heal call would be sent right now: the project is not disabled
+   * and a heal slot is free. A healable failure that cannot be sent is tracked
+   * instead, so it is never lost from both ledgers.
+   */
+  canHeal() {
+    return this.enabled() && this.inFlight < MAX_HEALS_IN_FLIGHT;
+  }
   headers() {
     return {
       authorization: `Bearer ${this.key}`,
       "content-type": "application/json",
-      "user-agent": `mnfst-node/${VERSION}`,
-      "x-mnfst-source": "node-sdk"
+      "user-agent": `mnfst-node/${VERSION}`
     };
   }
   async heal(capture, signal) {
-    if (!this.enabled() || this.inFlight >= 8) return null;
+    if (!this.canHeal()) return null;
     this.inFlight++;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeoutMs);
@@ -339,14 +350,20 @@ var HealApi = class {
         });
         return null;
       }
-      const captured = await captureResponse(response, 1048576, this.timeoutMs);
+      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 (!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;
+      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 } : {},
@@ -360,6 +377,72 @@ var HealApi = class {
       this.inFlight--;
     }
   }
+  /**
+   * Announce this install: "I am installed."
+   *
+   * Without it, a broken install and a healthy app look identical from the
+   * dashboard — both are silence. Four causes hide behind that silence (key
+   * unset, key invalid, app not restarted, SDK never loaded), and an app with
+   * no failing calls produces exactly the same nothing.
+   *
+   * Deliberately fire-and-forget and deliberately quiet. It carries no
+   * application data: the name and version ride in the user-agent this class
+   * already sends, so the body is the runtime and nothing else. A failure is
+   * not warned about — the dashboard showing "not connected" IS the signal,
+   * and an app that cannot reach Manifest must not print on every boot.
+   *
+   * Uses `rawFetch`, so the handshake cannot be intercepted by our own patch.
+   */
+  hello(runtime) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.reportTimeoutMs);
+    void this.rawFetch(new URL("v1/hello", this.url), {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({ runtime }),
+      signal: controller.signal,
+      redirect: "error"
+    }).then((response) => {
+      void response.body?.cancel().catch(() => {
+      });
+    }).catch(() => {
+    }).finally(() => clearTimeout(timer));
+  }
+  /**
+   * Ship one batch of tracked calls to `POST /v1/requests`. Throws only when a
+   * retry could help (network error, timeout, 429, 5xx), so the buffer retries
+   * once; any other answer, including 404 from a backend that predates the
+   * route, drops the batch quietly. Uses `rawFetch`, so the send is never
+   * tracked or healed by our own patch.
+   */
+  async sendRequests(calls, signal) {
+    if (!this.enabled() || calls.length === 0) return;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.reportTimeoutMs);
+    try {
+      const response = await this.rawFetch(new URL("v1/requests", this.url), {
+        method: "POST",
+        headers: this.headers(),
+        body: JSON.stringify({ requests: calls }),
+        signal: signal ? AbortSignal.any([signal, controller.signal]) : controller.signal,
+        redirect: "error"
+      });
+      if (response.status === 403) {
+        const body = await response.json().catch(() => null);
+        if (isObject(body) && body.error === "project_disabled") {
+          this.disabledUntil = performance.now() + 3e5;
+        }
+        return;
+      }
+      void response.body?.cancel().catch(() => {
+      });
+      if (response.status === 429 || response.status >= 500) {
+        throw new Error(`tracked calls refused (${response.status})`);
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   report(id, outcome) {
     if (!id) return;
     if (this.pending.size >= 64) {
@@ -374,16 +457,20 @@ var HealApi = class {
     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"
-      });
+      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");
+      if (!response.ok)
+        warn("Outcome report rejected; attempt remains unconfirmed");
     } catch {
       warn("Outcome report failed; attempt remains unconfirmed");
     } finally {
@@ -392,329 +479,20 @@ var HealApi = class {
   }
 };
 
-// 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 {
+  isObject,
+  safeUrl,
+  trackedUrl,
+  safeHeaders,
+  travelingBody,
+  mergeBody,
+  parseRequestBody,
+  serializeRequestBody,
+  TRANSPORT_ERROR,
+  REQUEST_LIMIT,
+  captureRequest,
+  captureResponse,
   VERSION,
-  manifest
+  warn,
+  HealApi
 };