lambder 6.0.2 → 7.0.2

package/dist/shared/wire/LambderAnswerHeaders.d.ts

@@ -0,0 +1,60 @@
+/**
+ * An answer's headers: the case-insensitive read, replace and append every
+ * layer uses on a plain header map, and the accumulator that records what a
+ * call wrote so it can be applied onto whichever answer the call ends up
+ * with.
+ *
+ * One implementation, at the bottom of the stack, because every layer above
+ * it needs the same one: LambderResponse's own header methods are these three
+ * functions, and a second copy had already drifted from them.
+ */
+/** The header's values under a case-insensitive lookup, or undefined. */
+export declare const getAnswerHeader: (headers: Record<string, string[]>, name: string) => string[] | undefined;
+/** Replaces the header under any casing of its name. */
+export declare const setAnswerHeader: (headers: Record<string, string[]>, name: string, value: string | string[]) => void;
+/** Appends a value to the header, under the casing it already has if any. */
+export declare const addAnswerHeader: (headers: Record<string, string[]>, name: string, value: string) => void;
+/** What LambderAnswerHeaders applies onto: a LambderResponse, or a header map. */
+export type LambderHeaderTarget = {
+    getHeader(key: string): string[] | undefined;
+    setHeader(key: string, value: string | string[]): unknown;
+    addHeader(key: string, value: string): unknown;
+};
+/**
+ * Response headers written while a call runs (`res.setHeader`, `res.addHeader`,
+ * the session controller's Set-Cookie), applied onto the answer once the
+ * call has one. Recorded as operations in call order rather than as a map,
+ * so `set` replaces what the answer itself carries (a Content-Type, say) and
+ * `add` appends to it, exactly as the two would if called on the answer
+ * directly.
+ *
+ * These headers belong to the CALL, not to the response that first carried
+ * them: on the server an afterRender hook may answer with a different
+ * response than the handler produced, and a session cookie written during the
+ * call has to travel across to it. So applying never forgets the operations,
+ * and applying the same ones twice is a no-op: `set` writes the same value
+ * again, and `add` skips a value the header already carries. The one thing
+ * that costs is two `add` calls of the identical value under one name, which
+ * collapse to one; duplicate identical header values carry no meaning in
+ * HTTP, so nothing observable is lost.
+ */
+export declare class LambderAnswerHeaders {
+    private operations;
+    set(key: string, value: string | string[]): void;
+    add(key: string, value: string): void;
+    /**
+     * How many operations have been recorded. Also a mark: reading it before
+     * a step and passing it back as `fromIndex` applies only what that step
+     * wrote.
+     */
+    get size(): number;
+    /**
+     * Applies the recorded operations, in order, onto anything that reads and
+     * writes headers: a LambderResponse, or a header map through applyInto.
+     * One definition of what an operation does, so the two targets cannot
+     * drift apart.
+     */
+    applyTo(target: LambderHeaderTarget, fromIndex?: number): void;
+    /** The same, onto an answer's plain header map. */
+    applyInto(headers: Record<string, string[]>, fromIndex?: number): void;
+}

package/dist/shared/wire/LambderAnswerHeaders.js

@@ -0,0 +1,94 @@
+/**
+ * An answer's headers: the case-insensitive read, replace and append every
+ * layer uses on a plain header map, and the accumulator that records what a
+ * call wrote so it can be applied onto whichever answer the call ends up
+ * with.
+ *
+ * One implementation, at the bottom of the stack, because every layer above
+ * it needs the same one: LambderResponse's own header methods are these three
+ * functions, and a second copy had already drifted from them.
+ */
+/** The header's values under a case-insensitive lookup, or undefined. */
+export const getAnswerHeader = (headers, name) => {
+    const lower = name.toLowerCase();
+    for (const [key, values] of Object.entries(headers)) {
+        if (key.toLowerCase() === lower)
+            return values;
+    }
+    return undefined;
+};
+/** Replaces the header under any casing of its name. */
+export const setAnswerHeader = (headers, name, value) => {
+    const lower = name.toLowerCase();
+    for (const key of Object.keys(headers)) {
+        if (key.toLowerCase() === lower)
+            delete headers[key];
+    }
+    headers[name] = Array.isArray(value) ? [...value] : [value];
+};
+/** Appends a value to the header, under the casing it already has if any. */
+export const addAnswerHeader = (headers, name, value) => {
+    const lower = name.toLowerCase();
+    const existing = Object.keys(headers).find((key) => key.toLowerCase() === lower);
+    if (existing)
+        headers[existing].push(value);
+    else
+        headers[name] = [value];
+};
+/**
+ * Response headers written while a call runs (`res.setHeader`, `res.addHeader`,
+ * the session controller's Set-Cookie), applied onto the answer once the
+ * call has one. Recorded as operations in call order rather than as a map,
+ * so `set` replaces what the answer itself carries (a Content-Type, say) and
+ * `add` appends to it, exactly as the two would if called on the answer
+ * directly.
+ *
+ * These headers belong to the CALL, not to the response that first carried
+ * them: on the server an afterRender hook may answer with a different
+ * response than the handler produced, and a session cookie written during the
+ * call has to travel across to it. So applying never forgets the operations,
+ * and applying the same ones twice is a no-op: `set` writes the same value
+ * again, and `add` skips a value the header already carries. The one thing
+ * that costs is two `add` calls of the identical value under one name, which
+ * collapse to one; duplicate identical header values carry no meaning in
+ * HTTP, so nothing observable is lost.
+ */
+export class LambderAnswerHeaders {
+    operations = [];
+    set(key, value) {
+        this.operations.push({ op: "set", key, value });
+    }
+    add(key, value) {
+        this.operations.push({ op: "add", key, value });
+    }
+    /**
+     * How many operations have been recorded. Also a mark: reading it before
+     * a step and passing it back as `fromIndex` applies only what that step
+     * wrote.
+     */
+    get size() { return this.operations.length; }
+    /**
+     * Applies the recorded operations, in order, onto anything that reads and
+     * writes headers: a LambderResponse, or a header map through applyInto.
+     * One definition of what an operation does, so the two targets cannot
+     * drift apart.
+     */
+    applyTo(target, fromIndex = 0) {
+        for (const operation of this.operations.slice(fromIndex)) {
+            if (operation.op === "set") {
+                target.setHeader(operation.key, operation.value);
+            }
+            else if (!target.getHeader(operation.key)?.includes(operation.value)) {
+                target.addHeader(operation.key, operation.value);
+            }
+        }
+    }
+    /** The same, onto an answer's plain header map. */
+    applyInto(headers, fromIndex = 0) {
+        this.applyTo({
+            getHeader: (key) => getAnswerHeader(headers, key),
+            setHeader: (key, value) => setAnswerHeader(headers, key, value),
+            addHeader: (key, value) => addAnswerHeader(headers, key, value),
+        }, fromIndex);
+    }
+}

package/dist/shared/wire/LambderApiContract.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Lambder API Contract System
+ *
+ * Contracts are built via method chaining and inferred using typeof lambder.ApiContract
+ */
+import type { LambderCrashDetail } from "./LambderCrashDetail.js";
+import type { LambderNonEmptyOptionMap } from "../util/LambderTypeUtilities.js";
+import type { LambderAppRefusalMessage } from "./LambderApiRefusal.js";
+import type { LambderApiIdempotencyOption, LambderGuardsOptionValue, LambderRateLimitOptionValue } from "./LambderApiOptionValues.js";
+/** Whether an endpoint runs without a session or requires one (addApi versus addSessionApi). */
+export type LambderApiMode = "public" | "session";
+/**
+ * Base shape for API contracts: what LambderCaller, LambderInvokeCaller and
+ * LambderMockApp accept as a contract type.
+ */
+export type LambderApiContractShape = Record<string, {
+    input: any;
+    output: any;
+    /** "public" (addApi) or "session" (addSessionApi). */
+    mode?: LambderApiMode;
+    /** Present when the API declares guardInput-mode guards: guard name -> value the client must send via options.guardInputs. */
+    guardInputs?: any;
+    /**
+     * Present when the API declares guards: the `guards` option exactly as
+     * written at registration, so a client-side copy of "what does this API
+     * need" can be pinned to the server's own declaration with `satisfies`
+     * rather than kept honest by a test that reads the source.
+     */
+    guards?: LambderGuardsOptionValue;
+    /** Present when the API declares a rate limit: the `rateLimit` option exactly as written. */
+    rateLimit?: LambderRateLimitOptionValue;
+    /** Present when the API declares idempotency: the `idempotency` option exactly as written. */
+    idempotency?: LambderApiIdempotencyOption;
+}>;
+/** Envelope flags/channels the server may set beside (or instead of) the payload. */
+export type LambderApiResponseConfig = {
+    versionExpired?: boolean;
+    sessionExpired?: boolean;
+    notAuthorized?: boolean;
+    message?: any;
+    /** A refusal message, or a plain string: what LambderApiRefusal and res.api(null, { errorMessage }) put here. */
+    errorMessage?: LambderAppRefusalMessage | string;
+    logList?: any[];
+    /**
+     * A crash described in full (name, message, stack, cause chain, where it
+     * happened), for a caller that is allowed to see it: a global error
+     * handler answering a trusted invoker sets it with describeCrash().
+     * LambderInvokeCaller reads it back as the cause of the error it throws;
+     * the browser caller ignores it.
+     */
+    crash?: LambderCrashDetail;
+};
+/**
+ * The config a null answer carries: at least one of the reason fields, so
+ * `res.api(null, {})` is a compile error. A bare null with no flag and no
+ * message reaches the caller as a success whose payload is null, which is
+ * indistinguishable from an endpoint that answered nothing on purpose.
+ */
+export type LambderApiNullAnswerConfig = LambderNonEmptyOptionMap<Pick<LambderApiResponseConfig, "versionExpired" | "sessionExpired" | "notAuthorized" | "errorMessage" | "message">> & LambderApiResponseConfig;
+/** The API wire envelope both sides speak: res.api() emits it, LambderCaller parses it. */
+export type LambderApiEnvelopeBody<T> = LambderApiResponseConfig & {
+    apiVersion?: string | null;
+    payload?: T | null;
+};
+/**
+ * One contract entry as addApi/addSessionApi record it: the payload types,
+ * the mode, and every declarative option exactly as written. Options that
+ * were not written are absent rather than undefined, so `keyof` an entry
+ * lists only what the endpoint declared.
+ */
+export type LambderContractEntry<In, Out, Mode extends LambderApiMode, GuardInputs = never, Guards = never, RateLimit = never, Idempotency = never> = {
+    input: In;
+    output: Out;
+    mode: Mode;
+} & ([GuardInputs] extends [never] ? {} : {
+    guardInputs: GuardInputs;
+}) & ([Guards] extends [never] ? {} : {
+    guards: Guards;
+}) & ([RateLimit] extends [never] ? {} : {
+    rateLimit: RateLimit;
+}) & ([Idempotency] extends [never] ? {} : {
+    idempotency: Idempotency;
+});
+/** Helper type for merging a new entry into the contract during chaining. */
+export type LambderMergeContract<Old, Name extends string, Entry> = Old & {
+    [K in Name]: Entry;
+};
+/** Guard names referenced by a guards option, whichever of its three forms is used. */
+export type LambderGuardNamesIn<TOpt> = TOpt extends string ? TOpt : TOpt extends readonly (infer N extends string)[] ? N : TOpt extends object ? keyof TOpt & string : never;
+/** The endpoint's mode; a contract written without one admits either. */
+export type LambderContractMode<C, K extends keyof C> = C[K] extends {
+    mode: infer M extends LambderApiMode;
+} ? M : LambderApiMode;
+/** The endpoint names of one mode. */
+export type LambderContractKeysWithMode<C, M extends LambderApiMode> = {
+    [K in keyof C]: LambderContractMode<C, K> extends M ? K : never;
+}[keyof C] & string;
+/** The endpoint's guards option as written, or never when it declared none. */
+export type LambderContractGuardsOf<C, K extends keyof C> = C[K] extends {
+    guards: infer G;
+} ? G : never;
+/** Every guard name any endpoint of the contract declares. */
+export type LambderContractGuardNames<C> = {
+    [K in keyof C]: LambderGuardNamesIn<LambderContractGuardsOf<C, K>>;
+}[keyof C] & string;
+/** The endpoint's guardInputs requirement, or never when its guards take no client input. */
+export type LambderContractGuardInputsOf<C, K extends keyof C> = C[K] extends {
+    guardInputs: infer G;
+} ? G : never;
+/** The value guard N takes from the client, as the endpoints declaring it inferred it (a union across them when they differ). */
+export type LambderContractGuardInput<C, N extends string> = {
+    [K in keyof C]: [LambderContractGuardInputsOf<C, K>] extends [never] ? never : (N extends keyof LambderContractGuardInputsOf<C, K> ? LambderContractGuardInputsOf<C, K>[N] : never);
+}[keyof C];
+/**
+ * Guard names any endpoint declares in guardInput mode: the ones whose
+ * value the client sends. (An endpoint without guardInputs contributes
+ * nothing: `keyof never` would be every key, so it is excluded first.)
+ */
+export type LambderContractGuardInputNames<C> = {
+    [K in keyof C]: [LambderContractGuardInputsOf<C, K>] extends [never] ? never : keyof LambderContractGuardInputsOf<C, K> & string;
+}[keyof C];
+/** The endpoint's rateLimit option as written, or never. */
+export type LambderContractRateLimitOf<C, K extends keyof C> = C[K] extends {
+    rateLimit: infer R;
+} ? R : never;
+/** The endpoint's idempotency option as written, or never. */
+export type LambderContractIdempotencyOf<C, K extends keyof C> = C[K] extends {
+    idempotency: infer I;
+} ? I : never;

package/dist/shared/wire/LambderApiOptionValues.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The runtime shapes of the three per-API policy options (guards, rate limit,
+ * idempotency), declared below both the contract that records them and the
+ * engines that enforce them so neither has to import the other.
+ *
+ * A contract type carries these options exactly as an API wrote them, and the
+ * engines in `api/` read the same shapes back. Declaring them here is what
+ * keeps `shared/` at the bottom of the stack: without it the contract would
+ * name an `api/` type and `shared/` would depend on a layer above it.
+ */
+import type { LambderAppRefusalMessage } from "./LambderApiRefusal.js";
+import type { LambderRateLimitPolicy } from "../contracts/LambderRateLimiter.js";
+/** The guards option's runtime shape: a name, ordered names, or a name-to-param map. */
+export type LambderGuardsOptionValue = string | readonly string[] | Readonly<Record<string, unknown>>;
+/**
+ * What an API may override on a policy it references, in the map form of the
+ * rateLimit option. Windows merge over the policy's own (a tighter burst keeps
+ * the policy's daily cap) and are only overridable on "perApi" budgets: a
+ * shared counter has one set of numbers. errorMessage is per-API text, so it
+ * is overridable on either budget.
+ */
+export type LambderRateLimitOverride = LambderRateLimitPolicy & {
+    errorMessage?: LambderAppRefusalMessage;
+};
+/** The rateLimit option's runtime shape: a name, ordered names, or a name-to-override map (LambderRateLimitOption narrows the names and overrides per policy). */
+export type LambderRateLimitOptionValue = string | readonly string[] | Readonly<Record<string, true | LambderRateLimitOverride | undefined>>;
+/** The per-endpoint idempotency declaration: on, or on with its own replay TTL. */
+export type LambderApiIdempotencyOption = boolean | {
+    /** Seconds this API's stored answer replays for; overrides defaultTtlSeconds. */
+    ttlSeconds?: number;
+    /**
+     * Seconds this API's claim stays pending before a retry may take the
+     * scope; overrides defaultPendingTtlSeconds. Raise it on an API whose
+     * handler can run longer than the default, or a retry that arrives after
+     * it expires runs the operation a second time while the original is still
+     * working.
+     */
+    pendingTtlSeconds?: number;
+};

package/dist/shared/wire/LambderApiOptionValues.js

@@ -0,0 +1,11 @@
+/**
+ * The runtime shapes of the three per-API policy options (guards, rate limit,
+ * idempotency), declared below both the contract that records them and the
+ * engines that enforce them so neither has to import the other.
+ *
+ * A contract type carries these options exactly as an API wrote them, and the
+ * engines in `api/` read the same shapes back. Declaring them here is what
+ * keeps `shared/` at the bottom of the stack: without it the contract would
+ * name an `api/` type and `shared/` would depend on a layer above it.
+ */
+export {};

package/dist/shared/wire/LambderApiOutcome.d.ts

@@ -0,0 +1,128 @@
+/**
+ * The one mapping from an HTTP answer to an API outcome.
+ *
+ * LambderCaller (a browser, over fetch) and LambderInvokeCaller (a server,
+ * over a direct Lambda invoke) receive the same envelope and must read it
+ * the same way: which status is a crash, which is a rejected input, in what
+ * order the envelope flags are honoured, what a non-envelope body means.
+ * Both hand their answer to resolveApiOutcome and act on the result; the
+ * side effects each has (handlers, cookie clearing, error reporting) stay
+ * with the caller that owns them. Pure and dependency-free, so the browser
+ * entry resolves it.
+ */
+import type { z } from "zod";
+import type { LambderApiEnvelopeBody } from "./LambderApiContract.js";
+import type { LambderAppRefusalMessage } from "./LambderApiRefusal.js";
+/**
+ * The 422 body's `zodError` as it survives JSON: a ZodError's name and
+ * message, and its issues spelled out. Not a ZodError instance (it has no
+ * methods on this side of the wire), which is why it is not typed as one.
+ */
+export type LambderValidationError = {
+    name: string;
+    message: string;
+    issues: z.core.$ZodIssue[];
+};
+export type LambderApiFailureReason = 'network' | 'timeout' | 'server' | 'validation' | 'versionExpired' | 'sessionExpired' | 'notAuthorized' | 'errorMessage' | 'unknown';
+/** A call that produced an answer the server means as a result. */
+export type LambderApiSuccessOutcome<T> = {
+    ok: true;
+    payload: T | null | undefined;
+    response: LambderApiEnvelopeBody<T>;
+    /** The answer's logList, when it carried one. See LambderApiFailureFields.logList: the field is on every arm so a caller surfaces logs once. */
+    logList?: unknown[];
+};
+/** What every failure carries, whatever went wrong. */
+type LambderApiFailureFields = {
+    ok: false;
+    /** HTTP status, when a response was received. */
+    status?: number;
+    /** Envelope errorMessage, when the server provided one. */
+    errorMessage?: LambderAppRefusalMessage | string;
+    /** Seconds to wait before retrying, from the response's Retry-After header (rate-limit refusals send it). */
+    retryAfterSeconds?: number;
+    /**
+     * The answer's logList, when it carried one: the envelope's on a success
+     * or an envelope refusal, the parsed 500 body's on a server failure, and
+     * the validation body's on a 422 (the server writes it there too). It is
+     * on every arm so that a caller surfaces logs in ONE place, right after
+     * reading the answer, instead of once per outcome it happens to handle:
+     * the browser caller surfaced them after its early returns and so never
+     * printed the logs of the answer whose logs matter most, a 500.
+     */
+    logList?: unknown[];
+};
+/**
+ * No result came back to read: the request never completed, it was given up
+ * on, the server failed, or something inside the caller threw. Always carries
+ * the Error, so a reader that narrowed this far never has to check for it.
+ * A 5xx also carries `response` when the server answered with Lambder's own
+ * envelope, which is how a crash detail and a logList arrive with it.
+ */
+export type LambderApiCallFailure<T> = LambderApiFailureFields & {
+    reason: 'network' | 'timeout' | 'server' | 'unknown';
+    error: Error;
+    response?: LambderApiEnvelopeBody<T>;
+};
+/** HTTP 422: the server rejected the input against the API's schema. Always carries the issues. */
+export type LambderApiValidationFailure = LambderApiFailureFields & {
+    reason: 'validation';
+    zodError: LambderValidationError;
+};
+/** The server answered, and the envelope itself says the call is refused. Always carries that envelope. */
+export type LambderApiEnvelopeFailure<T> = LambderApiFailureFields & {
+    reason: 'versionExpired' | 'sessionExpired' | 'notAuthorized' | 'errorMessage';
+    response: LambderApiEnvelopeBody<T>;
+};
+/**
+ * Discriminated result of an API call: `ok: true` carries the payload, every
+ * failure carries a machine-readable reason, so "the server returned null"
+ * and "the request failed" are never conflated.
+ *
+ * The failure side is discriminated by `reason` rather than being one arm of
+ * optional fields, so narrowing to a reason narrows to what that reason
+ * actually carries: `zodError` after `reason === 'validation'`, `response`
+ * after an envelope reason, `error` after the rest. Read as one wide arm, the
+ * framework's own reader needed three non-null assertions to say what the
+ * union already knew.
+ */
+export type LambderApiOutcome<T> = LambderApiSuccessOutcome<T> | LambderApiCallFailure<T> | LambderApiValidationFailure | LambderApiEnvelopeFailure<T>;
+/**
+ * What reading one HTTP answer can produce. Narrower than LambderApiOutcome
+ * by the three reasons no answer can carry: `network` and `timeout` belong to
+ * the caller's own abort, and `unknown` to something throwing around the
+ * call. So a caller that has handled `server` and `validation` holds a
+ * success or an envelope refusal, both of which carry the envelope.
+ */
+export type LambderApiAnswerOutcome<T> = LambderApiSuccessOutcome<T> | (LambderApiCallFailure<T> & {
+    reason: 'server';
+}) | LambderApiValidationFailure | LambderApiEnvelopeFailure<T>;
+/**
+ * What the mapping needs from an HTTP answer, whichever transport produced it.
+ *
+ * Exactly one of `json()` and `text()` is read per answer, never both: a
+ * transport backed by a real Response body may only be read once, and the
+ * mapping is written to that rule (a 5xx reads text and parses it itself, so
+ * that a non-envelope body is still reportable).
+ */
+export type LambderApiHttpAnswer = {
+    status: number;
+    statusText?: string;
+    /** Case-insensitive header lookup; null or undefined when absent. */
+    header: (name: string) => string | null | undefined;
+    /** The body parsed as JSON; rejects when it is not JSON. */
+    json: () => Promise<unknown>;
+    /** The body as text. */
+    text: () => Promise<string>;
+    /** The answer's Set-Cookie header values, for a transport that can see them (a cookie jar consumes them); absent in a browser. */
+    setCookies?: string[];
+};
+/**
+ * Reads one HTTP answer into an outcome. A 5xx is a server failure that keeps
+ * the envelope when the server sent one (Lambder's own 500 body carries
+ * errorMessage, and a global error handler may add crash and logList); a
+ * 422 is a validation failure only with Lambder's validation body; anything
+ * else must be a JSON envelope, whose flags are honoured in a fixed order.
+ */
+export declare const resolveApiOutcome: <T>(answer: LambderApiHttpAnswer) => Promise<LambderApiAnswerOutcome<T>>;
+export {};

package/dist/shared/{LambderApiOutcome.js → wire/LambderApiOutcome.js}

@@ -36,6 +36,7 @@ export const resolveApiOutcome = async (answer) => {
         return {
             ok: false, reason: 'server', status,
             errorMessage: envelope?.errorMessage,
+            logList: envelope?.logList,
             ...(envelope ? { response: envelope } : {}),
             error: new Error("Request failed: " + status + " - " + (answer.statusText ?? "")),
         };
@@ -43,15 +44,18 @@ export const resolveApiOutcome = async (answer) => {
     if (status === 422) {
         // A 422 without Lambder's validation body (e.g. a proxy's error page)
         // is a server failure, not a validation result.
-        let zodError;
+        // The validation body carries the call's logList as every other
+        // answer does, so it is read here rather than left on the wire.
+        let body;
         try {
-            zodError = (await answer.json())?.zodError;
+            body = await answer.json();
         }
         catch { /* not JSON */ }
+        const zodError = body?.zodError;
         if (zodError === undefined) {
             return { ok: false, reason: 'server', status, error: new Error("Request failed: 422 without a validation body") };
         }
-        return { ok: false, reason: 'validation', status, zodError };
+        return { ok: false, reason: 'validation', status, zodError, logList: body?.logList };
     }
     // Retry-After (delta-seconds) rides every refusal that knows its reset
     // time, e.g. a rate limit; absent or unreadable is undefined.
@@ -68,12 +72,15 @@ export const resolveApiOutcome = async (answer) => {
         return { ok: false, reason: 'server', status, error: new Error("Request failed: response is not a valid API envelope (status " + status + ")", { cause: err }) };
     }
     if (data.versionExpired)
-        return { ok: false, reason: 'versionExpired', status, errorMessage: data.errorMessage, response: data, ...retryAfter };
+        return { ok: false, reason: 'versionExpired', status, errorMessage: data.errorMessage, response: data, logList: data.logList, ...retryAfter };
     if (data.sessionExpired)
-        return { ok: false, reason: 'sessionExpired', status, errorMessage: data.errorMessage, response: data, ...retryAfter };
+        return { ok: false, reason: 'sessionExpired', status, errorMessage: data.errorMessage, response: data, logList: data.logList, ...retryAfter };
     if (data.notAuthorized)
-        return { ok: false, reason: 'notAuthorized', status, errorMessage: data.errorMessage, response: data, ...retryAfter };
-    if (data.errorMessage)
-        return { ok: false, reason: 'errorMessage', status, errorMessage: data.errorMessage, response: data, ...retryAfter };
-    return { ok: true, payload: data.payload, response: data };
+        return { ok: false, reason: 'notAuthorized', status, errorMessage: data.errorMessage, response: data, logList: data.logList, ...retryAfter };
+    // Presence, not truthiness: the writer keeps an errorMessage an app spelled
+    // out as the empty string, so a refusal that says nothing is still a
+    // refusal. Tested for truth here, it shipped back as a success.
+    if (data.errorMessage !== undefined)
+        return { ok: false, reason: 'errorMessage', status, errorMessage: data.errorMessage, response: data, logList: data.logList, ...retryAfter };
+    return { ok: true, payload: data.payload, response: data, logList: data.logList };
 };