lambder 8.1.2 → 9.0.1

package/dist/mock/LambderMockApp.js

@@ -1,6 +1,6 @@
 import { LambderApiPipeline } from "../api/LambderApiPipeline.js";
 import { readApiEnvelope, cookieValuesByName, lowercaseHeaderNames } from "../api/LambderApiRequest.js";
-import { bindCallTools, createApiCallContext } from "../api/LambderApiCallContext.js";
+import { bindCallTools, createApiCallContext, responseToolsOf } from "../api/LambderApiCallContext.js";
 import { toHttpAnswer } from "../api/LambderApiAnswer.js";
 import { getAnswerHeader } from "../shared/wire/LambderAnswerHeaders.js";
 import { buildApiEnvelope, envelopeAnswer, crashAnswer, } from "../api/LambderApiEnvelope.js";
@@ -47,7 +47,8 @@ const defaultCookieHost = () => globalThis.location?.host || "localhost";
  *
  * Create one with initLambderMock<Contract, SessionData>().create(...),
  * which fixes the contract and session types first so everything else is
- * inferred from the options.
+ * inferred from the options. `TDerived` is true for a mock created with the
+ * generated `apiOptions` table, whose entries are their handlers alone.
  */
 export class LambderMockApp {
     apiVersion;
@@ -85,10 +86,13 @@ export class LambderMockApp {
     recorder;
     /** Registered entries and the overrides over them (see LambderMockEntryRegistry). */
     registry = new LambderMockEntryRegistry();
+    /** The server's declared options per API, when create() was given the generated table; the entries' declarations come from here. */
+    apiOptions;
     /** The jars the runtime owns and what it planted in document.cookie (see LambderMockBrowserCookies). */
     browserCookies = new LambderMockBrowserCookies();
     constructor(options) {
         this.apiVersion = options.apiVersion ?? null;
+        this.apiOptions = options.apiOptions ?? null;
         this.failures = new LambderMockFailureInjector({ apiVersion: this.apiVersion, latency: options.latency ?? 0 });
         this.recorder = new LambderMockCallRecorder({ callLogSize: options.callLogSize ?? DEFAULT_CALL_LOG_SIZE });
         // The loopback address when nothing names a client, as for a request
@@ -196,13 +200,49 @@ export class LambderMockApp {
             throw new Error(`LambderMockApp: session endpoint "${definition.name}" needs the sessions option at creation.`);
         }
     }
+    /**
+     * The table's entry for an endpoint, when create() was given one: null
+     * without a table, and a throw for a name the table does not hold or an
+     * entry registered under the other mode. The compiler already refuses
+     * both against the contract; this is where a stale table meets a caller
+     * the compiler did not see.
+     */
+    declaredOptionsOf(name, mode) {
+        if (!this.apiOptions)
+            return null;
+        const declared = Object.prototype.hasOwnProperty.call(this.apiOptions, name) ? this.apiOptions[name] : undefined;
+        if (!declared) {
+            throw new Error(`LambderMockApp: "${name}" has no entry in the apiOptions table given to create(). The table predates this endpoint: regenerate it with writeApiOptions.`);
+        }
+        if (declared.mode !== mode) {
+            throw new Error(`LambderMockApp: "${name}" is a ${declared.mode} endpoint in the apiOptions table, registered here as a ${mode} one.`);
+        }
+        return declared;
+    }
+    /** The mode the apiOptions table gives a name, or null without a table or for a name it does not hold. */
+    declaredModeOf(name) {
+        if (!this.apiOptions || !Object.prototype.hasOwnProperty.call(this.apiOptions, name))
+            return null;
+        return this.apiOptions[name].mode;
+    }
     buildEntry(name, mode, input) {
         const options = (typeof input === "function" ? { handler: input } : input);
+        const declared = this.declaredOptionsOf(name, mode);
+        if (declared) {
+            // A caller the compiler did not see (a JavaScript slice, a cast)
+            // would otherwise have its restatement silently lose to the table.
+            for (const field of ["guards", "rateLimit", "idempotency"]) {
+                if (options[field] !== undefined) {
+                    throw new Error(`LambderMockApp: "${name}" restates its ${field} option, which the apiOptions table given to create() already declares. Leave it out of the entry.`);
+                }
+            }
+        }
+        const declarations = declared ?? options;
         const definition = {
             name, mode,
-            guards: options.guards,
-            rateLimit: options.rateLimit,
-            idempotency: options.idempotency,
+            guards: declarations.guards,
+            rateLimit: declarations.rateLimit,
+            idempotency: declarations.idempotency,
             // No cast: the entry's schema is a z.ZodType, the same type the
             // definition holds. A structural { safeParse } here would let a
             // validator that is not a zod schema reach the 422 body as
@@ -257,18 +297,21 @@ export class LambderMockApp {
      * still refused, and an entry registered later (registerPartial, or a
      * second register) takes its endpoint back from the rest.
      *
-     * What it cannot do is the session read. The mode of an unregistered name
-     * is not knowable at runtime (the contract is a type), so a call it
-     * answers is processed as public: the protocol's pre-pass still runs, so
-     * a stale client still hears versionExpired, but a signed-out call to an
-     * unmocked session endpoint answers "not mocked" where the server answers
-     * sessionExpired. Declare an endpoint whose signed-out path a test cares
-     * about with sessionNotMocked instead.
+     * The mode of an unregistered name comes from the apiOptions table, when
+     * create() was given one, so an unmocked session endpoint still reads the
+     * session and a signed-out call answers sessionExpired as on the server.
+     * Without the table the mode is not knowable at runtime (the contract is
+     * a type), and a call it answers is processed as public: the protocol's
+     * pre-pass still runs, so a stale client still hears versionExpired, but
+     * a signed-out call to an unmocked session endpoint answers "not mocked"
+     * where the server answers sessionExpired. Declare an endpoint whose
+     * signed-out path a test cares about with sessionNotMocked there.
      */
     restNotMocked(reason) {
         return { restNotMockedReason: reason };
     }
     buildNotMockedEntry(name, mode, reason) {
+        this.declaredOptionsOf(name, mode);
         const definition = { name, mode };
         this.assertEntryRegistration(definition);
         return { name, mode, definition, handler: null, notMockedReason: reason };
@@ -352,16 +395,18 @@ export class LambderMockApp {
     /**
      * The entry that answers a name nothing registered, when register() was
      * given a rest entry: the notMocked refusal carrying its reason, run
-     * through the pipeline as a public endpoint, since the mode of an
-     * unregistered name cannot be recovered at runtime. Everything before
-     * dispatch still runs (the signature gate, the payload restore); the
-     * missing session read is the fidelity limit restNotMocked documents.
+     * through the pipeline under the mode the apiOptions table gives the
+     * name, and as a public endpoint where there is no table to say (the
+     * mode of an unregistered name cannot otherwise be recovered at runtime).
+     * Everything before dispatch still runs (the signature gate, the payload
+     * restore, and for a session endpoint the session read).
      */
     restNotMockedEntry(apiName) {
         const reason = this.registry.restNotMockedReason;
         if (reason === null)
             return null;
-        return { name: apiName, mode: "public", definition: { name: apiName, mode: "public" }, handler: null, notMockedReason: reason };
+        const mode = this.declaredModeOf(apiName) ?? "public";
+        return { name: apiName, mode, definition: { name: apiName, mode }, handler: null, notMockedReason: reason };
     }
     // -----------------------------------------------------------------------
     // Control surface
@@ -517,7 +562,6 @@ export class LambderMockApp {
             apiName: request.apiName,
             request,
             signal: request.signal ?? new AbortController().signal,
-            envelope: {},
             payload: request.payload,
             guardInputs: request.guardInputs,
             // The key as a handler can use it. A non-string is not a key: the
@@ -546,6 +590,7 @@ export class LambderMockApp {
             methods: {
                 rateLimit: async (policy, key) => { await chargeRateLimit(policy, key, true); },
                 isRateLimited: (policy, key) => chargeRateLimit(policy, key, false),
+                ...responseToolsOf(ctx, request.host),
             },
         });
         return ctx;
@@ -581,12 +626,13 @@ export class LambderMockApp {
         const id = this.recorder.nextCallId();
         const registered = this.entryFor(request.apiName);
         // The rest entry answers whatever nothing registered, when register()
-        // was given one. The mode reported stays the registered entry's, so it
-        // is null here exactly as it is for a name the registry does not know:
-        // the rest answer is processed as public, which is a property of the
-        // answer rather than a claim about the endpoint.
+        // was given one. The mode reported is the registered entry's, or the
+        // apiOptions table's for a name it holds, and null otherwise, exactly
+        // as for a name nothing knows: without the table a rest answer is
+        // processed as public, which is a property of the answer rather than
+        // a claim about the endpoint.
         const entry = registered ?? this.restNotMockedEntry(request.apiName);
-        const mode = registered?.mode ?? null;
+        const mode = registered?.mode ?? this.declaredModeOf(request.apiName);
         const facts = this.callFacts(id, request, mode);
         const startedAt = facts.startedAt;
         const ctx = this.createContext(request);
@@ -637,7 +683,6 @@ export class LambderMockApp {
                         callCtx.payload = request.payload;
                         const payload = await handler(callCtx);
                         return envelopeAnswer(buildApiEnvelope(this.apiVersion, payload === undefined ? null : payload, {
-                            message: callCtx.envelope.message,
                             logList: callCtx.logList,
                         }));
                     }

package/dist/mock/LambderMockCreateOptions.d.ts

@@ -3,8 +3,9 @@ import type { LambderApiSignatureMap } from "../shared/wire/LambderApiSignature.
 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 { LambderContractGuardNames, LambderContractIdempotencyOf, LambderContractKeysWithMode, LambderContractMode, LambderContractRateLimitNames, LambderContractRateLimitOf } from "../shared/wire/LambderApiContract.js";
 import type { LambderApiGuard } from "../api/LambderApiGuards.js";
+import type { LambderApiOptionEntry, LambderGuardDeclarationEntry } from "../shared/wire/LambderApiOptionEntries.js";
 import type { LambderApiRateLimitPolicyConfig } from "../api/LambderApiRateLimits.js";
 import type { LambderApiRequest } from "../api/LambderApiRequest.js";
 import type { LambderApiTransport } from "../shared/transport/LambderApiTransport.js";
@@ -114,6 +115,37 @@ type LambderMockRateLimitsOptions<C, S, P extends LambderMockRateLimitPolicies<S
     /** Let a call through when the limiter throws, instead of refusing it. Default: true. */
     failOpen?: boolean;
 };
+/**
+ * The shape a mock guard has to have to stand in for a server guard the
+ * generated `guardDeclarations` table describes: the same input mode and the
+ * same session requirement. The contract cannot say these for every guard
+ * (it names a guardInput's shape, and nothing about a guard fed from the
+ * payload or from nothing), so a mock guard that reads a payload slice the
+ * server's guard never sees, or that requires a session where the server's
+ * does not, would run and decide differently without this.
+ */
+export type LambderMockGuardShapeOf<D> = (D extends {
+    input: "apiInput";
+} ? {
+    apiInput: z.ZodType;
+} : D extends {
+    input: "guardInput";
+} ? {
+    guardInput: z.ZodType;
+} : {
+    apiInput?: undefined;
+    guardInput?: undefined;
+}) & (D extends {
+    session: true;
+} ? {
+    session: true;
+} : {
+    session?: false | undefined;
+});
+/** Each mock guard the declarations know held to its declared shape; a guard the table does not have is free. */
+type LambderMockGuardsAgree<G, D> = {
+    [N in keyof G & keyof D]: G[N] extends LambderMockGuardShapeOf<D[N]> ? unknown : LambderMockGuardShapeOf<D[N]>;
+};
 /**
  * The guards option: required whenever the contract declares any guard name,
  * omittable only for a contract that declares none.
@@ -123,12 +155,12 @@ type LambderMockRateLimitsOptions<C, S, P extends LambderMockRateLimitPolicies<S
  * would answer 200 here. Optional, it would be the droppable half of exactly
  * the check it exists for.
  */
-type LambderMockGuardsOption<C, S, G> = [
+type LambderMockGuardsOption<C, S, G, D> = [
     LambderContractGuardNames<C>
 ] extends [never] ? {
-    guards?: G & LambderMockGuards<C, S> & LambderMockGuardShapes<S, G>;
+    guards?: G & LambderMockGuards<C, S> & LambderMockGuardShapes<S, G> & LambderMockGuardsAgree<G, NoInfer<D>>;
 } : {
-    guards: G & LambderMockGuards<C, S> & LambderMockGuardShapes<S, G>;
+    guards: G & LambderMockGuards<C, S> & LambderMockGuardShapes<S, G> & LambderMockGuardsAgree<G, NoInfer<D>>;
 };
 /**
  * The sessions, idempotency and rateLimits options: each required whenever
@@ -168,7 +200,38 @@ type LambderMockRateLimitsOption<C, S, P extends LambderMockRateLimitPolicies<S>
 type LambderMockGuardShapes<S, G> = {
     [N in keyof G]: LambderMockSurplusKeys<G[N], LambderApiGuard<any, any, any, LambderMockCallContext<S>, LambderMockSessionCallContext<S>>>;
 };
-export type LambderMockAppOptions<C, S, G, P extends LambderMockRateLimitPolicies<S> = LambderMockRateLimitPolicies<S>, I extends boolean | LambderMockIdempotencyOptions<S> = boolean | LambderMockIdempotencyOptions<S>> = LambderMockGuardsOption<C, S, G> & LambderMockSessionsOption<C, S> & LambderMockIdempotencyOption<C, S, I> & LambderMockRateLimitsOption<C, S, P> & {
+/**
+ * What the generated `apiOptions` table has to hold to stand in for the
+ * restated declarations of a contract's entries: an entry for every endpoint
+ * the contract declares, of the endpoint's mode. A table generated before an
+ * endpoint was added, or before one changed mode, is a compile error at the
+ * option rather than a throw when that endpoint's entry registers.
+ */
+export type LambderMockApiOptionsCover<C> = {
+    [K in keyof C & string]: {
+        mode: LambderContractMode<C, K>;
+    };
+};
+export type LambderMockAppOptions<C, S, G, P extends LambderMockRateLimitPolicies<S> = LambderMockRateLimitPolicies<S>, I extends boolean | LambderMockIdempotencyOptions<S> = boolean | LambderMockIdempotencyOptions<S>, D extends Record<string, LambderGuardDeclarationEntry> = {}, A extends Record<string, LambderApiOptionEntry> | undefined = undefined> = LambderMockGuardsOption<C, S, G, D> & LambderMockSessionsOption<C, S> & LambderMockIdempotencyOption<C, S, I> & LambderMockRateLimitsOption<C, S, P> & {
+    /**
+     * The server's guard declarations, as the generated options module
+     * exports them (`guardDeclarations`). Given, every mock guard of a name
+     * the table has is held to its input mode and session requirement at
+     * the `guards` option (see LambderMockGuardShapeOf). Nothing runs on it.
+     */
+    guardDeclarations?: D;
+    /**
+     * The server's declared options per API, as the generated options module
+     * exports them (`apiOptions`). Given, every entry's guards, rateLimit and
+     * idempotency are read off the table rather than restated: an entry is
+     * its handler (and an input schema, if it has one), a restated option is
+     * a compile error, and an endpoint whose mode the table and the builder
+     * disagree on is refused at registration. A restNotMocked answer reads
+     * the endpoint's mode off the table too, so a session endpoint nothing
+     * mocks still reads the session first. The table has to cover the
+     * contract (see LambderMockApiOptionsCover).
+     */
+    apiOptions?: A & LambderMockApiOptionsCover<C>;
     /** Stamped on every answer's envelope as apiVersion, as the server's option is. */
     apiVersion?: string;
     /** The version floor, as on the server: a call naming a lower `version` answers versionExpired whatever its signature says. */
@@ -219,8 +282,8 @@ export type LambderMockAppOptions<C, S, G, P extends LambderMockRateLimitPolicie
 };
 /**
  * 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).
+ * the handler's `res.api(payload, config)` as data, with the status it went
+ * out with (200 unless named).
  */
 export type LambderMockInvalidInputAnswer = {
     payload?: unknown;

package/dist/mock/LambderMockTypes.d.ts

@@ -9,7 +9,7 @@ import type { z } from "zod";
 import type { LambderApiMode, LambderContractGuardInput, LambderContractGuardInputNames, LambderContractGuardInputsOf, LambderContractGuardNames, LambderContractGuardsOf, LambderContractIdempotencyOf, LambderContractKeysWithMode, LambderContractMode, LambderContractRateLimitOf } from "../shared/wire/LambderApiContract.js";
 import type { LambderApiGuard, LambderGuardDataOf, LambderGuardMetaMap } from "../api/LambderApiGuards.js";
 import type { LambderApiRateLimitPolicyConfig, LambderContextRateLimit, LambderContextRateLimitCheck } from "../api/LambderApiRateLimits.js";
-import type { LambderApiCallContext } from "../api/LambderApiCallContext.js";
+import type { LambderApiCallContext, LambderResponseTools } from "../api/LambderApiCallContext.js";
 import type { LambderApiRequest } from "../api/LambderApiRequest.js";
 import type { LambderHttpStatusCode } from "../shared/wire/LambderHttpStatus.js";
 import type { LambderApiDefinition } from "../api/LambderApiDefinition.js";
@@ -47,7 +47,7 @@ export type LambderMockSurplusKeys<TOptions, TShape> = [
  * fields: the API core's call context plus the request, a session
  * controller for the call, and the caller's abort signal.
  */
-export type LambderMockCallContext<S = any> = LambderApiCallContext<S> & {
+export type LambderMockCallContext<S = any> = LambderApiCallContext<S> & LambderResponseTools & {
     apiName: string;
     request: LambderApiRequest;
     /** Create, rotate, refresh and end sessions, exactly as a server handler does through its own ctx.sessionController. */
@@ -61,15 +61,6 @@ export type LambderMockCallContext<S = any> = LambderApiCallContext<S> & {
     /** The same count, answered instead of thrown, as ctx.isRateLimited on the server. */
     isRateLimited: LambderContextRateLimitCheck<Record<string, LambderApiRateLimitPolicyConfig>>;
     signal: AbortSignal;
-    /**
-     * The envelope fields that travel beside the payload, the mock's stand-in
-     * for the server's `res.api(payload, config)`: a mock handler returns its
-     * payload, so this is where the rest of the envelope goes. `logList` is
-     * the usual channel and lives on the context itself.
-     */
-    envelope: {
-        message?: string;
-    };
 };
 /** The same, with the session present: what a `session: true` mock guard and a session endpoint's handler see. */
 export type LambderMockSessionCallContext<S = any> = Omit<LambderMockCallContext<S>, "session"> & {
@@ -186,8 +177,26 @@ type LambderMockInputPin<C, K extends keyof C, TSchema extends z.ZodType> = [
 }) : {
     "LambderMockApp: this input schema takes something else than the endpoint's contract input": LambderMockInputOf<C, K>;
 };
-/** An entry written in full: the declarations restated and pinned, plus the handler. */
-export type LambderMockEntryOptions<C, K extends keyof C, S, G, TInputSchema extends z.ZodType = z.ZodType> = LambderMockGuardsField<C, K> & LambderMockRateLimitField<C, K> & LambderMockIdempotencyField<C, K> & {
+/**
+ * The three declaration fields of an entry on a mock created with the
+ * generated `apiOptions` table: absent, because the runtime reads them off
+ * the table. A restatement beside the table would be a second copy of the
+ * server's declaration, so writing one is an error rather than an override.
+ */
+type LambderMockDerivedFields = {
+    /** Read off the apiOptions table given to create(); not restated. */
+    guards?: never;
+    /** Read off the apiOptions table given to create(); not restated. */
+    rateLimit?: never;
+    /** Read off the apiOptions table given to create(); not restated. */
+    idempotency?: never;
+};
+/**
+ * An entry written in full: the handler, and the declarations restated and
+ * pinned to the contract, or, with `TDerived` (a mock created with the
+ * generated `apiOptions` table), the handler alone.
+ */
+export type LambderMockEntryOptions<C, K extends keyof C, S, G, TInputSchema extends z.ZodType = z.ZodType, TDerived extends boolean = false> = (TDerived extends true ? LambderMockDerivedFields : LambderMockGuardsField<C, K> & LambderMockRateLimitField<C, K> & LambderMockIdempotencyField<C, K>) & {
     /**
      * A schema to validate the posted payload against, so the mock answers
      * 422 exactly as the server would. Optional, and the mock's own: the
@@ -201,15 +210,16 @@ export type LambderMockEntryOptions<C, K extends keyof C, S, G, TInputSchema ext
     handler: LambderMockHandler<C, K, S, G>;
 };
 /**
- * What publicApi/sessionApi accept: a bare handler only for an endpoint the
- * contract declares nothing for, the full options otherwise, so the form that
- * cannot carry a restatement is unavailable exactly where one is owed. Keyed
- * on all three declarations: keyed on guards alone, a guardless endpoint
- * could drop its rate limit and idempotency through the bare form.
+ * What publicApi/sessionApi accept. On a mock created with the generated
+ * `apiOptions` table (`TDerived`), a bare handler or the options without the
+ * declarations, for every endpoint. Otherwise a bare handler only for an
+ * endpoint the contract declares nothing for, the full options elsewhere, so
+ * the form that cannot carry a restatement is unavailable exactly where one
+ * is owed. Keyed on all three declarations: keyed on guards alone, a
+ * guardless endpoint could drop its rate limit and idempotency through the
+ * bare form.
  */
-export type LambderMockEntryInput<C, K extends keyof C, S, G, TInputSchema extends z.ZodType = z.ZodType> = [
-    LambderContractGuardsOf<C, K> | LambderContractRateLimitOf<C, K> | LambderContractIdempotencyOf<C, K>
-] extends [never] ? LambderMockHandler<C, K, S, G> | LambderMockEntryOptions<C, K, S, G, TInputSchema> : LambderMockEntryOptions<C, K, S, G, TInputSchema>;
+export type LambderMockEntryInput<C, K extends keyof C, S, G, TInputSchema extends z.ZodType = z.ZodType, TDerived extends boolean = false> = TDerived extends true ? LambderMockHandler<C, K, S, G> | LambderMockEntryOptions<C, K, S, G, TInputSchema, true> : [LambderContractGuardsOf<C, K> | LambderContractRateLimitOf<C, K> | LambderContractIdempotencyOf<C, K>] extends [never] ? LambderMockHandler<C, K, S, G> | LambderMockEntryOptions<C, K, S, G, TInputSchema> : LambderMockEntryOptions<C, K, S, G, TInputSchema>;
 /** One registry entry: the endpoint's definition as the pipeline runs it, and its handler (null when registered as not mocked). */
 export type LambderMockEntry<C, K extends keyof C & string> = {
     readonly name: K;

package/dist/mock/lambderMockPoliciesFrom.d.ts

@@ -0,0 +1,51 @@
+import type { LambderRateLimitKeyFn } from "../api/LambderApiRateLimits.js";
+import type { LambderRateLimitPolicyEntry } from "../shared/wire/LambderApiOptionEntries.js";
+/** The names of the policies in a generated table whose key the app derives, and so the ones a mock has to supply a key handler for. */
+export type LambderCustomKeyedPolicyNames<TPolicies> = {
+    [N in keyof TPolicies]: TPolicies[N] extends {
+        per: "custom";
+    } ? N : never;
+}[keyof TPolicies] & string;
+/** One policy as the mock runs it: the table's entry with its `per` put back, the key handler for a custom one and the literal for the rest. */
+type LambderMockPolicyOf<TPolicy, TKey> = Omit<TPolicy, "per"> & (TPolicy extends {
+    per: "custom";
+} ? {
+    per: TKey;
+} : TPolicy extends {
+    per: infer P;
+} ? {
+    per: P;
+} : {});
+/** The key handlers a table needs: one per custom-keyed policy, none where the table has none. */
+export type LambderMockPolicyKeys<TPolicies> = {
+    [N in LambderCustomKeyedPolicyNames<TPolicies>]: LambderRateLimitKeyFn<any, any>;
+};
+/**
+ * The rate-limit policies a mock's create() takes, built from a generated
+ * `rateLimitPolicies` table and the key handlers for its custom-keyed
+ * policies (built with the mock's own `rateLimitKey`, so they see the mock's
+ * context). Required for exactly those policies, refused for any other:
+ *
+ * ```ts
+ * const mockApp = mock.create({
+ *     rateLimits: {
+ *         policies: lambderMockPoliciesFrom(rateLimitPolicies, {
+ *             keys: {
+ *                 codePerEmail: mock.rateLimitKey({ apiInput: z.object({ email: z.string() }), handler: (_ctx, { email }) => email.toLowerCase() }),
+ *             },
+ *         }),
+ *     },
+ * });
+ * ```
+ *
+ * Everything else about a policy (windows, budget, charge point, message) is
+ * the table's, so a mock never disagrees with the server about a limit it
+ * did not mean to change. The result keeps each policy's `per` and `budget`
+ * as literals, which is what lets create() hold it to the contract.
+ */
+export declare const lambderMockPoliciesFrom: <const TPolicies extends Record<string, LambderRateLimitPolicyEntry>, const TKeys extends LambderMockPolicyKeys<TPolicies> = LambderMockPolicyKeys<TPolicies>>(policies: TPolicies, options: [LambderCustomKeyedPolicyNames<TPolicies>] extends [never] ? {
+    keys?: TKeys & Record<Exclude<keyof TKeys, LambderCustomKeyedPolicyNames<TPolicies>>, never>;
+} : {
+    keys: TKeys & Record<Exclude<keyof TKeys, LambderCustomKeyedPolicyNames<TPolicies>>, never>;
+}) => { [N in keyof TPolicies]: LambderMockPolicyOf<TPolicies[N], N extends keyof TKeys ? TKeys[N] : never>; };
+export {};

package/dist/mock/lambderMockPoliciesFrom.js

@@ -0,0 +1,46 @@
+/**
+ * The rate-limit policies a mock's create() takes, built from a generated
+ * `rateLimitPolicies` table and the key handlers for its custom-keyed
+ * policies (built with the mock's own `rateLimitKey`, so they see the mock's
+ * context). Required for exactly those policies, refused for any other:
+ *
+ * ```ts
+ * const mockApp = mock.create({
+ *     rateLimits: {
+ *         policies: lambderMockPoliciesFrom(rateLimitPolicies, {
+ *             keys: {
+ *                 codePerEmail: mock.rateLimitKey({ apiInput: z.object({ email: z.string() }), handler: (_ctx, { email }) => email.toLowerCase() }),
+ *             },
+ *         }),
+ *     },
+ * });
+ * ```
+ *
+ * Everything else about a policy (windows, budget, charge point, message) is
+ * the table's, so a mock never disagrees with the server about a limit it
+ * did not mean to change. The result keeps each policy's `per` and `budget`
+ * as literals, which is what lets create() hold it to the contract.
+ */
+export const lambderMockPoliciesFrom = (policies, options) => {
+    const keys = (options.keys ?? {});
+    const built = {};
+    for (const [name, entry] of Object.entries(policies)) {
+        const { per, ...rest } = entry;
+        if (per === "custom") {
+            const key = keys[name];
+            if (typeof key?.handler !== "function") {
+                throw new Error(`LambderMockApp: rate-limit policy "${name}" is keyed by a handler of the server's, so the mock has to supply one: lambderMockPoliciesFrom(rateLimitPolicies, { keys: { ${name}: mock.rateLimitKey({ ... }) } }).`);
+            }
+            built[name] = { ...rest, per: key };
+        }
+        else {
+            built[name] = per === undefined ? { ...rest } : { ...rest, per };
+        }
+    }
+    for (const name of Object.keys(keys)) {
+        if (policies[name]?.per !== "custom") {
+            throw new Error(`LambderMockApp: a key handler was given for rate-limit policy "${name}", which the server ${name in policies ? "does not key by a handler" : "does not declare"}.`);
+        }
+    }
+    return built;
+};

package/dist/mock.d.ts

@@ -10,6 +10,9 @@ export { LambderMockApp, initLambderMock } from "./mock/LambderMockApp.js";
 export { LambderMockTransportError } from "./mock/LambderMockFailureInjector.js";
 export type { LambderMockAppOptions, LambderMockSessionsOptions, LambderMockIdempotencyOptions, LambderMockInvalidInputAnswer, LambderMockTransport, LambderMockTransportOptions } from "./mock/LambderMockCreateOptions.js";
 export type { LambderMockCallContext, LambderMockSessionCallContext, LambderMockContext, LambderMockGuards, LambderMockHandler, LambderMockEntry, LambderMockEntryOptions, LambderMockEntryInput, LambderMockSlice, LambderMockRestEntry, LambderMockRegistryCheck, LambderMockMissingNames, LambderMockStrayNames, LambderMockDuplicateNames, LambderMockPublicNames, LambderMockSessionNames, LambderMockLatency, LambderMockFailure, LambderMockFailureReason, LambderMockOutcome, LambderMockCallEvent, LambderMockRequestEvent, LambderMockResponseEvent, LambderMockCallRecord, LambderMockListener, LambderMockRateLimitPolicies, LambderMockInputOf, LambderMockOutputOf, LambderMockOverride, } from "./mock/LambderMockTypes.js";
+export { lambderMockPoliciesFrom } from "./mock/lambderMockPoliciesFrom.js";
+export type { LambderCustomKeyedPolicyNames, LambderMockPolicyKeys } from "./mock/lambderMockPoliciesFrom.js";
+export type { LambderMockGuardShapeOf } from "./mock/LambderMockCreateOptions.js";
 export { lambderMockConsoleLogger } from "./mock/lambderMockConsoleLogger.js";
 export type { LambderMockConsoleLoggerOptions } from "./mock/lambderMockConsoleLogger.js";
 export { lambderMockMswHandler } from "./mock/lambderMockMswHandler.js";

package/dist/mock.js

@@ -12,6 +12,9 @@ export { LambderMockApp, initLambderMock } from "./mock/LambderMockApp.js";
 // exported: the runtime is reached through the app. Only the error a
 // transport rejects with is public.
 export { LambderMockTransportError } from "./mock/LambderMockFailureInjector.js";
+// The server's rate-limit policies as the mock restates them, from the
+// generated options module plus the key handlers the module cannot hold.
+export { lambderMockPoliciesFrom } from "./mock/lambderMockPoliciesFrom.js";
 export { lambderMockConsoleLogger } from "./mock/lambderMockConsoleLogger.js";
 export { lambderMockMswHandler } from "./mock/lambderMockMswHandler.js";
 // The storage a mock app's uploads go to: a memory bucket the mock's ticket and