@mgcrea/mcp-apple-maps 0.0.0-bootstrap

package/dist/server-DgIy0w0S.js

@@ -0,0 +1,2080 @@
+import { AppleAutomationError, AppleAutomationError as AppleMapsError, BaseConfigSchema, CORE_DATA_EPOCH_OFFSET, IndexUnavailableError, SchemaDriftError, SchemaDriftError as SchemaDriftError$1, columnsOf, compact, describeStore, detectEpoch, escapeLike, fail, fingerprintSchema, inspectFile, limitArg, ok, openReadOnly, parseBool, parseConfig, parseIntOpt, promptArg, readPackageIdentity, registerSurfaceResources, registerWorkflowPrompt, trimmed, wrap, wrapResult } from "@mgcrea/mcp-apple-core";
+import { readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+//#region src/build-info.ts
+const pkg = readPackageIdentity(new URL("../package.json", import.meta.url), {
+	name: "@mgcrea/mcp-apple-maps",
+	version: "0.0.0"
+});
+const BUILD_INFO = {
+	name: pkg.name,
+	version: pkg.version,
+	gitCommit: "1779320",
+	gitCommitDate: "2026-08-30T12:29:09+02:00"
+};
+//#endregion
+//#region src/client/dates.ts
+/**
+* Date handling for the Maps tools.
+*
+* Deliberately much smaller than `packages/safari/src/client/dates.ts`. That
+* surface needed a whole input grammar because history is a range query; Maps'
+* entities are lists a person curates, and v1 ships no tool taking a date
+* argument. So this module solves only the OUTPUT half — turning a stored
+* number into an instant. Inventing a parser nothing calls would be a fourth
+* copy of a grammar `packages/safari` has already noted should be hoisted into
+* core rather than duplicated again.
+*
+* ## The epoch is DETECTED, never assumed
+*
+* `docs/maps.md` records the measurement: `ZCREATETIME` resolves to
+* **apple-seconds** (Core Data, 2001 anchor). The same value read as unix
+* seconds lands in **1995** — well-formed, plausible at a glance, and wrong by
+* 31 years. `pnpm probe:maps` prints both readings side by side precisely
+* because the wrong one does not announce itself.
+*
+* So the offset is resolved from the store's own newest timestamp at open time,
+* and when it cannot be resolved every date renders `null` rather than being
+* guessed. An absent timestamp is a visible gap somebody can report; a
+* confidently wrong one is not. This is the discipline `packages/safari`
+* arrived at after a probe misread its own column — adopted here rather than
+* re-derived.
+*/
+/** What `detectEpoch` says when it has matched nothing. Same shape as Safari's. */
+const GAVE_UP = /^(no dated rows|neither epoch)/;
+const resolveEpoch = (maxTimestamp, now = Date.now()) => {
+	const { offset, reason } = detectEpoch(maxTimestamp, now);
+	return {
+		offset,
+		reason,
+		confident: !GAVE_UP.test(reason)
+	};
+};
+/** The expectation docs/maps.md carries, used only where no store is open. */
+const APPLE_SECONDS = {
+	offset: CORE_DATA_EPOCH_OFFSET,
+	reason: "assumed apple-seconds; no store was opened to measure against",
+	confident: false
+};
+/** A stored timestamp to a JS Date, or null when it cannot be placed. */
+const fromStoreTime = (value, epoch) => {
+	if (value === null || !Number.isFinite(value) || value === 0) return null;
+	if (!epoch.confident) return null;
+	const date = /* @__PURE__ */ new Date((value + epoch.offset) * 1e3);
+	return Number.isNaN(date.getTime()) ? null : date;
+};
+/** ISO-8601, or null. What every date field on a result carries. */
+const renderInstant = (value, epoch) => fromStoreTime(value, epoch)?.toISOString() ?? null;
+//#endregion
+//#region src/client/errors.ts
+/**
+* Maps' error surface. The taxonomy lives in `@mgcrea/mcp-apple-core`; what
+* belongs here is the identity those messages are written against, plus the
+* failures no other surface has.
+*/
+const MAPS_SURFACE = {
+	appName: "Maps",
+	envPrefix: "APPLE_MAPS"
+};
+/**
+* Maps is one of the few Apple apps whose bundle id matches its display name —
+* unlike `com.apple.iCal`, `com.apple.AddressBook` and `com.apple.MobileSMS`.
+* Stated rather than assumed, because this repo has been caught by the opposite
+* three times.
+*
+* It is recorded here and used by almost nothing. Maps ships **no scripting
+* dictionary** — `/System/Applications/Maps.app` contains no `.sdef`, checked
+* directly rather than inferred from `NSAppleScriptEnabled` — so there is no
+* Apple Events lane to address, and this server never sends one.
+*/
+const MAPS_BUNDLE_ID = "com.apple.Maps";
+/**
+* The store could not be read.
+*
+* This surface has **one lane and no fallback**, which puts it with Messages
+* rather than with Safari: without Full Disk Access there is no degraded Maps
+* server, there is no Maps server. So every read throws this rather than
+* returning an empty list — an empty `favorites` reads exactly like a person
+* who has saved no places, and that is the failure this error exists to
+* prevent.
+*
+* The hint names the trap that actually catches people: the store lives at a
+* path with **no file extension**, inside the one directory in Maps' container
+* that Full Disk Access gates. A sweep for `*.db` finds nothing and concludes
+* the data is not on disk. It is.
+*/
+var MapsStoreUnavailableError = class extends AppleAutomationError {
+	name = "MapsStoreUnavailableError";
+	constructor(reason) {
+		super(`${reason} Maps has no second lane — it ships no scripting dictionary, so there is no Apple Events fallback and nothing at all can be read without the grant.`, {});
+	}
+};
+/** A ref no longer resolves — the place was removed, or the store was re-synced. */
+var PlaceNotFoundError = class extends AppleAutomationError {
+	name = "PlaceNotFoundError";
+	constructor(ref) {
+		super(`No place for ref "${ref}". It may have been removed in Maps, or iCloud may have re-synced the store and renumbered it. Re-run the listing to get a current ref.`, { ref });
+	}
+};
+/**
+* The epoch could not be identified from the data.
+*
+* The same discipline `packages/safari` applies, for the same measured reason:
+* a wrong epoch produces dates that are well-formed and wrong by 31 years.
+* `docs/maps.md` records that this store's `ZCREATETIME` read as apple-seconds
+* and that a unix-seconds reading of the same value lands in 1995 while still
+* looking entirely plausible. So the offset is detected from the store at open
+* time and dates are WITHHELD when it cannot be.
+*/
+var UndatableStoreError = class extends AppleAutomationError {
+	name = "UndatableStoreError";
+	constructor(reason) {
+		super(`Maps' timestamps could not be placed on a known epoch (${reason}). Dates are withheld rather than guessed — a timestamp wrong by decades reads exactly like a correct one. Everything that does not depend on a date still works.`, {});
+	}
+};
+//#endregion
+//#region src/client/locate.ts
+/**
+* Find Maps' store.
+*
+* ## The path, and the three ways it was missed
+*
+* `~/Library/Containers/com.apple.Maps/Data/Maps/MapsSync_0.0.1` — 3.3 MB of
+* Core Data on the probed machine. `docs/maps.md` records that this surface was
+* declared "no file lane" three separate times before the file was found, and
+* each failure is a rule this locator is shaped by:
+*
+*   1. **The file has no extension.** A sweep for `*.db` / `*.sqlite*` finds
+*      nothing here. Nothing in this file matches on a suffix.
+*   2. **`Data/Maps/` is gated.** It was the ONE unreadable directory in the
+*      container, so a listing taken without Full Disk Access omits it, and the
+*      omission reads as absence. `inspectFile` splits exists from readable
+*      precisely so those two never collapse into one answer.
+*   3. **`group.com.apple.Maps` is a decoy.** It exists, it is EPERM without the
+*      grant, and it holds three files that are not the store. A probe that
+*      could not descend into it reported it as empty.
+*
+* The rule underneath all three is the one `docs/surfaces.md` states: "'Absent'
+* and 'EPERM' are different findings." Keeping them apart, and saying which one
+* happened, is most of this module's job.
+*
+* ## The device-local cache is located and never read
+*
+* `MapsSync_0.0.1_deviceLocalCache.db` sits beside the store with the same 33
+* entities and, on the probed machine, **zero rows in every one of them**. It is
+* reported by diagnostics so anyone comparing the directory against this
+* server's output can see it was considered, and it is never opened.
+*/
+/** The container path. `Data/Maps` is the gated directory, not `Data/Library`. */
+const MAPS_DIR = [
+	"Library",
+	"Containers",
+	"com.apple.Maps",
+	"Data",
+	"Maps"
+];
+/**
+* No extension, and a version in the name.
+*
+* The `0.0.1` was stable on every machine this project has measured, but it is a
+* version string and it will move. `locateStore` falls back to scanning for a
+* `MapsSync_*` sibling rather than reporting a rename as "Maps has never run".
+*/
+const STORE_FILENAME = "MapsSync_0.0.1";
+const LOCAL_CACHE_SUFFIX = "_deviceLocalCache.db";
+const FDA_HINT = "Grant Full Disk Access to the app running this server (System Settings > Privacy & Security > Full Disk Access) and restart it. Granting it to Maps.app does nothing — the reader needs the permission, not the app.";
+const defaultDirectory = (home = homedir()) => join(home, ...MAPS_DIR);
+const defaultStorePath = (home = homedir()) => join(defaultDirectory(home), STORE_FILENAME);
+const locateFile = (path) => ({
+	...inspectFile(path),
+	path
+});
+/**
+* Look for a `MapsSync_*` that is neither the local cache nor a SQLite sidecar.
+*
+* Only reached when the constant path is absent, and it needs the directory to
+* be listable — the same grant the store itself needs, so this asks for no new
+* permission and simply survives a version bump.
+*/
+const scanForStore = (directory, readdir) => {
+	let names;
+	try {
+		names = readdir(directory);
+	} catch {
+		return null;
+	}
+	const candidate = names.filter((n) => n.startsWith("MapsSync_") && !n.endsWith("_deviceLocalCache.db") && !n.endsWith("-wal") && !n.endsWith("-shm")).toSorted().at(-1);
+	return candidate ? join(directory, candidate) : null;
+};
+const locateStore = (opts = {}) => {
+	const directory = defaultDirectory(opts.home);
+	const readdir = opts.readdir ?? ((p) => readdirSync(p));
+	const explicit = opts.storePath;
+	const constant = defaultStorePath(opts.home);
+	let storePath = explicit ?? constant;
+	let resolvedByScan = false;
+	if (!explicit && !describeStore(constant).exists) {
+		const scanned = scanForStore(directory, readdir);
+		if (scanned) {
+			storePath = scanned;
+			resolvedByScan = true;
+		}
+	}
+	const facts = describeStore(storePath);
+	const reason = facts.readable ? null : facts.exists ? `Found Maps' store at ${storePath} but cannot read it. ${FDA_HINT}` : explicit ? `No file at ${explicit}. APPLE_MAPS_STORE points at nothing.` : `No Maps store at ${storePath}, and no MapsSync_* file in ${directory}. Either Maps has never been used on this account, or the directory itself is not readable — those look identical from outside and only the grant tells them apart. ${FDA_HINT}`;
+	return {
+		...facts,
+		directory,
+		storePath: facts.exists || !explicit ? storePath : null,
+		localCache: locateFile(`${constant}${LOCAL_CACHE_SUFFIX}`),
+		resolvedByScan,
+		reason
+	};
+};
+//#endregion
+//#region src/client/ref.ts
+/**
+* Refs for places and collections.
+*
+* ## Why the ref is not `ZMUID`
+*
+* `ZMUID` is Apple's own place identifier and looks like the better key — it is
+* the same number for the same restaurant across every device. It is not used,
+* for two measured reasons recorded in `docs/maps.md`:
+*
+*   * It is populated **20 of 23** favourites. The three without it are the
+*     rows that have no linked place at all, but a ref scheme that cannot
+*     address three rows in twenty-three is not a ref scheme.
+*   * It identifies a PLACE, not an entry. The same café saved as a favourite
+*     AND filed in a collection carries one `ZMUID` across both, so a ref built
+*     on it could not say which of the two a caller meant.
+*
+* The keys below address the ENTRY, which is what every tool here returns. The
+* kind is carried in the prefix so a favourite ref and a collection-item ref
+* can never be confused for one another.
+*
+* ## What the ref carries: a uuid when the store has one, a row id when it does not
+*
+* `ZIDENTIFIER` — a 16-byte Core Data UUID — is set on every favourite,
+* collection, collection item and recent on a real store, and is distinct on
+* every one. It addresses the ENTRY, survives a delete elsewhere in the table,
+* and survives an iCloud re-sync renumbering rows. It is the ref whenever
+* `store.ts` can confirm total coverage.
+*
+* It was found by watching Maps write, not by reading the schema — see
+* `docs/maps.md`. The read probe never reported it, because a probe can only
+* report columns it thought to look for.
+*
+* When a store has no usable identifier the ref falls back to the Core Data row
+* id, and then the old caveat applies in full: `Z_PK` is reused after a delete
+* and renumbered by a re-sync, so such a ref is only good for the session.
+* `packages/messages` rejected row ids outright for that reason; here they are
+* the degraded mode rather than the design.
+*
+* The two are told apart BY SHAPE — a uuid is 32 hex characters, a row id is
+* decimal — and the resolver refuses to try a uuid against a store with no
+* identifier column rather than reinterpreting it as a number. Silently
+* resolving one key space in the other would find a real but wrong place, which
+* is worse than finding nothing.
+*
+* ## Why `p1:` and `pc1:`
+*
+* `c1:` is Calendar's, `r1:` Reminders', `k1:` Contacts', `n1:` Notes',
+* `m1:`/`mc1:` Messages', `s1:`/`sb1:` Safari's. A ref that decodes under two
+* surfaces is worse than one that decodes under none, so each prefix is claimed
+* once and the version digit keeps a future change additive rather than a
+* silent reinterpretation of refs already sitting in a conversation.
+*/
+const PLACE_REF_VERSION = "p1";
+const COLLECTION_REF_VERSION = "pc1";
+const KIND_CODE = {
+	favorite: "f",
+	"collection-item": "c",
+	history: "h"
+};
+const CODE_KIND = {
+	f: "favorite",
+	c: "collection-item",
+	h: "history"
+};
+const PLACE_PATTERN = /^p1:([fch]):([0-9a-f]{32}|\d+)$/;
+const COLLECTION_PATTERN = /^pc1:([0-9a-f]{32}|\d+)$/;
+/** 32 hex characters is a uuid; anything else that matched the pattern is a row id. */
+const toKey = (raw) => /^[0-9a-f]{32}$/.test(raw) ? { uuid: `${raw.slice(0, 8)}-${raw.slice(8, 12)}-${raw.slice(12, 16)}-${raw.slice(16, 20)}-${raw.slice(20)}` } : { rowId: Number(raw) };
+/** A uuid goes into the ref undashed, so the ref stays one opaque token. */
+const fromKey = (key) => "uuid" in key ? key.uuid.replaceAll("-", "").toLowerCase() : String(key.rowId);
+const otherSurface = (raw) => {
+	if (raw.startsWith("c1:")) return " That one is a Calendar event ref.";
+	if (raw.startsWith("r1:")) return " That one is a Reminders ref.";
+	if (raw.startsWith("k1:")) return " That one is a Contacts ref.";
+	if (raw.startsWith("n1:")) return " That one is a Notes ref.";
+	if (raw.startsWith("mc1:")) return " That one is a Messages chat ref.";
+	if (raw.startsWith("m1:")) return " That one is a Messages message ref.";
+	if (raw.startsWith("sb1:")) return " That one is a Safari bookmark ref.";
+	if (raw.startsWith("s1:")) return " That one is a Safari history ref.";
+	if (raw.startsWith("pc1:")) return " That one is a COLLECTION ref — this wants a place ref.";
+	if (raw.startsWith("p1:")) return " That one is a PLACE ref — this wants a collection ref.";
+	return "";
+};
+var InvalidMapsRefError = class extends AppleAutomationError {
+	name = "InvalidMapsRefError";
+	constructor(raw, want) {
+		super(`"${raw}" is not a ${want} ref. Refs come from apple_maps_* results and look like ${want === "place" ? "\"p1:<kind>:<id>\"" : "\"pc1:<id>\""} — they are opaque and must not be constructed by hand.${otherSurface(raw)}`, { ref: raw });
+	}
+};
+const encodePlaceRef = (kind, key) => `p1:${KIND_CODE[kind]}:${fromKey(key)}`;
+const encodeCollectionRef = (key) => `pc1:${fromKey(key)}`;
+const decodePlaceRef = (raw) => {
+	const m = PLACE_PATTERN.exec(raw.trim());
+	const kind = m?.[1] ? CODE_KIND[m[1]] : void 0;
+	if (!m?.[2] || !kind) throw new InvalidMapsRefError(raw, "place");
+	return {
+		kind,
+		key: toKey(m[2])
+	};
+};
+const decodeCollectionRef = (raw) => {
+	const m = COLLECTION_PATTERN.exec(raw.trim());
+	if (!m?.[1]) throw new InvalidMapsRefError(raw, "collection");
+	return toKey(m[1]);
+};
+//#endregion
+//#region src/client/store.ts
+/**
+* Maps' file lane. There is no other lane.
+*
+* ## What is measured, and what is NOT
+*
+* MEASURED by `pnpm probe:maps` on macOS 26.6 — 146 schema objects, fingerprint
+* `2bbc03143125`, Core Data, `ZCREATETIME` on apple-seconds:
+*
+*     ZFAVORITEITEM     24 rows   ZCOLLECTION      10 rows
+*     ZCOLLECTIONITEM   30 rows   ZHISTORYITEM     34 rows
+*     ZMIXINMAPITEM     71 rows   ZREVIEWEDPLACE   24 rows
+*
+* and the id bridge, verified by running the join rather than by reading column
+* names: `ZMIXINMAPITEM`'s inverse relationships partition exactly —
+* 30 collection items + 21 favourites + 20 history rows = 71 = every row.
+*
+* NOT measured: this file has never been run against the real store by its
+* author, who has no Full Disk Access. Everything below is written against a
+* probe REPORT, which is one step further from the data than
+* `packages/safari/src/client/store.ts` was, and that file already treats every
+* column as optional. This one goes further in two ways.
+*
+* ## Columns are resolved BY COVERAGE, not by first name match
+*
+* The probe found `ZHISTORYITEM` carrying both `ZLATITUDE` (1 of 33 rows) and
+* `ZLATITUDE1` (19 of 33). A resolver that took the first candidate it
+* recognised would pick the column that is null 97% of the time and report that
+* Maps holds almost no coordinates. So each logical field names several
+* candidates and the one with the **most non-null values** wins, counted at
+* open time. That is a real query per candidate, run once, on tables of tens of
+* rows.
+*
+* ## Collection membership is a JOIN TABLE, and it is VALIDATED not guessed
+*
+* MEASURED: membership is `Z_6PLACES(Z_6COLLECTIONS, Z_7PLACES)`, a Core Data
+* many-to-many. `Z_PRIMARYKEY` decodes ordinal 6 as Collection and 7 as
+* CollectionItem, so the relationship is `Collection.places`.
+*
+* Four column names were guessed here before it was found — ZCOLLECTION,
+* ZCOLLECTION1, ZPARENTCOLLECTION, ZOWNINGCOLLECTION — and the store has none
+* of them, so every guide listed empty. A many-to-many leaves NO COLUMN on
+* either entity, so no list of column names could have contained the answer.
+* The near-miss is what makes this worth stating: `ZCOLLECTIONITEM.ZMAPITEM`
+* joins `ZCOLLECTION` for 3 of 10 collections, and a resolver picking the
+* best-covered joinable column would have chosen it and been confidently wrong.
+*
+* So membership is resolved BY RUNNING THE JOIN and scoring it against an
+* oracle the store hands over for free: `ZCOLLECTION.ZPLACESCOUNT`, Maps' own
+* count per guide. A candidate is accepted only when it reproduces all ten
+* numbers exactly with no key pointing at a missing collection. That survives
+* Apple renaming the relationship, which a hard-coded `Z_6PLACES` would not.
+*
+* The oracle is not independent evidence, and it is stronger for it. Core Data
+* maintains `ZPLACESCOUNT` with a trigger that reads:
+*
+*     UPDATE ZCOLLECTION SET ZPLACESCOUNT =
+*       (SELECT IFNULL(COUNT(Z_6COLLECTIONS), 0)
+*          FROM Z_6PLACES WHERE Z_6COLLECTIONS = NEW.Z_PK)
+*
+* so Apple's own schema states the relationship this resolver re-derives. The
+* count match is therefore guaranteed for the true mechanism rather than lucky,
+* and coincidental for anything else. The triggers are visible only in the
+* captured fixture — `pnpm probe:maps --write` omits them from the replay
+* because they call Core Data's private SQLite functions, which is recorded in
+* `writeFixture`.
+*
+* Because it is many-to-many, one place can sit in several guides, and the
+* membership query uses `IN (SELECT ...)` rather than a JOIN so a place in two
+* guides is not returned twice from one of them.
+*
+* MEASURED: 30 item rows, 18 of them in a guide. The other 12 belong to no
+* collection at all; all 30 link to a `ZMIXINMAPITEM`, so they are intact
+* places rather than broken rows.
+*
+* `SchemaDriftError` fires for exactly one condition — none of the three
+* place-bearing tables exists — because without them there is no surface.
+* Everything else is a capability downgrade that is reported, never a throw.
+*/
+const FAVORITES_TABLE = "ZFAVORITEITEM";
+const COLLECTIONS_TABLE = "ZCOLLECTION";
+const COLLECTION_ITEMS_TABLE = "ZCOLLECTIONITEM";
+const HISTORY_TABLE = "ZHISTORYITEM";
+const MAP_ITEMS_TABLE = "ZMIXINMAPITEM";
+/**
+* Candidates per logical field, best-known first — but order only breaks ties.
+* Coverage decides. See the header.
+*/
+const NAME_CANDIDATES = [
+	"ZMAPITEMNAME",
+	"ZCUSTOMNAME",
+	"ZLOCATIONDISPLAY",
+	"ZTITLE"
+];
+const LAT_CANDIDATES = ["ZLATITUDE", "ZLATITUDE1"];
+const LON_CANDIDATES = ["ZLONGITUDE", "ZLONGITUDE1"];
+const ADDRESS_CANDIDATES = ["ZMAPITEMADDRESS", "ZORIGINATINGADDRESSSTRING"];
+const MUID_CANDIDATES = ["ZMUID"];
+const MAP_ITEM_FK_CANDIDATES = ["ZMAPITEM"];
+const CREATED_CANDIDATES = ["ZCREATETIME"];
+const MODIFIED_CANDIDATES = ["ZMODIFICATIONTIME"];
+const COLLECTION_TITLE_CANDIDATES = [
+	"ZTITLE",
+	"ZNAME",
+	"ZCUSTOMNAME"
+];
+/**
+* The stable per-entry identifier, if this store has one.
+*
+* FOUND BY WATCHING MAPS WRITE, not by reading the schema: every row Maps
+* created during `pnpm probe:maps-write` carried `ZIDENTIFIER`, a 16-byte blob
+* — a UUID. It is not in the read probe's report because that probe only looked
+* for columns it already had candidates for, which is a good argument for
+* diffing a live write even when the read surface already works.
+*
+* `ZORIGINALIDENTIFIER` is deliberately NOT a candidate. It exists on
+* `ZCOLLECTIONITEM` and is populated on 3 rows of 30 — it records where an entry
+* was copied FROM, so it is neither complete nor unique to the entry.
+*/
+const IDENTIFIER_CANDIDATES = ["ZIDENTIFIER"];
+/**
+* Maps' own count of the places in a guide, and the oracle every membership
+* candidate is scored against. See the header.
+*/
+const COLLECTION_COUNT_COLUMN = "ZPLACESCOUNT";
+/** Core Data's own tables, which are never a relationship. */
+const RESERVED_JOIN_TABLES = /* @__PURE__ */ new Set([
+	"Z_METADATA",
+	"Z_MODELCACHE",
+	"Z_PRIMARYKEY"
+]);
+const isRealTable = (name) => !name.startsWith("sqlite_");
+/**
+* `HEX()` of a 16-byte blob to a canonical UUID.
+*
+* Returns null on anything that is not exactly 32 hex characters. Core Data
+* stores a UUID attribute as 16 raw bytes, so a different length means the
+* column is not what this code thinks it is — and a malformed ref that still
+* looks ref-shaped would be resolved against the wrong row rather than rejected.
+*/
+const toUuid = (hex) => {
+	if (hex === null || hex === void 0) return null;
+	const h = String(hex).toLowerCase();
+	if (!/^[0-9a-f]{32}$/.test(h)) return null;
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+};
+/** A `NULL AS alias` column reads back as null; every other value is coerced. */
+const num = (v) => v === null || v === void 0 ? null : Number(v);
+const str = (v) => v === null || v === void 0 ? null : String(v);
+/**
+* Pick the candidate column with the most non-null values.
+*
+* Returns null when none of the candidates exists, and also when they all exist
+* and are all empty — an all-null column is not a usable field, and reporting
+* one as resolved would produce a result whose every value is null with no
+* explanation.
+*/
+const resolveField = (db, table, columns, candidates, rows) => {
+	const present = candidates.filter((c) => columns.has(c));
+	if (present.length === 0) return null;
+	if (rows === 0) return present[0] ?? null;
+	let best = null;
+	for (const name of present) {
+		let count = 0;
+		try {
+			count = Number(db.prepare(`SELECT COUNT("${name}") AS c FROM "${table}"`).get().c);
+		} catch {
+			continue;
+		}
+		if (!best || count > best.count) best = {
+			name,
+			count
+		};
+	}
+	return best && best.count > 0 ? best.name : present[0] ?? null;
+};
+/**
+* The identifier column, but ONLY if it can actually carry every ref.
+*
+* Coverage is not enough here, and this is the difference between a fix and a
+* trap. A column populated on the rows Maps has written lately and null on the
+* ones that predate it would work perfectly for every place the user saves from
+* now on and fail silently for the places they already had — the failure mode
+* hardest to notice and worst to hit, since the older entries are the ones a
+* person is most likely to ask about.
+*
+* So the bar is TOTAL: set on every row, and distinct across every row. Anything
+* less returns null and the store falls back to `Z_PK`, which is worse but
+* uniformly worse. Measured on a real store: 24/24 favourites, 30/30 collection
+* items, 10/10 collections, 33/33 recents, all distinct.
+*/
+const resolveIdentifier = (db, table, columns, rows) => {
+	const present = IDENTIFIER_CANDIDATES.filter((c) => columns.has(c));
+	if (present.length === 0 || rows === 0) return null;
+	for (const name of present) try {
+		const r = db.prepare(`SELECT COUNT("${name}") AS nset, COUNT(DISTINCT "${name}") AS ndistinct FROM "${table}"`).get();
+		if (Number(r.nset) === rows && Number(r.ndistinct) === rows) return name;
+	} catch {
+		continue;
+	}
+	return null;
+};
+const countRows = (db, table) => {
+	try {
+		return Number(db.prepare(`SELECT COUNT(*) AS c FROM "${table}"`).get().c);
+	} catch {
+		return 0;
+	}
+};
+const describeEntity = (db, table, tables, nameCandidates = NAME_CANDIDATES) => {
+	const present = tables.includes(table);
+	if (!present) return {
+		table,
+		present: false,
+		rows: 0,
+		columns: /* @__PURE__ */ new Set(),
+		fields: {
+			identifier: null,
+			name: null,
+			customName: null,
+			latitude: null,
+			longitude: null,
+			address: null,
+			muid: null,
+			mapItem: null,
+			created: null,
+			modified: null
+		}
+	};
+	const columns = new Set(columnsOf(db, table));
+	const rows = countRows(db, table);
+	const pick = (cands) => resolveField(db, table, columns, cands, rows);
+	return {
+		table,
+		present,
+		rows,
+		columns,
+		fields: {
+			identifier: resolveIdentifier(db, table, columns, rows),
+			name: pick(nameCandidates),
+			customName: columns.has("ZCUSTOMNAME") ? "ZCUSTOMNAME" : null,
+			latitude: pick(LAT_CANDIDATES),
+			longitude: pick(LON_CANDIDATES),
+			address: pick(ADDRESS_CANDIDATES),
+			muid: pick(MUID_CANDIDATES),
+			mapItem: pick(MAP_ITEM_FK_CANDIDATES),
+			created: pick(CREATED_CANDIDATES),
+			modified: pick(MODIFIED_CANDIDATES)
+		}
+	};
+};
+/**
+* Maps' own places-per-guide, keyed by collection row id.
+*
+* Null when the store has no `ZPLACESCOUNT`, which changes what the resolver
+* below is allowed to accept — see `resolveMembership`.
+*/
+const declaredCounts = (db, collections) => {
+	if (!collections.present || !collections.columns.has(COLLECTION_COUNT_COLUMN)) return null;
+	try {
+		const rows = db.prepare(`SELECT "Z_PK" AS pk, "${COLLECTION_COUNT_COLUMN}" AS n FROM "${collections.table}"`).all();
+		return new Map(rows.map((r) => [Number(r.pk), Number(r.n ?? 0)]));
+	} catch {
+		return null;
+	}
+};
+/**
+* Group a candidate's keys and count the items under each.
+*
+* Keys are read as TEXT because `ZMUID` is an INTEGER column holding 64-bit
+* place ids, and `node:sqlite` THROWS on those rather than truncating — reading
+* raw would drop the candidate into a catch instead of rejecting it on the
+* evidence. See `PlaceRow.muid`.
+*/
+const tally = (db, sql) => {
+	try {
+		const rows = db.prepare(sql).all();
+		return new Map(rows.filter((r) => r.pk !== null).map((r) => [Number(r.pk), Number(r.n)]));
+	} catch {
+		return /* @__PURE__ */ new Map();
+	}
+};
+/**
+* Does this candidate reproduce Maps' own counts, exactly, for every guide?
+*
+* Exactness is the whole test. `ZCOLLECTIONITEM.ZMAPITEM` matches 3 of 10
+* collections by coincidence, so "mostly right" is precisely the answer that
+* must be rejected. A key pointing at no collection at all (`unknown`) is
+* disqualifying for the same reason.
+*/
+const reproducesCounts = (declared, tallies) => {
+	for (const pk of tallies.keys()) if (!declared.has(pk)) return false;
+	for (const [pk, n] of declared) if ((tallies.get(pk) ?? 0) !== n) return false;
+	return true;
+};
+/**
+* Find how an item belongs to a collection, by running each candidate join.
+*
+* Scalar columns are tried before join tables only so the cheaper query runs
+* first; the verdict does not depend on order, because a candidate is accepted
+* only when it reproduces every count. When several would qualify the first is
+* taken, and that ambiguity cannot arise on a store whose counts are distinct.
+*
+* WITHOUT the oracle the bar changes rather than disappearing: a single join
+* table whose every key resolves on both sides is accepted, and anything
+* ambiguous is refused. That is weaker evidence, and it is the reason the
+* result is reported to callers rather than assumed.
+*/
+const resolveMembership = (db, collectionItems, collections, tables) => {
+	if (!collectionItems.present || !collections.present) return null;
+	const declared = declaredCounts(db, collections);
+	if (declared) for (const column of collectionItems.columns) {
+		if ([
+			"Z_PK",
+			"Z_ENT",
+			"Z_OPT"
+		].includes(column)) continue;
+		const tallies = tally(db, `SELECT CAST(t."${column}" AS TEXT) AS pk, COUNT(*) AS n FROM "${collectionItems.table}" t
+           WHERE t."${column}" IS NOT NULL GROUP BY t."${column}"`);
+		if (tallies.size > 0 && reproducesCounts(declared, tallies)) return {
+			kind: "column",
+			column
+		};
+	}
+	const joinTables = tables.filter((t) => t.startsWith("Z_") && !RESERVED_JOIN_TABLES.has(t));
+	const accepted = [];
+	for (const table of joinTables) {
+		const columns = columnsOf(db, table);
+		for (const collectionColumn of columns) for (const itemColumn of columns) {
+			if (collectionColumn === itemColumn) continue;
+			const tallies = tally(db, `SELECT CAST(j."${collectionColumn}" AS TEXT) AS pk, COUNT(*) AS n FROM "${table}" j
+             JOIN "${collectionItems.table}" t ON t."Z_PK" = j."${itemColumn}"
+           GROUP BY j."${collectionColumn}"`);
+			if (tallies.size === 0) continue;
+			if (declared) {
+				if (reproducesCounts(declared, tallies)) return {
+					kind: "joinTable",
+					table,
+					collectionColumn,
+					itemColumn
+				};
+				continue;
+			}
+			if (tally(db, `SELECT CAST(j."${collectionColumn}" AS TEXT) AS pk, COUNT(*) AS n FROM "${table}" j
+             LEFT JOIN "${collections.table}" c ON c."Z_PK" = j."${collectionColumn}"
+           WHERE c."Z_PK" IS NULL GROUP BY j."${collectionColumn}"`).size === 0) accepted.push({
+				kind: "joinTable",
+				table,
+				collectionColumn,
+				itemColumn
+			});
+		}
+	}
+	return accepted.length === 1 ? accepted[0] ?? null : null;
+};
+/** The mechanism as one short string, for diagnostics. */
+const describeMembership = (m) => {
+	if (!m) return null;
+	return m.kind === "column" ? m.column : `${m.table}(${m.collectionColumn}, ${m.itemColumn})`;
+};
+const introspect = (db, now = Date.now()) => {
+	const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' ORDER BY name`).all().map((r) => r.name).filter(isRealTable);
+	const favorites = describeEntity(db, FAVORITES_TABLE, tables);
+	const collectionItems = describeEntity(db, COLLECTION_ITEMS_TABLE, tables);
+	const history = describeEntity(db, HISTORY_TABLE, tables);
+	if (!favorites.present && !collectionItems.present && !history.present) throw new SchemaDriftError(`Maps' store has none of "${FAVORITES_TABLE}", "${COLLECTION_ITEMS_TABLE}" or "${HISTORY_TABLE}" (found: ${tables.join(", ") || "nothing"}). This is either not a MapsSync store or Apple has restructured it. Nothing can be read from it.`);
+	const collections = describeEntity(db, COLLECTIONS_TABLE, tables, COLLECTION_TITLE_CANDIDATES);
+	const mapItems = describeEntity(db, MAP_ITEMS_TABLE, tables);
+	const membership = resolveMembership(db, collectionItems, collections, tables);
+	const dated = [
+		favorites,
+		collectionItems,
+		history,
+		mapItems
+	].filter((e) => e.present && e.rows > 0 && e.fields.created).toSorted((a, b) => b.rows - a.rows)[0];
+	let maxCreated = null;
+	if (dated?.fields.created) try {
+		maxCreated = db.prepare(`SELECT MAX(CAST("${dated.fields.created}" AS REAL)) AS m FROM "${dated.table}"`).get().m;
+	} catch {
+		maxCreated = null;
+	}
+	return {
+		fingerprint: fingerprintSchema(db),
+		tables,
+		favorites,
+		collections,
+		collectionItems,
+		history,
+		mapItems,
+		membership,
+		collectionFk: describeMembership(membership),
+		epoch: resolveEpoch(maxCreated, now)
+	};
+};
+var MapsStore = class {
+	db;
+	caps;
+	path;
+	mode;
+	constructor(opts) {
+		this.db = opts.db;
+		this.caps = opts.caps;
+		this.path = opts.path;
+		this.mode = opts.mode;
+	}
+	/**
+	* One column, or `NULL` under the same alias when it could not be resolved.
+	*
+	* The same guard `packages/safari` uses, and needed more here: this schema was
+	* read from a probe report rather than from the database, so a wrong
+	* expectation should cost one field instead of the whole lane.
+	*/
+	#col(column, alias, table = "t") {
+		return column ? `${table}."${column}" AS ${alias}` : `NULL AS ${alias}`;
+	}
+	/**
+	* The same, for a column whose value may not fit in a JS double.
+	*
+	* SQLite holds 64-bit integers; a JS number holds 53 bits of them, and
+	* `node:sqlite` refuses rather than silently losing precision. Casting in SQL
+	* keeps the exact value and moves the decision about what to do with it out
+	* of the driver.
+	*/
+	#colText(column, alias, table = "t") {
+		return column ? `CAST(${table}."${column}" AS TEXT) AS ${alias}` : `NULL AS ${alias}`;
+	}
+	#placeSelect(e) {
+		const f = e.fields;
+		return [
+			`t."Z_PK" AS id`,
+			f.identifier ? `HEX(t."${f.identifier}") AS uuid` : `NULL AS uuid`,
+			this.#col(f.name, "name"),
+			this.#col(f.customName, "customName"),
+			this.#col(f.latitude, "latitude"),
+			this.#col(f.longitude, "longitude"),
+			this.#col(f.address, "address"),
+			this.#colText(f.muid, "muid"),
+			this.#col(f.created, "createdRaw"),
+			this.#col(f.modified, "modifiedRaw"),
+			f.mapItem ? `t."${f.mapItem}" AS mapItem` : `NULL AS mapItem`
+		].join(", ");
+	}
+	#toPlace(r) {
+		return {
+			id: Number(r.id),
+			uuid: toUuid(r.uuid),
+			name: str(r.name),
+			customName: str(r.customName),
+			latitude: num(r.latitude),
+			longitude: num(r.longitude),
+			address: str(r.address),
+			muid: r.muid === null || r.muid === void 0 || String(r.muid) === "0" ? null : String(r.muid),
+			createdRaw: num(r.createdRaw),
+			modifiedRaw: num(r.modifiedRaw),
+			linked: r.mapItem !== null && r.mapItem !== void 0
+		};
+	}
+	#entityFor(kind) {
+		if (kind === "favorite") return this.caps.favorites;
+		if (kind === "collection-item") return this.caps.collectionItems;
+		return this.caps.history;
+	}
+	/**
+	* Items belonging to no collection at all, or null when unanswerable.
+	*
+	* MEASURED: 30 collection items, 18 filed in a guide, 12 in none — and Core
+	* Data has deleted nothing (`Z_PRIMARYKEY.Z_MAX` equals the live count for
+	* both `Collection` and `CollectionItem`), so these are not the debris of
+	* removed guides. 7 of the 12 appear nowhere else in the store: not as a
+	* favourite, not in another guide, not in recents. They are places the user
+	* saved that no other tool can reach.
+	*
+	* `NOT IN` needs the null guard. A subquery yielding a single NULL makes
+	* `NOT IN` false for EVERY row, so the filter would silently return nothing
+	* and read as "you have no unfiled places" — the failure this whole surface
+	* keeps having to design against.
+	*/
+	#unfiledClause() {
+		const m = this.caps.membership;
+		if (!m) return null;
+		if (m.kind === "column") return `t."${m.column}" IS NULL`;
+		return `t."Z_PK" NOT IN (SELECT j."${m.itemColumn}" FROM "${m.table}" j WHERE j."${m.itemColumn}" IS NOT NULL)`;
+	}
+	/** How many collection items are filed in no collection; null when unknown. */
+	unfiledCount() {
+		const e = this.caps.collectionItems;
+		const clause = this.#unfiledClause();
+		if (!e.present || !clause) return null;
+		try {
+			return Number(this.db.prepare(`SELECT COUNT(*) AS c FROM "${e.table}" t WHERE ${clause}`).get().c);
+		} catch {
+			return null;
+		}
+	}
+	/** One entity's places, newest first when a date is available. */
+	places(kind, opts) {
+		const e = this.#entityFor(kind);
+		if (!e.present || e.rows === 0) return {
+			rows: [],
+			truncated: false
+		};
+		const where = [];
+		const params = [];
+		if (opts.collectionId !== void 0) {
+			const m = this.caps.membership;
+			if (!m) return {
+				rows: [],
+				truncated: false
+			};
+			if (m.kind === "column") where.push(`t."${m.column}" = ?`);
+			else where.push(`t."Z_PK" IN (SELECT j."${m.itemColumn}" FROM "${m.table}" j WHERE j."${m.collectionColumn}" = ?)`);
+			params.push(opts.collectionId);
+		}
+		if (opts.unfiled) {
+			const clause = this.#unfiledClause();
+			if (!clause) return {
+				rows: [],
+				truncated: false
+			};
+			where.push(clause);
+		}
+		if (opts.query) {
+			const pattern = `%${escapeLike(opts.query)}%`;
+			const clauses = [];
+			for (const col of [
+				e.fields.name,
+				e.fields.customName,
+				e.fields.address
+			]) {
+				if (!col) continue;
+				clauses.push(`t."${col}" LIKE ? ESCAPE '\\'`);
+				params.push(pattern);
+			}
+			if (clauses.length === 0) return {
+				rows: [],
+				truncated: false
+			};
+			where.push(`(${clauses.join(" OR ")})`);
+		}
+		const limit = Math.max(1, opts.limit);
+		params.push(limit + 1);
+		const order = e.fields.modified ? `t."${e.fields.modified}" DESC` : e.fields.created ? `t."${e.fields.created}" DESC` : `t."Z_PK" DESC`;
+		const sql = `SELECT ${this.#placeSelect(e)} FROM "${e.table}" t ` + (where.length ? `WHERE ${where.join(" AND ")} ` : "") + `ORDER BY ${order} LIMIT ?`;
+		const raw = this.db.prepare(sql).all(...params);
+		return {
+			rows: raw.slice(0, limit).map((r) => this.#toPlace(r)),
+			truncated: raw.length > limit
+		};
+	}
+	/**
+	* The WHERE clause and parameter for one key, or null when the key cannot be
+	* honoured against this entity.
+	*
+	* A uuid key against a store with no resolved identifier column returns null
+	* rather than falling back to the row id. The two number spaces are unrelated,
+	* so a fallback would resolve to a real but WRONG place — the one outcome
+	* worse than not finding it.
+	*
+	* `HEX()` on both sides rather than `X'..'` literal: it keeps the comparison
+	* in one form, and these tables are tens of rows, so the lost index is free.
+	*/
+	#keyClause(e, key) {
+		if ("uuid" in key) {
+			if (!e.fields.identifier) return null;
+			return {
+				sql: `HEX(t."${e.fields.identifier}") = ?`,
+				param: key.uuid.replaceAll("-", "").toUpperCase()
+			};
+		}
+		return {
+			sql: `t."Z_PK" = ?`,
+			param: key.rowId
+		};
+	}
+	/** One place by entity and key. */
+	place(kind, key) {
+		const e = this.#entityFor(kind);
+		if (!e.present) return null;
+		const clause = this.#keyClause(e, key);
+		if (!clause) return null;
+		const sql = `SELECT ${this.#placeSelect(e)} FROM "${e.table}" t WHERE ${clause.sql} LIMIT 1`;
+		const r = this.db.prepare(sql).get(clause.param);
+		return r ? this.#toPlace(r) : null;
+	}
+	/**
+	* A collection key to the row id its items point at.
+	*
+	* Collection membership is a Core Data foreign key, so it holds `Z_PK` values
+	* whatever the ref carries. A uuid ref has to be translated before it can
+	* filter items, and this is the one place that happens.
+	*/
+	collectionRowId(key) {
+		if (!("uuid" in key)) return key.rowId;
+		const e = this.caps.collections;
+		const clause = this.#keyClause(e, key);
+		if (!e.present || !clause) return null;
+		const r = this.db.prepare(`SELECT t."Z_PK" AS id FROM "${e.table}" t WHERE ${clause.sql} LIMIT 1`).get(clause.param);
+		return r ? Number(r.id) : null;
+	}
+	collections(opts) {
+		const e = this.caps.collections;
+		if (!e.present || e.rows === 0) return {
+			rows: [],
+			truncated: false
+		};
+		const limit = Math.max(1, opts.limit);
+		const hasCount = e.columns.has("ZPLACESCOUNT");
+		const order = e.fields.modified ? `t."${e.fields.modified}" DESC` : `t."Z_PK" DESC`;
+		const sql = `SELECT t."Z_PK" AS id, ${e.fields.identifier ? `HEX(t."${e.fields.identifier}") AS uuid` : `NULL AS uuid`}, ${this.#col(e.fields.name, "title")}, ${hasCount ? `t."ZPLACESCOUNT" AS placesCount` : `NULL AS placesCount`}, ${this.#col(e.fields.created, "createdRaw")}, ${this.#col(e.fields.modified, "modifiedRaw")} FROM "${e.table}" t ORDER BY ${order} LIMIT ?`;
+		const raw = this.db.prepare(sql).all(limit + 1);
+		return {
+			rows: raw.slice(0, limit).map((r) => ({
+				id: Number(r.id),
+				uuid: toUuid(r.uuid),
+				title: r.title === null || r.title === void 0 ? null : String(r.title),
+				placesCount: r.placesCount === null ? null : Number(r.placesCount),
+				createdRaw: r.createdRaw === null ? null : Number(r.createdRaw),
+				modifiedRaw: r.modifiedRaw === null ? null : Number(r.modifiedRaw)
+			})),
+			truncated: raw.length > limit
+		};
+	}
+	close() {
+		try {
+			this.db.close();
+		} catch {}
+	}
+};
+const openStore = (opts) => {
+	const opened = openReadOnly(opts.path, opts.mode ?? "auto", {
+		envVar: "APPLE_MAPS_INDEX_MODE",
+		label: "Maps' place store",
+		...opts.hint ? { hint: opts.hint } : {},
+		validate: (db) => introspect(db, opts.now),
+		fatal: (err) => err instanceof SchemaDriftError,
+		onFallback: () => opts.logger?.warn?.("maps: opened immutable; places saved since the last checkpoint may be missing")
+	});
+	return new MapsStore({
+		db: opened.db,
+		caps: opened.validated,
+		path: opts.path,
+		mode: opened.mode
+	});
+};
+//#endregion
+//#region src/client/write.ts
+/**
+* Writing to Maps' store.
+*
+* ## Why this is SQL and not the app's own API
+*
+* Maps ships no scripting dictionary and registers no App Intents on macOS, so
+* there is no lane where the app performs the write on our behalf. Every other
+* surface in this repo writes through an Apple Event; this one cannot, and the
+* alternatives were measured rather than assumed — see `docs/maps.md`.
+*
+* ## The one thing that cannot be synthesised, and how it is obtained anyway
+*
+* A place is only real to Maps if it has a `ZMAPITEMSTORAGE` — a GEO protobuf of
+* one to four kilobytes that this repo has never decoded and cannot generate.
+*
+* It does not have to. **Opening a place makes Maps write one.**
+* `maps://?q=<name>&ll=<lat>,<lon>` goes through LaunchServices — not Apple
+* Events, not Accessibility — and Maps resolves the place and records it in
+* Recents with a full record attached. That record is then copied into the new
+* favourite. The blob is always minted by Maps, which is the only thing that can
+* mint one correctly.
+*
+* MEASURED consequences of that design, all of them in `docs/maps.md`:
+*
+*   * The insert needs THREE tables — the favourite, its map item, and the two
+*     `Z_PRIMARYKEY` counters. Not the eight the app touches.
+*   * No persistent history and no `NSCK*` metadata is written. Core Data
+*     reconciles unregistered objects on the app's next save and mirrors them to
+*     iCloud by itself; a favourite written this way reached another device.
+*   * It works with Maps RUNNING, and survives a subsequent save by the app.
+*     There is no need to quit anything.
+*
+* ## The cost the caller must be told about
+*
+* Seeding leaves the place in the user's **Recents**, whether or not the
+* favourite is kept. That is unavoidable — it is the mechanism — so every tool
+* built on this says so in its description rather than springing it on somebody.
+*
+* ## Why writes are dangerous here in a way the other surfaces are not
+*
+* The store is mirrored by `NSPersistentCloudKitContainer`, and mirroring does
+* not wait to be told. A malformed row is not a local mistake: it reaches every
+* device on the account as soon as Maps next runs. There is no such thing as a
+* local-only insert here — that was believed for a while and measured false.
+* Hence: never fabricate a place record, only ever copy one Maps wrote.
+*/
+const STORAGE_POLL_MS = 250;
+/**
+* Progress, on stderr.
+*
+* Adding a favourite can take tens of seconds — Maps has to resolve a place over
+* the network before there is anything to copy — and the first version said
+* NOTHING for the whole of it. That is indistinguishable from a hang, and was
+* reported as one three times while three different theories were tried. A long
+* operation that reports nothing cannot be diagnosed, only guessed at.
+*
+* stderr because this is an MCP stdio server: stdout carries the protocol, and
+* the server already writes its banner here.
+*/
+const progress = (message) => {
+	process.stderr.write(`[apple-maps-mcp] ${message}\n`);
+};
+var MapsWriteError = class extends AppleAutomationError {
+	name = "MapsWriteError";
+};
+const defaultOpenUrl = (url) => {
+	execFileSync("/usr/bin/open", ["-g", url], {
+		timeout: 1e4,
+		stdio: "ignore"
+	});
+};
+const uuidBytes = () => Uint8Array.from(Buffer.from(randomUUID().replaceAll("-", ""), "hex"));
+const uuidOf = (bytes) => {
+	const h = Buffer.from(bytes).toString("hex");
+	return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+};
+/**
+* Coordinates are floats and never compare exactly across sources, so identity
+* is "within about a metre" rather than equality. 1e-5 degrees is ~1.1 m of
+* latitude — close enough that two rows are the same doorway, far enough apart
+* that neighbouring shops are not merged.
+*/
+const NEAR = 1e-5;
+/** Same doorway, within about a metre. */
+const near = (aLat, aLon, bLat, bLon) => Math.abs(aLat - bLat) <= SEED_TOLERANCE && Math.abs(aLon - bLon) <= SEED_TOLERANCE;
+/**
+* How far a seeded place may sit from the coordinate the caller gave.
+*
+* Far looser than `NEAR`: the caller's coordinate and Apple's for the same place
+* routinely differ by a building's width, and a search resolves to the entrance
+* rather than the pin. ~250 m accepts that and still rejects a different town.
+*/
+const SEED_TOLERANCE = .0025;
+const toRad = (deg) => deg * Math.PI / 180;
+/** Metres between two coordinates, for the error message only. */
+const haversineMetres = (aLat, aLon, bLat, bLon) => {
+	const dLat = toRad(bLat - aLat);
+	const dLon = toRad(bLon - aLon);
+	const h = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(aLat)) * Math.cos(toRad(bLat)) * Math.sin(dLon / 2) ** 2;
+	return 12742e3 * Math.asin(Math.sqrt(h));
+};
+var MapsWriter = class {
+	#path;
+	#openUrl;
+	#seedTimeoutMs;
+	constructor(opts) {
+		this.#path = opts.storePath;
+		this.#openUrl = opts.openUrl ?? defaultOpenUrl;
+		this.#seedTimeoutMs = opts.seedTimeoutMs ?? 3e4;
+	}
+	/**
+	* A read-write handle.
+	*
+	* `busy_timeout` is not optional: Maps and `mapssyncd` hold this store open,
+	* and without it a write during ordinary use is refused outright rather than
+	* waiting for the lock the way any other SQLite client would.
+	*/
+	#open() {
+		const db = new DatabaseSync(this.#path);
+		db.exec("PRAGMA busy_timeout = 5000");
+		return db;
+	}
+	#entity(db, name) {
+		const row = db.prepare(`SELECT Z_ENT AS e FROM Z_PRIMARYKEY WHERE Z_NAME = ?`).get(name);
+		if (!row) throw new MapsWriteError(`This store has no "${name}" entity, so it cannot be written.`);
+		return Number(row.e);
+	}
+	/**
+	* The next primary key: one past whichever is HIGHER, the counter or the
+	* highest row actually present.
+	*
+	* `Z_PRIMARYKEY.Z_MAX` is the counter Core Data maintains, and trusting it
+	* alone is what a first version did. It is not always current — Maps can be
+	* mid-write, a crash can leave it behind, and a foreign writer that forgot to
+	* bump it (a mistake this very file guards against making) leaves it stale
+	* forever. Taking `MAX(Z_PK)` as well costs one indexed lookup and makes a
+	* collision impossible rather than unlikely.
+	*
+	* Found by a test whose stand-in for Maps inserted a row without bumping the
+	* counter. The stand-in was unfaithful; the bug it exposed was not.
+	*/
+	#nextPk(db, name, table) {
+		const counter = db.prepare(`SELECT Z_MAX AS m FROM Z_PRIMARYKEY WHERE Z_NAME = ?`).get(name);
+		const highest = db.prepare(`SELECT MAX(Z_PK) AS m FROM "${table}"`).get();
+		return Math.max(Number(counter?.m ?? 0), Number(highest?.m ?? 0)) + 1;
+	}
+	/**
+	* An existing favourite for this place.
+	*
+	* Two ways to match, because a coordinate alone is not enough in either
+	* direction. TIGHT coordinate (~1 m) catches the canonical case, where both
+	* numbers came from Maps. NAME plus a LOOSE coordinate (~250 m) catches the
+	* case that matters to a caller: it passed its own coordinate, which differs
+	* from Apple's by a building's width — measured at 6.9e-5 for Sagrada Família.
+	*
+	* Without the second, every repeated call re-seeded before discovering the
+	* duplicate, leaving a Recents entry each time for a favourite it then did not
+	* create. Loosening the coordinate ALONE was the wrong fix: two different shops
+	* 200 m apart would merge. Requiring the name as well makes the loose radius
+	* safe, because it only ever merges rows the caller already calls the same
+	* thing.
+	*/
+	#existingFavorite(db, lat, lon, name) {
+		const tight = db.prepare(`SELECT Z_PK AS pk, HEX(ZIDENTIFIER) AS hex, ZMAPITEMNAME AS name,
+                ZLATITUDE AS lat, ZLONGITUDE AS lon
+           FROM ZFAVORITEITEM
+          WHERE ZLATITUDE BETWEEN ? AND ? AND ZLONGITUDE BETWEEN ? AND ?
+          LIMIT 1`).get(lat - NEAR, lat + NEAR, lon - NEAR, lon + NEAR);
+		if (tight || !name) return tight;
+		return db.prepare(`SELECT Z_PK AS pk, HEX(ZIDENTIFIER) AS hex, ZMAPITEMNAME AS name,
+                ZLATITUDE AS lat, ZLONGITUDE AS lon
+           FROM ZFAVORITEITEM
+          WHERE ZMAPITEMNAME = ?
+            AND ZLATITUDE BETWEEN ? AND ? AND ZLONGITUDE BETWEEN ? AND ?
+          LIMIT 1`).get(name, lat - SEED_TOLERANCE, lat + SEED_TOLERANCE, lon - SEED_TOLERANCE, lon + SEED_TOLERANCE);
+	}
+	/**
+	* A place record already in the store for this coordinate.
+	*
+	* Checked before seeding, so asking for somewhere the user has already looked
+	* at costs no Recents entry and no network round trip. Recents, collection
+	* items and other favourites are all valid sources — the record is the same
+	* object whichever row points at it.
+	*/
+	#donorNear(db, lat, lon) {
+		return db.prepare(`SELECT m."Z_PK" AS mapPk, m."ZLATITUDE" AS lat, m."ZLONGITUDE" AS lon,
+                m."ZMAPITEMSTORAGE" AS storage,
+                COALESCE(f."ZMAPITEMNAME", ci."ZMAPITEMNAME") AS name,
+                COALESCE(f."ZMAPITEMADDRESS", ci."ZMAPITEMADDRESS") AS address,
+                COALESCE(f."ZMAPITEMCATEGORY", ci."ZMAPITEMCATEGORY") AS category,
+                CAST(COALESCE(f."ZMUID", ci."ZMUID") AS TEXT) AS muid
+           FROM "ZMIXINMAPITEM" m
+           LEFT JOIN "ZFAVORITEITEM" f ON f."ZMAPITEM" = m."Z_PK"
+           LEFT JOIN "ZCOLLECTIONITEM" ci ON ci."ZMAPITEM" = m."Z_PK"
+          WHERE m."ZMAPITEMSTORAGE" IS NOT NULL
+            AND m."ZLATITUDE" BETWEEN ? AND ? AND m."ZLONGITUDE" BETWEEN ? AND ?
+          LIMIT 1`).get(lat - NEAR, lat + NEAR, lon - NEAR, lon + NEAR) ?? null;
+	}
+	/** The newest recent carrying a place record, above a watermark. */
+	#seededDonor(db, sinceHistoryPk) {
+		return db.prepare(`SELECT m."Z_PK" AS mapPk, m."ZLATITUDE" AS lat, m."ZLONGITUDE" AS lon,
+                m."ZMAPITEMSTORAGE" AS storage,
+                h."ZCUSTOMNAME" AS name, NULL AS address, NULL AS category,
+                CAST(h."ZMUID" AS TEXT) AS muid
+           FROM "ZHISTORYITEM" h
+           JOIN "ZMIXINMAPITEM" m ON m."Z_PK" = h."ZMAPITEM"
+          WHERE h."Z_PK" > ? AND m."ZMAPITEMSTORAGE" IS NOT NULL
+          ORDER BY h."Z_PK" DESC LIMIT 1`).get(sinceHistoryPk) ?? null;
+	}
+	#maxHistory(db) {
+		const row = db.prepare(`SELECT MAX(Z_PK) AS m FROM ZHISTORYITEM`).get();
+		return Number(row?.m ?? 0);
+	}
+	/**
+	* Add a favourite, in three phases with a connection open for as little of it
+	* as possible.
+	*
+	* THE PHASES ARE THE POINT. A first version opened one read-write handle at the
+	* top and held it across the whole seed — including the wait for Maps to
+	* resolve a place, which can run to tens of seconds. That hung: Maps is being
+	* asked to WRITE the very record being waited for, into a store this process is
+	* holding open for writing. Whatever the precise interaction, the shape was a
+	* departure from the sequence that had been proven by hand, and the proven
+	* sequence never holds a write handle while waiting on the app.
+	*
+	*   1. READ  — look for an existing favourite and an existing place record.
+	*   2. SEED  — ask Maps to mint a record, holding NO connection at all, and
+	*              poll with a short-lived read-only handle each time.
+	*   3. WRITE — open read-write, insert, close.
+	*/
+	addFavorite(input) {
+		const hasCoords = input.latitude !== void 0 && input.longitude !== void 0;
+		const lat = input.latitude ?? 0;
+		const lon = input.longitude ?? 0;
+		progress(`add_favorite ${JSON.stringify(input.query)}: reading the store`);
+		const ro = new DatabaseSync(this.#path, { readOnly: true });
+		let existing = null;
+		let donor = null;
+		let watermark = 0;
+		try {
+			if (hasCoords) {
+				existing = this.#existingFavorite(ro, lat, lon, input.name ?? input.query) ?? null;
+				donor = this.#donorNear(ro, lat, lon);
+			}
+			watermark = this.#maxHistory(ro);
+		} finally {
+			ro.close();
+		}
+		if (existing) return {
+			rowId: Number(existing.pk),
+			uuid: uuidOf(Buffer.from(existing.hex, "hex")),
+			name: existing.name,
+			latitude: Number(existing.lat),
+			longitude: Number(existing.lon),
+			created: false,
+			seeded: false
+		};
+		let seeded = false;
+		if (!donor) {
+			const url = `maps://?q=${encodeURIComponent(input.query)}`;
+			progress(`asking Maps to resolve ${JSON.stringify(input.query)}…`);
+			this.#openUrl(url);
+			seeded = true;
+			progress(`opened, waiting up to ${Math.round(this.#seedTimeoutMs / 1e3)}s for a record`);
+			const deadline = Date.now() + this.#seedTimeoutMs;
+			let polls = 0;
+			while (Date.now() < deadline && !donor) {
+				const probe = new DatabaseSync(this.#path, { readOnly: true });
+				try {
+					donor = this.#seededDonor(probe, watermark);
+				} finally {
+					probe.close();
+				}
+				if (!donor) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, STORAGE_POLL_MS);
+				polls += 1;
+				if (polls % 8 === 0) progress(`still waiting (${polls * (STORAGE_POLL_MS / 1e3)}s)…`);
+			}
+			if (donor && hasCoords && !near(donor.lat, donor.lon, lat, lon)) throw new MapsWriteError(`Maps resolved ${JSON.stringify(input.query)} to a place about ${Math.round(haversineMetres(donor.lat, donor.lon, lat, lon))}m from the coordinate given, so it is probably not the place meant. Nothing was saved — try a more specific name.`, { query: input.query });
+			if (donor) progress(`got a place record (${donor.storage?.length ?? 0} bytes) after ${polls} polls`);
+			if (!donor) throw new MapsWriteError(`Maps did not produce a place record for "${input.query}" within ${Math.round(this.#seedTimeoutMs / 1e3)}s. Maps must be RUNNING for this to work — it is the only thing that can create a place record. It may also have resolved the query to a search rather than a place, since searches get no record. Try a more specific name, or pass latitude and longitude.`, { query: input.query });
+		}
+		const canonical = new DatabaseSync(this.#path, { readOnly: true });
+		let duplicate = null;
+		try {
+			duplicate = this.#existingFavorite(canonical, donor.lat, donor.lon) ?? null;
+		} finally {
+			canonical.close();
+		}
+		if (duplicate) {
+			progress("already a favourite; nothing written");
+			return {
+				rowId: Number(duplicate.pk),
+				uuid: uuidOf(Buffer.from(duplicate.hex, "hex")),
+				name: duplicate.name,
+				latitude: Number(duplicate.lat),
+				longitude: Number(duplicate.lon),
+				created: false,
+				seeded
+			};
+		}
+		progress("writing the favourite");
+		const db = this.#open();
+		try {
+			const favEnt = this.#entity(db, "FavoriteItem");
+			const mixEnt = this.#entity(db, "MixinMapItem");
+			const favPk = this.#nextPk(db, "FavoriteItem", "ZFAVORITEITEM");
+			const mixPk = this.#nextPk(db, "MixinMapItem", "ZMIXINMAPITEM");
+			const now = Date.now() / 1e3 - CORE_DATA_EPOCH_OFFSET;
+			const id = uuidBytes();
+			const label = input.name ?? donor.name ?? input.query;
+			const position = Number(db.prepare(`SELECT COUNT(*) AS c FROM ZFAVORITEITEM`).get().c);
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				db.prepare(`INSERT INTO "ZFAVORITEITEM"
+             (Z_PK, Z_ENT, Z_OPT, ZHIDDEN, ZPOSITIONINDEX, ZSOURCE, ZTYPE, ZVERSION,
+              ZMAPITEM, ZMUID, ZCREATETIME, ZMODIFICATIONTIME, ZMAPITEMLASTREFRESHED,
+              ZLATITUDE, ZLONGITUDE, ZMAPITEMNAME, ZMAPITEMADDRESS, ZMAPITEMCATEGORY,
+              ZIDENTIFIER)
+           VALUES (?, ?, 1, 0, ?, 0, 1, 2, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(favPk, favEnt, position, mixPk, donor.muid === null ? null : Number(donor.muid), now, now, now, donor.lat, donor.lon, label, donor.address, donor.category, id);
+				db.prepare(`INSERT INTO "ZMIXINMAPITEM"
+             (Z_PK, Z_ENT, Z_OPT, ZFAVORITEITEM, ZCREATETIME, ZMODIFICATIONTIME,
+              ZLATITUDE, ZLONGITUDE, ZMAPITEMSTORAGE)
+           VALUES (?, ?, 1, ?, ?, ?, ?, ?, ?)`).run(mixPk, mixEnt, favPk, now, now, donor.lat, donor.lon, donor.storage);
+				db.prepare(`UPDATE Z_PRIMARYKEY SET Z_MAX = ? WHERE Z_NAME = 'FavoriteItem'`).run(favPk);
+				db.prepare(`UPDATE Z_PRIMARYKEY SET Z_MAX = ? WHERE Z_NAME = 'MixinMapItem'`).run(mixPk);
+				db.exec("COMMIT");
+			} catch (err) {
+				try {
+					db.exec("ROLLBACK");
+				} catch {}
+				throw err;
+			}
+			return {
+				rowId: favPk,
+				uuid: uuidOf(id),
+				name: label,
+				latitude: Number(donor.lat),
+				longitude: Number(donor.lon),
+				created: true,
+				seeded
+			};
+		} finally {
+			db.close();
+		}
+	}
+	/**
+	* Remove a favourite and the place record it owns.
+	*
+	* `Z_MAX` is deliberately NOT rolled back. Core Data never reuses a primary
+	* key, and decrementing the counter would hand the next insert one that is
+	* already spoken for by a row still referenced elsewhere.
+	*/
+	removeFavorite(key) {
+		const db = this.#open();
+		try {
+			const where = "uuid" in key ? `HEX(ZIDENTIFIER) = ?` : `Z_PK = ?`;
+			const param = "uuid" in key ? key.uuid.replaceAll("-", "").toUpperCase() : key.rowId;
+			const row = db.prepare(`SELECT Z_PK AS pk, ZMAPITEM AS mapPk FROM ZFAVORITEITEM WHERE ${where} LIMIT 1`).get(param);
+			if (!row) return false;
+			db.exec("BEGIN IMMEDIATE");
+			try {
+				if (row.mapPk !== null) db.prepare(`DELETE FROM ZMIXINMAPITEM WHERE Z_PK = ?`).run(row.mapPk);
+				db.prepare(`DELETE FROM ZFAVORITEITEM WHERE Z_PK = ?`).run(row.pk);
+				db.exec("COMMIT");
+			} catch (err) {
+				try {
+					db.exec("ROLLBACK");
+				} catch {}
+				throw err;
+			}
+			return true;
+		} finally {
+			db.close();
+		}
+	}
+};
+//#endregion
+//#region src/client/maps.ts
+/**
+* What diagnostics says about one entity: how many rows, which column won for
+* each field, and which fields resolved to nothing. `resolved` is the part that
+* matters when a result looks wrong — it names the column actually being read.
+*/
+const summariseEntity = (e) => ({
+	rows: e.rows,
+	resolved: Object.fromEntries(Object.entries(e.fields).filter(([, v]) => v !== null)),
+	unresolved: Object.entries(e.fields).filter(([, v]) => v === null).map(([k]) => k)
+});
+var AppleMapsClient = class {
+	#config;
+	#logger;
+	#home;
+	#located = null;
+	#store = null;
+	#storeError = null;
+	constructor(opts) {
+		this.#config = opts.config;
+		this.#logger = opts.logger;
+		this.#home = opts.home;
+	}
+	get config() {
+		return this.#config;
+	}
+	located() {
+		this.#located ??= locateStore({
+			storePath: this.#config.storePath,
+			...this.#home ? { home: this.#home } : {}
+		});
+		return this.#located;
+	}
+	/**
+	* A writer bound to the located store, or an error explaining why not.
+	*
+	* Writes go through their own read-write connection rather than the shared
+	* read-only one: `store()` opens with `query_only` and an `immutable` fallback
+	* precisely so a read can never mutate by accident, and widening it would
+	* throw that guarantee away for every read on the surface.
+	*/
+	writer(openUrl) {
+		const located = this.located();
+		if (!located.readable || !located.storePath) throw new MapsStoreUnavailableError(located.reason ?? "Maps' store could not be opened.");
+		return new MapsWriter({
+			storePath: located.storePath,
+			...openUrl ? { openUrl } : {}
+		});
+	}
+	/** Open the store, once, lazily. Every read goes through here. */
+	store() {
+		if (this.#store) return this.#store;
+		if (this.#storeError !== null) throw new MapsStoreUnavailableError(this.#storeError);
+		const located = this.located();
+		if (!located.readable || !located.storePath) {
+			this.#storeError = located.reason ?? "Maps' store could not be opened.";
+			throw new MapsStoreUnavailableError(this.#storeError);
+		}
+		try {
+			this.#store = openStore({
+				path: located.storePath,
+				mode: this.#config.indexMode,
+				...this.#logger ? { logger: this.#logger } : {}
+			});
+			return this.#store;
+		} catch (err) {
+			this.#storeError = err instanceof Error ? err.message : String(err);
+			throw err;
+		}
+	}
+	get epoch() {
+		return this.store().caps.epoch;
+	}
+	#render(kind, row, epoch) {
+		return {
+			ref: encodePlaceRef(kind, row.uuid ? { uuid: row.uuid } : { rowId: row.id }),
+			kind,
+			name: row.customName ?? row.name,
+			placeName: row.name,
+			address: row.address,
+			latitude: row.latitude,
+			longitude: row.longitude,
+			muid: row.muid,
+			created: renderInstant(row.createdRaw, epoch),
+			modified: renderInstant(row.modifiedRaw, epoch),
+			linked: row.linked
+		};
+	}
+	#renderCollection(row, epoch) {
+		return {
+			ref: encodeCollectionRef(row.uuid ? { uuid: row.uuid } : { rowId: row.id }),
+			title: row.title,
+			placesCount: row.placesCount,
+			created: renderInstant(row.createdRaw, epoch),
+			modified: renderInstant(row.modifiedRaw, epoch)
+		};
+	}
+	places(kind, opts) {
+		const store = this.store();
+		const { rows, truncated } = store.places(kind, opts);
+		return {
+			places: rows.map((r) => this.#render(kind, r, store.caps.epoch)),
+			truncated,
+			datesAvailable: store.caps.epoch.confident
+		};
+	}
+	place(kind, key) {
+		const store = this.store();
+		const row = store.place(kind, key);
+		return row ? this.#render(kind, row, store.caps.epoch) : null;
+	}
+	/**
+	* A collection ref to the row id its items point at, or null when the ref
+	* addresses nothing in this store.
+	*
+	* Collection membership is a Core Data foreign key and always holds `Z_PK`,
+	* so a uuid ref has to be translated before it can filter items.
+	*/
+	collectionRowId(key) {
+		return this.store().collectionRowId(key);
+	}
+	collections(opts) {
+		const store = this.store();
+		const { rows, truncated } = store.collections(opts);
+		return {
+			collections: rows.map((r) => this.#renderCollection(r, store.caps.epoch)),
+			truncated,
+			itemsEnumerable: store.caps.membership !== null,
+			unfiled: store.unfiledCount()
+		};
+	}
+	/**
+	* Search every place-bearing entity at once.
+	*
+	* Three separate queries rather than a UNION, because the three tables have
+	* different resolved columns and a UNION would have to flatten them to the
+	* narrowest — which on this store means losing history's coordinates, since
+	* they live in a differently named column from the other two.
+	*/
+	search(opts) {
+		const store = this.store();
+		const kinds = [
+			"favorite",
+			"collection-item",
+			"history"
+		];
+		const places = [];
+		let truncated = false;
+		for (const kind of kinds) {
+			const { rows, truncated: t } = store.places(kind, {
+				limit: opts.limit,
+				query: opts.query
+			});
+			truncated ||= t;
+			for (const r of rows) places.push(this.#render(kind, r, store.caps.epoch));
+		}
+		return {
+			places: places.slice(0, opts.limit),
+			truncated: truncated || places.length > opts.limit,
+			datesAvailable: store.caps.epoch.confident
+		};
+	}
+	/** Everything diagnostics needs, with no failure allowed to fail the call. */
+	status() {
+		const located = this.located();
+		let store = null;
+		let reason = located.reason;
+		try {
+			store = this.store();
+		} catch (err) {
+			reason = err instanceof Error ? err.message : String(err);
+		}
+		return {
+			located,
+			store: {
+				opened: store !== null,
+				mode: store?.mode ?? null,
+				reason
+			},
+			capabilities: store ? {
+				fingerprint: store.caps.fingerprint,
+				tableCount: store.caps.tables.length,
+				epoch: store.caps.epoch,
+				collectionFk: store.caps.collectionFk,
+				collectionMembership: store.caps.membership,
+				entities: {
+					favorites: summariseEntity(store.caps.favorites),
+					collections: summariseEntity(store.caps.collections),
+					collectionItems: summariseEntity(store.caps.collectionItems),
+					history: summariseEntity(store.caps.history),
+					mapItems: summariseEntity(store.caps.mapItems)
+				}
+			} : null
+		};
+	}
+	close() {
+		this.#store?.close();
+		this.#store = null;
+	}
+};
+//#endregion
+//#region src/config.ts
+/**
+* Configuration is environment-only — this server holds no secret at all. Its
+* access is the macOS permission the user granted, which is the whole point.
+*
+* `allowWrites` gates two mutating tools, and gates them harder than elsewhere.
+* Maps has no scripting dictionary and no registered App Intents, so a write is
+* SQL straight into a Core Data store that `NSPersistentCloudKitContainer`
+* mirrors — which means it reaches every device on the account, not just this
+* Mac. That was measured, along with the rule that keeps it safe: never
+* fabricate a place record, only ever copy one Maps wrote itself. See
+* `docs/maps.md` and `client/write.ts`.
+*/
+const ConfigSchema = BaseConfigSchema.extend({
+	/** Explicit store path. Bypasses discovery — for tests and forensic copies. */
+	storePath: z.string().optional(),
+	indexMode: z.enum([
+		"auto",
+		"ro",
+		"immutable",
+		"off"
+	]).default("auto")
+}).strict();
+const loadConfig = (env = process.env) => parseConfig(ConfigSchema, {
+	allowWrites: parseBool(env.APPLE_MAPS_ALLOW_WRITES),
+	exposePrompts: parseBool(env.APPLE_MAPS_EXPOSE_PROMPTS),
+	debug: parseBool(env.APPLE_MAPS_DEBUG),
+	storePath: trimmed(env.APPLE_MAPS_STORE),
+	indexMode: trimmed(env.APPLE_MAPS_INDEX_MODE),
+	osascriptPath: trimmed(env.APPLE_MAPS_OSASCRIPT_PATH),
+	osascriptTimeoutMs: parseIntOpt(env.APPLE_MAPS_OSASCRIPT_TIMEOUT_MS),
+	maxResults: parseIntOpt(env.APPLE_MAPS_MAX_RESULTS)
+});
+//#endregion
+//#region src/guide.ts
+/**
+* The Maps operating manual, served as `cupertino://maps/guide` and embedded
+* ahead of every Maps prompt. Static by design — see the note in the Mail guide.
+*/
+const MAPS_GUIDE = `# Maps — how to drive this server
+
+## What this surface is, and is not
+
+It reads the places **saved on this Mac**: favourites, collections (Guides) and
+recents. It does **not** search Apple's map of the world, geocode an address,
+give directions, or compute a travel time. If asked for any of those, say so
+plainly rather than searching the saved places and presenting a near-miss —
+"the nearest coffee shop" is not a question this server can answer, and a
+favourite called "Coffee" is not the answer to it.
+
+## One lane, and no fallback
+
+Maps ships **no scripting dictionary** — there is no \`.sdef\` in the app bundle
+— so unlike every other surface here there is no Apple Events lane to fall back
+to. Everything comes from a Core Data store under **Full Disk Access**.
+
+The consequence matters: without the grant this server returns an **error**, not
+an empty list. If a tool ever does return an empty list, that means the user has
+genuinely saved nothing of that kind. Check
+\`cupertino://maps/diagnostics\` before concluding either way.
+
+## Which tool answers which question
+
+| Question | Tool |
+| --- | --- |
+| What places has the user saved? | \`apple_maps_list_favorites\` |
+| What Guides do they keep? | \`apple_maps_list_collections\` |
+| What is filed in one Guide? | \`apple_maps_list_collection_places\` |
+| Where have they looked recently? | \`apple_maps_list_recents\` |
+| Find a saved place by name or address | \`apple_maps_search_places\` |
+| One place, in full | \`apple_maps_get_place\` |
+
+## Four things not to say
+
+**\`linked: false\` is not a broken row.** Some favourites have no place
+attached, no name and no coordinate. They are Maps' unconfigured Home / Work /
+School slots. Report them as unset, not as places.
+
+**A null date is unknown, not old.** Timestamps are placed on an epoch detected
+from the store. When detection fails every date reads \`null\` rather than being
+guessed, because a date wrong by 31 years reads exactly like a correct one.
+
+**A collection with no listable places may still have places.** How an item
+belongs to a collection is not exposed by every version of this store. When the
+key is missing, \`placesCount\` is still Maps' own accurate number and the
+places simply cannot be enumerated. Say that, rather than reporting an empty
+Guide.
+
+**Refs expire.** They address a row in a store that iCloud re-syncs, and Core
+Data reuses row ids after a delete. A ref is good for this conversation. Do not
+store one or hand it back later.
+
+## Privacy, worth holding in mind
+
+Saved places are a home address, a doctor, a school, a partner's flat. This is
+among the most sensitive data any surface here reads. Answer what was asked;
+do not enumerate everything because a listing tool is available.
+`;
+//#endregion
+//#region src/prompts.ts
+const CTX = {
+	surface: "maps",
+	guide: MAPS_GUIDE
+};
+/**
+* Maps' one workflow prompt.
+*
+* It exists because "where was that place" spans three lists that hold the same
+* kind of thing for different reasons — a favourite is deliberate, a collection
+* entry is filed, a recent is incidental — and searching only one produces a
+* confident answer to a question nobody asked. The prompt also carries the
+* refusal: this server does not know about places the user has never saved, and
+* the most likely way to be wrong here is to answer anyway.
+*/
+const registerPrompts = (server) => {
+	registerWorkflowPrompt(server, CTX, {
+		name: "apple_maps_where_was_that_place",
+		title: "Find a place I saved",
+		description: "Track down a saved place across favourites, Guides and recents — three lists that hold places for different reasons. Read-only.",
+		argsSchema: { about: promptArg("What the place was, e.g. \"the ramen place near the office\".") },
+		build: ({ about }) => `Find the saved place ${about ? `matching: ${about}` : "I am after"}.
+
+Start with \`apple_maps_search_places\` — it covers favourites, Guide entries and
+recents in one call, and tells you which kind each match came from. That
+distinction is the answer, not a detail: a favourite is somewhere I chose to
+keep, a recent is somewhere I merely looked at once.
+
+If that finds nothing, list the three directly before concluding it is not
+there — a place I saved under my own label ("Mum's") will not match a search for
+what it actually is.
+
+Then report what you found, with the address and how it was saved.
+
+Three things to get right:
+- If nothing matches, say I have not saved it. Do **not** fall back to guessing
+  a place from general knowledge — this server only knows what is on this Mac,
+  and inventing an address is the worst possible failure here.
+- An entry with \`linked: false\` is an unconfigured Home/Work/School slot, not
+  a place. Do not report it as one.
+- If a date reads null, the date is unknown. Do not describe it as old.
+
+If every list comes back empty, check \`cupertino://maps/diagnostics\` before
+concluding I have saved nothing — this surface has no second lane, so a missing
+Full Disk Access grant takes all of it at once.`
+	});
+};
+//#endregion
+//#region src/tools/util.ts
+const placeRefArg = z.string().min(1).describe("An opaque place ref from a listing (looks like \"p1:f:12\"). Do not construct one by hand. Refs address a row in the local store, so they are only valid for this session — an iCloud re-sync can renumber them.");
+const collectionRefArg = z.string().min(1).describe("An opaque collection ref from apple_maps_list_collections (looks like \"pc1:3\").");
+const queryArg = z.string().min(1).describe("Text to look for in a place's name, the label you gave it, or its address. Wildcards are escaped, so searching for \"100%\" finds that literal string.");
+//#endregion
+//#region src/tools/diagnostics.ts
+/**
+* Build the report.
+*
+* Split out of the tool registration so the `cupertino://maps/diagnostics`
+* resource can serve the same bytes. Two renderings of one probe: duplicated,
+* the resource and the tool would drift, and the disagreement would surface as
+* "the diagnostics lied" — the one thing this file must never do.
+*/
+const buildDiagnostics = async (client) => {
+	const status = client.status();
+	const located = status.located;
+	return {
+		server: {
+			name: BUILD_INFO.name,
+			version: BUILD_INFO.version
+		},
+		settings: { exposePrompts: client.config.exposePrompts },
+		lanes: {
+			summary: "Maps has ONE lane. Maps.app ships no scripting dictionary — there is no .sdef in the bundle, checked directly — so there is no Apple Events fallback. Without Full Disk Access this server cannot read anything at all, and it says so rather than returning empty lists.",
+			fileLane: {
+				needs: "Full Disk Access",
+				answers: "favourites, collections (guides), recents",
+				working: status.store.opened
+			},
+			appleEvents: "none — Maps is not scriptable",
+			writes: "none — this server registers no mutating tool. The store is mirrored to iCloud by NSPersistentCloudKitContainer, so a write is an edit to one replica of a synchronising graph underneath a running app. That was never probed."
+		},
+		store: {
+			path: located.storePath,
+			exists: located.exists,
+			readable: located.readable,
+			opened: status.store.opened,
+			mode: status.store.mode,
+			reason: status.store.reason,
+			resolvedByScan: located.resolvedByScan,
+			...status.capabilities
+		},
+		files: {
+			directory: located.directory,
+			localCache: {
+				path: located.localCache.path,
+				exists: located.localCache.exists,
+				note: "The device-local cache. Same entities as the sync store and, on the probed machine, zero rows in every one of them. Located so it is visibly considered, never opened."
+			}
+		},
+		caveats: [
+			"This store was missed three times before it was found, and the reasons are worth knowing if it ever looks absent: the file has NO EXTENSION (MapsSync_0.0.1), it lives in the one directory of Maps' container that Full Disk Access gates, and `group.com.apple.Maps` is a decoy that is EPERM rather than empty.",
+			"Columns are resolved BY COVERAGE, not by name. ZHISTORYITEM carries both ZLATITUDE (1 row of 33) and ZLATITUDE1 (19 of 33); picking the first recognised name would report that Maps holds almost no coordinates. `entities.*.resolved` above shows which column actually won for each field.",
+			"Some favourites have no linked place: 3 of 23 on the probed machine, with no name and no coordinate. Almost certainly the unconfigured Home / Work / School slots. They are returned with `linked: false` rather than dropped, because silently omitting rows reads as a deletion.",
+			"Collection membership is a many-to-many join table, Z_6PLACES(Z_6COLLECTIONS, Z_7PLACES) on the probed machine, NOT a column on ZCOLLECTIONITEM — which is why four guessed column names all missed it. It is re-proved at open time by reproducing ZPLACESCOUNT exactly, never by matching a name, because ZCOLLECTIONITEM.ZMAPITEM joins 3 of 10 collections by coincidence. When nothing reproduces those counts, `collectionMembership` is null, collections list without their places and every result says so.",
+			"Refs address a local row id. Core Data reuses those after a delete and this store is mirrored from CloudKit, so a re-sync can renumber rows. A ref is good for the current session and should not be stored.",
+			"Timestamps are placed on an epoch DETECTED from the store, never assumed. The same value read as unix seconds instead of Core Data seconds lands in 1995 and looks entirely plausible. When detection fails every date reads null rather than guessed."
+		]
+	};
+};
+const registerDiagnosticsTools = (server, client) => {
+	server.registerTool("apple_maps_diagnostics", {
+		description: "Report whether Maps' store can be read, which columns were resolved for each entity, and what this server deliberately cannot do. Start here when a read returns nothing — this surface has no second lane, so a missing grant means no data at all rather than slower data.",
+		inputSchema: {},
+		annotations: { readOnlyHint: true }
+	}, async () => wrap(() => buildDiagnostics(client)));
+};
+//#endregion
+//#region src/tools/places.ts
+/**
+* The place tools.
+*
+* Every description states the permission fact plainly. On this surface it is
+* not the usual "slower without the grant" — there is no second lane, so
+* without Full Disk Access these tools have nothing to read. Saying so in the
+* description is what stops a model concluding, from an error it half-read,
+* that the person simply has not saved any places.
+*/
+const registerPlaceTools = (server, client) => {
+	server.registerTool("apple_maps_list_favorites", {
+		description: "List the places saved as favourites in Maps, with coordinates, address and the label the user gave them. Needs Full Disk Access — Maps is not scriptable, so without the grant this returns an error rather than an empty list. Some entries have no linked place (`linked: false`); those are the unconfigured Home/Work/School slots, not broken rows. This is everything SAVED: Maps' own Pinned panel applies display rules that are not in the store and can show fewer.",
+		inputSchema: { limit: limitArg },
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ limit }) => wrapResult(async () => {
+		const result = client.places("favorite", { limit: limit ?? client.config.maxResults });
+		const unlinked = result.places.filter((p) => !p.linked).length;
+		return ok(compact({
+			favorites: result.places,
+			count: result.places.length,
+			unlinked: unlinked ? `${unlinked} entr${unlinked === 1 ? "y has" : "ies have"} no linked place — these are Maps' unconfigured Home/Work/School slots. They are returned rather than dropped, because silently omitting rows reads as a deletion.` : void 0,
+			/**
+			* MEASURED, and the reason the note above no longer claims this count
+			* matches the app: on a real store Maps' Pinned panel showed 17 while
+			* this tool returned 24. Three extras were the unlinked slots; four
+			* were ordinary favourites with names, addresses and coordinates, one
+			* an exact duplicate of a shown entry.
+			*
+			* No column in ZFAVORITEITEM separates them — ZHIDDEN, ZSOURCE, ZTYPE
+			* and ZVERSION were all cross-tabulated and none yields a group of
+			* four. `ZVERSION = 2` has exactly 17 rows and is a COINCIDENCE OF
+			* TOTALS: 16 of them are linked while all 17 shown entries are. So
+			* Maps applies display rules this server cannot see — de-duplication
+			* is the visible one — and no filter written here could reproduce
+			* them. Saying so beats guessing, and beats the old note, which
+			* asserted the opposite of what was measured. See docs/maps.md.
+			*/
+			mayExceedApp: "Maps' own Pinned panel can show FEWER places than this. It applies display rules — de-duplication at least — that are not recorded in the store, so this is everything saved, not everything shown.",
+			truncated: result.truncated ? `More favourites exist beyond limit=${limit ?? client.config.maxResults}.` : void 0,
+			datesUnavailable: result.datesAvailable ? void 0 : "Timestamps could not be placed on a known epoch, so every date reads null. They are withheld rather than guessed — see apple_maps_diagnostics."
+		}));
+	}));
+	server.registerTool("apple_maps_list_collections", {
+		description: "List the collections (Guides) in Maps. Each carries Maps' own count of the places in it. Use apple_maps_list_collection_places to enumerate one. Needs Full Disk Access.",
+		inputSchema: { limit: limitArg },
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ limit }) => wrapResult(async () => {
+		const result = client.collections({ limit: limit ?? client.config.maxResults });
+		return ok(compact({
+			collections: result.collections,
+			count: result.collections.length,
+			unfiled: result.unfiled && result.unfiled > 0 ? `${result.unfiled} saved place(s) are in no collection. List them with apple_maps_list_unfiled_places.` : void 0,
+			itemsUnavailable: result.itemsEnumerable ? void 0 : "This store does not expose how an item belongs to a collection, so the places inside a collection cannot be listed. `placesCount` is Maps' own number and is still accurate; apple_maps_list_collection_places will return nothing.",
+			truncated: result.truncated ? `More collections exist beyond limit=${limit ?? client.config.maxResults}.` : void 0
+		}));
+	}));
+	server.registerTool("apple_maps_list_collection_places", {
+		description: "List the places filed in one collection, by its ref. Needs Full Disk Access. Returns nothing when this store does not expose collection membership — check apple_maps_diagnostics, which reports whether the key was resolved.",
+		inputSchema: {
+			ref: collectionRefArg,
+			limit: limitArg
+		},
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ ref, limit }) => wrapResult(async () => {
+		const collectionId = client.collectionRowId(decodeCollectionRef(ref));
+		const result = client.places("collection-item", {
+			limit: limit ?? client.config.maxResults,
+			collectionId: collectionId ?? void 0
+		});
+		if (!client.collections({ limit: 1e3 }).itemsEnumerable) return fail("This store does not expose which collection an item belongs to, so its places cannot be listed. The collection itself and its place count are still readable through apple_maps_list_collections.");
+		return ok(compact({
+			places: result.places,
+			count: result.places.length,
+			truncated: result.truncated ? `More places exist beyond limit=${limit ?? client.config.maxResults}.` : void 0
+		}));
+	}));
+	server.registerTool("apple_maps_list_unfiled_places", {
+		description: "List saved places that are in no collection. Maps files a saved place into a Guide through a join table, and a place can exist with no row there — 12 of 30 on the probed machine, 7 of which appear nowhere else in the store: not as a favourite, not in another Guide, not in recents. Those are reachable through no other tool. Needs Full Disk Access. Returns nothing when collection membership could not be resolved, which apple_maps_diagnostics reports.",
+		inputSchema: { limit: limitArg },
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ limit }) => wrapResult(async () => {
+		if (!client.collections({ limit: 1 }).itemsEnumerable) return fail("This store does not expose which collection an item belongs to, so places in no collection cannot be told apart from places in one. apple_maps_list_collections still works.");
+		const result = client.places("collection-item", {
+			limit: limit ?? client.config.maxResults,
+			unfiled: true
+		});
+		return ok(compact({
+			places: result.places,
+			count: result.places.length,
+			truncated: result.truncated ? `More places exist beyond limit=${limit ?? client.config.maxResults}.` : void 0
+		}));
+	}));
+	server.registerTool("apple_maps_list_recents", {
+		description: "List the places recently looked at in Maps, newest first. This is Maps' Recents list, not a search history: it holds places, directions and searches the user actually opened. Needs Full Disk Access.",
+		inputSchema: { limit: limitArg },
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ limit }) => wrapResult(async () => {
+		const result = client.places("history", { limit: limit ?? client.config.maxResults });
+		const named = result.places.filter((p) => p.name).length;
+		return ok(compact({
+			recents: result.places,
+			count: result.places.length,
+			namesUnavailable: result.places.length > 0 && named * 4 < result.places.length ? `Only ${named} of ${result.places.length} entries carry a name. Maps keeps a recent's place name in an encoded record this server does not decode, so most rows have coordinates and dates but no label. This is the store's shape, not missing data.` : void 0,
+			truncated: result.truncated ? `More entries exist beyond limit=${limit ?? client.config.maxResults}.` : void 0,
+			datesUnavailable: result.datesAvailable ? void 0 : "Timestamps could not be placed on a known epoch, so every date reads null."
+		}));
+	}));
+	server.registerTool("apple_maps_search_places", {
+		description: "Search every saved place — favourites, collection entries and recents — by name, by the label the user gave it, or by address. Returns each match with the kind of entry it came from. Needs Full Disk Access. This searches what is SAVED on this Mac; it does not search Apple's map of the world.",
+		inputSchema: {
+			query: queryArg,
+			limit: limitArg
+		},
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ query, limit }) => wrapResult(async () => {
+		const result = client.search({
+			query,
+			limit: limit ?? client.config.maxResults
+		});
+		return ok(compact({
+			places: result.places,
+			count: result.places.length,
+			truncated: result.truncated ? `More matches exist beyond limit=${limit ?? client.config.maxResults}.` : void 0
+		}));
+	}));
+	server.registerTool("apple_maps_get_place", {
+		description: "Get one saved place by its ref, with coordinates, address and dates. Needs Full Disk Access.",
+		inputSchema: { ref: placeRefArg },
+		annotations: {
+			readOnlyHint: true,
+			idempotentHint: true
+		}
+	}, async ({ ref }) => wrapResult(async () => {
+		const { kind, key } = decodePlaceRef(ref);
+		const place = client.place(kind, key);
+		if (!place) return fail("uuid" in key ? "No place for that ref. It was removed in Maps, or it belongs to a different store than the one being read." : "No place for that ref. It may have been removed in Maps, or iCloud may have re-synced the store and renumbered the rows since the listing ran — this ref carries a row id, which only this store's current numbering can resolve. Re-run the listing for a current ref.");
+		return ok({ place });
+	}));
+};
+//#endregion
+//#region src/tools/writes.ts
+/**
+* The mutating tools.
+*
+* Registered only when `APPLE_MAPS_ALLOW_WRITES` is true, so a host that has not
+* opted in is never told they exist — the same gate every other surface uses.
+*
+* ## Two things these descriptions must say, because they are surprising
+*
+* **Adding a favourite leaves an entry in Recents.** A place is only real to
+* Maps once it has a GEO record, and the only thing that can produce one is Maps
+* itself: the place is opened through the `maps://` URL scheme, Maps resolves it
+* and files it in Recents, and that record is copied into the favourite. There
+* is no way to have the first without the second, so the caller is told rather
+* than surprised. When the place is already known to the store, no seeding
+* happens and no Recents entry appears.
+*
+* **It reaches the user's other devices.** The store is mirrored by
+* `NSPersistentCloudKitContainer`, which reconciles on the app's next save
+* whether or not it was told anything. A favourite added here arrived on an
+* iPhone. That makes this the one write in the bundle whose blast radius is
+* larger than the machine it runs on, and the descriptions say so.
+*/
+const registerWriteTools = (server, client) => {
+	server.registerTool("apple_maps_add_favorite", {
+		description: "Save a place to Maps' favourites (the Pinned list). Give the place NAME as `query` — a bare coordinate does not identify a place to Maps — and latitude/longitude when known, which makes the match exact and skips the lookup. SIDE EFFECT: unless the place is already in the store, Maps is asked to resolve it and the place also appears in the user's Recents; there is no way to add a favourite without that. The favourite syncs to the user's other Apple devices through iCloud. Idempotent: asking twice for the same place returns the existing favourite rather than creating a second. Needs Full Disk Access.",
+		inputSchema: {
+			query: z.string().min(1).describe("The place's name, as you would type it into Maps' search field."),
+			latitude: z.number().min(-90).max(90).optional().describe("Latitude, when known."),
+			longitude: z.number().min(-180).max(180).optional().describe("Longitude, when known."),
+			name: z.string().min(1).optional().describe("Label to save it under. Defaults to `query`.")
+		},
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: true
+		}
+	}, async ({ query, latitude, longitude, name }) => wrapResult(async () => {
+		const result = client.writer().addFavorite({
+			query,
+			latitude,
+			longitude,
+			name
+		});
+		return ok(compact({
+			favorite: {
+				ref: `p1:f:${result.uuid.replaceAll("-", "")}`,
+				name: result.name,
+				latitude: result.latitude,
+				longitude: result.longitude
+			},
+			created: result.created,
+			alreadyExisted: result.created ? void 0 : "A favourite for this place already existed and was returned unchanged.",
+			recentsNote: result.seeded ? "Maps was asked to resolve this place, so it now also appears in the user's Recents. That is how the place record is obtained and cannot be avoided." : void 0,
+			syncNote: "This favourite will reach the user's other Apple devices through iCloud once Maps next runs."
+		}));
+	}));
+	server.registerTool("apple_maps_remove_favorite", {
+		description: "Remove a place from Maps' favourites, by a ref from apple_maps_list_favorites. This deletes the favourite on the user's other Apple devices too, through iCloud. It does not affect Guides, Recents, or anything else that references the same place. Needs Full Disk Access.",
+		inputSchema: { ref: placeRefArg },
+		annotations: {
+			readOnlyHint: false,
+			idempotentHint: true,
+			destructiveHint: true
+		}
+	}, async ({ ref }) => wrapResult(async () => {
+		const { kind, key } = decodePlaceRef(ref);
+		if (kind !== "favorite") return fail(`That ref points at a ${kind === "history" ? "recent" : "collection entry"}, not a favourite. Only favourites can be removed; pass a ref from apple_maps_list_favorites.`);
+		if (!client.writer().removeFavorite(key)) return fail("No favourite matched that ref. It may already have been removed, or the listing it came from may predate a change. Re-run apple_maps_list_favorites.");
+		return ok({
+			removed: true,
+			syncNote: "The removal will reach the user's other Apple devices through iCloud once Maps next runs."
+		});
+	}));
+};
+//#endregion
+//#region src/tools/index.ts
+/**
+* Register the Apple Maps tools.
+*
+* The registered set does NOT vary with whether the store opened. That is a
+* runtime condition and MCP clients cache the tool list, so a list that shrank
+* without Full Disk Access would stay shrunk after the grant was given. Every
+* tool is registered on a machine with no grant at all; each fails with an
+* error that says which permission is missing.
+*/
+const registerTools = (server, client, ctx) => {
+	registerDiagnosticsTools(server, client);
+	registerPlaceTools(server, client);
+	if (!ctx.allowWrites) return;
+	registerWriteTools(server, client);
+};
+//#endregion
+//#region src/server.ts
+const SERVER_NAME = BUILD_INFO.name;
+const SERVER_VERSION = BUILD_INFO.version;
+/**
+* Build the server. Side-effect free: it opens no database and reads no file,
+* so a test can construct it freely and every external dependency arrives
+* through an option.
+*
+* There is no `osascript` seam here, unlike every other surface. This server
+* never spawns one — Maps is not scriptable, so there is no Apple Events lane
+* to inject a fake for. Its absence is the point.
+*/
+const createServer = (opts) => {
+	const { config } = opts;
+	const server = new McpServer({
+		name: SERVER_NAME,
+		version: SERVER_VERSION
+	});
+	const client = new AppleMapsClient({
+		config,
+		...opts.logger ? { logger: opts.logger } : {},
+		...opts.home ? { home: opts.home } : {}
+	});
+	registerTools(server, client, { allowWrites: config.allowWrites });
+	if (config.exposePrompts) {
+		registerPrompts(server);
+		registerSurfaceResources(server, {
+			surface: "maps",
+			displayName: "Maps",
+			guide: MAPS_GUIDE,
+			diagnostics: () => buildDiagnostics(client)
+		});
+	}
+	return {
+		server,
+		client
+	};
+};
+//#endregion
+export { fromStoreTime as A, MAPS_SURFACE as C, UndatableStoreError as D, SchemaDriftError$1 as E, resolveEpoch as M, BUILD_INFO as N, APPLE_SECONDS as O, MAPS_BUNDLE_ID as S, PlaceNotFoundError as T, defaultDirectory as _, loadConfig as a, AppleMapsError as b, introspect as c, InvalidMapsRefError as d, PLACE_REF_VERSION as f, encodePlaceRef as g, encodeCollectionRef as h, registerTools as i, renderInstant as j, CORE_DATA_EPOCH_OFFSET as k, openStore as l, decodePlaceRef as m, SERVER_VERSION as n, AppleMapsClient as o, decodeCollectionRef as p, createServer as r, MapsStore as s, SERVER_NAME as t, COLLECTION_REF_VERSION as u, defaultStorePath as v, MapsStoreUnavailableError as w, IndexUnavailableError as x, locateStore as y };
+
+//# sourceMappingURL=server-DgIy0w0S.js.map