hippo-memory 1.69.0 → 1.71.0

package/dist/{autolearn.js → learn/autolearn.js}

@@ -1,20 +1,20 @@
-/**
- * Auto-learn from errors and git history.
- * Agents learn from failures without explicit hippo remember calls.
- */
+/** Auto-learn from errors and git history.
+ *  Agents learn from failures without explicit hippo remember calls. */
 import { execSync, execFileSync, spawn } from 'child_process';
-import { createMemory, Layer, DEFAULT_HALF_LIFE_DAYS } from './memory.js';
-import { loadAllEntries } from './store/entry-reads.js';
-import { textOverlap } from './tokenize.js';
-import { assessAutomaticMemory } from './memory-quality.js';
-import { redactSecretsStrict } from './secret-detect.js';
-import { log } from './log.js';
-/** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; no store is in reach, so `hippo watch` re-derives its half-life from the store's config. */
+import { createMemory, Layer, DEFAULT_HALF_LIFE_DAYS } from '../core/memory.js';
+import { loadAllEntries } from '../store/entry-reads.js';
+import { textOverlap } from '../util/tokenize.js';
+import { assessAutomaticMemory } from '../core/memory-quality.js';
+import { redactSecretsStrict } from '../util/secret-detect.js';
+import { errorMessage, log } from '../util/log.js';
+const AUTOLEARN_TEXT_CHARS = 500;
+const AUTOLEARN_TAG_CHARS = 30;
+/** A memory of a failed command, "Command '<cmd>' failed: <truncated stderr>"; `hippo watch` stores its text and tags through remember. */
 export function captureError(exitCode, stderr, command, tenantId) {
     // Truncate to first 500 chars to avoid storing megabytes of build logs
     const clean = redactSecretsStrict(stderr);
     const wasTruncated = clean.length > 500;
-    const truncated = clean.slice(0, 500).trim();
+    const truncated = clean.slice(0, AUTOLEARN_TEXT_CHARS).trim();
     const suffix = wasTruncated ? ' [truncated]' : '';
     // Strip leading env var assignments (KEY=val or key=val) before the actual command name
     const safeCmd = redactSecretsStrict(command.replace(/^([A-Za-z_][A-Za-z0-9_]*=\S+\s+)+/, '').trim()) || '(redacted)';
@@ -23,7 +23,7 @@ export function captureError(exitCode, stderr, command, tenantId) {
     const cmdBase = safeCmd.split(/\s+/)[0].replace(/[^a-zA-Z0-9-]/g, '');
     const tags = ['error', 'autolearn'];
     if (cmdBase)
-        tags.push(cmdBase.toLowerCase().slice(0, 30));
+        tags.push(cmdBase.toLowerCase().slice(0, AUTOLEARN_TAG_CHARS));
     return createMemory(content, {
         layer: Layer.Episodic,
         tags,
@@ -33,10 +33,8 @@ export function captureError(exitCode, stderr, command, tenantId) {
         baseHalfLifeDays: DEFAULT_HALF_LIFE_DAYS,
     });
 }
-/**
- * Parse git log output for actionable lessons.
- * Looks for fix:, revert:, bug:, error:, hotfix: commit messages.
- */
+/** Parse git log output for actionable lessons.
+ *  Looks for fix:, revert:, bug:, error:, hotfix: commit messages. */
 export function extractLessons(gitLog, customPatterns) {
     const lessons = [];
     const lines = gitLog.split('\n');
@@ -71,18 +69,8 @@ export function extractLessons(gitLog, customPatterns) {
     // Deduplicate exact matches at extraction time
     return [...new Set(lessons)];
 }
-/**
- * Split parsed lessons into ones worth storing and low-information ones.
- *
- * `extractLessons` is a published API surface (exported from src/index.ts)
- * and does one job: parse a git log into candidate lesson strings. Adding a
- * quality check inside it would break that contract and silently change
- * what external callers get back. So parsing and admission are separate
- * steps: this function is the write-path gate, called by each caller that
- * actually stores a lesson, not by the parser itself.
- *
- * Order is preserved in both output arrays; both hold lessons with secret shapes redacted.
- */
+/** Split parsed lessons into ones worth storing and low-information ones; kept out of `extractLessons` so that published parser's output cannot change.
+ *  Order is preserved in both arrays, and both hold lessons with secret shapes redacted. */
 export function partitionLessons(lessons) {
     const kept = [];
     const dropped = [];
@@ -96,15 +84,8 @@ export function partitionLessons(lessons) {
     }
     return { kept, dropped };
 }
-/**
- * Check if a substantially similar memory already exists.
- * Returns true if overlap > threshold (default 0.7).
- *
- * `tenantId` is opt-in. Only takes effect when the first argument is a
- * root string (string-overload path). When the first argument is a
- * pre-loaded MemoryEntry[], the caller has already scoped — tenantId is
- * ignored on that path.
- */
+/** Check if a substantially similar memory already exists: true if overlap > threshold (default 0.7).
+ *  `tenantId` applies only on the root-string overload; a pre-loaded MemoryEntry[] is already scoped, so it is ignored there. */
 export function deduplicateLesson(hippoRootOrEntries, lesson, threshold = 0.7, tenantId) {
     const entries = Array.isArray(hippoRootOrEntries)
         ? hippoRootOrEntries
@@ -116,10 +97,8 @@ export function deduplicateLesson(hippoRootOrEntries, lesson, threshold = 0.7, t
     }
     return false;
 }
-/**
- * Run a command, streaming stdout/stderr to the terminal in real time.
- * Returns: { exitCode, stderr }.
- */
+/** Run a command in a shell, streaming stderr live; never pass text the caller did not write.
+ *  Returns: { exitCode, stderr }. */
 export function runWatched(command) {
     return new Promise((resolve) => {
         // Use shell: true so the command string is handled by the shell as-is
@@ -141,9 +120,7 @@ export function runWatched(command) {
         });
     });
 }
-/**
- * Check whether a directory is a git work tree.
- */
+/** Check whether a directory is a git work tree. */
 export function isGitRepo(cwd) {
     try {
         const raw = execSync('git rev-parse --is-inside-work-tree', {
@@ -156,14 +133,12 @@ export function isGitRepo(cwd) {
         return raw.trim() === 'true';
     }
     catch (err) {
-        log.debug(`autolearn: not a git repo: ${err instanceof Error ? err.message : String(err)}`);
+        log.debug(`autolearn: not a git repo: ${errorMessage(err)}`);
         return false;
     }
 }
-/**
- * Fetch recent git log lines (subject lines only).
- * days: how many days of history to include.
- */
+/** Fetch recent git log lines (subject lines only).
+ *  days: how many days of history to include. */
 export function fetchGitLog(cwd, days) {
     try {
         const raw = execFileSync('git', [
@@ -172,7 +147,7 @@ export function fetchGitLog(cwd, days) {
         return raw;
     }
     catch (err) {
-        log.debug(`autolearn: git log unavailable: ${err instanceof Error ? err.message : String(err)}`);
+        log.debug(`autolearn: git log unavailable: ${errorMessage(err)}`);
         return '';
     }
 }

package/dist/{churn-git.d.ts → learn/churn-git.d.ts}

@@ -1,4 +1,4 @@
-/** Git subprocess helpers for churn-staleness (src/invalidation.ts). */
+/** Git subprocess helpers for churn-staleness (src/learn/invalidation.ts). */
 /** A real git failure (not git grep's expected exit-1-no-match). Callers abort the whole run on this. */
 export declare class GitReadError extends Error {
 }

package/dist/{churn-git.js → learn/churn-git.js}

@@ -1,8 +1,10 @@
-/** Git subprocess helpers for churn-staleness (src/invalidation.ts). */
+/** Git subprocess helpers for churn-staleness (src/learn/invalidation.ts). */
 import { execFileSync } from 'child_process';
 import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
+import { DAY_MS } from '../util/time.js';
+import { errorMessage } from '../util/log.js';
 // A `git log --name-status` dump can run to tens of MB; default 1MB pipe would truncate it.
 const GIT_MAX_BUFFER = 64 * 1024 * 1024;
 // Longer than the 10 s of one-line git reads because a full log dump on a large repo is slow, yet bounded so a wedged git cannot stall sleep.
@@ -15,7 +17,7 @@ function runGit(args, repoRoot) {
         return execFileSync('git', args, { cwd: repoRoot, encoding: 'utf8', maxBuffer: GIT_MAX_BUFFER, timeout: GIT_TIMEOUT_MS, windowsHide: true });
     }
     catch (err) {
-        throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
+        throw new GitReadError(`git ${args.join(' ')} failed: ${errorMessage(err)}`, { cause: err });
     }
 }
 // git grep exits 1 for "no match" -- a normal empty result, not a failure.
@@ -28,7 +30,7 @@ function runGitGrepOrEmpty(args, repoRoot) {
         const status = err.status;
         if (status === 1)
             return '';
-        throw new GitReadError(`git ${args.join(' ')} failed: ${err instanceof Error ? err.message : String(err)}`);
+        throw new GitReadError(`git ${args.join(' ')} failed: ${errorMessage(err)}`, { cause: err });
     }
 }
 // ls-tree, not ls-files: the index can hold staged adds/deletes that HEAD does not.
@@ -38,7 +40,7 @@ export function gitLsFilesAtHead(repoRoot) {
 }
 // 1-day buffer guards against git's --since boundary excluding a commit dated exactly at the anchor.
 export function fetchChurnWindowLog(repoRoot, sinceIso) {
-    const buffered = new Date(new Date(sinceIso).getTime() - 24 * 60 * 60 * 1000).toISOString();
+    const buffered = new Date(new Date(sinceIso).getTime() - DAY_MS).toISOString();
     const raw = runGit(
     // --first-parent -m: a merge's changes land as one diff against its mainline parent.
     ['log', '--no-renames', '--first-parent', '-m', `--since=${buffered}`, '--pretty=format:%x01%H%x02%cI', '--name-status'], repoRoot);

package/dist/{extract.d.ts → learn/extract.d.ts}

@@ -1,4 +1,4 @@
-import { MemoryEntry, EmotionalValence } from './memory.js';
+import { MemoryEntry, EmotionalValence } from '../core/memory.js';
 export interface ExtractedFact {
     content: string;
     tags: string[];

package/dist/learn/extract.js

@@ -0,0 +1,123 @@
+import { Layer, createMemory } from '../core/memory.js';
+import { writeEntry } from '../store/entry-writes.js';
+import { loadConfig } from '../core/config.js';
+import { RejectedValueError } from '../store/rejection.js';
+import { redactSecretsStrict } from '../util/secret-detect.js';
+import { describeMessageFailure, sendAnthropicMessage } from '../util/anthropic-messages.js';
+import { neverAutoShareTags } from '../sharing/share.js';
+import { errorMessage, log } from '../util/log.js';
+import { isJsonString } from '../util/json.js';
+import { certainDefect } from '../core/memory-quality.js';
+const EXTRACTION_PROMPT = `You are extracting factual statements from a conversation or memory entry. Extract 1-8 standalone factual statements that would be useful to remember later.
+
+Rules:
+- Each fact must be a complete, standalone sentence
+- Include the speaker's name in every fact (e.g. "Alice prefers..." not "She prefers...")
+- Preserve specific details: names, numbers, dates, paths, IDs
+- Return a JSON array of objects with: content (string), tags (array of "speaker:X" and "topic:Y" strings), valence ("neutral", "positive", "negative", or "critical")
+- Return an empty array [] for small talk with no extractable facts
+- Output ONLY the JSON array, no preamble or explanation
+
+Input text:
+`;
+// Output budget for one extraction reply.
+const EXTRACTION_MAX_TOKENS = 1200;
+export async function extractFacts(text, opts) {
+    const reply = await sendAnthropicMessage({
+        apiKey: opts.apiKey,
+        model: opts.model,
+        maxTokens: EXTRACTION_MAX_TOKENS,
+        prompt: EXTRACTION_PROMPT + redactSecretsStrict(text),
+        fetcher: opts.fetcher,
+    });
+    if (!reply.ok) {
+        opts.onError?.(describeMessageFailure(reply.failure));
+        return [];
+    }
+    try {
+        const raw = reply.text;
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parseExtractedFacts(parsed);
+    }
+    catch (err) {
+        opts.onError?.(`unparseable response: ${errorMessage(err)}`);
+        return [];
+    }
+}
+function parseExtractedFacts(parsed) {
+    const validValences = new Set(['neutral', 'positive', 'negative', 'critical']);
+    const facts = [];
+    for (const item of parsed) {
+        if (facts.length >= 8)
+            break;
+        if (!item ||
+            !isJsonString(item.content) ||
+            item.content.length < 3)
+            continue;
+        const itemTags = item.tags;
+        const tags = Array.isArray(itemTags)
+            ? itemTags.filter((t) => isJsonString(t))
+            : [];
+        // SAFETY: the isJsonString + validValences.has guard below confirms item.valence is one of the four literal strings of EmotionalValence.
+        const valence = isJsonString(item.valence) && validValences.has(item.valence)
+            ? item.valence
+            : 'neutral';
+        facts.push({ content: item.content, tags, valence });
+    }
+    return facts;
+}
+const INHERITABLE_PREFIXES = ['conv:', 'session:', 'scope:', 'path:'];
+export function storeExtractedFacts(hippoRoot, source, facts) {
+    const inheritedTags = [
+        ...source.tags.filter((t) => INHERITABLE_PREFIXES.some((p) => t.startsWith(p))),
+        ...neverAutoShareTags([source]),
+    ];
+    const entries = [];
+    let rejected = 0;
+    const baseHalfLifeDays = loadConfig(hippoRoot).defaultHalfLifeDays;
+    for (const fact of facts) {
+        const defect = certainDefect(fact.content);
+        if (defect !== null) {
+            log.warn(`storeExtractedFacts: skipped automatic quality defect (${defect})`);
+            continue;
+        }
+        const entry = buildExtractedEntry(fact, source, inheritedTags, baseHalfLifeDays);
+        // A refusal is per-VALUE: one rejected fact must not drop the rest of the batch; writeEntry already audited it (reject_refusal), so skip and count.
+        try {
+            writeEntry(hippoRoot, entry);
+        }
+        catch (err) {
+            if (err instanceof RejectedValueError) {
+                rejected++;
+                continue;
+            }
+            throw err;
+        }
+        entries.push(entry);
+    }
+    if (rejected > 0) {
+        log.warn(`storeExtractedFacts: skipped ${rejected} rejected value(s)`);
+    }
+    return entries;
+}
+function buildExtractedEntry(fact, source, inheritedTags, baseHalfLifeDays) {
+    const tags = ['extracted', ...inheritedTags, ...fact.tags];
+    return { ...createMemory(fact.content, {
+            layer: Layer.Semantic,
+            tags,
+            emotional_valence: fact.valence,
+            confidence: 'inferred',
+            source: source.source,
+            extracted_from: source.id,
+            scope: source.scope,
+            // Without it createMemory stamps 'default', and extracted facts leave
+            // the tenant of the episodic memory they were extracted from.
+            tenantId: source.tenantId,
+            baseHalfLifeDays,
+        }), origin_project: source.origin_project };
+}
+//# sourceMappingURL=extract.js.map

package/dist/learn/forward-claim-detector.d.ts

@@ -0,0 +1,12 @@
+/** Forward-claim detector: a pure regex set plus token extraction deciding whether a recall query carries a forward-prediction phrase.
+ *  Calibration is HIGH-PRECISION / LOW-RECALL, since cry-wolf noise dominates hint UX; `recall_autodebias_hint_no_class_match` audits are the telemetry. */
+export interface ForwardClaimMatch {
+    /** The regex match snippet (e.g. "will take"), surfaced in `PlanningFallacyHint.detectedPhrase` so the agent sees WHY the hint appeared. */
+    phrase: string;
+    /** Lower-cased non-stop-word tokens (len >= 3) from the FULL query, not just the match; the class resolver scores them against class_tag tokens. */
+    classQueryTokens: string[];
+}
+/** Detect whether a recall query carries a forward-prediction phrase; returns the first-match phrase plus class-resolution tokens, else null.
+ *  Token extraction runs only on a match, so non-forward queries pay nothing beyond the regex gate. */
+export declare function detectForwardClaim(queryText: string): ForwardClaimMatch | null;
+//# sourceMappingURL=forward-claim-detector.d.ts.map

package/dist/learn/forward-claim-detector.js

@@ -0,0 +1,60 @@
+/** Forward-claim detector: a pure regex set plus token extraction deciding whether a recall query carries a forward-prediction phrase.
+ *  Calibration is HIGH-PRECISION / LOW-RECALL, since cry-wolf noise dominates hint UX; `recall_autodebias_hint_no_class_match` audits are the telemetry. */
+/** Each pattern is deliberately narrow (add one only on audit evidence); word boundaries are mandatory so `ETA` never matches inside `BETAtesting`. */
+// Shared duration suffix: needs a digit + unit (`<N> unit`, `a/an unit`, `one unit`) so 'will take ownership' and 'ship in Docker' do not match.
+const DURATION_TAIL = String.raw `(?:about|around|~|≈)?\s*(?:\d+|a|an|one)\s*(?:day|week|month|hour|hr|min(?:ute)?|sec(?:ond)?)s?\b`;
+const FORWARD_CLAIM_PATTERNS = [
+    // Verb + duration tail: requires `<verb> take <N> <unit>`, because a bare `will take` matched `who will take ownership of auth?`.
+    new RegExp(String.raw `\b(?:will|should|gonna|going\s+to)\s+take\s+${DURATION_TAIL}`, 'i'),
+    // Ship + by/in + duration-or-day: a bare `ship in` matched `how does this ship in Docker?`, so a duration tail or literal day-of-week is required.
+    new RegExp(String.raw `\bship(?:ping|s)?\s+(?:by|in)\s+(?:(?:about|around)\s+)?(?:next\s+)?(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
+    /\bestimate(?:d)?\s+(?:at\s+)?(?:~|≈|about|around)?\s*\d+/i,
+    /\b(?:by|in|within)\s+(?:about|around|~)?\s*\d+\s*(?:day|week|month|hour)s?\b/i,
+    /\bETA\s*(?:is|:)?\s*\d+/i,
+    /\b(?:by|before)\s+next\s+(?:week|month|sprint|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/i,
+    // Standalone tilde duration ('~3 days for migration'): the lookbehind asserts start-of-string or whitespace because `\b` before `~` needs a word char
+    // and /\b~/ would only match 'foo~3 days', silently missing the real cases.
+    /(?<=^|\s)~\s*\d+\s*(?:day|week|month|hour)s?\b/i,
+    // Should + verb + duration tail. Same tightening as the leading 'will
+    // take' rule: 'should ship by EOD' must include a quantifier.
+    new RegExp(String.raw `\bshould\s+(?:be|ship|finish|complete|land)\s+(?:by|in|within)\s+(?:(?:about|around)\s+)?(?:next\s+)?(?:${DURATION_TAIL}|(?:monday|tuesday|wednesday|thursday|friday|saturday|sunday))\b`, 'i'),
+];
+/** Pronouns, function words and modal verbs the regex set already gates on; dropped before class resolution so overlap comes from domain tokens. */
+const STOP_WORDS = new Set([
+    'the', 'a', 'an', 'and', 'or', 'but', 'for', 'to', 'in', 'on', 'at', 'of',
+    'by', 'with', 'my', 'your', 'our', 'their', 'its', 'it', 'this', 'that',
+    'these', 'those', 'will', 'should', 'can', 'i', 'we', 'they', 'he', 'she',
+    'is', 'be', 'was', 'are', 'were', 'has', 'have', 'had', 'do', 'does', 'did',
+    'from', 'as', 'so', 'than', 'then',
+    // Verbs inside FORWARD_CLAIM_PATTERNS gate the regex but are no signal for class resolution; listing them keeps them out of the classQueryTokens overlap.
+    'take', 'taken', 'takes', 'ship', 'ships', 'finish', 'complete', 'land',
+    'eta', 'estimate', 'estimated', 'next', 'about', 'around',
+    // Every forward-claim phrase contains a duration unit by design; letting it through would let a class tag containing 'days' win or tie on the unit.
+    'day', 'days', 'week', 'weeks', 'month', 'months',
+    'hour', 'hours', 'hr', 'hrs',
+    'min', 'mins', 'minute', 'minutes', 'sec', 'secs', 'second', 'seconds',
+]);
+/** Detect whether a recall query carries a forward-prediction phrase; returns the first-match phrase plus class-resolution tokens, else null.
+ *  Token extraction runs only on a match, so non-forward queries pay nothing beyond the regex gate. */
+export function detectForwardClaim(queryText) {
+    if (!queryText)
+        return null;
+    for (const pat of FORWARD_CLAIM_PATTERNS) {
+        const m = queryText.match(pat);
+        if (m) {
+            const tokens = extractClassQueryTokens(queryText);
+            return { phrase: m[0], classQueryTokens: tokens };
+        }
+    }
+    return null;
+}
+function extractClassQueryTokens(queryText) {
+    return queryText
+        .toLowerCase()
+        // Strip everything that's not alphanum or whitespace or hyphen / underscore.
+        .replace(/[^a-z0-9\s_-]/g, ' ')
+        // Split on whitespace, hyphen and underscore so `migration-effort` yields ['migration', 'effort'], matching the class-tag split in resolveClassFromTokens.
+        .split(/[\s_-]+/)
+        .filter((t) => t.length >= 3 && !STOP_WORDS.has(t) && !/^\d+$/.test(t));
+}
+//# sourceMappingURL=forward-claim-detector.js.map

package/dist/{invalidation.d.ts → learn/invalidation.d.ts}

@@ -1,3 +1,4 @@
+import { type MemoryEntry } from '../core/memory.js';
 export interface InvalidationTarget {
     from: string;
     to: string | null;
@@ -19,25 +20,15 @@ export interface InvalidationOptions {
     /** Consider ONLY this memory id (no content/tag matching). */
     onlyId?: string;
 }
-/**
- * Extract what was replaced/removed from a commit message.
- * Returns null if the commit isn't a breaking/migration change.
- */
+/** Extract what was replaced/removed from a commit message.
+ *  Returns null if the commit isn't a breaking/migration change. */
 export declare function extractInvalidationTarget(message: string): InvalidationTarget | null;
-/**
- * Find memories that reference the invalidated pattern and weaken them.
- * - Halves half_life_days
- * - Sets confidence to 'stale'
- * - Adds 'invalidated' tag
- * - Skips pinned memories (reported in skippedPinned)
- *
- * Tag matching is EXACT (2026-06-09 incident): the FULL pattern must equal a
- * tag. Token-level matching applies to content only, so a pattern that merely
- * CONTAINS a common tag word ("hippo") can no longer mass-weaken every memory
- * carrying that tag. Both callers (the CLI `invalidate` command and the
- * auto-learn-from-git path) inherit this contract.
- */
+/** Find memories that reference the invalidated pattern and weaken them (halve half_life_days, confidence 'stale', add 'invalidated' tag; pinned are skipped).
+ *  Tag matching is EXACT: the FULL pattern must equal a tag, so a pattern merely containing a common tag word cannot mass-weaken every memory with that tag. */
 export declare function invalidateMatching(hippoRoot: string, target: InvalidationTarget, tenantId?: string, options?: InvalidationOptions): InvalidationResult;
+/** invalidateMatching for a batch: matches against `live`, the caller's list of the tenant's rows, and keeps it current.
+ *  Each match is read again before it is weakened, so a row another writer changed since the list was read is never written back stale. */
+export declare function invalidateMatchingAmong(hippoRoot: string, live: MemoryEntry[], target: InvalidationTarget, tenantId?: string): InvalidationResult;
 export interface ChurnRefs {
     paths: string[];
     symbols: string[];
@@ -69,6 +60,7 @@ export interface ChurnStaleResult {
     preview: ChurnStalePreviewRow[];
     error?: string;
 }
-/** Flags memories whose named file/symbol/script changed or disappeared since storage (or last confirmation); only adds/removes CHURN_STALE_TAG, never confidence/half-life/strength. */
+/** Flags memories whose named file/symbol/script changed or disappeared since storage (or last
+ * confirmation); only adds/removes CHURN_STALE_TAG, never confidence/half-life/strength. */
 export declare function detectChurnStale(hippoRoot: string, repoRoot: string, opts: DetectChurnStaleOptions): ChurnStaleResult;
 //# sourceMappingURL=invalidation.d.ts.map