@mgcrea/mcp-apple-notes 0.0.0-bootstrap

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Olivier Louvignes <olivier@mgcrea.io>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,58 @@
+# @mgcrea/mcp-apple-notes
+
+Model Context Protocol server for the macOS **Apple Notes** app.
+
+> **Unofficial.** Not affiliated with Apple. It drives the Notes app that is already on your Mac.
+
+## Two lanes
+
+- **Apple Events lane** — accounts, folders, bodies, and every mutation. Always the authority:
+  after a write, the result is what Notes re-read.
+- **Index lane** — read-only SQLite over `NoteStore.sqlite`, for search and metadata at a scale
+  Apple Events cannot reach. Needs Full Disk Access.
+
+Unlike Mail, **the Apple Events lane alone is a working server**. Measured on a 921-note library, a
+full-text search takes 97 ms — against the 74 s that forced Mail onto its index. So you can install
+this, use it, and only then decide whether to grant Full Disk Access.
+
+It does not scale for ever: there is no index behind it, so every query pays the full cost again.
+The wall is around 5–10k notes. `apple_notes_diagnostics` tells you which lane is answering.
+
+| Permission             | Needed for                        | Without it                                      |
+| ---------------------- | --------------------------------- | ----------------------------------------------- |
+| **Automation → Notes** | everything                        | nothing works; you get a `-1743` error          |
+| **Full Disk Access**   | search at scale, attachment bytes | the server still runs, on the Apple Events lane |
+
+Neither is granted to Notes.app — it is the _reader_ that needs permission.
+
+## Tools
+
+Read: `diagnostics`, `list_accounts`, `list_folders`, `list_notes`, `search_notes`, `get_note`,
+`list_attachments`, `save_attachment`.
+
+Write, registered **only** when `APPLE_NOTES_ALLOW_WRITES=1` — with the flag off they are invisible
+to the model, not merely refused: `create_note`, `update_note`, `move_note`, `delete_notes`.
+
+## Configuration
+
+| Variable                           | Default       |                                                   |
+| ---------------------------------- | ------------- | ------------------------------------------------- |
+| `APPLE_NOTES_ALLOW_WRITES`         | off           | Register the mutating tools.                      |
+| `APPLE_NOTES_ACCOUNTS`             | all           | Read-side allowlist, comma-separated.             |
+| `APPLE_NOTES_INDEX_MODE`           | `auto`        | `auto` \| `ro` \| `immutable` \| `off`.           |
+| `APPLE_NOTES_STORE`                | auto          | Explicit `NoteStore.sqlite` path.                 |
+| `APPLE_NOTES_SEARCH_CACHE_TTL_MS`  | `60000`       | How long the body corpus stays warm.              |
+| `APPLE_NOTES_ATTACHMENT_DIR`       | `~/Downloads` | The only directory attachments may be saved into. |
+| `APPLE_NOTES_BODY_MAX_BYTES`       | `262144`      | Body truncation, to protect the context window.   |
+| `APPLE_NOTES_OSASCRIPT_TIMEOUT_MS` | `30000`       | Sized for the first-run permission prompt.        |
+
+## Notes that will bite you
+
+- **Notes takes a note's title from the first line of its body.** Setting `name` is silently
+  ignored, so `create_note` prepends the title as a heading instead.
+- **Password-protected notes cannot be read at all.** Their text is AES ciphertext at rest, which
+  is why `ZICNOTEDATA` carries crypto columns; no permission makes it readable.
+- **Folders nest.** A folder map has to recurse even if your own library happens to be flat.
+- **Search caches on a TTL, not on invalidation.** Checking whether the cache is stale costs _more_
+  over Apple Events (128 ms) than redoing the scan (97 ms), so bounded staleness is the honest
+  trade. See [docs/notes.md](../../docs/notes.md).

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/cli.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { D as BUILD_INFO, S as NOTES_SURFACE, a as loadConfig, r as createServer } from "./server-HLS_dM7r.js";
+import { runStdioServer } from "@mgcrea/mcp-apple-core";
+//#region src/cli.ts
+const LOG_PREFIX = "apple-notes-mcp";
+runStdioServer({
+	build: BUILD_INFO,
+	surface: NOTES_SURFACE,
+	logPrefix: LOG_PREFIX,
+	start: async (logger) => {
+		const config = loadConfig();
+		const { server } = createServer({
+			config,
+			logger
+		});
+		return {
+			server,
+			banner: `writes=${config.allowWrites ? "ENABLED" : "disabled"}, accounts=${config.accounts.length ? config.accounts.join("/") : "all"}, index=${config.indexMode}`
+		};
+	}
+}).catch((err) => {
+	console.error(`[${LOG_PREFIX}] fatal:`, err);
+	process.exit(1);
+});
+//#endregion
+export {};
+
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\nimport { runStdioServer } from \"@mgcrea/mcp-apple-core\";\n\nimport { BUILD_INFO } from \"./build-info.js\";\nimport { NOTES_SURFACE } from \"./client/errors.js\";\nimport { loadConfig } from \"./config.js\";\nimport { createServer } from \"./server.js\";\n\nconst LOG_PREFIX = \"apple-notes-mcp\";\n\nrunStdioServer({\n  build: BUILD_INFO,\n  surface: NOTES_SURFACE,\n  logPrefix: LOG_PREFIX,\n  start: async (logger) => {\n    const config = loadConfig();\n    const { server } = createServer({ config, logger });\n    return {\n      server,\n      banner:\n        `writes=${config.allowWrites ? \"ENABLED\" : \"disabled\"}, ` +\n        `accounts=${config.accounts.length ? config.accounts.join(\"/\") : \"all\"}, ` +\n        `index=${config.indexMode}`,\n    };\n  },\n}).catch((err: unknown) => {\n  console.error(`[${LOG_PREFIX}] fatal:`, err);\n  process.exit(1);\n});\n"],"mappings":";;;;AAQA,MAAM,aAAa;AAEnB,eAAe;CACb,OAAO;CACP,SAAS;CACT,WAAW;CACX,OAAO,OAAO,WAAW;EACvB,MAAM,SAAS,WAAW;EAC1B,MAAM,EAAE,WAAW,aAAa;GAAE;GAAQ;EAAO,CAAC;EAClD,OAAO;GACL;GACA,QACE,UAAU,OAAO,cAAc,YAAY,WAAW,aAC1C,OAAO,SAAS,SAAS,OAAO,SAAS,KAAK,GAAG,IAAI,MAAM,UAC9D,OAAO;EACpB;CACF;AACF,CAAC,CAAC,CAAC,OAAO,QAAiB;CACzB,QAAQ,MAAM,IAAI,WAAW,WAAW,GAAG;CAC3C,QAAQ,KAAK,CAAC;AAChB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,433 @@
+import { AppBusyError as NotesBusyError, AppNotRunningError as NotesNotRunningError, AppleAutomationError, AppleAutomationError as AppleNotesError, BuildInfo, Logger, OsascriptRunner, ReadOnlyMode, StoreFacts, SurfaceContext } from "@mgcrea/mcp-apple-core";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { DatabaseSync } from "node:sqlite";
+//#region src/build-info.d.ts
+declare const BUILD_INFO: BuildInfo;
+//#endregion
+//#region src/client/errors.d.ts
+/** Named in every user-facing error and in the env vars they mention. */
+declare const NOTES_SURFACE: SurfaceContext;
+/** A NoteRef no longer resolves — the note was deleted, or the index is stale. */
+declare class NoteNotFoundError extends AppleAutomationError {
+  readonly name = "NoteNotFoundError";
+  constructor(ref: string);
+}
+/**
+ * The note is password-protected and Notes will not hand over its text.
+ *
+ * The file lane cannot help either: locked notes are AES ciphertext at rest,
+ * which is why `ZICNOTEDATA` carries `ZCRYPTOINITIALIZATIONVECTOR` and
+ * `ZCRYPTOTAG` columns. Saying so is more useful than an empty body.
+ */
+declare class NoteLockedError extends AppleAutomationError {
+  readonly name = "NoteLockedError";
+  constructor(ref: string);
+}
+//#endregion
+//#region src/client/locate.d.ts
+type LocateResult = StoreFacts & {
+  storePath: string;
+  /** Where attachment bytes live, one directory per account. */
+  mediaRoot: string;
+  reason: string | null;
+};
+declare const defaultStorePath: (home?: string) => string;
+declare const locateStore: (opts?: {
+  storePath?: string | undefined;
+  home?: 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.
+ *
+ * `allowWrites`, `debug`, `osascriptPath`, `osascriptTimeoutMs` and `maxResults`
+ * come from `BaseConfigSchema`.
+ */
+declare const ConfigSchema: z.ZodObject<{
+  allowWrites: z.ZodDefault<z.ZodBoolean>;
+  debug: z.ZodDefault<z.ZodBoolean>;
+  osascriptPath: z.ZodDefault<z.ZodString>;
+  osascriptTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  maxResults: z.ZodDefault<z.ZodNumber>;
+  accounts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  storePath: z.ZodOptional<z.ZodString>;
+  indexMode: z.ZodDefault<z.ZodEnum<{
+    auto: "auto";
+    immutable: "immutable";
+    off: "off";
+    ro: "ro";
+  }>>;
+  degradedMaxNotes: z.ZodDefault<z.ZodNumber>;
+  bodyMaxBytes: z.ZodDefault<z.ZodNumber>;
+  attachmentDir: z.ZodDefault<z.ZodString>;
+  searchCacheTtlMs: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>;
+type Config = z.infer<typeof ConfigSchema>;
+/**
+ * `env` is a parameter with a default so tests are hermetic — they pass their
+ * own object rather than mutating (and having to restore) process.env.
+ */
+declare const loadConfig: (env?: NodeJS.ProcessEnv) => Config;
+//#endregion
+//#region src/client/store.d.ts
+type NoteRow = {
+  primaryKey: number;
+  title: string | null;
+  snippet: string | null;
+  modified: string | null;
+  created: string | null;
+  folderPk: number | null;
+  locked: boolean;
+};
+type StoreCapabilities = {
+  fingerprint: string;
+  /**
+   * The persistent store UUID, which is the middle segment of every note's
+   * Apple Events id (`x-coredata://<uuid>/ICNote/p<N>`). Reading it here lets an
+   * index row be turned into a ref without asking Notes anything.
+   */
+  storeUuid: string | null;
+  /** `Z_ENT` for `ICNote`, looked up by name rather than hardcoded to 12. */
+  noteEnt: number | null;
+  /** Present on this schema, so the queries can use them. */
+  has: {
+    title: boolean;
+    snippet: boolean;
+    widgetSnippet: boolean;
+    folder: boolean;
+    locked: boolean;
+  };
+  deletionColumns: string[];
+  missing: string[];
+};
+declare const introspect: (db: DatabaseSync) => StoreCapabilities;
+type SearchFilters = {
+  query?: string | undefined;
+  folderPk?: number | undefined;
+  modifiedAfter?: string | undefined;
+  modifiedBefore?: string | undefined;
+  limit: number;
+  offset: number;
+};
+declare class NoteStore {
+  #private;
+  readonly caps: StoreCapabilities;
+  readonly mode: "ro" | "immutable";
+  constructor(db: DatabaseSync, caps: StoreCapabilities, mode: "ro" | "immutable");
+  count(): number;
+  /**
+   * Title and snippet search.
+   *
+   * Deliberately not full text: no indexed column carries the body. Callers that
+   * need body matching combine this with `bodyOf` or fall back to the Apple
+   * Events bulk scan.
+   */
+  search(filters: SearchFilters): NoteRow[];
+  byPrimaryKey(pk: number): NoteRow | null;
+  /**
+   * The note body, decoded from the gzipped protobuf.
+   *
+   * Returns null for password-protected notes: their `ZDATA` is AES ciphertext,
+   * flagged by a non-null `ZCRYPTOTAG`. No permission makes that readable.
+   */
+  bodyOf(pk: number): {
+    text: string | null;
+    via: string | null;
+    encrypted: boolean;
+  };
+  close(): void;
+}
+declare const openStore: (path: string, mode: ReadOnlyMode, logger?: Logger) => NoteStore;
+//#endregion
+//#region src/client/notes.d.ts
+type LaneStatus = {
+  applescript: "live" | "unavailable";
+  index: "live" | "unavailable" | "disabled";
+  indexMode: string | null;
+  storeFingerprint: string | null;
+  reason: string | null;
+};
+type NoteAccount = {
+  id: string | null;
+  name: string | null;
+  defaultFolder: string | null;
+  folderCount: number;
+  noteCount: number;
+};
+type NoteFolder = {
+  id: string | null;
+  name: string | null;
+  accountId: string | null;
+  accountName: string | null;
+  depth: number;
+  shared: boolean;
+  noteCount: number | null;
+};
+type NoteSummary = {
+  ref: string;
+  title: string | null;
+  snippet: string | null;
+  folder: string | null;
+  account: string | null;
+  modified: string | null;
+  created: string | null;
+  locked: boolean;
+  source: "index" | "apple-events";
+};
+type AppleNotesClientOptions = {
+  config: Config;
+  logger?: Logger | undefined;
+  /** Injected by tests so nothing spawns a process or touches a real Notes. */
+  osascript?: OsascriptRunner | undefined;
+};
+/**
+ * The Notes client.
+ *
+ * Two lanes, and which one answers depends on what was granted:
+ *
+ * - **Apple Events** — accounts, folders, every mutation, and bodies. Always the
+ *   authority: after a write, the result is what Notes re-read.
+ * - **Index** — `NoteStore.sqlite`, for search and metadata at a scale Apple
+ *   Events cannot reach.
+ *
+ * The discipline the measurements impose is in `jxa/core.ts`: bulk array fetches
+ * only, never `whose`, never a property read per note.
+ */
+declare class AppleNotesClient {
+  #private;
+  readonly config: Config;
+  readonly runner: OsascriptRunner;
+  constructor(opts: AppleNotesClientOptions);
+  locate(): LocateResult;
+  /** Open the index once and remember the outcome, including the failure. */
+  index(): NoteStore | null;
+  /**
+   * Probe both lanes.
+   *
+   * Apple Events is probed twice with a gap: the first event is what triggers
+   * the Automation prompt, and it can return failure while the user is still
+   * deciding — reporting "denied" then would be wrong.
+   */
+  lanes(): Promise<LaneStatus>;
+  accounts(): Promise<NoteAccount[]>;
+  folders(): Promise<NoteFolder[]>;
+  /**
+   * Note metadata.
+   *
+   * Prefers the index — it holds the same fields, costs no Apple Event, and
+   * keeps working as a library grows past the point where a bulk fetch stops
+   * being instant.
+   */
+  listNotes(opts: {
+    folder?: string | undefined;
+    limit: number;
+  }): Promise<NoteSummary[]>;
+  /**
+   * Search.
+   *
+   * `title` uses the index's title and snippet columns, which is a SQL query.
+   * `full` needs the body, which no indexed column carries — so it decodes the
+   * gzipped protobuf when the index is available and falls back to the Apple
+   * Events bulk scan when it is not. Either way the match happens in JS over a
+   * cached corpus, because `whose` is 6.9x slower than fetching and filtering.
+   */
+  searchNotes(opts: {
+    query: string;
+    scope: "title" | "full";
+    limit: number;
+    offset: number;
+  }): Promise<{
+    notes: NoteSummary[];
+    source: "index" | "apple-events";
+    scope: string;
+  }>;
+  getNote(ref: string, opts?: {
+    body?: boolean;
+  }): Promise<{
+    summary: NoteSummary;
+    body: string | null;
+    bodySource: string | null;
+  }>;
+  attachments(ref: string): Promise<{
+    id: string | null;
+    name: string | null;
+    url: string | null;
+    contentIdentifier: string | null;
+  }[]>;
+  /**
+   * Save an attachment's bytes.
+   *
+   * The scripting dictionary exposes `name`, `id`, `URL` and `content
+   * identifier` but **no filesystem path**, so the bytes can only come from the
+   * media directory — which is Full Disk Access territory. Without it this
+   * reports what is missing rather than failing obscurely.
+   */
+  saveAttachment(ref: string, attachmentId: string, targetDir?: string, opts?: {
+    overwrite?: boolean;
+  }): Promise<{
+    path: string;
+    bytes: number;
+  }>;
+  createNote(opts: {
+    title?: string;
+    body?: string;
+    folderId?: string;
+  }): Promise<unknown>;
+  updateNote(ref: string, body: string, mode: "replace" | "append"): Promise<unknown>;
+  moveNote(ref: string, folderId: string): Promise<unknown>;
+  deleteNotes(refs: string[]): Promise<unknown>;
+}
+//#endregion
+//#region src/client/protobuf.d.ts
+/**
+ * Minimal protobuf wire-format reader, enough to pull the body text out of a
+ * `ZICNOTEDATA.ZDATA` blob.
+ *
+ * ## Why it does not hardcode Apple's schema
+ *
+ * The usual approach compiles Apple's unpublished `.proto` and reads
+ * `document.note.note_text` by field number. That breaks the first time Apple
+ * renumbers a field, and this project already budgets for the schema drifting
+ * on every macOS release.
+ *
+ * So this walks the wire format structurally, and the path is *measured* rather
+ * than assumed — see `NOTE_TEXT_PATH`.
+ *
+ * Wire format, for reference:
+ *   tag = varint;  field = tag >> 3;  wire type = tag & 7
+ *   0 varint · 1 fixed64 · 2 length-delimited · 5 fixed32 · 3/4 groups (legacy)
+ *
+ * Pure and I/O-free: callers gunzip, callers decide what to do with the result.
+ */
+type Varint = {
+  value: number;
+  next: number;
+};
+/** Read a base-128 varint. Returns null rather than throwing on a truncated one. */
+declare const readVarint: (buf: Uint8Array, pos: number) => Varint | null;
+type WireField = {
+  field: number;
+  wire: number;
+  value?: number;
+  from?: number;
+  to?: number;
+};
+/**
+ * Split a buffer into wire-format fields. Returns null if the bytes are not a
+ * well-formed message ending exactly on the boundary — that "exactly" is what
+ * makes this usable as a test for whether a blob is a nested message.
+ */
+declare const parseFields: (buf: Uint8Array, start?: number, end?: number) => WireField[] | null;
+type StringCandidate = {
+  path: string;
+  text: string;
+  length: number;
+};
+/**
+ * Every string in the blob, with the field path that reached it.
+ *
+ * A length-delimited field can be both a valid message and valid text, so both
+ * readings are followed. That ambiguity is the normal case, not an error.
+ */
+declare const collectStrings: (buf: Uint8Array, maxDepth?: number) => StringCandidate[];
+/**
+ * Where the body lives: `document(2) -> note(3) -> note_text(2)`.
+ *
+ * Measured, not assumed. Running the structural walk over 53 real notes and
+ * checking each result against the same note's Apple Events plaintext, every
+ * note read from this path matched exactly (53/53), and picking the longest
+ * string instead matched only 27/53 — on the other 26 an attribute-run field
+ * outran the body by ~60 characters. That failure is silent: it returns
+ * plausible, wrong text rather than an error.
+ */
+declare const NOTE_TEXT_PATH = "2.3.2";
+type DecodedNote = {
+  text: string | null;
+  path: string | null;
+  /** `pinned` or `longest`. A shift to `longest` is the schema-drift signal. */
+  via: "pinned" | "longest" | null;
+  candidateCount: number;
+};
+/**
+ * The note body.
+ *
+ * Reads the pinned path first and falls back to the longest string only if that
+ * path is absent, reporting which route it took so drift is detectable rather
+ * than silently wrong.
+ */
+declare const extractNoteText: (buf: Uint8Array, preferPath?: string | null) => DecodedNote;
+//#endregion
+//#region src/client/ref.d.ts
+/**
+ * NoteRef — the one identifier any tool accepts or returns.
+ *
+ * Notes' own id is already globally unique and resolvable without a container,
+ * unlike Mail's message ids: `x-coredata://<store>/ICNote/p<N>` addresses a note
+ * outright, so this carries no folder and needs no lookup ladder.
+ *
+ * Wire format:  n1:<coredata-id>
+ *
+ * The `n1:` prefix is deliberate. If the id scheme ever changes, a versioned
+ * prefix makes that an additive change instead of a silent reinterpretation of
+ * every ref already in a conversation.
+ *
+ * Deliberately NOT shared with Mail's `ref.ts`: that codec's `#(\d+)$` and
+ * `Number.isSafeInteger` both assume an integer id, which this is not.
+ */
+declare const REF_VERSION = "n1";
+type NoteRef = {
+  /** The full Core Data URI, which is what Apple Events resolves. */
+  id: string;
+  /** `Z_PK` in `ZICCLOUDSYNCINGOBJECT` — measured, see docs/notes.md. */
+  primaryKey: number;
+};
+declare const encodeRef: (id: string) => string;
+declare const decodeRef: (raw: string) => NoteRef;
+/** Build a ref from an index row, which only ever knows the primary key. */
+declare const refFromPrimaryKey: (storeUuid: string, primaryKey: number) => string;
+//#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 nothing spawns a process or touches a real Notes. */
+  osascript?: OsascriptRunner;
+};
+type CreatedServer = {
+  server: McpServer;
+  client: AppleNotesClient;
+};
+/**
+ * Build the server. Side-effect free: it opens no connection, spawns no
+ * process and reads no file, so a test can construct it freely and every
+ * external dependency arrives through an option.
+ */
+declare const createServer: (opts: CreateServerOptions) => CreatedServer;
+//#endregion
+//#region src/tools/index.d.ts
+type ToolContext = {
+  /**
+   * Register the mutating tools too. Off by default — with the flag off they are
+   * not merely refused, they are invisible and cannot be called at all.
+   */
+  allowWrites: boolean;
+};
+/**
+ * Register the Apple Notes tools.
+ *
+ * The registered set is a pure function of `allowWrites` and nothing else. In
+ * particular it does NOT vary with whether Full Disk Access is granted: that is
+ * a runtime condition which can change while the process lives, and MCP clients
+ * cache the tool list, so a tool that appears and disappears would leave clients
+ * calling names the server no longer has. Tools that need the index instead
+ * report their source, or explain what is missing.
+ */
+declare const registerTools: (server: McpServer, client: AppleNotesClient, ctx: ToolContext) => void;
+//#endregion
+export { AppleNotesClient, AppleNotesError, BUILD_INFO, type BuildInfo, type Config, type CreateServerOptions, type DecodedNote, type LaneStatus, type LocateResult, NOTES_SURFACE, NOTE_TEXT_PATH, type NoteAccount, type NoteFolder, NoteLockedError, NoteNotFoundError, type NoteRef, type NoteRow, NoteStore, type NoteSummary, NotesBusyError, NotesNotRunningError, REF_VERSION, SERVER_NAME, SERVER_VERSION, type StoreCapabilities, type ToolContext, collectStrings, createServer, decodeRef, defaultStorePath, encodeRef, extractNoteText, introspect, loadConfig, locateStore, openStore, parseFields, readVarint, refFromPrimaryKey, registerTools };
+//# 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/errors.ts","../src/client/locate.ts","../src/config.ts","../src/client/store.ts","../src/client/notes.ts","../src/client/protobuf.ts","../src/client/ref.ts","../src/server.ts","../src/tools/index.ts"],"mappings":";;;;;cAkBa,YAAY;;;;cCTZ,eAAe;;cAiBf,0BAA0B;WACnB;EAElB,YAAY;;;;;;;;;cAeD,wBAAwB;WACjB;EAElB,YAAY;;;;KC1BF,eAAe;EACzB;;EAEA;EACA;;cAGW,mBAAgB;cAGhB,cAAW;EACd;EAAgC;MACvC;;;;;;;;;;cCbG,cAAY,EAAA;;;;;;;;;;;;;;;;;;GAiCP,EAAA,KAAA;KAEC,SAAS,EAAE,aAAa;;;;;cAMvB,aAAU,MAAS,OAAO,eAA2B;;;KC1BtD;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;;;;;;EAMA;;EAEA;;EAEA;IACE;IACA;IACA;IACA;IACA;;EAEF;EACA;;cAUW,aAAU,IAAQ,iBAAe;KA4DlC;EACV;EACA;EACA;EACA;EACA;EACA;;cAGW;;WAEF,MAAM;WACN;EAET,YAAY,IAAI,cAAc,MAAM,mBAAmB;EA+CvD;;;;;;;;EAcA,OAAO,SAAS,gBAAgB;EAwChC,aAAa,aAAa;;;;;;;EAa1B,OAAO;IAAe;IAAqB;IAAoB;;EAmB/D;;cAKW,YAAS,cAAgB,MAAQ,cAAY,SAAW,WAAS;;;KCrQlE;EACV;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;;KAGU;EACV;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;KAUU;EACV,QAAQ;EACR,SAAS;;EAET,YAAY;;;;;;;;;;;;;;;cAgBD;;WACF,QAAQ;WACR,QAAQ;EAMjB,YAAY,MAAM;EAalB,UAAU;;EAKV,SAAS;;;;;;;;EAoBH,SAAS,QAAQ;EA8BjB,YAAY,QAAQ;EAKpB,WAAW,QAAQ;;;;;;;;EAYnB,UAAU;IAAQ;IAA6B;MAAkB,QAAQ;;;;;;;;;;EA+GzE,YAAY;IAChB;IACA;IACA;IACA;MACE;IAAU,OAAO;IAAe;IAAkC;;EA4BhE,QACJ,aACA;IAAQ;MACP;IAAU,SAAS;IAAa;IAAqB;;EAwDlD,YAAY,cAAc;IAE5B;IACA;IACA;IACA;;;;;;;;;;EAeE,eACJ,aACA,sBACA,oBACA;IAAQ;MACP;IACD;IACA;;EAsFI,WAAW;IAAQ;IAAgB;IAAe;MAAsB;EAKxE,WAAW,aAAa,cAAc,6BAA6B;EAMnE,SAAS,aAAa,mBAAmB;EAMzC,YAAY,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;KClezB;EAAW;EAAe;;;cAGzB,aAAU,KAAS,YAAU,gBAAgB;KAiB9C;EACV;EACA;EACA;EACA;EACA;;;;;;;cAQW,cAAW,KACjB,YAAU,gBAAA,iBAGd;KAqDS;EAAoB;EAAc;EAAc;;;;;;;;cAQ/C,iBAAc,KAAS,YAAU,sBAAyB;;;;;;;;;;;cA4B1D;KAED;EACV;EACA;;EAEA;EACA;;;;;;;;;cAUW,kBAAe,KACrB,YAAU,+BAEd;;;;;;;;;;;;;;;;;;;cCjKU;KAKD;;EAEV;;EAEA;;cAGW,YAAS;cAET,YAAS,gBAAkB;;cAuB3B,oBAAiB,mBAAqB;;;cChDtC;cACA;KAED;EACV,QAAQ;EACR,SAAS;;EAET,YAAY;;KAGF;EACV,QAAQ;EACR,QAAQ;;;;;;;cAQG,eAAY,MAAU,wBAAsB;;;KCpB7C;;;;;EAKV;;;;;;;;;;;;cAaW,gBAAa,QAChB,WAAS,QACT,kBAAgB,KACnB"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { C as NoteLockedError, D as BUILD_INFO, E as NotesNotRunningError, S as NOTES_SURFACE, T as NotesBusyError, _ as encodeRef, a as loadConfig, b as locateStore, c as introspect, d as collectStrings, f as extractNoteText, g as decodeRef, h as REF_VERSION, i as registerTools, l as openStore, m as readVarint, n as SERVER_VERSION, o as AppleNotesClient, p as parseFields, r as createServer, s as NoteStore, t as SERVER_NAME, u as NOTE_TEXT_PATH, v as refFromPrimaryKey, w as NoteNotFoundError, x as AppleNotesError, y as defaultStorePath } from "./server-HLS_dM7r.js";
+export { AppleNotesClient, AppleNotesError, BUILD_INFO, NOTES_SURFACE, NOTE_TEXT_PATH, NoteLockedError, NoteNotFoundError, NoteStore, NotesBusyError, NotesNotRunningError, REF_VERSION, SERVER_NAME, SERVER_VERSION, collectStrings, createServer, decodeRef, defaultStorePath, encodeRef, extractNoteText, introspect, loadConfig, locateStore, openStore, parseFields, readVarint, refFromPrimaryKey, registerTools };