@remnic/core 9.65.8 → 9.66.1

package/dist/chunk-TB2MJRI6.js

@@ -0,0 +1,866 @@
+import {
+  STRUCTURED_ATTRIBUTE_LIMITS,
+  TAG_LIMITS
+} from "./chunk-WKAXBXVA.js";
+import {
+  activityDayWindow,
+  isValidActivityDate
+} from "./chunk-M6L7HI7R.js";
+import {
+  writeFileAtomically
+} from "./chunk-AW4QUFQF.js";
+import {
+  pathIsInside
+} from "./chunk-GCASGYIO.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// 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),
+      ...current.confidence !== void 0 ? { confidence: current.confidence } : {}
+    });
+  }
+  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/matching.ts
+var LOCATION_MATCH_MAX_MEMORY_SPAN_MS = 24 * 60 * 60 * 1e3;
+var LOCATION_TAG_PREFIX = "location:";
+var LOCATION_ATTRIBUTE_KEYS = [
+  "locationSource",
+  "locationPlaceId",
+  "locationPlace",
+  "locationConfidence",
+  "locationVisitStart",
+  "locationVisitEnd",
+  "locationLatitude",
+  "locationLongitude"
+];
+var TAGGABLE_PLACE_KINDS = { home: true, work: true, poi: true };
+function memoryLocationWindow(frontmatter, localDay) {
+  const start = frontmatter.valid_at ?? frontmatter.observedAt;
+  if (start === void 0 || Number.isNaN(Date.parse(start))) {
+    return { rejected: "untimed" };
+  }
+  const end = frontmatter.invalid_at;
+  if (end === void 0 || Number.isNaN(Date.parse(end)) || Date.parse(end) <= Date.parse(start)) {
+    return { window: { kind: "instant", atUtc: start }, days: [localDay(start)] };
+  }
+  if (Date.parse(end) - Date.parse(start) > LOCATION_MATCH_MAX_MEMORY_SPAN_MS) {
+    return { rejected: "span-too-long" };
+  }
+  const lastInstant = new Date(Date.parse(end) - 1).toISOString();
+  const days = [localDay(start)];
+  const endDay = localDay(lastInstant);
+  if (endDay !== days[0]) days.push(endDay);
+  return { window: { kind: "interval", startUtc: start, endUtc: end }, days };
+}
+function overlapMsOf(window, segment) {
+  if (window.kind === "instant") {
+    const at = Date.parse(window.atUtc);
+    return at >= Date.parse(segment.startUtc) && at < Date.parse(segment.endUtc) ? 1 : 0;
+  }
+  return Math.max(
+    0,
+    Math.min(Date.parse(window.endUtc), Date.parse(segment.endUtc)) - Math.max(Date.parse(window.startUtc), Date.parse(segment.startUtc))
+  );
+}
+function matchDominantPlace(window, sources, policy) {
+  const byPlace = /* @__PURE__ */ new Map();
+  for (const source of sources) {
+    for (const segment of source.segments) {
+      if (TAGGABLE_PLACE_KINDS[segment.place.kind ?? ""] !== true) continue;
+      const overlap = overlapMsOf(window, segment);
+      if (overlap <= 0) continue;
+      const duration = Date.parse(segment.endUtc) - Date.parse(segment.startUtc);
+      const existing = byPlace.get(segment.place.id);
+      if (existing === void 0) {
+        byPlace.set(segment.place.id, {
+          sourceId: source.sourceId,
+          place: segment.place,
+          overlapMs: overlap,
+          visitMs: duration,
+          confidence: segment.confidence,
+          startUtc: segment.startUtc,
+          endUtc: segment.endUtc
+        });
+        continue;
+      }
+      existing.overlapMs += overlap;
+      existing.visitMs += duration;
+      existing.confidence = existing.confidence === void 0 ? segment.confidence : segment.confidence === void 0 ? existing.confidence : Math.min(existing.confidence, segment.confidence);
+      if (segment.startUtc < existing.startUtc) existing.startUtc = segment.startUtc;
+      if (segment.endUtc > existing.endUtc) existing.endUtc = segment.endUtc;
+    }
+  }
+  if (byPlace.size === 0) return { status: "unmatched", reason: "no-overlap" };
+  let best = null;
+  let tie = false;
+  for (const candidate of byPlace.values()) {
+    if (best === null || candidate.overlapMs > best.overlapMs) {
+      best = candidate;
+      tie = false;
+      continue;
+    }
+    if (candidate.overlapMs === best.overlapMs) tie = true;
+  }
+  if (best === null || tie) return { status: "unmatched", reason: "ambiguous" };
+  const overlapForThreshold = window.kind === "instant" ? best.visitMs : best.overlapMs;
+  if (policy.minimumOverlapSeconds > 0 && overlapForThreshold < policy.minimumOverlapSeconds * 1e3) {
+    return { status: "unmatched", reason: "below-minimum-overlap" };
+  }
+  if (best.confidence !== void 0 && best.confidence < policy.minimumConfidence) {
+    return { status: "unmatched", reason: "below-minimum-confidence" };
+  }
+  return {
+    status: "matched",
+    match: {
+      sourceId: best.sourceId,
+      place: best.place,
+      overlapMs: best.overlapMs,
+      visitMs: best.visitMs,
+      ...best.confidence !== void 0 ? { confidence: best.confidence } : {},
+      visitStartUtc: best.startUtc,
+      visitEndUtc: best.endUtc
+    }
+  };
+}
+function locationTagSlug(placeId) {
+  const slug = placeId.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return slug.slice(0, TAG_LIMITS.maxTagLength - LOCATION_TAG_PREFIX.length);
+}
+function locationTagForPlace(placeId) {
+  return `${LOCATION_TAG_PREFIX}${locationTagSlug(placeId)}`;
+}
+function boundedAttributeValue(value) {
+  return value.slice(0, STRUCTURED_ATTRIBUTE_LIMITS.maxValueLength);
+}
+function locationAttributesForMatch(match, policy) {
+  const attributes = {
+    locationSource: match.sourceId,
+    locationPlaceId: boundedAttributeValue(match.place.id),
+    locationPlace: boundedAttributeValue(match.place.label),
+    ...match.confidence !== void 0 ? { locationConfidence: match.confidence.toFixed(3) } : {},
+    locationVisitStart: match.visitStartUtc,
+    locationVisitEnd: match.visitEndUtc
+  };
+  if (policy.retainCoordinates && match.place.latitude !== void 0 && match.place.longitude !== void 0) {
+    attributes.locationLatitude = String(match.place.latitude);
+    attributes.locationLongitude = String(match.place.longitude);
+  }
+  return attributes;
+}
+function frontmatterHasLocationMetadata(frontmatter) {
+  if ((frontmatter.tags ?? []).some((tag) => tag.startsWith(LOCATION_TAG_PREFIX))) return true;
+  return Object.keys(frontmatter.structuredAttributes ?? {}).some(
+    (key) => LOCATION_ATTRIBUTE_KEYS.includes(key)
+  );
+}
+function isProviderOwned(frontmatter) {
+  const source = frontmatter.structuredAttributes?.locationSource;
+  return typeof source === "string" && source.length > 0;
+}
+function planLocationUpdate(frontmatter, outcome, policy) {
+  if (frontmatterHasLocationMetadata(frontmatter) && !isProviderOwned(frontmatter)) {
+    return { outcome: "manual-metadata" };
+  }
+  const tags = [...frontmatter.tags ?? []];
+  const attributes = { ...frontmatter.structuredAttributes ?? {} };
+  const providerTagIndex = tags.findIndex((tag) => tag.startsWith(LOCATION_TAG_PREFIX));
+  const stripProviderFields = () => {
+    if (providerTagIndex >= 0) tags.splice(providerTagIndex, 1);
+    for (const key of LOCATION_ATTRIBUTE_KEYS) delete attributes[key];
+  };
+  if (outcome.status !== "matched") {
+    if (!isProviderOwned(frontmatter)) return { outcome: "unmatched" };
+    if (providerTagIndex < 0 && !("locationPlaceId" in attributes)) {
+      return { outcome: "unchanged" };
+    }
+    stripProviderFields();
+    return { patch: { tags, structuredAttributes: attributes }, outcome: "removed" };
+  }
+  const desiredTag = locationTagForPlace(outcome.match.place.id);
+  const desiredAttributes = locationAttributesForMatch(outcome.match, policy);
+  if (tags.length >= TAG_LIMITS.maxTags && providerTagIndex < 0) {
+    return { outcome: "unchanged" };
+  }
+  const alreadyCurrent = providerTagIndex >= 0 && tags[providerTagIndex] === desiredTag && LOCATION_ATTRIBUTE_KEYS.every((key) => {
+    const want = desiredAttributes[key];
+    const have = attributes[key];
+    return want === void 0 ? have === void 0 : have === want;
+  });
+  if (alreadyCurrent) return { outcome: "unchanged" };
+  if (providerTagIndex >= 0) tags[providerTagIndex] = desiredTag;
+  else tags.push(desiredTag);
+  for (const key of LOCATION_ATTRIBUTE_KEYS) delete attributes[key];
+  Object.assign(attributes, desiredAttributes);
+  const wasProviderOwned = isProviderOwned(frontmatter);
+  return {
+    patch: { tags, structuredAttributes: attributes },
+    outcome: wasProviderOwned ? "updated" : "tagged"
+  };
+}
+
+// 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/tagging.ts
+async function loadDaySegmentIndex(memoryDir) {
+  const state = await loadLocationSyncState(memoryDir);
+  const index = /* @__PURE__ */ new Map();
+  for (const [sourceId, source] of Object.entries(state.sources)) {
+    for (const [date, payload] of Object.entries(source.days ?? {})) {
+      const entry = { sourceId, segments: payload.segments ?? [] };
+      const existing = index.get(date);
+      if (existing === void 0) index.set(date, [entry]);
+      else existing.push(entry);
+    }
+  }
+  return index;
+}
+function locationTagPolicy(config) {
+  return {
+    minimumOverlapSeconds: config.minimumOverlapSeconds,
+    minimumConfidence: config.minimumConfidence,
+    retainCoordinates: config.retainCoordinates
+  };
+}
+function locationTaggingEnabled(config) {
+  return config.enabled && config.tagging.enabled;
+}
+async function tagPersistedMemories(storage, memoryIds, config) {
+  if (memoryIds.length === 0 || !config.location || !locationTaggingEnabled(config.location)) return;
+  try {
+    await enrichMemoriesWithLocation({
+      storage,
+      memoryIds,
+      memoryDir: config.memoryDir,
+      config: config.location
+    });
+  } catch (locationError) {
+    log.warn("[location] post-write tagging failed (non-fatal)", locationError);
+  }
+}
+function segmentsForDays(index, days) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const day of days) {
+    for (const entry of index.get(day) ?? []) {
+      const existing = merged.get(entry.sourceId);
+      if (existing === void 0) {
+        merged.set(entry.sourceId, { sourceId: entry.sourceId, segments: [...entry.segments] });
+        continue;
+      }
+      existing.segments.push(...entry.segments);
+    }
+  }
+  return [...merged.values()];
+}
+function planForMemory(frontmatter, index, config) {
+  const policy = locationTagPolicy(config);
+  const result = memoryLocationWindow(frontmatter, (instant) => localDayKey(instant, config.timezone));
+  if (result.rejected === "span-too-long") return { outcome: "span-too-long" };
+  if (result.rejected === "untimed" || result.window === void 0 || result.days === void 0) {
+    return { outcome: "untimed" };
+  }
+  const sources = segmentsForDays(index, result.days);
+  return planLocationUpdate(frontmatter, matchDominantPlace(result.window, sources, policy), policy);
+}
+function emptyEnrichmentCounts() {
+  return {
+    tagged: 0,
+    updated: 0,
+    removed: 0,
+    unchanged: 0,
+    unmatched: 0,
+    manual: 0,
+    untimed: 0,
+    spanTooLong: 0,
+    failed: 0
+  };
+}
+function countOutcome(counts, outcome) {
+  if (outcome === "tagged") counts.tagged += 1;
+  else if (outcome === "updated") counts.updated += 1;
+  else if (outcome === "removed") counts.removed += 1;
+  else if (outcome === "unchanged") counts.unchanged += 1;
+  else if (outcome === "manual-metadata") counts.manual += 1;
+  else if (outcome === "unmatched") counts.unmatched += 1;
+  else if (outcome === "untimed") counts.untimed += 1;
+  else if (outcome === "span-too-long") counts.spanTooLong += 1;
+}
+async function enrichMemoriesWithLocation(options) {
+  if (!locationTaggingEnabled(options.config)) return emptyEnrichmentCounts();
+  const counts = emptyEnrichmentCounts();
+  const index = options.index ?? await loadDaySegmentIndex(options.memoryDir);
+  let memories = options.memories;
+  if (memories === void 0 && options.memoryIds !== void 0) {
+    memories = [];
+    for (const id of options.memoryIds) {
+      const memory = await options.storage.getMemoryById(id);
+      if (memory !== null) memories.push(memory);
+    }
+  }
+  if (memories === void 0) return counts;
+  for (const memory of memories) {
+    try {
+      const plan = planForMemory(memory.frontmatter, index, options.config);
+      if (plan.patch === void 0 || options.dryRun === true) {
+        countOutcome(counts, plan.outcome);
+        continue;
+      }
+      await options.storage.writeMemoryFrontmatter(memory, plan.patch, { actor: "location-tagging" });
+      countOutcome(counts, plan.outcome);
+    } catch {
+      counts.failed += 1;
+    }
+  }
+  return counts;
+}
+async function fillWearableConversationLocations(conversations, deps) {
+  if (!locationTaggingEnabled(deps.config) || conversations.length === 0) return;
+  let index;
+  try {
+    index = await loadDaySegmentIndex(deps.memoryDir);
+  } catch {
+    return;
+  }
+  const policy = locationTagPolicy(deps.config);
+  for (const conversation of conversations) {
+    if (conversation.location !== void 0 && conversation.location.length > 0) continue;
+    try {
+      const startMs = Date.parse(conversation.startIso);
+      const endMs = conversation.endIso !== void 0 ? Date.parse(conversation.endIso) : Number.NaN;
+      const window = Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs ? { kind: "interval", startUtc: conversation.startIso, endUtc: conversation.endIso } : { kind: "instant", atUtc: conversation.startIso };
+      const anchor = window.kind === "interval" ? new Date(Date.parse(window.endUtc) - 1).toISOString() : window.atUtc;
+      const days = [.../* @__PURE__ */ new Set([localDayKey(anchor, deps.config.timezone), localDayKey(conversation.startIso, deps.config.timezone)])];
+      const outcome = matchDominantPlace(window, segmentsForDays(index, days), policy);
+      if (outcome.status === "matched") {
+        conversation.location = outcome.match.place.label;
+      }
+    } catch {
+    }
+  }
+}
+async function renderDayLocationContext(memoryDir, date, config) {
+  if (!locationTaggingEnabled(config)) return null;
+  const state = await loadLocationSyncState(memoryDir);
+  const segments = [];
+  for (const source of Object.values(state.sources)) {
+    for (const segment of source.days?.[date]?.segments ?? []) segments.push(segment);
+  }
+  if (segments.length === 0) return null;
+  const durations = placeDurations(segments).filter((duration) => ["home", "work", "poi"].includes(duration.place.kind ?? "poi")).sort((a, b) => a.totalMs !== b.totalMs ? b.totalMs - a.totalMs : a.place.id < b.place.id ? -1 : 1);
+  if (durations.length === 0) return null;
+  const lines = durations.map((duration) => {
+    const minutes = Math.round(duration.totalMs / 6e4);
+    const hours = Math.floor(minutes / 60);
+    const rendered = hours <= 0 ? `${minutes}m` : `${hours}h ${String(minutes % 60).padStart(2, "0")}m`;
+    return `- ${duration.place.label.replace(/\s+/g, " ").replace(/[`*_]/g, "").trim()}: ${rendered}`;
+  });
+  return `## Location context
+
+${lines.join("\n")}`;
+}
+
+export {
+  isValidLocationDate,
+  locationDayWindow,
+  localDayKey,
+  bucketObservationsByDay,
+  intervalOverlapMs,
+  observationSegments,
+  placeDurations,
+  dominantPlace,
+  LOCATION_MATCH_MAX_MEMORY_SPAN_MS,
+  LOCATION_TAG_PREFIX,
+  LOCATION_ATTRIBUTE_KEYS,
+  memoryLocationWindow,
+  matchDominantPlace,
+  locationTagSlug,
+  locationTagForPlace,
+  locationAttributesForMatch,
+  planLocationUpdate,
+  LOCATIONS_DIR_NAME,
+  LOCATION_DAY_KIND,
+  LOCATION_DAY_FORMAT_VERSION,
+  locationDayFilePath,
+  locationSyncStateFilePath,
+  emptyLocationSyncState,
+  loadLocationSyncState,
+  saveLocationSyncState,
+  updateLocationSourceDay,
+  hashLocationBody,
+  composeLocationDayBody,
+  composeLocationDayMeta,
+  serializeLocationDay,
+  parseLocationDaySummary,
+  writeLocationDay,
+  readLocationDay,
+  listLocationDayDates,
+  loadDaySegmentIndex,
+  locationTagPolicy,
+  locationTaggingEnabled,
+  tagPersistedMemories,
+  emptyEnrichmentCounts,
+  enrichMemoriesWithLocation,
+  fillWearableConversationLocations,
+  renderDayLocationContext
+};
+//# sourceMappingURL=chunk-TB2MJRI6.js.map