@bondedhq/sdk 0.0.0-stage → 0.1.1

package/dist/actions.js

@@ -0,0 +1,115 @@
+import { demoRouterAbi } from "@bondedhq/shared";
+import { encodeFunctionData, erc20Abi, formatUnits, getAddress, isAddress, isHex, } from "viem";
+import { BondedError } from "./errors.js";
+/**
+ * Bonded's testnet market (`DemoRouter`: oracle prices minus a fee). Its `swap` has no minimum
+ * output, so `minOut` is checked against its quote before sending.
+ */
+export function demoRouter(address) {
+    const router = getAddress(address);
+    return {
+        address: router,
+        encodeSwap: (p) => encodeFunctionData({
+            abi: demoRouterAbi,
+            functionName: "swap",
+            args: [p.tokenIn, p.tokenOut, p.amountIn, p.recipient],
+        }),
+        quote: (client, p) => client.readContract({
+            address: router,
+            abi: demoRouterAbi,
+            functionName: "quote",
+            args: [p.tokenIn, p.tokenOut, p.amountIn],
+        }),
+    };
+}
+/** Checks an action's fields and normalises its addresses, with errors that name the field. */
+export function normaliseAction(action) {
+    const address = (field, value) => {
+        if (typeof value !== "string" || !isAddress(value, { strict: false }))
+            throw new BondedError("INVALID_ACTION", `${action.type}: ${field} must be an address`);
+        return getAddress(value);
+    };
+    const amount = (field, value) => {
+        if (typeof value !== "bigint" || value < 0n)
+            throw new BondedError("INVALID_ACTION", `${action.type}: ${field} must be a non-negative bigint in the token's base units`);
+        return value;
+    };
+    switch (action.type) {
+        case "swap":
+            return {
+                type: "swap",
+                tokenIn: address("tokenIn", action.tokenIn),
+                tokenOut: address("tokenOut", action.tokenOut),
+                amountIn: amount("amountIn", action.amountIn),
+                ...(action.minOut !== undefined ? { minOut: amount("minOut", action.minOut) } : {}),
+            };
+        case "transfer":
+            return {
+                type: "transfer",
+                token: address("token", action.token),
+                to: address("to", action.to),
+                amount: amount("amount", action.amount),
+            };
+        case "approve":
+            return {
+                type: "approve",
+                token: address("token", action.token),
+                spender: address("spender", action.spender),
+                amount: amount("amount", action.amount),
+            };
+        case "call":
+            if (!isHex(action.data))
+                throw new BondedError("INVALID_ACTION", "call: data must be 0x-prefixed hex");
+            return { type: "call", target: address("target", action.target), data: action.data };
+        default:
+            throw new BondedError("INVALID_ACTION", `unknown action type ${action.type}`);
+    }
+}
+/** ERC-20 calldata for a transfer or approval. */
+export function erc20Call(fn, token, who, amount) {
+    return {
+        target: token,
+        data: encodeFunctionData({ abi: erc20Abi, functionName: fn, args: [who, amount] }),
+    };
+}
+/** An action in the words Sentinel was trained on: a tool name and string arguments. */
+export function describeAction(action, tokens = []) {
+    const token = (a) => tokens.find((t) => t.address.toLowerCase() === a.toLowerCase());
+    const symbol = (a) => token(a)?.symbol ?? a;
+    const units = (a, value) => {
+        const t = token(a);
+        return t ? formatUnits(value, t.decimals) : value.toString();
+    };
+    switch (action.type) {
+        case "swap":
+            return {
+                tool: "swap",
+                args: {
+                    tokenIn: symbol(action.tokenIn),
+                    tokenOut: symbol(action.tokenOut),
+                    amountIn: units(action.tokenIn, action.amountIn),
+                },
+            };
+        case "transfer":
+            return {
+                tool: "transfer",
+                args: {
+                    token: symbol(action.token),
+                    to: action.to,
+                    amount: units(action.token, action.amount),
+                },
+            };
+        case "approve":
+            return {
+                tool: "approve",
+                args: {
+                    token: symbol(action.token),
+                    spender: action.spender,
+                    amount: units(action.token, action.amount),
+                },
+            };
+        case "call":
+            return { tool: "call", args: { target: action.target, data: action.data.slice(0, 2_000) } };
+    }
+}
+//# sourceMappingURL=actions.js.map

package/dist/agent-url.d.ts

@@ -0,0 +1,101 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { BondedEpisode } from "./episode.js";
+import type { EpisodeUsage } from "./mcp.js";
+/** For your own handler: the proof a verify answer carries, and the whole answer. */
+export { agentUrlVerifyProof, answerAgentUrlVerify } from "@bondedhq/shared/agent-url";
+export { SIGNATURE_HEADER, SIGNATURE_TOLERANCE_SECONDS, signBondedRequest, type SignatureCheck, TIMESTAMP_HEADER, verifyBondedSignature, } from "./signature.js";
+/**
+ * Agent URL mode: instead of running the Bonded runner, an agent serves one HTTPS endpoint and
+ * Bonded calls it once per episode. Every call is a signed `POST` of one JSON message:
+ *
+ * - `{ type: "verify", challenge }` when the URL is registered: answer
+ *   `200 { challenge, proof, version? }`, where `proof` is the hex HMAC-SHA256 of
+ *   `"verify." + challenge` under the secret.
+ * - `{ type: "episode", ... }` (the runner protocol's `EpisodeMessage`): answer `2xx` within
+ *   10 seconds, then work: call the episode's tools and `POST {done}` when finished.
+ * - `{ type: "cancel", episodeId }`: stop that episode (best effort).
+ *
+ * `createBondedHandler` does all of that: it checks signatures, answers challenges, acknowledges an
+ * episode at once and runs your `onEpisode` in the background, aborts it on cancel or at the
+ * deadline, and posts `/done` (with the usage you return) when it resolves.
+ */
+/** What `onEpisode` may return: posted to the episode's `/done`. */
+export interface EpisodeOutcome {
+    finalMessage?: string;
+    /** Your model's usage for the episode; Bonded uses it to estimate a full rating's cost. */
+    usage?: EpisodeUsage;
+}
+export interface EpisodeContext {
+    /**
+     * Aborted when Bonded cancels the episode or its deadline passes. Stop then: the episode is
+     * over and its endpoints refuse further calls. Pass it to your model and HTTP calls.
+     */
+    signal: AbortSignal;
+}
+export interface BondedHandlerOptions {
+    /**
+     * The agent secret Bonded showed you when you registered the URL (`bonded_as_...`), or several
+     * while you rotate it (any one may match).
+     */
+    secret: string | string[];
+    /** Runs one episode. Resolve when the agent is finished; the handler then posts `/done`. */
+    onEpisode(episode: BondedEpisode, context: EpisodeContext): Promise<EpisodeOutcome | void> | EpisodeOutcome | void;
+    /**
+     * Your agent's version (a release tag, a git commit). Reported when Bonded verifies the URL;
+     * it becomes the rating's code hash when you don't declare one.
+     */
+    version?: string;
+    /** Called when `onEpisode` throws (default: `console.error`). `/done` is still posted. */
+    onError?: (error: unknown, episode: BondedEpisode) => void;
+    /**
+     * Keeps the background work alive on platforms that stop at the response (Cloudflare's
+     * `ctx.waitUntil`, Vercel's `waitUntil`, Next.js `after`). The handler's second argument wins.
+     */
+    waitUntil?: (work: Promise<unknown>) => void;
+    /** How far a request's timestamp may be from this server's clock. Default 300 seconds. */
+    toleranceSeconds?: number;
+    /** Largest request body accepted. Default 256 KiB (the most Bonded sends). */
+    maxBodyBytes?: number;
+    /** Most episodes run at once (Bonded sends one at a time per agent). Default 8. */
+    maxConcurrent?: number;
+    /** For tests: the clock, in milliseconds. */
+    now?: () => number;
+    /** For tests: the `fetch` used to post `/done`. */
+    fetch?: typeof fetch;
+}
+/** A standard Fetch API handler: Hono, Next.js route handlers, Bun, Deno, Cloudflare Workers. */
+export type BondedHandler = (request: Request, context?: {
+    waitUntil?: (work: Promise<unknown>) => void;
+}) => Promise<Response>;
+/**
+ * An Agent URL endpoint for your agent.
+ *
+ * ```ts
+ * const handler = createBondedHandler({
+ *   secret: process.env.BONDED_AGENT_SECRET!,
+ *   version: process.env.GIT_SHA,
+ *   async onEpisode(episode, { signal }) {
+ *     const tools = await bondedAiSdkTools(episode);
+ *     const { usage } = await generateText({ model, tools, prompt: episode.task.goal, abortSignal: signal });
+ *     return { usage: { inputTokens: usage.inputTokens ?? 0, outputTokens: usage.outputTokens ?? 0 } };
+ *   },
+ * });
+ * export const POST = handler; // Next.js; or app.post("/bonded", (c) => handler(c.req.raw)) in Hono
+ * ```
+ */
+export declare function createBondedHandler(options: BondedHandlerOptions): BondedHandler;
+/**
+ * The handler as a Node `http` / Express / Fastify-style listener:
+ *
+ * ```ts
+ * app.post("/bonded", toNodeHandler(handler)); // Express: mount it before express.json()
+ * http.createServer(toNodeHandler(handler)).listen(8080);
+ * ```
+ *
+ * The signature covers the raw body, so the body must reach it unparsed: either nothing has read
+ * the stream yet, or `req.body` is the raw `Buffer` or string (`express.raw()`/`express.text()`).
+ */
+export declare function toNodeHandler(handler: BondedHandler): (req: IncomingMessage & {
+    body?: unknown;
+}, res: ServerResponse) => Promise<void>;
+//# sourceMappingURL=agent-url.d.ts.map

package/dist/agent-url.js

@@ -0,0 +1,234 @@
+import { AGENT_URL_MAX_BODY_BYTES, AGENT_URL_TOLERANCE_SECONDS, AgentUrlReplayGuard, answerAgentUrlVerify, verifyAgentUrlRequest, } from "@bondedhq/shared/agent-url";
+import { finishEpisode } from "./done.js";
+/** For your own handler: the proof a verify answer carries, and the whole answer. */
+export { agentUrlVerifyProof, answerAgentUrlVerify } from "@bondedhq/shared/agent-url";
+export { SIGNATURE_HEADER, SIGNATURE_TOLERANCE_SECONDS, signBondedRequest, TIMESTAMP_HEADER, verifyBondedSignature, } from "./signature.js";
+/**
+ * An Agent URL endpoint for your agent.
+ *
+ * ```ts
+ * const handler = createBondedHandler({
+ *   secret: process.env.BONDED_AGENT_SECRET!,
+ *   version: process.env.GIT_SHA,
+ *   async onEpisode(episode, { signal }) {
+ *     const tools = await bondedAiSdkTools(episode);
+ *     const { usage } = await generateText({ model, tools, prompt: episode.task.goal, abortSignal: signal });
+ *     return { usage: { inputTokens: usage.inputTokens ?? 0, outputTokens: usage.outputTokens ?? 0 } };
+ *   },
+ * });
+ * export const POST = handler; // Next.js; or app.post("/bonded", (c) => handler(c.req.raw)) in Hono
+ * ```
+ */
+export function createBondedHandler(options) {
+    if (!options.secret || (Array.isArray(options.secret) && options.secret.length === 0))
+        throw new Error("createBondedHandler needs the agent secret");
+    const now = options.now ?? Date.now;
+    const tolerance = options.toleranceSeconds ?? AGENT_URL_TOLERANCE_SECONDS;
+    const maxBody = options.maxBodyBytes ?? AGENT_URL_MAX_BODY_BYTES;
+    const maxConcurrent = options.maxConcurrent ?? 8;
+    const onError = options.onError ??
+        ((error, episode) => console.error(`Bonded episode ${episode.episodeId} failed:`, error));
+    const secrets = Array.isArray(options.secret) ? options.secret : [options.secret];
+    /** Signatures already accepted, until they fall out of the window: replays are refused. */
+    const replay = new AgentUrlReplayGuard(tolerance);
+    const running = new Map();
+    const run = async (episode, controller) => {
+        const deadline = setTimeout(() => controller.abort(new Error("the episode's deadline passed")), episode.deadlineMs);
+        let outcome;
+        let failed = false;
+        try {
+            outcome = await options.onEpisode(episode, { signal: controller.signal });
+        }
+        catch (error) {
+            failed = true;
+            if (!controller.signal.aborted)
+                onError(error, episode);
+            outcome = {
+                finalMessage: `the agent failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 4_000),
+            };
+        }
+        finally {
+            clearTimeout(deadline);
+            running.delete(episode.episodeId);
+        }
+        // Cancelled or past its deadline: the episode is already over at the gateway.
+        if (controller.signal.aborted)
+            return;
+        try {
+            await finishEpisode(episode, {
+                ...(outcome?.finalMessage !== undefined
+                    ? { finalMessage: outcome.finalMessage.slice(0, 4_000) }
+                    : {}),
+                ...(outcome?.usage ? { usage: outcome.usage } : {}),
+            }, options.fetch ? { fetch: options.fetch } : {});
+        }
+        catch (error) {
+            if (!failed)
+                onError(error, episode);
+        }
+    };
+    return async (request, context) => {
+        if (request.method !== "POST")
+            return json(405, { error: "Bonded calls this endpoint with POST" }, { allow: "POST" });
+        const body = await readCapped(request, maxBody);
+        if (body === undefined)
+            return json(413, { error: `the body is over ${maxBody} bytes` });
+        const check = await verifyAgentUrlRequest({
+            secret: options.secret,
+            body,
+            headers: request.headers,
+            nowMs: now(),
+            toleranceSeconds: tolerance,
+            replay,
+        });
+        if (!check.ok)
+            return json(check.status, { error: check.reason });
+        const message = check.message;
+        // The answer proves the secret (an HMAC of the challenge), so an echo server can't pass.
+        if (message.type === "verify")
+            return json(200, await answerAgentUrlVerify(await signingSecret(secrets, body, request.headers, now(), tolerance), message, options.version));
+        if (message.type === "cancel") {
+            const controller = running.get(message.episodeId);
+            controller?.abort(new Error("Bonded cancelled the episode"));
+            return json(200, { ok: true, cancelled: controller !== undefined });
+        }
+        const episode = toEpisode(message);
+        if (running.has(episode.episodeId))
+            return json(200, { ok: true, episodeId: episode.episodeId, alreadyRunning: true });
+        if (running.size >= maxConcurrent)
+            return json(429, { error: `already running ${running.size} episodes` });
+        const controller = new AbortController();
+        running.set(episode.episodeId, controller);
+        const work = run(episode, controller);
+        // Called as a method: Cloudflare's ctx.waitUntil needs its `this`.
+        if (context?.waitUntil)
+            context.waitUntil(work);
+        else
+            options.waitUntil?.(work);
+        return json(202, { ok: true, episodeId: episode.episodeId });
+    };
+}
+/**
+ * Which of the secrets signed a request already verified (while a secret rotates, the verify
+ * proof must be made with the one Bonded holds).
+ */
+async function signingSecret(secrets, body, headers, nowMs, toleranceSeconds) {
+    if (secrets.length === 1)
+        return secrets[0];
+    for (const secret of secrets) {
+        const check = await verifyAgentUrlRequest({ secret, body, headers, nowMs, toleranceSeconds });
+        if (check.ok)
+            return secret;
+    }
+    return secrets[0];
+}
+/** The episode as the agent sees it (the same shape `fromBondedEnv` returns). */
+function toEpisode(message) {
+    // The runner protocol's message, minus `type`, `nonce` and `teeKeyId` (TEE-bound agents use
+    // the runner).
+    return {
+        episodeId: message.episodeId,
+        task: message.task,
+        mode: message.mode,
+        endpoints: message.endpoints,
+        vault: message.vault,
+        chainId: message.chainId,
+        contracts: { exchange: message.contracts.exchange, tokens: message.contracts.tokens },
+        ...(message.sessionKey ? { sessionKey: message.sessionKey } : {}),
+        deadlineMs: message.deadlineMs,
+    };
+}
+function json(status, body, headers = {}) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json", ...headers },
+    });
+}
+/** The body as text, or undefined when it is over `max` bytes (read no further than that). */
+async function readCapped(request, max) {
+    const declared = Number(request.headers.get("content-length") ?? "0");
+    if (declared > max)
+        return undefined;
+    if (!request.body)
+        return "";
+    const reader = request.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        size += value.byteLength;
+        if (size > max) {
+            await reader.cancel();
+            return undefined;
+        }
+        chunks.push(value);
+    }
+    const bytes = new Uint8Array(size);
+    let offset = 0;
+    for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return new TextDecoder().decode(bytes);
+}
+/**
+ * The handler as a Node `http` / Express / Fastify-style listener:
+ *
+ * ```ts
+ * app.post("/bonded", toNodeHandler(handler)); // Express: mount it before express.json()
+ * http.createServer(toNodeHandler(handler)).listen(8080);
+ * ```
+ *
+ * The signature covers the raw body, so the body must reach it unparsed: either nothing has read
+ * the stream yet, or `req.body` is the raw `Buffer` or string (`express.raw()`/`express.text()`).
+ */
+export function toNodeHandler(handler) {
+    return async (req, res) => {
+        let body;
+        if (typeof req.body === "string" || req.body instanceof Uint8Array) {
+            body = req.body;
+        }
+        else if (req.body !== undefined && req.body !== null && !isEmptyObject(req.body)) {
+            res.writeHead(500, { "content-type": "application/json" });
+            res.end(JSON.stringify({
+                error: "the body was already parsed, so its signature can't be checked: mount the Bonded handler before express.json(), or use express.raw({ type: 'application/json' })",
+            }));
+            return;
+        }
+        else if (req.method === "POST") {
+            body = new ReadableStream({
+                start(controller) {
+                    req.on("data", (chunk) => controller.enqueue(new Uint8Array(chunk)));
+                    req.on("end", () => controller.close());
+                    req.on("error", (error) => controller.error(error));
+                },
+                cancel() {
+                    req.destroy();
+                },
+            });
+        }
+        const headers = new Headers();
+        for (const [name, value] of Object.entries(req.headers))
+            if (typeof value === "string")
+                headers.set(name, value);
+            else if (Array.isArray(value))
+                headers.set(name, value.join(", "));
+        const request = new Request(`http://${req.headers.host ?? "localhost"}${req.url ?? "/"}`, {
+            method: req.method ?? "GET",
+            headers,
+            ...(body !== undefined ? { body, duplex: "half" } : {}),
+        });
+        const response = await handler(request);
+        res.writeHead(response.status, Object.fromEntries(response.headers));
+        res.end(Buffer.from(await response.arrayBuffer()));
+    };
+}
+function isEmptyObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        Object.keys(value).length === 0);
+}
+//# sourceMappingURL=agent-url.js.map

package/dist/agentkit.d.ts

@@ -0,0 +1,104 @@
+import { type Action, ActionProvider, EvmWalletProvider, type Network, type WalletProvider } from "@coinbase/agentkit";
+import { type Address, type Hex, type TransactionReceipt, type TransactionRequest } from "viem";
+import { type GuardOptions } from "./guarded.js";
+import type { MessageSigner } from "./sentinel.js";
+import { type EpisodeTools, type EpisodeToolsSource } from "./mcp.js";
+export interface BondedWalletProviderOptions {
+    /**
+     * A wallet provider for the vault's agent key, e.g. AgentKit's `ViemWalletProvider`. It signs,
+     * pays gas and reads the chain; it never holds the funds.
+     */
+    wallet: EvmWalletProvider;
+    /** The Mandate Vault (or MandateModule) whose agent key `wallet` is. */
+    vault: Address;
+    /**
+     * Where the funds are, which AgentKit sees as the wallet's address: the vault itself, or a
+     * module's smart account. `BondedWalletProvider.create` reads it from the chain.
+     */
+    holder?: Address;
+    /**
+     * Check each transaction before sending it: a dry run of the vault's `execute`, refused on a
+     * predicted breach, and Sentinel if configured. Off by default: the vault judges either way.
+     */
+    guard?: boolean | GuardOptions;
+}
+/**
+ * A Coinbase AgentKit wallet provider whose wallet is a Mandate Vault. Every transaction an
+ * action provider sends becomes `vault.execute(to, data)` from the agent key, so the vault checks
+ * it against the mandate and records any breach; `getAddress()` is where the funds
+ * are. Any AgentKit action provider then trades through the mandate unchanged.
+ *
+ * What a vault can't do is refused: native value (the vault is ERC-20 only), contract creation,
+ * and raw signatures or signed transactions from the agent key, which would bypass the vault.
+ * `signMessage` signs with the agent key (e.g. for API logins); it is not the vault's signature.
+ *
+ * In Enforce mode a blocked transaction still mines; `waitForTransactionReceipt` throws
+ * `BlockedByMandateError` for it, so the action reports a failure instead of a success.
+ */
+export declare class BondedWalletProvider extends EvmWalletProvider {
+    #private;
+    readonly vault: Address;
+    /** Where the funds are: the vault, or a module's smart account. */
+    readonly holder: Address;
+    constructor(options: BondedWalletProviderOptions);
+    /**
+     * A provider for a vault or a module, with `holder` read from the chain (a module's funds are
+     * in its smart account). Use this for modules; `new` assumes a vault unless `holder` is given.
+     */
+    static create(options: BondedWalletProviderOptions): Promise<BondedWalletProvider>;
+    getAddress(): string;
+    getNetwork(): Network;
+    getName(): string;
+    /** The native balance where the funds are. The mandate covers ERC-20 tokens; gas is paid by the agent key. */
+    getBalance(): Promise<bigint>;
+    getPublicClient(): ReturnType<EvmWalletProvider["getPublicClient"]>;
+    readContract<P>(params: P): Promise<never>;
+    /** Sends `transaction` as `vault.execute(to, data)` from the agent key. */
+    sendTransaction(transaction: TransactionRequest): Promise<Hex>;
+    /**
+     * Waits for the transaction, then reads the vault's verdict from its events: throws
+     * `BlockedByMandateError` when Enforce mode stopped the call, `VaultFrozenError` when a
+     * freeze skipped it. A Monitor-mode breach goes through and is in the vault's breach log.
+     */
+    waitForTransactionReceipt(txHash: Hex): Promise<TransactionReceipt>;
+    nativeTransfer(): Promise<Hex>;
+    /** Signs with the agent key. This is not a signature by the vault. */
+    signMessage(message: string | Uint8Array): Promise<Hex>;
+    sign(): Promise<Hex>;
+    signTypedData(): Promise<Hex>;
+    signTransaction(): Promise<Hex>;
+}
+/**
+ * Signs EIP-191 messages with an AgentKit wallet. Text is passed as its UTF-8 bytes, so a
+ * message that happens to look like hex is still signed as text.
+ */
+export declare function agentKitSigner(wallet: EvmWalletProvider): MessageSigner;
+/**
+ * An AgentKit action provider whose actions are the episode's tools, named
+ * `BondedEpisodeActionProvider_<tool>` as AgentKit names its own. Each action returns what the
+ * Arena returned, as text; a failed call returns `Error: ...` so the model can react. Works on
+ * any network and with any wallet provider: the tools don't use the wallet.
+ *
+ * In tools mode the episode's writes (`swap`, `transfer`, `approve`) are tools too. In chain mode
+ * only the reads are, and writes are transactions to the episode vault: use a
+ * `BondedWalletProvider` for `episode.vault` with `episode.sessionKey` and `episode.endpoints.rpc`.
+ */
+export declare class BondedEpisodeActionProvider extends ActionProvider<WalletProvider> {
+    #private;
+    constructor(episode: EpisodeTools);
+    getActions(): Action[];
+    supportsNetwork(): boolean;
+}
+/**
+ * The episode's tools as an AgentKit action provider. With no argument it reads the episode from
+ * the runner's `BONDED_*` variables. Switch to it only while being rated:
+ *
+ * ```ts
+ * const actionProviders = isBondedEpisode()
+ *   ? [await bondedEpisodeActionProvider()]
+ *   : [erc20ActionProvider(), myProviders()];
+ * const kit = await AgentKit.from({ walletProvider, actionProviders });
+ * ```
+ */
+export declare function bondedEpisodeActionProvider(from?: EpisodeTools | EpisodeToolsSource): Promise<BondedEpisodeActionProvider>;
+//# sourceMappingURL=agentkit.d.ts.map