lambder 4.0.1 → 4.2.1

package/dist/policies/LambderApiRateLimits.d.ts

@@ -1,15 +1,18 @@
 import type { z } from "zod";
 import type { LambderRenderContext } from "../core/LambderContext.js";
 import type LambderResolver from "../core/LambderResolver.js";
-import type { LambderRateLimitPolicy, LambderDdbRateLimiter } from "../stores/LambderDdbRateLimiter.js";
+import { type LambderRateLimitPolicy, type LambderDdbRateLimiter } from "../stores/LambderDdbRateLimiter.js";
+import { type LambderRefusalMessage } from "../shared/LambderApiError.js";
+import { type LambderInputValidationRefusal } from "./LambderApiGuards.js";
 /**
  * A custom rate-limit key. `apiInput` names the fields of the API's OWN
  * payload the key derives from: the slice is validated against the raw
- * payload before `handler` runs (failures answer the standard 422 validation
- * shape) and the handler receives it typed. Referencing the policy from an
- * API whose input schema does not carry those fields is a compile error, so
- * the API's schema stays the single owner of the field. Build with
- * lambderRateLimitKey() so the handler's payload type follows `apiInput`.
+ * payload before `handler` runs (failures answer like regular input
+ * validation, through setApiInputValidationErrorHandler when set) and the
+ * handler receives it typed. Referencing the policy from an API whose input
+ * schema does not carry those fields is a compile error, so the API's schema
+ * stays the single owner of the field. Build with lambderRateLimitKey() so
+ * the handler's payload type follows `apiInput`.
  */
 export type LambderRateLimitKeyFn<TInput extends z.ZodTypeAny = z.ZodTypeAny> = {
     apiInput: TInput;
@@ -38,19 +41,27 @@ export declare function lambderRateLimitKey(key: {
 };
 /** What one rate-limit counter tracks: the client IP, the session identity, or a custom payload-derived key. */
 export type LambderRateLimitPer = "ip" | "session" | LambderRateLimitKeyFn<any>;
-/** A named rate-limit policy: fixed windows plus the key one counter tracks. */
+/**
+ * What one budget spans. Required on every policy, so a declaration always
+ * says what its numbers mean:
+ *
+ * - "perApi": every API referencing the policy gets its own counter, so the
+ *   windows are a per-API ceiling (three APIs referencing a 60/min policy
+ *   allow one subject 180/min in total). An API may tune the windows in its
+ *   declaration: `rateLimit: { name: { perMin: 20 } }`.
+ * - "perPolicy": every API referencing the policy shares ONE counter, so the
+ *   windows are one combined budget (e.g. one per-email allowance across
+ *   send, register, and reset). The policy IS the group: to give user APIs
+ *   and report APIs separate shared budgets, declare two policies.
+ */
+export type LambderRateLimitBudget = "perApi" | "perPolicy";
+/** A named rate-limit policy: fixed windows, the key one counter tracks, and what one budget spans. */
 export type LambderApiRateLimitPolicyConfig = LambderRateLimitPolicy & {
     per: LambderRateLimitPer;
-    /**
-     * What one counter spans. "api" (default): each API referencing the
-     * policy gets its own counter, so the windows are a per-API budget.
-     * "policy": every API referencing the policy shares one counter, so the
-     * windows are one combined budget (e.g. one per-email allowance across
-     * send, register, and reset endpoints).
-     */
-    scope?: "api" | "policy";
-    /** Envelope errorMessage for refused requests. Default: a generic too-many-requests message. */
-    errorMessage?: any;
+    /** Whether the windows are a per-API ceiling or one budget shared by every referencing API. See LambderRateLimitBudget. */
+    budget: LambderRateLimitBudget;
+    /** Envelope errorMessage for refused requests. Default: a warning saying too many requests. */
+    errorMessage?: LambderRefusalMessage;
 };
 export type LambderApiRateLimitsConfig<TPolicies extends Record<string, LambderApiRateLimitPolicyConfig>> = {
     /** Your limiter instance; its table, keyPrefix and failOpen apply as configured on it. */
@@ -72,6 +83,29 @@ export type LambderAllowedPolicyNames<TPolicies, TPayload, TIncludeSession exten
         };
     } ? (TPayload extends z.output<S> ? K : never) : K;
 }[keyof TPolicies] & string;
+/**
+ * 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?: LambderRefusalMessage;
+};
+type LambderRateLimitOverrideFor<TPolicy> = TPolicy extends {
+    budget: "perApi";
+} ? LambderRateLimitOverride : Pick<LambderRateLimitOverride, "errorMessage">;
+/**
+ * The per-API `rateLimit` option: one policy name, an ordered list of names,
+ * or an object map that can carry each policy's override (`true` applies the
+ * policy as declared). Map entries are checked in insertion order.
+ */
+export type LambderRateLimitOption<TPolicies, TPayload, TIncludeSession extends boolean> = LambderAllowedPolicyNames<TPolicies, TPayload, TIncludeSession> | readonly LambderAllowedPolicyNames<TPolicies, TPayload, TIncludeSession>[] | {
+    readonly [K in LambderAllowedPolicyNames<TPolicies, TPayload, TIncludeSession> & keyof TPolicies]?: true | LambderRateLimitOverrideFor<TPolicies[K]>;
+};
+/** 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>>;
 /**
  * Runtime side of the rate-limit subsystem: holds the limiter and its named
  * policies, asserts API registrations against them at startup, and checks an
@@ -79,12 +113,21 @@ export type LambderAllowedPolicyNames<TPolicies, TPayload, TIncludeSession exten
  * LambderApiPolicyEngine.
  */
 export declare class LambderApiRateLimitsEngine {
+    private readonly onInvalidInput;
     private limiter;
     private policies;
+    constructor(onInvalidInput: LambderInputValidationRefusal);
     configure(config: LambderApiRateLimitsConfig<Record<string, LambderApiRateLimitPolicyConfig>>): void;
     /** Startup validation of one API registration's rateLimit option. */
-    assertRegistration(apiName: string, mode: "public" | "session", rateLimitOption?: string | readonly string[]): void;
-    /** Check the API's policies in declared order; the first exceeded one refuses with a 429 envelope. */
-    run(apiName: string, ctx: LambderRenderContext, resolver: LambderResolver, rateLimitOption?: string | readonly string[]): Promise<void>;
+    assertRegistration(apiName: string, mode: "public" | "session", rateLimitOption?: LambderRateLimitOptionValue): void;
+    /**
+     * Check the API's policies in declared order; the first exceeded one
+     * refuses with a 429 envelope and a Retry-After header. Attempts count,
+     * not successes: every counter checked before the refusing one (and every
+     * counter, when a later guard or validation refuses) keeps its increment,
+     * so list first the policy you want charged on refusals.
+     */
+    run(apiName: string, ctx: LambderRenderContext, resolver: LambderResolver, rateLimitOption?: LambderRateLimitOptionValue): Promise<void>;
     private resolveKey;
 }
+export {};

package/dist/policies/LambderApiRateLimits.js

@@ -1,8 +1,21 @@
+import { RATE_LIMIT_WINDOWS } from "../stores/LambderDdbRateLimiter.js";
 import { LambderApiError } from "../shared/LambderApiError.js";
 import { parsePreflightSlice } from "./LambderApiGuards.js";
-const RATE_LIMIT_WINDOW_KEYS = ["perMin", "per10Min", "perHour", "perDay", "perWeek", "perMonth"];
+const RATE_LIMIT_WINDOW_KEYS = RATE_LIMIT_WINDOWS.map((window) => window.key);
+/** Refusal a rate-limited request answers unless the policy or the API's override names its own. */
+const DEFAULT_RATE_LIMIT_REFUSAL = { type: "warning", content: "Too many requests. Please try again later." };
 export function lambderRateLimitKey(key) { return key; }
-const toList = (value) => value === undefined ? [] : typeof value === "string" ? [value] : value;
+/** Normalize the three rateLimit-option forms into ordered entries; an explicit `undefined` map value declares nothing. */
+const toRateLimitEntries = (value) => {
+    if (value === undefined)
+        return [];
+    if (typeof value === "string")
+        return [{ name: value }];
+    if (Array.isArray(value))
+        return value.map((name) => ({ name }));
+    return Object.entries(value).flatMap(([name, override]) => override === undefined ? [] : override === true ? [{ name }] : [{ name, override }]);
+};
+const hasWindowOverride = (override) => RATE_LIMIT_WINDOW_KEYS.some((key) => override[key] !== undefined);
 /**
  * Runtime side of the rate-limit subsystem: holds the limiter and its named
  * policies, asserts API registrations against them at startup, and checks an
@@ -10,11 +23,15 @@ const toList = (value) => value === undefined ? [] : typeof value === "string" ?
  * LambderApiPolicyEngine.
  */
 export class LambderApiRateLimitsEngine {
+    onInvalidInput;
     limiter = null;
     policies = {};
+    constructor(onInvalidInput) {
+        this.onInvalidInput = onInvalidInput;
+    }
     configure(config) {
         if (this.limiter)
-            throw new Error("Lambder: enableApiRateLimits() was already called.");
+            throw new Error("Lambder: rateLimits were already configured.");
         for (const [name, policy] of Object.entries(config.policies)) {
             const per = policy.per;
             if (!per || (per !== "ip" && per !== "session" && typeof per.handler !== "function")) {
@@ -23,39 +40,61 @@ export class LambderApiRateLimitsEngine {
             if (!RATE_LIMIT_WINDOW_KEYS.some((key) => policy[key])) {
                 throw new Error(`Lambder: rate-limit policy "${name}" declares no window (${RATE_LIMIT_WINDOW_KEYS.join("/")}).`);
             }
+            const budget = policy.budget;
+            if (budget !== "perApi" && budget !== "perPolicy") {
+                throw new Error(`Lambder: rate-limit policy "${name}" needs budget: "perApi" (each referencing API counts separately) or "perPolicy" (one counter shared by every referencing API).`);
+            }
         }
         this.limiter = config.limiter;
         this.policies = { ...config.policies };
     }
     /** Startup validation of one API registration's rateLimit option. */
     assertRegistration(apiName, mode, rateLimitOption) {
-        for (const name of toList(rateLimitOption)) {
+        for (const { name, override } of toRateLimitEntries(rateLimitOption)) {
             const policy = this.policies[name];
             if (!policy) {
-                throw new Error(`Lambder: API "${apiName}" references unknown rate-limit policy "${name}". Declare it via enableApiRateLimits() before registering the API.`);
+                throw new Error(`Lambder: API "${apiName}" references unknown rate-limit policy "${name}". Declare it in the rateLimits option at creation.`);
             }
             if (policy.per === "session" && mode !== "session") {
                 throw new Error(`Lambder: API "${apiName}" uses rate-limit policy "${name}" (per "session"), which requires addSessionApi.`);
             }
+            if (override && policy.budget === "perPolicy" && hasWindowOverride(override)) {
+                throw new Error(`Lambder: API "${apiName}" overrides the windows of rate-limit policy "${name}", whose budget is "perPolicy": one counter shared by every referencing API has one set of limits. Declare a separate policy instead.`);
+            }
         }
     }
-    /** Check the API's policies in declared order; the first exceeded one refuses with a 429 envelope. */
+    /**
+     * Check the API's policies in declared order; the first exceeded one
+     * refuses with a 429 envelope and a Retry-After header. Attempts count,
+     * not successes: every counter checked before the refusing one (and every
+     * counter, when a later guard or validation refuses) keeps its increment,
+     * so list first the policy you want charged on refusals.
+     */
     async run(apiName, ctx, resolver, rateLimitOption) {
-        for (const name of toList(rateLimitOption)) {
+        for (const { name, override } of toRateLimitEntries(rateLimitOption)) {
             const policy = this.policies[name];
             if (!policy || !this.limiter)
                 throw new Error(`Lambder: rate-limit policy "${name}" is not configured.`);
             const key = await this.resolveKey(ctx, resolver, policy.per);
-            // scope "policy" shares one counter across every API referencing
-            // the policy; the default gives each API its own budget.
-            const trackerKey = policy.scope === "policy"
+            // "perPolicy" shares one counter across every API referencing the
+            // policy; "perApi" keys each API separately, which is also what
+            // lets an API override the windows without colliding.
+            const trackerKey = policy.budget === "perPolicy"
                 ? `policy|${name}|${key}`
                 : `api|${apiName}|${name}|${key}`;
-            const limited = await this.limiter.isRateLimited(trackerKey, policy);
-            if (limited) {
-                throw new LambderApiError(`Rate limited: "${apiName}" exceeded policy "${name}".`, {
-                    errorMessage: policy.errorMessage ?? "Too many requests. Please try again later.",
+            const limits = {};
+            for (const windowKey of RATE_LIMIT_WINDOW_KEYS) {
+                const limit = override?.[windowKey] ?? policy[windowKey];
+                if (limit !== undefined)
+                    limits[windowKey] = limit;
+            }
+            const exceeded = await this.limiter.isRateLimited(trackerKey, limits);
+            if (exceeded) {
+                const retryAfterSeconds = Math.max(1, exceeded.resetAt - Math.floor(Date.now() / 1000));
+                throw new LambderApiError(`Rate limited: "${apiName}" exceeded policy "${name}" (${exceeded.window}: ${exceeded.limit}).`, {
+                    errorMessage: override?.errorMessage ?? policy.errorMessage ?? DEFAULT_RATE_LIMIT_REFUSAL,
                     statusCode: 429,
+                    headers: { "Retry-After": String(retryAfterSeconds) },
                 });
             }
         }
@@ -70,7 +109,7 @@ export class LambderApiRateLimitsEngine {
             return `session:${sessionKey}`;
         }
         const payload = per.apiInput
-            ? parsePreflightSlice(per.apiInput, ctx.post?.payload, resolver)
+            ? await parsePreflightSlice(per.apiInput, ctx.post?.payload, ctx, resolver, this.onInvalidInput)
             : undefined;
         return `custom:${await per.handler(ctx, payload)}`;
     }

package/dist/session/LambderSessionController.d.ts

@@ -37,7 +37,7 @@ export default class LambderSessionController<TSessionData = any> {
     isSessionValid(session: any): boolean;
     updateSessionData(newData: any): Promise<LambderSessionContext>;
     /**
-     * Force-runs the dataRefresh callback now (see enableDdbSession) and
+     * Force-runs the dataRefresh callback now (see the session option of create) and
      * persists the result onto the current session. Returns the updated
      * session, or null when the callback ended it: the record is deleted and
      * the session cookies are cleared.

package/dist/session/LambderSessionController.js

@@ -124,7 +124,7 @@ export default class LambderSessionController {
     }
     ;
     /**
-     * Force-runs the dataRefresh callback now (see enableDdbSession) and
+     * Force-runs the dataRefresh callback now (see the session option of create) and
      * persists the result onto the current session. Returns the updated
      * session, or null when the callback ended it: the record is deleted and
      * the session cookies are cleared.

package/dist/session/LambderSessionManager.js

@@ -230,7 +230,7 @@ export default class LambderSessionManager {
      */
     async refreshSessionData(session) {
         if (!this.dataRefresh)
-            throw new Error("dataRefresh is not configured. Pass dataRefresh to enableDdbSession(...) to enable.");
+            throw new Error("dataRefresh is not configured. Pass session.dataRefresh at creation to enable.");
         if (!session)
             throw new Error("Invalid session");
         let newData;

package/dist/shared/LambderApiError.d.ts

@@ -18,6 +18,8 @@ export type LambderApiErrorOptions = {
      * 422 (reserved for input validation).
      */
     statusCode?: HttpStatusCode;
+    /** Extra response headers on the refusal (e.g. Retry-After on a rate limit). */
+    headers?: Record<string, string>;
     /** Underlying cause, preserved on the standard Error `cause` property. */
     cause?: unknown;
 };
@@ -48,6 +50,7 @@ export declare class LambderApiError extends Error {
     readonly notAuthorized?: boolean;
     readonly sessionExpired?: boolean;
     readonly statusCode?: HttpStatusCode;
+    readonly headers?: Record<string, string>;
     constructor(message: string, options?: LambderApiErrorOptions);
 }
 /** Brand-based type guard (see LambderApiError.isLambderApiError). */
@@ -73,6 +76,8 @@ export type LambderRefuseOptions = {
     sessionExpired?: boolean;
     /** HTTP status of the refusal. Default 200; avoid 5xx (caller treats as crash) and 422 (reserved for validation). */
     statusCode?: HttpStatusCode;
+    /** Extra response headers on the refusal (e.g. Retry-After). */
+    headers?: Record<string, string>;
     /** Underlying cause, preserved on the Error cause property. */
     cause?: unknown;
 };

package/dist/shared/LambderApiError.js

@@ -25,6 +25,7 @@ export class LambderApiError extends Error {
     notAuthorized;
     sessionExpired;
     statusCode;
+    headers;
     constructor(message, options = {}) {
         super(message, options.cause !== undefined ? { cause: options.cause } : undefined);
         this.name = "LambderApiError";
@@ -32,6 +33,7 @@ export class LambderApiError extends Error {
         this.notAuthorized = options.notAuthorized;
         this.sessionExpired = options.sessionExpired;
         this.statusCode = options.statusCode;
+        this.headers = options.headers;
     }
 }
 /** Brand-based type guard (see LambderApiError.isLambderApiError). */
@@ -58,6 +60,7 @@ export const refuse = (content, options = {}) => {
         notAuthorized: options.notAuthorized,
         sessionExpired: options.sessionExpired,
         statusCode: options.statusCode,
+        headers: options.headers,
         cause: options.cause,
     });
 };

package/dist/stores/LambderDdbRateLimiter.d.ts

@@ -1,15 +1,42 @@
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
-export interface LambderRateLimitPolicy {
-    perMin?: number;
-    per10Min?: number;
-    perHour?: number;
-    perDay?: number;
-    perWeek?: number;
-    perMonth?: number;
-}
-export type LambderRateLimitExceededMap = Partial<Record<keyof LambderRateLimitPolicy, number>>;
-/** `false` when allowed, otherwise the window(s) whose limit was hit. */
-export type LambderRateLimitResult = false | LambderRateLimitExceededMap;
+/**
+ * The fixed windows a policy may cap, smallest first (the evaluation order),
+ * with their length. The policy type derives from this table, so the two can
+ * never drift.
+ */
+export declare const RATE_LIMIT_WINDOWS: readonly [{
+    readonly key: "perMin";
+    readonly seconds: 60;
+}, {
+    readonly key: "per10Min";
+    readonly seconds: number;
+}, {
+    readonly key: "perHour";
+    readonly seconds: number;
+}, {
+    readonly key: "perDay";
+    readonly seconds: number;
+}, {
+    readonly key: "perWeek";
+    readonly seconds: number;
+}, {
+    readonly key: "perMonth";
+    readonly seconds: number;
+}];
+export type LambderRateLimitWindow = (typeof RATE_LIMIT_WINDOWS)[number]["key"];
+/** Per-window caps. A window that is absent or 0 is not enforced. */
+export type LambderRateLimitPolicy = Partial<Record<LambderRateLimitWindow, number>>;
+/**
+ * The window that refused: which one, its limit, and the epoch second at
+ * which that fixed window resets (Retry-After derives from it).
+ */
+export type LambderRateLimitExceeded = {
+    window: LambderRateLimitWindow;
+    limit: number;
+    resetAt: number;
+};
+/** `false` when allowed, otherwise the window whose limit was hit. */
+export type LambderRateLimitResult = false | LambderRateLimitExceeded;
 export interface LambderDdbRateLimiterOptions {
     tableName: string;
     region?: string;
@@ -27,8 +54,11 @@ export interface LambderDdbRateLimiterOptions {
  * Each window is a single item counted with a conditional `ADD`, so the
  * increment and the limit check happen atomically in one request. Windows are
  * evaluated from smallest to largest and evaluation stops at the first
- * exceeded window, which keeps blocked requests cheap and avoids inflating the
- * larger counters. Items carry an `expiresAt` attribute for DynamoDB TTL.
+ * exceeded window, which keeps blocked requests cheap and spares the larger
+ * counters. Attempts count, not successes: a counter checked before the
+ * refusing one keeps its increment (there is no compensating decrement, which
+ * would give up the conditional-ADD atomicity). Items carry an `expiresAt`
+ * attribute for DynamoDB TTL.
  *
  * Table shape: string hash key `pk`, string range key `sk`, TTL on `expiresAt`.
  * Items are prefixed `RL#` by default, so the table can be shared with
@@ -44,7 +74,8 @@ export declare class LambderDdbRateLimiter {
     constructor(options: LambderDdbRateLimiterOptions);
     /**
      * Increment every configured window for `trackerKey` (IP, session, user id, ...)
-     * and report whether any of them is over its limit.
+     * and report whether any of them is over its limit, with the window's
+     * reset time when so.
      */
     isRateLimited(trackerKey: string, policy: LambderRateLimitPolicy): Promise<LambderRateLimitResult>;
     /** Increments one window counter. Returns true when the limit was already reached. */

package/dist/stores/LambderDdbRateLimiter.js

@@ -1,5 +1,10 @@
 import { DynamoDBClient, UpdateItemCommand, } from "@aws-sdk/client-dynamodb";
-const WINDOW_CONFIG = [
+/**
+ * The fixed windows a policy may cap, smallest first (the evaluation order),
+ * with their length. The policy type derives from this table, so the two can
+ * never drift.
+ */
+export const RATE_LIMIT_WINDOWS = [
     { key: "perMin", seconds: 60 },
     { key: "per10Min", seconds: 10 * 60 },
     { key: "perHour", seconds: 60 * 60 },
@@ -13,8 +18,11 @@ const WINDOW_CONFIG = [
  * Each window is a single item counted with a conditional `ADD`, so the
  * increment and the limit check happen atomically in one request. Windows are
  * evaluated from smallest to largest and evaluation stops at the first
- * exceeded window, which keeps blocked requests cheap and avoids inflating the
- * larger counters. Items carry an `expiresAt` attribute for DynamoDB TTL.
+ * exceeded window, which keeps blocked requests cheap and spares the larger
+ * counters. Attempts count, not successes: a counter checked before the
+ * refusing one keeps its increment (there is no compensating decrement, which
+ * would give up the conditional-ADD atomicity). Items carry an `expiresAt`
+ * attribute for DynamoDB TTL.
  *
  * Table shape: string hash key `pk`, string range key `sk`, TTL on `expiresAt`.
  * Items are prefixed `RL#` by default, so the table can be shared with
@@ -41,23 +49,24 @@ export class LambderDdbRateLimiter {
     }
     /**
      * Increment every configured window for `trackerKey` (IP, session, user id, ...)
-     * and report whether any of them is over its limit.
+     * and report whether any of them is over its limit, with the window's
+     * reset time when so.
      */
     async isRateLimited(trackerKey, policy) {
-        for (const { key, seconds } of WINDOW_CONFIG) {
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        for (const { key, seconds } of RATE_LIMIT_WINDOWS) {
             const limit = policy[key];
             if (!limit)
                 continue;
-            const exceeded = await this.incrementWindow(trackerKey, key, seconds, limit);
+            const windowStart = Math.floor(nowSeconds / seconds) * seconds;
+            const exceeded = await this.incrementWindow(trackerKey, key, windowStart, seconds, limit, nowSeconds);
             if (exceeded)
-                return { [key]: limit };
+                return { window: key, limit, resetAt: windowStart + seconds };
         }
         return false;
     }
     /** Increments one window counter. Returns true when the limit was already reached. */
-    async incrementWindow(trackerKey, sortKeyPrefix, windowSeconds, limit) {
-        const nowSeconds = Math.floor(Date.now() / 1000);
-        const windowStart = Math.floor(nowSeconds / windowSeconds) * windowSeconds;
+    async incrementWindow(trackerKey, sortKeyPrefix, windowStart, windowSeconds, limit, nowSeconds) {
         const expiresAt = nowSeconds + Math.ceil(windowSeconds * this.ttlWindowMultiplier);
         const input = {
             TableName: this.tableName,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lambder",
-  "version": "4.0.1",
+  "version": "4.2.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",