manifest 7.2.0 → 7.2.1

package/CONTRACT.md

@@ -71,4 +71,6 @@ Every call the SDK sees and does not send to `POST /v1/heal`, whatever its statu
 
 Metadata only. The URL carries scheme, host, port and path: no query string, userinfo or fragment. No headers and no request or response body are sent, and a response body is never read to record a call. A call sent to `/v1/heal` is not also tracked.
 
-Recording is an in-memory append and never delays or fails the caller's request. A batch is sent when 500 calls are queued or every five seconds, at most once per second, one send at a time, up to 500 calls per request, with a five-second deadline. At most 5,000 calls are buffered; newer calls are dropped past that. A network error, timeout, 429 or 5xx is retried once, then the batch is dropped; any other answer, including 404 from a server without the route, drops it. HTTP 403 with `{"error":"project_disabled"}` suspends sending for five minutes, as for healing. Methods are upper-cased; a record whose method exceeds 16 characters or whose URL exceeds 4,096 is not sent. Buffered calls are sent once when the event loop drains (`beforeExit`), for at most two seconds: a send still in flight then is aborted and the rest is dropped, so a script never hangs on an unreachable server. A process killed or frozen first (serverless) can lose them.
+Recording is an in-memory append and never delays or fails the caller's request. A batch is sent when 500 calls are queued or every five seconds, at most once per second, one send at a time, up to 500 calls per request, with a five-second deadline. At most 5,000 calls are buffered; newer calls are dropped past that. A network error, timeout, 429 or 5xx is retried once, then the batch is dropped; any other answer, including 404 from a server without the route, drops it. HTTP 403 with `{"error":"project_disabled"}` suspends sending for five minutes, as for healing. Methods are upper-cased; a record whose method exceeds 16 characters or whose URL exceeds 4,096 is not sent. Buffered calls are sent once when the event loop drains (`beforeExit`), for at most two seconds: a send still in flight then is aborted and the rest is dropped, so a script never hangs on an unreachable server. A process killed first can lose them.
+
+On a serverless platform (`VERCEL`, `AWS_LAMBDA_FUNCTION_NAME` or `K_SERVICE` set), the function freezes as soon as it responds, so neither the interval nor the exit flush would run. There, each call is sent as soon as it is recorded, still at most once per second and one send at a time, and the send and every outcome report are handed to the platform's `waitUntil` (Vercel's request context, or Next.js's own), so the function stays alive until they are delivered. Where no `waitUntil` exists, the send still starts during the invocation.

package/README.md

@@ -4,7 +4,7 @@
 
 # Manifest for Node.js
 
-**Turn 🔴 4xx API errors into 🟢 2xx in real time.**
+**The API resilience layer for your Node.js apps.**
 
 [![CI](https://github.com/mnfst/manifest-node/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/mnfst/manifest-node/actions/workflows/ci.yml)
 [![npm version](https://img.shields.io/npm/v/manifest?label=npm)](https://www.npmjs.com/package/manifest)
@@ -16,11 +16,11 @@
 
 ## What is Manifest
 
-Manifest is a self-healing layer that fixes and retries failed API requests on the fly.
+Manifest is the API resilience layer for your apps and agents. It works with every API they call: external services, your internal APIs and MCP tools.
 
-* 🎯 **Fix failures automatically** before they impact your users.
-* 🔔 **Get notified of root causes** so you can fix them permanently.
-* 🔌 **Works across your stack** with internal APIs, external services, and agent tools.
+* 🗺️ **See every API your app depends on**, and how reliable each one is.
+* 🎯 **Repair failed API requests on the fly**, so your app keeps working.
+* 🛠️ **Know what to fix in your code**, with a prompt for your coding agent.
 
 ## How it works
 
@@ -46,47 +46,73 @@ The prompt adds the one-line install to your entry file and stops to let you pas
 
 ### Start with code
 
-```sh
-npm install manifest
-```
+1. Create a project in your [Manifest dashboard](https://dashboard.manifest.build) and copy its project key.
 
-```js
-import { manifest } from 'manifest';
+2. Install the SDK:
 
-manifest();  // Once, at startup.
-// Keep making your API calls as usual.
-```
+   ```sh
+   npm install manifest
+   ```
 
-TypeScript, ESM and CommonJS. Zero dependencies.
+3. Call `manifest()` from the first import of the file that starts your app, before any client is constructed:
 
-## Setup
+   ```js
+   import { manifest } from 'manifest';
 
-1. Create a project in your [Manifest dashboard](https://dashboard.manifest.build) and copy its project key.
-2. Set the key as an environment variable:
+   manifest();  // Once, at startup.
+   // Keep making your API calls as usual.
+   ```
 
-```sh
-export MNFST_KEY='your-project-key'
-```
+   TypeScript, ESM and CommonJS. Zero dependencies.
+
+4. Set your key in the environment of your app:
+
+   ```sh
+   export MNFST_KEY='your-project-key'
+   ```
 
-Call `manifest()` from the first import of the file that starts your app, before any client is constructed. Some clients keep the `fetch` they saw when they were built, and a client built at import time runs before your call. Where that happens, or where the start command is not yours to change, preload the SDK instead:
+5. Restart your app, then check the install from your project directory:
+
+   ```sh
+   npx manifest doctor
+   ```
+
+   It resolves the installed SDK version, masks and validates the key, checks that Manifest loads before your app, and prints the runtime coverage.
+
+Some clients keep the `fetch` they saw when they were built, and a client built at import time runs before your call. Where that happens, or where the start command is not yours to change, preload the SDK instead:
 
 ```sh
 node -r manifest/register app.js
 ```
 
-Self-healing is enabled by default in your project settings.
+### n8n
 
-Verify the install from your project directory:
+Manifest runs in a self-hosted n8n with Docker Compose, through this SDK. n8n Cloud cannot load it. Run the steps in this order:
 
-```sh
-npx manifest doctor
-```
+1. Install the SDK from the folder of your `docker-compose.yml`:
+
+   ```sh
+   docker compose exec n8n npm install --prefix /home/node/.n8n/manifest manifest
+   ```
+
+2. Add these two lines to the `environment` of your n8n service, and of every worker service in queue mode:
+
+   ```yaml
+   MNFST_KEY: your-project-key
+   NODE_OPTIONS: --require /home/node/.n8n/manifest/node_modules/manifest/dist/register.cjs
+   ```
+
+3. Restart n8n:
+
+   ```sh
+   docker compose up -d
+   ```
 
-It resolves the installed SDK version, masks and validates the key against the handshake endpoint, checks that Manifest loads before your app, and prints the runtime coverage.
+n8n does not start when `NODE_OPTIONS` names a file that is not installed yet, so keep this order.
 
 ## Try it
 
-Send a request that would normally fail. Manifest catches it, repairs it, and retries:
+Send a request that fails with a 4xx error, such as a value the API rejects:
 
 ```js
 import { manifest } from 'manifest';
@@ -100,13 +126,13 @@ manifest({
 const res = await fetch('https://api.example.com/orders', {
   method: 'POST',
   headers: { 'content-type': 'application/json' },
-  body: JSON.stringify({ limit: 500 }),  // Invalid? Manifest fixes it and retries.
+  body: JSON.stringify({ limit: 500 }),  // rejected by the API
 });
-console.log(res.status);  // See the 200 OK response.
+console.log(res.status);
 ```
 
-Check your [Manifest dashboard](https://dashboard.manifest.build) to see all repairs and insights.
+The failed request appears in your [Manifest dashboard](https://dashboard.manifest.build), grouped with others like it in an issue. Once Manifest has a patch for that error, the next request that fails the same way is repaired and retried: `onHeal` reports `patched` or `unverified` with the retry's status code, and your app receives the answer to the retry.
 
 ## More
 
-[Configuration, limits & development](docs/guide.md) · [API contract](CONTRACT.md) · [Python SDK](https://github.com/mnfst/manifest-python) · [Website](https://manifest.build)
+[Documentation](https://docs.manifest.build) · [Configuration, limits & development](docs/guide.md) · [API contract](CONTRACT.md) · [Python SDK](https://github.com/mnfst/manifest-python) · [PHP SDK](https://github.com/mnfst/manifest-php) · [Website](https://manifest.build)

package/dist/bin.cjs

@@ -33,7 +33,7 @@ var import_node_path = __toESM(require("path"), 1);
 var isObject = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 
 // src/api.ts
-var VERSION = "7.2.0";
+var VERSION = "7.2.1";
 
 // src/cli.ts
 var DEFAULT_URL = "https://api.manifest.build";

package/dist/bin.js

@@ -2,7 +2,7 @@
 import {
   VERSION,
   isObject
-} from "./chunk-NHEF7GUP.js";
+} from "./chunk-OXOZQLZ3.js";
 
 // src/cli.ts
 import { createRequire } from "module";

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

@@ -293,8 +293,28 @@ 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/serverless.ts
+var CONTEXTS = [/* @__PURE__ */ Symbol.for("@vercel/request-context"), /* @__PURE__ */ Symbol.for("@next/request-context")];
+function isServerless(env = process.env) {
+  return Boolean(env.VERCEL || env.AWS_LAMBDA_FUNCTION_NAME || env.K_SERVICE);
+}
+function keepAlive(promise) {
+  try {
+    const globals = globalThis;
+    for (const symbol of CONTEXTS) {
+      const waitUntil = globals[symbol]?.get?.()?.waitUntil;
+      if (typeof waitUntil === "function") {
+        waitUntil(promise.catch(() => {
+        }));
+        return;
+      }
+    }
+  } catch {
+  }
+}
+
 // src/api.ts
-var VERSION = "7.2.0";
+var VERSION = "7.2.1";
 var MAX_HEALS_IN_FLIGHT = 8;
 var warn = (message) => process.emitWarning(message, { code: "MNFST" });
 var HealApi = class {
@@ -452,6 +472,7 @@ var HealApi = class {
     const promise = this.send(id, outcome);
     this.pending.add(promise);
     void promise.then(() => this.pending.delete(promise));
+    keepAlive(promise);
   }
   async send(id, outcome) {
     const controller = new AbortController();
@@ -492,6 +513,8 @@ export {
   REQUEST_LIMIT,
   captureRequest,
   captureResponse,
+  isServerless,
+  keepAlive,
   VERSION,
   warn,
   HealApi

package/dist/{chunk-GC5H22R2.js → chunk-RO6CIYR2.js}

@@ -5,6 +5,8 @@ import {
   captureRequest,
   captureResponse,
   isObject,
+  isServerless,
+  keepAlive,
   mergeBody,
   parseRequestBody,
   safeHeaders,
@@ -13,7 +15,7 @@ import {
   trackedUrl,
   travelingBody,
   warn
-} from "./chunk-NHEF7GUP.js";
+} from "./chunk-OXOZQLZ3.js";
 
 // src/http.ts
 import http from "http";
@@ -33,6 +35,8 @@ var CallBuffer = class {
     this.send = send;
     this.flushAt = options.flushAt ?? 500;
     this.minGapMs = options.minGapMs ?? 1e3;
+    this.immediate = options.immediate ?? false;
+    this.keepAlive = options.keepAlive ?? keepAlive;
     this.timer = setInterval(() => void this.kick(), options.intervalMs ?? 5e3);
     this.timer.unref();
   }
@@ -46,10 +50,14 @@ var CallBuffer = class {
   timer;
   flushAt;
   minGapMs;
+  immediate;
+  keepAlive;
+  draining = null;
   record(call) {
     if (this.queue.length >= MAX_BUFFER) return;
     this.queue.push(call);
-    if (this.queue.length >= this.flushAt) void this.kick();
+    if (this.immediate) this.drain();
+    else if (this.queue.length >= this.flushAt) void this.kick();
   }
   size() {
     return this.queue.length;
@@ -80,6 +88,21 @@ var CallBuffer = class {
   stop() {
     clearInterval(this.timer);
   }
+  /**
+   * Serverless: the function may freeze as soon as its response is sent, before
+   * any timer fires. So send now, through `flush()` (same gap, same single send
+   * in flight), and let the platform wait for it. Calls recorded meanwhile ride
+   * the same drain; one that lands as it settles starts the next.
+   */
+  drain() {
+    if (this.draining) return;
+    const run = this.flush().finally(() => {
+      this.draining = null;
+      if (this.queue.length > 0) this.drain();
+    });
+    this.draining = run;
+    this.keepAlive(run);
+  }
   kick() {
     if (this.inFlight || this.queue.length === 0) return;
     if (performance.now() - this.lastSentAt < this.minGapMs) return;
@@ -127,7 +150,10 @@ var Runtime = class {
     this.options = options;
     this.original = original;
     this.api = api ?? new HealApi(original, options.key, options.url);
-    this.tracker = new CallBuffer((batch, signal) => this.api.sendRequests(batch, signal));
+    this.tracker = new CallBuffer(
+      (batch, signal) => this.api.sendRequests(batch, signal),
+      { immediate: isServerless() }
+    );
   }
   options;
   original;

package/dist/index.cjs

@@ -340,8 +340,28 @@ async function captureResponse(original, limit = RESPONSE_LIMIT, timeoutMs = CAP
 // src/runtime.ts
 var import_node_crypto = require("crypto");
 
+// src/serverless.ts
+var CONTEXTS = [/* @__PURE__ */ Symbol.for("@vercel/request-context"), /* @__PURE__ */ Symbol.for("@next/request-context")];
+function isServerless(env = process.env) {
+  return Boolean(env.VERCEL || env.AWS_LAMBDA_FUNCTION_NAME || env.K_SERVICE);
+}
+function keepAlive(promise) {
+  try {
+    const globals2 = globalThis;
+    for (const symbol of CONTEXTS) {
+      const waitUntil = globals2[symbol]?.get?.()?.waitUntil;
+      if (typeof waitUntil === "function") {
+        waitUntil(promise.catch(() => {
+        }));
+        return;
+      }
+    }
+  } catch {
+  }
+}
+
 // src/api.ts
-var VERSION = "7.2.0";
+var VERSION = "7.2.1";
 var MAX_HEALS_IN_FLIGHT = 8;
 var warn = (message) => process.emitWarning(message, { code: "MNFST" });
 var HealApi = class {
@@ -499,6 +519,7 @@ var HealApi = class {
     const promise = this.send(id, outcome);
     this.pending.add(promise);
     void promise.then(() => this.pending.delete(promise));
+    keepAlive(promise);
   }
   async send(id, outcome) {
     const controller = new AbortController();
@@ -534,6 +555,8 @@ var CallBuffer = class {
     this.send = send;
     this.flushAt = options.flushAt ?? 500;
     this.minGapMs = options.minGapMs ?? 1e3;
+    this.immediate = options.immediate ?? false;
+    this.keepAlive = options.keepAlive ?? keepAlive;
     this.timer = setInterval(() => void this.kick(), options.intervalMs ?? 5e3);
     this.timer.unref();
   }
@@ -547,10 +570,14 @@ var CallBuffer = class {
   timer;
   flushAt;
   minGapMs;
+  immediate;
+  keepAlive;
+  draining = null;
   record(call) {
     if (this.queue.length >= MAX_BUFFER) return;
     this.queue.push(call);
-    if (this.queue.length >= this.flushAt) void this.kick();
+    if (this.immediate) this.drain();
+    else if (this.queue.length >= this.flushAt) void this.kick();
   }
   size() {
     return this.queue.length;
@@ -581,6 +608,21 @@ var CallBuffer = class {
   stop() {
     clearInterval(this.timer);
   }
+  /**
+   * Serverless: the function may freeze as soon as its response is sent, before
+   * any timer fires. So send now, through `flush()` (same gap, same single send
+   * in flight), and let the platform wait for it. Calls recorded meanwhile ride
+   * the same drain; one that lands as it settles starts the next.
+   */
+  drain() {
+    if (this.draining) return;
+    const run = this.flush().finally(() => {
+      this.draining = null;
+      if (this.queue.length > 0) this.drain();
+    });
+    this.draining = run;
+    this.keepAlive(run);
+  }
   kick() {
     if (this.inFlight || this.queue.length === 0) return;
     if (performance.now() - this.lastSentAt < this.minGapMs) return;
@@ -628,7 +670,10 @@ var Runtime = class {
     this.options = options;
     this.original = original;
     this.api = api ?? new HealApi(original, options.key, options.url);
-    this.tracker = new CallBuffer((batch, signal) => this.api.sendRequests(batch, signal));
+    this.tracker = new CallBuffer(
+      (batch, signal) => this.api.sendRequests(batch, signal),
+      { immediate: isServerless() }
+    );
   }
   options;
   original;

package/dist/index.d.cts

@@ -12,7 +12,7 @@ interface HealEvent {
     operations?: unknown[];
 }
 
-declare const VERSION = "7.2.0";
+declare const VERSION = "7.2.1";
 
 /** Install once, before libraries capture their own reference to global fetch. */
 declare function manifest(options?: ManifestOptions): void;

package/dist/index.d.ts

@@ -12,7 +12,7 @@ interface HealEvent {
     operations?: unknown[];
 }
 
-declare const VERSION = "7.2.0";
+declare const VERSION = "7.2.1";
 
 /** Install once, before libraries capture their own reference to global fetch. */
 declare function manifest(options?: ManifestOptions): void;

package/dist/index.js

@@ -1,9 +1,9 @@
 import {
   manifest
-} from "./chunk-GC5H22R2.js";
+} from "./chunk-RO6CIYR2.js";
 import {
   VERSION
-} from "./chunk-NHEF7GUP.js";
+} from "./chunk-OXOZQLZ3.js";
 export {
   VERSION,
   manifest

package/dist/register.cjs

@@ -327,8 +327,28 @@ async function captureResponse(original, limit = RESPONSE_LIMIT, timeoutMs = CAP
 // src/runtime.ts
 var import_node_crypto = require("crypto");
 
+// src/serverless.ts
+var CONTEXTS = [/* @__PURE__ */ Symbol.for("@vercel/request-context"), /* @__PURE__ */ Symbol.for("@next/request-context")];
+function isServerless(env = process.env) {
+  return Boolean(env.VERCEL || env.AWS_LAMBDA_FUNCTION_NAME || env.K_SERVICE);
+}
+function keepAlive(promise) {
+  try {
+    const globals2 = globalThis;
+    for (const symbol of CONTEXTS) {
+      const waitUntil = globals2[symbol]?.get?.()?.waitUntil;
+      if (typeof waitUntil === "function") {
+        waitUntil(promise.catch(() => {
+        }));
+        return;
+      }
+    }
+  } catch {
+  }
+}
+
 // src/api.ts
-var VERSION = "7.2.0";
+var VERSION = "7.2.1";
 var MAX_HEALS_IN_FLIGHT = 8;
 var warn = (message) => process.emitWarning(message, { code: "MNFST" });
 var HealApi = class {
@@ -486,6 +506,7 @@ var HealApi = class {
     const promise = this.send(id, outcome);
     this.pending.add(promise);
     void promise.then(() => this.pending.delete(promise));
+    keepAlive(promise);
   }
   async send(id, outcome) {
     const controller = new AbortController();
@@ -521,6 +542,8 @@ var CallBuffer = class {
     this.send = send;
     this.flushAt = options.flushAt ?? 500;
     this.minGapMs = options.minGapMs ?? 1e3;
+    this.immediate = options.immediate ?? false;
+    this.keepAlive = options.keepAlive ?? keepAlive;
     this.timer = setInterval(() => void this.kick(), options.intervalMs ?? 5e3);
     this.timer.unref();
   }
@@ -534,10 +557,14 @@ var CallBuffer = class {
   timer;
   flushAt;
   minGapMs;
+  immediate;
+  keepAlive;
+  draining = null;
   record(call) {
     if (this.queue.length >= MAX_BUFFER) return;
     this.queue.push(call);
-    if (this.queue.length >= this.flushAt) void this.kick();
+    if (this.immediate) this.drain();
+    else if (this.queue.length >= this.flushAt) void this.kick();
   }
   size() {
     return this.queue.length;
@@ -568,6 +595,21 @@ var CallBuffer = class {
   stop() {
     clearInterval(this.timer);
   }
+  /**
+   * Serverless: the function may freeze as soon as its response is sent, before
+   * any timer fires. So send now, through `flush()` (same gap, same single send
+   * in flight), and let the platform wait for it. Calls recorded meanwhile ride
+   * the same drain; one that lands as it settles starts the next.
+   */
+  drain() {
+    if (this.draining) return;
+    const run = this.flush().finally(() => {
+      this.draining = null;
+      if (this.queue.length > 0) this.drain();
+    });
+    this.draining = run;
+    this.keepAlive(run);
+  }
   kick() {
     if (this.inFlight || this.queue.length === 0) return;
     if (performance.now() - this.lastSentAt < this.minGapMs) return;
@@ -615,7 +657,10 @@ var Runtime = class {
     this.options = options;
     this.original = original;
     this.api = api ?? new HealApi(original, options.key, options.url);
-    this.tracker = new CallBuffer((batch, signal) => this.api.sendRequests(batch, signal));
+    this.tracker = new CallBuffer(
+      (batch, signal) => this.api.sendRequests(batch, signal),
+      { immediate: isServerless() }
+    );
   }
   options;
   original;

package/dist/register.js

@@ -1,7 +1,7 @@
 import {
   manifest
-} from "./chunk-GC5H22R2.js";
-import "./chunk-NHEF7GUP.js";
+} from "./chunk-RO6CIYR2.js";
+import "./chunk-OXOZQLZ3.js";
 
 // src/register.ts
 manifest();

package/docs/guide.md

@@ -124,7 +124,7 @@ Outcome reports are best effort, limited to 64 concurrent requests with five-sec
 
 ## Data sent to Manifest
 
-**Every call (metadata only).** For each call that is not healed, whatever its status, the SDK sends its method, URL without the query string, userinfo or fragment, status code, response time and time of the call. No headers and no bodies. Calls are batched and sent in the background, at most once per second; recording one never slows the call. Calls still buffered when a serverless runtime freezes the process can be lost.
+**Every call (metadata only).** For each call that is not healed, whatever its status, the SDK sends its method, URL without the query string, userinfo or fragment, status code, response time and time of the call. No headers and no bodies. Calls are batched and sent in the background, at most once per second; recording one never slows the call. On Vercel, AWS Lambda and Cloud Run, each call is sent as soon as it is recorded, and the function is kept alive until it is delivered.
 
 **Healable failures (full capture).** Failed URLs, request headers, JSON or form-urlencoded bodies, and raw error responses go to the configured server. Known credential names in query parameters and headers are masked; credential-named top-level request body fields are withheld and restored on retry. Exception prose is not sent for transport failures.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "manifest",
-  "version": "7.2.0",
+  "version": "7.2.1",
   "description": "Repair eligible failed API calls made by Node HTTP clients.",
   "type": "module",
   "main": "./dist/index.cjs",