hippo-memory 1.56.0 → 1.57.0

package/dist/api.d.ts

@@ -19,7 +19,7 @@ import { auditMemories, type AuditEvent, type AuditOp } from './audit.js';
 import { autoShare } from './shared.js';
 import type { DeliveryObserver } from './delivery-recorder.js';
 import { type ApiKeyListItem } from './auth.js';
-import { type RerankStep } from './search.js';
+import { type RerankStep, type SearchResult } from './search.js';
 import { consolidate } from './consolidate.js';
 import { loadConfig } from './config.js';
 import { deduplicateStore } from './dedupe.js';
@@ -92,9 +92,8 @@ export type { TokenSummary, TokenSurface, TokenSurfaceSummary } from './token-le
 export type { FailureSummary } from './failure-log.js';
 export { classifyOriginProject } from './project-identity.js';
 /**
- * v39 S4: the secret half of the ambient policy on its own, for surfaces
- * with their own scope semantics (MCP hippo_context's explicit-scope
- * exact-match). A flagged row is only admitted inside its owning project;
+ * v39 S4: the secret half of the ambient policy on its own, for callers
+ * that apply their own scope rule. A flagged row is only admitted inside its owning project;
  * flagged rows with no project origin never ambient-inject.
  */
 export declare function ambientSecretAdmit(e: MemoryEntry, currentProjectName: string): boolean;
@@ -270,16 +269,22 @@ export interface RecallOpts {
      * Mirrors `suppressAvailabilityHint`'s pattern: callers that run their OWN
      * tracing over a DIFFERENT result set must suppress api.recall's copy so
      * the training corpus doesn't get a trace mislabeled as 'api' pipeline
-     * when the caller's actual user-visible results came from elsewhere. The
-     * MCP handler sets this — its primary ranked band comes from a separate
-     * physics/hybrid scorer, not this api.recall call's BM25 band (real MCP
-     * tracing is the reserved 'mcp' pipeline, a follow-up). HTTP / direct SDK
-     * callers leave this unset and get the trace.
+     * when the caller's actual user-visible results came from elsewhere. Under
+     * `showRanked` it also drops the 'mcp' trace of the shown list. HTTP /
+     * direct SDK callers leave this unset and get the trace.
      */
     suppressRecallTrace?: boolean;
     /** Set only by the MCP recall tool, which ranks with its own scorer and drops copies from its own final list: this call
      *  then keeps a memory that a merged row in the same result holds word for word. Other callers leave it unset. */
     keepHeldCopies?: boolean;
+    /** MCP recall only: `retrieve` ranks the whole scoped store and strengthens and traces (pipeline 'mcp') just the ids this returns; `results` stays the window band. */
+    showRanked?: (ranking: StoreRanking, result: RecallResult) => readonly string[];
+}
+/** `ranked`: every scored row, best first, goal boost applied, entries as loaded; `pool`: the store after the scope filter. */
+export interface StoreRanking {
+    ranked: SearchResult[];
+    pool: MemoryEntry[];
+    droppedByScope: number;
 }
 export interface ContinuityBlock {
     activeSnapshot: TaskSnapshot | null;
@@ -946,6 +951,8 @@ export interface ContextOpts {
     limit?: number;
     pinnedOnly?: boolean;
     scope?: string;
+    /** Envelope scope to match exactly, as in `recall`: admits that scope even when private, after the actor's scope check. */
+    exactScope?: string;
     /** With `pinnedOnly`, also inject the N most recent writes that pass the
      *  quality floor (`isContentWorthStoring`, DF3). Filtering happens BEFORE
      *  the take-N, so a caller asking for 5 gets 5 qualifying entries rather

package/dist/api.js

@@ -16,7 +16,7 @@ import { detectInstruction } from './instruction-detect.js';
 import { quarantineScopeFor, recordQuarantine, getQuarantineRow, listQuarantineRows, approveQuarantineRow, rejectQuarantineRow, } from './quarantine.js';
 import { summarizeFailures } from './failure-log.js';
 import { formatHandoffEvidenceLine } from './handoff.js';
-import { createMemory, createSuccessor, applyOutcome, calculateStrength, CHURN_STALE_TAG, COMPACTION_MEMORY_TAG, } from './memory.js';
+import { createMemory, createSuccessor, applyOutcome, calculateStrength, markRetrieved, CHURN_STALE_TAG, COMPACTION_MEMORY_TAG, } from './memory.js';
 import { appendAuditEvent, auditQueryFields, queryAuditEvents, auditMemories, isContentWorthStoring, } from './audit.js';
 import { promoteToGlobal, getGlobalRoot, autoShare, searchBothHybrid } from './shared.js';
 import { writeRecallTrace, writeRecallTraceAtRoot, recordTraceOutcome } from './recall-trace.js';
@@ -24,7 +24,7 @@ import { evalNow } from './ablation.js';
 import { archiveRawMemory } from './raw-archive.js';
 import { createApiKey, listApiKeys, revokeApiKey, grantScope, ungrantScope, } from './auth.js';
 import { applyGoalStackBoost } from './goals.js';
-import { markRetrieved, estimateTokens, hybridSearch, physicsSearch, churnStaleFactor } from './search.js';
+import { estimateTokens, hybridSearch, physicsSearch, churnStaleFactor } from './search.js';
 import { compareEntryIdentity, compareScoredResults } from './compare.js';
 import { dropHeldCopies, duplicateKey, storedTextKeys } from './same-text.js';
 import { scopeMatch } from './scope.js';
@@ -39,7 +39,7 @@ import { computeAmbientState } from './ambient.js';
 import { loadPendingExtractionTenants, markPendingProcessedUpTo } from './graph.js';
 import { extractGraph } from './graph-extract.js';
 import { computePlanningFallacyOutput, } from './predictions.js';
-import { detectAnchoring, hashQueryText, } from './recall-history.js';
+import { detectAnchoring, hashQueryText, biasHintEnabled, } from './recall-history.js';
 import { detectAvailabilityBias } from './availability.js';
 /**
  * Helper for building process-local (admin-by-default) Actor values. v1.12.0
@@ -107,23 +107,22 @@ export { classifyOriginProject } from './project-identity.js';
  *   injects inside its owning project; flagged rows with no project origin
  *   (''/null) never ambient-inject at all. Explicit recall is unaffected -
  *   recalling a secret is a deliberate act.
- * - S2 envelope parity: private scopes + quarantine buckets never inject.
+ * - S2 envelope parity: private/quarantine scopes never inject unless `exactScope` names one.
  * - S3 origin partition: other-project rows are excluded unless
  *   `includeCrossProject`.
  */
-function ambientAdmitEntry(e, currentProjectName, includeCrossProject) {
+function ambientAdmitEntry(e, currentProjectName, includeCrossProject, exactScope) {
     if (!ambientSecretAdmit(e, currentProjectName))
         return false;
-    if (!passesScopeFilterForRecall(e.scope ?? null, undefined))
+    if (!passesScopeFilterForRecall(e.scope ?? null, exactScope))
         return false;
     if (includeCrossProject)
         return true;
     return classifyOriginProject(e.origin_project, currentProjectName) !== 'cross-project';
 }
 /**
- * v39 S4: the secret half of the ambient policy on its own, for surfaces
- * with their own scope semantics (MCP hippo_context's explicit-scope
- * exact-match). A flagged row is only admitted inside its owning project;
+ * v39 S4: the secret half of the ambient policy on its own, for callers
+ * that apply their own scope rule. A flagged row is only admitted inside its owning project;
  * flagged rows with no project origin never ambient-inject.
  */
 export function ambientSecretAdmit(e, currentProjectName) {
@@ -244,6 +243,8 @@ export function recall(ctx, opts) {
 export async function retrieve(ctx, opts) {
     assertScopeRequestAllowed(ctx.actor, opts.scope);
     const windowSize = recallWindowSize(opts);
+    if (opts.showRanked)
+        return retrieveFromStore(ctx, opts, windowSize, opts.showRanked);
     let candidates = loadRecallSearchEntries(ctx.hippoRoot, opts.query, windowSize, ctx.tenantId, opts.scope, 'exact', false);
     if (opts.mode === 'hybrid' || opts.mode === 'physics') {
         const searchOpts = { budget: Infinity, hippoRoot: ctx.hippoRoot, scope: opts.scope ?? null };
@@ -257,6 +258,40 @@ export async function retrieve(ctx, opts) {
     strengthenRetrieved(ctx.hippoRoot, result.results.map((r) => r.id), ctx.tenantId);
     return result;
 }
+/** `retrieve` under `showRanked`: physics when `mode` says so, hybrid otherwise, over every admitted row. */
+async function retrieveFromStore(ctx, opts, windowSize, show) {
+    const store = loadAllEntries(ctx.hippoRoot, ctx.tenantId);
+    const pool = store.filter((e) => passesScopeFilterForRecall(e.scope ?? null, opts.scope));
+    // No scope option: the scope boost follows HIPPO_SCOPE and the skill env, as MCP recall always ranked.
+    const searchOpts = { budget: Infinity, hippoRoot: ctx.hippoRoot };
+    let ranked = opts.mode === 'physics'
+        ? await physicsSearch(opts.query, pool, { ...searchOpts, physicsConfig: loadConfig(ctx.hippoRoot).physics })
+        : await hybridSearch(opts.query, pool, searchOpts);
+    if (opts.sessionId && !opts.goalTag) {
+        const db = openHippoDb(ctx.hippoRoot);
+        try {
+            ranked = applyGoalStackBoost(db, ranked, { sessionId: opts.sessionId, tenantId: ctx.tenantId, limit: ranked.length });
+        }
+        finally {
+            closeHippoDb(db);
+        }
+    }
+    const window = ranked.slice(0, windowSize).map((r) => r.entry);
+    const result = recallFrom(ctx, { ...opts, suppressRecallTrace: true }, windowSize, window);
+    const shown = show({ ranked, pool, droppedByScope: store.length - pool.length }, result);
+    strengthenRetrieved(ctx.hippoRoot, shown, ctx.tenantId);
+    if (!opts.suppressRecallTrace) {
+        const scores = new Map(ranked.map((r) => [r.entry.id, r.score]));
+        writeRecallTraceAtRoot(ctx.hippoRoot, {
+            tenantId: ctx.tenantId,
+            sessionId: opts.sessionId ?? null,
+            pipeline: 'mcp',
+            query: opts.query,
+            results: shown.map((id) => ({ memoryId: id, score: scores.get(id) ?? 0 })),
+        });
+    }
+    return result;
+}
 /** Contract preflight: throws before any store-touching work. */
 function recallWindowSize(opts) {
     // F5 (v1.6.5) preflight — codex P1: original guard fired AFTER
@@ -564,9 +599,9 @@ function recallFrom(ctx, opts, windowSize, all) {
         // handle. v1.11.5 contract lock holds — api.recall does NOT write
         // last_trace_id (tests/api-recall-no-side-effects.test.ts); a trace INSERT
         // is the same observability class as the audit row it sits beside, not
-        // retrieval state. F2 fix: suppressed when the caller (currently only the
-        // MCP handler) traces its own, different result set — see
-        // opts.suppressRecallTrace JSDoc. Fail-soft internally; never throws.
+        // retrieval state. F2 fix: suppressed when the caller traces its own,
+        // different result set (retrieve under showRanked traces the shown list as
+        // 'mcp'). Fail-soft internally; never throws.
         if (!opts.suppressRecallTrace) {
             writeRecallTrace(db, {
                 tenantId: ctx.tenantId,
@@ -656,7 +691,7 @@ function recallFrom(ctx, opts, windowSize, all) {
     // detect call returns null and api.recall's anchoringHint stays absent.
     let anchoringHint = null;
     let suppressedByInterferenceCount = 0;
-    if (process.env.HIPPO_ANCHORING !== 'off' && opts.recallHistory) {
+    if (biasHintEnabled('anchoring') && opts.recallHistory) {
         const queryHash = hashQueryText(opts.query);
         const topMemoryId = rankedOut[0]?.id ?? null;
         anchoringHint = detectAnchoring(opts.recallHistory, queryHash, topMemoryId);
@@ -709,7 +744,7 @@ function recallFrom(ctx, opts, windowSize, all) {
     // opts.recallHistory gate above so we never double-emit the audit op. Audit
     // emission is pipeline-local, mirroring the J1 block above.
     let availabilityHint = null;
-    if (process.env.HIPPO_AVAILABILITY !== 'off' && !opts.suppressAvailabilityHint) {
+    if (biasHintEnabled('availability') && !opts.suppressAvailabilityHint) {
         availabilityHint = detectAvailabilityBias({
             topK: baseSlice.map((e) => ({ id: e.id, created: e.created })),
             pool: entries.map((e) => ({ id: e.id, created: e.created })),
@@ -1551,6 +1586,8 @@ export async function getContext(ctx, opts = {}) {
     const limit = opts.limit ?? Number.POSITIVE_INFINITY;
     const includeRecent = opts.includeRecent ?? 0;
     const activeScope = opts.scope ?? '';
+    assertScopeRequestAllowed(ctx.actor, opts.exactScope);
+    const exactScope = opts.exactScope || undefined;
     if (budget <= 0) {
         return { entries: [], tokens: 0 };
     }
@@ -1562,10 +1599,7 @@ export async function getContext(ctx, opts = {}) {
     const primaryIsGlobal = isGlobalStoreRoot(ctx.hippoRoot);
     const hasLocalTaskState = hasLocal && !primaryIsGlobal;
     // v39 memory scope isolation (docs/plans/2026-07-01-memory-scope-isolation.md).
-    // S2: envelope-filter parity with api.recall for AMBIENT context - private
-    // scopes and quarantine buckets never inject. `requested` is deliberately
-    // undefined: opts.scope is the scope-TAG boost input here, not an
-    // envelope-scope request (api.recall's exact-match semantics don't apply).
+    // S2: envelope-filter parity with api.recall; opts.scope is only the tag boost, opts.exactScope the envelope request.
     // S3: origin partition - other-project memories are excluded unless the
     // caller explicitly asks for them (crossProject) or isolation is disabled.
     const config = loadConfig(ctx.hippoRoot);
@@ -1612,9 +1646,8 @@ export async function getContext(ctx, opts = {}) {
             sessionId: opts.currentSessionId,
         })
         : null;
-    // W1: pre-existing leak; same `requested: undefined` ambientAdmitEntry
-    // already uses when it scope-filters memory rows above.
-    const activeSnapshot = rawActiveSnapshot && passesScopeFilterForRecall(rowScope(rawActiveSnapshot), undefined)
+    // W1: the same envelope rule ambientAdmitEntry applies to memory rows.
+    const activeSnapshot = rawActiveSnapshot && passesScopeFilterForRecall(rowScope(rawActiveSnapshot), exactScope)
         ? rawActiveSnapshot
         : null;
     // Key on the RAW snapshot: a scope-hidden active session must not fall through to another session's ambient handoff.
@@ -1628,7 +1661,7 @@ export async function getContext(ctx, opts = {}) {
                 // codex P2: admit scope in SQL so a newer denied row can't hide an older eligible one before LIMIT 1.
                 scopeFilter: 'default-deny',
             });
-    const sessionHandoff = rawSessionHandoff && passesScopeFilterForRecall(rowScope(rawSessionHandoff), undefined)
+    const sessionHandoff = rawSessionHandoff && passesScopeFilterForRecall(rowScope(rawSessionHandoff), exactScope)
         ? rawSessionHandoff
         : null;
     // Raw session id here too: each event is admitted on its own scope, same as recall and the CLI.
@@ -1636,7 +1669,7 @@ export async function getContext(ctx, opts = {}) {
         ? listSessionEvents(ctx.hippoRoot, ctx.tenantId, {
             session_id: rawActiveSnapshot.session_id,
             limit: 5,
-        }).filter((e) => passesScopeFilterForRecall(rowScope(e), undefined))
+        }).filter((e) => passesScopeFilterForRecall(rowScope(e), exactScope))
         : [];
     const shownSnapshot = activeSnapshot && (!cost || pays(cost.snapshot(activeSnapshot))) ? activeSnapshot : null;
     const shownHandoff = sessionHandoff && (!cost || pays(cost.handoff(sessionHandoff))) ? sessionHandoff : null;
@@ -1650,7 +1683,7 @@ export async function getContext(ctx, opts = {}) {
             digestHiddenForHandoff = true;
             return false;
         }
-        return ambientAdmitEntry(e, currentProjectName, includeCrossProject);
+        return ambientAdmitEntry(e, currentProjectName, includeCrossProject, exactScope);
     };
     const ownSessionId = opts.currentSessionId || '';
     // Inside admit, not after the load, so the loader's window widens past a session's own items.

package/dist/card-detail.d.ts

@@ -1,6 +1,6 @@
 import type { Card, CardComment, CardRun } from './card.js';
 import type { SessionHandoff } from './handoff.js';
-import { loadCardDeps } from './store.js';
+import { loadCardDeps } from './store-cards.js';
 /** A card plus everything `hippo card show` prints about it. */
 export interface CardDetail {
     card: Card;

package/dist/card-detail.js

@@ -1,4 +1,4 @@
-import { loadCard, loadCardComments, loadCardDeps, loadCardRuns, loadLatestHandoffForCard } from './store.js';
+import { loadCard, loadCardComments, loadCardDeps, loadCardRuns, loadLatestHandoffForCard } from './store-cards.js';
 /** Loads the detail behind `hippo card show` and `GET /api/cards/:id` (null when the tenant has no such card); five separate reads, so a write landing between them can show a mixed view, as `card show` always could. */
 export function loadCardDetail(hippoRoot, tenantId, id) {
     const card = loadCard(hippoRoot, tenantId, id);

package/dist/cli/shared.d.ts

@@ -0,0 +1,137 @@
+import { TaskSnapshot, SessionEvent } from '../store.js';
+import type { HandoffEvidence, SessionHandoff } from '../handoff.js';
+import { type SearchResult } from '../search.js';
+import { type HippoConfig } from '../config.js';
+import { openHippoDb } from '../db.js';
+import { type ImportReport } from '../agent-memories/report.js';
+import { type ChurnStaleResult } from '../invalidation.js';
+import { type AuditOp } from '../audit.js';
+import { type ServerInfo } from '../server-detect.js';
+import type { RecallSearchOpts } from '../recall-pipeline.js';
+export declare function parseLimitFlag(value: string | boolean | string[] | undefined): number;
+export declare function parseCountFlag(value: string | boolean | string[] | undefined): number;
+export declare function parseBudgetFlag(value: string | boolean | string[] | undefined, fallback: number): number;
+/**
+ * Emit an audit event against `hippoRoot`'s db. Opens its own short-lived
+ * connection so callers don't have to thread a db handle. Swallows all errors
+ * — audit must never crash a CLI command.
+ */
+export declare function emitCliAudit(hippoRoot: string, op: AuditOp, targetId?: string, metadata?: Record<string, unknown>): void;
+export declare function requireInit(hippoRoot: string): void;
+/** Runs detectChurnStale against every store this repo's memories can live in. */
+export declare function runChurnStaleForRepo(hippoRoot: string, dryRun: boolean): {
+    root: string;
+    result: ChurnStaleResult;
+}[];
+/**
+ * Run an HTTP-routed command if a `hippo serve` instance is detected for
+ * `hippoRoot`. Returns:
+ *   - true  if the HTTP path ran (success OR a structured server error that
+ *           was already surfaced to stdout/stderr by `httpFn`),
+ *   - false if no server was detected, or if the detected pidfile turned out
+ *           to be stale (connection refused). On stale, the pidfile is removed
+ *           if it still names that dead server (a newer one may have replaced
+ *           it) and the caller should fall back to the direct path.
+ *
+ * Stale pidfiles must self-heal, not crash.
+ * When HIPPO_REQUIRE_SERVER is set, both fallback paths throw instead of
+ * returning false, so a missing server fails loudly rather than silently
+ * degrading to direct mode.
+ */
+export declare function runViaServerIfAvailable(hippoRoot: string, httpFn: (info: ServerInfo, apiKey: string | undefined) => Promise<void>): Promise<boolean>;
+export declare function fmt(n: number, digits?: number): string;
+export declare function recallEntryText(r: SearchResult, query: string, showWhy: boolean, isGlobal: boolean): string;
+export declare function recallHeading(entries: number, tokens: number, query: string): string;
+/** One line when an agent memory import moved anything; its warnings go to stderr. */
+export declare function printAgentImport(report: ImportReport, indent?: string): void;
+/** The first hippo block in `text` and the agent whose current or shipped text it is; `owner` is undefined for an edited block. */
+export declare function hippoBlock(text: string): {
+    start: number;
+    end: number;
+    eol: string;
+    inner: string;
+    owner?: string;
+} | null;
+/** Adds hippo's two Codex hooks and says what changed; each install ends on the trust reminder, since Codex skips an untrusted hook. */
+export declare function installCodexMemoryHooks(indent: string): void;
+/**
+ * Set up a machine-level daily runner that sweeps all registered Hippo
+ * workspaces.
+ * Linux/macOS: writes to user crontab.
+ * Windows: creates a scheduled task.
+ * Skips if already installed.
+ */
+export declare function setupDailySchedule(globalRoot: string): void;
+export type CliFlags = Record<string, string | boolean | string[]>;
+export type EngineFlags = Pick<RecallSearchOpts, 'usePhysics' | 'physicsConfig' | 'mmr' | 'mmrLambda' | 'localBump'>;
+export declare function parseAsOfFlag(flags: CliFlags): string | undefined;
+/** --physics forces physics, --classic forces BM25+cosine, else physics unless the config turns it off. */
+export declare function engineFlags(flags: CliFlags, config: HippoConfig): EngineFlags;
+/**
+ * Detached worker that counts re-reads, runs sleep, then capture. Invoked via the internal
+ * `__session-end-worker` subcommand (not user-facing). Failures in one stage
+ * do not block the other.
+ */
+export declare function collectHandoffEvidence(cwd: string, testStatus: HandoffEvidence['testStatus']): HandoffEvidence;
+/** A folder without its own store never sleeps at session end, so its project's agent notes go to the global store here. */
+export declare function logSessionEndImport(logFile: string | null, transcriptPath: string | undefined): void;
+/**
+ * Best-effort log line for the snapshot-close step in
+ * `cmdSessionEndWorker`. `cmdSleep`/`cmdCapture` each tee console output to
+ * `logFile` only for their own duration (the tee is restored before this
+ * runs), so a plain `console.log` here would be silently discarded under
+ * the detached worker's `stdio: 'ignore'` — write straight to the file
+ * instead, matching capture.ts's `appendPreCompactLog` convention.
+ */
+export declare function appendSessionEndCloseLog(logFile: string | null, message: string, opts?: {
+    startFresh?: boolean;
+}): void;
+export declare function printActiveTaskSnapshot(snapshot: TaskSnapshot): void;
+export declare function printSessionEvents(events: SessionEvent[]): void;
+export declare function printHandoff(handoff: SessionHandoff): void;
+export declare function cardStringFlag(flags: Record<string, string | boolean | string[]>, key: string): string | undefined;
+export declare function hostSessionId(): string | undefined;
+/**
+ * Compaction drops the pinned blocks the per-prompt hook injected
+ * earlier, so record a `reset` for the payload's session and the next prompt
+ * injects again even if nothing changed. `requiredSource` limits it to hook
+ * payloads with that `source` (SessionStart fires for other reasons too).
+ * Best-effort and silent: a malformed payload records nothing.
+ */
+export declare function resetHookInjection(hippoRoot: string, stdinText: string | undefined, requiredSource: string | null): void;
+/**
+ * Run `fn` with console.log captured; returns the captured lines joined by
+ * newlines (what the same calls would have printed, minus the final newline).
+ */
+export declare function captureConsole(fn: () => void): string;
+/**
+ * The store a Claude Code hook writes to: the project store when there is
+ * one, else an existing global store, else the project path (which the hook
+ * then skips, since hooks fire in every directory and must not create one).
+ * Pre-compact and compact-resume must agree, or a snapshot saved to one store
+ * is looked for in the other.
+ */
+export declare function hookStoreRoot(hippoRoot: string): string;
+/**
+ * Run `fn` against the token ledger's store: the local store when it is
+ * initialized, else the global one (the per-prompt hook runs in directories
+ * without a local store). Best-effort: returns undefined and never throws,
+ * because a ledger failure must not break context or recall.
+ */
+export declare function withLedgerDb<T>(hippoRoot: string, fn: (db: ReturnType<typeof openHippoDb>) => T): T | undefined;
+export declare function learnFromRepo(hippoRoot: string, repoPath: string, days: number, label?: string): {
+    added: number;
+    skipped: number;
+    lowInfo: number;
+};
+export declare const HOOK_MARKERS: {
+    start: string;
+    end: string;
+};
+export declare const HOOKS: Record<string, {
+    file: string;
+    content: string;
+    description: string;
+}>;
+export declare function resolveAuthRoot(hippoRoot: string, flags: Record<string, string | boolean | string[]>): string;
+//# sourceMappingURL=shared.d.ts.map