@fortemi/core 2026.7.5 → 2026.7.8

package/dist/index.js

@@ -1,4 +1,4 @@
-import { v7 } from 'uuid';
+import { v7, v5 } from 'uuid';
 import { sha256 } from '@noble/hashes/sha256';
 import { blake3 } from '@noble/hashes/blake3';
 import { bytesToHex } from '@noble/hashes/utils';
@@ -743,6 +743,80 @@ var migration0016 = {
   `
 };
 
+// src/migrations/0017_attachment_blob_parity.ts
+var migration0017 = {
+  version: 17,
+  name: "0017_attachment_blob_parity",
+  sql: `
+    -- \u2500\u2500 attachment_blob parity \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    ALTER TABLE attachment_blob
+      ADD COLUMN IF NOT EXISTS content_type TEXT NOT NULL DEFAULT 'application/octet-stream';
+
+    ALTER TABLE attachment_blob
+      ADD COLUMN IF NOT EXISTS storage_type TEXT NOT NULL DEFAULT 'bytecask';
+
+    -- DERIVED projection state (ADR-013): rebuilt from canonical manifests;
+    -- no trigger maintains it and nothing may treat it as lifecycle truth.
+    ALTER TABLE attachment_blob
+      ADD COLUMN IF NOT EXISTS reference_count INTEGER NOT NULL DEFAULT 0;
+
+    -- Backfill content_type from the attachment-level MIME denormalization (0010).
+    UPDATE attachment_blob ab
+    SET content_type = a.mime_type
+    FROM attachment a
+    WHERE a.blob_id = ab.id
+      AND a.mime_type IS NOT NULL
+      AND ab.content_type = 'application/octet-stream';
+
+    -- Backfill the derived reference count from live manifests.
+    UPDATE attachment_blob ab
+    SET reference_count = (
+      SELECT COUNT(*) FROM attachment a
+      WHERE a.blob_id = ab.id AND a.deleted_at IS NULL
+    );
+
+    -- Orphan scan support (projection-side reporting only).
+    CREATE INDEX IF NOT EXISTS idx_attachment_blob_orphan
+      ON attachment_blob(reference_count) WHERE reference_count = 0;
+
+    -- \u2500\u2500 attachment parity additions (additive, nullable-first) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS original_filename TEXT;
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'uploaded'
+      CHECK (status IN ('uploaded', 'queued', 'processing', 'completed', 'failed', 'quarantined'));
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS processing_error TEXT;
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS extraction_strategy TEXT;
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS extraction_config JSONB DEFAULT '{}';
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS extracted_metadata JSONB;
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS ai_description TEXT;
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS has_preview BOOLEAN NOT NULL DEFAULT FALSE;
+    ALTER TABLE attachment ADD COLUMN IF NOT EXISTS preview_blob_id TEXT REFERENCES attachment_blob(id);
+
+    -- Backfill: browser attachments that already carry extracted text were
+    -- fully processed at attach time \u2014 mark them completed so the
+    -- status-gated searchable-text join (server parity) keeps including them.
+    UPDATE attachment SET status = 'completed'
+    WHERE extracted_text IS NOT NULL AND extracted_text <> '';
+
+    -- \u2500\u2500 attachment_embedding (server parity; CLIP column reserved) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+    CREATE TABLE IF NOT EXISTS attachment_embedding (
+      id TEXT PRIMARY KEY,
+      attachment_id TEXT NOT NULL REFERENCES attachment(id),
+      embedding_set_id TEXT REFERENCES embedding_set(id),
+      chunk_index INTEGER NOT NULL DEFAULT 0,
+      text TEXT NOT NULL,
+      vector vector(768),
+      clip_vector vector(512),
+      model TEXT NOT NULL,
+      embedding_type TEXT NOT NULL DEFAULT 'text',
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      UNIQUE (attachment_id, embedding_set_id, chunk_index)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_attachment_embedding_attachment
+      ON attachment_embedding(attachment_id);
+  `
+};
+
 // src/migrations/index.ts
 var allMigrations = [
   migration0001,
@@ -760,7 +834,8 @@ var allMigrations = [
   migration0013,
   migration0014,
   migration0015,
-  migration0016
+  migration0016,
+  migration0017
 ];
 
 // src/data-archive.ts
@@ -888,7 +963,7 @@ var NotesRepository = class {
    * All writes happen in a single transaction.
    */
   async create(input) {
-    const noteId = generateId();
+    const noteId = input.id ?? generateId();
     const originalId = generateId();
     const contentHash = computeHash(new TextEncoder().encode(input.content));
     await this.db.transaction(async (tx) => {
@@ -1282,7 +1357,7 @@ var ATTACHMENT_TEXT_JOIN = `
                 string_agg(extracted_text, ' ' ORDER BY position, created_at)
                   FILTER (WHERE extracted_text IS NOT NULL AND extracted_text <> '') as extracted_text
          FROM attachment
-         WHERE deleted_at IS NULL
+         WHERE deleted_at IS NULL AND status = 'completed'
          GROUP BY note_id
        ) ax ON ax.note_id = n.id`;
 var COMBINED_TEXT_VECTOR_SQL = `to_tsvector('english', (coalesce(c.content, '') || ' ' || coalesce(ax.extracted_text, '')))`;
@@ -1797,7 +1872,7 @@ var ATTACHMENT_TEXT_JOIN2 = `
                 string_agg(extracted_text, ' ' ORDER BY position, created_at)
                   FILTER (WHERE extracted_text IS NOT NULL AND extracted_text <> '') as extracted_text
          FROM attachment
-         WHERE deleted_at IS NULL
+         WHERE deleted_at IS NULL AND status = 'completed'
          GROUP BY note_id
        ) ax ON ax.note_id = n.id`;
 var COMBINED_TEXT_SQL = `trim(both from (coalesce(c.content, '') || ' ' || coalesce(ax.extracted_text, '')))`;
@@ -3609,150 +3684,326 @@ function matchRoute(routes, request, url) {
   return null;
 }
 
-// src/blob-store.ts
-function hashPath(hash) {
-  return {
-    dir1: hash.slice(0, 2),
-    dir2: hash.slice(2, 4),
-    filename: hash
-  };
+// src/shard/blob-sidecar.ts
+var SIDECAR_PREFIX = "blobs/";
+function blobChecksumToHex(checksum) {
+  const sep = checksum.indexOf(":");
+  return sep >= 0 ? checksum.slice(sep + 1) : checksum;
+}
+function sidecarEntryName(checksum) {
+  return SIDECAR_PREFIX + blobChecksumToHex(checksum);
+}
+function isSidecarEntry(name) {
+  if (!name.startsWith(SIDECAR_PREFIX)) return false;
+  const rest = name.slice(SIDECAR_PREFIX.length);
+  return rest.length > 0 && !rest.includes("/");
 }
-var OpfsBlobStore = class {
-  constructor(archiveName) {
-    this.archiveName = archiveName;
+function collectSidecarBlobs(files) {
+  const blobs = /* @__PURE__ */ new Map();
+  for (const [name, bytes] of files) {
+    if (isSidecarEntry(name)) {
+      blobs.set(name.slice(SIDECAR_PREFIX.length), bytes);
+    }
   }
-  async getRoot() {
-    const root = await navigator.storage.getDirectory();
-    return root.getDirectoryHandle(`fortemi-${this.archiveName}-blobs`, { create: true });
+  return blobs;
+}
+
+// src/blob-store-legacy.ts
+function legacyName(archiveName) {
+  return `fortemi-${archiveName}-blobs`;
+}
+function idbRequest(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function legacyIdbExists(factory, name) {
+  if (typeof factory.databases === "function") {
+    const dbs = await factory.databases();
+    return dbs.some((db) => db.name === name);
   }
-  async getFileHandle(hash, create) {
-    const { dir1, dir2, filename } = hashPath(hash);
-    try {
-      const root = await this.getRoot();
-      const d1 = await root.getDirectoryHandle(dir1, { create });
-      const d2 = await d1.getDirectoryHandle(dir2, { create });
-      return d2.getFileHandle(filename, { create });
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "NotFoundError") {
-        return null;
-      }
-      throw err;
-    }
+  return false;
+}
+async function migrateLegacyIdb(archiveName, target, factory) {
+  const name = legacyName(archiveName);
+  if (!await legacyIdbExists(factory, name)) return 0;
+  const db = await new Promise((resolve, reject) => {
+    const req = factory.open(name);
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+  try {
+    if (!db.objectStoreNames.contains("blobs")) return 0;
+    const tx = db.transaction("blobs", "readonly");
+    const values = await idbRequest(tx.objectStore("blobs").getAll());
+    let migrated = 0;
+    for (const value of values) {
+      if (value instanceof Uint8Array) {
+        await target.put(value);
+        migrated += 1;
+      } else if (value instanceof ArrayBuffer) {
+        await target.put(new Uint8Array(value));
+        migrated += 1;
+      }
+    }
+    db.close();
+    await idbRequest(factory.deleteDatabase(name));
+    return migrated;
+  } finally {
+    db.close();
   }
-  async write(hash, data) {
-    const fh = await this.getFileHandle(hash, true);
-    if (!fh) throw new Error(`OpfsBlobStore: could not create file for hash ${hash}`);
-    const writable = await fh.createWritable();
-    await writable.write(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
-    await writable.close();
+}
+async function migrateLegacyOpfs(archiveName, target) {
+  if (typeof navigator === "undefined" || typeof navigator.storage?.getDirectory !== "function") {
+    return 0;
   }
-  async read(hash) {
-    const fh = await this.getFileHandle(hash, false);
-    if (!fh) return null;
-    const file = await fh.getFile();
-    const buffer = await file.arrayBuffer();
-    return new Uint8Array(buffer);
+  const root = await navigator.storage.getDirectory();
+  let legacyDir;
+  try {
+    legacyDir = await root.getDirectoryHandle(legacyName(archiveName), {
+      create: false
+    });
+  } catch {
+    return 0;
   }
-  async remove(hash) {
-    const { dir1, dir2, filename } = hashPath(hash);
-    try {
-      const root = await this.getRoot();
-      const d1 = await root.getDirectoryHandle(dir1, { create: false });
-      const d2 = await d1.getDirectoryHandle(dir2, { create: false });
-      await d2.removeEntry(filename);
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "NotFoundError") {
-        return;
+  let migrated = 0;
+  for await (const [, d1] of legacyDir.entries()) {
+    if (d1.kind !== "directory") continue;
+    for await (const [, d2] of d1.entries()) {
+      if (d2.kind !== "directory") continue;
+      for await (const [, fh] of d2.entries()) {
+        if (fh.kind !== "file") continue;
+        const file = await fh.getFile();
+        await target.put(new Uint8Array(await file.arrayBuffer()));
+        migrated += 1;
       }
-      throw err;
     }
   }
-  async exists(hash) {
-    const fh = await this.getFileHandle(hash, false);
-    return fh !== null;
-  }
-};
-var IDB_STORE = "blobs";
-var IDB_VERSION = 1;
-function openDb(dbName) {
-  return new Promise((resolve, reject) => {
-    const req = indexedDB.open(dbName, IDB_VERSION);
-    req.onupgradeneeded = () => {
-      req.result.createObjectStore(IDB_STORE);
-    };
-    req.onsuccess = () => resolve(req.result);
-    req.onerror = () => reject(req.error);
-  });
+  await root.removeEntry(legacyName(archiveName), { recursive: true });
+  return migrated;
 }
-var IdbBlobStore = class {
-  dbName;
-  _db = null;
-  constructor(archiveName) {
-    this.dbName = `fortemi-${archiveName}-blobs`;
-  }
-  async db() {
-    if (!this._db) {
-      this._db = await openDb(this.dbName);
+async function migrateLegacyBlobStore(archiveName, target, indexedDbFactory) {
+  let migrated = 0;
+  let failed = false;
+  const factory = indexedDbFactory ?? globalThis.indexedDB;
+  if (factory) {
+    try {
+      migrated += await migrateLegacyIdb(archiveName, target, factory);
+    } catch {
+      failed = true;
     }
-    return this._db;
   }
-  async write(hash, data) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readwrite");
-      tx.objectStore(IDB_STORE).put(data, hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
+  try {
+    migrated += await migrateLegacyOpfs(archiveName, target);
+  } catch {
+    failed = true;
   }
-  async read(hash) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readonly");
-      const req = tx.objectStore(IDB_STORE).get(hash);
-      req.onsuccess = () => resolve(req.result ?? null);
-      req.onerror = () => reject(req.error);
-    });
+  return { migrated, failed };
+}
+
+// src/blob-store.ts
+var MemoryBlobStore = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  entries = /* @__PURE__ */ new Map();
+  async put(bytes) {
+    const checksum = computeBlobHash(bytes);
+    const existing = this.entries.get(checksum);
+    if (existing) {
+      existing.refcount += 1;
+    } else {
+      this.entries.set(checksum, { bytes, createdAt: this.now(), refcount: 1 });
+    }
+    return checksum;
+  }
+  async read(checksum) {
+    return this.entries.get(checksum)?.bytes ?? null;
+  }
+  async has(checksum) {
+    return this.entries.has(checksum);
+  }
+  async reconcile(liveChecksums, opts) {
+    const live = /* @__PURE__ */ new Map();
+    for (const checksum of liveChecksums) {
+      live.set(checksum, (live.get(checksum) ?? 0) + 1);
+    }
+    const missing = [...live.keys()].filter((c) => !this.entries.has(c)).sort();
+    const unreferenced = [];
+    let referenced = 0;
+    let removed = 0;
+    let bytesFreed = 0;
+    for (const [checksum, entry] of [...this.entries].sort()) {
+      const refcount = live.get(checksum) ?? 0;
+      entry.refcount = refcount;
+      if (refcount > 0) {
+        referenced += 1;
+        continue;
+      }
+      unreferenced.push(checksum);
+      if (opts?.removeUnreferenced) {
+        this.entries.delete(checksum);
+        removed += 1;
+        bytesFreed += entry.bytes.byteLength;
+      }
+    }
+    return { referenced, missing, unreferenced, removed, bytesFreed };
   }
-  async remove(hash) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readwrite");
-      tx.objectStore(IDB_STORE).delete(hash);
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
+  async gc(opts) {
+    const minAgeMs = opts?.minAgeMs ?? 0;
+    const cutoff = this.now() - minAgeMs;
+    let collected = 0;
+    let bytesFreed = 0;
+    for (const [checksum, entry] of this.entries) {
+      if (entry.refcount === 0 && entry.createdAt <= cutoff) {
+        this.entries.delete(checksum);
+        collected += 1;
+        bytesFreed += entry.bytes.byteLength;
+      }
+    }
+    return { collected, bytesFreed };
   }
-  async exists(hash) {
-    const db = await this.db();
-    return new Promise((resolve, reject) => {
-      const tx = db.transaction(IDB_STORE, "readonly");
-      const req = tx.objectStore(IDB_STORE).count(hash);
-      req.onsuccess = () => resolve(req.result > 0);
-      req.onerror = () => reject(req.error);
-    });
+  async diagnostics() {
+    return { backend: "memory", probe: null };
+  }
+  async close() {
   }
 };
-var MemoryBlobStore = class {
-  store = /* @__PURE__ */ new Map();
-  async write(hash, data) {
-    this.store.set(hash, data);
+var CHECKSUM_PREFIX = "blake3:";
+function toChecksum(hex) {
+  return CHECKSUM_PREFIX + hex;
+}
+var BytecaskBlobStore = class {
+  constructor(facade, adapter, index, probe, now = Date.now) {
+    this.facade = facade;
+    this.adapter = adapter;
+    this.index = index;
+    this.probe = probe;
+    this.now = now;
+  }
+  async put(bytes) {
+    return toChecksum(await this.facade.put(bytes));
+  }
+  async read(checksum) {
+    return this.facade.get(blobChecksumToHex(checksum));
+  }
+  async has(checksum) {
+    return this.adapter.exists(blobChecksumToHex(checksum));
+  }
+  async reconcile(liveChecksums, opts) {
+    const live = /* @__PURE__ */ new Set();
+    for (const checksum of liveChecksums) live.add(blobChecksumToHex(checksum));
+    const physical = /* @__PURE__ */ new Set();
+    for await (const hash of this.adapter.list()) physical.add(hash);
+    const entryList = [...await this.index.values()];
+    const entries = new Map(entryList.map((e) => [e.hash, e]));
+    for (const hash of [...entries.keys()]) {
+      if (!physical.has(hash)) {
+        await this.index.delete(hash);
+        entries.delete(hash);
+      }
+    }
+    const missing = [...live].filter((hash) => !physical.has(hash)).sort().map(toChecksum);
+    const unreferenced = [];
+    let referenced = 0;
+    let removed = 0;
+    let bytesFreed = 0;
+    for (const hash of [...physical].sort()) {
+      const existing = entries.get(hash);
+      const size = existing?.size ?? (await this.adapter.read(hash))?.byteLength ?? 0;
+      if (live.has(hash)) {
+        await this.index.set({
+          hash,
+          size,
+          createdAt: existing?.createdAt ?? this.now(),
+          refcount: 1
+        });
+        referenced += 1;
+        continue;
+      }
+      unreferenced.push(toChecksum(hash));
+      if (opts?.removeUnreferenced) {
+        await this.adapter.remove(hash);
+        await this.index.delete(hash);
+        removed += 1;
+        bytesFreed += size;
+      } else {
+        await this.index.set({
+          hash,
+          size,
+          createdAt: existing?.createdAt ?? this.now(),
+          refcount: 0
+        });
+      }
+    }
+    return { referenced, missing, unreferenced, removed, bytesFreed };
   }
-  async read(hash) {
-    return this.store.get(hash) ?? null;
+  async gc(opts) {
+    const result = await this.facade.gc({ minAgeMs: opts?.minAgeMs });
+    return { collected: result.collected, bytesFreed: result.bytesFreed };
   }
-  async remove(hash) {
-    this.store.delete(hash);
+  async diagnostics() {
+    return { backend: this.adapter.kind, probe: this.probe };
   }
-  async exists(hash) {
-    return this.store.has(hash);
+  async close() {
+    await this.facade.close();
   }
 };
-function createBlobStore(archiveName) {
-  if (typeof navigator !== "undefined" && "storage" in navigator && "getDirectory" in navigator.storage) {
-    return new OpfsBlobStore(archiveName);
+async function createBlobStore(archiveName, options) {
+  const bytecask = await import('@bytecask/core');
+  if (options?.backend === "opfs") {
+    throw new Error(
+      "BlobStore: the OPFS tier requires @bytecask/core >= 2026.7.2 (worker-backed adapter); use the default IndexedDB tier until the upstream factory switch lands."
+    );
+  }
+  const idbFactory = options?.indexedDB ?? globalThis.indexedDB;
+  const attempted = [];
+  let adapter;
+  const wantsIdb = options?.backend !== "memory";
+  if (wantsIdb && idbFactory) {
+    adapter = new bytecask.IdbAdapter({
+      databaseName: `fortemi-${archiveName}-bytecask`,
+      factory: idbFactory
+    });
+    attempted.push({ backend: "idb", ok: true });
+  } else {
+    if (wantsIdb) {
+      attempted.push({ backend: "idb", ok: false, reason: "indexedDB unavailable" });
+      if (options?.backend === "idb") {
+        throw new Error("BlobStore: IndexedDB tier requested but indexedDB is unavailable");
+      }
+    }
+    adapter = new bytecask.MemoryAdapter();
+    attempted.push({ backend: "memory", ok: true });
   }
-  return new IdbBlobStore(archiveName);
+  const index = new bytecask.MemoryIndexStore();
+  const facade = bytecask.createMemoryBlobStore({ adapter, index });
+  const probe = { backend: adapter.kind, attempted };
+  const wrapped = new BytecaskBlobStore(facade, adapter, index, probe);
+  if (options?.migrateLegacy !== false) {
+    await migrateLegacyBlobStore(archiveName, wrapped, options?.indexedDB);
+  }
+  return wrapped;
+}
+function createLazyBlobStore(archiveName, options) {
+  let inner = null;
+  const open = () => {
+    inner ??= createBlobStore(archiveName, options);
+    return inner;
+  };
+  return {
+    put: async (bytes) => (await open()).put(bytes),
+    read: async (checksum) => (await open()).read(checksum),
+    has: async (checksum) => (await open()).has(checksum),
+    reconcile: async (live, opts) => (await open()).reconcile(live, opts),
+    gc: async (opts) => (await open()).gc(opts),
+    diagnostics: async () => (await open()).diagnostics(),
+    close: async () => {
+      if (inner) await (await inner).close();
+      inner = null;
+    }
+  };
 }
 
 // src/repositories/graph-repository.ts
@@ -5412,16 +5663,21 @@ var AttachmentsRepository = class {
   /**
    * Attach a binary file to a note.
    *
-   * If a blob with the same BLAKE3 content hash already exists, the existing
-   * blob row is reused (deduplication). Otherwise a new blob row is inserted
-   * and the raw bytes are written to the BlobStore. The BLAKE3 `content_hash`
-   * (`blake3:<hex>`) matches the server convention and is the key used by the
-   * portable Knowledge-Shard byte sidecar.
+   * Bytes are written first (`put()` is idempotent — content addressing makes
+   * replays safe), then the metadata rows commit (ADR-013 D5). A crash
+   * between the two leaves an unreferenced blob that reconcile/gc sweeps —
+   * never a manifest without recoverable state. The store-computed BLAKE3
+   * `content_hash` (`blake3:<hex>`) matches the server convention and is the
+   * key used by the portable Knowledge-Shard byte sidecar.
+   *
+   * If a blob row with the same content hash already exists, it is reused
+   * (deduplication) — re-putting the bytes also heals a previously
+   * reference-only blob whose bytes went missing.
    *
    * Returns the newly created AttachmentRow.
    */
   async attach(input) {
-    const contentHash = computeBlobHash(input.data);
+    const contentHash = await this.blobStore.put(input.data);
     const sizeBytes = input.data.length;
     let blobId;
     const existing = await this.db.query(
@@ -5432,7 +5688,6 @@ var AttachmentsRepository = class {
       blobId = existing.rows[0].id;
     } else {
       blobId = generateId();
-      await this.blobStore.write(contentHash, input.data);
       await this.db.query(
         `INSERT INTO attachment_blob (id, content_hash, size_bytes) VALUES ($1, $2, $3)`,
         [blobId, contentHash, sizeBytes]
@@ -5440,8 +5695,8 @@ var AttachmentsRepository = class {
     }
     const attachmentId = generateId();
     await this.db.query(
-      `INSERT INTO attachment (id, note_id, blob_id, filename, display_name, mime_type, extracted_text)
-       VALUES ($1, $2, $3, $4, $5, $6, $7)`,
+      `INSERT INTO attachment (id, note_id, blob_id, filename, display_name, mime_type, extracted_text, status)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
       [
         attachmentId,
         input.noteId,
@@ -5449,7 +5704,8 @@ var AttachmentsRepository = class {
         input.filename,
         input.displayName ?? null,
         input.mimeType ?? null,
-        input.extractedText ?? null
+        input.extractedText ?? null,
+        input.extractedText ? "completed" : "uploaded"
       ]
     );
     return this.get(attachmentId);
@@ -5468,16 +5724,23 @@ var AttachmentsRepository = class {
   }
   /**
    * Retrieve the raw binary data for an attachment.
-   * Returns null if the blob cannot be found in the BlobStore.
+   * Returns null when the bytes are not present — the attachment is then in
+   * the recoverable reference-only state (metadata intact, bytes
+   * re-hydratable from a shard sidecar or a re-attach of the same content).
    */
   async getBlob(attachmentId) {
-    const att = await this.get(attachmentId);
-    const blob = await this.db.query(
-      `SELECT content_hash FROM attachment_blob WHERE id = $1`,
-      [att.blob_id]
-    );
-    if (blob.rows.length === 0) return null;
-    return this.blobStore.read(blob.rows[0].content_hash);
+    const checksum = await this.blobChecksumOf(attachmentId);
+    if (checksum === null) return null;
+    return this.blobStore.read(checksum);
+  }
+  /**
+   * True when the attachment's bytes are physically present in the BlobStore.
+   * False means reference-only (recoverable), not an error.
+   */
+  async hasBlob(attachmentId) {
+    const checksum = await this.blobChecksumOf(attachmentId);
+    if (checksum === null) return false;
+    return this.blobStore.has(checksum);
   }
   /**
    * List active (non-deleted) attachments for a note.
@@ -5494,7 +5757,9 @@ var AttachmentsRepository = class {
   }
   /**
    * Soft-delete an attachment by setting deleted_at to the current timestamp.
-   * The underlying blob row and BlobStore data are not removed.
+   * The blob row is untouched and no bytes are removed inline — physical
+   * removal happens only through deferred `reconcileBlobs()`/`gcBlobs()`
+   * against the canonical live set (ADR-013 D4).
    */
   async delete(id) {
     await this.db.query(
@@ -5502,6 +5767,44 @@ var AttachmentsRepository = class {
       [id]
     );
   }
+  /**
+   * The authoritative live-checksum set: content hashes referenced by at
+   * least one non-deleted attachment. This — not any refcount — decides
+   * which bytes are reachable.
+   */
+  async liveBlobChecksums() {
+    const result = await this.db.query(
+      `SELECT DISTINCT ab.content_hash
+       FROM attachment_blob ab
+       JOIN attachment a ON a.blob_id = ab.id
+       WHERE a.deleted_at IS NULL`
+    );
+    return result.rows.map((row) => row.content_hash);
+  }
+  /**
+   * Reconcile the BlobStore against the canonical live set (startup, after
+   * quota events, after interrupted writes). `missing` lists reference-only
+   * checksums; `unreferenced` lists GC candidates.
+   */
+  async reconcileBlobs(opts) {
+    return this.blobStore.reconcile(await this.liveBlobChecksums(), opts);
+  }
+  /**
+   * Deferred, age-thresholded physical removal of unreachable bytes.
+   * Runs a reconcile first so GC always acts on current manifest truth.
+   */
+  async gcBlobs(opts) {
+    await this.reconcileBlobs();
+    return this.blobStore.gc(opts);
+  }
+  async blobChecksumOf(attachmentId) {
+    const att = await this.get(attachmentId);
+    const blob = await this.db.query(
+      `SELECT content_hash FROM attachment_blob WHERE id = $1`,
+      [att.blob_id]
+    );
+    return blob.rows.length > 0 ? blob.rows[0].content_hash : null;
+  }
 };
 
 // src/tools/manage-attachments.ts
@@ -5516,6 +5819,21 @@ var ManageAttachmentsInputSchema = z.object({
   extracted_text: z.string().optional(),
   display_name: z.string().optional()
 });
+function toToolAttachment(row) {
+  return {
+    id: row.id,
+    note_id: row.note_id,
+    blob_id: row.blob_id,
+    document_type_id: row.document_type_id,
+    mime_type: row.mime_type,
+    extracted_text: row.extracted_text,
+    filename: row.filename,
+    display_name: row.display_name,
+    position: row.position,
+    created_at: row.created_at,
+    deleted_at: row.deleted_at
+  };
+}
 async function manageAttachments(db, blobStore, rawInput) {
   const input = ManageAttachmentsInputSchema.parse(rawInput);
   const repo = new AttachmentsRepository(db, blobStore);
@@ -5539,17 +5857,17 @@ async function manageAttachments(db, blobStore, rawInput) {
         await enqueueJob(db, { noteId: input.note_id, jobType: "embedding" });
         await enqueueJob(db, { noteId: input.note_id, jobType: "concept_tagging" });
       }
-      return { action: "attach", attachment, size_bytes: data.length };
+      return { action: "attach", attachment: toToolAttachment(attachment), size_bytes: data.length };
     }
     case "list": {
       if (!input.note_id) throw new Error("note_id required for list");
       const attachments = await repo.list(input.note_id);
-      return { action: "list", attachments };
+      return { action: "list", attachments: attachments.map(toToolAttachment) };
     }
     case "get": {
       if (!input.attachment_id) throw new Error("attachment_id required for get");
       const attachment = await repo.get(input.attachment_id);
-      return { action: "get", attachment };
+      return { action: "get", attachment: toToolAttachment(attachment) };
     }
     case "get_blob": {
       if (!input.attachment_id) throw new Error("attachment_id required for get_blob");
@@ -6223,13 +6541,13 @@ var OpenAICompatibleProvider = class {
       throw new Error("Streaming not supported: response body is null");
     }
     const reader = response.body.getReader();
-    const decoder6 = new TextDecoder();
+    const decoder7 = new TextDecoder();
     let buffer = "";
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        buffer += decoder6.decode(value, { stream: true });
+        buffer += decoder7.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
@@ -7011,6 +7329,180 @@ async function validateChecksums(checksums, files) {
   return { valid: failures.length === 0, failures };
 }
 
+// src/shard/shard-signature.ts
+var SIGNATURE_ENTRY = "signature.json";
+var SIGNING_ENVELOPE_VERSION = "1";
+var SIGNING_ALGORITHM = "ed25519";
+var MAX_ENVELOPE_BYTES = 64 * 1024;
+var AllowlistTrustStore = class {
+  keys;
+  constructor(keys) {
+    this.keys = new Map(keys.map((k) => [k.key_id, k]));
+  }
+  resolve(keyId) {
+    return this.keys.get(keyId) ?? null;
+  }
+  /** Mark a key revoked without removing it (still resolvable, verdict `revoked`). */
+  revoke(keyId) {
+    const key = this.keys.get(keyId);
+    if (key) this.keys.set(keyId, { ...key, revoked: true });
+  }
+};
+function base64urlToBytes(s) {
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/");
+  const b64 = padded + "=".repeat((4 - padded.length % 4) % 4);
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i += 1) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function bytesToBase64url(bytes) {
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  return btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function canonicalPayloadBytes(payload) {
+  const canonical = {
+    blob_digests: [...payload.blob_digests].sort(),
+    format_version: payload.format_version,
+    manifest_digest: payload.manifest_digest,
+    signer: {
+      algorithm: payload.signer.algorithm,
+      key_id: payload.signer.key_id,
+      public_key: payload.signer.public_key
+    }
+  };
+  return new TextEncoder().encode(JSON.stringify(canonical));
+}
+var ed25519Supported = null;
+async function isShardSigningSupported() {
+  if (ed25519Supported !== null) return ed25519Supported;
+  try {
+    const subtle = globalThis.crypto?.subtle;
+    if (!subtle) {
+      ed25519Supported = false;
+      return false;
+    }
+    await subtle.importKey("raw", toBufferSource(new Uint8Array(32)), { name: "Ed25519" }, false, ["verify"]);
+    ed25519Supported = true;
+  } catch {
+    ed25519Supported = false;
+  }
+  return ed25519Supported;
+}
+function sidecarBlobDigests(files) {
+  const digests = [];
+  for (const name of files.keys()) {
+    if (isSidecarEntry(name)) digests.push(name.slice(SIDECAR_PREFIX.length));
+  }
+  return digests.sort();
+}
+async function verifyShardSignature(input) {
+  const { files, trustStore } = input;
+  const sigBytes = files.get(SIGNATURE_ENTRY);
+  if (!sigBytes) return { ok: false, reason: "unsigned" };
+  if (sigBytes.byteLength > MAX_ENVELOPE_BYTES) {
+    return { ok: false, reason: "malformed", detail: "signature envelope exceeds size cap" };
+  }
+  let envelope;
+  try {
+    const parsed = JSON.parse(new TextDecoder().decode(sigBytes));
+    if (!isEnvelopeShape(parsed)) throw new Error("unexpected envelope shape");
+    envelope = parsed;
+  } catch (err) {
+    return { ok: false, reason: "malformed", detail: err instanceof Error ? err.message : String(err) };
+  }
+  if (envelope.format_version !== SIGNING_ENVELOPE_VERSION) {
+    return { ok: false, reason: "malformed", detail: `unsupported envelope version ${envelope.format_version}` };
+  }
+  if (envelope.signer.algorithm !== SIGNING_ALGORITHM) {
+    return { ok: false, reason: "malformed", detail: `unsupported algorithm ${envelope.signer.algorithm}` };
+  }
+  const trusted = await trustStore.resolve(envelope.signer.key_id);
+  if (!trusted) return { ok: false, reason: "unknown-signer", keyId: envelope.signer.key_id };
+  if (trusted.revoked) return { ok: false, reason: "revoked", keyId: envelope.signer.key_id };
+  if (trusted.public_key !== envelope.signer.public_key) {
+    return { ok: false, reason: "bad-signature", keyId: envelope.signer.key_id };
+  }
+  if (!await isShardSigningSupported()) return { ok: false, reason: "unsupported" };
+  const payload = {
+    format_version: envelope.format_version,
+    signer: envelope.signer,
+    manifest_digest: envelope.manifest_digest,
+    blob_digests: envelope.blob_digests
+  };
+  let signatureValid = false;
+  try {
+    const key = await globalThis.crypto.subtle.importKey(
+      "raw",
+      toBufferSource(base64urlToBytes(trusted.public_key)),
+      { name: "Ed25519" },
+      false,
+      ["verify"]
+    );
+    const digest = await sha256Hex(canonicalPayloadBytes(payload));
+    signatureValid = await globalThis.crypto.subtle.verify(
+      "Ed25519",
+      key,
+      toBufferSource(base64urlToBytes(envelope.signature)),
+      toBufferSource(new TextEncoder().encode(digest))
+    );
+  } catch (err) {
+    return { ok: false, reason: "malformed", detail: err instanceof Error ? err.message : String(err) };
+  }
+  if (!signatureValid) return { ok: false, reason: "bad-signature", keyId: envelope.signer.key_id };
+  const manifest = files.get("manifest.json");
+  if (!manifest) {
+    return { ok: false, reason: "content-mismatch", detail: "manifest.json missing" };
+  }
+  const manifestDigest = await sha256Hex(manifest);
+  if (manifestDigest !== envelope.manifest_digest) {
+    return { ok: false, reason: "content-mismatch", detail: "manifest digest does not match signature" };
+  }
+  const archiveBlobDigests = sidecarBlobDigests(files);
+  const signedBlobDigests = [...envelope.blob_digests].sort();
+  if (archiveBlobDigests.join(",") !== signedBlobDigests.join(",")) {
+    return {
+      ok: false,
+      reason: "content-mismatch",
+      detail: "sidecar blob digest set does not match signature"
+    };
+  }
+  return { ok: true, keyId: envelope.signer.key_id };
+}
+function toBufferSource(bytes) {
+  const copy = new Uint8Array(new ArrayBuffer(bytes.byteLength));
+  copy.set(bytes);
+  return copy;
+}
+function isEnvelopeShape(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const v = value;
+  const signer = v.signer;
+  return typeof v.format_version === "string" && typeof v.manifest_digest === "string" && typeof v.signature === "string" && Array.isArray(v.blob_digests) && v.blob_digests.every((d) => typeof d === "string") && typeof signer === "object" && signer !== null && typeof signer.key_id === "string" && typeof signer.algorithm === "string" && typeof signer.public_key === "string";
+}
+async function signShard(input) {
+  const manifest = input.files.get("manifest.json");
+  if (!manifest) throw new Error("signShard: manifest.json missing from archive");
+  const payload = {
+    format_version: SIGNING_ENVELOPE_VERSION,
+    signer: { key_id: input.keyId, algorithm: SIGNING_ALGORITHM, public_key: input.publicKey },
+    manifest_digest: await sha256Hex(manifest),
+    blob_digests: sidecarBlobDigests(input.files)
+  };
+  const digest = await sha256Hex(canonicalPayloadBytes(payload));
+  const signature = await globalThis.crypto.subtle.sign(
+    "Ed25519",
+    input.privateKey,
+    toBufferSource(new TextEncoder().encode(digest))
+  );
+  const envelope = {
+    ...payload,
+    signature: bytesToBase64url(new Uint8Array(signature))
+  };
+  return new TextEncoder().encode(JSON.stringify(envelope, null, 2));
+}
+
 // src/shard/field-mapper.ts
 function noteToShard(note) {
   return {
@@ -7018,6 +7510,7 @@ function noteToShard(note) {
     title: note.title,
     original_content: note.original_content,
     revised_content: note.revised_content,
+    ...note.ai_metadata != null ? { metadata: note.ai_metadata } : {},
     collection_id: note.collection_id ?? null,
     ...note.attachments?.length ? { attachments: note.attachments } : {},
     format: note.format,
@@ -7041,6 +7534,7 @@ function noteFromShard(shard) {
     is_archived: shard.archived,
     original_content: shard.original_content,
     revised_content: shard.revised_content,
+    ai_metadata: shard.metadata ?? null,
     collection_id: shard.collection_id ?? null,
     attachments,
     tags: shard.tags,
@@ -7079,11 +7573,11 @@ function linkFromShard(shard) {
     id: shard.id,
     source_note_id: shard.from_note_id,
     target_note_id: shard.to_note_id,
-    to_url: shard.to_url,
+    to_url: shard.to_url ?? null,
     link_type: shard.kind,
     confidence: shard.score,
     created_at: shard.created_at,
-    metadata: shard.metadata
+    metadata: shard.metadata ?? null
   };
 }
 function collectionToShard(collection, noteCount) {
@@ -7213,10 +7707,10 @@ function embeddingFromShard(shard) {
     id: shard.id,
     note_id: shard.note_id,
     embedding_set_id: shard.embedding_set_id ?? null,
-    chunk_index: shard.chunk_index,
-    text: shard.text,
+    chunk_index: shard.chunk_index ?? 0,
+    text: shard.text ?? "",
     vector: `[${shard.vector.join(",")}]`,
-    model: shard.model,
+    model: shard.model ?? null,
     created_at: shard.created_at ?? null
   };
 }
@@ -7311,30 +7805,6 @@ function slugifyEmbeddingSet(value) {
   return slug || "embedding-set";
 }
 
-// src/shard/blob-sidecar.ts
-var SIDECAR_PREFIX = "blobs/";
-function blobChecksumToHex(checksum) {
-  const sep = checksum.indexOf(":");
-  return sep >= 0 ? checksum.slice(sep + 1) : checksum;
-}
-function sidecarEntryName(checksum) {
-  return SIDECAR_PREFIX + blobChecksumToHex(checksum);
-}
-function isSidecarEntry(name) {
-  if (!name.startsWith(SIDECAR_PREFIX)) return false;
-  const rest = name.slice(SIDECAR_PREFIX.length);
-  return rest.length > 0 && !rest.includes("/");
-}
-function collectSidecarBlobs(files) {
-  const blobs = /* @__PURE__ */ new Map();
-  for (const [name, bytes] of files) {
-    if (isSidecarEntry(name)) {
-      blobs.set(name.slice(SIDECAR_PREFIX.length), bytes);
-    }
-  }
-  return blobs;
-}
-
 // src/shard/shard-export.ts
 var encoder = new TextEncoder();
 function jsonObject3(value) {
@@ -7356,6 +7826,7 @@ async function exportShard(db, options) {
               n.created_at, n.updated_at, n.deleted_at,
               o.content as original_content,
               c.content as revised_content,
+              c.ai_metadata,
               $1::text as collection_id
        FROM note n
        LEFT JOIN note_original o ON o.note_id = n.id
@@ -7369,6 +7840,7 @@ async function exportShard(db, options) {
               n.created_at, n.updated_at, n.deleted_at,
               o.content as original_content,
               c.content as revised_content,
+              c.ai_metadata,
               (
                 SELECT cn.collection_id
                 FROM collection_note cn
@@ -7388,6 +7860,7 @@ async function exportShard(db, options) {
               n.created_at, n.updated_at, n.deleted_at,
               o.content as original_content,
               c.content as revised_content,
+              c.ai_metadata,
               (
                 SELECT cn.collection_id
                 FROM collection_note cn
@@ -7784,6 +8257,32 @@ function parseJsonArrayBytes(data) {
 // src/shard/shard-import.ts
 var decoder2 = new TextDecoder();
 var DEFAULT_BATCH_SIZE = 250;
+async function enforceSignaturePolicy(files, options, warnings) {
+  const policy = options?.verifySignature ?? (options?.trustStore ? "require" : void 0);
+  if (!policy) return null;
+  if (policy === "trusted-local-only") {
+    warnings.push(
+      "Signature verification skipped (trusted-local-only): the shard was imported without authenticating its publisher."
+    );
+    return null;
+  }
+  if (!options?.trustStore) {
+    return `verifySignature: '${policy}' requires a trustStore to resolve signer keys.`;
+  }
+  const verdict = await verifyShardSignature({ files, trustStore: options.trustStore });
+  if (verdict.ok) return null;
+  if (verdict.reason === "unsigned") {
+    if (policy === "prefer") {
+      warnings.push(
+        "Shard is unsigned; imported under verifySignature: prefer. Publisher provenance was NOT authenticated."
+      );
+      return null;
+    }
+    return "Shard is unsigned and verifySignature is required.";
+  }
+  const detail = "detail" in verdict ? `: ${verdict.detail}` : "keyId" in verdict ? ` (key ${verdict.keyId})` : "";
+  return `Shard signature verification failed [${verdict.reason}]${detail}. No records or bytes were written.`;
+}
 async function yieldToEventLoop2() {
   const scheduler = globalThis.scheduler;
   if (scheduler?.yield) {
@@ -7884,6 +8383,17 @@ async function importShard(db, data, options) {
       duration_ms: performance.now() - start
     };
   }
+  const sigError = await enforceSignaturePolicy(files, options, warnings);
+  if (sigError) {
+    return {
+      success: false,
+      counts,
+      skipped,
+      warnings,
+      errors: [sigError],
+      duration_ms: performance.now() - start
+    };
+  }
   report?.({ phase: "validate", done: 0, total: 1 });
   if (!manifest.checksums || typeof manifest.checksums !== "object") {
     return {
@@ -8102,10 +8612,14 @@ async function importShard(db, data, options) {
             );
           }
           await tx.query(
-            `INSERT INTO note_revised_current (note_id, content)
-             VALUES ($1, $2)
-             ON CONFLICT (note_id) DO UPDATE SET content = $2`,
-            [note.id, note.revised_content ?? note.original_content]
+            `INSERT INTO note_revised_current (note_id, content, ai_metadata)
+             VALUES ($1, $2, $3::jsonb)
+             ON CONFLICT (note_id) DO UPDATE SET content = $2, ai_metadata = $3::jsonb`,
+            [
+              note.id,
+              note.revised_content ?? note.original_content,
+              note.ai_metadata == null ? null : JSON.stringify(note.ai_metadata)
+            ]
           );
         } else {
           await tx.query(
@@ -8129,9 +8643,13 @@ async function importShard(db, data, options) {
             [generateId(), note.id, note.original_content, contentHash]
           );
           await tx.query(
-            `INSERT INTO note_revised_current (note_id, content)
-             VALUES ($1, $2) ${conflictClause}`,
-            [note.id, note.revised_content ?? note.original_content]
+            `INSERT INTO note_revised_current (note_id, content, ai_metadata)
+             VALUES ($1, $2, $3::jsonb) ${conflictClause}`,
+            [
+              note.id,
+              note.revised_content ?? note.original_content,
+              note.ai_metadata == null ? null : JSON.stringify(note.ai_metadata)
+            ]
           );
         }
         for (const tag of note.tags) {
@@ -8636,8 +9154,8 @@ async function importShard(db, data, options) {
   }
   if (options?.blobStore && blobsToHydrate.size > 0) {
     try {
-      for (const [hash, bytes] of blobsToHydrate) {
-        await options.blobStore.write(hash, bytes);
+      for (const [, bytes] of blobsToHydrate) {
+        await options.blobStore.put(bytes);
       }
     } catch (err) {
       warnings.push(
@@ -8655,13 +9173,14 @@ async function importShard(db, data, options) {
   };
 }
 async function resolveEmbeddingSetIdForServerEmbedding(db, model, vector) {
+  const modelName = model ?? "unknown";
   const dimension = vectorDimension(vector);
   const existing = await db.query(
     `SELECT id FROM embedding_set
      WHERE model_name = $1 AND dimensions = $2
      ORDER BY created_at, id
      LIMIT 1`,
-    [model, dimension]
+    [modelName, dimension]
   );
   if (existing.rows[0]?.id) return existing.rows[0].id;
   const id = generateId();
@@ -8670,7 +9189,7 @@ async function resolveEmbeddingSetIdForServerEmbedding(db, model, vector) {
        id, name, slug, description, purpose, document_count, embedding_count,
        is_system, keywords_json, model_name, dimensions, kind, created_at, updated_at
      ) VALUES ($1, $2, $3, NULL, NULL, 0, 0, false, '[]'::jsonb, $2, $4, 'physical', now(), now())`,
-    [id, model, slugifyServerEmbeddingSet(model), dimension]
+    [id, modelName, slugifyServerEmbeddingSet(modelName), dimension]
   );
   return id;
 }
@@ -8889,7 +9408,7 @@ var knowledge_shard_schema_default = {
     link: {
       type: "object",
       additionalProperties: false,
-      required: ["id", "from_note_id", "to_note_id", "to_url", "kind", "score", "created_at", "metadata"],
+      required: ["id", "from_note_id", "to_note_id", "kind", "score", "created_at"],
       properties: {
         id: { type: "string", minLength: 1 },
         from_note_id: { type: "string", minLength: 1 },
@@ -8904,7 +9423,7 @@ var knowledge_shard_schema_default = {
     embeddingSet: {
       type: "object",
       additionalProperties: false,
-      required: ["id", "name", "slug", "description", "purpose", "document_count", "embedding_count", "is_system", "keywords", "model", "dimension"],
+      required: ["id", "model", "dimension"],
       properties: {
         id: { type: "string", minLength: 1 },
         name: { type: "string" },
@@ -8932,10 +9451,11 @@ var knowledge_shard_schema_default = {
     embeddingSetMember: {
       type: "object",
       additionalProperties: false,
-      required: ["embedding_set_id", "note_id", "membership_type", "added_at", "added_by"],
+      required: ["embedding_set_id", "note_id"],
       properties: {
         embedding_set_id: { type: "string", minLength: 1 },
         note_id: { type: "string", minLength: 1 },
+        embedding_id: { type: "string", minLength: 1 },
         membership_type: { type: "string" },
         added_at: { $ref: "#/$defs/isoDateTime" },
         added_by: { type: ["string", "null"] }
@@ -8959,7 +9479,7 @@ var knowledge_shard_schema_default = {
     embedding: {
       type: "object",
       additionalProperties: false,
-      required: ["id", "note_id", "chunk_index", "text", "vector", "model"],
+      required: ["id", "note_id", "vector"],
       properties: {
         id: { type: "string", minLength: 1 },
         note_id: { type: "string", minLength: 1 },
@@ -9843,8 +10363,6 @@ function clearPrefetchedShard(url) {
   }
   warmStore.delete(url);
 }
-
-// src/aiwg-index.ts
 var AIWG_SCAN_REQUIRED_FIELDS = [
   "schema_version",
   "id",
@@ -11659,28 +12177,281 @@ function communityIdsFor(item, options) {
   if (item.concepts.length > 0) return item.concepts.map((concept) => `concept:${concept}`);
   return [`type:${item.type}`];
 }
-
-// schemas/aiwg-fortemi-index-export.schema.json
-var aiwg_fortemi_index_export_schema_default = {
-  $schema: "https://json-schema.org/draft/2020-12/schema",
-  $id: "https://aiwg.io/schemas/aiwg-fortemi-index-export.json",
-  title: "AIWG Fortemi Index Export",
-  type: "object",
-  additionalProperties: false,
-  required: ["schema_version", "generated_at", "source", "items"],
-  properties: {
-    schema_version: {
-      enum: ["aiwg.fortemi.index.export.v1", "aiwg.fortemi.index.export.v2"]
-    },
-    generated_at: {
-      type: "string",
-      format: "date-time"
-    },
-    source: {
-      type: "object",
-      additionalProperties: false,
-      required: ["repo", "privacy"],
-      properties: {
+var AIWG_SHARD_UUID_NAMESPACE = "7ab5d1f8-29d2-5e35-9e2f-3a45de171a9e";
+var shardEncoder = new TextEncoder();
+var shardDecoder = new TextDecoder();
+function aiwgShardUuid(kind, id) {
+  return v5(`${kind}:${id}`, AIWG_SHARD_UUID_NAMESPACE);
+}
+function aiwgShardTimestamp(value, fallback) {
+  if (!value || Number.isNaN(Date.parse(value))) return fallback;
+  return new Date(value).toISOString();
+}
+function aiwgRecordTitle(record) {
+  return record.title ?? record.search?.title ?? record.search?.name ?? record.id;
+}
+function aiwgRecordContent(record) {
+  if (record.text) return record.text;
+  if (record.search?.body) return record.search.body;
+  const chunks = record.chunks?.map((chunk) => chunk.text ?? chunk.body ?? chunk.summary ?? "").filter(Boolean);
+  if (chunks?.length) return chunks.join("\n\n");
+  return record.search?.summary ?? "";
+}
+function aiwgShardMetadata(index, record) {
+  return {
+    aiwg_fortemi_index: {
+      envelope: {
+        schema_version: index.schema_version,
+        generated_at: index.generated_at,
+        source: index.source,
+        ...index.compatibility ? { compatibility: index.compatibility } : {}
+      },
+      record
+    }
+  };
+}
+function encodeJsonLines(values) {
+  return shardEncoder.encode(values.map((value) => JSON.stringify(value)).join("\n"));
+}
+async function aiwgFortemiIndexToKnowledgeShard(index, options = {}) {
+  const validation = validateAiwgFortemiIndexExport(index);
+  if (!validation.valid) {
+    throw new Error(`Invalid AIWG Fortemi index export:
+${validation.errors.join("\n")}`);
+  }
+  if (index.schema_version !== "aiwg.fortemi.index.export.v2") {
+    throw new Error("Knowledge Shard conversion requires aiwg.fortemi.index.export.v2");
+  }
+  const createdAt = aiwgShardTimestamp(options.createdAt ?? index.generated_at, (/* @__PURE__ */ new Date()).toISOString());
+  const noteIds = new Map(index.items.map((record) => [record.id, aiwgShardUuid("record", record.id)]));
+  const notes = index.items.map((record) => ({
+    id: noteIds.get(record.id),
+    title: aiwgRecordTitle(record),
+    original_content: aiwgRecordContent(record),
+    revised_content: null,
+    metadata: aiwgShardMetadata(index, record),
+    format: "markdown",
+    source: "aiwg-index",
+    starred: false,
+    archived: false,
+    tags: [...new Set(record.tags)].sort(),
+    created_at: aiwgShardTimestamp(record.source.updated_at ?? record.updated_at, createdAt),
+    updated_at: aiwgShardTimestamp(record.updated_at, createdAt),
+    deleted_at: null
+  }));
+  const links = [];
+  for (const record of index.items) {
+    for (const [position, relationship] of record.relationships.entries()) {
+      const targetNoteId = noteIds.get(relationship.target_id) ?? null;
+      links.push({
+        id: aiwgShardUuid(
+          "relationship",
+          `${record.id}\0${position}\0${relationship.type}\0${relationship.target_id}`
+        ),
+        from_note_id: noteIds.get(record.id),
+        to_note_id: targetNoteId,
+        to_url: targetNoteId ? null : `aiwg://record/${encodeURIComponent(relationship.target_id)}`,
+        kind: relationship.type,
+        score: relationship.confidence ?? null,
+        created_at: aiwgShardTimestamp(record.updated_at, createdAt),
+        metadata: {
+          aiwg_fortemi_index: {
+            source_record_id: record.id,
+            target_record_id: relationship.target_id,
+            relationship
+          }
+        }
+      });
+    }
+  }
+  const defaultScheme = index.source.graph ?? index.source.repo;
+  const concepts = /* @__PURE__ */ new Map();
+  for (const record of index.items) {
+    for (const conceptId of record.concepts) {
+      concepts.set(conceptId, {
+        concept: { id: conceptId, prefLabel: conceptId },
+        scheme: defaultScheme
+      });
+    }
+    for (const concept of record.skos_concepts ?? []) {
+      concepts.set(concept.id, { concept, scheme: concept.scheme ?? defaultScheme });
+    }
+    for (const relation of record.skos_relations ?? []) {
+      if (!concepts.has(relation.source_id)) {
+        concepts.set(relation.source_id, {
+          concept: { id: relation.source_id, prefLabel: relation.source_id },
+          scheme: defaultScheme
+        });
+      }
+      if (!concepts.has(relation.target_id)) {
+        concepts.set(relation.target_id, {
+          concept: { id: relation.target_id, prefLabel: relation.target_id },
+          scheme: defaultScheme
+        });
+      }
+    }
+  }
+  const schemeNames = [...new Set([...concepts.values()].map(({ scheme }) => scheme))].sort();
+  const schemes = schemeNames.map((scheme) => ({
+    id: aiwgShardUuid("skos-scheme", scheme),
+    title: scheme,
+    description: `SKOS scheme projected from ${index.source.repo}`,
+    created_at: createdAt,
+    updated_at: createdAt
+  }));
+  const shardConcepts = [...concepts.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([id, { concept, scheme }]) => ({
+    id: aiwgShardUuid("skos-concept", id),
+    scheme_id: aiwgShardUuid("skos-scheme", scheme),
+    pref_label: concept.prefLabel,
+    alt_labels: concept.altLabels ?? [],
+    definition: concept.definition ?? null,
+    created_at: createdAt,
+    updated_at: createdAt
+  }));
+  const noteSkosTags = [];
+  const skosRelations = [];
+  const provenanceEdges = [];
+  for (const record of index.items) {
+    const recordConceptIds = /* @__PURE__ */ new Set([
+      ...record.concepts,
+      ...(record.skos_concepts ?? []).map((concept) => concept.id)
+    ]);
+    for (const conceptId of [...recordConceptIds].sort()) {
+      noteSkosTags.push({
+        id: aiwgShardUuid("note-skos-tag", `${record.id}\0${conceptId}`),
+        note_id: noteIds.get(record.id),
+        concept_id: aiwgShardUuid("skos-concept", conceptId),
+        created_at: createdAt
+      });
+    }
+    for (const [position, relation] of (record.skos_relations ?? []).entries()) {
+      const relationType = relation.type === "broader" || relation.type === "narrower" ? relation.type : "related";
+      skosRelations.push({
+        id: aiwgShardUuid(
+          "skos-relation",
+          `${record.id}\0${position}\0${relation.source_id}\0${relation.type}\0${relation.target_id}`
+        ),
+        source_concept_id: aiwgShardUuid("skos-concept", relation.source_id),
+        target_concept_id: aiwgShardUuid("skos-concept", relation.target_id),
+        relation_type: relationType,
+        created_at: createdAt
+      });
+    }
+    for (const [position, provenance] of record.provenance.entries()) {
+      provenanceEdges.push({
+        id: aiwgShardUuid("provenance", `${record.id}\0field\0${position}`),
+        entity_type: "note",
+        entity_id: noteIds.get(record.id),
+        activity: "source",
+        agent: provenance.source,
+        started_at: aiwgShardTimestamp(record.updated_at, createdAt),
+        ended_at: null,
+        attributes: { aiwg_fortemi_index: { provenance } }
+      });
+    }
+    for (const [position, event] of (record.provenance_events ?? []).entries()) {
+      provenanceEdges.push({
+        id: aiwgShardUuid("provenance", event.id ?? `${record.id}\0event\0${position}`),
+        entity_type: "note",
+        entity_id: noteIds.get(record.id),
+        activity: event.activity,
+        agent: event.agent ?? "aiwg-index",
+        started_at: aiwgShardTimestamp(event.started_at, createdAt),
+        ended_at: event.ended_at ? aiwgShardTimestamp(event.ended_at, createdAt) : null,
+        attributes: { aiwg_fortemi_index: { event } }
+      });
+    }
+  }
+  const files = /* @__PURE__ */ new Map();
+  const components = ["notes", "tags"];
+  const counts = {
+    notes: notes.length,
+    tags: [...new Set(notes.flatMap((note) => note.tags))].length
+  };
+  files.set("notes.jsonl", encodeJsonLines(notes));
+  files.set("tags.json", shardEncoder.encode(JSON.stringify(
+    [...new Set(notes.flatMap((note) => note.tags))].sort().map((name) => ({ name, created_at: createdAt }))
+  )));
+  const addComponent = (component, filename, values, jsonLines = true) => {
+    if (values.length === 0) return;
+    components.push(component);
+    counts[component] = values.length;
+    files.set(filename, jsonLines ? encodeJsonLines(values) : shardEncoder.encode(JSON.stringify(values)));
+  };
+  addComponent("links", "links.jsonl", links);
+  if (options.includeNativeRichComponents) {
+    addComponent("skos_schemes", "skos_schemes.json", schemes, false);
+    addComponent("skos_concepts", "skos_concepts.json", shardConcepts, false);
+    addComponent("skos_relations", "skos_relations.jsonl", skosRelations);
+    addComponent("note_skos_tags", "note_skos_tags.jsonl", noteSkosTags);
+    addComponent("provenance_edges", "provenance_edges.jsonl", provenanceEdges);
+  }
+  const checksums = {};
+  for (const [filename, bytes] of files) checksums[filename] = await sha256Hex(bytes);
+  const manifest = {
+    version: CURRENT_SHARD_VERSION,
+    matric_version: options.matricVersion ?? "fortemi-core-aiwg-index",
+    format: SHARD_FORMAT,
+    created_at: createdAt,
+    components,
+    counts,
+    checksums,
+    min_reader_version: CURRENT_SHARD_VERSION,
+    migrated_from: null,
+    migration_history: []
+  };
+  files.set("manifest.json", shardEncoder.encode(JSON.stringify(manifest, null, 2)));
+  return packTarGz(files);
+}
+function aiwgFortemiIndexFromKnowledgeShard(bytes) {
+  const files = unpackTarGz(bytes);
+  const noteBytes = files.get("notes.jsonl");
+  const notes = (noteBytes ? shardDecoder.decode(noteBytes) : "").split("\n").filter(Boolean).map((line) => JSON.parse(line));
+  if (notes.length === 0) throw new Error("Knowledge Shard contains no AIWG index notes");
+  let envelope;
+  const items = [];
+  for (const note of notes) {
+    const metadata = note.metadata?.aiwg_fortemi_index;
+    if (!metadata || typeof metadata !== "object" || Array.isArray(metadata)) {
+      throw new Error(`Knowledge Shard note ${note.id} has no AIWG index metadata`);
+    }
+    const value = metadata;
+    envelope ??= value.envelope;
+    items.push(value.record);
+  }
+  const restored = {
+    ...envelope,
+    items: items.sort((left, right) => left.id.localeCompare(right.id))
+  };
+  const validation = validateAiwgFortemiIndexExport(restored);
+  if (!validation.valid) {
+    throw new Error(`Knowledge Shard contains invalid AIWG index metadata:
+${validation.errors.join("\n")}`);
+  }
+  return restored;
+}
+
+// schemas/aiwg-fortemi-index-export.schema.json
+var aiwg_fortemi_index_export_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://aiwg.io/schemas/aiwg-fortemi-index-export.json",
+  title: "AIWG Fortemi Index Export",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "generated_at", "source", "items"],
+  properties: {
+    schema_version: {
+      enum: ["aiwg.fortemi.index.export.v1", "aiwg.fortemi.index.export.v2"]
+    },
+    generated_at: {
+      type: "string",
+      format: "date-time"
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["repo", "privacy"],
+      properties: {
         repo: {
           type: "string",
           minLength: 1
@@ -12377,9 +13148,1369 @@ function validateAiwgFortemiProjectedRecordSchema(value) {
   return { valid, errors: formatErrors2(validate.errors) };
 }
 
+// src/records/types.ts
+var RECORD_COLLECTIONS = [
+  "note",
+  "note_original",
+  "note_revised_current",
+  "note_tag",
+  "link",
+  "collection",
+  "collection_note",
+  "attachment",
+  "attachment_blob"
+];
+var RECORD_STORE_CAPABILITIES = {
+  crud: true,
+  journal: true,
+  boundedTextScan: true,
+  fullTextSearch: false,
+  vectorSearch: false,
+  sqlJoins: false
+};
+
+// src/records/memory-record-store.ts
+var MemoryRecordStore = class {
+  capabilities = RECORD_STORE_CAPABILITIES;
+  collections = /* @__PURE__ */ new Map();
+  journal = [];
+  seq = 0;
+  table(collection) {
+    let table = this.collections.get(collection);
+    if (!table) {
+      table = /* @__PURE__ */ new Map();
+      this.collections.set(collection, table);
+    }
+    return table;
+  }
+  async get(collection, id) {
+    return this.table(collection).get(id) ?? null;
+  }
+  async put(collection, record) {
+    const entry = {
+      seq: ++this.seq,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      op: "put",
+      collection,
+      id: record.id,
+      record: structuredClone(record)
+    };
+    this.table(collection).set(record.id, structuredClone(record));
+    this.journal.push(entry);
+    return entry;
+  }
+  async remove(collection, id) {
+    const entry = {
+      seq: ++this.seq,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      op: "delete",
+      collection,
+      id
+    };
+    this.table(collection).delete(id);
+    this.journal.push(entry);
+    return entry;
+  }
+  async list(collection, opts) {
+    const all = [...this.table(collection).values()];
+    return opts?.limit !== void 0 ? all.slice(0, opts.limit) : all;
+  }
+  async journalSince(sinceSeq, limit) {
+    const entries = this.journal.filter((e) => e.seq > sinceSeq);
+    return limit !== void 0 ? entries.slice(0, limit) : entries;
+  }
+  async headSeq() {
+    return this.seq;
+  }
+  async close() {
+  }
+};
+
+// src/records/idb-record-store.ts
+var DB_VERSION = 1;
+var JOURNAL_STORE = "journal";
+var META_STORE = "meta";
+var RECORD_SCHEMA_VERSION = 1;
+function requestToPromise(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+}
+function transactionComplete(tx) {
+  return new Promise((resolve, reject) => {
+    tx.oncomplete = () => resolve();
+    tx.onabort = () => reject(tx.error);
+    tx.onerror = () => reject(tx.error);
+  });
+}
+var IdbRecordStore = class _IdbRecordStore {
+  constructor(db) {
+    this.db = db;
+  }
+  capabilities = RECORD_STORE_CAPABILITIES;
+  static async open(archiveName, options) {
+    const factory = options?.indexedDB ?? globalThis.indexedDB;
+    if (!factory) {
+      throw new Error("IdbRecordStore requires IndexedDB (none available in this environment)");
+    }
+    const db = await new Promise((resolve, reject) => {
+      const request = factory.open(`fortemi-${archiveName}-records`, DB_VERSION);
+      request.onupgradeneeded = () => {
+        const database = request.result;
+        for (const collection of RECORD_COLLECTIONS) {
+          if (!database.objectStoreNames.contains(collection)) {
+            database.createObjectStore(collection, { keyPath: "id" });
+          }
+        }
+        if (!database.objectStoreNames.contains(JOURNAL_STORE)) {
+          database.createObjectStore(JOURNAL_STORE, { keyPath: "seq", autoIncrement: true });
+        }
+        if (!database.objectStoreNames.contains(META_STORE)) {
+          database.createObjectStore(META_STORE);
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+    const store = new _IdbRecordStore(db);
+    await store.ensureSchemaVersion();
+    return store;
+  }
+  async ensureSchemaVersion() {
+    const tx = this.db.transaction(META_STORE, "readwrite");
+    const meta = tx.objectStore(META_STORE);
+    const current = await requestToPromise(meta.get("schemaVersion"));
+    if (current === void 0) {
+      meta.put(RECORD_SCHEMA_VERSION, "schemaVersion");
+    } else if (current > RECORD_SCHEMA_VERSION) {
+      throw new Error(
+        `IdbRecordStore: records were written by a newer schema (v${current} > v${RECORD_SCHEMA_VERSION}); refusing to open`
+      );
+    }
+    await transactionComplete(tx);
+  }
+  async get(collection, id) {
+    const tx = this.db.transaction(collection, "readonly");
+    const result = await requestToPromise(
+      tx.objectStore(collection).get(id)
+    );
+    return result ?? null;
+  }
+  async put(collection, record) {
+    const tx = this.db.transaction([collection, JOURNAL_STORE], "readwrite");
+    tx.objectStore(collection).put(record);
+    const pending = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      op: "put",
+      collection,
+      id: record.id,
+      record
+    };
+    const seqReq = tx.objectStore(JOURNAL_STORE).add(pending);
+    await transactionComplete(tx);
+    return { ...pending, seq: seqReq.result };
+  }
+  async remove(collection, id) {
+    const tx = this.db.transaction([collection, JOURNAL_STORE], "readwrite");
+    tx.objectStore(collection).delete(id);
+    const pending = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      op: "delete",
+      collection,
+      id
+    };
+    const seqReq = tx.objectStore(JOURNAL_STORE).add(pending);
+    await transactionComplete(tx);
+    return { ...pending, seq: seqReq.result };
+  }
+  async list(collection, opts) {
+    const tx = this.db.transaction(collection, "readonly");
+    const store = tx.objectStore(collection);
+    const all = await requestToPromise(
+      opts?.limit !== void 0 ? store.getAll(void 0, opts.limit) : store.getAll()
+    );
+    return all;
+  }
+  async journalSince(sinceSeq, limit) {
+    const tx = this.db.transaction(JOURNAL_STORE, "readonly");
+    const range = IDBKeyRange.lowerBound(sinceSeq, true);
+    const entries = await requestToPromise(
+      limit !== void 0 ? tx.objectStore(JOURNAL_STORE).getAll(range, limit) : tx.objectStore(JOURNAL_STORE).getAll(range)
+    );
+    return entries;
+  }
+  async headSeq() {
+    const tx = this.db.transaction(JOURNAL_STORE, "readonly");
+    const cursor = await requestToPromise(
+      tx.objectStore(JOURNAL_STORE).openCursor(null, "prev")
+    );
+    return cursor ? cursor.value.seq : 0;
+  }
+  async close() {
+    this.db.close();
+  }
+};
+function createRecordStore(archiveName, options) {
+  return IdbRecordStore.open(archiveName, options);
+}
+
+// src/records/canonical-notes-repository.ts
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var CanonicalNotesRepository = class {
+  constructor(store) {
+    this.store = store;
+  }
+  // ── Notes ─────────────────────────────────────────────────────────────────
+  async create(input) {
+    const noteId = input.id ?? generateId();
+    const ts = nowIso();
+    await this.store.put("note", {
+      id: noteId,
+      archive_id: null,
+      title: input.title ?? null,
+      format: input.format ?? "markdown",
+      source: input.source ?? "user",
+      visibility: input.visibility ?? "private",
+      revision_mode: "standard",
+      is_starred: false,
+      is_pinned: false,
+      is_archived: false,
+      created_at: ts,
+      updated_at: ts,
+      deleted_at: null
+    });
+    await this.store.put("note_original", {
+      id: generateId(),
+      note_id: noteId,
+      content: input.content,
+      content_hash: computeHash(new TextEncoder().encode(input.content)),
+      created_at: ts
+    });
+    await this.store.put("note_revised_current", {
+      id: noteId,
+      content: input.content,
+      ai_metadata: null,
+      generation_count: 0,
+      model: null,
+      is_user_edited: false,
+      updated_at: ts
+    });
+    return await this.get(noteId);
+  }
+  async get(noteId) {
+    const note = await this.store.get("note", noteId);
+    if (!note) return null;
+    const revised = await this.store.get("note_revised_current", noteId);
+    const originals = (await this.store.list("note_original")).filter(
+      (o) => o.note_id === noteId
+    );
+    const tags = (await this.store.list("note_tag")).filter((t) => t.note_id === noteId).map((t) => t.tag).sort();
+    return {
+      note,
+      original_content: originals[0]?.content ?? "",
+      revised_content: revised?.content ?? originals[0]?.content ?? "",
+      tags
+    };
+  }
+  async update(noteId, input) {
+    const note = await this.store.get("note", noteId);
+    if (!note) throw new Error(`Note not found: ${noteId}`);
+    const ts = nowIso();
+    await this.store.put("note", {
+      ...note,
+      title: input.title !== void 0 ? input.title : note.title,
+      format: input.format ?? note.format,
+      visibility: input.visibility ?? note.visibility,
+      is_starred: input.is_starred ?? note.is_starred,
+      is_pinned: input.is_pinned ?? note.is_pinned,
+      is_archived: input.is_archived ?? note.is_archived,
+      updated_at: ts
+    });
+    if (input.content !== void 0) {
+      const revised = await this.store.get("note_revised_current", noteId);
+      await this.store.put("note_revised_current", {
+        id: noteId,
+        content: input.content,
+        ai_metadata: revised?.ai_metadata ?? null,
+        generation_count: revised?.generation_count ?? 0,
+        model: revised?.model ?? null,
+        is_user_edited: true,
+        updated_at: ts
+      });
+    }
+    return await this.get(noteId);
+  }
+  /** Soft-delete: sets `deleted_at`; the record (and history) remains. */
+  async softDelete(noteId) {
+    const note = await this.store.get("note", noteId);
+    if (!note) throw new Error(`Note not found: ${noteId}`);
+    await this.store.put("note", { ...note, deleted_at: nowIso(), updated_at: nowIso() });
+  }
+  async restore(noteId) {
+    const note = await this.store.get("note", noteId);
+    if (!note) throw new Error(`Note not found: ${noteId}`);
+    await this.store.put("note", { ...note, deleted_at: null, updated_at: nowIso() });
+  }
+  /** Non-deleted notes, most recently updated first. */
+  async listRecent(limit = 50) {
+    const notes = (await this.store.list("note")).filter((n) => n.deleted_at === null);
+    notes.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+    return notes.slice(0, limit);
+  }
+  /**
+   * Bounded substring scan over title + revised content (case-insensitive).
+   * This is deliberately not ranked FTS — see `store.capabilities`.
+   */
+  async searchText(query, limit = 20) {
+    const needle = query.toLowerCase();
+    const revised = new Map(
+      (await this.store.list("note_revised_current")).map((r) => [r.id, r.content])
+    );
+    const hits = [];
+    for (const note of await this.store.list("note")) {
+      if (note.deleted_at !== null) continue;
+      const haystack = `${note.title ?? ""}
+${revised.get(note.id) ?? ""}`.toLowerCase();
+      if (haystack.includes(needle)) {
+        hits.push(note);
+        if (hits.length >= limit) break;
+      }
+    }
+    return hits;
+  }
+  // ── Tags ──────────────────────────────────────────────────────────────────
+  async addTag(noteId, tag) {
+    const existing = (await this.store.list("note_tag")).find(
+      (t) => t.note_id === noteId && t.tag === tag
+    );
+    if (existing) return;
+    await this.store.put("note_tag", {
+      id: generateId(),
+      note_id: noteId,
+      tag,
+      created_at: nowIso()
+    });
+  }
+  async removeTag(noteId, tag) {
+    const existing = (await this.store.list("note_tag")).find(
+      (t) => t.note_id === noteId && t.tag === tag
+    );
+    if (existing) await this.store.remove("note_tag", existing.id);
+  }
+  async notesByTag(tag) {
+    const noteIds = new Set(
+      (await this.store.list("note_tag")).filter((t) => t.tag === tag).map((t) => t.note_id)
+    );
+    return (await this.store.list("note")).filter(
+      (n) => noteIds.has(n.id) && n.deleted_at === null
+    );
+  }
+  // ── Links ─────────────────────────────────────────────────────────────────
+  async createLink(sourceNoteId, targetNoteId, linkType = "related") {
+    const link = {
+      id: generateId(),
+      source_note_id: sourceNoteId,
+      target_note_id: targetNoteId,
+      link_type: linkType,
+      created_at: nowIso(),
+      deleted_at: null
+    };
+    await this.store.put("link", link);
+    return link;
+  }
+  async softDeleteLink(linkId) {
+    const link = await this.store.get("link", linkId);
+    if (!link) throw new Error(`Link not found: ${linkId}`);
+    await this.store.put("link", { ...link, deleted_at: nowIso() });
+  }
+  /** Active links touching a note (either direction). */
+  async linksOf(noteId) {
+    return (await this.store.list("link")).filter(
+      (l) => l.deleted_at === null && (l.source_note_id === noteId || l.target_note_id === noteId)
+    );
+  }
+  // ── Collections ───────────────────────────────────────────────────────────
+  async createCollection(name, description) {
+    const ts = nowIso();
+    const collection = {
+      id: generateId(),
+      name,
+      description: description ?? null,
+      created_at: ts,
+      updated_at: ts,
+      deleted_at: null
+    };
+    await this.store.put("collection", collection);
+    return collection;
+  }
+  async addNoteToCollection(collectionId, noteId) {
+    const existing = (await this.store.list("collection_note")).find(
+      (cn) => cn.collection_id === collectionId && cn.note_id === noteId
+    );
+    if (existing) return;
+    await this.store.put("collection_note", {
+      id: generateId(),
+      collection_id: collectionId,
+      note_id: noteId,
+      created_at: nowIso()
+    });
+  }
+  async notesInCollection(collectionId) {
+    const noteIds = new Set(
+      (await this.store.list("collection_note")).filter((cn) => cn.collection_id === collectionId).map((cn) => cn.note_id)
+    );
+    return (await this.store.list("note")).filter(
+      (n) => noteIds.has(n.id) && n.deleted_at === null
+    );
+  }
+};
+
+// src/records/canonical-attachments-repository.ts
+function nowIso2() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var CanonicalAttachmentsRepository = class {
+  constructor(store, blobStore) {
+    this.store = store;
+    this.blobStore = blobStore;
+  }
+  /** Bytes-first attach (ADR-013 D5); dedupes on the store-computed hash. */
+  async attach(input) {
+    const contentHash = await this.blobStore.put(input.data);
+    let blob = (await this.store.list("attachment_blob")).find(
+      (b) => b.content_hash === contentHash
+    );
+    if (!blob) {
+      blob = {
+        id: generateId(),
+        content_hash: contentHash,
+        size_bytes: input.data.length,
+        created_at: nowIso2()
+      };
+      await this.store.put("attachment_blob", blob);
+    }
+    const attachment = {
+      id: generateId(),
+      note_id: input.noteId,
+      blob_id: blob.id,
+      document_type_id: null,
+      mime_type: input.mimeType ?? null,
+      extracted_text: input.extractedText ?? null,
+      filename: input.filename,
+      display_name: input.displayName ?? null,
+      position: 0,
+      created_at: nowIso2(),
+      deleted_at: null
+    };
+    await this.store.put("attachment", attachment);
+    return attachment;
+  }
+  async get(id) {
+    const attachment = await this.store.get("attachment", id);
+    if (!attachment) throw new Error(`Attachment not found: ${id}`);
+    return attachment;
+  }
+  /** Null when bytes are absent — the recoverable reference-only state. */
+  async getBlob(attachmentId) {
+    const checksum = await this.checksumOf(attachmentId);
+    return checksum === null ? null : this.blobStore.read(checksum);
+  }
+  async hasBlob(attachmentId) {
+    const checksum = await this.checksumOf(attachmentId);
+    return checksum === null ? false : this.blobStore.has(checksum);
+  }
+  async list(noteId) {
+    const items = (await this.store.list("attachment")).filter(
+      (a) => a.note_id === noteId && a.deleted_at === null
+    );
+    items.sort(
+      (a, b) => a.position - b.position || a.created_at.localeCompare(b.created_at)
+    );
+    return items;
+  }
+  /** Soft-delete the manifest; bytes are only swept via reconcile/gc. */
+  async delete(id) {
+    const attachment = await this.get(id);
+    await this.store.put("attachment", { ...attachment, deleted_at: nowIso2() });
+  }
+  /** Authoritative live set: hashes referenced by non-deleted manifests. */
+  async liveBlobChecksums() {
+    const liveBlobIds = new Set(
+      (await this.store.list("attachment")).filter((a) => a.deleted_at === null).map((a) => a.blob_id)
+    );
+    return (await this.store.list("attachment_blob")).filter((b) => liveBlobIds.has(b.id)).map((b) => b.content_hash);
+  }
+  /** Startup / post-quota reconciliation against canonical manifests (ADR-013 D4). */
+  async reconcileBlobs(opts) {
+    return this.blobStore.reconcile(await this.liveBlobChecksums(), opts);
+  }
+  /** Deferred reachability-based blob GC. */
+  async gcBlobs(opts) {
+    await this.reconcileBlobs();
+    return this.blobStore.gc(opts);
+  }
+  async checksumOf(attachmentId) {
+    const attachment = await this.get(attachmentId);
+    const blob = await this.store.get("attachment_blob", attachment.blob_id);
+    return blob?.content_hash ?? null;
+  }
+};
+
+// src/records/attachment-projection.ts
+async function projectAttachments(db, store) {
+  const blobs = await store.list("attachment_blob");
+  const attachments = await store.list("attachment");
+  for (const blob of blobs) {
+    await db.query(
+      `INSERT INTO attachment_blob (id, content_hash, size_bytes, created_at)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (id) DO UPDATE SET
+         content_hash = EXCLUDED.content_hash,
+         size_bytes = EXCLUDED.size_bytes`,
+      [blob.id, blob.content_hash, blob.size_bytes, blob.created_at]
+    );
+  }
+  for (const att of attachments) {
+    await db.query(
+      `INSERT INTO attachment (
+         id, note_id, blob_id, document_type_id, mime_type, extracted_text,
+         filename, display_name, position, status, created_at, deleted_at
+       )
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
+       ON CONFLICT (id) DO UPDATE SET
+         mime_type = EXCLUDED.mime_type,
+         extracted_text = EXCLUDED.extracted_text,
+         filename = EXCLUDED.filename,
+         display_name = EXCLUDED.display_name,
+         position = EXCLUDED.position,
+         status = EXCLUDED.status,
+         deleted_at = EXCLUDED.deleted_at`,
+      [
+        att.id,
+        att.note_id,
+        att.blob_id,
+        att.document_type_id,
+        att.mime_type,
+        att.extracted_text,
+        att.filename,
+        att.display_name,
+        att.position,
+        // Browser attach-time extraction: text present == processing done.
+        att.extracted_text !== null && att.extracted_text !== "" ? "completed" : "uploaded",
+        att.created_at,
+        att.deleted_at
+      ]
+    );
+  }
+  await db.query(
+    `UPDATE attachment_blob ab
+     SET reference_count = (
+       SELECT COUNT(*) FROM attachment a
+       WHERE a.blob_id = ab.id AND a.deleted_at IS NULL
+     )`
+  );
+  return { blobs: blobs.length, attachments: attachments.length };
+}
+async function dropAttachmentProjection(db) {
+  await db.query(`DELETE FROM attachment_embedding`);
+  await db.query(`DELETE FROM attachment`);
+  await db.query(`DELETE FROM attachment_blob`);
+}
+
+// src/records/record-projection.ts
+async function projectNotes(db, store) {
+  const [noteRows, originals, revised, tags, links, collections, memberships] = await Promise.all([
+    store.list("note"),
+    store.list("note_original"),
+    store.list("note_revised_current"),
+    store.list("note_tag"),
+    store.list("link"),
+    store.list("collection"),
+    store.list("collection_note")
+  ]);
+  for (const c of collections) {
+    await db.query(
+      `INSERT INTO collection (id, name, description, created_at, updated_at, deleted_at)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (id) DO UPDATE SET
+         name = EXCLUDED.name,
+         description = EXCLUDED.description,
+         updated_at = EXCLUDED.updated_at,
+         deleted_at = EXCLUDED.deleted_at`,
+      [c.id, c.name, c.description, c.created_at, c.updated_at, c.deleted_at]
+    );
+  }
+  for (const n of noteRows) {
+    await db.query(
+      `INSERT INTO note (
+         id, archive_id, title, format, source, visibility, revision_mode,
+         is_starred, is_pinned, is_archived, created_at, updated_at, deleted_at
+       )
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+       ON CONFLICT (id) DO UPDATE SET
+         archive_id = EXCLUDED.archive_id,
+         title = EXCLUDED.title,
+         format = EXCLUDED.format,
+         source = EXCLUDED.source,
+         visibility = EXCLUDED.visibility,
+         revision_mode = EXCLUDED.revision_mode,
+         is_starred = EXCLUDED.is_starred,
+         is_pinned = EXCLUDED.is_pinned,
+         is_archived = EXCLUDED.is_archived,
+         updated_at = EXCLUDED.updated_at,
+         deleted_at = EXCLUDED.deleted_at`,
+      [
+        n.id,
+        n.archive_id,
+        n.title,
+        n.format,
+        n.source,
+        n.visibility,
+        n.revision_mode,
+        n.is_starred,
+        n.is_pinned,
+        n.is_archived,
+        n.created_at,
+        n.updated_at,
+        n.deleted_at
+      ]
+    );
+  }
+  for (const o of originals) {
+    await db.query(
+      `INSERT INTO note_original (id, note_id, content, content_hash, created_at)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (id) DO UPDATE SET
+         content = EXCLUDED.content,
+         content_hash = EXCLUDED.content_hash`,
+      [o.id, o.note_id, o.content, o.content_hash, o.created_at]
+    );
+  }
+  for (const r of revised) {
+    await db.query(
+      `INSERT INTO note_revised_current (
+         note_id, content, ai_metadata, generation_count, model, is_user_edited, updated_at
+       )
+       VALUES ($1, $2, $3::jsonb, $4, $5, $6, $7)
+       ON CONFLICT (note_id) DO UPDATE SET
+         content = EXCLUDED.content,
+         ai_metadata = EXCLUDED.ai_metadata,
+         generation_count = EXCLUDED.generation_count,
+         model = EXCLUDED.model,
+         is_user_edited = EXCLUDED.is_user_edited,
+         updated_at = EXCLUDED.updated_at`,
+      [
+        r.id,
+        r.content,
+        r.ai_metadata == null ? null : JSON.stringify(r.ai_metadata),
+        r.generation_count,
+        r.model,
+        r.is_user_edited,
+        r.updated_at
+      ]
+    );
+  }
+  for (const t of tags) {
+    await db.query(
+      `INSERT INTO note_tag (id, note_id, tag, created_at)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (note_id, tag) DO NOTHING`,
+      [t.id, t.note_id, t.tag, t.created_at]
+    );
+  }
+  await db.query(
+    `DELETE FROM note_tag WHERE NOT (id = ANY($1::text[]))`,
+    [tags.map((t) => t.id)]
+  );
+  for (const l of links) {
+    await db.query(
+      `INSERT INTO link (id, source_note_id, target_note_id, link_type, created_at, deleted_at)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (id) DO UPDATE SET
+         link_type = EXCLUDED.link_type,
+         deleted_at = EXCLUDED.deleted_at`,
+      [l.id, l.source_note_id, l.target_note_id, l.link_type, l.created_at, l.deleted_at]
+    );
+  }
+  for (const m of memberships) {
+    await db.query(
+      `INSERT INTO collection_note (collection_id, note_id, position, added_at)
+       VALUES ($1, $2, 0, $3)
+       ON CONFLICT (collection_id, note_id) DO NOTHING`,
+      [m.collection_id, m.note_id, m.created_at]
+    );
+  }
+  await db.query(
+    `DELETE FROM collection_note WHERE NOT ((collection_id || ':' || note_id) = ANY($1::text[]))`,
+    [memberships.map((m) => `${m.collection_id}:${m.note_id}`)]
+  );
+  return {
+    notes: noteRows.length,
+    tags: tags.length,
+    links: links.length,
+    collections: collections.length,
+    memberships: memberships.length
+  };
+}
+async function projectRecords(db, store) {
+  const notes = await projectNotes(db, store);
+  const attachments = await projectAttachments(db, store);
+  return { ...notes, attachments };
+}
+async function dropNoteProjection(db) {
+  await db.query(`DELETE FROM collection_note`);
+  await db.query(`DELETE FROM note_tag`);
+  await db.query(`DELETE FROM link`);
+  await db.query(`DELETE FROM note_revised_current`);
+  await db.query(`DELETE FROM note_revision`);
+  await db.query(`DELETE FROM note_original`);
+  await db.query(`DELETE FROM job_queue`);
+  await db.query(`DELETE FROM note`);
+  await db.query(`DELETE FROM collection`);
+}
+
+// src/records/record-backend.ts
+function noteToBackend(n, tags) {
+  return {
+    id: n.id,
+    title: n.title,
+    tags,
+    createdAt: n.created_at,
+    updatedAt: n.updated_at,
+    source: n.source,
+    starred: n.is_starred,
+    archived: n.is_archived
+  };
+}
+function linkToBackend2(link) {
+  return {
+    id: link.id,
+    fromNoteId: link.source_note_id,
+    toNoteId: link.target_note_id,
+    kind: link.link_type,
+    score: null,
+    createdAt: link.created_at
+  };
+}
+function createRecordBackend(store, options = {}) {
+  const notes = new CanonicalNotesRepository(store);
+  async function tagsByNote() {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of await store.list("note_tag")) {
+      const tags = map.get(row.note_id) ?? [];
+      tags.push(row.tag);
+      map.set(row.note_id, tags);
+    }
+    for (const tags of map.values()) tags.sort();
+    return map;
+  }
+  return {
+    id: options.id ?? "canonical-records",
+    capabilities: {
+      read: true,
+      write: true,
+      merge: true,
+      // via importShardToRecords (record-shard.ts)
+      multiUser: false,
+      semantic: "none",
+      startupCost: "instant"
+    },
+    async listNotes(o) {
+      const all = (await store.list("note")).filter((n) => n.deleted_at === null);
+      all.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+      const offset = o?.offset ?? 0;
+      const limit = o?.limit ?? 50;
+      const tags = await tagsByNote();
+      return {
+        items: all.slice(offset, offset + limit).map((n) => noteToBackend(n, tags.get(n.id) ?? [])),
+        total: all.length
+      };
+    },
+    async getNote(id) {
+      const view = await notes.get(id);
+      if (!view || view.note.deleted_at !== null) return null;
+      return noteToBackend(view.note, view.tags);
+    },
+    async search(query, o) {
+      const offset = o?.offset ?? 0;
+      const limit = o?.limit ?? 20;
+      let matched = await notes.searchText(query, offset + limit);
+      if (o?.tags?.length) {
+        const tags2 = await tagsByNote();
+        matched = matched.filter((n) => o.tags.every((t) => (tags2.get(n.id) ?? []).includes(t)));
+      }
+      if (o?.source?.length) {
+        matched = matched.filter((n) => o.source.includes(n.source));
+      }
+      const tags = await tagsByNote();
+      const hits = matched.slice(offset, offset + limit).map((n) => ({ note: noteToBackend(n, tags.get(n.id) ?? []) }));
+      return { hits, total: matched.length };
+    },
+    async getNoteFull(id) {
+      const view = await notes.get(id);
+      if (!view || view.note.deleted_at !== null) return null;
+      return {
+        ...noteToBackend(view.note, view.tags),
+        content: view.revised_content,
+        links: (await notes.linksOf(id)).map(linkToBackend2)
+      };
+    },
+    async linksOf(id) {
+      return (await notes.linksOf(id)).map(linkToBackend2);
+    },
+    async manageNote(input) {
+      const parsed = ManageNoteInputSchema.parse(input);
+      switch (parsed.action) {
+        case "update": {
+          const note = await notes.update(parsed.note_id, {
+            title: parsed.title,
+            content: parsed.content,
+            format: parsed.format,
+            visibility: parsed.visibility
+          });
+          return { action: "update", note_id: parsed.note_id, note };
+        }
+        case "delete":
+          await notes.softDelete(parsed.note_id);
+          return { action: "delete", note_id: parsed.note_id };
+        case "restore": {
+          await notes.restore(parsed.note_id);
+          return { action: "restore", note_id: parsed.note_id, note: await notes.get(parsed.note_id) };
+        }
+        case "archive": {
+          const note = await notes.update(parsed.note_id, { is_archived: true });
+          return { action: "archive", note_id: parsed.note_id, note };
+        }
+        case "unarchive": {
+          const note = await notes.update(parsed.note_id, { is_archived: false });
+          return { action: "unarchive", note_id: parsed.note_id, note };
+        }
+        case "star": {
+          const note = await notes.update(parsed.note_id, { is_starred: true });
+          return { action: "star", note_id: parsed.note_id, note };
+        }
+        case "unstar": {
+          const note = await notes.update(parsed.note_id, { is_starred: false });
+          return { action: "unstar", note_id: parsed.note_id, note };
+        }
+      }
+    }
+  };
+}
+
+// src/records/record-shard.ts
+var encoder2 = new TextEncoder();
+var decoder6 = new TextDecoder();
+function emptyCounts() {
+  return {
+    notes: 0,
+    collections: 0,
+    templates: 0,
+    tags: 0,
+    links: 0,
+    embedding_sets: 0,
+    embedding_configs: 0,
+    embedding_set_members: 0,
+    embeddings: 0,
+    skos_schemes: 0,
+    skos_concepts: 0,
+    skos_relations: 0,
+    note_skos_tags: 0,
+    provenance_edges: 0,
+    graph_sources: 0,
+    graph_edges: 0,
+    community_sets: 0,
+    communities: 0,
+    community_assignments: 0
+  };
+}
+async function exportShardFromRecords(store, options) {
+  const files = /* @__PURE__ */ new Map();
+  const components = [];
+  const counts = {};
+  const [allNotes, originals, revisedRows, tagRows, collections, memberships, attachments, blobs] = await Promise.all([
+    store.list("note"),
+    store.list("note_original"),
+    store.list("note_revised_current"),
+    store.list("note_tag"),
+    store.list("collection"),
+    store.list("collection_note"),
+    store.list("attachment"),
+    store.list("attachment_blob")
+  ]);
+  const originalByNote = new Map(originals.map((o) => [o.note_id, o]));
+  const revisedByNote = new Map(revisedRows.map((r) => [r.id, r]));
+  const blobById = new Map(blobs.map((b) => [b.id, b]));
+  const tagsByNote = /* @__PURE__ */ new Map();
+  for (const row of [...tagRows].sort((a, b) => a.tag.localeCompare(b.tag))) {
+    const tags = tagsByNote.get(row.note_id) ?? [];
+    tags.push(row.tag);
+    tagsByNote.set(row.note_id, tags);
+  }
+  const collectionByNote = /* @__PURE__ */ new Map();
+  for (const m of [...memberships].sort((a, b) => a.created_at.localeCompare(b.created_at))) {
+    if (!collectionByNote.has(m.note_id)) collectionByNote.set(m.note_id, m.collection_id);
+  }
+  const membershipNoteIds = /* @__PURE__ */ new Map();
+  for (const m of memberships) {
+    const set = membershipNoteIds.get(m.collection_id) ?? /* @__PURE__ */ new Set();
+    set.add(m.note_id);
+    membershipNoteIds.set(m.collection_id, set);
+  }
+  let notes = allNotes.filter((n) => n.deleted_at === null);
+  if (options?.collectionId) {
+    const inCollection = membershipNoteIds.get(options.collectionId) ?? /* @__PURE__ */ new Set();
+    notes = notes.filter((n) => inCollection.has(n.id));
+  } else if (options?.tag) {
+    notes = notes.filter((n) => tagsByNote.get(n.id)?.includes(options.tag));
+  }
+  notes.sort((a, b) => a.created_at.localeCompare(b.created_at));
+  const liveAttachments = attachments.filter((a) => a.deleted_at === null).sort((a, b) => a.position - b.position || a.created_at.localeCompare(b.created_at));
+  const attachmentsByNote = /* @__PURE__ */ new Map();
+  const exportedBlobChecksums = [];
+  for (const att of liveAttachments) {
+    const blob = blobById.get(att.blob_id);
+    if (!blob) continue;
+    const projection = {
+      extracted_text: att.extracted_text,
+      attachment: {
+        // `path` is the display filename per the binary-attachment projection
+        // contract — never a physical storage key.
+        id: att.id,
+        path: att.filename,
+        mime: att.mime_type,
+        checksum: blob.content_hash,
+        bytes: blob.size_bytes
+      }
+    };
+    const list = attachmentsByNote.get(att.note_id) ?? [];
+    list.push(projection);
+    attachmentsByNote.set(att.note_id, list);
+    exportedBlobChecksums.push(blob.content_hash);
+  }
+  const browserNotes = notes.map((n) => {
+    const revised = revisedByNote.get(n.id);
+    return {
+      id: n.id,
+      title: n.title,
+      format: n.format,
+      source: n.source,
+      is_starred: n.is_starred,
+      is_archived: n.is_archived,
+      created_at: n.created_at,
+      updated_at: n.updated_at,
+      deleted_at: n.deleted_at,
+      original_content: originalByNote.get(n.id)?.content ?? "",
+      revised_content: revised?.content ?? null,
+      ai_metadata: revised?.ai_metadata ?? null,
+      collection_id: collectionByNote.get(n.id) ?? null,
+      attachments: attachmentsByNote.get(n.id),
+      tags: tagsByNote.get(n.id) ?? []
+    };
+  });
+  const exportedNoteIds = new Set(browserNotes.map((n) => n.id));
+  const shardNotes = browserNotes.map((n) => noteToShard(n));
+  let layout;
+  const clusterSize = options?.clusterNotesSize;
+  if (clusterSize && Number.isInteger(clusterSize) && clusterSize > 0 && shardNotes.length > 0) {
+    const clusters = [];
+    for (let offset = 0; offset < shardNotes.length; offset += clusterSize) {
+      const slice = shardNotes.slice(offset, offset + clusterSize);
+      const href = `notes/${String(offset).padStart(6, "0")}.jsonl`;
+      clusters.push({ href, offset });
+      files.set(href, encoder2.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
+    }
+    layout = { clusters: { notes: clusters } };
+  } else {
+    files.set("notes.jsonl", encoder2.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
+  }
+  components.push("notes");
+  counts.notes = shardNotes.length;
+  const liveCollections = collections.filter((c) => c.deleted_at === null).sort((a, b) => a.name.localeCompare(b.name));
+  const shardCollections = liveCollections.map(
+    (c) => collectionToShard(
+      // Canonical collections are flat (no parent hierarchy yet).
+      { id: c.id, name: c.name, description: c.description, parent_id: null, created_at: c.created_at },
+      membershipNoteIds.get(c.id)?.size ?? 0
+    )
+  );
+  files.set("collections.json", encoder2.encode(JSON.stringify(shardCollections)));
+  components.push("collections");
+  counts.collections = shardCollections.length;
+  const distinctTags = [...new Set(
+    tagRows.filter((t) => exportedNoteIds.has(t.note_id) || !options?.collectionId && !options?.tag).map((t) => t.tag)
+  )].sort();
+  const shardTags = tagsToShard(distinctTags.map((name) => ({ name, created_at: /* @__PURE__ */ new Date() })));
+  files.set("tags.json", encoder2.encode(JSON.stringify(shardTags)));
+  components.push("tags");
+  counts.tags = shardTags.length;
+  const links = await store.list("link");
+  const isFiltered = !!(options?.collectionId || options?.tag);
+  const shardLinks = links.filter((l) => l.deleted_at === null).filter((l) => !isFiltered || exportedNoteIds.has(l.source_note_id) && exportedNoteIds.has(l.target_note_id)).sort((a, b) => a.created_at.localeCompare(b.created_at)).map((l) => linkToShard({
+    id: l.id,
+    source_note_id: l.source_note_id,
+    target_note_id: l.target_note_id,
+    link_type: l.link_type,
+    // Canonical links carry no confidence score (PGlite-tier column).
+    confidence: null,
+    created_at: l.created_at
+  }));
+  files.set("links.jsonl", encoder2.encode(shardLinks.map((l) => JSON.stringify(l)).join("\n")));
+  components.push("links");
+  counts.links = shardLinks.length;
+  const checksums = {};
+  for (const [filename, data] of files) {
+    checksums[filename] = await sha256Hex(data);
+  }
+  const manifest = {
+    version: CURRENT_SHARD_VERSION,
+    matric_version: VERSION,
+    format: SHARD_FORMAT,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    components,
+    counts,
+    checksums,
+    min_reader_version: "1.0.0",
+    migrated_from: null,
+    migration_history: [],
+    ...layout ? { layout } : {}
+  };
+  files.set("manifest.json", encoder2.encode(JSON.stringify(manifest, null, 2)));
+  if (options?.includeBlobs && options.blobStore) {
+    const packed = /* @__PURE__ */ new Set();
+    for (const checksum of exportedBlobChecksums) {
+      if (packed.has(checksum)) continue;
+      packed.add(checksum);
+      const bytes = await options.blobStore.read(checksum);
+      if (bytes) files.set(sidecarEntryName(checksum), bytes);
+    }
+  }
+  return packTarGz(files);
+}
+var UNSUPPORTED_COMPONENTS = [
+  "templates",
+  "embedding_sets",
+  "embedding_configs",
+  "embedding_set_members",
+  "embeddings",
+  "skos_schemes",
+  "skos_concepts",
+  "skos_relations",
+  "note_skos_tags",
+  "provenance_edges",
+  "graph_sources",
+  "graph_edges",
+  "communities",
+  "community_assignments"
+];
+function failure(counts, skipped, warnings, error, start) {
+  return {
+    success: false,
+    counts,
+    skipped,
+    warnings,
+    errors: [error],
+    duration_ms: performance.now() - start
+  };
+}
+async function importShardToRecords(store, data, options) {
+  const start = performance.now();
+  const strategy = options?.conflictStrategy ?? "skip";
+  const counts = emptyCounts();
+  const skipped = {};
+  const warnings = [];
+  const inputData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+  let files;
+  try {
+    files = unpackTarGz(inputData);
+  } catch (err) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Failed to decompress archive: ${err instanceof Error ? err.message : String(err)}`,
+      start
+    );
+  }
+  const manifestData = files.get("manifest.json");
+  if (!manifestData) {
+    return failure(counts, skipped, warnings, "Missing manifest.json in shard archive", start);
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(decoder6.decode(manifestData));
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+      throw new Error("manifest must be a JSON object");
+    }
+  } catch {
+    return failure(counts, skipped, warnings, "Invalid manifest.json: failed to parse JSON", start);
+  }
+  if (manifest.min_reader_version && compareShardVersions(manifest.min_reader_version, CURRENT_SHARD_VERSION) > 0) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Shard requires reader version ${manifest.min_reader_version}, but this version supports up to ${CURRENT_SHARD_VERSION}`,
+      start
+    );
+  }
+  const sigError = await enforceSignaturePolicy(files, options, warnings);
+  if (sigError) return failure(counts, skipped, warnings, sigError, start);
+  if (!manifest.checksums || typeof manifest.checksums !== "object") {
+    return failure(counts, skipped, warnings, "Invalid manifest.json: checksums must be an object", start);
+  }
+  const checksumResult = await validateChecksums(manifest.checksums, files);
+  if (!checksumResult.valid) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Checksum validation failed for: ${checksumResult.failures.join(", ")}`,
+      start
+    );
+  }
+  const sidecarBlobs = options?.blobStore ? collectSidecarBlobs(files) : null;
+  const noteClusters = manifest.layout?.clusters?.notes;
+  let parsedNotes;
+  let parsedCollections;
+  let parsedLinks;
+  try {
+    parsedNotes = noteClusters && noteClusters.length > 0 ? [...noteClusters].sort((a, b) => a.offset - b.offset).flatMap((ref) => parseJsonlBytes(files.get(ref.href))) : parseJsonlBytes(files.get("notes.jsonl"));
+    parsedCollections = parseJsonArrayBytes(files.get("collections.json"));
+    parsedLinks = parseJsonlBytes(files.get("links.jsonl"));
+  } catch (err) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Failed to parse shard component: ${err instanceof Error ? err.message : String(err)}`,
+      start
+    );
+  }
+  for (const component of manifest.components ?? []) {
+    if (UNSUPPORTED_COMPONENTS.includes(component)) {
+      const count = manifest.counts?.[component];
+      const key = component === "communities" ? "communities" : component;
+      skipped[key] = (skipped[key] ?? 0) + (typeof count === "number" ? count : 0);
+      warnings.push(
+        `Shard component '${component}' is not supported by the canonical record tier and was skipped. Import into a PGlite-backed store to preserve it.`
+      );
+    }
+  }
+  if (strategy === "error") {
+    for (const col of parsedCollections) {
+      if (await store.get("collection", col.id)) {
+        return failure(counts, skipped, warnings, `Collection already exists: ${col.id}`, start);
+      }
+    }
+    for (const shardNote of parsedNotes) {
+      if (await store.get("note", shardNote.id)) {
+        return failure(counts, skipped, warnings, `Note already exists: ${shardNote.id}`, start);
+      }
+    }
+  }
+  const nowIso3 = (/* @__PURE__ */ new Date()).toISOString();
+  for (const shardCol of parsedCollections) {
+    const col = collectionFromShard(shardCol);
+    const existing = await store.get("collection", col.id);
+    if (existing && strategy === "skip") {
+      skipped.collections = (skipped.collections ?? 0) + 1;
+      continue;
+    }
+    await store.put("collection", {
+      id: col.id,
+      name: col.name,
+      description: col.description,
+      created_at: col.created_at,
+      updated_at: existing?.updated_at ?? nowIso3,
+      deleted_at: existing?.deleted_at ?? null
+    });
+    counts.collections++;
+  }
+  const existingBlobs = await store.list("attachment_blob");
+  const blobIdByChecksum = new Map(existingBlobs.map((b) => [b.content_hash, b.id]));
+  const blobsToHydrate = /* @__PURE__ */ new Map();
+  let referenceOnlyCount = 0;
+  let notesWithAttachmentRefs = 0;
+  for (const shardNote of parsedNotes) {
+    const note = noteFromShard(shardNote);
+    const existing = await store.get("note", note.id);
+    if (existing && strategy === "skip") {
+      skipped.notes = (skipped.notes ?? 0) + 1;
+      continue;
+    }
+    await store.put("note", {
+      id: note.id,
+      archive_id: existing?.archive_id ?? null,
+      title: note.title,
+      format: note.format,
+      source: note.source,
+      visibility: existing?.visibility ?? "private",
+      revision_mode: existing?.revision_mode ?? "standard",
+      is_starred: note.is_starred,
+      is_pinned: existing?.is_pinned ?? false,
+      is_archived: note.is_archived,
+      created_at: typeof note.created_at === "string" ? note.created_at : note.created_at.toISOString(),
+      updated_at: typeof note.updated_at === "string" ? note.updated_at : note.updated_at.toISOString(),
+      deleted_at: note.deleted_at ? typeof note.deleted_at === "string" ? note.deleted_at : note.deleted_at.toISOString() : null
+    });
+    const contentHash = computeHash(encoder2.encode(note.original_content));
+    const existingOriginal = existing ? (await store.list("note_original")).find((o) => o.note_id === note.id) : void 0;
+    await store.put("note_original", {
+      id: existingOriginal?.id ?? generateId(),
+      note_id: note.id,
+      content: note.original_content,
+      content_hash: contentHash,
+      created_at: existingOriginal?.created_at ?? nowIso3
+    });
+    const existingRevised = existing ? await store.get("note_revised_current", note.id) : null;
+    await store.put("note_revised_current", {
+      id: note.id,
+      content: note.revised_content ?? note.original_content,
+      ai_metadata: note.ai_metadata ?? null,
+      generation_count: existingRevised?.generation_count ?? 0,
+      model: existingRevised?.model ?? null,
+      is_user_edited: existingRevised?.is_user_edited ?? false,
+      updated_at: typeof note.updated_at === "string" ? note.updated_at : note.updated_at.toISOString()
+    });
+    const existingTags = new Set(
+      (await store.list("note_tag")).filter((t) => t.note_id === note.id).map((t) => t.tag)
+    );
+    for (const tag of note.tags) {
+      if (existingTags.has(tag)) continue;
+      await store.put("note_tag", { id: generateId(), note_id: note.id, tag, created_at: nowIso3 });
+    }
+    if (note.collection_id && await store.get("collection", note.collection_id)) {
+      const member = (await store.list("collection_note")).find(
+        (cn) => cn.collection_id === note.collection_id && cn.note_id === note.id
+      );
+      if (!member) {
+        await store.put("collection_note", {
+          id: generateId(),
+          collection_id: note.collection_id,
+          note_id: note.id,
+          created_at: nowIso3
+        });
+      }
+    }
+    if (note.attachments?.length) {
+      notesWithAttachmentRefs++;
+      for (let position = 0; position < note.attachments.length; position += 1) {
+        const projection = note.attachments[position];
+        const ref = projection.attachment;
+        let blobId = blobIdByChecksum.get(ref.checksum);
+        if (!blobId) {
+          const blob = {
+            id: generateId(),
+            content_hash: ref.checksum,
+            size_bytes: ref.bytes,
+            created_at: nowIso3
+          };
+          await store.put("attachment_blob", blob);
+          blobIdByChecksum.set(ref.checksum, blob.id);
+          blobId = blob.id;
+        }
+        const filename = ref.path.split("/").filter(Boolean).pop() ?? ref.path;
+        const attachment = {
+          id: ref.id,
+          note_id: note.id,
+          blob_id: blobId,
+          document_type_id: null,
+          mime_type: ref.mime,
+          extracted_text: projection.extracted_text,
+          filename,
+          display_name: null,
+          position,
+          created_at: nowIso3,
+          deleted_at: null
+        };
+        const existingAttachment = await store.get("attachment", ref.id);
+        if (!existingAttachment || strategy === "replace") {
+          await store.put("attachment", {
+            ...attachment,
+            created_at: existingAttachment?.created_at ?? nowIso3
+          });
+        }
+        let hydrated = false;
+        if (sidecarBlobs) {
+          if (blobsToHydrate.has(ref.checksum)) {
+            hydrated = true;
+          } else {
+            const bytes = sidecarBlobs.get(blobChecksumToHex(ref.checksum));
+            if (bytes) {
+              if (computeBlobHash(bytes) === ref.checksum) {
+                blobsToHydrate.set(ref.checksum, bytes);
+                hydrated = true;
+              } else {
+                warnings.push(
+                  `Sidecar blob for attachment ${ref.id} failed BLAKE3 integrity check (expected ${ref.checksum}); imported as reference-only.`
+                );
+              }
+            }
+          }
+        }
+        if (!hydrated) referenceOnlyCount++;
+      }
+    }
+    counts.notes++;
+  }
+  if (referenceOnlyCount > 0) {
+    warnings.push(
+      `${referenceOnlyCount} attachment reference(s) across ${notesWithAttachmentRefs} note(s) were imported as metadata only: no matching byte-sidecar entry (or no import blobStore), so getBlob() returns null until bytes are hydrated. Export a self-contained shard (\`includeBlobs\` + a \`blobStore\`) and import with a \`blobStore\` to hydrate bytes.`
+    );
+  }
+  for (const shardLink of parsedLinks) {
+    const link = linkFromShard(shardLink);
+    if (!link.target_note_id) {
+      skipped.links = (skipped.links ?? 0) + 1;
+      warnings.push(
+        link.to_url ? `URL link ${link.id} skipped: the canonical record tier does not persist URL-target links.` : `Shard link skipped: ${link.id} has neither to_note_id nor to_url.`
+      );
+      continue;
+    }
+    const existing = await store.get("link", link.id);
+    if (existing && strategy === "skip") {
+      skipped.links = (skipped.links ?? 0) + 1;
+      continue;
+    }
+    await store.put("link", {
+      id: link.id,
+      source_note_id: link.source_note_id,
+      target_note_id: link.target_note_id,
+      link_type: link.link_type,
+      created_at: link.created_at,
+      deleted_at: existing?.deleted_at ?? null
+    });
+    counts.links++;
+  }
+  const errors = [];
+  if (options?.blobStore && blobsToHydrate.size > 0) {
+    try {
+      for (const [, bytes] of blobsToHydrate) {
+        await options.blobStore.put(bytes);
+      }
+    } catch (err) {
+      warnings.push(
+        `Imported records successfully but failed to hydrate ${blobsToHydrate.size} attachment blob(s) into the BlobStore: ${err instanceof Error ? err.message : String(err)}.`
+      );
+    }
+  }
+  return {
+    success: true,
+    counts,
+    skipped,
+    warnings,
+    errors,
+    duration_ms: performance.now() - start
+  };
+}
+
 // src/index.ts
-var VERSION = "2026.7.5";
+var VERSION = "2026.7.8";
 
-export { AIWG_SCAN_REQUIRED_FIELDS, ArchiveManager, AttachmentsRepository, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, DB_SNAPSHOT_SCHEMA_VERSION, DbSnapshotVersionError, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, EmbeddingSetsRepository, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProvenanceRepository, ProviderRegistry, SHARD_FORMAT, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexToCommunityGraph, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, assertShardComponentRecord, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeBlobHash, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, isPluginScriptAllowed, isShardPrefetched, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, provenanceEdgeToShard, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateAiwgStaticEmbeddingSet, validateChecksums, validateFortemiCompatibilityResponse, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifySri };
+export { AIWG_SCAN_REQUIRED_FIELDS, AllowlistTrustStore, ArchiveManager, AttachmentsRepository, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, CanonicalAttachmentsRepository, CanonicalNotesRepository, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, DB_SNAPSHOT_SCHEMA_VERSION, DbSnapshotVersionError, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, EmbeddingSetsRepository, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, IdbRecordStore, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MemoryRecordStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProvenanceRepository, ProviderRegistry, RECORD_COLLECTIONS, RECORD_SCHEMA_VERSION, RECORD_STORE_CAPABILITIES, SHARD_FORMAT, SIGNATURE_ENTRY, SIGNING_ENVELOPE_VERSION, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexFromKnowledgeShard, aiwgFortemiIndexToCommunityGraph, aiwgFortemiIndexToKnowledgeShard, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, assertShardComponentRecord, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeBlobHash, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLazyBlobStore, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRecordBackend, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, exportShardFromRecords, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, importShardToRecords, isPluginScriptAllowed, isShardPrefetched, isShardSigningSupported, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, migrateLegacyBlobStore, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, sidecarBlobDigests, signShard, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateAiwgStaticEmbeddingSet, validateChecksums, validateFortemiCompatibilityResponse, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map