@mgcrea/mcp-apple-maps 0.0.0-bootstrap

package/dist/index.d.ts

@@ -0,0 +1,633 @@
+import { AppleAutomationError, AppleAutomationError as AppleMapsError, BuildInfo, CORE_DATA_EPOCH_OFFSET, FileFacts, IndexUnavailableError, Logger, ReadOnlyMode, SchemaDriftError, StoreFacts, SurfaceContext } from "@mgcrea/mcp-apple-core";
+import { DatabaseSync } from "node:sqlite";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+//#region src/build-info.d.ts
+declare const BUILD_INFO: BuildInfo;
+//#endregion
+//#region src/client/dates.d.ts
+/**
+ * How this store's timestamps map onto real time.
+ *
+ * `confident` is the field that matters. `detectEpoch` always returns an offset
+ * — it falls back to unix when nothing fits — so the offset alone cannot
+ * distinguish "measured as unix" from "gave up and assumed unix". Rendering the
+ * second as though it were the first is the failure this module exists to
+ * prevent, so the two are kept apart.
+ */
+type Epoch = {
+  offset: number;
+  reason: string;
+  confident: boolean;
+};
+declare const resolveEpoch: (maxTimestamp: number | null, now?: number) => Epoch;
+/** The expectation docs/maps.md carries, used only where no store is open. */
+declare const APPLE_SECONDS: Epoch;
+/** A stored timestamp to a JS Date, or null when it cannot be placed. */
+declare const fromStoreTime: (value: number | null, epoch: Epoch) => Date | null;
+/** ISO-8601, or null. What every date field on a result carries. */
+declare const renderInstant: (value: number | null, epoch: Epoch) => string | null;
+//#endregion
+//#region src/client/errors.d.ts
+declare const MAPS_SURFACE: SurfaceContext;
+/**
+ * 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.
+ */
+declare 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.
+ */
+declare class MapsStoreUnavailableError extends AppleAutomationError {
+  readonly name = "MapsStoreUnavailableError";
+  constructor(reason: string);
+}
+/** A ref no longer resolves — the place was removed, or the store was re-synced. */
+declare class PlaceNotFoundError extends AppleAutomationError {
+  readonly name = "PlaceNotFoundError";
+  constructor(ref: string);
+}
+/**
+ * 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.
+ */
+declare class UndatableStoreError extends AppleAutomationError {
+  readonly name = "UndatableStoreError";
+  constructor(reason: string);
+}
+//#endregion
+//#region src/client/locate.d.ts
+type LocatedFile = FileFacts & {
+  path: string;
+};
+type LocateResult = StoreFacts & {
+  directory: string;
+  storePath: string | null;
+  /** Reported so a reader can see it was considered. Never opened. */
+  localCache: LocatedFile;
+  /** True when the name came from a directory scan rather than the constant. */
+  resolvedByScan: boolean;
+  reason: string | null;
+};
+declare const defaultDirectory: (home?: string) => string;
+declare const defaultStorePath: (home?: string) => string;
+declare const locateStore: (opts?: {
+  storePath?: string | undefined;
+  home?: string;
+  /** Injected by tests so a scan never reaches a real directory. */
+  readdir?: (path: string) => string[];
+}) => LocateResult;
+//#endregion
+//#region src/config.d.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`.
+ */
+declare const ConfigSchema: z.ZodObject<{
+  allowWrites: z.ZodDefault<z.ZodBoolean>;
+  exposePrompts: z.ZodDefault<z.ZodBoolean>;
+  debug: z.ZodDefault<z.ZodBoolean>;
+  osascriptPath: z.ZodDefault<z.ZodString>;
+  osascriptTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  maxResults: z.ZodDefault<z.ZodNumber>;
+  storePath: z.ZodOptional<z.ZodString>;
+  indexMode: z.ZodDefault<z.ZodEnum<{
+    auto: "auto";
+    immutable: "immutable";
+    off: "off";
+    ro: "ro";
+  }>>;
+}, z.core.$strict>;
+type Config = z.infer<typeof ConfigSchema>;
+declare const loadConfig: (env?: NodeJS.ProcessEnv) => Config;
+//#endregion
+//#region src/client/store.d.ts
+type FieldMap = {
+  /**
+   * The column holding a stable UUID, or null when this store has none good
+   * enough to address rows by. See `resolveIdentifier`.
+   */
+  identifier: string | null;
+  name: string | null;
+  customName: string | null;
+  latitude: string | null;
+  longitude: string | null;
+  address: string | null;
+  muid: string | null;
+  mapItem: string | null;
+  created: string | null;
+  modified: string | null;
+};
+type EntityFacts = {
+  table: string;
+  present: boolean;
+  rows: number;
+  columns: Set<string>;
+  fields: FieldMap;
+};
+/**
+ * How an item says which collection it is in, once proved against the oracle.
+ *
+ * Two shapes because Core Data has two: a scalar foreign key named after the
+ * relationship, and a `Z_<ordinal><RELATIONSHIP>` join table for a
+ * many-to-many. THIS store uses the second. Both are carried because the
+ * resolver proves whichever is there rather than assuming, and a store that
+ * changes shape should degrade rather than read the wrong column.
+ */
+type CollectionMembership = {
+  kind: "column";
+  column: string;
+} | {
+  kind: "joinTable";
+  table: string;
+  collectionColumn: string;
+  itemColumn: string;
+};
+type StoreCapabilities = {
+  fingerprint: string;
+  tables: string[];
+  favorites: EntityFacts;
+  collections: EntityFacts;
+  collectionItems: EntityFacts;
+  history: EntityFacts;
+  mapItems: EntityFacts;
+  /**
+   * The proved membership mechanism, or null when nothing reproduced
+   * `ZPLACESCOUNT` and collections must therefore list without their places.
+   */
+  membership: CollectionMembership | null;
+  /**
+   * The membership mechanism as one short string, for diagnostics.
+   *
+   * Kept because `apple_maps_diagnostics` reported `collectionFk` before this
+   * was understood, and a field that silently changes meaning is worse than one
+   * that widens: it now names a join table as well as a column.
+   */
+  collectionFk: string | null;
+  epoch: Epoch;
+};
+type PlaceRow = {
+  id: number;
+  /**
+   * The stable identifier, when the store has one. Null means refs on this
+   * entity fall back to the row id and are only good for the session.
+   */
+  uuid: string | null;
+  name: string | null;
+  customName: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  address: string | null;
+  /**
+   * Apple's place id, carried as a STRING.
+   *
+   * MEASURED on a real store: `-2679868148951248105`. It is a 64-bit integer and
+   * `node:sqlite` THROWS on one past `Number.MAX_SAFE_INTEGER` rather than
+   * truncating, so reading it as a number failed the whole listing with
+   * "Value is too large to be represented as a JavaScript number" — one column
+   * taking down every favourite. `docs/surfaces.md` states the rule this broke:
+   * read such columns as BigInt or `CAST(... AS TEXT)`.
+   *
+   * The fixture used a small id, so the offline suite passed. Only the real
+   * store has ids of this size.
+   */
+  muid: string | null;
+  createdRaw: number | null;
+  modifiedRaw: number | null;
+  /**
+   * False when the row has no linked `ZMIXINMAPITEM`.
+   *
+   * MEASURED: 3 of 23 favourites, and they carry no name and no coordinate
+   * either. Almost certainly the unconfigured Home / Work / School slots that
+   * Maps creates whether or not anyone fills them in. They are RETURNED rather
+   * than filtered, with this flag, because silently dropping rows is how a
+   * caller concludes a favourite was deleted.
+   */
+  linked: boolean;
+};
+type CollectionRow = {
+  id: number;
+  uuid: string | null;
+  title: string | null;
+  placesCount: number | null;
+  createdRaw: number | null;
+  modifiedRaw: number | null;
+};
+/**
+ * How a caller addresses one row.
+ *
+ * Two shapes rather than one because the store decides which is available, not
+ * the caller: a store whose `ZIDENTIFIER` is complete gets durable refs, one
+ * without falls back to row ids. Making the difference explicit in the type
+ * means a resolver cannot quietly treat a row id as a uuid when the store
+ * changed underneath it.
+ */
+type EntityKey = {
+  uuid: string;
+} | {
+  rowId: number;
+};
+declare const introspect: (db: DatabaseSync, now?: number) => StoreCapabilities;
+declare class MapsStore {
+  #private;
+  readonly db: DatabaseSync;
+  readonly caps: StoreCapabilities;
+  readonly path: string;
+  readonly mode: ReadOnlyMode;
+  constructor(opts: {
+    db: DatabaseSync;
+    caps: StoreCapabilities;
+    path: string;
+    mode: ReadOnlyMode;
+  });
+  /** How many collection items are filed in no collection; null when unknown. */
+  unfiledCount(): number | null;
+  /** One entity's places, newest first when a date is available. */
+  places(kind: "favorite" | "collection-item" | "history", opts: {
+    limit: number;
+    collectionId?: number | undefined;
+    query?: string | undefined;
+    /** Only items filed in NO collection. See `#unfiledClause`. */
+    unfiled?: boolean | undefined;
+  }): {
+    rows: PlaceRow[];
+    truncated: boolean;
+  };
+  /** One place by entity and key. */
+  place(kind: "favorite" | "collection-item" | "history", key: EntityKey): PlaceRow | 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: EntityKey): number | null;
+  collections(opts: {
+    limit: number;
+  }): {
+    rows: CollectionRow[];
+    truncated: boolean;
+  };
+  close(): void;
+}
+declare const openStore: (opts: {
+  path: string;
+  mode?: ReadOnlyMode;
+  logger?: Logger;
+  now?: number;
+  hint?: string;
+}) => MapsStore;
+//#endregion
+//#region src/client/ref.d.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.
+ */
+declare const PLACE_REF_VERSION = "p1";
+declare const COLLECTION_REF_VERSION = "pc1";
+/** The entity a place ref points into. Carried in the ref, never guessed. */
+type PlaceKind = "favorite" | "collection-item" | "history";
+declare class InvalidMapsRefError extends AppleAutomationError {
+  readonly name = "InvalidMapsRefError";
+  constructor(raw: string, want: "place" | "collection");
+}
+declare const encodePlaceRef: (kind: PlaceKind, key: EntityKey) => string;
+declare const encodeCollectionRef: (key: EntityKey) => string;
+declare const decodePlaceRef: (raw: string) => {
+  kind: PlaceKind;
+  key: EntityKey;
+};
+declare const decodeCollectionRef: (raw: string) => EntityKey;
+//#endregion
+//#region src/client/write.d.ts
+/** Injected so tests never launch an application. */
+type OpenUrl = (url: string) => void;
+type AddFavoriteInput = {
+  /** What to search for. A name; a bare coordinate does NOT open a place card. */
+  query: string;
+  latitude?: number | undefined;
+  longitude?: number | undefined;
+  /** The label to store. Defaults to `query`. */
+  name?: string | undefined;
+};
+type AddFavoriteResult = {
+  rowId: number;
+  uuid: string;
+  name: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  /** False when an equivalent favourite already existed and was returned as-is. */
+  created: boolean;
+  /** True when Maps had to be asked to resolve the place, leaving a Recents entry. */
+  seeded: boolean;
+};
+declare class MapsWriter {
+  #private;
+  constructor(opts: {
+    storePath: string;
+    openUrl?: OpenUrl;
+    seedTimeoutMs?: number;
+  });
+  /**
+   * 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: AddFavoriteInput): AddFavoriteResult;
+  /**
+   * 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: EntityKey): boolean;
+}
+//#endregion
+//#region src/client/maps.d.ts
+/**
+ * The client.
+ *
+ * ## One lane, and the consequence of that
+ *
+ * Safari's orchestrator exists to keep two lanes from being mistaken for one
+ * another. Maps has no second lane at all — the app ships no scripting
+ * dictionary — so this class has the opposite job: making sure the ABSENCE of
+ * the one lane is never mistaken for an absence of data.
+ *
+ * Without Full Disk Access every list would naturally come back `[]`, and an
+ * empty `favorites` reads exactly like a person who has saved no places. So a
+ * read with no store THROWS a named error; it never returns an empty array.
+ * That is the same rule `packages/messages` follows, and for the same reason:
+ * both are surfaces where the grant is not an optimisation.
+ */
+type RenderedPlace = {
+  ref: string;
+  kind: PlaceKind;
+  /** The user's own label when they set one, otherwise the place's name. */
+  name: string | null;
+  /** The place's own name, kept separate so a rename is visible as one. */
+  placeName: string | null;
+  address: string | null;
+  latitude: number | null;
+  longitude: number | null;
+  /**
+   * Apple's place identifier. Stable for the same place across devices, and
+   * shared between a favourite and a collection entry for the same place — so
+   * it is reported, and never used as the ref. See `ref.ts`.
+   *
+   * A STRING: it is a 64-bit integer that does not fit in a JS number. A real
+   * store returned `-2679868148951248105`.
+   */
+  muid: string | null;
+  created: string | null;
+  modified: string | null;
+  /**
+   * False for a row with no linked place record. MEASURED: 3 of 23 favourites,
+   * carrying no name and no coordinate — almost certainly the unconfigured
+   * Home / Work / School slots Maps creates whether or not anyone fills them in.
+   */
+  linked: boolean;
+};
+type RenderedCollection = {
+  ref: string;
+  title: string | null;
+  /** Maps' own count, which may include items this server cannot enumerate. */
+  placesCount: number | null;
+  created: string | null;
+  modified: string | null;
+};
+type CreateClientOptions = {
+  config: Config;
+  logger?: Logger;
+  /** Injected by tests so discovery never reaches the developer's real home. */
+  home?: string;
+};
+declare class AppleMapsClient {
+  #private;
+  constructor(opts: CreateClientOptions);
+  get config(): Config;
+  located(): LocateResult;
+  /**
+   * 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?: OpenUrl): MapsWriter;
+  /** Open the store, once, lazily. Every read goes through here. */
+  store(): MapsStore;
+  get epoch(): Epoch;
+  places(kind: PlaceKind, opts: {
+    limit: number;
+    collectionId?: number | undefined;
+    query?: string | undefined;
+    unfiled?: boolean | undefined;
+  }): {
+    places: RenderedPlace[];
+    truncated: boolean;
+    datesAvailable: boolean;
+  };
+  place(kind: PlaceKind, key: EntityKey): RenderedPlace | 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: EntityKey): number | null;
+  collections(opts: {
+    limit: number;
+  }): {
+    collections: RenderedCollection[];
+    truncated: boolean;
+    /** Null when the membership key was not found — see `store.ts`. */
+    itemsEnumerable: boolean;
+    /**
+     * Saved places filed in no collection, or null when unanswerable.
+     *
+     * Reported beside the collections because the counts otherwise do not add
+     * up and nothing says so: the guides account for 18 places while the store
+     * holds 30, and a caller comparing the two has no way to learn where the
+     * rest went.
+     */
+    unfiled: number | null;
+  };
+  /**
+   * 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: {
+    query: string;
+    limit: number;
+  }): {
+    places: RenderedPlace[];
+    truncated: boolean;
+    datesAvailable: boolean;
+  };
+  /** Everything diagnostics needs, with no failure allowed to fail the call. */
+  status(): {
+    located: LocateResult;
+    store: {
+      opened: boolean;
+      mode: string | null;
+      reason: string | null;
+    };
+    capabilities: Record<string, unknown> | null;
+  };
+  close(): void;
+}
+//#endregion
+//#region src/server.d.ts
+declare const SERVER_NAME: string;
+declare const SERVER_VERSION: string;
+type CreateServerOptions = {
+  config: Config;
+  logger?: Logger;
+  /** Injected by tests so discovery never reaches the developer's real home. */
+  home?: string;
+};
+type CreatedServer = {
+  server: McpServer;
+  client: AppleMapsClient;
+};
+/**
+ * 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.
+ */
+declare const createServer: (opts: CreateServerOptions) => CreatedServer;
+//#endregion
+//#region src/tools/index.d.ts
+type ToolContext = {
+  /**
+   * Gates the two mutating tools, which are NOT registered when it is false —
+   * so a host that has not opted in is never told they exist.
+   *
+   * This surface writes SQL directly into Maps' Core Data store, because Maps
+   * has no scripting dictionary and no App Intents to write through. The store
+   * is mirrored to iCloud, so a write here reaches every device on the account.
+   * `docs/maps.md` carries the measurements; `client/write.ts` carries the rule
+   * that makes it safe — never fabricate a place record, only copy one Maps
+   * wrote itself.
+   */
+  allowWrites: boolean;
+};
+/**
+ * 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.
+ */
+declare const registerTools: (server: McpServer, client: AppleMapsClient, ctx: ToolContext) => void;
+//#endregion
+export { APPLE_SECONDS, AppleMapsClient, AppleMapsError, BUILD_INFO, type BuildInfo, COLLECTION_REF_VERSION, CORE_DATA_EPOCH_OFFSET, type CollectionRow, type Config, type CreateClientOptions, type CreateServerOptions, type EntityFacts, type Epoch, IndexUnavailableError, InvalidMapsRefError, type LocateResult, MAPS_BUNDLE_ID, MAPS_SURFACE, MapsStore, MapsStoreUnavailableError, PLACE_REF_VERSION, type PlaceKind, PlaceNotFoundError, type PlaceRow, type RenderedCollection, type RenderedPlace, SERVER_NAME, SERVER_VERSION, SchemaDriftError, type StoreCapabilities, type ToolContext, UndatableStoreError, createServer, decodeCollectionRef, decodePlaceRef, defaultDirectory, defaultStorePath, encodeCollectionRef, encodePlaceRef, fromStoreTime, introspect, loadConfig, locateStore, openStore, registerTools, renderInstant, resolveEpoch };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/build-info.ts","../src/client/dates.ts","../src/client/errors.ts","../src/client/locate.ts","../src/config.ts","../src/client/store.ts","../src/client/ref.ts","../src/client/write.ts","../src/client/maps.ts","../src/server.ts","../src/tools/index.ts"],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { A as fromStoreTime, C as MAPS_SURFACE, D as UndatableStoreError, E as SchemaDriftError, M as resolveEpoch, N as BUILD_INFO, O as APPLE_SECONDS, S as MAPS_BUNDLE_ID, T as PlaceNotFoundError, _ as defaultDirectory, a as loadConfig, b as AppleMapsError, c as introspect, d as InvalidMapsRefError, f as PLACE_REF_VERSION, g as encodePlaceRef, h as encodeCollectionRef, i as registerTools, j as renderInstant, k as CORE_DATA_EPOCH_OFFSET, l as openStore, m as decodePlaceRef, n as SERVER_VERSION, o as AppleMapsClient, p as decodeCollectionRef, r as createServer, s as MapsStore, t as SERVER_NAME, u as COLLECTION_REF_VERSION, v as defaultStorePath, w as MapsStoreUnavailableError, x as IndexUnavailableError, y as locateStore } from "./server-DgIy0w0S.js";
+export { APPLE_SECONDS, AppleMapsClient, AppleMapsError, BUILD_INFO, COLLECTION_REF_VERSION, CORE_DATA_EPOCH_OFFSET, IndexUnavailableError, InvalidMapsRefError, MAPS_BUNDLE_ID, MAPS_SURFACE, MapsStore, MapsStoreUnavailableError, PLACE_REF_VERSION, PlaceNotFoundError, SERVER_NAME, SERVER_VERSION, SchemaDriftError, UndatableStoreError, createServer, decodeCollectionRef, decodePlaceRef, defaultDirectory, defaultStorePath, encodeCollectionRef, encodePlaceRef, fromStoreTime, introspect, loadConfig, locateStore, openStore, registerTools, renderInstant, resolveEpoch };