@fortemi/core 2026.7.4 → 2026.7.7

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");
@@ -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,974 +10363,263 @@ function clearPrefetchedShard(url) {
   }
   warmStore.delete(url);
 }
-
-// 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
-        },
-        privacy: {
-          $ref: "#/$defs/privacy"
-        },
-        graph: {
-          type: "string",
-          minLength: 1
+var AIWG_SCAN_REQUIRED_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "title",
+  "text",
+  "facets",
+  "tags",
+  "concepts",
+  "privacy"
+];
+function isPrivacyExcluded(record, options) {
+  const privacy = record.privacy;
+  if (!privacy || !isPrivacyClassification(privacy.classification) || typeof privacy.pii !== "boolean") return true;
+  if (privacy.classification === "private" && !options?.includePrivate) return true;
+  if (privacy.pii && !options?.includePii) return true;
+  return false;
+}
+function filterAiwgRecordsByPrivacy(records, options) {
+  return records.filter((record) => !isPrivacyExcluded(record, options));
+}
+var REQUIRED_RECORD_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "source",
+  "facets",
+  "tags",
+  "concepts",
+  "relationships",
+  "provenance",
+  "privacy",
+  "updated_at"
+];
+var DEFAULT_QUERY_WEIGHTS = {
+  title: 4,
+  tag: 3,
+  concept: 2,
+  text: 1,
+  facet: 2,
+  id: 1,
+  source: 0.25
+};
+function hasString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function pushFacet(counts, name, value) {
+  let bucket = counts[name];
+  if (bucket === void 0) {
+    bucket = /* @__PURE__ */ Object.create(null);
+    counts[name] = bucket;
+  }
+  bucket[value] = (bucket[value] ?? 0) + 1;
+}
+function hasNonNegativeInteger(value) {
+  return Number.isInteger(value) && typeof value === "number" && value >= 0;
+}
+function hasPositiveInteger(value) {
+  return Number.isInteger(value) && typeof value === "number" && value > 0;
+}
+function isFacetCounts(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  return Object.values(value).every((counts) => !!counts && typeof counts === "object" && !Array.isArray(counts) && Object.values(counts).every((count) => hasNonNegativeInteger(count)));
+}
+function isPlainRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function isOptionalStringArray(value) {
+  return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isSupportedIndexSchemaVersion(value) {
+  return value === "aiwg.fortemi.index.export.v1" || value === "aiwg.fortemi.index.export.v2";
+}
+function isSupportedRecordSchemaVersion(value) {
+  return value === "aiwg.fortemi.index.record.v1" || value === "aiwg.fortemi.index.record.v2";
+}
+function validateOptionalRichMetadata(item, index, errors) {
+  if (item.skos_concepts !== void 0) {
+    if (!Array.isArray(item.skos_concepts)) {
+      errors.push("items[" + index + "].skos_concepts must be an array when present");
+    } else {
+      for (const [conceptIndex, concept] of item.skos_concepts.entries()) {
+        if (!isPlainRecord(concept)) {
+          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "] must be an object");
+          continue;
         }
-      }
-    },
-    compatibility: {
-      type: "object",
-      additionalProperties: false,
-      required: ["previous_schema_version", "strategy"],
-      properties: {
-        previous_schema_version: {
-          const: "aiwg.fortemi.index.export.v1"
-        },
-        strategy: {
-          const: "supported"
+        if (!hasString(concept.id)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].id is required");
+        if (!hasString(concept.prefLabel)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].prefLabel is required");
+        if (!isOptionalStringArray(concept.altLabels)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].altLabels must be a string array");
+        if (concept.metadata !== void 0 && !isPlainRecord(concept.metadata)) {
+          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].metadata must be an object");
         }
       }
-    },
-    items: {
-      type: "array",
-      items: {
-        $ref: "#/$defs/record"
-      }
     }
-  },
-  allOf: [
-    {
-      if: {
-        properties: {
-          schema_version: {
-            const: "aiwg.fortemi.index.export.v1"
-          }
+  }
+  if (item.skos_relations !== void 0) {
+    if (!Array.isArray(item.skos_relations)) {
+      errors.push("items[" + index + "].skos_relations must be an array when present");
+    } else {
+      for (const [relationIndex, relation] of item.skos_relations.entries()) {
+        if (!isPlainRecord(relation)) {
+          errors.push("items[" + index + "].skos_relations[" + relationIndex + "] must be an object");
+          continue;
         }
-      },
-      then: {
-        not: {
-          required: ["compatibility"]
-        },
-        properties: {
-          source: {
-            not: {
-              required: ["graph"]
-            }
-          },
-          items: {
-            items: {
-              allOf: [
-                {
-                  properties: {
-                    schema_version: {
-                      const: "aiwg.fortemi.index.record.v1"
-                    }
-                  }
-                },
-                {
-                  $ref: "#/$defs/v1RecordCompatibility"
-                }
-              ]
-            }
-          }
+        if (!hasString(relation.type)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].type is required");
+        if (!hasString(relation.source_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].source_id is required");
+        if (!hasString(relation.target_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].target_id is required");
+        if (relation.metadata !== void 0 && !isPlainRecord(relation.metadata)) {
+          errors.push("items[" + index + "].skos_relations[" + relationIndex + "].metadata must be an object");
         }
       }
-    },
-    {
-      if: {
-        properties: {
-          schema_version: {
-            const: "aiwg.fortemi.index.export.v2"
-          }
+    }
+  }
+  if (item.provenance_events !== void 0) {
+    if (!Array.isArray(item.provenance_events)) {
+      errors.push("items[" + index + "].provenance_events must be an array when present");
+    } else {
+      for (const [eventIndex, event] of item.provenance_events.entries()) {
+        if (!isPlainRecord(event)) {
+          errors.push("items[" + index + "].provenance_events[" + eventIndex + "] must be an object");
+          continue;
         }
-      },
-      then: {
-        required: ["compatibility"],
-        properties: {
-          source: {
-            required: ["graph"]
-          },
-          items: {
-            items: {
-              properties: {
-                schema_version: {
-                  const: "aiwg.fortemi.index.record.v2"
-                }
-              }
-            }
-          }
+        if (!hasString(event.activity)) errors.push("items[" + index + "].provenance_events[" + eventIndex + "].activity is required");
+        if (event.attributes !== void 0 && !isPlainRecord(event.attributes)) {
+          errors.push("items[" + index + "].provenance_events[" + eventIndex + "].attributes must be an object");
         }
       }
     }
-  ],
-  $defs: {
-    privacy: {
-      enum: ["private", "sanitized", "public"]
-    },
-    recordType: {
-      type: "string",
-      minLength: 1
-    },
-    stringArray: {
-      type: "array",
-      items: {
-        type: "string"
+  }
+  if (Array.isArray(item.relationships)) {
+    for (const [relationshipIndex, relationship] of item.relationships.entries()) {
+      if (!isPlainRecord(relationship)) {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "] must be an object");
+        continue;
       }
-    },
-    numberArray: {
-      type: "array",
-      items: {
-        type: "number"
+      if (relationship.metadata !== void 0 && !isPlainRecord(relationship.metadata)) {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].metadata must be an object");
       }
-    },
-    v1RecordCompatibility: {
-      type: "object",
-      not: {
-        anyOf: [
-          {
-            required: ["name"]
-          },
-          {
-            required: ["summary"]
-          },
-          {
-            required: ["search"]
-          },
-          {
-            required: ["chunks"]
-          },
-          {
-            required: ["embeddings"]
-          },
-          {
-            required: ["compatibility"]
-          },
-          {
-            required: ["skos_concepts"]
-          },
-          {
-            required: ["skos_relations"]
-          },
-          {
-            required: ["provenance_events"]
-          }
-        ]
-      },
-      properties: {
-        source: {
-          not: {
-            anyOf: [
-              {
-                required: ["origin"]
-              },
-              {
-                required: ["generated"]
-              },
-              {
-                required: ["checksum"]
-              },
-              {
-                required: ["updated_at"]
-              }
-            ]
-          }
-        },
-        relationships: {
-          items: {
-            not: {
-              anyOf: [
-                {
-                  required: ["target_path"]
-                },
-                {
-                  required: ["direction"]
-                },
-                {
-                  required: ["label"]
-                },
-                {
-                  required: ["confidence"]
-                },
-                {
-                  required: ["privacy"]
-                },
-                {
-                  required: ["metadata"]
-                }
-              ]
-            }
-          }
-        },
-        privacy: {
-          not: {
-            required: ["locality"]
-          }
+      if (relationship.direction !== void 0 && relationship.direction !== "upstream" && relationship.direction !== "downstream" && relationship.direction !== "related") {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].direction must be upstream, downstream, or related");
+      }
+      if (relationship.target_path !== void 0 && typeof relationship.target_path !== "string") {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].target_path must be a string");
+      }
+    }
+  }
+  if (item.search !== void 0) {
+    if (!isPlainRecord(item.search)) {
+      errors.push("items[" + index + "].search must be an object");
+    } else {
+      if (!isOptionalStringArray(item.search.triggers)) errors.push("items[" + index + "].search.triggers must be a string array");
+      if (!isOptionalStringArray(item.search.aliases)) errors.push("items[" + index + "].search.aliases must be a string array");
+      if (!isOptionalStringArray(item.search.tags)) errors.push("items[" + index + "].search.tags must be a string array");
+      if (item.search.frontmatter !== void 0 && !isPlainRecord(item.search.frontmatter)) {
+        errors.push("items[" + index + "].search.frontmatter must be an object");
+      }
+    }
+  }
+  if (item.chunks !== void 0) {
+    if (!Array.isArray(item.chunks)) {
+      errors.push("items[" + index + "].chunks must be an array when present");
+    } else {
+      for (const [chunkIndex, chunk] of item.chunks.entries()) {
+        if (!isPlainRecord(chunk)) {
+          errors.push("items[" + index + "].chunks[" + chunkIndex + "] must be an object");
+          continue;
+        }
+        if (chunk.metadata !== void 0 && !isPlainRecord(chunk.metadata)) {
+          errors.push("items[" + index + "].chunks[" + chunkIndex + "].metadata must be an object");
         }
       }
-    },
-    record: {
-      type: "object",
-      additionalProperties: false,
-      required: [
-        "schema_version",
-        "id",
-        "type",
-        "source",
-        "title",
-        "text",
-        "facets",
-        "tags",
-        "concepts",
-        "relationships",
-        "provenance",
-        "privacy",
-        "updated_at"
-      ],
-      properties: {
-        schema_version: {
-          enum: [
-            "aiwg.fortemi.index.record.v1",
-            "aiwg.fortemi.index.record.v2"
-          ]
-        },
-        id: {
-          type: "string",
-          minLength: 1
-        },
-        type: {
-          $ref: "#/$defs/recordType"
-        },
-        source: {
-          type: "object",
-          additionalProperties: false,
-          required: ["path", "repo_relative_path", "locator"],
-          properties: {
-            path: {
-              type: "string",
-              minLength: 1
-            },
-            repo_relative_path: {
-              type: "string",
-              minLength: 1
-            },
-            locator: {
-              type: "string",
-              minLength: 1
-            },
-            origin: {
-              type: "string",
-              minLength: 1
-            },
-            generated: {
-              type: "boolean"
-            },
-            checksum: {
-              type: "string"
-            },
-            updated_at: {
-              type: "string",
-              format: "date-time"
-            }
-          }
-        },
-        title: {
-          type: "string"
-        },
-        name: {
-          type: "string"
-        },
-        summary: {
-          type: "string"
-        },
-        text: {
-          type: "string"
-        },
-        search: {
-          type: "object",
-          additionalProperties: false,
-          required: [
-            "title",
-            "body",
-            "triggers",
-            "aliases",
-            "tags",
-            "frontmatter"
-          ],
-          properties: {
-            title: {
-              type: "string"
-            },
-            name: {
-              type: "string"
-            },
-            summary: {
-              type: "string"
-            },
-            body: {
-              type: "string"
-            },
-            triggers: {
-              $ref: "#/$defs/stringArray"
-            },
-            aliases: {
-              $ref: "#/$defs/stringArray"
-            },
-            capability: {
-              type: "string"
-            },
-            tags: {
-              $ref: "#/$defs/stringArray"
-            },
-            phase: {
-              type: "string"
-            },
-            type: {
-              type: "string"
-            },
-            frontmatter: {
-              type: "object"
-            }
-          }
-        },
-        facets: {
-          type: "object",
-          additionalProperties: {
-            $ref: "#/$defs/stringArray"
-          }
-        },
-        tags: {
-          $ref: "#/$defs/stringArray"
-        },
-        concepts: {
-          $ref: "#/$defs/stringArray"
-        },
-        relationships: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["type", "target_id"],
-            properties: {
-              type: {
-                type: "string",
-                minLength: 1
-              },
-              target_id: {
-                type: "string",
-                minLength: 1
-              },
-              source_path: {
-                type: "string"
-              },
-              target_path: {
-                type: "string"
-              },
-              direction: {
-                enum: ["upstream", "downstream", "related"]
-              },
-              label: {
-                type: "string"
-              },
-              confidence: {
-                type: "number"
-              },
-              privacy: {
-                $ref: "#/$defs/privacy"
-              },
-              metadata: {
-                type: "object"
-              }
-            }
-          }
-        },
-        provenance: {
-          type: "array",
-          minItems: 1,
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["field", "source", "path", "confidence", "privacy"],
-            properties: {
-              field: {
-                type: "string",
-                minLength: 1
-              },
-              source: {
-                type: "string",
-                minLength: 1
-              },
-              path: {
-                type: "string",
-                minLength: 1
-              },
-              confidence: {
-                enum: ["source", "candidate", "reviewed", "rejected"]
-              },
-              privacy: {
-                $ref: "#/$defs/privacy"
-              }
-            }
-          }
-        },
-        privacy: {
-          type: "object",
-          additionalProperties: false,
-          required: ["classification", "pii"],
-          properties: {
-            classification: {
-              $ref: "#/$defs/privacy"
-            },
-            pii: {
-              type: "boolean"
-            },
-            locality: {
-              enum: ["project", "framework", "external"]
-            }
-          }
-        },
-        chunks: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-              id: {
-                type: "string",
-                minLength: 1
-              },
-              text: {
-                type: "string"
-              },
-              body: {
-                type: "string"
-              },
-              summary: {
-                type: "string"
-              },
-              source_path: {
-                type: "string"
-              },
-              metadata: {
-                type: "object"
-              },
-              checksum: {
-                type: "string"
-              }
-            }
-          }
-        },
-        embeddings: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-              id: {
-                type: "string"
-              },
-              model: {
-                type: "string"
-              },
-              embedding: {
-                $ref: "#/$defs/numberArray"
-              },
-              vector: {
-                $ref: "#/$defs/numberArray"
-              },
-              granularity: {
-                type: "string"
-              },
-              source_path: {
-                type: "string"
-              },
-              metadata: {
-                type: "object"
-              },
-              chunk_id: {
-                type: "string"
-              },
-              vector_ref: {
-                type: "string"
-              },
-              input_hash: {
-                type: "string"
-              }
-            }
-          }
-        },
-        compatibility: {
-          type: "object"
-        },
-        skos_concepts: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["id", "prefLabel"],
-            properties: {
-              id: {
-                type: "string",
-                minLength: 1
-              },
-              prefLabel: {
-                type: "string",
-                minLength: 1
-              },
-              definition: {
-                type: "string"
-              },
-              scheme: {
-                type: "string"
-              },
-              notation: {
-                type: "string"
-              },
-              uri: {
-                type: "string"
-              },
-              altLabels: {
-                $ref: "#/$defs/stringArray"
-              },
-              metadata: {
-                type: "object"
-              }
-            }
-          }
-        },
-        skos_relations: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["type", "source_id", "target_id"],
-            properties: {
-              type: {
-                type: "string",
-                minLength: 1
-              },
-              source_id: {
-                type: "string",
-                minLength: 1
-              },
-              target_id: {
-                type: "string",
-                minLength: 1
-              },
-              source_path: {
-                type: "string"
-              },
-              metadata: {
-                type: "object"
-              }
-            }
-          }
-        },
-        provenance_events: {
-          type: "array",
-          items: {
-            type: "object",
-            additionalProperties: false,
-            required: ["activity"],
-            properties: {
-              id: {
-                type: "string"
-              },
-              activity: {
-                type: "string",
-                minLength: 1
-              },
-              agent: {
-                type: "string"
-              },
-              started_at: {
-                type: "string",
-                format: "date-time"
-              },
-              ended_at: {
-                type: "string",
-                format: "date-time"
-              },
-              source: {
-                type: "string"
-              },
-              path: {
-                type: "string"
-              },
-              confidence: {
-                enum: ["source", "candidate", "reviewed", "rejected"]
-              },
-              privacy: {
-                $ref: "#/$defs/privacy"
-              },
-              attributes: {
-                type: "object"
-              }
-            }
-          }
-        },
-        updated_at: {
-          type: "string",
-          format: "date-time"
+    }
+  }
+  if (item.embeddings !== void 0) {
+    if (!Array.isArray(item.embeddings)) {
+      errors.push("items[" + index + "].embeddings must be an array when present");
+    } else {
+      for (const [embeddingIndex, embedding] of item.embeddings.entries()) {
+        if (!isPlainRecord(embedding)) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "] must be an object");
+          continue;
+        }
+        const vector = embedding.embedding ?? embedding.vector;
+        if (vector !== void 0 && (!Array.isArray(vector) || !vector.every((entry) => typeof entry === "number"))) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].embedding/vector must be a number array");
+        }
+        if (embedding.metadata !== void 0 && !isPlainRecord(embedding.metadata)) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].metadata must be an object");
         }
       }
     }
   }
-};
-
-// src/aiwg-index-schema.ts
-var PROJECTED_FIELDS = [
-  "schema_version",
-  "id",
-  "type",
-  "title",
-  "text",
-  "facets",
-  "tags",
-  "concepts",
-  "privacy"
-];
-var ajvInstance2;
-var exportValidator;
-var projectedRecordValidator;
-function getAiwgFortemiIndexExportSchema() {
-  return aiwg_fortemi_index_export_schema_default;
-}
-function getAjv2() {
-  if (!ajvInstance2) {
-    ajvInstance2 = new Ajv2020({
-      allErrors: true,
-      strict: false,
-      validateFormats: false
-    });
-    ajvInstance2.addSchema(aiwg_fortemi_index_export_schema_default);
+  if (item.compatibility !== void 0 && !isPlainRecord(item.compatibility)) {
+    errors.push("items[" + index + "].compatibility must be an object");
   }
-  return ajvInstance2;
 }
-function formatErrors2(errors) {
-  return (errors ?? []).map((error) => {
-    const path = error.instancePath || "(root)";
-    return `${path} ${error.message ?? "is invalid"}`;
-  });
+function isPrivacyClassification(value) {
+  return value === "private" || value === "sanitized" || value === "public";
 }
-function getExportValidator() {
-  exportValidator ??= getAjv2().getSchema(aiwg_fortemi_index_export_schema_default.$id) ?? getAjv2().compile(aiwg_fortemi_index_export_schema_default);
-  return exportValidator;
+function isProvenanceConfidence(value) {
+  return value === "source" || value === "candidate" || value === "reviewed" || value === "rejected";
 }
-function getProjectedRecordValidator() {
-  if (!projectedRecordValidator) {
-    const properties = Object.fromEntries(Object.keys(aiwg_fortemi_index_export_schema_default.$defs.record.properties).map((field) => [
-      field,
-      { $ref: `${aiwg_fortemi_index_export_schema_default.$id}#/$defs/record/properties/${field}` }
-    ]));
-    projectedRecordValidator = getAjv2().compile({
-      type: "object",
-      required: PROJECTED_FIELDS,
-      properties,
-      additionalProperties: true,
-      allOf: [
-        {
-          if: {
-            properties: {
-              schema_version: { const: "aiwg.fortemi.index.record.v1" }
-            }
-          },
-          then: { $ref: `${aiwg_fortemi_index_export_schema_default.$id}#/$defs/v1RecordCompatibility` }
-        }
-      ]
-    });
+function validateProvenanceItems(item, index, errors) {
+  if (!Array.isArray(item.provenance)) return;
+  for (const [provIndex, prov] of item.provenance.entries()) {
+    const at = "items[" + index + "].provenance[" + provIndex + "]";
+    if (!isPlainRecord(prov)) {
+      errors.push(at + " must be an object");
+      continue;
+    }
+    if (!hasString(prov.field)) errors.push(at + ".field is required");
+    if (!hasString(prov.source)) errors.push(at + ".source is required");
+    if (!hasString(prov.path)) errors.push(at + ".path is required");
+    if (!isProvenanceConfidence(prov.confidence)) errors.push(at + ".confidence must be one of source, candidate, reviewed, rejected");
+    if (!isPrivacyClassification(prov.privacy)) errors.push(at + ".privacy must be one of private, sanitized, public");
   }
-  return projectedRecordValidator;
-}
-function validateAiwgFortemiIndexExportSchema(value) {
-  const validate = getExportValidator();
-  const schemaValue = value && typeof value === "object" && Array.isArray(value.items) ? {
-    ...value,
-    items: value.items.map((item) => {
-      if (!item || typeof item !== "object" || Array.isArray(item)) return item;
-      const schemaRecord = { ...item };
-      Reflect.deleteProperty(schemaRecord, "binary_sources");
-      return schemaRecord;
-    })
-  } : value;
-  const valid = validate(schemaValue);
-  return { valid, errors: formatErrors2(validate.errors) };
-}
-function validateAiwgFortemiProjectedRecordSchema(value) {
-  const validate = getProjectedRecordValidator();
-  const valid = validate(value);
-  return { valid, errors: formatErrors2(validate.errors) };
-}
-
-// src/aiwg-index.ts
-var AIWG_SCAN_REQUIRED_FIELDS = [
-  "schema_version",
-  "id",
-  "type",
-  "title",
-  "text",
-  "facets",
-  "tags",
-  "concepts",
-  "privacy"
-];
-function isPrivacyExcluded(record, options) {
-  const privacy = record.privacy;
-  if (!privacy || !isPrivacyClassification(privacy.classification) || typeof privacy.pii !== "boolean") return true;
-  if (privacy.classification === "private" && !options?.includePrivate) return true;
-  if (privacy.pii && !options?.includePii) return true;
-  return false;
 }
-function filterAiwgRecordsByPrivacy(records, options) {
-  return records.filter((record) => !isPrivacyExcluded(record, options));
-}
-var REQUIRED_RECORD_FIELDS = [
-  "schema_version",
-  "id",
-  "type",
-  "source",
-  "facets",
-  "tags",
-  "concepts",
-  "relationships",
-  "provenance",
-  "privacy",
-  "updated_at"
+var V2_ONLY_RECORD_FIELDS = [
+  "search",
+  "chunks",
+  "embeddings",
+  "skos_concepts",
+  "skos_relations",
+  "provenance_events",
+  "compatibility"
 ];
-var DEFAULT_QUERY_WEIGHTS = {
-  title: 4,
-  tag: 3,
-  concept: 2,
-  text: 1,
-  facet: 2,
-  id: 1,
-  source: 0.25
-};
-function hasString(value) {
-  return typeof value === "string" && value.length > 0;
-}
-function pushFacet(counts, name, value) {
-  let bucket = counts[name];
-  if (bucket === void 0) {
-    bucket = /* @__PURE__ */ Object.create(null);
-    counts[name] = bucket;
-  }
-  bucket[value] = (bucket[value] ?? 0) + 1;
-}
-function hasNonNegativeInteger(value) {
-  return Number.isInteger(value) && typeof value === "number" && value >= 0;
-}
-function hasPositiveInteger(value) {
-  return Number.isInteger(value) && typeof value === "number" && value > 0;
-}
-function isFacetCounts(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-  return Object.values(value).every((counts) => !!counts && typeof counts === "object" && !Array.isArray(counts) && Object.values(counts).every((count) => hasNonNegativeInteger(count)));
-}
-function isPlainRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function isOptionalStringArray(value) {
-  return value === void 0 || Array.isArray(value) && value.every((item) => typeof item === "string");
-}
-function isSupportedIndexSchemaVersion(value) {
-  return value === "aiwg.fortemi.index.export.v1" || value === "aiwg.fortemi.index.export.v2";
-}
-function isSupportedRecordSchemaVersion(value) {
-  return value === "aiwg.fortemi.index.record.v1" || value === "aiwg.fortemi.index.record.v2";
-}
-function validateOptionalRichMetadata(item, index, errors) {
-  if (item.skos_concepts !== void 0) {
-    if (!Array.isArray(item.skos_concepts)) {
-      errors.push("items[" + index + "].skos_concepts must be an array when present");
-    } else {
-      for (const [conceptIndex, concept] of item.skos_concepts.entries()) {
-        if (!isPlainRecord(concept)) {
-          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "] must be an object");
-          continue;
-        }
-        if (!hasString(concept.id)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].id is required");
-        if (!hasString(concept.prefLabel)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].prefLabel is required");
-        if (!isOptionalStringArray(concept.altLabels)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].altLabels must be a string array");
-        if (concept.metadata !== void 0 && !isPlainRecord(concept.metadata)) {
-          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].metadata must be an object");
-        }
-      }
-    }
+var V2_ONLY_SOURCE_FIELDS = ["origin", "generated", "checksum", "updated_at"];
+var V2_ONLY_RELATIONSHIP_FIELDS = ["target_path", "direction", "metadata"];
+function forbidV2FieldsOnV1Record(item, index, errors) {
+  if (item.schema_version !== "aiwg.fortemi.index.record.v1") return;
+  const at = "items[" + index + "]";
+  const bag = item;
+  const v2msg = " is a v2-only field and must be absent on a record.v1 record";
+  for (const field of V2_ONLY_RECORD_FIELDS) {
+    if (bag[field] !== void 0) errors.push(at + "." + field + v2msg);
   }
-  if (item.skos_relations !== void 0) {
-    if (!Array.isArray(item.skos_relations)) {
-      errors.push("items[" + index + "].skos_relations must be an array when present");
-    } else {
-      for (const [relationIndex, relation] of item.skos_relations.entries()) {
-        if (!isPlainRecord(relation)) {
-          errors.push("items[" + index + "].skos_relations[" + relationIndex + "] must be an object");
-          continue;
-        }
-        if (!hasString(relation.type)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].type is required");
-        if (!hasString(relation.source_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].source_id is required");
-        if (!hasString(relation.target_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].target_id is required");
-        if (relation.metadata !== void 0 && !isPlainRecord(relation.metadata)) {
-          errors.push("items[" + index + "].skos_relations[" + relationIndex + "].metadata must be an object");
-        }
-      }
+  if (isPlainRecord(item.source)) {
+    const src = item.source;
+    for (const field of V2_ONLY_SOURCE_FIELDS) {
+      if (src[field] !== void 0) errors.push(at + ".source." + field + v2msg);
     }
   }
-  if (item.provenance_events !== void 0) {
-    if (!Array.isArray(item.provenance_events)) {
-      errors.push("items[" + index + "].provenance_events must be an array when present");
-    } else {
-      for (const [eventIndex, event] of item.provenance_events.entries()) {
-        if (!isPlainRecord(event)) {
-          errors.push("items[" + index + "].provenance_events[" + eventIndex + "] must be an object");
-          continue;
-        }
-        if (!hasString(event.activity)) errors.push("items[" + index + "].provenance_events[" + eventIndex + "].activity is required");
-        if (event.attributes !== void 0 && !isPlainRecord(event.attributes)) {
-          errors.push("items[" + index + "].provenance_events[" + eventIndex + "].attributes must be an object");
-        }
-      }
-    }
+  if (isPlainRecord(item.privacy) && item.privacy.locality !== void 0) {
+    errors.push(at + ".privacy.locality" + v2msg);
   }
   if (Array.isArray(item.relationships)) {
-    for (const [relationshipIndex, relationship] of item.relationships.entries()) {
-      if (!isPlainRecord(relationship)) {
-        errors.push("items[" + index + "].relationships[" + relationshipIndex + "] must be an object");
-        continue;
-      }
-      if (relationship.metadata !== void 0 && !isPlainRecord(relationship.metadata)) {
-        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].metadata must be an object");
-      }
-      if (relationship.direction !== void 0 && relationship.direction !== "upstream" && relationship.direction !== "downstream" && relationship.direction !== "related") {
-        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].direction must be upstream, downstream, or related");
-      }
-      if (relationship.target_path !== void 0 && typeof relationship.target_path !== "string") {
-        errors.push("items[" + index + "].relationships[" + relationshipIndex + "].target_path must be a string");
-      }
-    }
-  }
-  if (item.search !== void 0) {
-    if (!isPlainRecord(item.search)) {
-      errors.push("items[" + index + "].search must be an object");
-    } else {
-      if (!isOptionalStringArray(item.search.triggers)) errors.push("items[" + index + "].search.triggers must be a string array");
-      if (!isOptionalStringArray(item.search.aliases)) errors.push("items[" + index + "].search.aliases must be a string array");
-      if (!isOptionalStringArray(item.search.tags)) errors.push("items[" + index + "].search.tags must be a string array");
-      if (item.search.frontmatter !== void 0 && !isPlainRecord(item.search.frontmatter)) {
-        errors.push("items[" + index + "].search.frontmatter must be an object");
-      }
-    }
-  }
-  if (item.chunks !== void 0) {
-    if (!Array.isArray(item.chunks)) {
-      errors.push("items[" + index + "].chunks must be an array when present");
-    } else {
-      for (const [chunkIndex, chunk] of item.chunks.entries()) {
-        if (!isPlainRecord(chunk)) {
-          errors.push("items[" + index + "].chunks[" + chunkIndex + "] must be an object");
-          continue;
-        }
-        if (chunk.metadata !== void 0 && !isPlainRecord(chunk.metadata)) {
-          errors.push("items[" + index + "].chunks[" + chunkIndex + "].metadata must be an object");
-        }
-      }
-    }
-  }
-  if (item.embeddings !== void 0) {
-    if (!Array.isArray(item.embeddings)) {
-      errors.push("items[" + index + "].embeddings must be an array when present");
-    } else {
-      for (const [embeddingIndex, embedding] of item.embeddings.entries()) {
-        if (!isPlainRecord(embedding)) {
-          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "] must be an object");
-          continue;
-        }
-        const vector = embedding.embedding ?? embedding.vector;
-        if (vector !== void 0 && (!Array.isArray(vector) || !vector.every((entry) => typeof entry === "number"))) {
-          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].embedding/vector must be a number array");
-        }
-        if (embedding.metadata !== void 0 && !isPlainRecord(embedding.metadata)) {
-          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].metadata must be an object");
-        }
-      }
-    }
-  }
-  if (item.compatibility !== void 0 && !isPlainRecord(item.compatibility)) {
-    errors.push("items[" + index + "].compatibility must be an object");
-  }
-}
-function isPrivacyClassification(value) {
-  return value === "private" || value === "sanitized" || value === "public";
-}
-function isProvenanceConfidence(value) {
-  return value === "source" || value === "candidate" || value === "reviewed" || value === "rejected";
-}
-function validateProvenanceItems(item, index, errors) {
-  if (!Array.isArray(item.provenance)) return;
-  for (const [provIndex, prov] of item.provenance.entries()) {
-    const at = "items[" + index + "].provenance[" + provIndex + "]";
-    if (!isPlainRecord(prov)) {
-      errors.push(at + " must be an object");
-      continue;
-    }
-    if (!hasString(prov.field)) errors.push(at + ".field is required");
-    if (!hasString(prov.source)) errors.push(at + ".source is required");
-    if (!hasString(prov.path)) errors.push(at + ".path is required");
-    if (!isProvenanceConfidence(prov.confidence)) errors.push(at + ".confidence must be one of source, candidate, reviewed, rejected");
-    if (!isPrivacyClassification(prov.privacy)) errors.push(at + ".privacy must be one of private, sanitized, public");
-  }
-}
-var V2_ONLY_RECORD_FIELDS = ["search", "chunks", "embeddings", "skos_concepts", "skos_relations", "compatibility"];
-var V2_ONLY_SOURCE_FIELDS = ["origin", "generated", "checksum", "updated_at"];
-var V2_ONLY_RELATIONSHIP_FIELDS = ["target_path", "direction", "metadata"];
-function forbidV2FieldsOnV1Record(item, index, errors) {
-  if (item.schema_version !== "aiwg.fortemi.index.record.v1") return;
-  const at = "items[" + index + "]";
-  const bag = item;
-  const v2msg = " is a v2-only field and must be absent on a record.v1 record";
-  for (const field of V2_ONLY_RECORD_FIELDS) {
-    if (bag[field] !== void 0) errors.push(at + "." + field + v2msg);
-  }
-  if (isPlainRecord(item.source)) {
-    const src = item.source;
-    for (const field of V2_ONLY_SOURCE_FIELDS) {
-      if (src[field] !== void 0) errors.push(at + ".source." + field + v2msg);
-    }
-  }
-  if (isPlainRecord(item.privacy) && item.privacy.locality !== void 0) {
-    errors.push(at + ".privacy.locality" + v2msg);
-  }
-  if (Array.isArray(item.relationships)) {
-    for (const [relIndex, rel] of item.relationships.entries()) {
-      if (!isPlainRecord(rel)) continue;
-      const relBag = rel;
-      for (const field of V2_ONLY_RELATIONSHIP_FIELDS) {
-        if (relBag[field] !== void 0) errors.push(at + ".relationships[" + relIndex + "]." + field + v2msg);
+    for (const [relIndex, rel] of item.relationships.entries()) {
+      if (!isPlainRecord(rel)) continue;
+      const relBag = rel;
+      for (const field of V2_ONLY_RELATIONSHIP_FIELDS) {
+        if (relBag[field] !== void 0) errors.push(at + ".relationships[" + relIndex + "]." + field + v2msg);
       }
     }
   }
 }
 function validateAiwgFortemiIndexExport(value) {
-  const errors = validateAiwgFortemiIndexExportSchema(value).errors;
+  const errors = [];
   const counts = /* @__PURE__ */ Object.create(null);
   const data = isPlainRecord(value) ? value : {};
   if (!isPlainRecord(value)) errors.push("index export must be an object");
@@ -10849,6 +10658,9 @@ function validateAiwgFortemiIndexExport(value) {
     if (!isSupportedRecordSchemaVersion(item.schema_version)) {
       errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1 or aiwg.fortemi.index.record.v2");
     }
+    if (data.schema_version === "aiwg.fortemi.index.export.v1" && item.schema_version === "aiwg.fortemi.index.record.v2") {
+      errors.push("items[" + index + "].schema_version must match aiwg.fortemi.index.export.v1");
+    }
     if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
     if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
     if (hasString(item.id)) ids.add(item.id);
@@ -10956,6 +10768,33 @@ function assertAiwgFortemiChunkManifest(value) {
   }
   return value;
 }
+function validateProjectedRecordShape(item, index, errors) {
+  const at = "items[" + index + "]";
+  if (!item.privacy || !isPlainRecord(item.privacy)) {
+    errors.push(at + "/privacy requires classification and pii");
+  } else {
+    if (!isPrivacyClassification(item.privacy.classification)) {
+      errors.push(at + "/privacy/classification must be one of private, sanitized, public");
+    }
+    if (typeof item.privacy.pii !== "boolean") {
+      errors.push(at + "/privacy/pii must be boolean");
+    }
+  }
+  if (Array.isArray(item.provenance)) {
+    for (const [provIndex, prov] of item.provenance.entries()) {
+      if (!isPlainRecord(prov)) {
+        errors.push(at + "/provenance/" + provIndex + " must be an object");
+        continue;
+      }
+      if (!isProvenanceConfidence(prov.confidence)) {
+        errors.push(at + "/provenance/" + provIndex + "/confidence must be one of source, candidate, reviewed, rejected");
+      }
+      if (!isPrivacyClassification(prov.privacy)) {
+        errors.push(at + "/provenance/" + provIndex + "/privacy must be one of private, sanitized, public");
+      }
+    }
+  }
+}
 function validateProjectedRecords(items, sourceSchemaVersion) {
   const errors = [];
   const ids = /* @__PURE__ */ new Set();
@@ -10965,8 +10804,7 @@ function validateProjectedRecords(items, sourceSchemaVersion) {
       errors.push("items[" + index + "] must be an object");
       continue;
     }
-    const schemaValidation = validateAiwgFortemiProjectedRecordSchema(item);
-    errors.push(...schemaValidation.errors.map((error) => `items[${index}]${error}`));
+    validateProjectedRecordShape(item, index, errors);
     const expectedRecordVersion = sourceSchemaVersion === "aiwg.fortemi.index.export.v2" ? "aiwg.fortemi.index.record.v2" : "aiwg.fortemi.index.record.v1";
     if (item.schema_version !== expectedRecordVersion) {
       errors.push(`items[${index}].schema_version must match ${sourceSchemaVersion}`);
@@ -11130,6 +10968,137 @@ function generatedAtString(value) {
   if (value instanceof Date) return value.toISOString();
   return value ?? (/* @__PURE__ */ new Date()).toISOString();
 }
+var SHA256_K = [
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+];
+function rotr(value, bits) {
+  return value >>> bits | value << 32 - bits;
+}
+function sha256Hex2(data) {
+  const bitLength = data.length * 8;
+  const padded = new Uint8Array(data.length + 9 + 63 >> 6 << 6);
+  padded.set(data);
+  padded[data.length] = 128;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 4, bitLength >>> 0);
+  view.setUint32(padded.length - 8, Math.floor(bitLength / 4294967296));
+  let h0 = 1779033703;
+  let h1 = 3144134277;
+  let h2 = 1013904242;
+  let h3 = 2773480762;
+  let h4 = 1359893119;
+  let h5 = 2600822924;
+  let h6 = 528734635;
+  let h7 = 1541459225;
+  const w = new Uint32Array(64);
+  for (let offset = 0; offset < padded.length; offset += 64) {
+    for (let i = 0; i < 16; i++) w[i] = view.getUint32(offset + i * 4);
+    for (let i = 16; i < 64; i++) {
+      const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ w[i - 15] >>> 3;
+      const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ w[i - 2] >>> 10;
+      w[i] = w[i - 16] + s0 + w[i - 7] + s1 >>> 0;
+    }
+    let a = h0;
+    let b = h1;
+    let c = h2;
+    let d = h3;
+    let e = h4;
+    let f = h5;
+    let g = h6;
+    let h = h7;
+    for (let i = 0; i < 64; i++) {
+      const s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+      const ch = e & f ^ ~e & g;
+      const temp1 = h + s1 + ch + SHA256_K[i] + w[i] >>> 0;
+      const s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+      const maj = a & b ^ a & c ^ b & c;
+      const temp2 = s0 + maj >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temp1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temp1 + temp2 >>> 0;
+    }
+    h0 = h0 + a >>> 0;
+    h1 = h1 + b >>> 0;
+    h2 = h2 + c >>> 0;
+    h3 = h3 + d >>> 0;
+    h4 = h4 + e >>> 0;
+    h5 = h5 + f >>> 0;
+    h6 = h6 + g >>> 0;
+    h7 = h7 + h >>> 0;
+  }
+  return [h0, h1, h2, h3, h4, h5, h6, h7].map((part) => part.toString(16).padStart(8, "0")).join("");
+}
+function computeAiwgIndexHash(data) {
+  return `sha256:${sha256Hex2(data)}`;
+}
 async function buildAiwgStaticEmbeddingSet(index, options) {
   assertAiwgFortemiIndexExport(index);
   const granularity = options.granularity ?? "body";
@@ -11145,7 +11114,7 @@ async function buildAiwgStaticEmbeddingSet(index, options) {
       record_id: record.id,
       embedding,
       granularity,
-      input_hash: computeHash(new TextEncoder().encode(input)),
+      input_hash: computeAiwgIndexHash(new TextEncoder().encode(input)),
       source_path: record.source.path
     });
   }
@@ -11891,327 +11860,1867 @@ async function recordsFromChunkedRuntime(runtime, onProgress) {
       records.push(item.relationships ? item : await getChunkRecord(runtime, item.id));
     }
   }
-  return { records, scannedParts, fetchedParts };
-}
-async function relationshipResultFromChunkedRuntime(runtime, options = {}) {
-  const loaded = await recordsFromChunkedRuntime(runtime);
-  return {
-    ...relationshipResultFromRecords(loaded.records, options),
-    scannedParts: loaded.scannedParts,
-    fetchedParts: loaded.fetchedParts
-  };
+  return { records, scannedParts, fetchedParts };
+}
+async function relationshipResultFromChunkedRuntime(runtime, options = {}) {
+  const loaded = await recordsFromChunkedRuntime(runtime);
+  return {
+    ...relationshipResultFromRecords(loaded.records, options),
+    scannedParts: loaded.scannedParts,
+    fetchedParts: loaded.fetchedParts
+  };
+}
+async function queryChunkedAiwgFortemiIndex(runtime, query = "", options = {}) {
+  const q = query.trim().toLowerCase();
+  let scannedParts = 0;
+  let fetchedParts = 0;
+  if (isDirectChunkBrowse(query, options)) {
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? runtime.manifest.total;
+    const parts = getPartsForRange(runtime.manifest, offset, limit);
+    const items = [];
+    for (const partRef of parts) {
+      const loaded = await loadChunkPart(runtime, partRef);
+      if (loaded.fetched) fetchedParts += 1;
+      scannedParts += 1;
+      options.onProgress?.({ phase: "part", done: scannedParts, total: parts.length, href: partRef.href });
+      const start = Math.max(0, offset - partRef.offset);
+      const end = Math.min(loaded.part.items.length, offset + limit - partRef.offset);
+      items.push(...loaded.part.items.slice(start, end));
+    }
+    return {
+      items,
+      total: runtime.manifest.total,
+      facets: runtime.manifest.facets ?? {},
+      manifestTotal: runtime.manifest.total,
+      scannedParts,
+      fetchedParts,
+      complete: true
+    };
+  }
+  const matchKey = matchSetCacheKey(q, options);
+  const cached = runtime.matchCache.get(matchKey);
+  if (cached) {
+    runtime.matchCache.delete(matchKey);
+    runtime.matchCache.set(matchKey, cached);
+    return {
+      ...createQueryResultFromRankedEntries(cached, q, options),
+      manifestTotal: runtime.manifest.total,
+      scannedParts: 0,
+      fetchedParts: 0,
+      complete: true
+    };
+  }
+  const entries = [];
+  for (const partRef of runtime.manifest.parts) {
+    const loaded = await loadChunkPart(runtime, partRef);
+    if (loaded.fetched) fetchedParts += 1;
+    scannedParts += 1;
+    options.onProgress?.({ phase: "part", done: scannedParts, total: runtime.manifest.parts.length, href: partRef.href });
+    entries.push(...createRankedEntries(loaded.part.items, q, options, partRef.offset));
+    options.onProgress?.({ phase: "query", done: scannedParts, total: runtime.manifest.parts.length, href: partRef.href });
+  }
+  cacheMatchEntries(runtime, matchKey, entries);
+  return {
+    ...createQueryResultFromRankedEntries(entries, q, options),
+    manifestTotal: runtime.manifest.total,
+    scannedParts,
+    fetchedParts,
+    complete: true
+  };
+}
+function createAiwgReviewDecisionExport(source, decisions, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    schema_version: "aiwg.fortemi.review-decisions.v1",
+    generated_at: generatedAt,
+    source_export_schema_version: source.schema_version,
+    decisions: [...decisions].sort((left, right) => left.item_id.localeCompare(right.item_id))
+  };
+}
+function createAiwgIndexController(initialIndex) {
+  let index = initialIndex ?? null;
+  let chunked = null;
+  let data = null;
+  let error = null;
+  let reviewDecisions = [];
+  const listeners = /* @__PURE__ */ new Set();
+  const snapshot = () => ({
+    index,
+    chunked: chunked ? {
+      manifest: chunked.manifest,
+      cachedParts: chunked.partCache.size,
+      maxCachedParts: chunked.maxCachedParts
+    } : null,
+    data,
+    error,
+    reviewDecisions: [...reviewDecisions]
+  });
+  const notify = () => {
+    const current = snapshot();
+    for (const listener of listeners) listener(current);
+  };
+  const requireIndex = () => {
+    if (!index) throw new Error("No AIWG index export loaded");
+    return index;
+  };
+  return {
+    loadIndex(value) {
+      try {
+        const parsed = assertAiwgFortemiIndexExport(value);
+        index = parsed;
+        chunked = null;
+        data = null;
+        reviewDecisions = [];
+        error = null;
+        notify();
+        return parsed;
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    loadChunkedIndex(manifest, loader, options = {}) {
+      try {
+        const parsed = assertAiwgFortemiChunkManifest(manifest);
+        index = null;
+        chunked = {
+          manifest: parsed,
+          loader,
+          maxCachedParts: clampMaxCachedParts(options.maxCachedParts),
+          partCache: /* @__PURE__ */ new Map(),
+          detailLoader: options.detailLoader,
+          maxCachedDetails: clampMaxCachedDetails(options.maxCachedDetails),
+          detailCache: /* @__PURE__ */ new Map(),
+          maxCachedMatches: clampMaxCachedMatches(options.maxCachedMatches),
+          matchCache: /* @__PURE__ */ new Map()
+        };
+        data = null;
+        reviewDecisions = [];
+        error = null;
+        notify();
+        return parsed;
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    getIndex() {
+      return index;
+    },
+    getChunkedManifest() {
+      return chunked?.manifest ?? null;
+    },
+    getSnapshot() {
+      return snapshot();
+    },
+    query(query = "", options) {
+      const result = queryAiwgFortemiIndex(requireIndex(), query, options);
+      data = result;
+      error = null;
+      notify();
+      return result;
+    },
+    async queryChunked(query = "", options) {
+      if (!chunked) throw new Error("No AIWG chunked index manifest loaded");
+      try {
+        const result = await queryChunkedAiwgFortemiIndex(chunked, query, options);
+        data = result;
+        error = null;
+        notify();
+        return result;
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    async getRecord(id) {
+      if (chunked) {
+        try {
+          return await getChunkRecord(chunked, id);
+        } catch (err) {
+          error = err instanceof Error ? err : new Error(String(err));
+          notify();
+          throw error;
+        }
+      }
+      const found = requireIndex().items.find((item) => item.id === id);
+      if (!found) throw new Error("Record not found: " + id);
+      return found;
+    },
+    async neighbors(id, options) {
+      try {
+        const queryOptions = neighborQueryOptions(id, options);
+        const result = chunked ? await relationshipResultFromChunkedRuntime(chunked, queryOptions) : relationshipResultFromRecords(requireIndex().items, queryOptions);
+        return filterNeighborResult(id, result, options);
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    async relationshipQuery(options) {
+      try {
+        return chunked ? await relationshipResultFromChunkedRuntime(chunked, options) : relationshipResultFromRecords(requireIndex().items, options);
+      } catch (err) {
+        error = err instanceof Error ? err : new Error(String(err));
+        notify();
+        throw error;
+      }
+    },
+    async relationshipSet(options) {
+      const [left, right] = await Promise.all([
+        this.neighbors(options.a, options),
+        this.neighbors(options.b, options)
+      ]);
+      const leftIds = new Set(left.nodes.map((node) => node.id).filter((id) => id !== options.a));
+      const rightIds = new Set(right.nodes.map((node) => node.id).filter((id) => id !== options.b));
+      let ids;
+      if (options.op === "intersection") ids = [...leftIds].filter((id) => rightIds.has(id));
+      else if (options.op === "difference") ids = [...leftIds].filter((id) => !rightIds.has(id));
+      else ids = [.../* @__PURE__ */ new Set([...leftIds, ...rightIds])];
+      return { op: options.op, ids: ids.sort() };
+    },
+    clearChunkCache() {
+      chunked?.partCache.clear();
+      chunked?.detailCache.clear();
+      chunked?.matchCache.clear();
+      error = null;
+      notify();
+    },
+    toCommunityGraph(options) {
+      return aiwgFortemiIndexToCommunityGraph(requireIndex(), options);
+    },
+    async toCommunityGraphChunked(options) {
+      if (!chunked) return aiwgFortemiIndexToCommunityGraph(requireIndex(), options);
+      const loaded = await recordsFromChunkedRuntime(chunked, options?.onProgress);
+      return aiwgFortemiIndexToCommunityGraph({
+        generated_at: chunked.manifest.generated_at,
+        source: chunked.manifest.source,
+        items: loaded.records
+      }, options);
+    },
+    setReviewDecision(input) {
+      const decision = {
+        ...input,
+        updated_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      reviewDecisions = [
+        ...reviewDecisions.filter((item) => item.item_id !== decision.item_id),
+        decision
+      ].sort((left, right) => left.item_id.localeCompare(right.item_id));
+      error = null;
+      notify();
+      return decision;
+    },
+    clearReviewDecision(itemId) {
+      reviewDecisions = reviewDecisions.filter((item) => item.item_id !== itemId);
+      error = null;
+      notify();
+    },
+    createReviewDecisionExport(generatedAt) {
+      const source = index ?? (chunked ? { schema_version: chunked.manifest.source_export_schema_version ?? "aiwg.fortemi.index.export.v1" } : null);
+      if (!source) throw new Error("No AIWG index export or chunked manifest loaded");
+      return createAiwgReviewDecisionExport(source, reviewDecisions, generatedAt);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+}
+function aiwgFortemiIndexToCommunityGraph(index, options = {}) {
+  const ids = new Set(index.items.map((item) => item.id));
+  const relationshipWeights = options.relationshipWeights ?? /* @__PURE__ */ Object.create(null);
+  const edgeCounts = /* @__PURE__ */ new Map();
+  for (const item of index.items) {
+    for (const relationship of item.relationships) {
+      if (!ids.has(relationship.target_id) && !options.includeDanglingRelationships) continue;
+      const kind = relationship.type;
+      const configuredWeight = Object.prototype.hasOwnProperty.call(relationshipWeights, kind) ? relationshipWeights[kind] : void 0;
+      const baseWeight = typeof configuredWeight === "number" && Number.isFinite(configuredWeight) ? configuredWeight : 1;
+      const key = `${item.id}\0${relationship.target_id}\0${kind}`;
+      const existing = edgeCounts.get(key);
+      if (existing) existing.weight += baseWeight;
+      else edgeCounts.set(key, { source: item.id, target: relationship.target_id, kind, weight: baseWeight });
+    }
+  }
+  const communities = /* @__PURE__ */ new Map();
+  for (const item of index.items) {
+    const communityIds = communityIdsFor(item, options);
+    for (const communityId of communityIds) {
+      const nodes = communities.get(communityId) ?? [];
+      nodes.push(item.id);
+      communities.set(communityId, nodes);
+    }
+  }
+  return {
+    nodes: index.items.map((item) => ({ id: item.id })),
+    edges: Array.from(edgeCounts.values()).sort((left, right) => left.source.localeCompare(right.source) || left.target.localeCompare(right.target) || left.kind.localeCompare(right.kind)),
+    communities: Array.from(communities.entries()).map(([id, nodes]) => ({ id, nodes: [...new Set(nodes)].sort() })).sort((left, right) => left.id.localeCompare(right.id))
+  };
+}
+function communityIdsFor(item, options) {
+  if (options.communityFacet) {
+    const values = item.facets[options.communityFacet] ?? [];
+    if (values.length > 0) return values.map((value) => `${options.communityFacet}:${value}`);
+  }
+  if (options.communityTagPrefix) {
+    const prefix = options.communityTagPrefix;
+    const tags = item.tags.filter((tag) => tag.startsWith(prefix));
+    if (tags.length > 0) return tags;
+  }
+  if (item.concepts.length > 0) return item.concepts.map((concept) => `concept:${concept}`);
+  return [`type:${item.type}`];
+}
+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
+        },
+        privacy: {
+          $ref: "#/$defs/privacy"
+        },
+        graph: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    compatibility: {
+      type: "object",
+      additionalProperties: false,
+      required: ["previous_schema_version", "strategy"],
+      properties: {
+        previous_schema_version: {
+          const: "aiwg.fortemi.index.export.v1"
+        },
+        strategy: {
+          const: "supported"
+        }
+      }
+    },
+    items: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/record"
+      }
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          schema_version: {
+            const: "aiwg.fortemi.index.export.v1"
+          }
+        }
+      },
+      then: {
+        not: {
+          required: ["compatibility"]
+        },
+        properties: {
+          source: {
+            not: {
+              required: ["graph"]
+            }
+          },
+          items: {
+            items: {
+              allOf: [
+                {
+                  properties: {
+                    schema_version: {
+                      const: "aiwg.fortemi.index.record.v1"
+                    }
+                  }
+                },
+                {
+                  $ref: "#/$defs/v1RecordCompatibility"
+                }
+              ]
+            }
+          }
+        }
+      }
+    },
+    {
+      if: {
+        properties: {
+          schema_version: {
+            const: "aiwg.fortemi.index.export.v2"
+          }
+        }
+      },
+      then: {
+        required: ["compatibility"],
+        properties: {
+          source: {
+            required: ["graph"]
+          },
+          items: {
+            items: {
+              properties: {
+                schema_version: {
+                  const: "aiwg.fortemi.index.record.v2"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ],
+  $defs: {
+    privacy: {
+      enum: ["private", "sanitized", "public"]
+    },
+    recordType: {
+      type: "string",
+      minLength: 1
+    },
+    stringArray: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    numberArray: {
+      type: "array",
+      items: {
+        type: "number"
+      }
+    },
+    v1RecordCompatibility: {
+      type: "object",
+      not: {
+        anyOf: [
+          {
+            required: ["name"]
+          },
+          {
+            required: ["summary"]
+          },
+          {
+            required: ["search"]
+          },
+          {
+            required: ["chunks"]
+          },
+          {
+            required: ["embeddings"]
+          },
+          {
+            required: ["compatibility"]
+          },
+          {
+            required: ["skos_concepts"]
+          },
+          {
+            required: ["skos_relations"]
+          },
+          {
+            required: ["provenance_events"]
+          }
+        ]
+      },
+      properties: {
+        source: {
+          not: {
+            anyOf: [
+              {
+                required: ["origin"]
+              },
+              {
+                required: ["generated"]
+              },
+              {
+                required: ["checksum"]
+              },
+              {
+                required: ["updated_at"]
+              }
+            ]
+          }
+        },
+        relationships: {
+          items: {
+            not: {
+              anyOf: [
+                {
+                  required: ["target_path"]
+                },
+                {
+                  required: ["direction"]
+                },
+                {
+                  required: ["label"]
+                },
+                {
+                  required: ["confidence"]
+                },
+                {
+                  required: ["privacy"]
+                },
+                {
+                  required: ["metadata"]
+                }
+              ]
+            }
+          }
+        },
+        privacy: {
+          not: {
+            required: ["locality"]
+          }
+        }
+      }
+    },
+    record: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "schema_version",
+        "id",
+        "type",
+        "source",
+        "title",
+        "text",
+        "facets",
+        "tags",
+        "concepts",
+        "relationships",
+        "provenance",
+        "privacy",
+        "updated_at"
+      ],
+      properties: {
+        schema_version: {
+          enum: [
+            "aiwg.fortemi.index.record.v1",
+            "aiwg.fortemi.index.record.v2"
+          ]
+        },
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        type: {
+          $ref: "#/$defs/recordType"
+        },
+        source: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path", "repo_relative_path", "locator"],
+          properties: {
+            path: {
+              type: "string",
+              minLength: 1
+            },
+            repo_relative_path: {
+              type: "string",
+              minLength: 1
+            },
+            locator: {
+              type: "string",
+              minLength: 1
+            },
+            origin: {
+              type: "string",
+              minLength: 1
+            },
+            generated: {
+              type: "boolean"
+            },
+            checksum: {
+              type: "string"
+            },
+            updated_at: {
+              type: "string",
+              format: "date-time"
+            }
+          }
+        },
+        title: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        summary: {
+          type: "string"
+        },
+        text: {
+          type: "string"
+        },
+        search: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "title",
+            "body",
+            "triggers",
+            "aliases",
+            "tags",
+            "frontmatter"
+          ],
+          properties: {
+            title: {
+              type: "string"
+            },
+            name: {
+              type: "string"
+            },
+            summary: {
+              type: "string"
+            },
+            body: {
+              type: "string"
+            },
+            triggers: {
+              $ref: "#/$defs/stringArray"
+            },
+            aliases: {
+              $ref: "#/$defs/stringArray"
+            },
+            capability: {
+              type: "string"
+            },
+            tags: {
+              $ref: "#/$defs/stringArray"
+            },
+            phase: {
+              type: "string"
+            },
+            type: {
+              type: "string"
+            },
+            frontmatter: {
+              type: "object"
+            }
+          }
+        },
+        facets: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        },
+        tags: {
+          $ref: "#/$defs/stringArray"
+        },
+        concepts: {
+          $ref: "#/$defs/stringArray"
+        },
+        relationships: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "target_id"],
+            properties: {
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              target_id: {
+                type: "string",
+                minLength: 1
+              },
+              source_path: {
+                type: "string"
+              },
+              target_path: {
+                type: "string"
+              },
+              direction: {
+                enum: ["upstream", "downstream", "related"]
+              },
+              label: {
+                type: "string"
+              },
+              confidence: {
+                type: "number"
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        provenance: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["field", "source", "path", "confidence", "privacy"],
+            properties: {
+              field: {
+                type: "string",
+                minLength: 1
+              },
+              source: {
+                type: "string",
+                minLength: 1
+              },
+              path: {
+                type: "string",
+                minLength: 1
+              },
+              confidence: {
+                enum: ["source", "candidate", "reviewed", "rejected"]
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              }
+            }
+          }
+        },
+        privacy: {
+          type: "object",
+          additionalProperties: false,
+          required: ["classification", "pii"],
+          properties: {
+            classification: {
+              $ref: "#/$defs/privacy"
+            },
+            pii: {
+              type: "boolean"
+            },
+            locality: {
+              enum: ["project", "framework", "external"]
+            }
+          }
+        },
+        chunks: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              text: {
+                type: "string"
+              },
+              body: {
+                type: "string"
+              },
+              summary: {
+                type: "string"
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              },
+              checksum: {
+                type: "string"
+              }
+            }
+          }
+        },
+        embeddings: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              id: {
+                type: "string"
+              },
+              model: {
+                type: "string"
+              },
+              embedding: {
+                $ref: "#/$defs/numberArray"
+              },
+              vector: {
+                $ref: "#/$defs/numberArray"
+              },
+              granularity: {
+                type: "string"
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              },
+              chunk_id: {
+                type: "string"
+              },
+              vector_ref: {
+                type: "string"
+              },
+              input_hash: {
+                type: "string"
+              }
+            }
+          }
+        },
+        compatibility: {
+          type: "object"
+        },
+        skos_concepts: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "prefLabel"],
+            properties: {
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              prefLabel: {
+                type: "string",
+                minLength: 1
+              },
+              definition: {
+                type: "string"
+              },
+              scheme: {
+                type: "string"
+              },
+              notation: {
+                type: "string"
+              },
+              uri: {
+                type: "string"
+              },
+              altLabels: {
+                $ref: "#/$defs/stringArray"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        skos_relations: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "source_id", "target_id"],
+            properties: {
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              source_id: {
+                type: "string",
+                minLength: 1
+              },
+              target_id: {
+                type: "string",
+                minLength: 1
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        provenance_events: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["activity"],
+            properties: {
+              id: {
+                type: "string"
+              },
+              activity: {
+                type: "string",
+                minLength: 1
+              },
+              agent: {
+                type: "string"
+              },
+              started_at: {
+                type: "string",
+                format: "date-time"
+              },
+              ended_at: {
+                type: "string",
+                format: "date-time"
+              },
+              source: {
+                type: "string"
+              },
+              path: {
+                type: "string"
+              },
+              confidence: {
+                enum: ["source", "candidate", "reviewed", "rejected"]
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              },
+              attributes: {
+                type: "object"
+              }
+            }
+          }
+        },
+        updated_at: {
+          type: "string",
+          format: "date-time"
+        }
+      }
+    }
+  }
+};
+
+// src/aiwg-index-schema.ts
+var PROJECTED_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "title",
+  "text",
+  "facets",
+  "tags",
+  "concepts",
+  "privacy"
+];
+var ajvInstance2;
+var exportValidator;
+var projectedRecordValidator;
+function getAiwgFortemiIndexExportSchema() {
+  return aiwg_fortemi_index_export_schema_default;
 }
-async function queryChunkedAiwgFortemiIndex(runtime, query = "", options = {}) {
-  const q = query.trim().toLowerCase();
-  let scannedParts = 0;
-  let fetchedParts = 0;
-  if (isDirectChunkBrowse(query, options)) {
-    const offset = options.offset ?? 0;
-    const limit = options.limit ?? runtime.manifest.total;
-    const parts = getPartsForRange(runtime.manifest, offset, limit);
-    const items = [];
-    for (const partRef of parts) {
-      const loaded = await loadChunkPart(runtime, partRef);
-      if (loaded.fetched) fetchedParts += 1;
-      scannedParts += 1;
-      options.onProgress?.({ phase: "part", done: scannedParts, total: parts.length, href: partRef.href });
-      const start = Math.max(0, offset - partRef.offset);
-      const end = Math.min(loaded.part.items.length, offset + limit - partRef.offset);
-      items.push(...loaded.part.items.slice(start, end));
-    }
-    return {
-      items,
-      total: runtime.manifest.total,
-      facets: runtime.manifest.facets ?? {},
-      manifestTotal: runtime.manifest.total,
-      scannedParts,
-      fetchedParts,
-      complete: true
-    };
-  }
-  const matchKey = matchSetCacheKey(q, options);
-  const cached = runtime.matchCache.get(matchKey);
-  if (cached) {
-    runtime.matchCache.delete(matchKey);
-    runtime.matchCache.set(matchKey, cached);
-    return {
-      ...createQueryResultFromRankedEntries(cached, q, options),
-      manifestTotal: runtime.manifest.total,
-      scannedParts: 0,
-      fetchedParts: 0,
-      complete: true
-    };
-  }
-  const entries = [];
-  for (const partRef of runtime.manifest.parts) {
-    const loaded = await loadChunkPart(runtime, partRef);
-    if (loaded.fetched) fetchedParts += 1;
-    scannedParts += 1;
-    options.onProgress?.({ phase: "part", done: scannedParts, total: runtime.manifest.parts.length, href: partRef.href });
-    entries.push(...createRankedEntries(loaded.part.items, q, options, partRef.offset));
-    options.onProgress?.({ phase: "query", done: scannedParts, total: runtime.manifest.parts.length, href: partRef.href });
+function getAjv2() {
+  if (!ajvInstance2) {
+    ajvInstance2 = new Ajv2020({
+      allErrors: true,
+      strict: false,
+      validateFormats: false
+    });
+    ajvInstance2.addSchema(aiwg_fortemi_index_export_schema_default);
   }
-  cacheMatchEntries(runtime, matchKey, entries);
-  return {
-    ...createQueryResultFromRankedEntries(entries, q, options),
-    manifestTotal: runtime.manifest.total,
-    scannedParts,
-    fetchedParts,
-    complete: true
-  };
-}
-function createAiwgReviewDecisionExport(source, decisions, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  return {
-    schema_version: "aiwg.fortemi.review-decisions.v1",
-    generated_at: generatedAt,
-    source_export_schema_version: source.schema_version,
-    decisions: [...decisions].sort((left, right) => left.item_id.localeCompare(right.item_id))
-  };
+  return ajvInstance2;
 }
-function createAiwgIndexController(initialIndex) {
-  let index = initialIndex ?? null;
-  let chunked = null;
-  let data = null;
-  let error = null;
-  let reviewDecisions = [];
-  const listeners = /* @__PURE__ */ new Set();
-  const snapshot = () => ({
-    index,
-    chunked: chunked ? {
-      manifest: chunked.manifest,
-      cachedParts: chunked.partCache.size,
-      maxCachedParts: chunked.maxCachedParts
-    } : null,
-    data,
-    error,
-    reviewDecisions: [...reviewDecisions]
+function formatErrors2(errors) {
+  return (errors ?? []).map((error) => {
+    const path = error.instancePath || "(root)";
+    return `${path} ${error.message ?? "is invalid"}`;
   });
-  const notify = () => {
-    const current = snapshot();
-    for (const listener of listeners) listener(current);
-  };
-  const requireIndex = () => {
-    if (!index) throw new Error("No AIWG index export loaded");
-    return index;
-  };
-  return {
-    loadIndex(value) {
-      try {
-        const parsed = assertAiwgFortemiIndexExport(value);
-        index = parsed;
-        chunked = null;
-        data = null;
-        reviewDecisions = [];
-        error = null;
-        notify();
-        return parsed;
-      } catch (err) {
-        error = err instanceof Error ? err : new Error(String(err));
-        notify();
-        throw error;
-      }
-    },
-    loadChunkedIndex(manifest, loader, options = {}) {
-      try {
-        const parsed = assertAiwgFortemiChunkManifest(manifest);
-        index = null;
-        chunked = {
-          manifest: parsed,
-          loader,
-          maxCachedParts: clampMaxCachedParts(options.maxCachedParts),
-          partCache: /* @__PURE__ */ new Map(),
-          detailLoader: options.detailLoader,
-          maxCachedDetails: clampMaxCachedDetails(options.maxCachedDetails),
-          detailCache: /* @__PURE__ */ new Map(),
-          maxCachedMatches: clampMaxCachedMatches(options.maxCachedMatches),
-          matchCache: /* @__PURE__ */ new Map()
-        };
-        data = null;
-        reviewDecisions = [];
-        error = null;
-        notify();
-        return parsed;
-      } catch (err) {
-        error = err instanceof Error ? err : new Error(String(err));
-        notify();
-        throw error;
-      }
-    },
-    getIndex() {
-      return index;
-    },
-    getChunkedManifest() {
-      return chunked?.manifest ?? null;
-    },
-    getSnapshot() {
-      return snapshot();
-    },
-    query(query = "", options) {
-      const result = queryAiwgFortemiIndex(requireIndex(), query, options);
-      data = result;
-      error = null;
-      notify();
-      return result;
-    },
-    async queryChunked(query = "", options) {
-      if (!chunked) throw new Error("No AIWG chunked index manifest loaded");
-      try {
-        const result = await queryChunkedAiwgFortemiIndex(chunked, query, options);
-        data = result;
-        error = null;
-        notify();
-        return result;
-      } catch (err) {
-        error = err instanceof Error ? err : new Error(String(err));
-        notify();
-        throw error;
-      }
-    },
-    async getRecord(id) {
-      if (chunked) {
-        try {
-          return await getChunkRecord(chunked, id);
-        } catch (err) {
-          error = err instanceof Error ? err : new Error(String(err));
-          notify();
-          throw error;
+}
+function getExportValidator() {
+  exportValidator ??= getAjv2().getSchema(aiwg_fortemi_index_export_schema_default.$id) ?? getAjv2().compile(aiwg_fortemi_index_export_schema_default);
+  return exportValidator;
+}
+function getProjectedRecordValidator() {
+  if (!projectedRecordValidator) {
+    const properties = Object.fromEntries(Object.keys(aiwg_fortemi_index_export_schema_default.$defs.record.properties).map((field) => [
+      field,
+      { $ref: `${aiwg_fortemi_index_export_schema_default.$id}#/$defs/record/properties/${field}` }
+    ]));
+    projectedRecordValidator = getAjv2().compile({
+      type: "object",
+      required: PROJECTED_FIELDS,
+      properties,
+      additionalProperties: true,
+      allOf: [
+        {
+          if: {
+            properties: {
+              schema_version: { const: "aiwg.fortemi.index.record.v1" }
+            }
+          },
+          then: { $ref: `${aiwg_fortemi_index_export_schema_default.$id}#/$defs/v1RecordCompatibility` }
+        }
+      ]
+    });
+  }
+  return projectedRecordValidator;
+}
+function validateAiwgFortemiIndexExportSchema(value) {
+  const validate = getExportValidator();
+  const schemaValue = value && typeof value === "object" && Array.isArray(value.items) ? {
+    ...value,
+    items: value.items.map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+      const schemaRecord = { ...item };
+      Reflect.deleteProperty(schemaRecord, "binary_sources");
+      return schemaRecord;
+    })
+  } : value;
+  const valid = validate(schemaValue);
+  return { valid, errors: formatErrors2(validate.errors) };
+}
+function validateAiwgFortemiProjectedRecordSchema(value) {
+  const validate = getProjectedRecordValidator();
+  const valid = validate(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);
         }
-      }
-      const found = requireIndex().items.find((item) => item.id === id);
-      if (!found) throw new Error("Record not found: " + id);
-      return found;
-    },
-    async neighbors(id, options) {
-      try {
-        const queryOptions = neighborQueryOptions(id, options);
-        const result = chunked ? await relationshipResultFromChunkedRuntime(chunked, queryOptions) : relationshipResultFromRecords(requireIndex().items, queryOptions);
-        return filterNeighborResult(id, result, options);
-      } catch (err) {
-        error = err instanceof Error ? err : new Error(String(err));
-        notify();
-        throw error;
-      }
-    },
-    async relationshipQuery(options) {
-      try {
-        return chunked ? await relationshipResultFromChunkedRuntime(chunked, options) : relationshipResultFromRecords(requireIndex().items, options);
-      } catch (err) {
-        error = err instanceof Error ? err : new Error(String(err));
-        notify();
-        throw error;
-      }
-    },
-    async relationshipSet(options) {
-      const [left, right] = await Promise.all([
-        this.neighbors(options.a, options),
-        this.neighbors(options.b, options)
-      ]);
-      const leftIds = new Set(left.nodes.map((node) => node.id).filter((id) => id !== options.a));
-      const rightIds = new Set(right.nodes.map((node) => node.id).filter((id) => id !== options.b));
-      let ids;
-      if (options.op === "intersection") ids = [...leftIds].filter((id) => rightIds.has(id));
-      else if (options.op === "difference") ids = [...leftIds].filter((id) => !rightIds.has(id));
-      else ids = [.../* @__PURE__ */ new Set([...leftIds, ...rightIds])];
-      return { op: options.op, ids: ids.sort() };
-    },
-    clearChunkCache() {
-      chunked?.partCache.clear();
-      chunked?.detailCache.clear();
-      chunked?.matchCache.clear();
-      error = null;
-      notify();
-    },
-    toCommunityGraph(options) {
-      return aiwgFortemiIndexToCommunityGraph(requireIndex(), options);
-    },
-    async toCommunityGraphChunked(options) {
-      if (!chunked) return aiwgFortemiIndexToCommunityGraph(requireIndex(), options);
-      const loaded = await recordsFromChunkedRuntime(chunked, options?.onProgress);
-      return aiwgFortemiIndexToCommunityGraph({
-        generated_at: chunked.manifest.generated_at,
-        source: chunked.manifest.source,
-        items: loaded.records
-      }, options);
-    },
-    setReviewDecision(input) {
-      const decision = {
-        ...input,
-        updated_at: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      reviewDecisions = [
-        ...reviewDecisions.filter((item) => item.item_id !== decision.item_id),
-        decision
-      ].sort((left, right) => left.item_id.localeCompare(right.item_id));
-      error = null;
-      notify();
-      return decision;
-    },
-    clearReviewDecision(itemId) {
-      reviewDecisions = reviewDecisions.filter((item) => item.item_id !== itemId);
-      error = null;
-      notify();
-    },
-    createReviewDecisionExport(generatedAt) {
-      const source = index ?? (chunked ? { schema_version: chunked.manifest.source_export_schema_version ?? "aiwg.fortemi.index.export.v1" } : null);
-      if (!source) throw new Error("No AIWG index export or chunked manifest loaded");
-      return createAiwgReviewDecisionExport(source, reviewDecisions, generatedAt);
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
       };
+      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);
 }
-function aiwgFortemiIndexToCommunityGraph(index, options = {}) {
-  const ids = new Set(index.items.map((item) => item.id));
-  const relationshipWeights = options.relationshipWeights ?? /* @__PURE__ */ Object.create(null);
-  const edgeCounts = /* @__PURE__ */ new Map();
-  for (const item of index.items) {
-    for (const relationship of item.relationships) {
-      if (!ids.has(relationship.target_id) && !options.includeDanglingRelationships) continue;
-      const kind = relationship.type;
-      const configuredWeight = Object.prototype.hasOwnProperty.call(relationshipWeights, kind) ? relationshipWeights[kind] : void 0;
-      const baseWeight = typeof configuredWeight === "number" && Number.isFinite(configuredWeight) ? configuredWeight : 1;
-      const key = `${item.id}\0${relationship.target_id}\0${kind}`;
-      const existing = edgeCounts.get(key);
-      if (existing) existing.weight += baseWeight;
-      else edgeCounts.set(key, { source: item.id, target: relationship.target_id, kind, weight: baseWeight });
+
+// 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,
+      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);
   }
-  const communities = /* @__PURE__ */ new Map();
-  for (const item of index.items) {
-    const communityIds = communityIdsFor(item, options);
-    for (const communityId of communityIds) {
-      const nodes = communities.get(communityId) ?? [];
-      nodes.push(item.id);
-      communities.set(communityId, nodes);
+  /** 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;
   }
-  return {
-    nodes: index.items.map((item) => ({ id: item.id })),
-    edges: Array.from(edgeCounts.values()).sort((left, right) => left.source.localeCompare(right.source) || left.target.localeCompare(right.target) || left.kind.localeCompare(right.kind)),
-    communities: Array.from(communities.entries()).map(([id, nodes]) => ({ id, nodes: [...new Set(nodes)].sort() })).sort((left, right) => left.id.localeCompare(right.id))
-  };
+  // ── 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();
 }
-function communityIdsFor(item, options) {
-  if (options.communityFacet) {
-    const values = item.facets[options.communityFacet] ?? [];
-    if (values.length > 0) return values.map((value) => `${options.communityFacet}:${value}`);
+var CanonicalAttachmentsRepository = class {
+  constructor(store, blobStore) {
+    this.store = store;
+    this.blobStore = blobStore;
   }
-  if (options.communityTagPrefix) {
-    const prefix = options.communityTagPrefix;
-    const tags = item.tags.filter((tag) => tag.startsWith(prefix));
-    if (tags.length > 0) return tags;
+  /** 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;
   }
-  if (item.concepts.length > 0) return item.concepts.map((concept) => `concept:${concept}`);
-  return [`type:${item.type}`];
+  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/index.ts
-var VERSION = "2026.7.4";
+var VERSION = "2026.7.7";
 
-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, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, 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, isShardSigningSupported, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, migrateLegacyBlobStore, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, projectAttachments, 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