@qvac/sdk 0.18.1 → 0.19.0

package/dist/server/plugins/registry.js

@@ -1,107 +0,0 @@
-import { pluginDefinitionRuntimeSchema } from '../../schemas/plugin.js';
-import { isModelTypeAlias } from '../../schemas/index.js';
-import { PluginAlreadyRegisteredError, PluginDefinitionInvalidError, PluginLoggingInvalidError, PluginModelTypeReservedError } from '../../utils/errors-server.js';
-import { createAddonLoggerCallback } from '../../logging/addon.js';
-import { getServerLogger } from '../../logging/index.js';
-import { formatZodError } from '../../utils/zod-error.js';
-const plugins = new Map();
-function getLoggingModule(plugin) {
-    return plugin.logging?.module;
-}
-function findPluginUsingLoggingModule(loggingModule) {
-    return Array.from(plugins.values()).find((plugin) => plugin.logging?.module === loggingModule);
-}
-function getModelTypeForError(plugin) {
-    if (!plugin || typeof plugin !== 'object')
-        return '(unknown)';
-    if (!('modelType' in plugin))
-        return '(unknown)';
-    const modelType = plugin.modelType;
-    return typeof modelType === 'string' && modelType.length > 0 ? modelType : '(unknown)';
-}
-function validatePluginDefinition(plugin) {
-    const result = pluginDefinitionRuntimeSchema.safeParse(plugin);
-    if (result.success)
-        return;
-    throw new PluginDefinitionInvalidError(getModelTypeForError(plugin), formatZodError(result.error));
-}
-export function registerPlugin(plugin) {
-    validatePluginDefinition(plugin);
-    if (isModelTypeAlias(plugin.modelType)) {
-        throw new PluginModelTypeReservedError(plugin.modelType);
-    }
-    if (plugins.has(plugin.modelType)) {
-        throw new PluginAlreadyRegisteredError(plugin.modelType);
-    }
-    // Validate logging module shape if provided
-    if (plugin.logging?.module) {
-        const loggingModule = plugin.logging.module;
-        if (typeof loggingModule['setLogger'] !== 'function') {
-            throw new PluginLoggingInvalidError(plugin.modelType, 'logging.module must have a setLogger(callback) function');
-        }
-    }
-    const loggingModule = getLoggingModule(plugin);
-    const pluginUsingLoggingModule = loggingModule
-        ? findPluginUsingLoggingModule(loggingModule)
-        : undefined;
-    if (pluginUsingLoggingModule &&
-        pluginUsingLoggingModule.logging?.namespace !== plugin.logging?.namespace) {
-        throw new PluginLoggingInvalidError(plugin.modelType, 'plugins sharing logging.module must use the same namespace');
-    }
-    plugins.set(plugin.modelType, plugin);
-    if (loggingModule && plugin.logging?.namespace && !pluginUsingLoggingModule) {
-        loggingModule.setLogger(createAddonLoggerCallback(plugin.logging.namespace));
-    }
-}
-export function registerPlugins(pluginList) {
-    for (const plugin of pluginList) {
-        registerPlugin(plugin);
-    }
-}
-export function getPlugin(modelType) {
-    return plugins.get(modelType);
-}
-export function getPluginHandler(modelType, handlerName) {
-    const plugin = plugins.get(modelType);
-    if (!plugin)
-        return undefined;
-    return plugin.handlers[handlerName];
-}
-export function hasPlugin(modelType) {
-    return plugins.has(modelType);
-}
-export function unregisterPlugin(modelType) {
-    const plugin = plugins.get(modelType);
-    if (!plugin)
-        return false;
-    const loggingModule = getLoggingModule(plugin);
-    plugins.delete(modelType);
-    if (loggingModule && !findPluginUsingLoggingModule(loggingModule)) {
-        loggingModule.releaseLogger?.();
-    }
-    return true;
-}
-export function getAllPlugins() {
-    return Array.from(plugins.values());
-}
-export function clearPlugins() {
-    const loggingModules = new Map();
-    for (const plugin of plugins.values()) {
-        const loggingModule = getLoggingModule(plugin);
-        if (loggingModule && !loggingModules.has(loggingModule)) {
-            loggingModules.set(loggingModule, plugin.modelType);
-        }
-    }
-    plugins.clear();
-    for (const [loggingModule, modelType] of loggingModules) {
-        try {
-            loggingModule.releaseLogger?.();
-        }
-        catch (error) {
-            // A plugin's logger teardown must not abort the sweep or leave the
-            // registry half-cleared for the next caller — but surface it, so a leaked
-            // reference or async handle is not masked as a clean teardown.
-            getServerLogger().warn(`[${modelType}] releaseLogger failed during clearPlugins: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}

package/dist/server/rpc/create-server.js

@@ -1,46 +0,0 @@
-import RPC from 'bare-rpc';
-import { connect } from 'bare-net';
-import { handleRequest } from './handle-request.js';
-import { getServerLogger } from '../../logging/index.js';
-const logger = getServerLogger();
-export function createBareKitRPCServer() {
-    const { IPC } = globalThis.BareKit;
-    return new RPC(IPC, handleRequest);
-}
-/**
- * Dial the client's IPC endpoint. Two encodings cross the handshake:
- *
- * - `tcp://host:port` — a loopback TCP endpoint. Used by clients whose
- *   runtime has no portable server for filesystem sockets, notably the
- *   Python `asyncio` transport (`start_unix_server` is Unix-only, and
- *   asyncio has no cross-platform named-pipe server). One code path on
- *   every OS, so Windows dials the same way Linux/macOS do.
- * - anything else — a filesystem path: a Unix domain socket, or a
- *   `\\.\pipe\...` named pipe on Windows, as the Node client (`node:net`)
- *   creates.
- */
-function connectToEndpoint(endpoint) {
-    if (endpoint.startsWith('tcp://')) {
-        const hostPort = endpoint.slice('tcp://'.length);
-        const sep = hostPort.lastIndexOf(':');
-        const host = hostPort.slice(0, sep);
-        const port = Number(hostPort.slice(sep + 1));
-        return connect(port, host);
-    }
-    return connect(endpoint);
-}
-export function createIPCClient(socketPath, options) {
-    logger.info(`Connecting to IPC socket at ${socketPath}`);
-    const socket = connectToEndpoint(socketPath);
-    socket.on('connect', () => {
-        logger.info('Connected to IPC server');
-    });
-    socket.on('error', (err) => {
-        logger.error('IPC client connection error:', err);
-    });
-    socket.on('close', () => {
-        logger.warn('IPC socket closed — parent process likely terminated');
-        options?.onDisconnect?.();
-    });
-    return new RPC(socket, handleRequest);
-}

package/dist/server/rpc/delegate-transport.d.ts

@@ -1,19 +0,0 @@
-/**
- * Server-side RPC transport for delegated requests.
- *
- * This module provides `send` and `stream` functions for server-side
- * delegation to remote peers (via HyperSwarm RPC).
- */
-import type RPC from 'bare-rpc';
-import { DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY, type Request, type Response, type RPCOptions, type DelegationBreakdown, type OperationEvent } from '../../schemas/index.js';
-import type { DelegatedHandlerOptions } from './profiling/index.js';
-export interface DelegateOptions extends RPCOptions, DelegatedHandlerOptions {
-    peerKey?: string;
-}
-export type ResponseWithDelegation = Response & {
-    [DELEGATION_BREAKDOWN_KEY]?: DelegationBreakdown;
-    [OPERATION_EVENT_KEY]?: OperationEvent;
-};
-export declare function send<T extends Request>(request: T, rpc: RPC, options?: DelegateOptions): Promise<Response>;
-export declare function stream<T extends Request>(request: T, rpc: RPC, options?: DelegateOptions): AsyncGenerator<Response>;
-//# sourceMappingURL=delegate-transport.d.ts.map

package/dist/server/rpc/delegate-transport.js

@@ -1,237 +0,0 @@
-/**
- * Server-side RPC transport for delegated requests.
- *
- * This module provides `send` and `stream` functions for server-side
- * delegation to remote peers (via HyperSwarm RPC).
- */
-import { requestSchema, responseSchema, PROFILING_KEY, PROFILING_TRAILER_KEY, DELEGATION_BREAKDOWN_KEY, OPERATION_EVENT_KEY } from '../../schemas/index.js';
-import { nowMs, extractProfilingMeta, stripProfilingMeta, recordFailure, generateId, createDelegatedProfilingMeta } from '../../profiling/index.js';
-import { withTimeout, withTimeoutStream } from '../../utils/withTimeout.js';
-import { getServerLogger } from '../../logging/index.js';
-import { DelegateProviderError } from '../../utils/errors-server.js';
-import { cleanupStaleConnection } from '../../server/bare/delegate-rpc-client.js';
-import { shouldProfileDelegation, createDelegationTimings, createDelegationStreamTimings, recordDelegationEvents, recordDelegationStreamEvents, buildDelegationStreamBreakdown, flushServerConnectionEvent, consumeBreakdownConnectionTime } from './profiling/delegation-profiler.js';
-const logger = getServerLogger();
-import { getNextCommandId } from '../../server/rpc/rpc-utils.js';
-function checkAndThrowError(response) {
-    if (response.type === 'error') {
-        throw new DelegateProviderError(response.message || 'Unknown provider error', response.code);
-    }
-}
-function isConnectionError(error) {
-    return !(error instanceof DelegateProviderError);
-}
-function cleanupDelegationPeer(options, error) {
-    if (!options?.peerKey)
-        return;
-    if (error !== undefined && !isConnectionError(error))
-        return;
-    cleanupStaleConnection(options.peerKey);
-}
-export async function send(request, rpc, options) {
-    const { profilingMeta } = options ?? {};
-    const shouldProfile = shouldProfileDelegation(request.type, profilingMeta);
-    if (!shouldProfile) {
-        return sendBase(request, rpc, options, profilingMeta);
-    }
-    return sendProfiled(request, rpc, options, profilingMeta);
-}
-async function sendBase(request, rpc, options, profilingMeta) {
-    try {
-        const parsedRequest = requestSchema.parse(request);
-        const req = rpc.request(getNextCommandId());
-        logger.debug('[delegate-transport] Sending:', { type: request.type });
-        // Propagate per-call disable signal to delegated provider
-        const finalRequest = profilingMeta?.enabled === false
-            ? { ...parsedRequest, [PROFILING_KEY]: { enabled: false } }
-            : parsedRequest;
-        const payload = JSON.stringify(finalRequest);
-        req.send(payload, 'utf-8');
-        const response = await withTimeout(req.reply('utf-8'), options?.timeout);
-        const rawPayload = JSON.parse(response?.toString() || '{}');
-        const resPayload = responseSchema.parse(stripProfilingMeta(rawPayload));
-        logger.debug('[delegate-transport] Response:', { type: resPayload.type });
-        checkAndThrowError(resPayload);
-        return resPayload;
-    }
-    catch (error) {
-        cleanupDelegationPeer(options, error);
-        throw error;
-    }
-}
-async function sendProfiled(request, rpc, options, profilingMeta) {
-    const profileId = profilingMeta?.id ?? generateId();
-    const timings = createDelegationTimings(profileId, request.type);
-    try {
-        if (options?.peerKey) {
-            flushServerConnectionEvent(options.peerKey);
-        }
-        const connectionMs = options?.peerKey
-            ? consumeBreakdownConnectionTime(options.peerKey)
-            : undefined;
-        const parsedRequest = requestSchema.parse(request);
-        const req = rpc.request(getNextCommandId());
-        logger.debug('[delegate-transport] Sending (profiled):', {
-            type: request.type
-        });
-        const stringifyStart = nowMs();
-        const requestWithProfiling = {
-            ...parsedRequest,
-            [PROFILING_KEY]: createDelegatedProfilingMeta(profileId, profilingMeta)
-        };
-        const payload = JSON.stringify(requestWithProfiling);
-        timings.requestStringifyMs = nowMs() - stringifyStart;
-        timings.sendStart = nowMs();
-        req.send(payload, 'utf-8');
-        const response = await withTimeout(req.reply('utf-8'), options?.timeout);
-        timings.firstResponseAt = nowMs();
-        const parseStart = nowMs();
-        const rawPayload = JSON.parse(response?.toString() || '{}');
-        timings.responseJsonParseMs = nowMs() - parseStart;
-        const serverMeta = extractProfilingMeta(rawPayload);
-        const cleanPayload = stripProfilingMeta(rawPayload);
-        const resPayload = responseSchema.parse(cleanPayload);
-        logger.debug('[delegate-transport] Response (profiled):', {
-            type: resPayload.type
-        });
-        checkAndThrowError(resPayload);
-        const delegationBreakdown = recordDelegationEvents(timings, serverMeta, connectionMs);
-        resPayload[DELEGATION_BREAKDOWN_KEY] = delegationBreakdown;
-        if (serverMeta?.operation) {
-            resPayload[OPERATION_EVENT_KEY] = serverMeta.operation;
-        }
-        return resPayload;
-    }
-    catch (error) {
-        cleanupDelegationPeer(options, error);
-        const base = {
-            ts: nowMs(),
-            op: timings.requestType,
-            kind: 'delegation',
-            profileId: timings.profileId
-        };
-        recordFailure(base, timings.requestStart, error);
-        throw error;
-    }
-}
-export async function* stream(request, rpc, options = {}) {
-    const { profilingMeta } = options;
-    const shouldProfile = shouldProfileDelegation(request.type, profilingMeta);
-    if (!shouldProfile) {
-        yield* streamBase(request, rpc, options, profilingMeta);
-        return;
-    }
-    yield* streamProfiled(request, rpc, options, profilingMeta);
-}
-async function* streamBase(request, rpc, options = {}, profilingMeta) {
-    try {
-        const parsedRequest = requestSchema.parse(request);
-        const req = rpc.request(getNextCommandId());
-        logger.debug('[delegate-transport] Streaming:', { type: request.type });
-        // Propagate per-call disable signal to delegated provider
-        const finalRequest = profilingMeta?.enabled === false
-            ? { ...parsedRequest, [PROFILING_KEY]: { enabled: false } }
-            : parsedRequest;
-        req.send(JSON.stringify(finalRequest), 'utf-8');
-        const responseStream = req.createResponseStream({ encoding: 'utf-8' });
-        let buffer = '';
-        async function* processStream() {
-            for await (const chunk of responseStream) {
-                yield chunk;
-            }
-        }
-        const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
-        for await (const chunk of streamWithTimeout) {
-            buffer += chunk.toString();
-            // Process complete lines (newline-delimited JSON)
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || ''; // Keep incomplete line in buffer
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                const rawPayload = JSON.parse(line);
-                if (rawPayload[PROFILING_TRAILER_KEY] === true)
-                    continue;
-                const response = responseSchema.parse(stripProfilingMeta(rawPayload));
-                checkAndThrowError(response);
-                yield response;
-            }
-        }
-    }
-    catch (error) {
-        cleanupDelegationPeer(options, error);
-        throw error;
-    }
-}
-async function* streamProfiled(request, rpc, options = {}, profilingMeta) {
-    const profileId = profilingMeta?.id ?? generateId();
-    const timings = createDelegationStreamTimings(profileId, request.type);
-    try {
-        if (options.peerKey) {
-            flushServerConnectionEvent(options.peerKey);
-        }
-        const parsedRequest = requestSchema.parse(request);
-        const req = rpc.request(getNextCommandId());
-        logger.debug('[delegate-transport] Streaming (profiled):', {
-            type: request.type
-        });
-        const stringifyStart = nowMs();
-        const requestWithProfiling = {
-            ...parsedRequest,
-            [PROFILING_KEY]: createDelegatedProfilingMeta(profileId, profilingMeta)
-        };
-        const payload = JSON.stringify(requestWithProfiling);
-        timings.requestStringifyMs = nowMs() - stringifyStart;
-        timings.sendStart = nowMs();
-        req.send(payload, 'utf-8');
-        const responseStream = req.createResponseStream({ encoding: 'utf-8' });
-        let buffer = '';
-        async function* processStream() {
-            for await (const chunk of responseStream) {
-                yield chunk;
-            }
-        }
-        const streamWithTimeout = withTimeoutStream(processStream(), options?.timeout);
-        let lastServerMeta;
-        for await (const chunk of streamWithTimeout) {
-            buffer += chunk.toString();
-            const lines = buffer.split('\n');
-            buffer = lines.pop() || '';
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                const rawPayload = JSON.parse(line);
-                const serverMeta = extractProfilingMeta(rawPayload);
-                if (serverMeta) {
-                    lastServerMeta = serverMeta;
-                }
-                if (rawPayload[PROFILING_TRAILER_KEY] === true)
-                    continue;
-                const response = responseSchema.parse(stripProfilingMeta(rawPayload));
-                checkAndThrowError(response);
-                timings.chunkCount++;
-                if (timings.firstChunkAt === undefined) {
-                    timings.firstChunkAt = nowMs();
-                }
-                timings.lastChunkAt = nowMs();
-                if (serverMeta?.operation) {
-                    response[OPERATION_EVENT_KEY] = serverMeta.operation;
-                }
-                response[DELEGATION_BREAKDOWN_KEY] = buildDelegationStreamBreakdown(timings);
-                yield response;
-            }
-        }
-        recordDelegationStreamEvents(timings, lastServerMeta);
-    }
-    catch (error) {
-        cleanupDelegationPeer(options, error);
-        const base = {
-            ts: nowMs(),
-            op: timings.requestType,
-            kind: 'delegation',
-            profileId: timings.profileId
-        };
-        recordFailure(base, timings.requestStart, error);
-        throw error;
-    }
-}

package/dist/server/rpc/handle-request.js

@@ -1,172 +0,0 @@
-import { requestSchema, normalizeModelType, PROFILING_KEY } from '../../schemas/index.js';
-import { nowMs } from '../../profiling/index.js';
-import { resolveModelConfig } from '../../server/bare/registry/model-config-registry.js';
-import { sendErrorResponse, sendStreamErrorResponse } from '../../server/error-handlers.js';
-import { RPCUnknownRequestTypeError, PluginHandlerTypeMismatchError } from '../../utils/errors-server.js';
-import { registry } from './handler-registry.js';
-import { executeHandler, executeDuplexHandler, handleInitConfig, isInitConfigMessage, handleShutdown, isShutdownMessage } from './handler-utils.js';
-import { createServerProfiler } from './profiling/index.js';
-import { assertLifecycleAllowed } from '../../server/bare/runtime-lifecycle.js';
-import { shouldUseStreamErrorTransport } from './transport-selector.js';
-export async function handleRequest(req) {
-    let profiler;
-    let validationStart = 0;
-    let rawRequest;
-    let entry;
-    try {
-        const rawData = req.data?.toString();
-        // Duplex stream request: metadata arrives as the first chunk on the
-        // request stream (client used createRequestStream instead of send).
-        if (!rawData) {
-            await handleDuplexRequest(req);
-            return;
-        }
-        // Timing runs unconditionally since we can't know if client
-        // requested profiling until after parsing.
-        const parseStart = nowMs();
-        const jsonData = JSON.parse(rawData);
-        const jsonParseMs = nowMs() - parseStart;
-        // Handle internal config initialization (bypasses schema)
-        if (isInitConfigMessage(jsonData)) {
-            handleInitConfig(req, jsonData);
-            return;
-        }
-        // Handle internal pre-terminate cleanup signal (bypasses schema). Lets
-        // the client tear addons down while the JS env is still alive so static
-        // js_ref_t state doesn't survive into the next worklet's isolate.
-        if (isShutdownMessage(jsonData)) {
-            await handleShutdown(req);
-            return;
-        }
-        const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
-        if (cleanData && typeof cleanData === 'object') {
-            rawRequest = cleanData;
-            const rawType = rawRequest['type'];
-            if (typeof rawType === 'string') {
-                entry = registry[rawType];
-            }
-        }
-        profiler = createServerProfiler(profilingMeta);
-        profiler.markRequestParsed(jsonParseMs);
-        validationStart = nowMs();
-        const processedData = applyDeviceDefaultsToRequest(cleanData);
-        const request = requestSchema.parse(processedData);
-        attachProfilingMetaToRequest(request, profilingMeta);
-        profiler.markRequestValidated(nowMs() - validationStart);
-        validationStart = 0;
-        assertLifecycleAllowed(request);
-        entry = registry[request.type];
-        if (!entry) {
-            throw new RPCUnknownRequestTypeError(request.type);
-        }
-        await executeHandler(req, request, entry, profiler);
-    }
-    catch (error) {
-        if (profiler && validationStart > 0) {
-            profiler.markRequestValidated(nowMs() - validationStart);
-        }
-        if (shouldUseStreamErrorTransport(entry, rawRequest)) {
-            sendStreamErrorResponse(req.createResponseStream(), error, profiler);
-        }
-        else {
-            sendErrorResponse(req, error, profiler);
-        }
-    }
-}
-function attachProfilingMetaToRequest(request, profilingMeta) {
-    if (!profilingMeta)
-        return;
-    Object.defineProperty(request, PROFILING_KEY, {
-        value: profilingMeta,
-        enumerable: false,
-        configurable: true,
-        writable: false
-    });
-}
-function extractProfilingMeta(data) {
-    if (!data || typeof data !== 'object' || !(PROFILING_KEY in data)) {
-        return { data, profilingMeta: undefined };
-    }
-    const obj = data;
-    const { [PROFILING_KEY]: meta, ...rest } = obj;
-    return {
-        data: rest,
-        profilingMeta: meta
-    };
-}
-async function handleDuplexRequest(req) {
-    const inputStream = req.createRequestStream();
-    const outputStream = req.createResponseStream();
-    let profiler;
-    try {
-        const firstChunk = await new Promise((resolve, reject) => {
-            const onData = (data) => {
-                inputStream.off('error', onError);
-                inputStream.pause();
-                resolve(data);
-            };
-            const onError = (err) => {
-                inputStream.off('data', onData);
-                reject(err instanceof Error ? err : new Error(String(err)));
-            };
-            inputStream.once('data', onData);
-            inputStream.once('error', onError);
-        });
-        const parseStart = nowMs();
-        const jsonData = JSON.parse(firstChunk.toString());
-        const jsonParseMs = nowMs() - parseStart;
-        const { data: cleanData, profilingMeta } = extractProfilingMeta(jsonData);
-        profiler = createServerProfiler(profilingMeta);
-        profiler.markRequestParsed(jsonParseMs);
-        const validationStart = nowMs();
-        const processedData = applyDeviceDefaultsToRequest(cleanData);
-        const request = requestSchema.parse(processedData);
-        attachProfilingMetaToRequest(request, profilingMeta);
-        profiler.markRequestValidated(nowMs() - validationStart);
-        assertLifecycleAllowed(request);
-        const entry = registry[request.type];
-        if (!entry) {
-            throw new RPCUnknownRequestTypeError(request.type);
-        }
-        if (entry.type !== 'duplex') {
-            throw new PluginHandlerTypeMismatchError(request.type, 'duplex', entry.type);
-        }
-        await executeDuplexHandler(req, request, entry, inputStream, outputStream, profiler);
-    }
-    catch (error) {
-        inputStream.destroy();
-        sendStreamErrorResponse(outputStream, error, profiler);
-    }
-}
-/**
- * Apply device-specific config defaults to loadModel requests before schema parsing.
- * This ensures device defaults are applied before schema defaults.
- *
- * Priority: User config > Device defaults > Schema defaults
- */
-function applyDeviceDefaultsToRequest(data) {
-    if (!data || typeof data !== 'object')
-        return data;
-    const obj = data;
-    const requestType = obj['type'];
-    // Only process loadModel requests (not reload config which uses modelId)
-    if (requestType !== 'loadModel' || !obj['modelType'] || !('modelSrc' in obj)) {
-        return data;
-    }
-    // Normalize model type to canonical form
-    let canonicalType;
-    try {
-        canonicalType = normalizeModelType(obj['modelType']);
-    }
-    catch {
-        // Invalid model type, let schema validation handle it
-        return data;
-    }
-    // Apply device defaults and full schema defaults to modelConfig
-    const rawConfig = obj['modelConfig'] ?? {};
-    const configWithDefaults = resolveModelConfig(canonicalType, rawConfig);
-    return {
-        ...obj,
-        modelConfig: configWithDefaults
-    };
-}

package/dist/server/rpc/handler-registry.d.ts

@@ -1,3 +0,0 @@
-import type { HandlerEntry } from './handler-utils.js';
-export declare const registry: Record<string, HandlerEntry>;
-//# sourceMappingURL=handler-registry.d.ts.map