lambder 15.1.1 → 16.0.1

package/dist/core/LambderCreateOptions.d.ts

@@ -19,15 +19,15 @@ import { type LambderRefusalVocabulary } from "../api/LambderApiRefusals.js";
 import type { LambderNoExtraKeys } from "../shared/util/LambderTypeUtilities.js";
 import type { LambderGuardNamesIn, LambderJsonOf } from "../shared/wire/LambderApiContract.js";
 import type { LambderRateLimitMessage } from "../shared/wire/LambderApiOptionValues.js";
-import type { MaybePromise } from "../shared/util/LambderTypeUtilities.js";
-export type LambderRouteHandler = (ctx: LambderRenderContext, resolver: LambderResolver) => MaybePromise<LambderResponse>;
-export type LambderSessionRouteHandler<SessionData = any> = (ctx: LambderSessionRenderContext<any, SessionData>, resolver: LambderResolver) => MaybePromise<LambderResponse>;
+import type { LambderMaybePromise } from "../shared/util/LambderTypeUtilities.js";
+export type LambderRouteHandler = (ctx: LambderRenderContext, resolver: LambderResolver) => LambderMaybePromise<LambderResponse>;
+export type LambderSessionRouteHandler<SessionData = any> = (ctx: LambderSessionRenderContext<any, SessionData>, resolver: LambderResolver) => LambderMaybePromise<LambderResponse>;
 export type LambderHookEvent = "created" | "beforeRender" | "afterRender" | "fallback";
 /** Return the (possibly replaced) ctx to continue, a LambderResponse to short-circuit, or an Error to fail. */
-export type LambderBeforeRenderHook = (ctx: LambderRenderContext, resolver: LambderResolver) => MaybePromise<LambderRenderContext | LambderResponse | Error>;
-export type LambderAfterRenderHook = (ctx: LambderRenderContext, resolver: LambderResolver, response: LambderResponse) => MaybePromise<LambderResponse | Error>;
+export type LambderBeforeRenderHook = (ctx: LambderRenderContext, resolver: LambderResolver) => LambderMaybePromise<LambderRenderContext | LambderResponse | Error>;
+export type LambderAfterRenderHook = (ctx: LambderRenderContext, resolver: LambderResolver, response: LambderResponse) => LambderMaybePromise<LambderResponse | Error>;
 export type LambderFallbackHook = (ctx: LambderRenderContext, resolver: LambderResolver) => void | Promise<void>;
-export type LambderGlobalErrorHandler = (err: Error, ctx: LambderRenderContext | null, response: LambderResponseBuilder) => MaybePromise<LambderResponse>;
+export type LambderGlobalErrorHandler = (err: Error, ctx: LambderRenderContext | null, response: LambderResponseBuilder) => LambderMaybePromise<LambderResponse>;
 /**
  * Where a crash happened.
  *
@@ -68,7 +68,7 @@ export type LambderCrashSite = {
  * password in the body, the session record): forward the fields a crash
  * needs rather than the whole context to an error tracker.
  */
-export type LambderCrashReporter = (error: Error, site: LambderCrashSite) => MaybePromise<void>;
+export type LambderCrashReporter = (error: Error, site: LambderCrashSite) => LambderMaybePromise<void>;
 /** The `crashes` option of create(). */
 export type LambderCrashOptions = {
     /** Told every crash on every path; see LambderCrashReporter. Default: none, and the framework's own 500 logs the crash to the console instead. */
@@ -88,10 +88,10 @@ export type LambderCrashOptions = {
      * writes its own answer, and describeCrash is there for it. A reveal
      * that throws counts as no. Default: nobody.
      */
-    reveal?: (ctx: LambderRenderContext) => MaybePromise<boolean>;
+    reveal?: (ctx: LambderRenderContext) => LambderMaybePromise<boolean>;
 };
-export type LambderFallbackHandler = (ctx: LambderRenderContext, resolver: LambderResolver) => MaybePromise<LambderResponse>;
-export type LambderInputValidationHandler = (ctx: LambderRenderContext, resolver: LambderResolver, zodError: z.ZodError) => MaybePromise<LambderResponse>;
+export type LambderFallbackHandler = (ctx: LambderRenderContext, resolver: LambderResolver) => LambderMaybePromise<LambderResponse>;
+export type LambderInputValidationHandler = (ctx: LambderRenderContext, resolver: LambderResolver, zodError: z.ZodError) => LambderMaybePromise<LambderResponse>;
 /**
  * Second argument of an addAction handler. Discriminated on `ctx`: HTTP
  * invocations get the full context and a resolver, non-HTTP invocations get
@@ -107,7 +107,7 @@ export type LambderActionTools = {
     lambdaContext: Context;
 };
 export type LambderActionFilter = (event: unknown, ctx: LambderRenderContext | null) => boolean;
-export type LambderActionHandler<TEvent = unknown> = (event: TEvent, tools: LambderActionTools) => MaybePromise<unknown>;
+export type LambderActionHandler<TEvent = unknown> = (event: TEvent, tools: LambderActionTools) => LambderMaybePromise<unknown>;
 /** Overloaded handler type returned by getHandler(): HTTP events get a typed response, others dispatch to actions. */
 export type LambderHandler = {
     (event: LambderHttpEvent, context: Context): Promise<LambderHttpResponse>;
@@ -170,8 +170,12 @@ export type LambderGuardsMap<TSessionData = any> = Record<string, LambderApiGuar
 export type LambderRateLimitPoliciesMap = Record<string, LambderApiRateLimitPolicyConfig<LambderRenderContext>>;
 /** The `rateLimits` option of create(): the engine's config, with `policies` as one map or a list of maps. */
 export type LambderCreateRateLimitsOption = Omit<LambderApiRateLimitsConfig<LambderRateLimitPoliciesMap>, "policies"> & {
-    /** Named policies referenced (typed) from defineApi: one map, or a list of maps merged in order. */
-    policies: LambderNamedMapsOption<LambderRateLimitPoliciesMap>;
+    /**
+     * Named policies referenced (typed) from defineApi: one map, or a list of
+     * maps merged in order. Left out where every policy is declared by the
+     * app's modules (defineApiModule), which count on this limiter.
+     */
+    policies?: LambderNamedMapsOption<LambderRateLimitPoliciesMap>;
 };
 /** The options as the instance holds them: the guards and the rate-limit policies merged into one map each. */
 export type LambderMergedCreateOptions<TSessionData = any> = Omit<LambderCreateOptions<TSessionData>, "guards" | "rateLimits"> & {
@@ -475,7 +479,7 @@ type LambderGuardRefusalsKnown<TGuard, TRefusals> = TGuard extends {
     refusals: readonly (keyof NonNullable<TRefusals> & string)[];
 } : unknown : unknown;
 /** Every policy in a map, or in each map of a list, held to the policy shape, its message included; a list also declares no name twice. */
-type LambderRateLimitPolicyChecks<TPolicies> = TPolicies extends readonly unknown[] ? {
+export type LambderRateLimitPolicyChecks<TPolicies> = TPolicies extends readonly unknown[] ? {
     [TIndex in keyof TPolicies]: LambderRateLimitPolicyChecks<TPolicies[TIndex]>;
 } & LambderNoRepeatedNames<TPolicies> : {
     [TPolicy in keyof TPolicies]: LambderNoExtraKeys<TPolicies[TPolicy], LambderApiRateLimitPolicyConfig<LambderRenderContext>> & (TPolicies[TPolicy] extends {
@@ -485,7 +489,7 @@ type LambderRateLimitPolicyChecks<TPolicies> = TPolicies extends readonly unknow
     } : unknown);
 };
 /** Every guard in a map, or in each map of a list, held to the guard shape and its refusals to the vocabulary; a list also declares no name twice. */
-type LambderGuardChecks<TSessionData, TGuards, TRefusals> = TGuards extends readonly unknown[] ? {
+export type LambderGuardChecks<TSessionData, TGuards, TRefusals> = TGuards extends readonly unknown[] ? {
     [TIndex in keyof TGuards]: LambderGuardChecks<TSessionData, TGuards[TIndex], TRefusals>;
 } & LambderNoRepeatedNames<TGuards> : {
     [TGuard in keyof TGuards]: LambderNoExtraKeys<TGuards[TGuard], LambderGuardsMap<TSessionData>[string]> & LambderGuardRefusalsKnown<TGuards[TGuard], TRefusals>;
@@ -510,7 +514,7 @@ export type LambderNestedOptionChecks<TSessionData, TOptions extends LambderCrea
     crashes?: LambderNoExtraKeys<NonNullable<TOptions["crashes"]>, LambderOptionShape<TSessionData, "crashes">>;
     originProof?: LambderNoExtraKeys<NonNullable<TOptions["originProof"]>, LambderOptionShape<TSessionData, "originProof">>;
     rateLimits?: LambderNoExtraKeys<NonNullable<TOptions["rateLimits"]>, LambderOptionShape<TSessionData, "rateLimits">> & {
-        policies?: LambderRateLimitPolicyChecks<NonNullable<TOptions["rateLimits"]>["policies"]>;
+        policies?: LambderRateLimitPolicyChecks<NonNullable<NonNullable<TOptions["rateLimits"]>["policies"]>>;
     };
     guards?: LambderGuardChecks<TSessionData, NonNullable<TOptions["guards"]>, TRefusals>;
     files?: TOptions["files"] extends {

package/dist/index.d.ts

@@ -1,8 +1,12 @@
 import Lambder from './core/Lambder.js';
 export default Lambder;
 export { initLambder } from './core/Lambder.js';
-export type { LambderCreatedHook } from './core/Lambder.js';
-export type { LambderAppTypes, LambderPlainAppTypes, LambderApiDeclaration, LambderApiDeclarations, LambderApiGroup, LambderLazyApiGroup, LambderRegistrableApiGroup, LambderApiModeOf, LambderEntryOf, LambderContractOfGroups, } from './api/LambderApiDeclarations.js';
+export type { LambderCreatedHook, LambderInitCreateOptions } from './core/Lambder.js';
+export type { LambderDefineApi, LambderDefineApiGroup, LambderDefineLazyApiGroup, LambderApiHandlerContext, } from './core/LambderApiBuilders.js';
+export { LambderApiModule } from './core/LambderApiModule.js';
+export type { LambderApiModuleOptions, LambderApiModuleOptionChecks, LambderModuleAppTypes } from './core/LambderApiModule.js';
+export type { LambderApiModuleDeclarations } from './api/LambderApiModules.js';
+export type { LambderAppTypes, LambderPlainAppTypes, LambderApiDeclaration, LambderApiDeclarations, LambderApiGroup, LambderLazyApiGroup, LambderRegistrableApiGroup, LambderApiModeOf, LambderEntryOf, LambderContractOfGroups, LambderRegisteredGroupsCheck, LambderActionNamesCheck, LambderGroupNameCheck, LambderGroupPartsCheck, LambderMergedParts, LambderPublicSessionPolicyCheck, LambderSessionModeCheck, } from './api/LambderApiDeclarations.js';
 export { apiCallPath, apiNameOfCallPath, splitApiName, isGroupName, isActionName, LAMBDER_API_NAME_SEGMENT, LAMBDER_CALLER_MEMBER_NAMES, LAMBDER_RESERVED_GROUP_NAMES, LAMBDER_RESERVED_ACTION_NAMES, } from './shared/wire/LambderApiNames.js';
 export type { LambderReservedGroupName, LambderReservedActionName } from './shared/wire/LambderApiNames.js';
 export type { LambderContractGroupsOf, LambderContractNamesInGroup, LambderContractActionOf } from './shared/wire/LambderApiGroupCalls.js';
@@ -77,7 +81,7 @@ export type { LambderTemplateData, LambderTemplatingEngineOptions } from "./core
 export type { LambderResponseOptions, LambderRawResponseInit, LambderTemplateFileOptions, } from "./core/LambderResponseBuilder.js";
 export type { LambderRouteMatcher, LambderRouteConditionFn, LambderRouteCondition, LambderPathParamsOf, LambderRoutePath } from "./core/LambderRouting.js";
 export type { LambderCorsConfig } from "./core/LambderCors.js";
-export type { LambderCreateOptions, LambderSessionOptions, LambderActionTools, LambderHandler, } from "./core/LambderCreateOptions.js";
+export type { LambderCreateOptions, LambderSessionOptions, LambderActionTools, LambderHandler, LambderGivenOption, LambderNamedMapsOption, LambderMergedNamedMaps, LambderNestedOptionChecks, LambderObjectOutputCheck, LambderPayloadSliceCheck, LambderRequirableGuardsField, LambderSessionEnabledInstance, } from "./core/LambderCreateOptions.js";
 export type { LambderIndexHtmlOptions } from "./core/LambderIndexHtml.js";
 export type { LambderRouteHandler, LambderSessionRouteHandler, LambderActionHandler, LambderActionFilter, LambderHookEvent, LambderBeforeRenderHook, LambderAfterRenderHook, LambderFallbackHook, LambderGlobalErrorHandler, LambderFallbackHandler, LambderInputValidationHandler, LambderCrashOptions, LambderCrashReporter, LambderCrashSite, } from "./core/LambderCreateOptions.js";
 export type { LambderPublicFilesOptions } from "./core/LambderPublicFiles.js";
@@ -136,10 +140,11 @@ export { lambderGuard, lambderRateLimitKey } from "./core/LambderPolicyBuilders.
 export { lambderGuardBuilder } from "./api/LambderApiGuards.js";
 export type { LambderGuardBuilder, LambderApiGuard, LambderGuardMeta, LambderGuardMetaMap, LambderGuardRunAt, LambderAllowedGuardNames, LambderGuardNamesInputLacks, LambderParamlessGuardNames, LambderGuardsOption, LambderGuardDataOf, LambderGuardInputsOf, LambderGuardRefusals, LambderGuardRefusalNamesOf, } from "./api/LambderApiGuards.js";
 export { LambderApiRefusalValidationError } from "./api/LambderApiRefusals.js";
-export type { LambderRefusalDeclaration, LambderRefusalVocabulary, LambderRefusalVocabularyOption, LambderMergedRefusalVocabulary, LambderApiAllowedRefusal, LambderApiAllowedRefusals, LambderEndpointRefusals, LambderRefusalsOption, LambderRefusalNamesIn, LambderHandlerRefusalsOf, LambderWireRefusalsOf, } from "./api/LambderApiRefusals.js";
+export type { LambderRefusalDeclaration, LambderRefusalVocabulary, LambderRefusalVocabularyOption, LambderRefusalVocabularyOptionChecks, LambderMergedRefusalVocabulary, LambderApiAllowedRefusal, LambderApiAllowedRefusals, LambderEndpointRefusals, LambderRefusalsOption, LambderRefusalNamesIn, LambderHandlerRefusalsOf, LambderWireRefusalsOf, } from "./api/LambderApiRefusals.js";
 export { lambderRateLimitKeyBuilder, rateLimitRefusal, DEFAULT_RATE_LIMIT_REFUSAL } from "./api/LambderApiRateLimits.js";
 export type { LambderRateLimitKeyBuilder } from "./api/LambderApiRateLimits.js";
-export type { LambderContextRateLimit, LambderContextRateLimitCheck, LambderRateLimitCheckResult, LambderChargeablePolicyNames, LambderChargeKeyArgs, LambderRateLimitKeyFn, LambderRateLimitPer, LambderRateLimitBudget, LambderRateLimitChargeAt, LambderApiRateLimitPolicyConfig, LambderApiRateLimitsConfig, LambderAllowedPolicyNames, LambderPolicyNamesInputLacks, LambderRateLimitOption, } from "./api/LambderApiRateLimits.js";
+export type { LambderContextRateLimit, LambderContextRateLimitCheck, LambderRateLimitCheckResult, LambderChargeablePolicyNames, LambderChargeKeyArgs, LambderRateLimitKeyFn, LambderRateLimitPer, LambderRateLimitBudget, LambderRateLimitChargeAt, LambderApiRateLimitPolicyConfig, LambderApiRateLimitsConfig, LambderAllowedPolicyNames, LambderPolicyNamesInputLacks, LambderRateLimitOption, LambderPolicyPerOf, } from "./api/LambderApiRateLimits.js";
+export type { LambderMaybePromise, LambderNoExtraKeys } from "./shared/util/LambderTypeUtilities.js";
 export type { LambderApiIdempotencyConfig } from "./api/LambderApiIdempotency.js";
 export type { LambderGuardsOptionValue, LambderRateLimitMessage, LambderRateLimitOverride, LambderRateLimitOptionValue, LambderRefusalsOptionValue, LambderApiIdempotencyOption, } from "./shared/wire/LambderApiOptionValues.js";
 export { apiGuardParam, apiGuardParamExportName, apisWithGuard } from "./shared/wire/LambderApiOptionEntries.js";

package/dist/index.js

@@ -1,6 +1,8 @@
 import Lambder from './core/Lambder.js';
 export default Lambder;
 export { initLambder } from './core/Lambder.js';
+// Modules: guards and rate-limit policies a part of an app declares for its own endpoints.
+export { LambderApiModule } from './core/LambderApiModule.js';
 // How an endpoint is named, and where a call to it goes.
 export { apiCallPath, apiNameOfCallPath, splitApiName, isGroupName, isActionName, LAMBDER_API_NAME_SEGMENT, LAMBDER_CALLER_MEMBER_NAMES, LAMBDER_RESERVED_GROUP_NAMES, LAMBDER_RESERVED_ACTION_NAMES, } from './shared/wire/LambderApiNames.js';
 export { default as LambderCaller } from "./client/LambderCaller.js";

package/dist/mock/LambderMockApiModule.d.ts

@@ -0,0 +1,70 @@
+import type { z } from "zod";
+import type { LambderApiContractShape } from "../shared/wire/LambderApiContract.js";
+import type { LambderApiGuard } from "../api/LambderApiGuards.js";
+import type { LambderRefusalVocabulary } from "../api/LambderApiRefusals.js";
+import type { LambderMockGuardsAgree, LambderMockGuardShapes } from "./LambderMockCreateOptions.js";
+import type { LambderMockCallContext, LambderMockEntry, LambderMockEntryGuardsCheck, LambderMockEntryInput, LambderMockGuardMapChecks, LambderMockHandler, LambderMockNotMockedGuardsCheck, LambderMockNotMockedInput, LambderMockOverride, LambderMockSessionCallContext, LambderMockSlice } from "./LambderMockTypes.js";
+/**
+ * What a mock app's defineApiModule() takes: the mock guards a part of the
+ * app declares for its own endpoints, standing in for the guards the
+ * server's module declares (its defineApiModule), as create()'s guards stand
+ * in for the server instance's. One map.
+ *
+ * No rate-limit policies: a mock takes every policy at create(), from the
+ * generated table the server writes (lambderMockPoliciesFrom), the module's
+ * among them, so none is restated by hand here.
+ */
+export type LambderMockApiModuleOptions<S = any> = {
+    /** The module's mock guards, one per guard the server's module declares, built with the mock init's guard(). */
+    guards: Record<string, LambderApiGuard<any, any, any, LambderMockCallContext<S>, LambderMockSessionCallContext<S>>>;
+};
+/** A module's map held to declaring names of its own: one the mock app's create() declares is a compile error, and the property name is the message. */
+type LambderMockModuleNamesCheck<MG, TAppNames> = [
+    Extract<keyof MG, TAppNames>
+] extends [never] ? unknown : {
+    readonly "lambder: the mock app declares these guards already; a module declares guards of its own": Extract<keyof MG, TAppNames>;
+};
+/**
+ * A module's mock guards held to what create()'s are held to: the contract,
+ * the generated guard declarations when the app was given them, surplus
+ * keys, and names of their own.
+ */
+export type LambderMockApiModuleChecks<C, S, G, D, TOptions extends LambderMockApiModuleOptions<S>> = {
+    guards: LambderMockGuardMapChecks<C, S, TOptions["guards"]> & LambderMockGuardShapes<S, TOptions["guards"]> & LambderMockGuardsAgree<TOptions["guards"], D> & LambderMockModuleNamesCheck<TOptions["guards"], keyof G>;
+};
+/**
+ * What a mock module asks of the app that made it: the app's own entry
+ * builders, given the module's declarations. The constructor's parameter,
+ * which the app's defineApiModule() passes; an app does not build one.
+ */
+export type LambderMockApiModuleDoor = {
+    api: (name: string, entry: unknown) => LambderMockEntry<any, any>;
+    notMocked: (name: string, input: unknown) => LambderMockEntry<any, any>;
+    apiSlice: (...entries: readonly LambderMockEntry<any, any>[]) => unknown;
+    override: (name: string, handler: unknown) => LambderMockOverride;
+};
+/**
+ * A part of a mock app with mock guards of its own: the app's entry builders,
+ * typed with the module's guards beside the app's. Made by the mock app's
+ * defineApiModule(); its entries are registered as any are (register,
+ * registerPartial), and registering them adds the module's guards to the
+ * app, refusing a name the app or another module declares. The mock twin of
+ * the server's LambderApiModule, so a module's mock guards are declared with
+ * the module's mocks, and the app's own setup imports none of them.
+ *
+ * `G` is the app's guards and the module's together, which is what the
+ * entries' handlers read guardData by.
+ */
+export declare class LambderMockApiModule<C extends LambderApiContractShape, S = any, G extends Record<string, LambderApiGuard<any, any, any>> = {}, TDerived extends boolean = false, TVocabulary extends LambderRefusalVocabulary = never, TCodesRequired extends boolean = false> {
+    private readonly door;
+    constructor(door: LambderMockApiModuleDoor);
+    /** A mock for one of the module's endpoints, as the app's api() builds one: its guards may be the app's and the module's own. */
+    api<K extends keyof C & string, TInputSchema extends z.ZodType = z.ZodType>(name: K & LambderMockEntryGuardsCheck<C, K, G, TDerived>, entry: LambderMockEntryInput<C, K, S, G, TInputSchema, TDerived, TVocabulary, TCodesRequired>): LambderMockEntry<C, K>;
+    /** One of the module's endpoints deliberately left without a mock, as the app's notMocked() builds one; its restated guards may name the module's. */
+    notMocked<K extends keyof C & string>(name: K & LambderMockNotMockedGuardsCheck<C, K, G, TDerived>, input: LambderMockNotMockedInput<C, K, TDerived>): LambderMockEntry<C, K>;
+    /** The entries of one slice, keyed by name, as the app's apiSlice() gathers them. */
+    apiSlice<const E extends readonly LambderMockEntry<C, keyof C & string>[]>(...entries: E): LambderMockSlice<C, E[number]["name"]>;
+    /** Replaces one of the module's registered handlers until restored, as the app's override() does, its guardData typed with the module's guards. */
+    override<K extends keyof C & string>(name: K, handler: LambderMockHandler<C, K, S, G, TVocabulary, TCodesRequired>): LambderMockOverride;
+}
+export {};

package/dist/mock/LambderMockApiModule.js

@@ -0,0 +1,34 @@
+/**
+ * A part of a mock app with mock guards of its own: the app's entry builders,
+ * typed with the module's guards beside the app's. Made by the mock app's
+ * defineApiModule(); its entries are registered as any are (register,
+ * registerPartial), and registering them adds the module's guards to the
+ * app, refusing a name the app or another module declares. The mock twin of
+ * the server's LambderApiModule, so a module's mock guards are declared with
+ * the module's mocks, and the app's own setup imports none of them.
+ *
+ * `G` is the app's guards and the module's together, which is what the
+ * entries' handlers read guardData by.
+ */
+export class LambderMockApiModule {
+    door;
+    constructor(door) {
+        this.door = door;
+    }
+    /** A mock for one of the module's endpoints, as the app's api() builds one: its guards may be the app's and the module's own. */
+    api(name, entry) {
+        return this.door.api(name, entry);
+    }
+    /** One of the module's endpoints deliberately left without a mock, as the app's notMocked() builds one; its restated guards may name the module's. */
+    notMocked(name, input) {
+        return this.door.notMocked(name, input);
+    }
+    /** The entries of one slice, keyed by name, as the app's apiSlice() gathers them. */
+    apiSlice(...entries) {
+        return this.door.apiSlice(...entries);
+    }
+    /** Replaces one of the module's registered handlers until restored, as the app's override() does, its guardData typed with the module's guards. */
+    override(name, handler) {
+        return this.door.override(name, handler);
+    }
+}

package/dist/mock/LambderMockApp.d.ts

@@ -7,6 +7,8 @@ import { type LambderDeclaredVocabulary, type LambderHandlerRefusalsOf, type Lam
 import { type LambderApiTransport, type LambderApiTransportRequest } from "../shared/transport/LambderApiTransport.js";
 import { LambderCookieJar } from "../shared/transport/LambderCookieJar.js";
 import { type LambderApiGuard } from "../api/LambderApiGuards.js";
+import type { LambderNoExtraKeys } from "../shared/util/LambderTypeUtilities.js";
+import { LambderMockApiModule, type LambderMockApiModuleChecks, type LambderMockApiModuleOptions } from "./LambderMockApiModule.js";
 import { LAMBDER_MOCK_ADAPTER_DOOR, type LambderMockAdapterDoor } from "./LambderMockAdapterDoor.js";
 import { LambderMemoryRateLimiter } from "../stores/LambderMemoryRateLimiter.js";
 import { LambderMemoryIdempotencyStore } from "../stores/LambderMemoryIdempotencyStore.js";
@@ -14,7 +16,7 @@ import { LambderMemorySessionStore } from "../stores/LambderMemorySessionStore.j
 import LambderSessionManager, { type LambderCreatedSession } from "../session/LambderSessionManager.js";
 import type { LambderMockAppOptions, LambderMockIdempotencyOptions, LambderMockTransport, LambderMockTransportOptions } from "./LambderMockCreateOptions.js";
 import type { LambderApiOptionEntry, LambderGuardDeclarationEntry } from "../shared/wire/LambderApiOptionEntries.js";
-import type { LambderMockCallContext, LambderMockCallRecord, LambderMockEntry, LambderMockEntryInput, LambderMockFailure, LambderMockFailureReason, LambderMockHandler, LambderMockLatency, LambderMockListener, LambderMockNotMockedInput, LambderMockRateLimitPolicies, LambderMockRegistryCheck, LambderMockRestEntry, LambderMockSessionCallContext, LambderMockSlice, LambderMockOverride, LambderMockRefusalsOf } from "./LambderMockTypes.js";
+import type { LambderMockCallContext, LambderMockCallRecord, LambderMockEntry, LambderMockEntryGuardsCheck, LambderMockEntryInput, LambderMockFailure, LambderMockFailureReason, LambderMockHandler, LambderMockLatency, LambderMockListener, LambderMockNotMockedGuardsCheck, LambderMockNotMockedInput, LambderMockRateLimitPolicies, LambderMockRegistryCheck, LambderMockRestEntry, LambderMockSessionCallContext, LambderMockSlice, LambderMockOverride, LambderMockRefusalsOf } from "./LambderMockTypes.js";
 /**
  * The mock runtime: the API core (LambderApiPipeline, the same class the
  * Lambda server runs) over memory stores, with typed mock handlers and mock
@@ -31,8 +33,10 @@ import type { LambderMockCallContext, LambderMockCallRecord, LambderMockEntry, L
  * generated `apiOptions` table, whose entries are their handlers alone.
  * `TVocabulary` and `TCodesRequired` are the refusal vocabulary the init
  * declared (declareRefusals), which types every handler's ctx.refuse.
+ * `D` is the generated guard declarations create() was given, which a
+ * module's mock guards are held to as create()'s are.
  */
-export declare class LambderMockApp<C extends LambderApiContractShape, S = any, G extends Record<string, LambderApiGuard<any, any, any>> = {}, TDerived extends boolean = false, TVocabulary extends LambderRefusalVocabulary = never, TCodesRequired extends boolean = false> {
+export declare class LambderMockApp<C extends LambderApiContractShape, S = any, G extends Record<string, LambderApiGuard<any, any, any>> = {}, TDerived extends boolean = false, TVocabulary extends LambderRefusalVocabulary = never, TCodesRequired extends boolean = false, D extends Record<string, LambderGuardDeclarationEntry> = {}> {
     readonly apiVersion: string | null;
     /** The memory stores, for assertions and reset; null for a subsystem that is off or backed by a store of yours. */
     readonly sessionStore: LambderMemorySessionStore<S> | null;
@@ -87,8 +91,8 @@ export declare class LambderMockApp<C extends LambderApiContractShape, S = any,
     private readonly apiOptions;
     /** The server's schemas, when create() was given the generated table: every entry's input is validated, and every answer parsed, through them. */
     private readonly apiSchemas;
-    /** The mock's own guards as create() was given them: which of them need a session, for an entry's mode without the apiOptions table. */
-    private readonly mockGuards;
+    /** The mock's own guards as create() was given them, and every registered module's beside them: which of them need a session, for an entry's mode without the apiOptions table. */
+    private mockGuards;
     /** The server's guard declarations, when create() was given the generated table: the refusal codes a declared guard adds to an entry. */
     private readonly guardDeclarations;
     /** The server's refusal vocabulary, when create() was given the generated table: whether each code an entry may refuse with carries data. */
@@ -100,6 +104,15 @@ export declare class LambderMockApp<C extends LambderApiContractShape, S = any,
     constructor(options: LambderMockAppOptions<C, S, G, LambderMockRateLimitPolicies<S>, boolean | LambderMockIdempotencyOptions<S>, {}, Record<string, LambderApiOptionEntry> | undefined>, 
     /** The vocabulary the init declared, or null: what initLambderMock().declareRefusals() passes on. */
     declared?: LambderDeclaredVocabulary<TVocabulary, TCodesRequired> | null);
+    /**
+     * A mock guard stands in for the server's guard of its name, so it
+     * declares the codes that guard declares: its own refusals type its
+     * ctx.refuse and are what checkApiRefusals holds it to. The compiler
+     * compares literal lists at the guards option and at a module's; this
+     * catches a list typed as any string and a caller the compiler did not
+     * see.
+     */
+    private assertGuardRefusalsAgree;
     /**
      * The registration-time checks every entry goes through, mocked or not:
      * the ones the server runs on a definition, and the mock's own "a session
@@ -145,6 +158,11 @@ export declare class LambderMockApp<C extends LambderApiContractShape, S = any,
      * and defaulted as on the server). Either alone where only one is given.
      */
     private entryInputOf;
+    /**
+     * An entry built and checked, by the app's api() or by a module's, whose
+     * declarations (`module`) its guards may name beside the app's own; the
+     * entry carries the module, which registering it adds.
+     */
     private buildEntry;
     /**
      * A mock for an endpoint: a handler, or the handler with the endpoint's
@@ -152,7 +170,7 @@ export declare class LambderMockApp<C extends LambderApiContractShape, S = any,
      * session endpoint's session is fetched before the handler runs, and a
      * call without one is refused as on the server.
      */
-    api<K extends keyof C & string, TInputSchema extends z.ZodType = z.ZodType>(name: K, entry: LambderMockEntryInput<C, K, S, G, TInputSchema, TDerived, TVocabulary, TCodesRequired>): LambderMockEntry<C, K>;
+    api<K extends keyof C & string, TInputSchema extends z.ZodType = z.ZodType>(name: K & LambderMockEntryGuardsCheck<C, K, G, TDerived>, entry: LambderMockEntryInput<C, K, S, G, TInputSchema, TDerived, TVocabulary, TCodesRequired>): LambderMockEntry<C, K>;
     /**
      * An endpoint deliberately left without a mock; a call answers the
      * notMocked refusal carrying the reason. The refusal runs through the
@@ -162,7 +180,9 @@ export declare class LambderMockApp<C extends LambderApiContractShape, S = any,
      * apiOptions table a session endpoint restates its guards to say so,
      * `notMocked(name, { reason, guards })`; no guard runs.
      */
-    notMocked<K extends keyof C & string>(name: K, input: LambderMockNotMockedInput<C, K, TDerived>): LambderMockEntry<C, K>;
+    notMocked<K extends keyof C & string>(name: K & LambderMockNotMockedGuardsCheck<C, K, G, TDerived>, input: LambderMockNotMockedInput<C, K, TDerived>): LambderMockEntry<C, K>;
+    /** A notMocked entry, by the app's notMocked() or by a module's, whose guards give its mode beside the app's own. */
+    private buildNotMockedEntry;
     /**
      * "Everything I did not register is not mocked, for this reason", as an
      * argument to the same register() call:
@@ -190,8 +210,33 @@ export declare class LambderMockApp<C extends LambderApiContractShape, S = any,
      * a test cares about that path.
      */
     restNotMocked(reason: string): LambderMockRestEntry;
+    /**
+     * Defines a module: the mock guards a part of the app declares with its
+     * own entries, standing in for the guards the server's module declares
+     * (its defineApiModule). Returns the module's entry builders, whose
+     * entries may name the app's guards and the module's own; registering
+     * them adds the module's guards to the app. So the app's create() need
+     * not import every module's mock guards.
+     *
+     * ```ts
+     * export const giftCardMocks = mockApp.defineApiModule({ guards: { cardHolder: mock.guard({ ... }) } });
+     * giftCardMocks.apiSlice(giftCardMocks.api("giftCards.redeem", async () => ({ redeemed: true })));
+     * ```
+     *
+     * Each guard is held to what create()'s are held to (the contract, the
+     * generated guardDeclarations, surplus keys); a name the app's create()
+     * declares is refused here, at compile time and at the call, and a name
+     * two modules declare when the second is registered.
+     */
+    defineApiModule<const TOptions extends LambderMockApiModuleOptions<S>>(options: LambderNoExtraKeys<TOptions, LambderMockApiModuleOptions<S>> & LambderMockApiModuleChecks<C, S, G, D, TOptions>): LambderMockApiModule<C, S, G & TOptions["guards"], TDerived, TVocabulary, TCodesRequired>;
     /** The entries of one module as a slice, keyed by name. Two entries for one endpoint is an error here. */
     apiSlice<const E extends readonly LambderMockEntry<C, keyof C & string>[]>(...entries: E): LambderMockSlice<C, E[number]["name"]>;
+    /**
+     * Registers slices, adding the modules their entries were built with: a
+     * module's mock guards are checked against the app's and every other
+     * module's first, and taken only once the registry took the slices, so a
+     * refused registration leaves the app as it was.
+     */
     private addSlices;
     /**
      * Registers the whole contract: every endpoint in exactly one slice, or
@@ -389,7 +434,7 @@ export declare const initLambderMock: <C extends LambderApiContractShape, S = an
          * dropped. `I` exists for the same reason `P` does, and
          * LambderMockSurplusKeys puts the error back on the key.
          */
-        create<const G extends Record<string, LambderApiGuard<any, any, any, LambderMockCallContext<S>, LambderMockSessionCallContext<S>>> = {}, const P extends LambderMockRateLimitPolicies<S> = {}, I extends boolean | LambderMockIdempotencyOptions<S> = boolean | LambderMockIdempotencyOptions<S>, const D extends Record<string, LambderGuardDeclarationEntry> = {}, const A extends Record<string, LambderApiOptionEntry> | undefined = undefined>(options: LambderMockAppOptions<C, S, G, P, I, D, A>): LambderMockApp<C, S, G, [A] extends [undefined] ? false : true, LambderMergedRefusalVocabulary<TVocabulary>, TRequireCodes>;
+        create<const G extends Record<string, LambderApiGuard<any, any, any, LambderMockCallContext<S>, LambderMockSessionCallContext<S>>> = {}, const P extends LambderMockRateLimitPolicies<S> = {}, I extends boolean | LambderMockIdempotencyOptions<S> = boolean | LambderMockIdempotencyOptions<S>, const D extends Record<string, LambderGuardDeclarationEntry> = {}, const A extends Record<string, LambderApiOptionEntry> | undefined = undefined>(options: LambderMockAppOptions<C, S, G, P, I, D, A>): LambderMockApp<C, S, G, [A] extends [undefined] ? false : true, LambderMergedRefusalVocabulary<TVocabulary>, TRequireCodes, D>;
     };
     /**
      * Builds a mock guard: the server guard's shape, the handler seeing the
@@ -425,5 +470,5 @@ export declare const initLambderMock: <C extends LambderApiContractShape, S = an
      * dropped. `I` exists for the same reason `P` does, and
      * LambderMockSurplusKeys puts the error back on the key.
      */
-    create<const G extends Record<string, LambderApiGuard<any, any, any, LambderMockCallContext<S>, LambderMockSessionCallContext<S>>> = {}, const P extends LambderMockRateLimitPolicies<S> = {}, I extends boolean | LambderMockIdempotencyOptions<S> = boolean | LambderMockIdempotencyOptions<S>, const D extends Record<string, LambderGuardDeclarationEntry> = {}, const A extends Record<string, LambderApiOptionEntry> | undefined = undefined>(options: LambderMockAppOptions<C, S, G, P, I, D, A>): LambderMockApp<C, S, G, [A] extends [undefined] ? false : true, never, false>;
+    create<const G extends Record<string, LambderApiGuard<any, any, any, LambderMockCallContext<S>, LambderMockSessionCallContext<S>>> = {}, const P extends LambderMockRateLimitPolicies<S> = {}, I extends boolean | LambderMockIdempotencyOptions<S> = boolean | LambderMockIdempotencyOptions<S>, const D extends Record<string, LambderGuardDeclarationEntry> = {}, const A extends Record<string, LambderApiOptionEntry> | undefined = undefined>(options: LambderMockAppOptions<C, S, G, P, I, D, A>): LambderMockApp<C, S, G, [A] extends [undefined] ? false : true, never, false, D>;
 };