lambder 7.3.1 → 8.1.1

package/dist/mock/LambderMockBrowserCookies.js

@@ -1,21 +1,17 @@
 import { parseSetCookie } from "../shared/transport/LambderCookieJar.js";
 /**
  * Where the runtime's cookies live outside its own answers: the jars it built
- * for itself, and the copies it planted in the page's own cookie storage.
+ * for itself, and the copies it planted in the page's cookie storage. A
+ * collaborator of LambderMockApp that owns state nothing else touches, meets
+ * the runtime at two calls (an answer coming back, reset()), and holds the
+ * one outside dependency, `document`, keeping the app free of browser
+ * conditionals.
  *
- * The fourth of LambderMockApp's collaborators, and the same argument as the
- * other three: it owns state nothing else touches and meets the runtime at two
- * calls (a transport's answer coming back, and reset()). It is the piece with
- * an outside dependency, `document`, so keeping it here is also what keeps the
- * app free of browser conditionals.
- *
- * Both the direct transport's "document" mode and the MSW adapter come through
- * one instance, so there is one mirror implementation and one record of what
- * was planted. They carried a copy each before: the MSW copy dropped `Secure`
- * on a page that is not a secure context and the transport's did not, so on
- * plain http (device testing on a LAN address) the browser silently refused
- * the CSRF cookie and every session call failed its CSRF check with nothing in
- * any log to say why.
+ * The direct transport's "document" mode and the MSW adapter share one
+ * instance, so they cannot disagree on dropping `Secure`: on plain http
+ * (device testing on a LAN address) a kept `Secure` makes the browser
+ * silently refuse the CSRF cookie, failing every session call's CSRF check
+ * with nothing in any log.
  */
 export class LambderMockBrowserCookies {
     /** The jars transport() and the adapters built for themselves, which reset() is therefore free to empty. */
@@ -24,9 +20,9 @@ export class LambderMockBrowserCookies {
     mirroredCookies = new Map();
     /**
      * Takes a jar built for the runtime as the runtime's own, so reset()
-     * empties it with the rest. A jar the app passed in stays the app's, the
-     * way an app-supplied session store does: the runtime did not create it and
-     * does not know what else holds it.
+     * empties it with the rest. A jar the app passed in stays the app's, like
+     * an app-supplied session store: the runtime does not know what else
+     * holds it.
      */
     adoptJar(jar) {
         this.ownedJars.add(jar);
@@ -35,13 +31,13 @@ export class LambderMockBrowserCookies {
      * Mirrors an answer's non-HttpOnly cookies into document.cookie and
      * remembers them for reset().
      *
-     * HttpOnly cookies are skipped exactly as a real browser skips them, the
-     * jar being the store no script can reach. `Secure` is dropped where the
-     * page is not a secure context, because the browser would refuse the write
-     * and development over plain http on a LAN address has to keep working. A
-     * `__Host-` or `__Secure-` cookie name is then discarded by the browser
-     * for breaking its own prefix rule, which is correct: such a name cannot
-     * work on plain http at all, and localhost is a secure context.
+     * HttpOnly cookies are skipped as a real browser skips them; the jar is
+     * the store no script can reach. `Secure` is dropped where the page is not
+     * a secure context, since the browser would refuse the write and plain
+     * http on a LAN address has to keep working. The browser then discards a
+     * `__Host-` or `__Secure-` name for breaking its prefix rule, which is
+     * correct: such a name cannot work on plain http, and localhost is a
+     * secure context.
      */
     mirrorSetCookies(setCookies) {
         if (typeof document === "undefined")
@@ -59,10 +55,10 @@ export class LambderMockBrowserCookies {
      * Empties the jars the runtime owns and expires what it mirrored, which is
      * what clearing the page's cookie storage would do.
      *
-     * As much a part of a rewind as the session store is: emptying the store
-     * while a jar still holds the token for one of its sessions leaves the next
-     * call carrying a session that no longer exists, which reads as signed in
-     * until the answer says sessionExpired.
+     * Part of a rewind as much as the session store is: emptying the store
+     * while a jar still holds one of its session tokens leaves the next call
+     * carrying a dead session, which reads as signed in until the answer says
+     * sessionExpired.
      */
     reset() {
         for (const jar of this.ownedJars)

package/dist/mock/LambderMockCallRecorder.d.ts

@@ -11,11 +11,10 @@ export type LambderMockCallFacts = {
     startedAt: number;
     /**
      * The call's request, read when the call settles rather than copied when it
-     * starts. The pipeline rewrites the payload as the call goes: a compressed
-     * one is restored before anything reads it, and an endpoint with an input
-     * schema replaces it with the parsed value. Copied up front, the log kept
-     * the wire fields, so the compressed calls a developer opens a panel for
-     * were the ones logged as `undefined`.
+     * starts. The pipeline rewrites the payload as the call goes (restoring a
+     * compressed one, replacing it with the parsed value under an input
+     * schema); a copy taken up front would hold the wire fields and log every
+     * compressed payload as `undefined`.
      */
     request: {
         payload: unknown;
@@ -37,20 +36,17 @@ type LambderMockCallEnding = {
  * emitted to, and the bounded log of completed calls.
  *
  * One of the four pieces of state LambderMockApp holds that nothing else
- * touches.
- * `subscribe` and `calls` stay on the app as one-line delegations, because
- * they are the surface a dev panel reads.
+ * touches. `subscribe` and `calls` are one-line delegations on the app,
+ * because they are the surface a dev panel reads.
  *
- * Ending a call is `settle`, one call for the whole of it: classification,
- * redaction, the event and the log row. A record literal built at each of the
- * three exits instead would drift between them, which is exactly what a log
- * is read to rule out.
+ * `settle` ends a call in one place: classification, redaction, the event and
+ * the log row. A record built separately at each of the three exits would
+ * drift between them, which is exactly what a log is read to rule out.
  *
- * `calls` hands out copies down to the values, so a reader that sorts
- * guardsRun or deletes a header is not editing what the next reader sees, and
- * the caller is free to edit what it got. The Error is the exception, passed
- * by reference: a clone of it would no longer be the class a test asserts on,
- * and an Error carries nothing worth protecting.
+ * `calls` hands out deep copies, so a reader that sorts guardsRun or deletes
+ * a header does not edit what the next reader sees. The Error is passed by
+ * reference: a clone would lose the class a test asserts on, and an Error
+ * carries nothing worth protecting.
  */
 export declare class LambderMockCallRecorder {
     private readonly listeners;
@@ -71,11 +67,8 @@ export declare class LambderMockCallRecorder {
     /**
      * Ends one call: reads how it went, redacts what a log has no business
      * keeping, and emits the response event and the log row from one object,
-     * so the two cannot say different things about the same call.
-     *
-     * The event and the row carry copies of their own, so a listener that
-     * edits the event it was handed is not editing the row the log keeps; the
-     * row is copied again on the way in and on the way out.
+     * so the two cannot disagree about the call. Each carries its own copies,
+     * so a listener editing its event does not edit the logged row.
      */
     settle(facts: LambderMockCallFacts, ending: LambderMockCallEnding): void;
     private push;

package/dist/mock/LambderMockCallRecorder.js

@@ -1,9 +1,8 @@
 import { LAMBDER_REFUSAL_CODES } from "../shared/wire/LambderApiRefusal.js";
 /**
  * Set-Cookie values are redacted in the log: the name stays so a reader can
- * see that a session cookie was written, the value goes, because a live
- * session token in a panel a developer renders and a test snapshots is no
- * place to keep it.
+ * see a session cookie was written, the value goes, since a live session
+ * token does not belong in a panel a developer renders or a test snapshots.
  */
 const loggedHeaders = (headers) => {
     const copy = {};
@@ -16,10 +15,9 @@ const loggedHeaders = (headers) => {
 };
 /**
  * A logged value copied, so a reader that reaches into a record cannot edit
- * what the next reader sees. structuredClone is the platform's deep copy and
- * everything logged arrived as JSON; a value it refuses (a function on the
- * payload of a hand-built request) is handed over as it is rather than
- * failing the read.
+ * what the next reader sees. Everything logged arrived as JSON, so
+ * structuredClone fits; a value it refuses (a function on a hand-built
+ * request's payload) is handed over as is rather than failing the read.
  */
 const cloneLoggedValue = (value) => {
     if (value === null || typeof value !== "object")
@@ -73,20 +71,17 @@ const classifyAnswer = (answer, envelope) => {
  * emitted to, and the bounded log of completed calls.
  *
  * One of the four pieces of state LambderMockApp holds that nothing else
- * touches.
- * `subscribe` and `calls` stay on the app as one-line delegations, because
- * they are the surface a dev panel reads.
+ * touches. `subscribe` and `calls` are one-line delegations on the app,
+ * because they are the surface a dev panel reads.
  *
- * Ending a call is `settle`, one call for the whole of it: classification,
- * redaction, the event and the log row. A record literal built at each of the
- * three exits instead would drift between them, which is exactly what a log
- * is read to rule out.
+ * `settle` ends a call in one place: classification, redaction, the event and
+ * the log row. A record built separately at each of the three exits would
+ * drift between them, which is exactly what a log is read to rule out.
  *
- * `calls` hands out copies down to the values, so a reader that sorts
- * guardsRun or deletes a header is not editing what the next reader sees, and
- * the caller is free to edit what it got. The Error is the exception, passed
- * by reference: a clone of it would no longer be the class a test asserts on,
- * and an Error carries nothing worth protecting.
+ * `calls` hands out deep copies, so a reader that sorts guardsRun or deletes
+ * a header does not edit what the next reader sees. The Error is passed by
+ * reference: a clone would lose the class a test asserts on, and an Error
+ * carries nothing worth protecting.
  */
 export class LambderMockCallRecorder {
     listeners = new Map();
@@ -127,10 +122,9 @@ export class LambderMockCallRecorder {
                 listener(event);
             }
             catch (err) {
-                // Muted, not merely reported once: a listener that throws on
-                // one event throws on the next, so leaving it in the loop
-                // costs every remaining call a thrown error and a swallowed
-                // one, for a listener that is already known to be broken.
+                // Muted, not merely reported: a listener that throws on one
+                // event throws on the next, and keeping it would cost every
+                // later call a thrown and swallowed error for nothing.
                 this.mutedListeners.add(key);
                 console.error(`[lambder mock] listener "${key}" threw and is muted until it subscribes again or the mock is reset`, err);
             }
@@ -139,11 +133,8 @@ export class LambderMockCallRecorder {
     /**
      * Ends one call: reads how it went, redacts what a log has no business
      * keeping, and emits the response event and the log row from one object,
-     * so the two cannot say different things about the same call.
-     *
-     * The event and the row carry copies of their own, so a listener that
-     * edits the event it was handed is not editing the row the log keeps; the
-     * row is copied again on the way in and on the way out.
+     * so the two cannot disagree about the call. Each carries its own copies,
+     * so a listener editing its event does not edit the logged row.
      */
     settle(facts, ending) {
         const answer = ending.answer;

package/dist/mock/LambderMockCreateOptions.d.ts

@@ -1,4 +1,8 @@
+import type { z } from "zod";
 import type { LambderApiSignatureMap } from "../shared/wire/LambderApiSignature.js";
+import type { LambderApiResponseConfig } from "../shared/wire/LambderApiContract.js";
+import type { LambderHttpStatusCode } from "../shared/wire/LambderHttpStatus.js";
+import type { MaybePromise } from "../shared/util/LambderTypeUtilities.js";
 import type { LambderContractGuardNames, LambderContractIdempotencyOf, LambderContractKeysWithMode, LambderContractRateLimitNames, LambderContractRateLimitOf } from "../shared/wire/LambderApiContract.js";
 import type { LambderApiGuard } from "../api/LambderApiGuards.js";
 import type { LambderApiRateLimitPolicyConfig } from "../api/LambderApiRateLimits.js";
@@ -35,9 +39,9 @@ export type LambderMockSessionsOptions<S> = {
  *
  * `callerIdentity` and `defaultPendingTtlSeconds` are here because a mock
  * that cannot express them answers differently from the server on exactly the
- * calls idempotency exists for: without an identity a public endpoint's stored
- * answer replays to whoever presents the key, so a mock replayed where the
- * server, configured with one, misses.
+ * calls idempotency exists for: without an identity, a public endpoint's
+ * stored answer replays to whoever presents the key, where a server
+ * configured with one misses.
  */
 export type LambderMockIdempotencyOptions<S = any> = {
     /** Seconds a stored answer replays for. Default: 86400 (24h). Per-endpoint override: `idempotency: { ttlSeconds }`. */
@@ -50,13 +54,12 @@ export type LambderMockIdempotencyOptions<S = any> = {
     store?: LambderIdempotencyStore;
     /**
      * Who a call is acting as, for scoping a PUBLIC endpoint's stored answer;
-     * session endpoints already scope per session. The server's option word
+     * session endpoints already scope per user. The server's option word
      * for word (see LambderApiIdempotencyConfig), bound to the mock's own call
      * context, because that is the context the engine hands it here.
      *
      * Without the session, as on the server: this runs on public endpoints
-     * alone, where the session is always null, so offering it would be
-     * offering a field that answers nothing.
+     * alone, where the session is always null.
      */
     callerIdentity?: (ctx: Omit<LambderMockCallContext<S>, "session">, request: LambderApiRequest) => string | null | Promise<string | null>;
 };
@@ -75,19 +78,18 @@ type LambderContractIdempotentKeys<C> = {
  * The rate limits option: the policies endpoints may restate, the limiter
  * they are counted on, and what happens when that limiter throws.
  *
- * The policies are held to what the server's own policies were held to when
- * it registered the same endpoints, because an entry the mock's copy does not
- * fit cannot be registered, and this makes that an error at the option rather
- * than a throw when the registry loads. So the map names every policy the
- * contract references, a policy a public endpoint names is not keyed per
- * session, and a policy whose windows an endpoint overrides keeps a per-API
- * budget. Policies the contract does not reference may be added freely.
+ * The policies must meet the rules the server's policies met when it
+ * registered the same endpoints: an entry the mock's copy does not fit cannot
+ * be registered, and this makes that an error at the option rather than a
+ * throw when the registry loads. So the map names every policy the contract
+ * references, a policy a public endpoint names is not keyed per session, and
+ * a policy whose windows an endpoint overrides keeps a per-API budget.
+ * Policies the contract does not reference may be added freely.
  *
- * `failOpen` is the server's own option (see LambderApiRateLimitsConfig) and
- * is here for the reason the idempotency option's twin is: with a limiter of
- * the app's own that fails, a mock that cannot express it always lets the
- * call through, so it answers 200 where a server configured to refuse answers
- * 429.
+ * `failOpen` is the server's own option (see LambderApiRateLimitsConfig),
+ * here for the idempotency option's reason: with a failing limiter of the
+ * app's own, a mock that cannot express it always lets the call through,
+ * answering 200 where a server configured to refuse answers 429.
  */
 type LambderMockRateLimitsOptions<C, S, P extends LambderMockRateLimitPolicies<S>> = {
     policies: P & {
@@ -117,9 +119,9 @@ type LambderMockRateLimitsOptions<C, S, P extends LambderMockRateLimitPolicies<S
  * omittable only for a contract that declares none.
  *
  * The same reasoning the entry's own guards field carries: a guard the mock
- * does not declare cannot run, and a call the server answers notAuthorized
- * then answers 200 here. Optional, it was the droppable half of exactly the
- * check it exists for.
+ * does not declare cannot run, so a call the server answers notAuthorized
+ * would answer 200 here. Optional, it would be the droppable half of exactly
+ * the check it exists for.
  */
 type LambderMockGuardsOption<C, S, G> = [
     LambderContractGuardNames<C>
@@ -184,9 +186,8 @@ export type LambderMockAppOptions<C, S, G, P extends LambderMockRateLimitPolicie
      *
      * One host per app, because a jar checks a cookie's scope the way a
      * browser does: planted at "localhost" and read back on
-     * "transit.localhost:5173", the session cookie is simply not sent, and
-     * every session call in a browser served from anything but plain
-     * localhost answered sessionExpired.
+     * "shop.localhost:5173", the session cookie is not sent, and every
+     * session call would answer sessionExpired.
      */
     cookieHost?: string;
     /** Ceiling on what a compressed request payload may restore to. Default: 20,000,000. */
@@ -208,6 +209,23 @@ export type LambderMockAppOptions<C, S, G, P extends LambderMockRateLimitPolicie
     revealHandlerErrors?: boolean;
     /** Called at the end of reset(), so the app can rewind its own data. */
     onReset?: () => void;
+    /**
+     * The answer to an input that fails its schema, where the server app
+     * sets setApiInputValidationErrorHandler: the same answer, stated as
+     * data. Return null for the standard 422 `validation` refusal, which is
+     * also what an app that sets neither gets.
+     */
+    onInvalidInput?: (zodError: z.ZodError, ctx: LambderMockCallContext<S>) => MaybePromise<LambderMockInvalidInputAnswer | null>;
+};
+/**
+ * What the server's input validation handler answers, as a mock states it:
+ * `res.api(payload, config)` as data, with the status it went out with (200
+ * unless named).
+ */
+export type LambderMockInvalidInputAnswer = {
+    payload?: unknown;
+    config?: LambderApiResponseConfig;
+    statusCode?: LambderHttpStatusCode;
 };
 /** How the mock transport carries cookies: a fresh memory jar (default), a jar of yours, the memory jar mirrored into document.cookie, or none. */
 export type LambderMockTransportOptions = {

package/dist/mock/LambderMockEntryRegistry.d.ts

@@ -4,14 +4,14 @@ import type { LambderMockEntry, LambderMockOverride, LambderMockRestEntry } from
  * standing over them.
  *
  * One of the four pieces of state LambderMockApp holds that nothing else
- * touches; it meets the rest of the runtime at one call, the lookup a request
- * makes. The app keeps the whole caller-facing surface (register,
- * registerPartial, override, restoreOverrides, registeredNames) as
- * delegations, because that surface is contract-typed and the checks that
- * make it safe are compile-time; what lives here is the bookkeeping.
+ * touches; the rest of the runtime reaches it only through a request's
+ * lookup. The app keeps the caller-facing surface (register, registerPartial,
+ * override, restoreOverrides, registeredNames) as delegations, because that
+ * surface is contract-typed and its safety checks are compile-time; this
+ * class holds the bookkeeping.
  *
- * Generic over the contract only so the entries keep their type through the
- * map; the registry itself never reads one.
+ * Generic over the contract only so entries keep their type through the map;
+ * the registry itself never reads one.
  */
 export declare class LambderMockEntryRegistry<C> {
     private readonly entries;
@@ -32,11 +32,10 @@ export declare class LambderMockEntryRegistry<C> {
     get restNotMockedReason(): string | null;
     /**
      * Adds every entry of every slice, and the rest entry where one is among
-     * them. Slices are staged and committed together, so a slice that fails a
-     * check leaves nothing behind: a caller that catches the error and retries
-     * sees the problem it is fixing rather than a duplicate-name error from
-     * its own first attempt. The rest entry is staged with them, for the same
-     * reason.
+     * them. Everything is staged and committed together, so a failed check
+     * leaves nothing behind: a caller that catches the error and retries sees
+     * the problem it is fixing, not a duplicate-name error from its own first
+     * attempt.
      */
     addSlices(slices: readonly (Record<string, LambderMockEntry<C, any>> | LambderMockRestEntry)[]): void;
     /** The registered entry for a name, before any override; null when there is none. */

package/dist/mock/LambderMockEntryRegistry.js

@@ -1,10 +1,9 @@
 /**
  * Which of register()'s arguments is the rest entry rather than a slice.
  *
- * Read off the one field restNotMocked() writes, which is also why that field
- * is named as it is: a slice is keyed by endpoint names holding entries, so
- * what tells the two apart has to be a key no endpoint name plausibly is,
- * carrying a value no entry is.
+ * Read off the one field restNotMocked() writes. A slice maps endpoint names
+ * to entries, so the marker has to be a key no endpoint name plausibly is,
+ * holding a value no entry is.
  */
 const isRestNotMockedEntry = (slice) => typeof slice.restNotMockedReason === "string";
 /**
@@ -12,14 +11,14 @@ const isRestNotMockedEntry = (slice) => typeof slice.restNotMockedReason === "st
  * standing over them.
  *
  * One of the four pieces of state LambderMockApp holds that nothing else
- * touches; it meets the rest of the runtime at one call, the lookup a request
- * makes. The app keeps the whole caller-facing surface (register,
- * registerPartial, override, restoreOverrides, registeredNames) as
- * delegations, because that surface is contract-typed and the checks that
- * make it safe are compile-time; what lives here is the bookkeeping.
+ * touches; the rest of the runtime reaches it only through a request's
+ * lookup. The app keeps the caller-facing surface (register, registerPartial,
+ * override, restoreOverrides, registeredNames) as delegations, because that
+ * surface is contract-typed and its safety checks are compile-time; this
+ * class holds the bookkeeping.
  *
- * Generic over the contract only so the entries keep their type through the
- * map; the registry itself never reads one.
+ * Generic over the contract only so entries keep their type through the map;
+ * the registry itself never reads one.
  */
 export class LambderMockEntryRegistry {
     entries = new Map();
@@ -42,21 +41,19 @@ export class LambderMockEntryRegistry {
     }
     /**
      * Adds every entry of every slice, and the rest entry where one is among
-     * them. Slices are staged and committed together, so a slice that fails a
-     * check leaves nothing behind: a caller that catches the error and retries
-     * sees the problem it is fixing rather than a duplicate-name error from
-     * its own first attempt. The rest entry is staged with them, for the same
-     * reason.
+     * them. Everything is staged and committed together, so a failed check
+     * leaves nothing behind: a caller that catches the error and retries sees
+     * the problem it is fixing, not a duplicate-name error from its own first
+     * attempt.
      */
     addSlices(slices) {
         const staged = new Map();
         let stagedRestReason = null;
         for (const slice of slices) {
             if (isRestNotMockedEntry(slice)) {
-                // Two of them answer the same calls with two different
-                // reasons, and which one a call would get is registration
-                // order, which is exactly what a duplicate name is refused
-                // for.
+                // Two rest entries would answer the same calls with different
+                // reasons, picked by registration order: the same ambiguity a
+                // duplicate name is refused for.
                 const registered = this.restReason ?? stagedRestReason;
                 if (registered !== null) {
                     throw new Error(`LambderMockApp: the rest of the contract is already registered as not mocked ("${registered}"). One restNotMocked entry covers every endpoint the slices leave out.`);
@@ -66,12 +63,11 @@ export class LambderMockEntryRegistry {
             }
             for (const [key, entry] of Object.entries(slice)) {
                 // The compile-time completeness check reads the slice's KEYS
-                // and registration reads entry.name, so the two have to agree
-                // or the check is checking something else than what runs. A
-                // hand-written slice is where they part: `{ ...userMocks,
-                // "user.list": someOtherEntry }` registers the other endpoint
-                // and leaves "user.list" unanswered, and the first symptom is
-                // an overlap error naming an endpoint nobody wrote twice.
+                // while registration reads entry.name, so they must agree. A
+                // hand-written `{ ...userMocks, "user.list": someOtherEntry }`
+                // would register the other endpoint, leave "user.list"
+                // unanswered, and surface as an overlap error naming an
+                // endpoint nobody wrote twice.
                 if (key !== entry.name) {
                     throw new Error(`LambderMockApp: slice key "${key}" holds the mock for "${entry.name}". Key every entry by its own endpoint name, or build the slice with mockApp.apiSlice(...).`);
                 }
@@ -97,9 +93,8 @@ export class LambderMockEntryRegistry {
         this.overrideStacks.set(name, stack);
         // Removes this override wherever it sits rather than popping the top:
         // scopes do not always unwind innermost first (an outer handle
-        // restored by hand while an inner one is still standing), and popping
-        // would then take down somebody else's override. Restoring twice is a
-        // no-op.
+        // restored by hand while an inner one stands), and popping would take
+        // down somebody else's override. Restoring twice is a no-op.
         const restore = () => {
             const current = this.overrideStacks.get(name);
             const at = current?.lastIndexOf(entry) ?? -1;

package/dist/mock/LambderMockFailureInjector.d.ts

@@ -13,12 +13,9 @@ export declare class LambderMockTransportError extends Error {
 /**
  * What a call fails with and how long it takes to do it: the queued and
  * standing failures per endpoint, the offline switch, and the configured
- * latency.
- *
- * One of the four pieces of state LambderMockApp holds that nothing else
- * touches, so it is its own object. The app keeps the whole surface
- * (failNext, setFailure, setOffline, setLatency) as one-line delegations,
- * which is what a caller reads; what moved is the bookkeeping behind them.
+ * latency. State nothing else in LambderMockApp touches, so it is its own
+ * object; the app's failNext, setFailure, setOffline and setLatency delegate
+ * here.
  *
  * Injected refusals are rendered through the real envelope helpers, never
  * hand-written: an injected 429 and an earned one have to be the same bytes,

package/dist/mock/LambderMockFailureInjector.js

@@ -20,12 +20,9 @@ export class LambderMockTransportError extends Error {
 /**
  * What a call fails with and how long it takes to do it: the queued and
  * standing failures per endpoint, the offline switch, and the configured
- * latency.
- *
- * One of the four pieces of state LambderMockApp holds that nothing else
- * touches, so it is its own object. The app keeps the whole surface
- * (failNext, setFailure, setOffline, setLatency) as one-line delegations,
- * which is what a caller reads; what moved is the bookkeeping behind them.
+ * latency. State nothing else in LambderMockApp touches, so it is its own
+ * object; the app's failNext, setFailure, setOffline and setLatency delegate
+ * here.
  *
  * Injected refusals are rendered through the real envelope helpers, never
  * hand-written: an injected 429 and an earned one have to be the same bytes,