@remnic/core 9.65.6 → 9.65.7

package/dist/chunk-3BCULS4U.js

@@ -0,0 +1,1093 @@
+import {
+  activityDayWindow,
+  isValidActivityDate
+} from "./chunk-M6L7HI7R.js";
+import {
+  writeFileAtomically
+} from "./chunk-AW4QUFQF.js";
+import {
+  pathIsInside
+} from "./chunk-GCASGYIO.js";
+import {
+  readEnvVar
+} from "./chunk-JUC24CTX.js";
+import {
+  EngramAccessInputError
+} from "./chunk-2Z24E5W2.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.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;
+}
+
+// src/location/provider-setup.ts
+var loadFailuresWarned = /* @__PURE__ */ new Set();
+function readReittiEnv() {
+  return {
+    baseUrl: readEnvVar("REITTI_BASE_URL"),
+    token: readEnvVar("REITTI_TOKEN"),
+    authMode: readEnvVar("REITTI_AUTH_MODE")
+  };
+}
+async function ensureConfiguredLocationProviders(config, deps = {}) {
+  const registered = [];
+  if (!config.enabled) return registered;
+  for (const source of config.sources) {
+    if (!source.enabled) continue;
+    if (getLocationProvider(source.id) !== void 0) continue;
+    if (source.id !== "reitti") continue;
+    const env = deps.env ?? readReittiEnv();
+    const baseUrl = env.baseUrl?.trim();
+    const token = env.token?.trim();
+    if (!baseUrl || !token) continue;
+    const authMode = env.authMode === "x-api-token" || env.authMode === "bearer" ? env.authMode : void 0;
+    const specifier = "@remnic/connector-reitti";
+    const load = deps.importModule ?? ((s) => import(s));
+    try {
+      const mod = await load(specifier);
+      if (mod.ensureReittiProviderRegistered({
+        baseUrl,
+        token,
+        timezone: config.timezone,
+        ...authMode !== void 0 ? { authMode } : {}
+      })) {
+        registered.push("reitti");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (!message.includes(specifier)) {
+        if (!loadFailuresWarned.has(specifier)) {
+          loadFailuresWarned.add(specifier);
+          log.warn(`location: failed to load optional provider package ${specifier}: ${message}`);
+        }
+      }
+    }
+  }
+  return registered;
+}
+
+// src/location/surfaces.ts
+async function runLocationStatus(deps) {
+  await ensureConfiguredLocationProviders(deps.config);
+  return locationStatus(deps.config, deps.memoryDir);
+}
+async function runLocationCheck(deps, signal) {
+  await ensureConfiguredLocationProviders(deps.config);
+  return checkLocationSources(deps.config, signal !== void 0 ? { signal } : {});
+}
+async function runLocationSync(deps, request = {}) {
+  await ensureConfiguredLocationProviders(deps.config);
+  const runs = await syncLocation({ ...deps, ...validatedSyncWindow(request) });
+  return runs;
+}
+async function runLocationDay(memoryDir, rawDate) {
+  const date = requireLocationDate(rawDate, "date");
+  const body = await readLocationDay(memoryDir, date);
+  const summary = body === null ? null : parseLocationDaySummary(body);
+  return {
+    date,
+    found: body !== null,
+    sources: summary?.sources ?? [],
+    observationCount: summary?.observationCount ?? 0,
+    body
+  };
+}
+function requireLocationDate(raw, label) {
+  if (typeof raw !== "string" || !isValidLocationDate(raw)) {
+    throw new EngramAccessInputError(`location: ${label} is required (YYYY-MM-DD)`);
+  }
+  return raw;
+}
+function optionalLocationDays(raw) {
+  if (raw === void 0 || raw === null || raw === "") return void 0;
+  const parsed = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 90) {
+    throw new EngramAccessInputError("location: days expects an integer from 1 to 90");
+  }
+  return parsed;
+}
+function validatedSyncWindow(request) {
+  const days = optionalLocationDays(request.days);
+  const endDate = request.endDate === void 0 || request.endDate === null || request.endDate === "" ? void 0 : requireLocationDate(request.endDate, "date");
+  return { ...endDate !== void 0 ? { endDate } : {}, ...days !== void 0 ? { days } : {} };
+}
+function parseLocationBackfillRange(rawFrom, rawTo) {
+  const from = requireLocationDate(rawFrom, "from");
+  const to = requireLocationDate(rawTo, "to");
+  const fromMs = Date.parse(`${from}T00:00:00Z`);
+  const toMs = Date.parse(`${to}T00:00:00Z`);
+  if (toMs < fromMs) {
+    throw new EngramAccessInputError("location: backfill --from must not be after --to");
+  }
+  const days = Math.round((toMs - fromMs) / 864e5) + 1;
+  if (days > 90) {
+    throw new EngramAccessInputError("location: backfill range is capped at 90 days");
+  }
+  return { endDate: to, days };
+}
+var USAGE = `Usage: location <command> [options]
+
+Commands:
+  status                         Configured sources, registration, last sync
+  check                          Probe every enabled provider (auth/connectivity)
+  sync [options]                 Sync recent local days (default: config.syncDays
+                                   ending yesterday)
+    --date <YYYY-MM-DD>          End the window on this day (inclusive)
+    --days <n>                   Window size, 1..90 (default: location.syncDays)
+  backfill --from <date> --to <date>
+                                 Sync an explicit historical range (\u2264 90 days)
+  day <YYYY-MM-DD>               Print one stored location day
+
+Add --json to status/sync/backfill/day for machine-readable output.
+Credentials for built-in providers come from the environment:
+  reitti: REITTI_BASE_URL, REITTI_TOKEN[, REITTI_AUTH_MODE=x-api-token|bearer]
+`;
+var VALUE_FLAGS = /* @__PURE__ */ new Set(["--date", "--days", "--from", "--to"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json"]);
+function parseCliFlags(args) {
+  const flags = /* @__PURE__ */ new Map();
+  const positional = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (!arg.startsWith("--")) {
+      positional.push(arg);
+      continue;
+    }
+    if (BOOLEAN_FLAGS.has(arg)) {
+      flags.set(arg, true);
+      continue;
+    }
+    if (VALUE_FLAGS.has(arg)) {
+      const value = args[index + 1];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new EngramAccessInputError(`location: ${arg} requires a value`);
+      }
+      flags.set(arg, value);
+      index++;
+      continue;
+    }
+    throw new EngramAccessInputError(
+      `location: unknown flag '${arg}' \u2014 valid flags: ${[...VALUE_FLAGS, ...BOOLEAN_FLAGS].join(", ")}`
+    );
+  }
+  return { flags, positional };
+}
+function flagString(parsed, name) {
+  const value = parsed.flags.get(name);
+  return typeof value === "string" ? value : void 0;
+}
+function renderStatus(report) {
+  const lines = [
+    `Location: ${report.enabled ? "enabled" : "disabled"} (timezone ${report.timezone})`
+  ];
+  if (report.sources.length === 0) {
+    lines.push("No sources configured. Add location.sources to the plugin config.");
+    return `${lines.join("\n")}
+`;
+  }
+  for (const source of report.sources) {
+    lines.push(
+      `  ${source.id}: ${source.enabled ? "enabled" : "disabled"}, provider ${source.providerRegistered ? "registered" : "not registered"}, ${source.trackedDays} tracked day${source.trackedDays === 1 ? "" : "s"}, last sync ${source.lastSyncedAtUtc ?? "never"}`
+    );
+  }
+  if (report.recentDays.length > 0) {
+    lines.push("  recent days:");
+    for (const day of report.recentDays) {
+      lines.push(
+        `    ${day.date}  ${day.observationCount} observation${day.observationCount === 1 ? "" : "s"}  [${day.sources.join(", ")}]`
+      );
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+function anySourceFailed(runs) {
+  return runs.some((run) => run.results.some((result) => result.status === "failed"));
+}
+function renderRuns(io, runs) {
+  for (const run of runs) {
+    for (const result of run.results) {
+      io.stdout.write(
+        `${run.date} ${result.sourceId}: ${result.status}${result.error ? ` \u2014 ${result.error}` : ""} (${result.fetched} fetched)
+`
+      );
+    }
+  }
+}
+async function runLocationCliCommand(deps, args, io) {
+  const [command, ...rest] = args;
+  try {
+    switch (command) {
+      case void 0:
+      case "help":
+      case "--help": {
+        io.stdout.write(USAGE);
+        return command === void 0 ? 1 : 0;
+      }
+      case "status": {
+        const parsed = parseCliFlags(rest);
+        const report = await runLocationStatus(deps);
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify(report, null, 2)}
+`);
+          return 0;
+        }
+        io.stdout.write(renderStatus(report));
+        return 0;
+      }
+      case "check": {
+        const results = await runLocationCheck(deps);
+        for (const result of results) {
+          const skipped = result.skipped === void 0 ? "" : ` (skipped: ${result.skipped})`;
+          io.stdout.write(
+            `${result.id}: ${result.ok ? "OK" : "FAILED"}${skipped}${result.detail ? ` \u2014 ${result.detail}` : ""}
+`
+          );
+        }
+        return results.every((result) => result.ok) ? 0 : 1;
+      }
+      case "sync": {
+        const parsed = parseCliFlags(rest);
+        if (parsed.positional.length > 0) {
+          throw new EngramAccessInputError(
+            `location: unexpected argument '${parsed.positional[0]}' \u2014 sync takes flags only`
+          );
+        }
+        const daysValue = flagString(parsed, "--days");
+        const runs = await runLocationSync(deps, {
+          endDate: flagString(parsed, "--date"),
+          ...daysValue !== void 0 ? { days: Number(daysValue) } : {}
+        });
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify({ days: runs }, null, 2)}
+`);
+        } else {
+          renderRuns(io, runs);
+        }
+        return anySourceFailed(runs) ? 1 : 0;
+      }
+      case "backfill": {
+        const parsed = parseCliFlags(rest);
+        const range = parseLocationBackfillRange(flagString(parsed, "--from"), flagString(parsed, "--to"));
+        const runs = await runLocationSync(deps, range);
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify({ days: runs }, null, 2)}
+`);
+        } else {
+          renderRuns(io, runs);
+        }
+        return anySourceFailed(runs) ? 1 : 0;
+      }
+      case "day": {
+        const parsed = parseCliFlags(rest);
+        const date = parsed.positional[0] ?? flagString(parsed, "--date");
+        const view = await runLocationDay(deps.memoryDir, date);
+        if (!view.found) {
+          io.stderr.write(`No stored location day for ${view.date}.
+`);
+          return 1;
+        }
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify(view, null, 2)}
+`);
+          return 0;
+        }
+        io.stdout.write(`${view.body}
+`);
+        return 0;
+      }
+      default:
+        io.stderr.write(`location: unknown command '${command}'
+${USAGE}`);
+        return 1;
+    }
+  } catch (err) {
+    io.stderr.write(`${err instanceof Error ? err.message : String(err)}
+`);
+    return 1;
+  }
+}
+
+export {
+  registerLocationProvider,
+  getLocationProvider,
+  listLocationProviders,
+  clearLocationProviders,
+  isValidLocationDate,
+  locationDayWindow,
+  localDayKey,
+  bucketObservationsByDay,
+  intervalOverlapMs,
+  observationSegments,
+  placeDurations,
+  dominantPlace,
+  LOCATIONS_DIR_NAME,
+  LOCATION_DAY_KIND,
+  LOCATION_DAY_FORMAT_VERSION,
+  locationDayFilePath,
+  locationSyncStateFilePath,
+  emptyLocationSyncState,
+  loadLocationSyncState,
+  saveLocationSyncState,
+  updateLocationSourceDay,
+  hashLocationBody,
+  composeLocationDayBody,
+  composeLocationDayMeta,
+  serializeLocationDay,
+  parseLocationDaySummary,
+  writeLocationDay,
+  readLocationDay,
+  listLocationDayDates,
+  sanitizeProviderError,
+  syncLocationDay,
+  locationStatus,
+  checkLocationSources,
+  syncLocation,
+  ensureConfiguredLocationProviders,
+  runLocationStatus,
+  runLocationCheck,
+  runLocationSync,
+  runLocationDay,
+  parseLocationBackfillRange,
+  runLocationCliCommand
+};
+//# sourceMappingURL=chunk-3BCULS4U.js.map