@remnic/core 9.65.5 → 9.65.7

package/dist/location/index.js

@@ -1,766 +1,68 @@
+import {
+  LOCATION_SYNC_DEFAULT_INTERVAL_MS,
+  startLocationAutoSync
+} from "../chunk-BWGCOLEL.js";
 import {
   defaultLocationConfig,
   parseLocationConfig
 } from "../chunk-7PHI6GUI.js";
 import {
-  activityDayWindow,
-  isValidActivityDate
-} from "../chunk-M6L7HI7R.js";
+  LOCATIONS_DIR_NAME,
+  LOCATION_DAY_FORMAT_VERSION,
+  LOCATION_DAY_KIND,
+  bucketObservationsByDay,
+  checkLocationSources,
+  clearLocationProviders,
+  composeLocationDayBody,
+  composeLocationDayMeta,
+  dominantPlace,
+  emptyLocationSyncState,
+  ensureConfiguredLocationProviders,
+  getLocationProvider,
+  hashLocationBody,
+  intervalOverlapMs,
+  isValidLocationDate,
+  listLocationDayDates,
+  listLocationProviders,
+  loadLocationSyncState,
+  localDayKey,
+  locationDayFilePath,
+  locationDayWindow,
+  locationStatus,
+  locationSyncStateFilePath,
+  observationSegments,
+  parseLocationBackfillRange,
+  parseLocationDaySummary,
+  placeDurations,
+  readLocationDay,
+  registerLocationProvider,
+  runLocationCheck,
+  runLocationCliCommand,
+  runLocationDay,
+  runLocationStatus,
+  runLocationSync,
+  sanitizeProviderError,
+  saveLocationSyncState,
+  serializeLocationDay,
+  syncLocation,
+  syncLocationDay,
+  updateLocationSourceDay,
+  writeLocationDay
+} from "../chunk-3BCULS4U.js";
+import "../chunk-M6L7HI7R.js";
 import "../chunk-PQVCH2AE.js";
-import {
-  writeFileAtomically
-} from "../chunk-AW4QUFQF.js";
-import {
-  pathIsInside
-} from "../chunk-GCASGYIO.js";
+import "../chunk-AW4QUFQF.js";
+import "../chunk-GCASGYIO.js";
+import "../chunk-JUC24CTX.js";
+import "../chunk-2Z24E5W2.js";
 import "../chunk-5UZXUTVO.js";
 import "../chunk-3WCASNQZ.js";
 import "../chunk-PZ5AY32C.js";
-
-// src/location/registry.ts
-var PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
-var providers = /* @__PURE__ */ new Map();
-function assertValidProvider(provider) {
-  if (typeof provider !== "object" || provider === null) {
-    throw new TypeError("location provider must be an object");
-  }
-  if (typeof provider.id !== "string" || !PROVIDER_ID_PATTERN.test(provider.id)) {
-    throw new RangeError(
-      "location provider id must be a non-empty lowercase kebab string (a-z, 0-9, hyphens)"
-    );
-  }
-  if (typeof provider.displayName !== "string" || provider.displayName.trim().length === 0) {
-    throw new TypeError(`location provider '${provider.id}' must declare a non-empty displayName`);
-  }
-  if (typeof provider.verify !== "function" || typeof provider.fetchObservations !== "function") {
-    throw new TypeError(
-      `location provider '${provider.id}' must implement verify() and fetchObservations()`
-    );
-  }
-}
-function registerLocationProvider(provider) {
-  assertValidProvider(provider);
-  if (providers.has(provider.id)) {
-    throw new Error(`location provider '${provider.id}' is already registered`);
-  }
-  providers.set(provider.id, provider);
-}
-function getLocationProvider(id) {
-  return typeof id === "string" ? providers.get(id) : void 0;
-}
-function listLocationProviders() {
-  return [...providers.keys()].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-}
-function clearLocationProviders() {
-  providers.clear();
-}
-
-// src/location/intervals.ts
-function isValidLocationDate(date) {
-  return isValidActivityDate(date);
-}
-function locationDayWindow(date, timezone) {
-  if (!isValidActivityDate(date)) {
-    throw new RangeError(`Invalid location date "${date}"; expected a real YYYY-MM-DD day.`);
-  }
-  return activityDayWindow(date, timezone);
-}
-function assertFiniteInstant(iso, what) {
-  const ms = Date.parse(iso);
-  if (typeof iso !== "string" || !Number.isFinite(ms)) {
-    throw new RangeError(`${what} must be a UTC ISO-8601 instant; got "${String(iso)}"`);
-  }
-  return ms;
-}
-function localDayKey(instantUtc, timezone) {
-  assertFiniteInstant(instantUtc, "instantUtc");
-  return new Intl.DateTimeFormat("en-CA", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  }).format(new Date(instantUtc));
-}
-function compareObservations(a, b) {
-  if (a.observedAtUtc !== b.observedAtUtc) {
-    return a.observedAtUtc < b.observedAtUtc ? -1 : 1;
-  }
-  if (a.place.id !== b.place.id) {
-    return a.place.id < b.place.id ? -1 : 1;
-  }
-  return 0;
-}
-function bucketObservationsByDay(observations, timezone) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const observation of observations) {
-    assertFiniteInstant(observation.observedAtUtc, "observation observedAtUtc");
-    const key = localDayKey(observation.observedAtUtc, timezone);
-    const bucket = buckets.get(key);
-    if (bucket === void 0) buckets.set(key, [observation]);
-    else bucket.push(observation);
-  }
-  for (const bucket of buckets.values()) bucket.sort(compareObservations);
-  return buckets;
-}
-function intervalOverlapMs(a, b) {
-  const overlap = Math.min(Date.parse(a.endUtc), Date.parse(b.endUtc)) - Math.max(Date.parse(a.startUtc), Date.parse(b.startUtc));
-  return Math.max(0, overlap);
-}
-function placeForSegment(place, retainCoordinates) {
-  if (retainCoordinates || place.latitude === void 0 || place.longitude === void 0) {
-    return place;
-  }
-  return {
-    id: place.id,
-    label: place.label,
-    ...place.kind === void 0 ? {} : { kind: place.kind }
-  };
-}
-function observationSegments(observations, window, options) {
-  const startMs = assertFiniteInstant(window.startUtc, "window startUtc");
-  const endMs = assertFiniteInstant(window.endUtc, "window endUtc");
-  if (startMs >= endMs) {
-    throw new RangeError("location window must satisfy startUtc < endUtc");
-  }
-  const ordered = [...observations].sort(compareObservations);
-  const segments = [];
-  for (let index = 0; index < ordered.length; index += 1) {
-    const current = ordered[index];
-    const currentMs = Date.parse(current.observedAtUtc);
-    if (currentMs < startMs || currentMs >= endMs) {
-      throw new RangeError(
-        `location observation at "${current.observedAtUtc}" falls outside the requested [${window.startUtc}, ${window.endUtc}) window`
-      );
-    }
-    const nextMs = index + 1 < ordered.length ? Date.parse(ordered[index + 1].observedAtUtc) : endMs;
-    const segmentEndMs = Math.min(nextMs, endMs);
-    if (currentMs >= segmentEndMs) continue;
-    segments.push({
-      startUtc: new Date(currentMs).toISOString(),
-      endUtc: new Date(segmentEndMs).toISOString(),
-      place: placeForSegment(current.place, options.retainCoordinates)
-    });
-  }
-  return segments;
-}
-function unionIntervalMs(segments) {
-  const bounds = segments.map((segment) => ({ start: Date.parse(segment.startUtc), end: Date.parse(segment.endUtc) })).sort((a, b) => a.start !== b.start ? a.start - b.start : a.end - b.end);
-  let total = 0;
-  let sweepStart = null;
-  let sweepEnd = 0;
-  for (const bound of bounds) {
-    if (sweepStart === null || bound.start > sweepEnd) {
-      if (sweepStart !== null) total += sweepEnd - sweepStart;
-      sweepStart = bound.start;
-      sweepEnd = bound.end;
-    } else if (bound.end > sweepEnd) {
-      sweepEnd = bound.end;
-    }
-  }
-  if (sweepStart !== null) total += sweepEnd - sweepStart;
-  return total;
-}
-function placeDurations(segments) {
-  const byPlace = /* @__PURE__ */ new Map();
-  for (const segment of segments) {
-    const existing = byPlace.get(segment.place.id);
-    if (existing === void 0) {
-      byPlace.set(segment.place.id, { place: segment.place, segments: [segment], firstStartUtc: segment.startUtc });
-      continue;
-    }
-    existing.segments.push(segment);
-    if (segment.startUtc < existing.firstStartUtc) existing.firstStartUtc = segment.startUtc;
-    if (segment.place.label < existing.place.label) existing.place = segment.place;
-  }
-  const durations = [...byPlace.values()].map((entry) => ({
-    place: entry.place,
-    totalMs: unionIntervalMs(entry.segments),
-    firstStartUtc: entry.firstStartUtc
-  }));
-  durations.sort((a, b) => {
-    if (a.place.id !== b.place.id) return a.place.id < b.place.id ? -1 : 1;
-    return 0;
-  });
-  return durations;
-}
-function dominantPlace(segments) {
-  const durations = placeDurations(segments);
-  let best = null;
-  for (const duration of durations) {
-    if (best === null) {
-      best = duration;
-      continue;
-    }
-    if (duration.totalMs !== best.totalMs) {
-      if (duration.totalMs > best.totalMs) best = duration;
-      continue;
-    }
-    if (duration.firstStartUtc !== best.firstStartUtc) {
-      if (duration.firstStartUtc < best.firstStartUtc) best = duration;
-      continue;
-    }
-    if (duration.place.id < best.place.id) best = duration;
-  }
-  return best === null ? null : { place: best.place, totalMs: best.totalMs };
-}
-
-// src/location/store.ts
-import { createHash } from "crypto";
-import { lstat, mkdir, readFile, readdir, realpath } from "fs/promises";
-import path from "path";
-var LOCATIONS_DIR_NAME = "locations";
-var LOCATION_DAY_KIND = "location-day";
-var LOCATION_DAY_FORMAT_VERSION = 1;
-var MAX_TRACKED_LOCATION_DAYS = 90;
-var DAY_FILE_NAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.md$/;
-var stateLocks = /* @__PURE__ */ new Map();
-function withStateLock(key, fn) {
-  const prior = stateLocks.get(key) ?? Promise.resolve();
-  const next = prior.then(fn, fn);
-  const tail = next.then(
-    () => void 0,
-    () => void 0
-  );
-  stateLocks.set(key, tail);
-  void tail.then(() => {
-    if (stateLocks.get(key) === tail) stateLocks.delete(key);
-  });
-  return next;
-}
-function locationDayFilePath(memoryDir, date) {
-  if (!isValidLocationDate(date)) {
-    throw new RangeError(`Invalid location date "${date}"; expected a real YYYY-MM-DD day.`);
-  }
-  return path.join(memoryDir, LOCATIONS_DIR_NAME, `${date}.md`);
-}
-function locationSyncStateFilePath(memoryDir) {
-  return path.join(memoryDir, "state", "locations", "sync.json");
-}
-function emptyLocationSyncState() {
-  return { version: 1, sources: {} };
-}
-async function loadLocationSyncState(memoryDir) {
-  let raw;
-  try {
-    raw = await readFile(locationSyncStateFilePath(memoryDir), "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") return emptyLocationSyncState();
-    throw err;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return emptyLocationSyncState();
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.sources !== "object" || parsed.sources === null) {
-    return emptyLocationSyncState();
-  }
-  return { version: 1, sources: parsed.sources };
-}
-async function saveLocationSyncState(memoryDir, state) {
-  await mkdir(path.dirname(locationSyncStateFilePath(memoryDir)), { recursive: true, mode: 448 });
-  await writeFileAtomically(
-    locationSyncStateFilePath(memoryDir),
-    `${JSON.stringify(state, null, 2)}
-`
-  );
-}
-function pruneSourceDays(source) {
-  const days = source.days;
-  if (days === void 0) return;
-  const keys = Object.keys(days).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  for (const key of keys.slice(0, Math.max(0, keys.length - MAX_TRACKED_LOCATION_DAYS))) {
-    delete days[key];
-  }
-}
-async function updateLocationSourceDay(memoryDir, sourceId, date, payload, completedAtUtc) {
-  if (!isValidLocationDate(date)) {
-    throw new RangeError(`Invalid location date "${date}"; expected a real YYYY-MM-DD day.`);
-  }
-  return withStateLock(locationSyncStateFilePath(memoryDir), async () => {
-    const state = await loadLocationSyncState(memoryDir);
-    const source = state.sources[sourceId] ?? {};
-    const days = source.days ?? {};
-    days[date] = payload;
-    source.days = days;
-    source.lastSyncedAtUtc = completedAtUtc;
-    state.sources[sourceId] = source;
-    for (const candidate of Object.values(state.sources)) pruneSourceDays(candidate);
-    await saveLocationSyncState(memoryDir, state);
-    return state;
-  });
-}
-function hashLocationBody(body) {
-  return createHash("sha256").update(body, "utf8").digest("hex");
-}
-function clockHhMm(iso, timezone) {
-  return new Intl.DateTimeFormat("en-GB", {
-    timeZone: timezone,
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false
-  }).format(new Date(iso));
-}
-function formatDuration(ms) {
-  const totalMinutes = Math.round(ms / 6e4);
-  const hours = Math.floor(totalMinutes / 60);
-  const minutes = totalMinutes % 60;
-  if (hours <= 0) return `${minutes}m`;
-  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
-}
-function safeLabel(label) {
-  return label.replace(/\s+/g, " ").replace(/[`*_]/g, "").trim();
-}
-function formatPlaceLabel(segment) {
-  const label = safeLabel(segment.place.label);
-  return segment.place.kind === void 0 ? label : `${label} (${segment.place.kind})`;
-}
-function formatCoordinates(segment) {
-  if (segment.place.latitude === void 0 || segment.place.longitude === void 0) return "";
-  return ` @ ${segment.place.latitude.toFixed(4)},${segment.place.longitude.toFixed(4)}`;
-}
-function composeLocationDayBody(date, timezone, sources) {
-  const lines = [`# Location day \u2014 ${date} (${timezone})`, ""];
-  const allSegments = [];
-  let observationCount = 0;
-  for (const entry of Object.values(sources)) {
-    allSegments.push(...entry.segments);
-    observationCount += entry.observationCount;
-  }
-  lines.push("## Summary", "");
-  if (observationCount === 0) {
-    lines.push("No location observations recorded.", "");
-  } else {
-    const durations = placeDurations(allSegments).sort((a, b) => b.totalMs - a.totalMs);
-    lines.push(
-      `- Places visited: ${durations.length}`,
-      ...durations.map(
-        (duration) => `- ${safeLabel(duration.place.label)}: ${formatDuration(duration.totalMs)}`
-      ),
-      ""
-    );
-  }
-  const sourceIds = Object.keys(sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  for (const sourceId of sourceIds) {
-    const entry = sources[sourceId];
-    lines.push(`## Timeline \u2014 ${safeLabel(entry.providerDisplayName ?? sourceId)}`, "");
-    if (entry.segments.length === 0) {
-      lines.push("No observations.", "");
-      continue;
-    }
-    for (const segment of entry.segments) {
-      lines.push(
-        `- ${clockHhMm(segment.startUtc, timezone)}\u2013${clockHhMm(segment.endUtc, timezone)} \u2014 ${formatPlaceLabel(segment)}${formatCoordinates(segment)}`
-      );
-    }
-    lines.push("");
-  }
-  return `${lines.join("\n").trimEnd()}
-`;
-}
-function composeLocationDayMeta(date, timezone, sources, body) {
-  let observationCount = 0;
-  for (const entry of Object.values(sources)) observationCount += entry.observationCount;
-  return {
-    kind: LOCATION_DAY_KIND,
-    date,
-    timezone,
-    formatVersion: LOCATION_DAY_FORMAT_VERSION,
-    sources: Object.keys(sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0),
-    observationCount,
-    contentHash: hashLocationBody(body)
-  };
-}
-function frontmatterScalar(key, value) {
-  return `${key}: ${typeof value === "number" ? value : JSON.stringify(value)}`;
-}
-function frontmatterList(key, values) {
-  if (values.length === 0) return [`${key}: []`];
-  const lines = [`${key}:`];
-  for (const value of values) lines.push(`  - ${JSON.stringify(value)}`);
-  return lines;
-}
-function serializeLocationDay(meta, body) {
-  const lines = ["---"];
-  lines.push(frontmatterScalar("kind", meta.kind));
-  lines.push(frontmatterScalar("date", meta.date));
-  lines.push(frontmatterScalar("timezone", meta.timezone));
-  lines.push(frontmatterScalar("formatVersion", meta.formatVersion));
-  lines.push(...frontmatterList("sources", meta.sources));
-  lines.push(frontmatterScalar("observationCount", meta.observationCount));
-  lines.push(frontmatterScalar("contentHash", meta.contentHash));
-  lines.push("---", "", body);
-  return lines.join("\n");
-}
-function parseScalar(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    return typeof parsed === "string" ? parsed : raw;
-  } catch {
-    return raw;
-  }
-}
-function parseLocationDaySummary(raw) {
-  if (!raw.startsWith("---\n")) return null;
-  const closeIndex = raw.indexOf("\n---\n", 4);
-  if (closeIndex === -1) return null;
-  const scalars = {};
-  const lists = {};
-  let currentList = null;
-  for (const line of raw.slice(4, closeIndex).split("\n")) {
-    const listItem = /^ {2}- (.*)$/.exec(line);
-    if (listItem !== null && currentList !== null) {
-      lists[currentList].push(parseScalar(listItem[1]));
-      continue;
-    }
-    currentList = null;
-    const separator = line.indexOf(":");
-    if (separator === -1) continue;
-    const key = line.slice(0, separator);
-    const value = line.slice(separator + 1).trim();
-    if (value === "" || value === "[]") {
-      lists[key] = [];
-      currentList = key;
-      continue;
-    }
-    if (value.startsWith("[")) {
-      lists[key] = [parseScalar(value)];
-      currentList = key;
-      continue;
-    }
-    scalars[key] = value;
-  }
-  if (scalars.kind === void 0 || parseScalar(scalars.kind) !== LOCATION_DAY_KIND) return null;
-  if (scalars.date === void 0 || scalars.contentHash === void 0) return null;
-  return {
-    date: parseScalar(scalars.date),
-    timezone: scalars.timezone === void 0 ? "UTC" : parseScalar(scalars.timezone),
-    sources: lists.sources ?? [],
-    observationCount: scalars.observationCount === void 0 ? 0 : Number(scalars.observationCount) || 0,
-    contentHash: parseScalar(scalars.contentHash)
-  };
-}
-function isErrnoCode(err, code) {
-  return err instanceof Error && err.code === code;
-}
-async function assertNotSymlink(target, kind) {
-  let stat;
-  try {
-    stat = await lstat(target);
-  } catch (err) {
-    if (isErrnoCode(err, "ENOENT")) return;
-    throw err;
-  }
-  if (stat.isSymbolicLink()) {
-    throw new Error(
-      `locations ${kind} '${path.basename(target)}' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)`
-    );
-  }
-}
-async function assertNoEscape(rootReal, candidate) {
-  let candidateReal;
-  try {
-    candidateReal = await realpath(candidate);
-  } catch {
-    return;
-  }
-  if (!pathIsInside(rootReal, candidateReal)) {
-    throw new Error(
-      "location day path resolves outside the memory dir \u2014 refusing to follow a symlink/traversal (AGENTS.md pattern #3)"
-    );
-  }
-}
-async function assertDayPathContained(memoryDir, targetPath) {
-  let rootReal;
-  try {
-    rootReal = await realpath(memoryDir);
-  } catch {
-    rootReal = path.resolve(memoryDir);
-  }
-  const locationsDir = path.join(memoryDir, LOCATIONS_DIR_NAME);
-  await assertNoEscape(rootReal, locationsDir);
-  await assertNoEscape(rootReal, targetPath);
-  await assertNotSymlink(locationsDir, "directory");
-  await assertNotSymlink(targetPath, "day file");
-}
-async function writeLocationDay(memoryDir, date, serialized) {
-  const target = locationDayFilePath(memoryDir, date);
-  await assertDayPathContained(memoryDir, target);
-  try {
-    if (await readFile(target, "utf-8") === serialized) return false;
-  } catch (err) {
-    if (!isErrnoCode(err, "ENOENT")) throw err;
-  }
-  await mkdir(path.dirname(target), { recursive: true, mode: 448 });
-  await writeFileAtomically(target, serialized);
-  return true;
-}
-async function readLocationDay(memoryDir, date) {
-  const target = locationDayFilePath(memoryDir, date);
-  await assertDayPathContained(memoryDir, target);
-  try {
-    return await readFile(target, "utf-8");
-  } catch (err) {
-    if (isErrnoCode(err, "ENOENT")) return null;
-    throw err;
-  }
-}
-async function listLocationDayDates(memoryDir) {
-  const locationsDir = path.join(memoryDir, LOCATIONS_DIR_NAME);
-  await assertDayPathContained(memoryDir, locationsDir);
-  let entries;
-  try {
-    entries = await readdir(locationsDir);
-  } catch (err) {
-    if (isErrnoCode(err, "ENOENT")) return [];
-    throw err;
-  }
-  const dates = entries.filter((entry) => DAY_FILE_NAME_PATTERN.test(entry)).map((entry) => entry.slice(0, -3));
-  dates.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
-  return dates;
-}
-
-// src/location/pipeline.ts
-var MAX_SYNC_PAGES = 1e4;
-function sanitizeProviderError(error) {
-  const raw = error instanceof Error ? error.message : String(error);
-  return raw.replace(/Bearer\s+[A-Za-z0-9._~+/=-]+/gi, "Bearer [redacted]").replace(/[?#][^ \t"']*/g, "[redacted]").replace(/[+-]?\d+\.\d{3,},\s?[+-]?\d+\.\d{3,}/g, "[coordinates]").slice(0, 300);
-}
-function assertValidObservation(observation) {
-  if (typeof observation !== "object" || observation === null) {
-    throw new TypeError("location provider returned a non-object observation");
-  }
-  if (typeof observation.observedAtUtc !== "string" || !Number.isFinite(Date.parse(observation.observedAtUtc))) {
-    throw new TypeError("location provider returned an observation with an invalid observedAtUtc");
-  }
-  const place = observation.place;
-  if (typeof place !== "object" || place === null || typeof place.id !== "string" || place.id.length === 0) {
-    throw new TypeError("location provider returned an observation without a valid place");
-  }
-  if (typeof place.label !== "string" || place.label.trim().length === 0) {
-    throw new TypeError(`location provider returned place '${place.id}' without a label`);
-  }
-}
-async function fetchWindow(provider, window, options) {
-  const maxPages = options.maxPages ?? MAX_SYNC_PAGES;
-  if (!Number.isInteger(maxPages) || maxPages < 1) {
-    throw new RangeError("location sync maxPages must be a positive integer");
-  }
-  const observations = [];
-  const seenCursors = /* @__PURE__ */ new Set();
-  let cursor = null;
-  let pages = 0;
-  let completed = false;
-  while (pages < maxPages) {
-    options.signal?.throwIfAborted();
-    const page = await provider.fetchObservations({
-      startUtc: window.startUtc,
-      endUtc: window.endUtc,
-      cursor,
-      signal: options.signal
-    });
-    pages += 1;
-    for (const observation of page.observations) assertValidObservation(observation);
-    observations.push(...page.observations);
-    if (page.nextCursor === null) {
-      completed = true;
-      break;
-    }
-    if (typeof page.nextCursor !== "string" || page.nextCursor.length === 0) {
-      throw new TypeError("location provider returned an invalid cursor");
-    }
-    if (seenCursors.has(page.nextCursor)) {
-      throw new Error("location provider returned a repeated cursor");
-    }
-    seenCursors.add(page.nextCursor);
-    cursor = page.nextCursor;
-  }
-  if (!completed) {
-    throw new Error(`location provider exceeded ${maxPages} pages`);
-  }
-  return observations;
-}
-async function syncLocationDay(options) {
-  if (!options.config.enabled) return [];
-  const window = locationDayWindow(options.date, options.config.timezone);
-  const now = options.now ?? (() => /* @__PURE__ */ new Date());
-  const resolveProvider = options.getProvider ?? getLocationProvider;
-  const results = [];
-  for (const source of options.config.sources) {
-    if (!source.enabled) {
-      results.push({
-        sourceId: source.id,
-        status: "skipped",
-        skipReason: "source-disabled",
-        fetched: 0,
-        dayWritten: false,
-        stateSaved: false
-      });
-      continue;
-    }
-    const provider = resolveProvider(source.id);
-    if (provider === void 0) {
-      results.push({
-        sourceId: source.id,
-        status: "skipped",
-        skipReason: "provider-not-registered",
-        fetched: 0,
-        dayWritten: false,
-        stateSaved: false
-      });
-      continue;
-    }
-    let observations;
-    try {
-      observations = await fetchWindow(provider, window, options);
-    } catch (error) {
-      results.push({
-        sourceId: source.id,
-        status: "failed",
-        fetched: 0,
-        dayWritten: false,
-        stateSaved: false,
-        ...error instanceof Error && error.name === "AbortError" ? { error: "aborted" } : { error: sanitizeProviderError(error) }
-      });
-      continue;
-    }
-    try {
-      options.signal?.throwIfAborted();
-      const segments = observationSegments(observations, window, {
-        retainCoordinates: options.config.retainCoordinates
-      });
-      const payload = { observationCount: observations.length, segments, providerDisplayName: provider.displayName };
-      const merged = await mergeDaySources(options.memoryDir, source.id, options.date, payload);
-      let dayWritten = false;
-      if (Object.values(merged).some((entry) => entry.observationCount > 0)) {
-        const body = composeLocationDayBody(options.date, options.config.timezone, merged);
-        const meta = composeLocationDayMeta(options.date, options.config.timezone, merged, body);
-        dayWritten = await writeLocationDay(options.memoryDir, options.date, serializeLocationDay(meta, body));
-      }
-      await updateLocationSourceDay(
-        options.memoryDir,
-        source.id,
-        options.date,
-        payload,
-        now().toISOString()
-      );
-      results.push({
-        sourceId: source.id,
-        status: "synced",
-        fetched: observations.length,
-        dayWritten,
-        stateSaved: true
-      });
-    } catch (error) {
-      results.push({
-        sourceId: source.id,
-        status: "failed",
-        fetched: observations.length,
-        dayWritten: false,
-        stateSaved: false,
-        ...error instanceof Error && error.name === "AbortError" ? { error: "aborted" } : { error: sanitizeProviderError(error) }
-      });
-    }
-  }
-  return results;
-}
-async function mergeDaySources(memoryDir, sourceId, date, payload) {
-  const state = await loadLocationSyncState(memoryDir);
-  const merged = {};
-  for (const [otherId, otherState] of Object.entries(state.sources)) {
-    if (otherId === sourceId) continue;
-    const day = otherState.days?.[date];
-    if (day === void 0) continue;
-    merged[otherId] = { ...day, segments: [...day.segments] };
-  }
-  merged[sourceId] = payload;
-  return merged;
-}
-
-// src/location/cli.ts
-async function locationStatus(config, memoryDir, options = {}) {
-  const resolveProvider = options.getProvider ?? getLocationProvider;
-  const state = await loadLocationSyncState(memoryDir);
-  const sources = config.sources.map((source) => {
-    const sourceState = state.sources[source.id];
-    return {
-      id: source.id,
-      enabled: source.enabled,
-      providerRegistered: resolveProvider(source.id) !== void 0,
-      ...sourceState?.lastSyncedAtUtc === void 0 ? {} : { lastSyncedAtUtc: sourceState.lastSyncedAtUtc },
-      trackedDays: Object.keys(sourceState?.days ?? {}).length
-    };
-  });
-  const maxDays = options.maxDays ?? 7;
-  const recentDays = [];
-  for (const date of (await listLocationDayDates(memoryDir)).slice(0, Math.max(0, maxDays))) {
-    const raw = await readLocationDay(memoryDir, date);
-    const summary = raw === null ? null : parseLocationDaySummary(raw);
-    recentDays.push({
-      date,
-      sources: summary?.sources ?? [],
-      observationCount: summary?.observationCount ?? 0
-    });
-  }
-  return { enabled: config.enabled, timezone: config.timezone, sources, recentDays };
-}
-async function checkLocationSources(config, options = {}) {
-  if (!config.enabled) {
-    return config.sources.map((source) => ({ id: source.id, ok: false, skipped: "location-disabled" }));
-  }
-  const resolveProvider = options.getProvider ?? getLocationProvider;
-  const results = [];
-  for (const source of config.sources) {
-    if (!source.enabled) {
-      results.push({ id: source.id, ok: false, skipped: "source-disabled" });
-      continue;
-    }
-    const provider = resolveProvider(source.id);
-    if (provider === void 0) {
-      results.push({ id: source.id, ok: false, skipped: "provider-not-registered" });
-      continue;
-    }
-    try {
-      const check = await provider.verify(options.signal);
-      results.push({
-        id: source.id,
-        ok: check.ok,
-        ...check.detail === void 0 || check.detail.length === 0 ? {} : { detail: check.detail }
-      });
-    } catch (error) {
-      results.push({ id: source.id, ok: false, detail: error instanceof Error ? error.name : "provider error" });
-    }
-  }
-  return results;
-}
-function shiftIsoDate(date, days) {
-  const parsed = /* @__PURE__ */ new Date(`${date}T00:00:00Z`);
-  parsed.setUTCDate(parsed.getUTCDate() + days);
-  return parsed.toISOString().slice(0, 10);
-}
-async function syncLocation(options) {
-  const { config, memoryDir, endDate, days, ...rest } = options;
-  if (endDate !== void 0 && !isValidLocationDate(endDate)) {
-    throw new RangeError(`Invalid location endDate "${endDate}"; expected a real YYYY-MM-DD day.`);
-  }
-  const now = rest.now ?? (() => /* @__PURE__ */ new Date());
-  const end = endDate ?? shiftIsoDate(localDayKey(now().toISOString(), config.timezone), -1);
-  const count = days ?? config.syncDays;
-  if (!Number.isInteger(count) || count < 1 || count > 90) {
-    throw new RangeError("location sync days must be an integer from 1 to 90");
-  }
-  const runs = [];
-  for (let offset = count; offset >= 1; offset -= 1) {
-    const date = shiftIsoDate(end, -(offset - 1));
-    runs.push({ date, results: await syncLocationDay({ ...rest, config, memoryDir, date, now }) });
-  }
-  return runs;
-}
 export {
   LOCATIONS_DIR_NAME,
   LOCATION_DAY_FORMAT_VERSION,
   LOCATION_DAY_KIND,
+  LOCATION_SYNC_DEFAULT_INTERVAL_MS,
   bucketObservationsByDay,
   checkLocationSources,
   clearLocationProviders,
@@ -769,6 +71,7 @@ export {
   defaultLocationConfig,
   dominantPlace,
   emptyLocationSyncState,
+  ensureConfiguredLocationProviders,
   getLocationProvider,
   hashLocationBody,
   intervalOverlapMs,
@@ -782,14 +85,21 @@ export {
   locationStatus,
   locationSyncStateFilePath,
   observationSegments,
+  parseLocationBackfillRange,
   parseLocationConfig,
   parseLocationDaySummary,
   placeDurations,
   readLocationDay,
   registerLocationProvider,
+  runLocationCheck,
+  runLocationCliCommand,
+  runLocationDay,
+  runLocationStatus,
+  runLocationSync,
   sanitizeProviderError,
   saveLocationSyncState,
   serializeLocationDay,
+  startLocationAutoSync,
   syncLocation,
   syncLocationDay,
   updateLocationSourceDay,