@fortemi/core 2026.7.7 → 2026.7.8

package/dist/index.js

@@ -6541,13 +6541,13 @@ var OpenAICompatibleProvider = class {
       throw new Error("Streaming not supported: response body is null");
     }
     const reader = response.body.getReader();
-    const decoder6 = new TextDecoder();
+    const decoder7 = new TextDecoder();
     let buffer = "";
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        buffer += decoder6.decode(value, { stream: true });
+        buffer += decoder7.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
@@ -13422,6 +13422,8 @@ var CanonicalNotesRepository = class {
     await this.store.put("note", {
       ...note,
       title: input.title !== void 0 ? input.title : note.title,
+      format: input.format ?? note.format,
+      visibility: input.visibility ?? note.visibility,
       is_starred: input.is_starred ?? note.is_starred,
       is_pinned: input.is_pinned ?? note.is_pinned,
       is_archived: input.is_archived ?? note.is_archived,
@@ -13718,9 +13720,797 @@ async function dropAttachmentProjection(db) {
   await db.query(`DELETE FROM attachment_blob`);
 }
 
+// src/records/record-projection.ts
+async function projectNotes(db, store) {
+  const [noteRows, originals, revised, tags, links, collections, memberships] = await Promise.all([
+    store.list("note"),
+    store.list("note_original"),
+    store.list("note_revised_current"),
+    store.list("note_tag"),
+    store.list("link"),
+    store.list("collection"),
+    store.list("collection_note")
+  ]);
+  for (const c of collections) {
+    await db.query(
+      `INSERT INTO collection (id, name, description, created_at, updated_at, deleted_at)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (id) DO UPDATE SET
+         name = EXCLUDED.name,
+         description = EXCLUDED.description,
+         updated_at = EXCLUDED.updated_at,
+         deleted_at = EXCLUDED.deleted_at`,
+      [c.id, c.name, c.description, c.created_at, c.updated_at, c.deleted_at]
+    );
+  }
+  for (const n of noteRows) {
+    await db.query(
+      `INSERT INTO note (
+         id, archive_id, title, format, source, visibility, revision_mode,
+         is_starred, is_pinned, is_archived, created_at, updated_at, deleted_at
+       )
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+       ON CONFLICT (id) DO UPDATE SET
+         archive_id = EXCLUDED.archive_id,
+         title = EXCLUDED.title,
+         format = EXCLUDED.format,
+         source = EXCLUDED.source,
+         visibility = EXCLUDED.visibility,
+         revision_mode = EXCLUDED.revision_mode,
+         is_starred = EXCLUDED.is_starred,
+         is_pinned = EXCLUDED.is_pinned,
+         is_archived = EXCLUDED.is_archived,
+         updated_at = EXCLUDED.updated_at,
+         deleted_at = EXCLUDED.deleted_at`,
+      [
+        n.id,
+        n.archive_id,
+        n.title,
+        n.format,
+        n.source,
+        n.visibility,
+        n.revision_mode,
+        n.is_starred,
+        n.is_pinned,
+        n.is_archived,
+        n.created_at,
+        n.updated_at,
+        n.deleted_at
+      ]
+    );
+  }
+  for (const o of originals) {
+    await db.query(
+      `INSERT INTO note_original (id, note_id, content, content_hash, created_at)
+       VALUES ($1, $2, $3, $4, $5)
+       ON CONFLICT (id) DO UPDATE SET
+         content = EXCLUDED.content,
+         content_hash = EXCLUDED.content_hash`,
+      [o.id, o.note_id, o.content, o.content_hash, o.created_at]
+    );
+  }
+  for (const r of revised) {
+    await db.query(
+      `INSERT INTO note_revised_current (
+         note_id, content, ai_metadata, generation_count, model, is_user_edited, updated_at
+       )
+       VALUES ($1, $2, $3::jsonb, $4, $5, $6, $7)
+       ON CONFLICT (note_id) DO UPDATE SET
+         content = EXCLUDED.content,
+         ai_metadata = EXCLUDED.ai_metadata,
+         generation_count = EXCLUDED.generation_count,
+         model = EXCLUDED.model,
+         is_user_edited = EXCLUDED.is_user_edited,
+         updated_at = EXCLUDED.updated_at`,
+      [
+        r.id,
+        r.content,
+        r.ai_metadata == null ? null : JSON.stringify(r.ai_metadata),
+        r.generation_count,
+        r.model,
+        r.is_user_edited,
+        r.updated_at
+      ]
+    );
+  }
+  for (const t of tags) {
+    await db.query(
+      `INSERT INTO note_tag (id, note_id, tag, created_at)
+       VALUES ($1, $2, $3, $4)
+       ON CONFLICT (note_id, tag) DO NOTHING`,
+      [t.id, t.note_id, t.tag, t.created_at]
+    );
+  }
+  await db.query(
+    `DELETE FROM note_tag WHERE NOT (id = ANY($1::text[]))`,
+    [tags.map((t) => t.id)]
+  );
+  for (const l of links) {
+    await db.query(
+      `INSERT INTO link (id, source_note_id, target_note_id, link_type, created_at, deleted_at)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       ON CONFLICT (id) DO UPDATE SET
+         link_type = EXCLUDED.link_type,
+         deleted_at = EXCLUDED.deleted_at`,
+      [l.id, l.source_note_id, l.target_note_id, l.link_type, l.created_at, l.deleted_at]
+    );
+  }
+  for (const m of memberships) {
+    await db.query(
+      `INSERT INTO collection_note (collection_id, note_id, position, added_at)
+       VALUES ($1, $2, 0, $3)
+       ON CONFLICT (collection_id, note_id) DO NOTHING`,
+      [m.collection_id, m.note_id, m.created_at]
+    );
+  }
+  await db.query(
+    `DELETE FROM collection_note WHERE NOT ((collection_id || ':' || note_id) = ANY($1::text[]))`,
+    [memberships.map((m) => `${m.collection_id}:${m.note_id}`)]
+  );
+  return {
+    notes: noteRows.length,
+    tags: tags.length,
+    links: links.length,
+    collections: collections.length,
+    memberships: memberships.length
+  };
+}
+async function projectRecords(db, store) {
+  const notes = await projectNotes(db, store);
+  const attachments = await projectAttachments(db, store);
+  return { ...notes, attachments };
+}
+async function dropNoteProjection(db) {
+  await db.query(`DELETE FROM collection_note`);
+  await db.query(`DELETE FROM note_tag`);
+  await db.query(`DELETE FROM link`);
+  await db.query(`DELETE FROM note_revised_current`);
+  await db.query(`DELETE FROM note_revision`);
+  await db.query(`DELETE FROM note_original`);
+  await db.query(`DELETE FROM job_queue`);
+  await db.query(`DELETE FROM note`);
+  await db.query(`DELETE FROM collection`);
+}
+
+// src/records/record-backend.ts
+function noteToBackend(n, tags) {
+  return {
+    id: n.id,
+    title: n.title,
+    tags,
+    createdAt: n.created_at,
+    updatedAt: n.updated_at,
+    source: n.source,
+    starred: n.is_starred,
+    archived: n.is_archived
+  };
+}
+function linkToBackend2(link) {
+  return {
+    id: link.id,
+    fromNoteId: link.source_note_id,
+    toNoteId: link.target_note_id,
+    kind: link.link_type,
+    score: null,
+    createdAt: link.created_at
+  };
+}
+function createRecordBackend(store, options = {}) {
+  const notes = new CanonicalNotesRepository(store);
+  async function tagsByNote() {
+    const map = /* @__PURE__ */ new Map();
+    for (const row of await store.list("note_tag")) {
+      const tags = map.get(row.note_id) ?? [];
+      tags.push(row.tag);
+      map.set(row.note_id, tags);
+    }
+    for (const tags of map.values()) tags.sort();
+    return map;
+  }
+  return {
+    id: options.id ?? "canonical-records",
+    capabilities: {
+      read: true,
+      write: true,
+      merge: true,
+      // via importShardToRecords (record-shard.ts)
+      multiUser: false,
+      semantic: "none",
+      startupCost: "instant"
+    },
+    async listNotes(o) {
+      const all = (await store.list("note")).filter((n) => n.deleted_at === null);
+      all.sort((a, b) => b.updated_at.localeCompare(a.updated_at));
+      const offset = o?.offset ?? 0;
+      const limit = o?.limit ?? 50;
+      const tags = await tagsByNote();
+      return {
+        items: all.slice(offset, offset + limit).map((n) => noteToBackend(n, tags.get(n.id) ?? [])),
+        total: all.length
+      };
+    },
+    async getNote(id) {
+      const view = await notes.get(id);
+      if (!view || view.note.deleted_at !== null) return null;
+      return noteToBackend(view.note, view.tags);
+    },
+    async search(query, o) {
+      const offset = o?.offset ?? 0;
+      const limit = o?.limit ?? 20;
+      let matched = await notes.searchText(query, offset + limit);
+      if (o?.tags?.length) {
+        const tags2 = await tagsByNote();
+        matched = matched.filter((n) => o.tags.every((t) => (tags2.get(n.id) ?? []).includes(t)));
+      }
+      if (o?.source?.length) {
+        matched = matched.filter((n) => o.source.includes(n.source));
+      }
+      const tags = await tagsByNote();
+      const hits = matched.slice(offset, offset + limit).map((n) => ({ note: noteToBackend(n, tags.get(n.id) ?? []) }));
+      return { hits, total: matched.length };
+    },
+    async getNoteFull(id) {
+      const view = await notes.get(id);
+      if (!view || view.note.deleted_at !== null) return null;
+      return {
+        ...noteToBackend(view.note, view.tags),
+        content: view.revised_content,
+        links: (await notes.linksOf(id)).map(linkToBackend2)
+      };
+    },
+    async linksOf(id) {
+      return (await notes.linksOf(id)).map(linkToBackend2);
+    },
+    async manageNote(input) {
+      const parsed = ManageNoteInputSchema.parse(input);
+      switch (parsed.action) {
+        case "update": {
+          const note = await notes.update(parsed.note_id, {
+            title: parsed.title,
+            content: parsed.content,
+            format: parsed.format,
+            visibility: parsed.visibility
+          });
+          return { action: "update", note_id: parsed.note_id, note };
+        }
+        case "delete":
+          await notes.softDelete(parsed.note_id);
+          return { action: "delete", note_id: parsed.note_id };
+        case "restore": {
+          await notes.restore(parsed.note_id);
+          return { action: "restore", note_id: parsed.note_id, note: await notes.get(parsed.note_id) };
+        }
+        case "archive": {
+          const note = await notes.update(parsed.note_id, { is_archived: true });
+          return { action: "archive", note_id: parsed.note_id, note };
+        }
+        case "unarchive": {
+          const note = await notes.update(parsed.note_id, { is_archived: false });
+          return { action: "unarchive", note_id: parsed.note_id, note };
+        }
+        case "star": {
+          const note = await notes.update(parsed.note_id, { is_starred: true });
+          return { action: "star", note_id: parsed.note_id, note };
+        }
+        case "unstar": {
+          const note = await notes.update(parsed.note_id, { is_starred: false });
+          return { action: "unstar", note_id: parsed.note_id, note };
+        }
+      }
+    }
+  };
+}
+
+// src/records/record-shard.ts
+var encoder2 = new TextEncoder();
+var decoder6 = new TextDecoder();
+function emptyCounts() {
+  return {
+    notes: 0,
+    collections: 0,
+    templates: 0,
+    tags: 0,
+    links: 0,
+    embedding_sets: 0,
+    embedding_configs: 0,
+    embedding_set_members: 0,
+    embeddings: 0,
+    skos_schemes: 0,
+    skos_concepts: 0,
+    skos_relations: 0,
+    note_skos_tags: 0,
+    provenance_edges: 0,
+    graph_sources: 0,
+    graph_edges: 0,
+    community_sets: 0,
+    communities: 0,
+    community_assignments: 0
+  };
+}
+async function exportShardFromRecords(store, options) {
+  const files = /* @__PURE__ */ new Map();
+  const components = [];
+  const counts = {};
+  const [allNotes, originals, revisedRows, tagRows, collections, memberships, attachments, blobs] = await Promise.all([
+    store.list("note"),
+    store.list("note_original"),
+    store.list("note_revised_current"),
+    store.list("note_tag"),
+    store.list("collection"),
+    store.list("collection_note"),
+    store.list("attachment"),
+    store.list("attachment_blob")
+  ]);
+  const originalByNote = new Map(originals.map((o) => [o.note_id, o]));
+  const revisedByNote = new Map(revisedRows.map((r) => [r.id, r]));
+  const blobById = new Map(blobs.map((b) => [b.id, b]));
+  const tagsByNote = /* @__PURE__ */ new Map();
+  for (const row of [...tagRows].sort((a, b) => a.tag.localeCompare(b.tag))) {
+    const tags = tagsByNote.get(row.note_id) ?? [];
+    tags.push(row.tag);
+    tagsByNote.set(row.note_id, tags);
+  }
+  const collectionByNote = /* @__PURE__ */ new Map();
+  for (const m of [...memberships].sort((a, b) => a.created_at.localeCompare(b.created_at))) {
+    if (!collectionByNote.has(m.note_id)) collectionByNote.set(m.note_id, m.collection_id);
+  }
+  const membershipNoteIds = /* @__PURE__ */ new Map();
+  for (const m of memberships) {
+    const set = membershipNoteIds.get(m.collection_id) ?? /* @__PURE__ */ new Set();
+    set.add(m.note_id);
+    membershipNoteIds.set(m.collection_id, set);
+  }
+  let notes = allNotes.filter((n) => n.deleted_at === null);
+  if (options?.collectionId) {
+    const inCollection = membershipNoteIds.get(options.collectionId) ?? /* @__PURE__ */ new Set();
+    notes = notes.filter((n) => inCollection.has(n.id));
+  } else if (options?.tag) {
+    notes = notes.filter((n) => tagsByNote.get(n.id)?.includes(options.tag));
+  }
+  notes.sort((a, b) => a.created_at.localeCompare(b.created_at));
+  const liveAttachments = attachments.filter((a) => a.deleted_at === null).sort((a, b) => a.position - b.position || a.created_at.localeCompare(b.created_at));
+  const attachmentsByNote = /* @__PURE__ */ new Map();
+  const exportedBlobChecksums = [];
+  for (const att of liveAttachments) {
+    const blob = blobById.get(att.blob_id);
+    if (!blob) continue;
+    const projection = {
+      extracted_text: att.extracted_text,
+      attachment: {
+        // `path` is the display filename per the binary-attachment projection
+        // contract — never a physical storage key.
+        id: att.id,
+        path: att.filename,
+        mime: att.mime_type,
+        checksum: blob.content_hash,
+        bytes: blob.size_bytes
+      }
+    };
+    const list = attachmentsByNote.get(att.note_id) ?? [];
+    list.push(projection);
+    attachmentsByNote.set(att.note_id, list);
+    exportedBlobChecksums.push(blob.content_hash);
+  }
+  const browserNotes = notes.map((n) => {
+    const revised = revisedByNote.get(n.id);
+    return {
+      id: n.id,
+      title: n.title,
+      format: n.format,
+      source: n.source,
+      is_starred: n.is_starred,
+      is_archived: n.is_archived,
+      created_at: n.created_at,
+      updated_at: n.updated_at,
+      deleted_at: n.deleted_at,
+      original_content: originalByNote.get(n.id)?.content ?? "",
+      revised_content: revised?.content ?? null,
+      ai_metadata: revised?.ai_metadata ?? null,
+      collection_id: collectionByNote.get(n.id) ?? null,
+      attachments: attachmentsByNote.get(n.id),
+      tags: tagsByNote.get(n.id) ?? []
+    };
+  });
+  const exportedNoteIds = new Set(browserNotes.map((n) => n.id));
+  const shardNotes = browserNotes.map((n) => noteToShard(n));
+  let layout;
+  const clusterSize = options?.clusterNotesSize;
+  if (clusterSize && Number.isInteger(clusterSize) && clusterSize > 0 && shardNotes.length > 0) {
+    const clusters = [];
+    for (let offset = 0; offset < shardNotes.length; offset += clusterSize) {
+      const slice = shardNotes.slice(offset, offset + clusterSize);
+      const href = `notes/${String(offset).padStart(6, "0")}.jsonl`;
+      clusters.push({ href, offset });
+      files.set(href, encoder2.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
+    }
+    layout = { clusters: { notes: clusters } };
+  } else {
+    files.set("notes.jsonl", encoder2.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
+  }
+  components.push("notes");
+  counts.notes = shardNotes.length;
+  const liveCollections = collections.filter((c) => c.deleted_at === null).sort((a, b) => a.name.localeCompare(b.name));
+  const shardCollections = liveCollections.map(
+    (c) => collectionToShard(
+      // Canonical collections are flat (no parent hierarchy yet).
+      { id: c.id, name: c.name, description: c.description, parent_id: null, created_at: c.created_at },
+      membershipNoteIds.get(c.id)?.size ?? 0
+    )
+  );
+  files.set("collections.json", encoder2.encode(JSON.stringify(shardCollections)));
+  components.push("collections");
+  counts.collections = shardCollections.length;
+  const distinctTags = [...new Set(
+    tagRows.filter((t) => exportedNoteIds.has(t.note_id) || !options?.collectionId && !options?.tag).map((t) => t.tag)
+  )].sort();
+  const shardTags = tagsToShard(distinctTags.map((name) => ({ name, created_at: /* @__PURE__ */ new Date() })));
+  files.set("tags.json", encoder2.encode(JSON.stringify(shardTags)));
+  components.push("tags");
+  counts.tags = shardTags.length;
+  const links = await store.list("link");
+  const isFiltered = !!(options?.collectionId || options?.tag);
+  const shardLinks = links.filter((l) => l.deleted_at === null).filter((l) => !isFiltered || exportedNoteIds.has(l.source_note_id) && exportedNoteIds.has(l.target_note_id)).sort((a, b) => a.created_at.localeCompare(b.created_at)).map((l) => linkToShard({
+    id: l.id,
+    source_note_id: l.source_note_id,
+    target_note_id: l.target_note_id,
+    link_type: l.link_type,
+    // Canonical links carry no confidence score (PGlite-tier column).
+    confidence: null,
+    created_at: l.created_at
+  }));
+  files.set("links.jsonl", encoder2.encode(shardLinks.map((l) => JSON.stringify(l)).join("\n")));
+  components.push("links");
+  counts.links = shardLinks.length;
+  const checksums = {};
+  for (const [filename, data] of files) {
+    checksums[filename] = await sha256Hex(data);
+  }
+  const manifest = {
+    version: CURRENT_SHARD_VERSION,
+    matric_version: VERSION,
+    format: SHARD_FORMAT,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    components,
+    counts,
+    checksums,
+    min_reader_version: "1.0.0",
+    migrated_from: null,
+    migration_history: [],
+    ...layout ? { layout } : {}
+  };
+  files.set("manifest.json", encoder2.encode(JSON.stringify(manifest, null, 2)));
+  if (options?.includeBlobs && options.blobStore) {
+    const packed = /* @__PURE__ */ new Set();
+    for (const checksum of exportedBlobChecksums) {
+      if (packed.has(checksum)) continue;
+      packed.add(checksum);
+      const bytes = await options.blobStore.read(checksum);
+      if (bytes) files.set(sidecarEntryName(checksum), bytes);
+    }
+  }
+  return packTarGz(files);
+}
+var UNSUPPORTED_COMPONENTS = [
+  "templates",
+  "embedding_sets",
+  "embedding_configs",
+  "embedding_set_members",
+  "embeddings",
+  "skos_schemes",
+  "skos_concepts",
+  "skos_relations",
+  "note_skos_tags",
+  "provenance_edges",
+  "graph_sources",
+  "graph_edges",
+  "communities",
+  "community_assignments"
+];
+function failure(counts, skipped, warnings, error, start) {
+  return {
+    success: false,
+    counts,
+    skipped,
+    warnings,
+    errors: [error],
+    duration_ms: performance.now() - start
+  };
+}
+async function importShardToRecords(store, data, options) {
+  const start = performance.now();
+  const strategy = options?.conflictStrategy ?? "skip";
+  const counts = emptyCounts();
+  const skipped = {};
+  const warnings = [];
+  const inputData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+  let files;
+  try {
+    files = unpackTarGz(inputData);
+  } catch (err) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Failed to decompress archive: ${err instanceof Error ? err.message : String(err)}`,
+      start
+    );
+  }
+  const manifestData = files.get("manifest.json");
+  if (!manifestData) {
+    return failure(counts, skipped, warnings, "Missing manifest.json in shard archive", start);
+  }
+  let manifest;
+  try {
+    manifest = JSON.parse(decoder6.decode(manifestData));
+    if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
+      throw new Error("manifest must be a JSON object");
+    }
+  } catch {
+    return failure(counts, skipped, warnings, "Invalid manifest.json: failed to parse JSON", start);
+  }
+  if (manifest.min_reader_version && compareShardVersions(manifest.min_reader_version, CURRENT_SHARD_VERSION) > 0) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Shard requires reader version ${manifest.min_reader_version}, but this version supports up to ${CURRENT_SHARD_VERSION}`,
+      start
+    );
+  }
+  const sigError = await enforceSignaturePolicy(files, options, warnings);
+  if (sigError) return failure(counts, skipped, warnings, sigError, start);
+  if (!manifest.checksums || typeof manifest.checksums !== "object") {
+    return failure(counts, skipped, warnings, "Invalid manifest.json: checksums must be an object", start);
+  }
+  const checksumResult = await validateChecksums(manifest.checksums, files);
+  if (!checksumResult.valid) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Checksum validation failed for: ${checksumResult.failures.join(", ")}`,
+      start
+    );
+  }
+  const sidecarBlobs = options?.blobStore ? collectSidecarBlobs(files) : null;
+  const noteClusters = manifest.layout?.clusters?.notes;
+  let parsedNotes;
+  let parsedCollections;
+  let parsedLinks;
+  try {
+    parsedNotes = noteClusters && noteClusters.length > 0 ? [...noteClusters].sort((a, b) => a.offset - b.offset).flatMap((ref) => parseJsonlBytes(files.get(ref.href))) : parseJsonlBytes(files.get("notes.jsonl"));
+    parsedCollections = parseJsonArrayBytes(files.get("collections.json"));
+    parsedLinks = parseJsonlBytes(files.get("links.jsonl"));
+  } catch (err) {
+    return failure(
+      counts,
+      skipped,
+      warnings,
+      `Failed to parse shard component: ${err instanceof Error ? err.message : String(err)}`,
+      start
+    );
+  }
+  for (const component of manifest.components ?? []) {
+    if (UNSUPPORTED_COMPONENTS.includes(component)) {
+      const count = manifest.counts?.[component];
+      const key = component === "communities" ? "communities" : component;
+      skipped[key] = (skipped[key] ?? 0) + (typeof count === "number" ? count : 0);
+      warnings.push(
+        `Shard component '${component}' is not supported by the canonical record tier and was skipped. Import into a PGlite-backed store to preserve it.`
+      );
+    }
+  }
+  if (strategy === "error") {
+    for (const col of parsedCollections) {
+      if (await store.get("collection", col.id)) {
+        return failure(counts, skipped, warnings, `Collection already exists: ${col.id}`, start);
+      }
+    }
+    for (const shardNote of parsedNotes) {
+      if (await store.get("note", shardNote.id)) {
+        return failure(counts, skipped, warnings, `Note already exists: ${shardNote.id}`, start);
+      }
+    }
+  }
+  const nowIso3 = (/* @__PURE__ */ new Date()).toISOString();
+  for (const shardCol of parsedCollections) {
+    const col = collectionFromShard(shardCol);
+    const existing = await store.get("collection", col.id);
+    if (existing && strategy === "skip") {
+      skipped.collections = (skipped.collections ?? 0) + 1;
+      continue;
+    }
+    await store.put("collection", {
+      id: col.id,
+      name: col.name,
+      description: col.description,
+      created_at: col.created_at,
+      updated_at: existing?.updated_at ?? nowIso3,
+      deleted_at: existing?.deleted_at ?? null
+    });
+    counts.collections++;
+  }
+  const existingBlobs = await store.list("attachment_blob");
+  const blobIdByChecksum = new Map(existingBlobs.map((b) => [b.content_hash, b.id]));
+  const blobsToHydrate = /* @__PURE__ */ new Map();
+  let referenceOnlyCount = 0;
+  let notesWithAttachmentRefs = 0;
+  for (const shardNote of parsedNotes) {
+    const note = noteFromShard(shardNote);
+    const existing = await store.get("note", note.id);
+    if (existing && strategy === "skip") {
+      skipped.notes = (skipped.notes ?? 0) + 1;
+      continue;
+    }
+    await store.put("note", {
+      id: note.id,
+      archive_id: existing?.archive_id ?? null,
+      title: note.title,
+      format: note.format,
+      source: note.source,
+      visibility: existing?.visibility ?? "private",
+      revision_mode: existing?.revision_mode ?? "standard",
+      is_starred: note.is_starred,
+      is_pinned: existing?.is_pinned ?? false,
+      is_archived: note.is_archived,
+      created_at: typeof note.created_at === "string" ? note.created_at : note.created_at.toISOString(),
+      updated_at: typeof note.updated_at === "string" ? note.updated_at : note.updated_at.toISOString(),
+      deleted_at: note.deleted_at ? typeof note.deleted_at === "string" ? note.deleted_at : note.deleted_at.toISOString() : null
+    });
+    const contentHash = computeHash(encoder2.encode(note.original_content));
+    const existingOriginal = existing ? (await store.list("note_original")).find((o) => o.note_id === note.id) : void 0;
+    await store.put("note_original", {
+      id: existingOriginal?.id ?? generateId(),
+      note_id: note.id,
+      content: note.original_content,
+      content_hash: contentHash,
+      created_at: existingOriginal?.created_at ?? nowIso3
+    });
+    const existingRevised = existing ? await store.get("note_revised_current", note.id) : null;
+    await store.put("note_revised_current", {
+      id: note.id,
+      content: note.revised_content ?? note.original_content,
+      ai_metadata: note.ai_metadata ?? null,
+      generation_count: existingRevised?.generation_count ?? 0,
+      model: existingRevised?.model ?? null,
+      is_user_edited: existingRevised?.is_user_edited ?? false,
+      updated_at: typeof note.updated_at === "string" ? note.updated_at : note.updated_at.toISOString()
+    });
+    const existingTags = new Set(
+      (await store.list("note_tag")).filter((t) => t.note_id === note.id).map((t) => t.tag)
+    );
+    for (const tag of note.tags) {
+      if (existingTags.has(tag)) continue;
+      await store.put("note_tag", { id: generateId(), note_id: note.id, tag, created_at: nowIso3 });
+    }
+    if (note.collection_id && await store.get("collection", note.collection_id)) {
+      const member = (await store.list("collection_note")).find(
+        (cn) => cn.collection_id === note.collection_id && cn.note_id === note.id
+      );
+      if (!member) {
+        await store.put("collection_note", {
+          id: generateId(),
+          collection_id: note.collection_id,
+          note_id: note.id,
+          created_at: nowIso3
+        });
+      }
+    }
+    if (note.attachments?.length) {
+      notesWithAttachmentRefs++;
+      for (let position = 0; position < note.attachments.length; position += 1) {
+        const projection = note.attachments[position];
+        const ref = projection.attachment;
+        let blobId = blobIdByChecksum.get(ref.checksum);
+        if (!blobId) {
+          const blob = {
+            id: generateId(),
+            content_hash: ref.checksum,
+            size_bytes: ref.bytes,
+            created_at: nowIso3
+          };
+          await store.put("attachment_blob", blob);
+          blobIdByChecksum.set(ref.checksum, blob.id);
+          blobId = blob.id;
+        }
+        const filename = ref.path.split("/").filter(Boolean).pop() ?? ref.path;
+        const attachment = {
+          id: ref.id,
+          note_id: note.id,
+          blob_id: blobId,
+          document_type_id: null,
+          mime_type: ref.mime,
+          extracted_text: projection.extracted_text,
+          filename,
+          display_name: null,
+          position,
+          created_at: nowIso3,
+          deleted_at: null
+        };
+        const existingAttachment = await store.get("attachment", ref.id);
+        if (!existingAttachment || strategy === "replace") {
+          await store.put("attachment", {
+            ...attachment,
+            created_at: existingAttachment?.created_at ?? nowIso3
+          });
+        }
+        let hydrated = false;
+        if (sidecarBlobs) {
+          if (blobsToHydrate.has(ref.checksum)) {
+            hydrated = true;
+          } else {
+            const bytes = sidecarBlobs.get(blobChecksumToHex(ref.checksum));
+            if (bytes) {
+              if (computeBlobHash(bytes) === ref.checksum) {
+                blobsToHydrate.set(ref.checksum, bytes);
+                hydrated = true;
+              } else {
+                warnings.push(
+                  `Sidecar blob for attachment ${ref.id} failed BLAKE3 integrity check (expected ${ref.checksum}); imported as reference-only.`
+                );
+              }
+            }
+          }
+        }
+        if (!hydrated) referenceOnlyCount++;
+      }
+    }
+    counts.notes++;
+  }
+  if (referenceOnlyCount > 0) {
+    warnings.push(
+      `${referenceOnlyCount} attachment reference(s) across ${notesWithAttachmentRefs} note(s) were imported as metadata only: no matching byte-sidecar entry (or no import blobStore), so getBlob() returns null until bytes are hydrated. Export a self-contained shard (\`includeBlobs\` + a \`blobStore\`) and import with a \`blobStore\` to hydrate bytes.`
+    );
+  }
+  for (const shardLink of parsedLinks) {
+    const link = linkFromShard(shardLink);
+    if (!link.target_note_id) {
+      skipped.links = (skipped.links ?? 0) + 1;
+      warnings.push(
+        link.to_url ? `URL link ${link.id} skipped: the canonical record tier does not persist URL-target links.` : `Shard link skipped: ${link.id} has neither to_note_id nor to_url.`
+      );
+      continue;
+    }
+    const existing = await store.get("link", link.id);
+    if (existing && strategy === "skip") {
+      skipped.links = (skipped.links ?? 0) + 1;
+      continue;
+    }
+    await store.put("link", {
+      id: link.id,
+      source_note_id: link.source_note_id,
+      target_note_id: link.target_note_id,
+      link_type: link.link_type,
+      created_at: link.created_at,
+      deleted_at: existing?.deleted_at ?? null
+    });
+    counts.links++;
+  }
+  const errors = [];
+  if (options?.blobStore && blobsToHydrate.size > 0) {
+    try {
+      for (const [, bytes] of blobsToHydrate) {
+        await options.blobStore.put(bytes);
+      }
+    } catch (err) {
+      warnings.push(
+        `Imported records successfully but failed to hydrate ${blobsToHydrate.size} attachment blob(s) into the BlobStore: ${err instanceof Error ? err.message : String(err)}.`
+      );
+    }
+  }
+  return {
+    success: true,
+    counts,
+    skipped,
+    warnings,
+    errors,
+    duration_ms: performance.now() - start
+  };
+}
+
 // src/index.ts
-var VERSION = "2026.7.7";
+var VERSION = "2026.7.8";
 
-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 };
+export { AIWG_SCAN_REQUIRED_FIELDS, AllowlistTrustStore, ArchiveManager, AttachmentsRepository, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, CanonicalAttachmentsRepository, CanonicalNotesRepository, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, DB_SNAPSHOT_SCHEMA_VERSION, DbSnapshotVersionError, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, EmbeddingSetsRepository, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, IdbRecordStore, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MemoryRecordStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProvenanceRepository, ProviderRegistry, RECORD_COLLECTIONS, RECORD_SCHEMA_VERSION, RECORD_STORE_CAPABILITIES, SHARD_FORMAT, SIGNATURE_ENTRY, SIGNING_ENVELOPE_VERSION, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexFromKnowledgeShard, aiwgFortemiIndexToCommunityGraph, aiwgFortemiIndexToKnowledgeShard, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, assertShardComponentRecord, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, computeBlobHash, computeHash, computeSri, conceptTaggingHandler, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLazyBlobStore, createLegacyProvider, createPGliteBackend, createPGliteInstance, createRecordBackend, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, exportShardFromRecords, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, handleEmbedRequests, hasFortemiSecureSecrets, importShard, importShardToRecords, isPluginScriptAllowed, isShardPrefetched, isShardSigningSupported, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, migrateLegacyBlobStore, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectLlmModel, setEmbedFunction, setLlmFunction, sha256Hex, sidecarBlobDigests, signShard, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateAiwgStaticEmbeddingSet, validateChecksums, validateFortemiCompatibilityResponse, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map