@openparachute/vault 0.1.0 → 0.2.0

package/core/src/store.ts

@@ -5,13 +5,15 @@ import * as noteOps from "./notes.js";
 import * as linkOps from "./links.js";
 import * as tagSchemaOps from "./tag-schemas.js";
 import { syncWikilinks, resolveUnresolvedWikilinks } from "./wikilinks.js";
-import { normalizePath, pathTitle } from "./paths.js";
+import { pathTitle } from "./paths.js";
 import { HookRegistry } from "./hooks.js";
 
 /**
- * SQLite-backed Store implementation.
+ * bun:sqlite-backed Store implementation. Internally everything is
+ * synchronous; the public Store API is async so the same interface
+ * can back an async runtime (e.g. Cloudflare Durable Objects SQLite).
  */
-export class SqliteStore implements Store {
+export class BunSqliteStore implements Store {
   public readonly hooks: HookRegistry;
 
   constructor(public readonly db: Database, opts?: { hooks?: HookRegistry }) {
@@ -21,39 +23,45 @@ export class SqliteStore implements Store {
 
   // ---- Notes ----
 
-  createNote(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string }): Note {
+  async createNote(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string }): Promise<Note> {
     const note = noteOps.createNote(this.db, content, opts);
 
-    // Auto-sync wikilinks from content
     if (content) {
       syncWikilinks(this.db, note.id, content);
     }
 
-    // If this note has a path, resolve any pending wikilinks targeting it
     if (note.path) {
       resolveUnresolvedWikilinks(this.db, note.path, note.id);
     }
 
-    // Dispatch async hooks post-commit. Never blocks the caller.
     this.hooks.dispatch("created", note, this);
 
     return note;
   }
 
-  getNote(id: string): Note | null {
+  async getNote(id: string): Promise<Note | null> {
     return noteOps.getNote(this.db, id);
   }
 
-  getNoteByPath(path: string): Note | null {
+  async getNoteByPath(path: string): Promise<Note | null> {
     return noteOps.getNoteByPath(this.db, path);
   }
 
-  getNotes(ids: string[]): Note[] {
+  async getNotes(ids: string[]): Promise<Note[]> {
     return noteOps.getNotes(this.db, ids);
   }
 
-  updateNote(id: string, updates: { content?: string; path?: string; metadata?: Record<string, unknown>; created_at?: string; skipUpdatedAt?: boolean }): Note {
-    // Capture old path before update for rename cascading
+  async updateNote(
+    id: string,
+    updates: {
+      content?: string;
+      path?: string;
+      metadata?: Record<string, unknown>;
+      created_at?: string;
+      skipUpdatedAt?: boolean;
+      if_updated_at?: string;
+    },
+  ): Promise<Note> {
     let oldPath: string | undefined;
     if (updates.path !== undefined) {
       const existing = noteOps.getNote(this.db, id);
@@ -62,12 +70,10 @@ export class SqliteStore implements Store {
 
     const note = noteOps.updateNote(this.db, id, updates);
 
-    // Re-sync wikilinks if content changed
     if (updates.content !== undefined) {
       syncWikilinks(this.db, id, updates.content);
     }
 
-    // If path changed, cascade rename through wikilinks in other notes
     if (updates.path !== undefined && note.path) {
       if (oldPath && oldPath !== note.path) {
         this.cascadeRename(oldPath, note.path);
@@ -75,7 +81,6 @@ export class SqliteStore implements Store {
       resolveUnresolvedWikilinks(this.db, note.path, id);
     }
 
-    // Dispatch async hooks post-commit. Never blocks the caller.
     this.hooks.dispatch("updated", note, this);
 
     return note;
@@ -89,8 +94,6 @@ export class SqliteStore implements Store {
     const oldTitle = pathTitle(oldPath);
     const newTitle = pathTitle(newPath);
 
-    // Find notes whose content contains a likely wikilink to the old path
-    // Search for both the full old path and just the old basename
     const candidates = this.db.prepare(`
       SELECT id, content FROM notes
       WHERE content LIKE ? OR content LIKE ?
@@ -99,14 +102,11 @@ export class SqliteStore implements Store {
     for (const row of candidates) {
       let updated = row.content;
 
-      // Replace [[OldPath...]] with [[NewPath...]] (preserving aliases and anchors)
       updated = updated.replace(
         new RegExp(`\\[\\[${escapeRegex(oldPath)}([#|\\]])`, "g"),
         `[[${newPath}$1`,
       );
 
-      // Replace [[OldTitle...]] with [[NewTitle...]] (basename references)
-      // Only if old title !== new title and old title !== old path (avoid double-replace)
       if (oldTitle !== newTitle && oldTitle !== oldPath) {
         updated = updated.replace(
           new RegExp(`\\[\\[${escapeRegex(oldTitle)}([#|\\]])`, "g"),
@@ -115,118 +115,113 @@ export class SqliteStore implements Store {
       }
 
       if (updated !== row.content) {
-        // Call noteOps directly (not this.updateNote) to avoid recursive cascading.
-        // Only content changes here, so path normalization/cascading aren't needed.
         noteOps.updateNote(this.db, row.id, { content: updated });
         syncWikilinks(this.db, row.id, updated);
       }
     }
   }
 
-  deleteNote(id: string): void {
+  async deleteNote(id: string): Promise<void> {
     noteOps.deleteNote(this.db, id);
   }
 
-  queryNotes(opts: QueryOpts): Note[] {
+  async queryNotes(opts: QueryOpts): Promise<Note[]> {
     return noteOps.queryNotes(this.db, opts);
   }
 
-  searchNotes(query: string, opts?: { tags?: string[]; limit?: number }): Note[] {
+  async searchNotes(query: string, opts?: { tags?: string[]; limit?: number }): Promise<Note[]> {
     return noteOps.searchNotes(this.db, query, opts);
   }
 
   // ---- Tags ----
 
-  tagNote(noteId: string, tags: string[]): void {
+  async tagNote(noteId: string, tags: string[]): Promise<void> {
     noteOps.tagNote(this.db, noteId, tags);
   }
 
-  untagNote(noteId: string, tags: string[]): void {
+  async untagNote(noteId: string, tags: string[]): Promise<void> {
     noteOps.untagNote(this.db, noteId, tags);
   }
 
-  listTags(): { name: string; count: number }[] {
+  async listTags(): Promise<{ name: string; count: number }[]> {
     return noteOps.listTags(this.db);
   }
 
-  deleteTag(name: string): { deleted: boolean; notes_untagged: number } {
+  async deleteTag(name: string): Promise<{ deleted: boolean; notes_untagged: number }> {
     return noteOps.deleteTag(this.db, name);
   }
 
   // ---- Vault Stats ----
 
-  getVaultStats(opts?: { topTagsLimit?: number }) {
+  async getVaultStats(opts?: { topTagsLimit?: number }) {
     return noteOps.getVaultStats(this.db, opts);
   }
 
   // ---- Links ----
 
-  createLink(sourceId: string, targetId: string, relationship: string, metadata?: Record<string, unknown>): Link {
+  async createLink(sourceId: string, targetId: string, relationship: string, metadata?: Record<string, unknown>): Promise<Link> {
     return linkOps.createLink(this.db, sourceId, targetId, relationship, metadata);
   }
 
-  deleteLink(sourceId: string, targetId: string, relationship: string): void {
+  async deleteLink(sourceId: string, targetId: string, relationship: string): Promise<void> {
     linkOps.deleteLink(this.db, sourceId, targetId, relationship);
   }
 
-  getLinks(noteId: string, opts?: { direction?: "outbound" | "inbound" | "both" }): Link[] {
+  async getLinks(noteId: string, opts?: { direction?: "outbound" | "inbound" | "both" }): Promise<Link[]> {
     return linkOps.getLinks(this.db, noteId, opts);
   }
 
-  listLinks(opts?: { noteId?: string; direction?: "outbound" | "inbound" | "both"; relationship?: string }): Link[] {
+  async listLinks(opts?: { noteId?: string; direction?: "outbound" | "inbound" | "both"; relationship?: string }): Promise<Link[]> {
     return linkOps.listLinks(this.db, opts);
   }
 
   // ---- Bulk Operations ----
 
-  createNotes(inputs: noteOps.BulkNoteInput[]): Note[] {
+  async createNotes(inputs: noteOps.BulkNoteInput[]): Promise<Note[]> {
     const notes = noteOps.createNotes(this.db, inputs);
-    // Dispatch hooks for each created note — AFTER the bulk transaction
-    // commits inside noteOps.createNotes. Dispatch itself is async-safe
-    // (queueMicrotask), so the loop returns immediately.
     for (const note of notes) {
       this.hooks.dispatch("created", note, this);
     }
     return notes;
   }
 
-  batchTag(noteIds: string[], tags: string[]): number {
+  async batchTag(noteIds: string[], tags: string[]): Promise<number> {
     return noteOps.batchTag(this.db, noteIds, tags);
   }
 
-  batchUntag(noteIds: string[], tags: string[]): number {
+  async batchUntag(noteIds: string[], tags: string[]): Promise<number> {
     return noteOps.batchUntag(this.db, noteIds, tags);
   }
 
   // ---- Deeper Link Queries ----
 
-  traverseLinks(noteId: string, opts?: { max_depth?: number; relationship?: string }) {
+  async traverseLinks(noteId: string, opts?: { max_depth?: number; relationship?: string }) {
     return linkOps.traverseLinks(this.db, noteId, opts);
   }
 
-  findPath(sourceId: string, targetId: string, opts?: { max_depth?: number }) {
+  async findPath(sourceId: string, targetId: string, opts?: { max_depth?: number }) {
     return linkOps.findPath(this.db, sourceId, targetId, opts);
   }
 
   // ---- Tag Schemas ----
 
-  listTagSchemas() {
+  async listTagSchemas() {
     return tagSchemaOps.listTagSchemas(this.db);
   }
 
-  getTagSchema(tag: string) {
+  async getTagSchema(tag: string) {
     return tagSchemaOps.getTagSchema(this.db, tag);
   }
 
-  upsertTagSchema(tag: string, schema: { description?: string; fields?: Record<string, tagSchemaOps.TagFieldSchema> }) {
+  async upsertTagSchema(tag: string, schema: { description?: string; fields?: Record<string, tagSchemaOps.TagFieldSchema> }) {
     return tagSchemaOps.upsertTagSchema(this.db, tag, schema);
   }
 
-  deleteTagSchema(tag: string) {
+  async deleteTagSchema(tag: string) {
     return tagSchemaOps.deleteTagSchema(this.db, tag);
   }
 
-  getTagSchemaMap() {
+  async getTagSchemaMap() {
     return tagSchemaOps.getTagSchemaMap(this.db);
   }
 
@@ -236,7 +231,7 @@ export class SqliteStore implements Store {
    * Create a note without triggering wikilink sync.
    * Use this during bulk imports, then call syncAllWikilinks() after.
    */
-  createNoteRaw(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string }): Note {
+  async createNoteRaw(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string }): Promise<Note> {
     return noteOps.createNote(this.db, content, opts);
   }
 
@@ -244,7 +239,7 @@ export class SqliteStore implements Store {
    * Sync wikilinks for all notes in the vault.
    * Efficient for bulk imports — call once after importing all notes.
    */
-  syncAllWikilinks(): { synced: number; totalAdded: number; totalRemoved: number } {
+  async syncAllWikilinks(): Promise<{ synced: number; totalAdded: number; totalRemoved: number }> {
     const allNotes = noteOps.queryNotes(this.db, { limit: 1000000 });
     let synced = 0;
     let totalAdded = 0;
@@ -265,7 +260,7 @@ export class SqliteStore implements Store {
 
   // ---- Attachments ----
 
-  addAttachment(noteId: string, filePath: string, mimeType: string, metadata?: Record<string, unknown>): Attachment {
+  async addAttachment(noteId: string, filePath: string, mimeType: string, metadata?: Record<string, unknown>): Promise<Attachment> {
     const id = noteOps.generateId();
     const now = new Date().toISOString();
     const metadataJson = metadata ? JSON.stringify(metadata) : "{}";
@@ -276,7 +271,7 @@ export class SqliteStore implements Store {
     return { id, noteId, path: filePath, mimeType, metadata, createdAt: now };
   }
 
-  getAttachments(noteId: string): Attachment[] {
+  async getAttachments(noteId: string): Promise<Attachment[]> {
     const rows = this.db.prepare(
       "SELECT * FROM attachments WHERE note_id = ? ORDER BY created_at",
     ).all(noteId) as { id: string; note_id: string; path: string; mime_type: string; metadata: string | null; created_at: string }[];
@@ -298,6 +293,11 @@ export class SqliteStore implements Store {
   }
 }
 
+/** @deprecated Renamed to `BunSqliteStore` to make the runtime split explicit. Kept as an alias for backward compatibility. */
+export const SqliteStore = BunSqliteStore;
+/** @deprecated Renamed to `BunSqliteStore`. */
+export type SqliteStore = BunSqliteStore;
+
 function escapeRegex(s: string): string {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }

package/core/src/types.ts

@@ -94,47 +94,47 @@ export interface HydratedLink extends Link {
 
 export interface Store {
   // Notes
-  createNote(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string }): Note;
-  getNote(id: string): Note | null;
-  getNoteByPath(path: string): Note | null;
-  getNotes(ids: string[]): Note[];
-  updateNote(id: string, updates: { content?: string; path?: string; metadata?: Record<string, unknown>; skipUpdatedAt?: boolean }): Note;
-  deleteNote(id: string): void;
-  queryNotes(opts: QueryOpts): Note[];
-  searchNotes(query: string, opts?: { tags?: string[]; limit?: number }): Note[];
+  createNote(content: string, opts?: { id?: string; path?: string; tags?: string[]; metadata?: Record<string, unknown>; created_at?: string }): Promise<Note>;
+  getNote(id: string): Promise<Note | null>;
+  getNoteByPath(path: string): Promise<Note | null>;
+  getNotes(ids: string[]): Promise<Note[]>;
+  updateNote(id: string, updates: { content?: string; path?: string; metadata?: Record<string, unknown>; created_at?: string; skipUpdatedAt?: boolean; if_updated_at?: string }): Promise<Note>;
+  deleteNote(id: string): Promise<void>;
+  queryNotes(opts: QueryOpts): Promise<Note[]>;
+  searchNotes(query: string, opts?: { tags?: string[]; limit?: number }): Promise<Note[]>;
 
   // Tags
-  tagNote(noteId: string, tags: string[]): void;
-  untagNote(noteId: string, tags: string[]): void;
-  listTags(): { name: string; count: number }[];
-  deleteTag(name: string): { deleted: boolean; notes_untagged: number };
+  tagNote(noteId: string, tags: string[]): Promise<void>;
+  untagNote(noteId: string, tags: string[]): Promise<void>;
+  listTags(): Promise<{ name: string; count: number }[]>;
+  deleteTag(name: string): Promise<{ deleted: boolean; notes_untagged: number }>;
 
   // Vault stats (aggregate, read-only)
-  getVaultStats(opts?: { topTagsLimit?: number }): VaultStats;
+  getVaultStats(opts?: { topTagsLimit?: number }): Promise<VaultStats>;
 
   // Links
-  createLink(sourceId: string, targetId: string, relationship: string, metadata?: Record<string, unknown>): Link;
-  deleteLink(sourceId: string, targetId: string, relationship: string): void;
-  getLinks(noteId: string, opts?: { direction?: "outbound" | "inbound" | "both" }): Link[];
-  listLinks(opts?: { noteId?: string; direction?: "outbound" | "inbound" | "both"; relationship?: string }): Link[];
+  createLink(sourceId: string, targetId: string, relationship: string, metadata?: Record<string, unknown>): Promise<Link>;
+  deleteLink(sourceId: string, targetId: string, relationship: string): Promise<void>;
+  getLinks(noteId: string, opts?: { direction?: "outbound" | "inbound" | "both" }): Promise<Link[]>;
+  listLinks(opts?: { noteId?: string; direction?: "outbound" | "inbound" | "both"; relationship?: string }): Promise<Link[]>;
 
   // Bulk operations
-  createNotes(inputs: { content: string; id?: string; path?: string; tags?: string[] }[]): Note[];
-  batchTag(noteIds: string[], tags: string[]): number;
-  batchUntag(noteIds: string[], tags: string[]): number;
+  createNotes(inputs: { content: string; id?: string; path?: string; tags?: string[] }[]): Promise<Note[]>;
+  batchTag(noteIds: string[], tags: string[]): Promise<number>;
+  batchUntag(noteIds: string[], tags: string[]): Promise<number>;
 
   // Deeper link queries
-  traverseLinks(noteId: string, opts?: { max_depth?: number; relationship?: string }): { noteId: string; depth: number; relationship: string; direction: "outbound" | "inbound" }[];
-  findPath(sourceId: string, targetId: string, opts?: { max_depth?: number }): { path: string[]; relationships: string[] } | null;
+  traverseLinks(noteId: string, opts?: { max_depth?: number; relationship?: string }): Promise<{ noteId: string; depth: number; relationship: string; direction: "outbound" | "inbound" }[]>;
+  findPath(sourceId: string, targetId: string, opts?: { max_depth?: number }): Promise<{ path: string[]; relationships: string[] } | null>;
 
   // Tag schemas
-  listTagSchemas(): { tag: string; description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }[];
-  getTagSchema(tag: string): { tag: string; description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> } | null;
-  upsertTagSchema(tag: string, schema: { description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }): { tag: string; description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> };
-  deleteTagSchema(tag: string): boolean;
-  getTagSchemaMap(): Record<string, { description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }>;
+  listTagSchemas(): Promise<{ tag: string; description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }[]>;
+  getTagSchema(tag: string): Promise<{ tag: string; description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> } | null>;
+  upsertTagSchema(tag: string, schema: { description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }): Promise<{ tag: string; description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }>;
+  deleteTagSchema(tag: string): Promise<boolean>;
+  getTagSchemaMap(): Promise<Record<string, { description?: string; fields?: Record<string, { type: string; description?: string; enum?: string[] }> }>>;
 
   // Attachments
-  addAttachment(noteId: string, path: string, mimeType: string, metadata?: Record<string, unknown>): Attachment;
-  getAttachments(noteId: string): Attachment[];
+  addAttachment(noteId: string, path: string, mimeType: string, metadata?: Record<string, unknown>): Promise<Attachment>;
+  getAttachments(noteId: string): Promise<Attachment[]>;
 }

package/core/src/wikilinks.test.ts

@@ -110,28 +110,28 @@ More text
 // Resolution
 // ---------------------------------------------------------------------------
 
-describe("resolveWikilink", () => {
-  it("resolves exact path match", () => {
-    store.createNote("Target note", { path: "My Note" });
+describe("resolveWikilink", async () => {
+  it("resolves exact path match", async () => {
+    await store.createNote("Target note", { path: "My Note" });
     const id = resolveWikilink(db, "My Note");
     expect(id).toBeTruthy();
   });
 
-  it("resolves case-insensitively", () => {
-    const note = store.createNote("Target", { path: "My Note" });
+  it("resolves case-insensitively", async () => {
+    const note = await store.createNote("Target", { path: "My Note" });
     const id = resolveWikilink(db, "my note");
     expect(id).toBe(note.id);
   });
 
-  it("resolves basename match", () => {
-    const note = store.createNote("Deep note", { path: "Projects/Parachute/README" });
+  it("resolves basename match", async () => {
+    const note = await store.createNote("Deep note", { path: "Projects/Parachute/README" });
     const id = resolveWikilink(db, "README");
     expect(id).toBe(note.id);
   });
 
-  it("returns null for ambiguous basename", () => {
-    store.createNote("A", { path: "Folder1/README" });
-    store.createNote("B", { path: "Folder2/README" });
+  it("returns null for ambiguous basename", async () => {
+    await store.createNote("A", { path: "Folder1/README" });
+    await store.createNote("B", { path: "Folder2/README" });
     const id = resolveWikilink(db, "README");
     expect(id).toBeNull();
   });
@@ -146,21 +146,21 @@ describe("resolveWikilink", () => {
 // Sync
 // ---------------------------------------------------------------------------
 
-describe("syncWikilinks", () => {
-  it("creates links for resolved wikilinks", () => {
-    const target = store.createNote("Target", { path: "Target Note" });
-    const source = store.createNote("See [[Target Note]]");
+describe("syncWikilinks", async () => {
+  it("creates links for resolved wikilinks", async () => {
+    const target = await store.createNote("Target", { path: "Target Note" });
+    const source = await store.createNote("See [[Target Note]]");
 
-    const links = store.getLinks(source.id, { direction: "outbound" });
+    const links = await store.getLinks(source.id, { direction: "outbound" });
     expect(links).toHaveLength(1);
     expect(links[0].targetId).toBe(target.id);
     expect(links[0].relationship).toBe("wikilink");
   });
 
-  it("tracks unresolved wikilinks", () => {
-    const source = store.createNote("See [[Missing Note]]");
+  it("tracks unresolved wikilinks", async () => {
+    const source = await store.createNote("See [[Missing Note]]");
 
-    const links = store.getLinks(source.id, { direction: "outbound" });
+    const links = await store.getLinks(source.id, { direction: "outbound" });
     expect(links).toHaveLength(0);
 
     // Check unresolved table
@@ -171,85 +171,85 @@ describe("syncWikilinks", () => {
     expect(unresolved[0].target_path).toBe("Missing Note");
   });
 
-  it("resolves pending wikilinks when target note is created", () => {
-    const source = store.createNote("See [[Future Note]]");
+  it("resolves pending wikilinks when target note is created", async () => {
+    const source = await store.createNote("See [[Future Note]]");
 
     // No link yet
-    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
+    expect(await store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
 
     // Create the target note
-    const target = store.createNote("I exist now", { path: "Future Note" });
+    const target = await store.createNote("I exist now", { path: "Future Note" });
 
     // Link should now exist
-    const links = store.getLinks(source.id, { direction: "outbound" });
+    const links = await store.getLinks(source.id, { direction: "outbound" });
     expect(links).toHaveLength(1);
     expect(links[0].targetId).toBe(target.id);
   });
 
-  it("removes links when wikilinks are removed from content", () => {
-    const target = store.createNote("Target", { path: "Target" });
-    const source = store.createNote("See [[Target]]");
+  it("removes links when wikilinks are removed from content", async () => {
+    const target = await store.createNote("Target", { path: "Target" });
+    const source = await store.createNote("See [[Target]]");
 
-    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(1);
+    expect(await store.getLinks(source.id, { direction: "outbound" })).toHaveLength(1);
 
     // Update content to remove the wikilink
-    store.updateNote(source.id, { content: "No more links here." });
+    await store.updateNote(source.id, { content: "No more links here." });
 
-    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
+    expect(await store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
   });
 
-  it("adds new links when wikilinks are added to content", () => {
-    const a = store.createNote("A", { path: "Note A" });
-    const b = store.createNote("B", { path: "Note B" });
-    const source = store.createNote("See [[Note A]]");
+  it("adds new links when wikilinks are added to content", async () => {
+    const a = await store.createNote("A", { path: "Note A" });
+    const b = await store.createNote("B", { path: "Note B" });
+    const source = await store.createNote("See [[Note A]]");
 
-    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(1);
+    expect(await store.getLinks(source.id, { direction: "outbound" })).toHaveLength(1);
 
     // Update to add another link
-    store.updateNote(source.id, { content: "See [[Note A]] and [[Note B]]" });
+    await store.updateNote(source.id, { content: "See [[Note A]] and [[Note B]]" });
 
-    const links = store.getLinks(source.id, { direction: "outbound" });
+    const links = await store.getLinks(source.id, { direction: "outbound" });
     expect(links).toHaveLength(2);
   });
 
-  it("does not create self-links", () => {
-    const note = store.createNote("I link to [[Myself]]", { path: "Myself" });
-    const links = store.getLinks(note.id, { direction: "outbound" });
+  it("does not create self-links", async () => {
+    const note = await store.createNote("I link to [[Myself]]", { path: "Myself" });
+    const links = await store.getLinks(note.id, { direction: "outbound" });
     expect(links.filter((l) => l.relationship === "wikilink")).toHaveLength(0);
   });
 
-  it("deduplicates multiple mentions of same target", () => {
-    const target = store.createNote("Target", { path: "Target" });
-    const source = store.createNote("See [[Target]] and again [[Target]]");
+  it("deduplicates multiple mentions of same target", async () => {
+    const target = await store.createNote("Target", { path: "Target" });
+    const source = await store.createNote("See [[Target]] and again [[Target]]");
 
-    const links = store.getLinks(source.id, { direction: "outbound" })
+    const links = (await store.getLinks(source.id, { direction: "outbound" }))
       .filter((l) => l.relationship === "wikilink");
     expect(links).toHaveLength(1);
   });
 
-  it("preserves non-wikilink links", () => {
-    const a = store.createNote("A", { id: "a", path: "Note A" });
-    const b = store.createNote("B", { id: "b", path: "Note B" });
+  it("preserves non-wikilink links", async () => {
+    const a = await store.createNote("A", { id: "a", path: "Note A" });
+    const b = await store.createNote("B", { id: "b", path: "Note B" });
 
     // Manual semantic link
-    store.createLink("a", "b", "related-to");
+    await store.createLink("a", "b", "related-to");
 
     // Create note with wikilink to B
-    const source = store.createNote("See [[Note B]]", { id: "source" });
+    const source = await store.createNote("See [[Note B]]", { id: "source" });
 
     // Update content to remove wikilink
-    store.updateNote("source", { content: "No links" });
+    await store.updateNote("source", { content: "No links" });
 
     // Semantic link between a and b should still exist
-    const links = store.getLinks("a", { direction: "outbound" });
+    const links = await store.getLinks("a", { direction: "outbound" });
     expect(links.some((l) => l.relationship === "related-to")).toBe(true);
   });
 
-  it("stores display text and anchor in link metadata", () => {
-    const target = store.createNote("Target", { path: "Target" });
-    const source = store.createNote("See [[Target#Introduction|intro]]");
+  it("stores display text and anchor in link metadata", async () => {
+    const target = await store.createNote("Target", { path: "Target" });
+    const source = await store.createNote("See [[Target#Introduction|intro]]");
 
-    const links = store.getLinks(source.id, { direction: "outbound" });
+    const links = await store.getLinks(source.id, { direction: "outbound" });
     expect(links).toHaveLength(1);
     expect(links[0].metadata?.display).toBe("intro");
     expect(links[0].metadata?.anchor).toBe("Introduction");
@@ -260,17 +260,17 @@ describe("syncWikilinks", () => {
 // Integration with path changes
 // ---------------------------------------------------------------------------
 
-describe("path-based resolution", () => {
-  it("resolves pending links when a note gets a path", () => {
-    const source = store.createNote("See [[Named Note]]");
-    expect(store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
+describe("path-based resolution", async () => {
+  it("resolves pending links when a note gets a path", async () => {
+    const source = await store.createNote("See [[Named Note]]");
+    expect(await store.getLinks(source.id, { direction: "outbound" })).toHaveLength(0);
 
     // Create a note without a path, then give it one
-    const target = store.createNote("Unnamed");
-    store.updateNote(target.id, { path: "Named Note" });
+    const target = await store.createNote("Unnamed");
+    await store.updateNote(target.id, { path: "Named Note" });
 
     // The pending link should be resolved
-    const links = store.getLinks(source.id, { direction: "outbound" });
+    const links = await store.getLinks(source.id, { direction: "outbound" });
     expect(links).toHaveLength(1);
     expect(links[0].targetId).toBe(target.id);
   });

package/docs/HTTP_API.md

@@ -46,8 +46,10 @@ Authorization: Bearer <key>
 X-API-Key: <key>
 ```
 
-Requests from localhost bypass auth (you can hit the server directly without a
-key for local dev).
+Every request is authenticated — localhost and remote traffic go through the
+same path, there is no bypass. Local dev feels friction-free because you can
+hand the CLI-generated API key to your script without exposing it to the
+network, not because the auth check is skipped.
 
 Keys have a **scope**:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openparachute/vault",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Agent-native knowledge graph. Notes, tags, links over MCP.",
   "module": "src/cli.ts",
   "type": "module",