@remnic/core 9.65.8 → 9.66.0

package/dist/intent.d.ts

@@ -1,7 +1,6 @@
-import { aw as MemoryIntent, R as RecallPlanMode } from './types-djxQlxJ7.js';
+import { aw as MemoryIntent, R as RecallPlanMode } from './types-BRpcNjHZ.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
-import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/lcm/engine.d.ts

@@ -2,13 +2,12 @@ import { LcmStructuredRecallMatch, LcmMessage } from './archive.js';
 import { SummarizeFn } from '../context-summary.js';
 import { LcmRecallWithTraceResult } from './recall.js';
 import { LcmObserveMessage } from './queue.js';
-import { P as PluginConfig } from '../types-djxQlxJ7.js';
+import { P as PluginConfig } from '../types-BRpcNjHZ.js';
 import 'better-sqlite3';
 import '../message-parts/index.js';
 import '../token-estimate.js';
 import './dag.js';
 import '../bounded-jsonl-state.js';
-import '../types-CM86alG1.js';
 import '../operator-doctor-types.js';
 import '../external-wiki-config.js';
 import '../contradiction-config.js';

package/dist/lcm/index.d.ts

@@ -8,9 +8,8 @@ export { ensureLcmStateDir, openLcmDatabase } from './schema.js';
 export { SummarizeFn } from '../context-summary.js';
 import './queue.js';
 import '../message-parts/index.js';
-import '../types-djxQlxJ7.js';
+import '../types-BRpcNjHZ.js';
 import '../bounded-jsonl-state.js';
-import '../types-CM86alG1.js';
 import '../operator-doctor-types.js';
 import '../external-wiki-config.js';
 import '../contradiction-config.js';

package/dist/lcm/tools.d.ts

@@ -7,9 +7,8 @@ import '../context-summary.js';
 import './recall.js';
 import './dag.js';
 import './queue.js';
-import '../types-djxQlxJ7.js';
+import '../types-BRpcNjHZ.js';
 import '../bounded-jsonl-state.js';
-import '../types-CM86alG1.js';
 import '../operator-doctor-types.js';
 import '../external-wiki-config.js';
 import '../contradiction-config.js';

package/dist/lifecycle.d.ts

@@ -1,7 +1,6 @@
-import { W as LifecycleState, y as MemoryCategory, M as MemoryFile, m as MemoryFrontmatter } from './types-djxQlxJ7.js';
+import { W as LifecycleState, y as MemoryCategory, M as MemoryFile, m as MemoryFrontmatter } from './types-BRpcNjHZ.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
-import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/live-connectors-runner.d.ts

@@ -1,8 +1,7 @@
 import { L as LiveConnector, C as ConnectorConfig, a as ConnectorDocument } from './framework-CNDn2164.js';
-import { L as LiveConnectorsConfig } from './types-djxQlxJ7.js';
+import { L as LiveConnectorsConfig } from './types-BRpcNjHZ.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
-import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/local-llm.d.ts

@@ -1,8 +1,7 @@
-import { P as PluginConfig } from './types-djxQlxJ7.js';
+import { P as PluginConfig } from './types-BRpcNjHZ.js';
 import { ModelRegistry } from './model-registry.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
-import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/local-model-endpoint.d.ts

@@ -1,7 +1,6 @@
-import { P as PluginConfig } from './types-djxQlxJ7.js';
+import { P as PluginConfig } from './types-BRpcNjHZ.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
-import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/location/index.d.ts

@@ -1,5 +1,289 @@
-import { L as LocationProvider, a as LocationConfig, b as LocationPlace, c as LocationObservation, d as LocationSegment } from '../types-CM86alG1.js';
-export { e as LocationObservationPage, f as LocationProviderCheck, g as LocationSourceConfig } from '../types-CM86alG1.js';
+import { bi as LocationSegment, bj as LocationPlace, bk as LocationConfig, M as MemoryFile, aY as WearableConversation, P as PluginConfig, bl as LocationProvider, bm as LocationObservation } from '../types-BRpcNjHZ.js';
+export { bn as LocationObservationPage, bo as LocationProviderCheck, bp as LocationSourceConfig, bq as LocationTaggingConfig } from '../types-BRpcNjHZ.js';
+import { S as StorageManager } from '../storage-BQn-xnxm.js';
+import '../message-parts/index.js';
+import '../bounded-jsonl-state.js';
+import '../operator-doctor-types.js';
+import '../external-wiki-config.js';
+import '../contradiction-config.js';
+import '../graph-path-scoring-config.js';
+import '../causal-trajectory.js';
+import '../objective-state.js';
+import '../active-context-config.js';
+import '../types-continuity.js';
+import '../corpus-read-cancellation.js';
+import '../artifact-search.js';
+import '../active-context-transform.js';
+import '../context-summary.js';
+import '../entity-id-normalization.js';
+import '../page-versioning.js';
+import '../consolidation-operator.js';
+import '../utils/serialize-mutations.js';
+import '../memory-projection-store.js';
+import '../maintenance/memory-governance.js';
+import '../runtime/better-sqlite.js';
+import 'better-sqlite3';
+import '../write-envelope.js';
+import '../structured-attributes.js';
+
+/**
+ * Core location matcher (issue #2046) — the ONE place that decides whether a
+ * memory or wearable conversation gets provider location context.
+ *
+ * Pure and deterministic: no IO, no clocks, no randomness. Inputs are UTC
+ * ISO-8601 instants and half-open [start, end) intervals everywhere.
+ *
+ * Rules (issue #2046 / umbrella #2043 decision D):
+ * 1. A valid memory interval is required — derived ONLY from the memory's own
+ *   bi-temporal frontmatter (`valid_at` / `observedAt` / `invalid_at`), never
+ *   from wall-clock time or message order. Untimed memories stay untagged.
+ * 2. Intervals longer than 24h describe long-lived facts, not events at a
+ *   place; they stay untagged.
+ * 3. A place is tagged only when it is DOMINANT (strictly the longest overlap
+ *   among candidate places; ties are conflicts and leave the memory untagged)
+ *   and meets `minimumOverlapSeconds` and `minimumConfidence`.
+ * 4. Only resolved named places participate (`kind` home/work/poi): transit
+ *   legs and unnamed visits never tag a memory.
+ * 5. No address is ever inferred from text, coordinates, IP, or proximity —
+ *   only provider-supplied place metadata is echoed, and coordinates only
+ *   when `retainCoordinates` is enabled.
+ *
+ * Provider-owned metadata contract: the tag is `location:<stable-place-slug>`
+ * and the opaque provider place id lives in structured attributes. Every
+ * field the matcher writes is provider-owned; a memory that carries
+ * location-ish metadata WITHOUT the `locationSource` marker is treated as
+ * manual/user-authored and is never touched.
+ */
+
+/** Maximum memory span eligible for location tagging. */
+declare const LOCATION_MATCH_MAX_MEMORY_SPAN_MS: number;
+/** Prefix of provider-owned location tags. */
+declare const LOCATION_TAG_PREFIX = "location:";
+/** Structured-attribute keys owned by the tagging pipeline (never manual). */
+declare const LOCATION_ATTRIBUTE_KEYS: readonly ["locationSource", "locationPlaceId", "locationPlace", "locationConfidence", "locationVisitStart", "locationVisitEnd", "locationLatitude", "locationLongitude"];
+interface LocationTagPolicy {
+    minimumOverlapSeconds: number;
+    minimumConfidence: number;
+    retainCoordinates: boolean;
+}
+/** The memory side of a match: a half-open interval, or a single instant. */
+type MemoryLocationWindow = {
+    kind: "interval";
+    startUtc: string;
+    endUtc: string;
+} | {
+    kind: "instant";
+    atUtc: string;
+};
+/** Why a window was rejected before matching. */
+type WindowRejectReason = "untimed" | "span-too-long";
+interface WindowResult {
+    window?: MemoryLocationWindow;
+    /** Local days (YYYY-MM-DD in the tag policy timezone) the window touches. */
+    days?: string[];
+    rejected?: WindowRejectReason;
+}
+/**
+ * Derive the match window from a memory's own frontmatter. `validAt` (the
+ * event start; assumed copies carry the ingestion anchor) opens the window;
+ * `invalid_at` closes it. An end-only memory (no start bound) is untimed.
+ */
+declare function memoryLocationWindow(frontmatter: {
+    valid_at?: string;
+    observedAt?: string;
+    invalid_at?: string;
+}, localDay: (instantUtc: string) => string): WindowResult;
+/** One source's segments for a day, keyed by the configured source id. */
+interface LocationSourceSegments {
+    sourceId: string;
+    segments: LocationSegment[];
+}
+interface LocationMatch {
+    sourceId: string;
+    place: LocationPlace;
+    /** Overlap (ms) with the window — interval mode; see `visitMs` otherwise. */
+    overlapMs: number;
+    /** Total dwell (ms) of the dominant place inside the window's day(s). */
+    visitMs: number;
+    /** Minimum contributing segment confidence, when any source reported one. */
+    confidence?: number;
+    /** Envelope [start, end) of the segments that produced the match. */
+    visitStartUtc: string;
+    visitEndUtc: string;
+}
+type MatchOutcome = {
+    status: "matched";
+    match: LocationMatch;
+} | {
+    status: "unmatched";
+    reason: "no-overlap" | "ambiguous" | "below-minimum-overlap" | "below-minimum-confidence";
+};
+/**
+ * The dominant qualifying place for a window, across every source's
+ * segments. Deterministic: strict overlap comparison, ties (conflicts) are
+ * rejected, and equal-place contributions merge across sources.
+ */
+declare function matchDominantPlace(window: MemoryLocationWindow, sources: readonly LocationSourceSegments[], policy: LocationTagPolicy): MatchOutcome;
+/** Deterministic tag slug for a provider place id (`reitti:place:7` → `reitti-place-7`). */
+declare function locationTagSlug(placeId: string): string;
+/** The provider-owned tag for a matched place. */
+declare function locationTagForPlace(placeId: string): string;
+/** Provider-owned structured attributes describing a match. */
+declare function locationAttributesForMatch(match: LocationMatch, policy: LocationTagPolicy): Record<string, string>;
+interface LocationUpdatePlan {
+    /** Patch for `writeMemoryFrontmatter`; absent when nothing changes. */
+    patch?: {
+        tags: string[];
+        structuredAttributes: Record<string, string>;
+    };
+    /** Outcome for reporting. */
+    outcome: "tagged" | "updated" | "removed" | "unchanged" | "manual-metadata" | "unmatched" | "untimed" | "span-too-long";
+}
+/**
+ * Plan the provider-owned update for one memory: a match adds/replaces ONLY
+ * provider-owned fields; a lost match removes them (corrected observations);
+ * manual location metadata (no `locationSource` marker) always wins and is
+ * never touched. Unrelated tags and attributes survive every path.
+ */
+declare function planLocationUpdate(frontmatter: {
+    tags?: string[];
+    structuredAttributes?: Record<string, string>;
+}, outcome: MatchOutcome, policy: LocationTagPolicy): LocationUpdatePlan;
+
+/**
+ * Location tagging service (issue #2046) — the IO half around the pure
+ * matcher in `matching.ts`. Three consumers share it so the policy can never
+ * fork:
+ *
+ *  1. Write-time enrichment: after an extraction batch has cleared the
+ *     trust/importance/content-hash gates and persisted, the caller tags the
+ *     new memories (post-write, best-effort, never fails the extraction).
+ *  2. Historical backfill (`location/backfill.ts`): the same plan/apply core
+ *     over a bounded date range, idempotent by construction.
+ *  3. Wearable conversation fill: `WearableConversation.location` is filled
+ *     ONLY when the source did not provide one and the match passes policy.
+ *
+ * Segment data comes from the machine-global location sync state
+ * (`state/locations/sync.json`, ≤ 90 tracked days — matching the bounded
+ * backfill range). Reads are plain file loads; every memory mutation goes
+ * through `StorageManager.writeMemoryFrontmatter`, the atomic frontmatter
+ * chokepoint that preserves content (and therefore the content hash),
+ * lifecycle, and versioning invariants.
+ */
+
+/** Segments for one local day, per source id, from the sync state. */
+type DaySegmentIndex = Map<string, LocationSourceSegments[]>;
+/** Load every tracked day's per-source segments (one file read). */
+declare function loadDaySegmentIndex(memoryDir: string): Promise<DaySegmentIndex>;
+declare function locationTagPolicy(config: LocationConfig): LocationTagPolicy;
+/** Every tagging path is off unless BOTH gates are on. */
+declare function locationTaggingEnabled(config: LocationConfig): boolean;
+/**
+ * Write-time post-persist hook (issue #2046): tag the memories an extraction
+ * batch just made durable. Best-effort by contract — gated on both location
+ * gates, and a location failure must never fail the extraction that already
+ * persisted.
+ */
+declare function tagPersistedMemories(storage: StorageManager, memoryIds: string[], config: {
+    memoryDir: string;
+    location?: LocationConfig;
+}): Promise<void>;
+interface LocationEnrichmentCounts {
+    tagged: number;
+    updated: number;
+    removed: number;
+    unchanged: number;
+    unmatched: number;
+    manual: number;
+    untimed: number;
+    spanTooLong: number;
+    failed: number;
+}
+declare function emptyEnrichmentCounts(): LocationEnrichmentCounts;
+interface EnrichMemoriesOptions {
+    storage: Pick<StorageManager, "getMemoryById" | "writeMemoryFrontmatter">;
+    memoryDir: string;
+    config: LocationConfig;
+    /** Enrich exactly these memory ids (write-time path). */
+    memoryIds?: string[];
+    /** Pre-loaded memories (backfill path — one readAllMemories per run). */
+    memories?: MemoryFile[];
+    /** Reuse a caller-loaded segment index (backfill). */
+    index?: DaySegmentIndex;
+    /** Skip every mutation and only report (dry-run). */
+    dryRun?: boolean;
+}
+/**
+ * Apply the matcher to a set of memories and patch provider-owned location
+ * metadata. A failure on ONE memory is counted and skipped — it never blocks
+ * the others (failure isolation, issue #2046).
+ */
+declare function enrichMemoriesWithLocation(options: EnrichMemoriesOptions): Promise<LocationEnrichmentCounts>;
+/**
+ * Fill `WearableConversation.location` for conversations whose source did not
+ * provide one. Missing-only and source-aware: a provider-supplied value is
+ * never overwritten, and a failing conversation never blocks the others.
+ */
+declare function fillWearableConversationLocations(conversations: WearableConversation[], deps: {
+    memoryDir: string;
+    config: LocationConfig;
+}): Promise<void>;
+/** Render an opt-in, labels-only location context section for a day summary. */
+declare function renderDayLocationContext(memoryDir: string, date: string, config: LocationConfig): Promise<string | null>;
+
+/**
+ * Location tag backfill (issue #2046) — idempotent, bounded, LLM-free.
+ *
+ * For each local day in an explicit [from, to] range, find the memories whose
+ * own bi-temporal window touches that day and re-run the shared tagging core
+ * over the stored location segments. Provider-owned fields update or remove
+ * as the (corrected) observations dictate; manual metadata, unrelated tags,
+ * supersession, corrections, and content hashes are untouched by the plan
+ * core in `matching.ts`.
+ *
+ * Failure isolation: one bad day is reported as `failed` and the run
+ * continues; one bad memory inside a day counts into `failed` without
+ * blocking its neighbors. A day with no stored segments is `emptyDay`, never
+ * an error (distinct from a failed day). Re-running the same range yields
+ * `unchanged` everywhere and writes nothing.
+ */
+
+interface LocationBackfillDayReport {
+    date: string;
+    /** No stored segments for any source on this day. */
+    emptyDay: boolean;
+    failed?: string;
+    counts: LocationEnrichmentCounts;
+    /** Memories whose window touched the day (empty days report 0). */
+    considered: number;
+}
+interface LocationBackfillReport {
+    from: string;
+    to: string;
+    dryRun: boolean;
+    days: LocationBackfillDayReport[];
+}
+interface BackfillLocationTagsOptions {
+    storage: Pick<StorageManager, "readAllMemories" | "getMemoryById" | "writeMemoryFrontmatter">;
+    memoryDir: string;
+    config: LocationConfig;
+    from: string;
+    to: string;
+    dryRun?: boolean;
+}
+type BackfillMemoryStorage = Pick<StorageManager, "readAllMemories" | "getMemoryById" | "writeMemoryFrontmatter">;
+/**
+ * The memory store tag backfill patches: the default-namespace store — the
+ * root memory dir when namespaces are off, the resolved default-namespace
+ * root when they are on.
+ */
+declare function backfillMemoryStorage(config: PluginConfig): Promise<StorageManager>;
+/**
+ * Run the bounded backfill. Requires both tagging gates (`location.enabled`
+ * and `location.tagging.enabled`); the caller surfaces a clear error for a
+ * gated-off run so no surface silently no-ops.
+ */
+declare function backfillLocationTags(options: BackfillLocationTagsOptions): Promise<LocationBackfillReport>;
 
 /**
  * Location provider registry (issue #2044).
@@ -293,8 +577,8 @@ declare function syncLocation(options: LocationSyncRunOptions): Promise<Array<{
 }>>;
 
 /**
- * Location surface runners (issue #2047) — ONE implementation shared by the
- * CLI (`remnic location ...`), the MCP tools, the HTTP routes, and the
+ * Location surface runners (issues #2047, #2046) — ONE implementation shared
+ * by the CLI (`remnic location ...`), the MCP tools, the HTTP routes, and the
  * scheduler, so no surface can fork validation or disabled/empty/failure
  * semantics (same rule as the wearables runner). Parsing here is strict:
  * unknown flags reject with the valid list, invalid values reject loudly.
@@ -303,13 +587,19 @@ declare function syncLocation(options: LocationSyncRunOptions): Promise<Array<{
 interface LocationSurfaceDeps {
     config: LocationConfig;
     memoryDir: string;
+    /**
+     * Memory storage for tag backfill (default-namespace store). Optional so
+     * pure day-sync surfaces (status/check/day) never construct one; hosts
+     * that expose backfill provide it (issue #2046).
+     */
+    getMemoryStorage?: () => Promise<StorageManager>;
 }
+declare function runLocationStatus(deps: LocationSurfaceDeps): Promise<LocationStatusReport>;
 interface LocationSyncRun {
     date: string;
     results: LocationSourceSyncResult[];
 }
 type LocationSyncRuns = LocationSyncRun[];
-declare function runLocationStatus(deps: LocationSurfaceDeps): Promise<LocationStatusReport>;
 declare function runLocationCheck(deps: LocationSurfaceDeps, signal?: AbortSignal): Promise<LocationSourceCheckResult[]>;
 declare function runLocationSync(deps: LocationSurfaceDeps, request?: {
     endDate?: string;
@@ -325,9 +615,28 @@ interface LocationDayView {
 declare function runLocationDay(memoryDir: string, rawDate: unknown): Promise<LocationDayView>;
 /** Day span between two inclusive local dates (from ≤ to, ≤ 90 days). */
 declare function parseLocationBackfillRange(rawFrom: unknown, rawTo: unknown): {
+    from: string;
     endDate: string;
     days: number;
 };
+interface LocationBackfillResult {
+    /** Per-day provider sync results (empty under `dryRun`). */
+    days: LocationSyncRuns;
+    /** Memory re-tag report; absent when no memory storage was provided. */
+    memory?: LocationBackfillReport;
+}
+/**
+ * Backfill an explicit historical range (issue #2046): sync the days (unless
+ * `dryRun`, which persists NOTHING — not day files, not memory patches), then
+ * re-run the shared tagging core over the stored segments. Requires
+ * `location.enabled` + `location.tagging.enabled` +
+ * `location.tagging.backfillEnabled`.
+ */
+declare function runLocationBackfill(deps: LocationSurfaceDeps, request?: {
+    from?: unknown;
+    to?: unknown;
+    dryRun?: boolean;
+}): Promise<LocationBackfillResult>;
 interface LocationCliIo {
     stdout: {
         write(chunk: string): unknown;
@@ -419,4 +728,4 @@ interface LocationAutoSyncHandle {
 }
 declare function startLocationAutoSync(settings: LocationAutoSyncSettings, deps?: LocationAutoSyncDeps): LocationAutoSyncHandle;
 
-export { type DominantPlaceResult, LOCATIONS_DIR_NAME, LOCATION_DAY_FORMAT_VERSION, LOCATION_DAY_KIND, LOCATION_SYNC_DEFAULT_INTERVAL_MS, type LocationAutoSyncDeps, type LocationAutoSyncHandle, type LocationAutoSyncSettings, type LocationCheckOptions, type LocationCliIo, LocationConfig, type LocationDayDocument, type LocationDayMeta, type LocationDaySourceEntry, type LocationDayStatus, type LocationDaySummary, type LocationDaySyncOptions, type LocationDayView, LocationObservation, LocationPlace, LocationProvider, type LocationProviderEnv, type LocationProviderSetupDeps, LocationSegment, type LocationSourceCheckResult, type LocationSourceDayPayload, type LocationSourceStatus, type LocationSourceSyncResult, type LocationSourceSyncState, type LocationStatusOptions, type LocationStatusReport, type LocationSurfaceDeps, type LocationSyncRun, type LocationSyncRunOptions, type LocationSyncRuns, type LocationSyncStateFile, type PlaceDuration, bucketObservationsByDay, checkLocationSources, clearLocationProviders, composeLocationDayBody, composeLocationDayMeta, defaultLocationConfig, dominantPlace, emptyLocationSyncState, ensureConfiguredLocationProviders, getLocationProvider, hashLocationBody, intervalOverlapMs, isValidLocationDate, listLocationDayDates, listLocationProviders, loadLocationSyncState, localDayKey, locationDayFilePath, locationDayWindow, locationStatus, locationSyncStateFilePath, observationSegments, parseLocationBackfillRange, parseLocationConfig, parseLocationDaySummary, placeDurations, readLocationDay, registerLocationProvider, runLocationCheck, runLocationCliCommand, runLocationDay, runLocationStatus, runLocationSync, sanitizeProviderError, saveLocationSyncState, serializeLocationDay, startLocationAutoSync, syncLocation, syncLocationDay, updateLocationSourceDay, writeLocationDay };
+export { type BackfillLocationTagsOptions, type BackfillMemoryStorage, type DaySegmentIndex, type DominantPlaceResult, type EnrichMemoriesOptions, LOCATIONS_DIR_NAME, LOCATION_ATTRIBUTE_KEYS, LOCATION_DAY_FORMAT_VERSION, LOCATION_DAY_KIND, LOCATION_MATCH_MAX_MEMORY_SPAN_MS, LOCATION_SYNC_DEFAULT_INTERVAL_MS, LOCATION_TAG_PREFIX, type LocationAutoSyncDeps, type LocationAutoSyncHandle, type LocationAutoSyncSettings, type LocationBackfillDayReport, type LocationBackfillReport, type LocationBackfillResult, type LocationCheckOptions, type LocationCliIo, LocationConfig, type LocationDayDocument, type LocationDayMeta, type LocationDaySourceEntry, type LocationDayStatus, type LocationDaySummary, type LocationDaySyncOptions, type LocationDayView, type LocationEnrichmentCounts, type LocationMatch, LocationObservation, LocationPlace, LocationProvider, type LocationProviderEnv, type LocationProviderSetupDeps, LocationSegment, type LocationSourceCheckResult, type LocationSourceDayPayload, type LocationSourceSegments, type LocationSourceStatus, type LocationSourceSyncResult, type LocationSourceSyncState, type LocationStatusOptions, type LocationStatusReport, type LocationSurfaceDeps, type LocationSyncRun, type LocationSyncRunOptions, type LocationSyncRuns, type LocationSyncStateFile, type LocationTagPolicy, type LocationUpdatePlan, type MatchOutcome, type MemoryLocationWindow, type PlaceDuration, type WindowRejectReason, type WindowResult, backfillLocationTags, backfillMemoryStorage, bucketObservationsByDay, checkLocationSources, clearLocationProviders, composeLocationDayBody, composeLocationDayMeta, defaultLocationConfig, dominantPlace, emptyEnrichmentCounts, emptyLocationSyncState, enrichMemoriesWithLocation, ensureConfiguredLocationProviders, fillWearableConversationLocations, getLocationProvider, hashLocationBody, intervalOverlapMs, isValidLocationDate, listLocationDayDates, listLocationProviders, loadDaySegmentIndex, loadLocationSyncState, localDayKey, locationAttributesForMatch, locationDayFilePath, locationDayWindow, locationStatus, locationSyncStateFilePath, locationTagForPlace, locationTagPolicy, locationTagSlug, locationTaggingEnabled, matchDominantPlace, memoryLocationWindow, observationSegments, parseLocationBackfillRange, parseLocationConfig, parseLocationDaySummary, placeDurations, planLocationUpdate, readLocationDay, registerLocationProvider, renderDayLocationContext, runLocationBackfill, runLocationCheck, runLocationCliCommand, runLocationDay, runLocationStatus, runLocationSync, sanitizeProviderError, saveLocationSyncState, serializeLocationDay, startLocationAutoSync, syncLocation, syncLocationDay, tagPersistedMemories, updateLocationSourceDay, writeLocationDay };