@remnic/core 9.69.56 → 9.69.58

package/dist/chunk-ZHUVMSHI.js

@@ -0,0 +1,731 @@
+import {
+  resolveDefaultNamespaceRoot
+} from "./chunk-MWZMVLXL.js";
+import {
+  StorageManager
+} from "./chunk-S2OBXHMN.js";
+import {
+  composeLocationDayBody,
+  composeLocationDayMeta,
+  emptyEnrichmentCounts,
+  enrichMemoriesWithLocation,
+  isValidLocationDate,
+  listLocationDayDates,
+  loadDaySegmentIndex,
+  loadLocationSyncState,
+  localDayKey,
+  locationDayWindow,
+  locationTaggingEnabled,
+  memoryLocationWindow,
+  observationSegments,
+  parseLocationDaySummary,
+  readLocationDay,
+  serializeLocationDay,
+  updateLocationSourceDay,
+  writeLocationDay
+} from "./chunk-IGEZE6QB.js";
+import {
+  resolveNamespaceCapabilities
+} from "./chunk-JUOZ62Y7.js";
+import {
+  readEnvVar
+} from "./chunk-P2QRMMVQ.js";
+import {
+  EngramAccessInputError
+} from "./chunk-3MUKQQ7A.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/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/backfill.ts
+async function backfillMemoryStorage(config) {
+  const root = resolveNamespaceCapabilities(config).namespaces ? await resolveDefaultNamespaceRoot(config) : config.memoryDir;
+  return new StorageManager(root);
+}
+function memoriesTouchingDay(memories, day, config) {
+  const touched = [];
+  for (const memory of memories) {
+    const result = memoryLocationWindow(memory.frontmatter, (instant) => localDayKey(instant, config.timezone));
+    if (result.days !== void 0 && result.days.includes(day)) touched.push(memory);
+  }
+  touched.sort((a, b) => a.frontmatter.id < b.frontmatter.id ? -1 : a.frontmatter.id > b.frontmatter.id ? 1 : 0);
+  return touched;
+}
+async function backfillLocationTags(options) {
+  if (!locationTaggingEnabled(options.config)) {
+    throw new Error(
+      "location backfill requires location.enabled and location.tagging.enabled (and location.tagging.backfillEnabled for the command surface)"
+    );
+  }
+  const index = await loadDaySegmentIndex(options.memoryDir);
+  const memories = await options.storage.readAllMemories();
+  const days = [];
+  const cursor = /* @__PURE__ */ new Date(`${options.from}T00:00:00Z`);
+  const end = /* @__PURE__ */ new Date(`${options.to}T00:00:00Z`);
+  while (cursor <= end) {
+    const date = cursor.toISOString().slice(0, 10);
+    try {
+      const daySegments = index.get(date);
+      if (daySegments === void 0 || daySegments.every((entry) => entry.segments.length === 0)) {
+        days.push({ date, emptyDay: true, counts: emptyEnrichmentCounts(), considered: 0 });
+      } else {
+        const touching = memoriesTouchingDay(memories, date, options.config);
+        const counts = await enrichMemoriesWithLocation({
+          storage: options.storage,
+          memoryDir: options.memoryDir,
+          config: options.config,
+          memories: touching,
+          index,
+          dryRun: options.dryRun === true
+        });
+        days.push({ date, emptyDay: false, counts, considered: touching.length });
+      }
+    } catch (error) {
+      days.push({
+        date,
+        emptyDay: false,
+        failed: error instanceof Error ? error.message : String(error),
+        counts: emptyEnrichmentCounts(),
+        considered: 0
+      });
+    }
+    cursor.setUTCDate(cursor.getUTCDate() + 1);
+  }
+  return { from: options.from, to: options.to, dryRun: options.dryRun === true, days };
+}
+
+// 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 { from, endDate: to, days };
+}
+async function runLocationBackfill(deps, request = {}) {
+  const range = parseLocationBackfillRange(request.from, request.to);
+  if (!deps.config.enabled || !deps.config.tagging.enabled || !deps.config.tagging.backfillEnabled) {
+    throw new EngramAccessInputError(
+      "location: backfill requires location.enabled, location.tagging.enabled, and location.tagging.backfillEnabled"
+    );
+  }
+  await ensureConfiguredLocationProviders(deps.config);
+  const days = request.dryRun === true ? [] : await syncLocation({ ...deps, endDate: range.endDate, days: range.days });
+  let memory;
+  if (deps.getMemoryStorage !== void 0) {
+    memory = await backfillLocationTags({
+      storage: await deps.getMemoryStorage(),
+      memoryDir: deps.memoryDir,
+      config: deps.config,
+      from: range.from,
+      to: range.endDate,
+      dryRun: request.dryRun === true
+    });
+  }
+  return { days, ...memory !== void 0 ? { memory } : {} };
+}
+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> [--dry-run]
+                                 Sync an explicit historical range (\u2264 90 days)
+                                 and re-tag overlapping memories (requires
+                                 location.tagging.backfillEnabled). --dry-run
+                                 persists nothing: it only reports the memory
+                                 changes stored segments would produce.
+  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", "--dry-run"]);
+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 renderBackfillReport(io, report) {
+  for (const day of report.days) {
+    if (day.emptyDay) {
+      io.stdout.write(`${day.date}: no stored location observations (empty day)
+`);
+      continue;
+    }
+    if (day.failed !== void 0) {
+      io.stdout.write(`${day.date}: FAILED \u2014 ${day.failed}
+`);
+      continue;
+    }
+    const c = day.counts;
+    io.stdout.write(
+      `${day.date}: ${c.tagged} tagged, ${c.updated} updated, ${c.removed} removed, ${c.unchanged} unchanged, ${c.unmatched} unmatched (incl. ambiguous), ${c.manual} manual, ${c.untimed} untimed, ${c.failed} failed, ${day.considered} considered${report.dryRun ? " (dry run)" : ""}
+`
+    );
+  }
+}
+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 result = await runLocationBackfill(deps, {
+          from: flagString(parsed, "--from"),
+          to: flagString(parsed, "--to"),
+          dryRun: parsed.flags.has("--dry-run")
+        });
+        if (parsed.flags.has("--json")) {
+          io.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        } else {
+          renderRuns(io, result.days);
+          if (result.memory !== void 0) renderBackfillReport(io, result.memory);
+        }
+        const memoryFailed = result.memory?.days.some((day) => day.failed !== void 0) === true;
+        return anySourceFailed(result.days) || memoryFailed ? 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,
+  sanitizeProviderError,
+  syncLocationDay,
+  locationStatus,
+  checkLocationSources,
+  syncLocation,
+  backfillMemoryStorage,
+  backfillLocationTags,
+  ensureConfiguredLocationProviders,
+  runLocationStatus,
+  runLocationCheck,
+  runLocationSync,
+  runLocationDay,
+  parseLocationBackfillRange,
+  runLocationBackfill,
+  runLocationCliCommand
+};
+//# sourceMappingURL=chunk-ZHUVMSHI.js.map