@fortemi/core 2026.7.15 → 2026.8.0

package/dist/index.js

@@ -926,6 +926,85 @@ var migration0022 = {
   `
 };
 
+// src/migrations/0023_source_metadata_purge.ts
+var migration0023 = {
+  version: 23,
+  name: "0023_source_metadata_purge",
+  sql: `
+    CREATE TABLE IF NOT EXISTS source_identity (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL DEFAULT 'default',
+      archive_id TEXT,
+      namespace TEXT NOT NULL,
+      external_id TEXT NOT NULL,
+      external_id_hash TEXT NOT NULL,
+      source_schema_version TEXT NOT NULL,
+      content_digest TEXT NOT NULL,
+      import_run_id TEXT NOT NULL,
+      caller_stable_id TEXT,
+      note_id TEXT NOT NULL REFERENCES note(id) ON DELETE CASCADE,
+      created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      updated_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      UNIQUE (tenant_id, archive_id, namespace, external_id)
+    );
+
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_source_identity_scope_key
+      ON source_identity(tenant_id, COALESCE(archive_id, ''), namespace, external_id);
+    CREATE INDEX IF NOT EXISTS idx_source_identity_note ON source_identity(note_id);
+    CREATE INDEX IF NOT EXISTS idx_source_identity_import_run ON source_identity(import_run_id);
+    CREATE INDEX IF NOT EXISTS idx_source_identity_hash ON source_identity(external_id_hash);
+
+    CREATE TABLE IF NOT EXISTS source_import_run (
+      id TEXT PRIMARY KEY,
+      tenant_id TEXT NOT NULL DEFAULT 'default',
+      archive_id TEXT,
+      namespace TEXT NOT NULL,
+      started_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      completed_at TIMESTAMPTZ,
+      checkpoint JSONB NOT NULL DEFAULT '{}',
+      receipt JSONB NOT NULL DEFAULT '{}'
+    );
+
+    CREATE TABLE IF NOT EXISTS metadata_index_path (
+      path TEXT PRIMARY KEY,
+      value_type TEXT NOT NULL,
+      indexed_at TIMESTAMPTZ NOT NULL DEFAULT now()
+    );
+
+    INSERT INTO metadata_index_path (path, value_type) VALUES
+      ('provider', 'string'),
+      ('model', 'string'),
+      ('role', 'string'),
+      ('event_kind', 'string'),
+      ('sensitivity', 'string'),
+      ('import_run_id', 'string')
+    ON CONFLICT (path) DO NOTHING;
+
+    CREATE INDEX IF NOT EXISTS idx_note_metadata_provider
+      ON note_revised_current ((ai_metadata ->> 'provider'));
+    CREATE INDEX IF NOT EXISTS idx_note_metadata_model
+      ON note_revised_current ((ai_metadata ->> 'model'));
+    CREATE INDEX IF NOT EXISTS idx_note_metadata_role
+      ON note_revised_current ((ai_metadata ->> 'role'));
+    CREATE INDEX IF NOT EXISTS idx_note_metadata_event_kind
+      ON note_revised_current ((ai_metadata ->> 'event_kind'));
+    CREATE INDEX IF NOT EXISTS idx_note_metadata_sensitivity
+      ON note_revised_current ((ai_metadata ->> 'sensitivity'));
+
+    CREATE TABLE IF NOT EXISTS deletion_receipt (
+      id TEXT PRIMARY KEY,
+      operation_key TEXT NOT NULL UNIQUE,
+      tenant_id TEXT NOT NULL DEFAULT 'default',
+      archive_id TEXT,
+      selector_hash TEXT NOT NULL,
+      outcome TEXT NOT NULL,
+      counts JSONB NOT NULL,
+      completed_at TIMESTAMPTZ NOT NULL DEFAULT now(),
+      policy JSONB NOT NULL DEFAULT '{}'
+    );
+  `
+};
+
 // src/migrations/index.ts
 var allMigrations = [
   migration0001,
@@ -949,7 +1028,8 @@ var allMigrations = [
   migration0019,
   migration0020,
   migration0021,
-  migration0022
+  migration0022,
+  migration0023
 ];
 
 // src/data-archive.ts
@@ -1732,7 +1812,7 @@ var EmbeddingSetsRepository = class {
     const set = await this.get(setId);
     if (set.kind !== "virtual") throw new Error(`Embedding set is not virtual: ${setId}`);
     const definition = this.definitionFromRow(set);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const now2 = (/* @__PURE__ */ new Date()).toISOString();
     const materialization = definition.materialization ? { ...definition.materialization, freshness: "stale" } : null;
     await this.db.query(
       `UPDATE embedding_set
@@ -1741,7 +1821,7 @@ var EmbeddingSetsRepository = class {
       [
         setId,
         jsonParam(materialization),
-        jsonParam({ status: "stale", sourceHash: definition.materialization?.inputHash, checkedAt: now, reason })
+        jsonParam({ status: "stale", sourceHash: definition.materialization?.inputHash, checkedAt: now2, reason })
       ]
     );
   }
@@ -2004,6 +2084,90 @@ var EmbeddingSetsRepository = class {
   }
 };
 
+// src/repositories/metadata-predicates.ts
+var REGISTERED_METADATA_PATHS = [
+  "provider",
+  "model",
+  "role",
+  "event_kind",
+  "sensitivity",
+  "import_run_id"
+];
+var REGISTERED_SET = new Set(REGISTERED_METADATA_PATHS);
+var MAX_PREDICATES = 8;
+var MAX_IN_VALUES = 32;
+var MAX_VALUE_LENGTH = 256;
+function assertRegisteredPath(path) {
+  if (!REGISTERED_SET.has(path) || path.includes(".") || path.includes("/")) {
+    throw new Error(`Unsupported metadata predicate path: ${path}`);
+  }
+}
+function assertBoundedValue(value) {
+  if (typeof value === "string" && value.length > MAX_VALUE_LENGTH) {
+    throw new Error("Metadata predicate value exceeds the 256 character bound");
+  }
+}
+function jsonAccessor(path) {
+  if (path === "import_run_id") return "si.import_run_id";
+  return `c.ai_metadata ->> '${path}'`;
+}
+function buildMetadataPredicateConditions(options, startIdx) {
+  const predicates = options.metadataPredicates ?? [];
+  if (predicates.length > MAX_PREDICATES) {
+    throw new Error(`Metadata predicate count exceeds the ${MAX_PREDICATES} predicate bound`);
+  }
+  const conditions = [];
+  const params = [];
+  const joins = [];
+  let idx = startIdx;
+  let needsSourceJoin = options.tenant_id !== void 0 || options.archive_id !== void 0;
+  if (options.tenant_id !== void 0) {
+    conditions.push(`COALESCE(si.tenant_id, 'default') = $${idx++}`);
+    params.push(options.tenant_id);
+  }
+  if (options.archive_id !== void 0) {
+    conditions.push(`si.archive_id IS NOT DISTINCT FROM $${idx++}`);
+    params.push(options.archive_id);
+  }
+  for (const predicate of predicates) {
+    assertRegisteredPath(predicate.path);
+    const lhs = jsonAccessor(predicate.path);
+    if (predicate.path === "import_run_id") needsSourceJoin = true;
+    if (predicate.op === "eq") {
+      assertBoundedValue(predicate.value);
+      conditions.push(`${lhs} IS NOT DISTINCT FROM $${idx++}`);
+      params.push(predicate.value == null ? null : String(predicate.value));
+    } else if (predicate.op === "in") {
+      if (predicate.value.length > MAX_IN_VALUES) {
+        throw new Error(`Metadata predicate membership exceeds the ${MAX_IN_VALUES} value bound`);
+      }
+      for (const value of predicate.value) assertBoundedValue(value);
+      conditions.push(`${lhs} = ANY($${idx++})`);
+      params.push(predicate.value.map((value) => value == null ? null : String(value)));
+    } else if (predicate.op === "range") {
+      if (predicate.gte === void 0 && predicate.lte === void 0) {
+        throw new Error("Metadata range predicate requires gte or lte");
+      }
+      if (predicate.gte !== void 0) {
+        assertBoundedValue(predicate.gte);
+        conditions.push(`${lhs} >= $${idx++}`);
+        params.push(String(predicate.gte));
+      }
+      if (predicate.lte !== void 0) {
+        assertBoundedValue(predicate.lte);
+        conditions.push(`${lhs} <= $${idx++}`);
+        params.push(String(predicate.lte));
+      }
+    } else {
+      conditions.push(predicate.value === false ? `${lhs} IS NULL` : `${lhs} IS NOT NULL`);
+    }
+  }
+  if (needsSourceJoin) {
+    joins.push("LEFT JOIN source_identity si ON si.note_id = n.id");
+  }
+  return { conditions, joins, params, nextIdx: idx };
+}
+
 // src/repositories/search-repository.ts
 var ATTACHMENT_TEXT_JOIN2 = `
        LEFT JOIN (
@@ -2072,6 +2236,41 @@ var SearchRepository = class {
   attachEmbeddingStatus(results, embeddingSet) {
     return results.map((r) => ({ ...r, has_embedding: embeddingSet.has(r.id) }));
   }
+  async fetchLocatorMap(noteIds, metadataPaths = []) {
+    const locators = /* @__PURE__ */ new Map();
+    if (noteIds.length === 0) return locators;
+    const result = await this.db.query(
+      `SELECT note_id, namespace, external_id_hash, import_run_id, source_schema_version
+       FROM source_identity
+       WHERE note_id = ANY($1)
+       ORDER BY created_at ASC`,
+      [noteIds]
+    );
+    for (const row of result.rows) {
+      const existing = locators.get(row.note_id) ?? [];
+      existing.push({
+        note_id: row.note_id,
+        chunk: { kind: "current", index: 0 },
+        source: {
+          namespace: row.namespace,
+          external_id_hash: row.external_id_hash,
+          import_run_id: row.import_run_id,
+          schema_version: row.source_schema_version
+        },
+        metadata_paths: [...metadataPaths]
+      });
+      locators.set(row.note_id, existing);
+    }
+    for (const noteId of noteIds) {
+      if (!locators.has(noteId)) {
+        locators.set(noteId, [{ note_id: noteId, chunk: { kind: "current", index: 0 }, metadata_paths: [...metadataPaths] }]);
+      }
+    }
+    return locators;
+  }
+  metadataPaths(options) {
+    return [...new Set((options.metadataPredicates ?? []).map((predicate) => predicate.path))];
+  }
   async search(query, options = {}, queryEmbedding) {
     const { limit = 20, offset = 0 } = options;
     const mode = options.mode ?? "auto";
@@ -2098,17 +2297,21 @@ var SearchRepository = class {
     const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const tsqFn = this.tsqueryFn(query);
     const { conditions, params, nextIdx } = buildNoteConditions(options, 2);
+    const metadata = buildMetadataPredicateConditions(options, nextIdx);
+    conditions.push(...metadata.conditions);
+    params.push(...metadata.params);
     conditions.unshift(
       `(n.tsv @@ ${tsqFn}('english', $1) OR
         ${COMBINED_TEXT_VECTOR_SQL2} @@ ${tsqFn}('english', $1))`
     );
-    let paramIdx = this.scopeToResolvedEmbeddingSet(conditions, params, nextIdx, resolvedEmbeddingSet);
+    let paramIdx = this.scopeToResolvedEmbeddingSet(conditions, params, metadata.nextIdx, resolvedEmbeddingSet);
     const allParams = [query, ...params];
     const where = conditions.join(" AND ");
     const countResult = await this.db.query(
       `SELECT COUNT(*) as count
        FROM note n
        LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${metadata.joins.join("\n")}
        ${ATTACHMENT_TEXT_JOIN2}
        WHERE ${where}`,
       allParams
@@ -2129,6 +2332,7 @@ var SearchRepository = class {
               ) as snippet
        FROM note n
        LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${metadata.joins.join("\n")}
        ${ATTACHMENT_TEXT_JOIN2}
        WHERE ${where}
        ORDER BY rank DESC, n.created_at DESC
@@ -2145,12 +2349,14 @@ var SearchRepository = class {
       const idsResult = await this.db.query(
         `SELECT n.id FROM note n
          LEFT JOIN note_revised_current c ON c.note_id = n.id
+         ${metadata.joins.join("\n")}
          ${ATTACHMENT_TEXT_JOIN2}
          WHERE ${where}`,
         allParams
       );
       facets = await this.fetchFacets(idsResult.rows.map((r) => r.id));
     }
+    const locatorMap = await this.fetchLocatorMap(resultIds, this.metadataPaths(options));
     const baseResults = result.rows.map((r) => ({
       id: r.id,
       title: r.title,
@@ -2158,7 +2364,8 @@ var SearchRepository = class {
       rank: r.rank,
       created_at: r.created_at,
       updated_at: r.updated_at,
-      tags: tagMap.get(r.id) ?? []
+      tags: tagMap.get(r.id) ?? [],
+      locators: locatorMap.get(r.id) ?? []
     }));
     return {
       results: this.attachEmbeddingStatus(baseResults, embeddingSet),
@@ -2176,12 +2383,17 @@ var SearchRepository = class {
     const vectorStr = `[${queryEmbedding.join(",")}]`;
     const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const { conditions, params, nextIdx } = buildNoteConditions(options, 1);
-    let paramIdx = this.scopeToResolvedEmbeddingRows(conditions, params, nextIdx, resolvedEmbeddingSet);
+    const metadata = buildMetadataPredicateConditions(options, nextIdx);
+    conditions.push(...metadata.conditions);
+    params.push(...metadata.params);
+    let paramIdx = this.scopeToResolvedEmbeddingRows(conditions, params, metadata.nextIdx, resolvedEmbeddingSet);
     const where = conditions.join(" AND ");
     const countResult = await this.db.query(
       `SELECT COUNT(*) as count
        FROM embedding e
        JOIN note n ON n.id = e.note_id
+       LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${metadata.joins.join("\n")}
        WHERE ${where}`,
       params
     );
@@ -2196,6 +2408,7 @@ var SearchRepository = class {
        FROM embedding e
        JOIN note n ON n.id = e.note_id
        LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${metadata.joins.join("\n")}
        ${ATTACHMENT_TEXT_JOIN2}
        WHERE ${where}
        ORDER BY e.vector <=> $${vecIdx}::vector ASC
@@ -2204,9 +2417,15 @@ var SearchRepository = class {
     );
     const tagMap = await this.fetchTagMap(result.rows.map((r) => r.id));
     const facets = options.include_facets ? await this.fetchFacets((await this.db.query(
-      `SELECT n.id FROM embedding e JOIN note n ON n.id = e.note_id WHERE ${where}`,
+      `SELECT n.id
+           FROM embedding e
+           JOIN note n ON n.id = e.note_id
+           LEFT JOIN note_revised_current c ON c.note_id = n.id
+           ${metadata.joins.join("\n")}
+           WHERE ${where}`,
       params
     )).rows.map((r) => r.id)) : void 0;
+    const locatorMap = await this.fetchLocatorMap(result.rows.map((r) => r.id), this.metadataPaths(options));
     return {
       results: result.rows.map((r) => ({
         id: r.id,
@@ -2216,7 +2435,8 @@ var SearchRepository = class {
         created_at: r.created_at,
         updated_at: r.updated_at,
         tags: tagMap.get(r.id) ?? [],
-        has_embedding: true
+        has_embedding: true,
+        locators: locatorMap.get(r.id) ?? []
       })),
       total,
       query: "",
@@ -2234,12 +2454,15 @@ var SearchRepository = class {
     const tsqFn = this.tsqueryFn(query);
     const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const textCond = buildNoteConditions(options, 2);
+    const textMeta = buildMetadataPredicateConditions(options, textCond.nextIdx);
     const textConditions = [
       ...textCond.conditions,
+      ...textMeta.conditions,
       `(n.tsv @@ ${tsqFn}('english', $1) OR
         ${COMBINED_TEXT_VECTOR_SQL2} @@ ${tsqFn}('english', $1))`
     ];
-    this.scopeToResolvedEmbeddingSet(textConditions, textCond.params, textCond.nextIdx, resolvedEmbeddingSet);
+    textCond.params.push(...textMeta.params);
+    this.scopeToResolvedEmbeddingSet(textConditions, textCond.params, textMeta.nextIdx, resolvedEmbeddingSet);
     const textWhere = textConditions.join(" AND ");
     const textParams = [query, ...textCond.params];
     const textResult = await this.db.query(
@@ -2250,6 +2473,7 @@ var SearchRepository = class {
               ) as rank
        FROM note n
        LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${textMeta.joins.join("\n")}
        ${ATTACHMENT_TEXT_JOIN2}
        WHERE ${textWhere}
        ORDER BY rank DESC
@@ -2257,13 +2481,18 @@ var SearchRepository = class {
       textParams
     );
     const vecCond = buildNoteConditions(options, 1);
-    vecCond.nextIdx = this.scopeToResolvedEmbeddingRows(vecCond.conditions, vecCond.params, vecCond.nextIdx, resolvedEmbeddingSet);
+    const vecMeta = buildMetadataPredicateConditions(options, vecCond.nextIdx);
+    vecCond.conditions.push(...vecMeta.conditions);
+    vecCond.params.push(...vecMeta.params);
+    vecCond.nextIdx = this.scopeToResolvedEmbeddingRows(vecCond.conditions, vecCond.params, vecMeta.nextIdx, resolvedEmbeddingSet);
     const vecWhere = vecCond.conditions.join(" AND ");
     const vecVecIdx = vecCond.nextIdx;
     const vectorResult = await this.db.query(
       `SELECT n.id, (e.vector <=> $${vecVecIdx}::vector) as distance
        FROM embedding e
        JOIN note n ON n.id = e.note_id
+       LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${vecMeta.joins.join("\n")}
        WHERE ${vecWhere}
        ORDER BY e.vector <=> $${vecVecIdx}::vector ASC
        LIMIT 100`,
@@ -2296,6 +2525,7 @@ var SearchRepository = class {
       this.fetchTagMap(pageIds),
       this.fetchEmbeddingStatus(pageIds, resolvedEmbeddingSet, options.embeddingSetId)
     ]);
+    const locatorMap = await this.fetchLocatorMap(pageIds, this.metadataPaths(options));
     const facets = options.include_facets ? await this.fetchFacets(sortedIds) : void 0;
     return {
       results: pageIds.map((id) => {
@@ -2309,7 +2539,8 @@ var SearchRepository = class {
           created_at: r.created_at,
           updated_at: r.updated_at,
           tags: tagMap.get(id) ?? [],
-          has_embedding: embeddingSet.has(id)
+          has_embedding: embeddingSet.has(id),
+          locators: locatorMap.get(id) ?? []
         };
       }).filter((r) => r !== null),
       total,
@@ -2325,10 +2556,17 @@ var SearchRepository = class {
     const { limit = 20, offset = 0 } = options;
     const resolvedEmbeddingSet = await this.resolveEmbeddingSet(options);
     const { conditions, params, nextIdx } = buildNoteConditions(options, 1);
-    let paramIdx = this.scopeToResolvedEmbeddingSet(conditions, params, nextIdx, resolvedEmbeddingSet);
+    const metadata = buildMetadataPredicateConditions(options, nextIdx);
+    conditions.push(...metadata.conditions);
+    params.push(...metadata.params);
+    let paramIdx = this.scopeToResolvedEmbeddingSet(conditions, params, metadata.nextIdx, resolvedEmbeddingSet);
     const where = conditions.join(" AND ");
     const countResult = await this.db.query(
-      `SELECT COUNT(*) as count FROM note n WHERE ${where}`,
+      `SELECT COUNT(*) as count
+       FROM note n
+       LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${metadata.joins.join("\n")}
+       WHERE ${where}`,
       params
     );
     const total = parseInt(countResult.rows[0].count, 10);
@@ -2338,6 +2576,7 @@ var SearchRepository = class {
               LEFT(${COMBINED_TEXT_SQL}, 200) as snippet
        FROM note n
        LEFT JOIN note_revised_current c ON c.note_id = n.id
+       ${metadata.joins.join("\n")}
        ${ATTACHMENT_TEXT_JOIN2}
        WHERE ${where}
        ORDER BY n.created_at DESC
@@ -2346,6 +2585,7 @@ var SearchRepository = class {
     );
     const resultIds = result.rows.map((r) => r.id);
     const embeddingSet = await this.fetchEmbeddingStatus(resultIds, resolvedEmbeddingSet, options.embeddingSetId);
+    const locatorMap = await this.fetchLocatorMap(resultIds, this.metadataPaths(options));
     return {
       results: result.rows.map((r) => ({
         id: r.id,
@@ -2355,7 +2595,8 @@ var SearchRepository = class {
         created_at: r.created_at,
         updated_at: r.updated_at,
         tags: [],
-        has_embedding: embeddingSet.has(r.id)
+        has_embedding: embeddingSet.has(r.id),
+        locators: locatorMap.get(r.id) ?? []
       })),
       total,
       query: "",
@@ -3945,8 +4186,8 @@ async function migrateLegacyBlobStore(archiveName, target, indexedDbFactory) {
 
 // src/blob-store.ts
 var MemoryBlobStore = class {
-  constructor(now = Date.now) {
-    this.now = now;
+  constructor(now2 = Date.now) {
+    this.now = now2;
   }
   entries = /* @__PURE__ */ new Map();
   async put(bytes) {
@@ -4019,12 +4260,12 @@ function toChecksum(hex) {
   return CHECKSUM_PREFIX + hex;
 }
 var BytecaskBlobStore = class {
-  constructor(facade, adapter, index, probe, now = Date.now) {
+  constructor(facade, adapter, index, probe, now2 = Date.now) {
     this.facade = facade;
     this.adapter = adapter;
     this.index = index;
     this.probe = probe;
-    this.now = now;
+    this.now = now2;
   }
   async put(bytes) {
     return toChecksum(await this.facade.put(bytes));
@@ -4159,6 +4400,482 @@ function createLazyBlobStore(archiveName, options) {
   };
 }
 
+// src/repositories/source-upsert-repository.ts
+var DEFAULT_MAX_ITEMS = 500;
+function assertSource(input) {
+  if (!input.namespace || input.namespace.length > 128) throw new Error("Source namespace is required and must be <= 128 characters");
+  if (!input.external_id || input.external_id.length > 1024) throw new Error("Source external_id is required and must be <= 1024 characters");
+  if (!input.source_schema_version || input.source_schema_version.length > 64) {
+    throw new Error("Source schema version is required and must be <= 64 characters");
+  }
+  if (!input.import_run_id || input.import_run_id.length > 128) throw new Error("Source import_run_id is required and must be <= 128 characters");
+}
+function sourceHash(source) {
+  return computeHash(new TextEncoder().encode([
+    source.tenant_id ?? "default",
+    source.archive_id ?? "",
+    source.namespace,
+    source.external_id
+  ].join("\0")));
+}
+function contentDigest(content) {
+  return computeHash(new TextEncoder().encode(content));
+}
+async function insertNote(tx, input, noteId, digest) {
+  const originalId = generateId();
+  if (input.source.archive_id) {
+    await tx.query(
+      `INSERT INTO archive (id, name)
+       VALUES ($1, $2)
+       ON CONFLICT (id) DO NOTHING`,
+      [input.source.archive_id, input.source.archive_id]
+    );
+  }
+  await tx.query(
+    `INSERT INTO note (id, archive_id, title, format, source, visibility)
+     VALUES ($1, $2, $3, $4, $5, $6)`,
+    [
+      noteId,
+      input.source.archive_id ?? null,
+      input.title ?? null,
+      input.format ?? "markdown",
+      `source:${input.source.namespace}`,
+      input.visibility ?? "private"
+    ]
+  );
+  await tx.query(
+    `INSERT INTO note_original (id, note_id, content, content_hash)
+     VALUES ($1, $2, $3, $4)`,
+    [originalId, noteId, input.content, digest]
+  );
+  await tx.query(
+    `INSERT INTO note_revised_current (note_id, content, ai_metadata)
+     VALUES ($1, $2, $3::jsonb)`,
+    [noteId, input.content, JSON.stringify(input.metadata ?? null)]
+  );
+}
+async function updateNote(tx, input, noteId, outcome) {
+  if (input.source.archive_id) {
+    await tx.query(
+      `INSERT INTO archive (id, name)
+       VALUES ($1, $2)
+       ON CONFLICT (id) DO NOTHING`,
+      [input.source.archive_id, input.source.archive_id]
+    );
+  }
+  if (outcome === "versioned") {
+    const count2 = await tx.query(
+      `SELECT COUNT(*) AS count FROM note_revision WHERE note_id = $1`,
+      [noteId]
+    );
+    const current = await tx.query(
+      `SELECT content, ai_metadata FROM note_revised_current WHERE note_id = $1`,
+      [noteId]
+    );
+    const nextRevision = Number.parseInt(count2.rows[0]?.count ?? "0", 10) + 1;
+    if (current.rows[0]) {
+      await tx.query(
+        `INSERT INTO note_revision (id, note_id, revision_number, type, content, ai_metadata)
+         VALUES ($1, $2, $3, 'source-import', $4, $5::jsonb)`,
+        [
+          generateId(),
+          noteId,
+          nextRevision,
+          current.rows[0].content,
+          JSON.stringify(current.rows[0].ai_metadata ?? null)
+        ]
+      );
+    }
+  }
+  await tx.query(
+    `UPDATE note
+     SET title = $1, format = $2, visibility = $3, archive_id = $4, updated_at = now(), deleted_at = NULL
+     WHERE id = $5`,
+    [
+      input.title ?? null,
+      input.format ?? "markdown",
+      input.visibility ?? "private",
+      input.source.archive_id ?? null,
+      noteId
+    ]
+  );
+  await tx.query(
+    `UPDATE note_revised_current
+     SET content = $1, ai_metadata = $2::jsonb, is_user_edited = false, updated_at = now()
+     WHERE note_id = $3`,
+    [input.content, JSON.stringify(input.metadata ?? null), noteId]
+  );
+}
+var SourceUpsertRepository = class {
+  constructor(db, events) {
+    this.db = db;
+    this.events = events;
+  }
+  async upsertBatch(items, options = {}) {
+    const maxItems = options.maxItems ?? DEFAULT_MAX_ITEMS;
+    if (items.length > maxItems) throw new Error(`Source upsert batch exceeds the ${maxItems} item bound`);
+    if (items.length === 0) {
+      return {
+        import_run_id: "",
+        dry_run: options.dryRun === true,
+        outcomes: [],
+        counts: { inserted: 0, unchanged: 0, versioned: 0, replaced: 0, conflict: 0, rejected: 0 }
+      };
+    }
+    const outcomes = [];
+    for (const [index, item] of items.entries()) {
+      try {
+        assertSource(item.source);
+        outcomes.push({
+          index,
+          outcome: "rejected",
+          external_id_hash: sourceHash(item.source),
+          content_digest: contentDigest(item.content)
+        });
+      } catch (error) {
+        outcomes.push({
+          index,
+          outcome: "rejected",
+          external_id_hash: item.source ? sourceHash({ ...item.source, external_id: item.source.external_id ?? "" }) : "",
+          content_digest: contentDigest(item.content ?? ""),
+          reason: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    if (outcomes.some((outcome) => outcome.reason)) {
+      return this.finish(items[0].source?.import_run_id ?? "", options.dryRun === true, outcomes);
+    }
+    if (options.dryRun) {
+      const preview = [];
+      for (const [index, item] of items.entries()) {
+        const externalIdHash = sourceHash(item.source);
+        const digest = contentDigest(item.content);
+        const existing = await this.db.query(
+          `SELECT note_id, content_digest
+           FROM source_identity
+           WHERE tenant_id = $1
+             AND archive_id IS NOT DISTINCT FROM $2
+             AND namespace = $3
+             AND external_id = $4
+           LIMIT 1`,
+          [item.source.tenant_id ?? "default", item.source.archive_id ?? null, item.source.namespace, item.source.external_id]
+        );
+        if (existing.rows.length === 0) {
+          preview.push({ index, outcome: "inserted", external_id_hash: externalIdHash, content_digest: digest });
+        } else if (existing.rows[0].content_digest === digest) {
+          preview.push({ index, outcome: "unchanged", note_id: existing.rows[0].note_id, external_id_hash: externalIdHash, content_digest: digest });
+        } else if ((item.policy ?? "version") === "conflict") {
+          preview.push({ index, outcome: "conflict", note_id: existing.rows[0].note_id, external_id_hash: externalIdHash, content_digest: digest });
+        } else {
+          preview.push({
+            index,
+            outcome: item.policy === "replace" ? "replaced" : "versioned",
+            note_id: existing.rows[0].note_id,
+            external_id_hash: externalIdHash,
+            content_digest: digest
+          });
+        }
+      }
+      return this.finish(items[0].source.import_run_id, true, preview);
+    }
+    await this.db.transaction(async (tx) => {
+      for (const [index, item] of items.entries()) {
+        const externalIdHash = sourceHash(item.source);
+        const digest = contentDigest(item.content);
+        const existing = await tx.query(
+          `SELECT note_id, content_digest
+           FROM source_identity
+           WHERE tenant_id = $1
+             AND archive_id IS NOT DISTINCT FROM $2
+             AND namespace = $3
+             AND external_id = $4
+           LIMIT 1`,
+          [item.source.tenant_id ?? "default", item.source.archive_id ?? null, item.source.namespace, item.source.external_id]
+        );
+        if (existing.rows.length === 0) {
+          const noteId = item.source.caller_stable_id ?? generateId();
+          await insertNote(tx, item, noteId, digest);
+          await tx.query(
+            `INSERT INTO source_identity
+              (id, tenant_id, archive_id, namespace, external_id, external_id_hash,
+               source_schema_version, content_digest, import_run_id, caller_stable_id, note_id)
+             VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
+            [
+              generateId(),
+              item.source.tenant_id ?? "default",
+              item.source.archive_id ?? null,
+              item.source.namespace,
+              item.source.external_id,
+              externalIdHash,
+              item.source.source_schema_version,
+              digest,
+              item.source.import_run_id,
+              item.source.caller_stable_id ?? null,
+              noteId
+            ]
+          );
+          outcomes[index] = { index, outcome: "inserted", note_id: noteId, external_id_hash: externalIdHash, content_digest: digest };
+          continue;
+        }
+        const row = existing.rows[0];
+        if (row.content_digest === digest) {
+          outcomes[index] = { index, outcome: "unchanged", note_id: row.note_id, external_id_hash: externalIdHash, content_digest: digest };
+          continue;
+        }
+        const policy = item.policy ?? "version";
+        if (policy === "conflict") {
+          outcomes[index] = { index, outcome: "conflict", note_id: row.note_id, external_id_hash: externalIdHash, content_digest: digest };
+          continue;
+        }
+        const outcome = policy === "replace" ? "replaced" : "versioned";
+        await updateNote(tx, item, row.note_id, outcome);
+        await tx.query(
+          `UPDATE source_identity
+           SET source_schema_version = $1, content_digest = $2, import_run_id = $3, updated_at = now()
+           WHERE note_id = $4
+             AND tenant_id = $5
+             AND archive_id IS NOT DISTINCT FROM $6
+             AND namespace = $7
+             AND external_id = $8`,
+          [
+            item.source.source_schema_version,
+            digest,
+            item.source.import_run_id,
+            row.note_id,
+            item.source.tenant_id ?? "default",
+            item.source.archive_id ?? null,
+            item.source.namespace,
+            item.source.external_id
+          ]
+        );
+        outcomes[index] = { index, outcome, note_id: row.note_id, external_id_hash: externalIdHash, content_digest: digest };
+      }
+      if (hasMaterialChange(outcomes)) {
+        await tx.query(
+          `INSERT INTO source_import_run (id, tenant_id, archive_id, namespace, completed_at, checkpoint, receipt)
+           VALUES ($1, $2, $3, $4, now(), $5::jsonb, $6::jsonb)
+           ON CONFLICT (id) DO UPDATE
+             SET completed_at = EXCLUDED.completed_at,
+                 checkpoint = EXCLUDED.checkpoint,
+                 receipt = EXCLUDED.receipt`,
+          [
+            items[0].source.import_run_id,
+            items[0].source.tenant_id ?? "default",
+            items[0].source.archive_id ?? null,
+            items[0].source.namespace,
+            JSON.stringify({ item_count: items.length }),
+            JSON.stringify({ counts: countOutcomes(outcomes) })
+          ]
+        );
+      }
+    });
+    if (hasMaterialChange(outcomes)) {
+      this.events?.emit("source.upserted", { importRunId: items[0].source.import_run_id, counts: countOutcomes(outcomes) });
+    }
+    return this.finish(items[0].source.import_run_id, false, outcomes);
+  }
+  finish(importRunId, dryRun, outcomes) {
+    return { import_run_id: importRunId, dry_run: dryRun, outcomes, counts: countOutcomes(outcomes) };
+  }
+};
+function hasMaterialChange(outcomes) {
+  return outcomes.some((outcome) => outcome.outcome === "inserted" || outcome.outcome === "versioned" || outcome.outcome === "replaced");
+}
+function countOutcomes(outcomes) {
+  return {
+    inserted: outcomes.filter((outcome) => outcome.outcome === "inserted").length,
+    unchanged: outcomes.filter((outcome) => outcome.outcome === "unchanged").length,
+    versioned: outcomes.filter((outcome) => outcome.outcome === "versioned").length,
+    replaced: outcomes.filter((outcome) => outcome.outcome === "replaced").length,
+    conflict: outcomes.filter((outcome) => outcome.outcome === "conflict").length,
+    rejected: outcomes.filter((outcome) => outcome.outcome === "rejected").length
+  };
+}
+
+// src/repositories/lifecycle-purge-repository.ts
+function zeroCounts() {
+  return {
+    notes: 0,
+    revisions: 0,
+    links: 0,
+    tags: 0,
+    embeddings: 0,
+    attachments: 0,
+    blobs: 0,
+    graph_edges: 0,
+    provenance_edges: 0,
+    source_identities: 0
+  };
+}
+function selectorHash(selector) {
+  return computeHash(new TextEncoder().encode(JSON.stringify({
+    tenant_id: selector.tenant_id ?? "default",
+    archive_id: selector.archive_id ?? null,
+    note_ids: [...selector.note_ids ?? []].sort(),
+    source: selector.source ? {
+      namespace: selector.source.namespace,
+      external_id_hash: selector.source.external_id ? computeHash(new TextEncoder().encode(selector.source.external_id)) : null
+    } : null
+  })));
+}
+function buildSelectorWhere(selector, startIdx) {
+  const clauses = [];
+  const params = [];
+  let idx = startIdx;
+  if (selector.note_ids?.length) {
+    clauses.push(`n.id = ANY($${idx++})`);
+    params.push([...selector.note_ids]);
+  }
+  if (selector.tenant_id !== void 0 || selector.archive_id !== void 0 || selector.source) {
+    clauses.push(`EXISTS (
+      SELECT 1 FROM source_identity si
+      WHERE si.note_id = n.id
+        AND si.tenant_id = $${idx++}
+        AND si.archive_id IS NOT DISTINCT FROM $${idx++}
+        ${selector.source ? `AND si.namespace = $${idx++}` : ""}
+        ${selector.source?.external_id ? `AND si.external_id = $${idx++}` : ""}
+    )`);
+    params.push(selector.tenant_id ?? "default", selector.archive_id ?? null);
+    if (selector.source) params.push(selector.source.namespace);
+    if (selector.source?.external_id) params.push(selector.source.external_id);
+  }
+  if (clauses.length === 0) throw new Error("Purge selector must target note_ids or source identity");
+  return { sql: clauses.join(" AND "), params };
+}
+async function selectedNoteIds(db, selector) {
+  const where = buildSelectorWhere(selector, 1);
+  const result = await db.query(
+    `SELECT n.id FROM note n WHERE ${where.sql} ORDER BY n.id`,
+    where.params
+  );
+  return result.rows.map((row) => row.id);
+}
+var LifecyclePurgeRepository = class {
+  constructor(db, events) {
+    this.db = db;
+    this.events = events;
+  }
+  async preview(selector) {
+    const noteIds = await selectedNoteIds(this.db, selector);
+    return { selector_hash: selectorHash(selector), counts: await this.count(noteIds) };
+  }
+  async purge(selector, operationKey) {
+    const existing = await this.db.query(
+      `SELECT id, operation_key, tenant_id, archive_id, selector_hash, outcome, counts, completed_at, policy
+       FROM deletion_receipt
+       WHERE operation_key = $1`,
+      [operationKey]
+    );
+    if (existing.rows[0]) return existing.rows[0];
+    const hash = selectorHash(selector);
+    let receipt;
+    await this.db.transaction(async (tx) => {
+      const noteIds = await selectedNoteIds(tx, selector);
+      const counts = await this.count(noteIds, tx);
+      await this.deleteSelected(tx, noteIds);
+      receipt = {
+        id: generateId(),
+        operation_key: operationKey,
+        tenant_id: selector.tenant_id ?? "default",
+        archive_id: selector.archive_id ?? null,
+        selector_hash: hash,
+        outcome: "completed",
+        counts,
+        completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+        policy: {
+          authority: "fortemi#1092",
+          mode: "terminal-purge",
+          receipt_contains_content: false
+        }
+      };
+      await tx.query(
+        `INSERT INTO deletion_receipt
+          (id, operation_key, tenant_id, archive_id, selector_hash, outcome, counts, completed_at, policy)
+         VALUES ($1, $2, $3, $4, $5, 'completed', $6::jsonb, $7, $8::jsonb)`,
+        [
+          receipt.id,
+          receipt.operation_key,
+          receipt.tenant_id,
+          receipt.archive_id,
+          receipt.selector_hash,
+          JSON.stringify(receipt.counts),
+          receipt.completed_at,
+          JSON.stringify(receipt.policy)
+        ]
+      );
+    });
+    const completedReceipt = receipt;
+    if (!completedReceipt) throw new Error("Purge transaction did not produce a receipt");
+    this.events?.emit("purge.completed", { receiptId: completedReceipt.id, counts: completedReceipt.counts });
+    return completedReceipt;
+  }
+  async count(noteIds, db = this.db) {
+    const counts = zeroCounts();
+    if (noteIds.length === 0) return counts;
+    const params = [noteIds];
+    const rows = await Promise.all([
+      db.query("SELECT COUNT(*) AS count FROM note WHERE id = ANY($1)", params),
+      db.query("SELECT COUNT(*) AS count FROM note_revision WHERE note_id = ANY($1)", params),
+      db.query("SELECT COUNT(*) AS count FROM link WHERE source_note_id = ANY($1) OR target_note_id = ANY($1)", params),
+      db.query("SELECT COUNT(*) AS count FROM note_tag WHERE note_id = ANY($1)", params),
+      db.query("SELECT COUNT(*) AS count FROM embedding WHERE note_id = ANY($1)", params),
+      db.query("SELECT COUNT(*) AS count FROM attachment WHERE note_id = ANY($1)", params),
+      db.query(
+        `SELECT COUNT(*) AS count FROM attachment_blob ab
+         WHERE EXISTS (SELECT 1 FROM attachment a WHERE a.blob_id = ab.id AND a.note_id = ANY($1))`,
+        params
+      ),
+      db.query("SELECT COUNT(*) AS count FROM graph_edge_artifact WHERE from_note_id = ANY($1) OR to_note_id = ANY($1)", params),
+      db.query(
+        `SELECT COUNT(*) AS count FROM provenance_edge
+         WHERE (entity_type = 'note' AND entity_id = ANY($1))
+            OR (attributes ->> 'note_id') = ANY($1)`,
+        params
+      ),
+      db.query("SELECT COUNT(*) AS count FROM source_identity WHERE note_id = ANY($1)", params)
+    ]);
+    const values = rows.map((row) => Number.parseInt(row.rows[0]?.count ?? "0", 10));
+    [
+      counts.notes,
+      counts.revisions,
+      counts.links,
+      counts.tags,
+      counts.embeddings,
+      counts.attachments,
+      counts.blobs,
+      counts.graph_edges,
+      counts.provenance_edges,
+      counts.source_identities
+    ] = values;
+    return counts;
+  }
+  async deleteSelected(tx, noteIds) {
+    if (noteIds.length === 0) return;
+    const params = [noteIds];
+    await tx.query("DELETE FROM community_assignment WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM graph_edge_artifact WHERE from_note_id = ANY($1) OR to_note_id = ANY($1)", params);
+    await tx.query("DELETE FROM embedding_set_member WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM embedding WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM attachment_embedding WHERE attachment_id IN (SELECT id FROM attachment WHERE note_id = ANY($1))", params);
+    await tx.query("DELETE FROM attachment WHERE note_id = ANY($1)", params);
+    await tx.query(
+      `DELETE FROM attachment_blob ab
+       WHERE NOT EXISTS (SELECT 1 FROM attachment a WHERE a.blob_id = ab.id)`
+    );
+    await tx.query("DELETE FROM source_identity WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM provenance_edge WHERE (entity_type = $2 AND entity_id = ANY($1)) OR (attributes ->> $3) = ANY($1)", [noteIds, "note", "note_id"]);
+    await tx.query("DELETE FROM job_queue WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM collection_note WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM note_tag WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM link WHERE source_note_id = ANY($1) OR target_note_id = ANY($1)", params);
+    await tx.query("DELETE FROM note_revision WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM note_revised_current WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM note_original WHERE note_id = ANY($1)", params);
+    await tx.query("DELETE FROM shard_field_presence WHERE component = $2 AND record_id = ANY($1)", [noteIds, "notes"]);
+    await tx.query("DELETE FROM note WHERE id = ANY($1)", params);
+  }
+};
+
 // src/repositories/graph-repository.ts
 var SIMILARITY_GRAPH_ALGORITHM = "knn-batched-v1";
 var DEFAULT_GRAPH_BATCH_SIZE = 64;
@@ -6958,11 +7675,11 @@ var FallbackRouter = class {
   // -------------------------------------------------------------------------
   /** Get providers not currently in cooldown */
   getAvailableProviders() {
-    const now = Date.now();
+    const now2 = Date.now();
     return this.providers.filter((p) => {
       const cd = this.cooldownMap.get(p.id);
       if (!cd) return true;
-      if (now >= cd.expiresAt) {
+      if (now2 >= cd.expiresAt) {
         this.cooldownMap.delete(p.id);
         return true;
       }
@@ -6971,10 +7688,10 @@ var FallbackRouter = class {
   }
   /** Get providers in cooldown with their expiry info */
   getCoolingDown() {
-    const now = Date.now();
+    const now2 = Date.now();
     const result = [];
     for (const [id, entry] of this.cooldownMap) {
-      if (now < entry.expiresAt) {
+      if (now2 < entry.expiresAt) {
         result.push({ providerId: id, category: entry.category, expiresAt: entry.expiresAt });
       }
     }
@@ -27959,13 +28676,13 @@ async function liveRepresentationLosses(db) {
     const result = await db.query(
       `SELECT COUNT(*) AS count FROM ${table} WHERE deleted_at IS NOT NULL`
     );
-    const count = Number(result.rows[0]?.count ?? 0);
-    if (count > 0) {
+    const count2 = Number(result.rows[0]?.count ?? 0);
+    if (count2 > 0) {
       losses.push({
         code: "unrepresentable-live-tombstone",
         component,
-        count,
-        message: `${count} ${table} tombstone(s) have no full-v1 wire field`,
+        count: count2,
+        message: `${count2} ${table} tombstone(s) have no full-v1 wire field`,
         action: "reject",
         reason: "full-v1-live-production"
       });
@@ -27997,15 +28714,15 @@ async function liveRepresentationLosses(db) {
   for (const row of vectorDimensions.rows) {
     const dimension = Number(row.dimension);
     if (dimension === 768) continue;
-    const count = Number(row.count);
+    const count2 = Number(row.count);
     losses.push({
       code: "unrepresentable-live-embedding-dimension",
       component: "embeddings",
-      count,
+      count: count2,
       field_path: "/vector",
       source_state: "value",
       destination_capability: "full-v1 requires exactly 768 vector dimensions",
-      message: `${count} embedding vector(s) have ${dimension} dimensions`,
+      message: `${count2} embedding vector(s) have ${dimension} dimensions`,
       action: "reject",
       reason: "full-v1-live-production"
     });
@@ -28565,16 +29282,27 @@ async function collectCoreV1Losses(db, options) {
     { component: "community_assignments", table: "community_assignment" }
   ];
   for (const { component, table } of componentCounts) {
-    const count = await rowCount(db, `SELECT COUNT(*) AS count FROM ${table}`);
-    if (count > 0) {
+    const count2 = await rowCount(db, `SELECT COUNT(*) AS count FROM ${table}`);
+    if (count2 > 0) {
       losses.push({
         code: "component-outside-profile",
         component,
-        count,
-        message: `${count} ${component} record(s) are outside core-v1 and were omitted.`
+        count: count2,
+        message: `${count2} ${component} record(s) are outside core-v1 and were omitted.`
       });
     }
   }
+  const sourceIdentities = await rowCount(db, "SELECT COUNT(*) AS count FROM source_identity");
+  if (sourceIdentities > 0) {
+    losses.push({
+      code: "source-identity-outside-profile",
+      count: sourceIdentities,
+      field_path: "source_identity",
+      action: "omit",
+      destination_capability: "core-v1 does not declare source-addressed identity mappings",
+      message: `${sourceIdentities} source identity mapping(s) are outside core-v1 and were omitted.`
+    });
+  }
   const nullRevisions = await rowCount(
     db,
     `SELECT COUNT(*) AS count
@@ -30718,13 +31446,13 @@ function noteSearchText(note) {
 }
 function countOccurrences(haystack, needle) {
   if (!needle) return 0;
-  let count = 0;
+  let count2 = 0;
   let index = haystack.indexOf(needle);
   while (index !== -1) {
-    count += 1;
+    count2 += 1;
     index = haystack.indexOf(needle, index + needle.length);
   }
-  return count;
+  return count2;
 }
 function noteMatchesTokens(note, tokens) {
   if (tokens.length === 0) return true;
@@ -31202,7 +31930,7 @@ function hasPositiveInteger(value) {
 }
 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)));
+  return Object.values(value).every((counts) => !!counts && typeof counts === "object" && !Array.isArray(counts) && Object.values(counts).every((count2) => hasNonNegativeInteger(count2)));
 }
 function isPlainRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -34797,13 +35525,20 @@ var RECORD_COLLECTIONS = [
   "collection_note",
   "attachment",
   "attachment_blob",
-  "shard_manifest"
+  "shard_manifest",
+  "source_identity",
+  "source_import_run",
+  "deletion_receipt"
 ];
 var RECORD_STORE_CAPABILITIES = {
   crud: true,
   journal: true,
   atomicBatch: true,
   boundedTextScan: true,
+  sourceAddressedUpsert: true,
+  deletionReceipts: true,
+  typedMetadataPredicates: false,
+  evidenceLocators: true,
   fullTextSearch: false,
   vectorSearch: false,
   sqlJoins: false
@@ -35992,7 +36727,7 @@ async function buildRecordShardArchive(store, options, profile) {
     (attachment) => exportedNoteIds.has(attachment.note_id)
   );
   const projectedAttachmentCount = browserNotes.reduce(
-    (count, note) => count + (note.attachments?.length ?? 0),
+    (count2, note) => count2 + (note.attachments?.length ?? 0),
     0
   );
   const sourceNoteById = new Map(notes.map((note) => [note.id, note]));
@@ -36146,6 +36881,17 @@ async function buildRecordShardArchive(store, options, profile) {
         message: `${collectionStateLosses} collection lifecycle state(s) are outside record-v1 and were omitted.`
       });
     }
+    const sourceIdentities = await store.list("source_identity");
+    if (sourceIdentities.length > 0) {
+      losses.push({
+        code: "source-identity-outside-profile",
+        count: sourceIdentities.length,
+        field_path: "source_identity",
+        action: "omit",
+        destination_capability: "record-v1 does not declare source-addressed identity mappings",
+        message: `${sourceIdentities.length} source identity mapping(s) are outside record-v1 and were omitted.`
+      });
+    }
   }
   let manifest = isRecordV1 ? {
     version: recordSchemaVersion2,
@@ -36428,9 +37174,9 @@ async function importShardToRecords(store, data, options) {
   }
   for (const component of manifest.components ?? []) {
     if (UNSUPPORTED_COMPONENTS.includes(component)) {
-      const count = manifest.counts?.[component];
+      const count2 = manifest.counts?.[component];
       const key = component === "communities" ? "communities" : component;
-      skipped[key] = (skipped[key] ?? 0) + (typeof count === "number" ? count : 0);
+      skipped[key] = (skipped[key] ?? 0) + (typeof count2 === "number" ? count2 : 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.`
       );
@@ -36830,9 +37576,302 @@ async function importShardToRecords(store, data, options) {
   };
 }
 
+// src/records/source-upsert.ts
+function now() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function contentDigest2(content) {
+  return computeHash(new TextEncoder().encode(content));
+}
+function sourceHash2(source) {
+  return computeHash(new TextEncoder().encode([
+    source.tenant_id ?? "default",
+    source.archive_id ?? "",
+    source.namespace,
+    source.external_id
+  ].join("\0")));
+}
+function countOutcomes2(outcomes) {
+  return {
+    inserted: outcomes.filter((outcome) => outcome.outcome === "inserted").length,
+    unchanged: outcomes.filter((outcome) => outcome.outcome === "unchanged").length,
+    versioned: outcomes.filter((outcome) => outcome.outcome === "versioned").length,
+    replaced: outcomes.filter((outcome) => outcome.outcome === "replaced").length,
+    conflict: outcomes.filter((outcome) => outcome.outcome === "conflict").length,
+    rejected: outcomes.filter((outcome) => outcome.outcome === "rejected").length
+  };
+}
+async function findSource(store, source) {
+  const identities = await store.list("source_identity");
+  return identities.find((identity) => identity.tenant_id === (source.tenant_id ?? "default") && identity.archive_id === (source.archive_id ?? null) && identity.namespace === source.namespace && identity.external_id === source.external_id) ?? null;
+}
+async function upsertRecordStoreSources(store, items, options = {}) {
+  const maxItems = options.maxItems ?? 500;
+  if (items.length > maxItems) throw new Error(`Source upsert batch exceeds the ${maxItems} item bound`);
+  if (!store.applyBatch) throw new Error("RecordStore source upsert requires atomic applyBatch() support");
+  if (items.length === 0) {
+    return {
+      import_run_id: "",
+      dry_run: options.dryRun === true,
+      outcomes: [],
+      counts: { inserted: 0, unchanged: 0, versioned: 0, replaced: 0, conflict: 0, rejected: 0 }
+    };
+  }
+  const outcomes = [];
+  const mutations = [];
+  const stamp = now();
+  for (const [index, item] of items.entries()) {
+    const external_id_hash = sourceHash2(item.source);
+    const content_digest = contentDigest2(item.content);
+    const existing = await findSource(store, item.source);
+    if (!existing) {
+      const noteId = item.source.caller_stable_id ?? generateId();
+      outcomes.push({ index, outcome: "inserted", note_id: noteId, external_id_hash, content_digest });
+      if (!options.dryRun) {
+        const note2 = {
+          id: noteId,
+          archive_id: item.source.archive_id ?? null,
+          title: item.title ?? null,
+          format: item.format ?? "markdown",
+          source: `source:${item.source.namespace}`,
+          visibility: item.visibility ?? "private",
+          revision_mode: "standard",
+          is_starred: false,
+          is_pinned: false,
+          is_archived: false,
+          created_at: stamp,
+          updated_at: stamp,
+          deleted_at: null
+        };
+        const original = {
+          id: generateId(),
+          note_id: noteId,
+          content: item.content,
+          content_hash: content_digest,
+          created_at: stamp
+        };
+        const current2 = {
+          id: noteId,
+          content: item.content,
+          ai_metadata: item.metadata ?? null,
+          generation_count: 0,
+          model: null,
+          is_user_edited: false,
+          updated_at: stamp
+        };
+        const identity = {
+          id: generateId(),
+          tenant_id: item.source.tenant_id ?? "default",
+          archive_id: item.source.archive_id ?? null,
+          namespace: item.source.namespace,
+          external_id: item.source.external_id,
+          external_id_hash,
+          source_schema_version: item.source.source_schema_version,
+          content_digest,
+          import_run_id: item.source.import_run_id,
+          caller_stable_id: item.source.caller_stable_id ?? null,
+          note_id: noteId,
+          created_at: stamp,
+          updated_at: stamp
+        };
+        mutations.push(
+          { op: "put", collection: "note", record: note2 },
+          { op: "put", collection: "note_original", record: original },
+          { op: "put", collection: "note_revised_current", record: current2 },
+          { op: "put", collection: "source_identity", record: identity }
+        );
+      }
+      continue;
+    }
+    if (existing.content_digest === content_digest) {
+      outcomes.push({ index, outcome: "unchanged", note_id: existing.note_id, external_id_hash, content_digest });
+      continue;
+    }
+    const policy = item.policy ?? "version";
+    if (policy === "conflict") {
+      outcomes.push({ index, outcome: "conflict", note_id: existing.note_id, external_id_hash, content_digest });
+      continue;
+    }
+    const note = await store.get("note", existing.note_id);
+    const current = await store.get("note_revised_current", existing.note_id);
+    if (!note || !current) {
+      outcomes.push({ index, outcome: "rejected", note_id: existing.note_id, external_id_hash, content_digest, reason: "source identity points to a missing note" });
+      continue;
+    }
+    const outcome = policy === "replace" ? "replaced" : "versioned";
+    outcomes.push({ index, outcome, note_id: existing.note_id, external_id_hash, content_digest });
+    if (!options.dryRun) {
+      mutations.push(
+        {
+          op: "put",
+          collection: "note",
+          record: {
+            ...note,
+            title: item.title ?? null,
+            archive_id: item.source.archive_id ?? null,
+            format: item.format ?? "markdown",
+            visibility: item.visibility ?? "private",
+            deleted_at: null,
+            updated_at: stamp
+          }
+        },
+        {
+          op: "put",
+          collection: "note_revised_current",
+          record: { ...current, content: item.content, ai_metadata: item.metadata ?? null, is_user_edited: false, updated_at: stamp }
+        },
+        {
+          op: "put",
+          collection: "source_identity",
+          record: { ...existing, source_schema_version: item.source.source_schema_version, content_digest, import_run_id: item.source.import_run_id, updated_at: stamp }
+        }
+      );
+    }
+  }
+  if (!options.dryRun && hasMaterialChange2(outcomes)) {
+    const run = {
+      id: items[0].source.import_run_id,
+      tenant_id: items[0].source.tenant_id ?? "default",
+      archive_id: items[0].source.archive_id ?? null,
+      namespace: items[0].source.namespace,
+      started_at: stamp,
+      completed_at: stamp,
+      checkpoint: { item_count: items.length },
+      receipt: { counts: countOutcomes2(outcomes) }
+    };
+    mutations.push({ op: "put", collection: "source_import_run", record: run });
+    await store.applyBatch(mutations);
+  }
+  return {
+    import_run_id: items[0].source.import_run_id,
+    dry_run: options.dryRun === true,
+    outcomes,
+    counts: countOutcomes2(outcomes)
+  };
+}
+function hasMaterialChange2(outcomes) {
+  return outcomes.some((outcome) => outcome.outcome === "inserted" || outcome.outcome === "versioned" || outcome.outcome === "replaced");
+}
+
+// src/records/lifecycle-purge.ts
+function hashSelector(selector) {
+  return computeHash(new TextEncoder().encode(JSON.stringify({
+    tenant_id: selector.tenant_id ?? "default",
+    archive_id: selector.archive_id ?? null,
+    note_ids: [...selector.note_ids ?? []].sort(),
+    source: selector.source ? {
+      namespace: selector.source.namespace,
+      external_id_hash: selector.source.external_id ? computeHash(new TextEncoder().encode(selector.source.external_id)) : null
+    } : null
+  })));
+}
+function zeroCounts2() {
+  return {
+    notes: 0,
+    revisions: 0,
+    links: 0,
+    tags: 0,
+    embeddings: 0,
+    attachments: 0,
+    blobs: 0,
+    graph_edges: 0,
+    provenance_edges: 0,
+    source_identities: 0
+  };
+}
+async function selectedNoteIds2(store, selector) {
+  const notes = await store.list("note");
+  if (selector.note_ids?.length) return notes.filter((note) => selector.note_ids.includes(note.id)).map((note) => note.id);
+  if (!selector.source) throw new Error("Purge selector must target note_ids or source identity");
+  const identities = await store.list("source_identity");
+  return identities.filter((identity) => identity.tenant_id === (selector.tenant_id ?? "default") && identity.archive_id === (selector.archive_id ?? null) && identity.namespace === selector.source.namespace && (selector.source.external_id === void 0 || identity.external_id === selector.source.external_id)).map((identity) => identity.note_id);
+}
+async function count(store, noteIds) {
+  const counts = zeroCounts2();
+  if (noteIds.length === 0) return counts;
+  const noteSet = new Set(noteIds);
+  counts.notes = (await store.list("note")).filter((record) => noteSet.has(record.id)).length;
+  counts.revisions = 0;
+  counts.links = (await store.list("link")).filter((record) => noteSet.has(record.source_note_id) || noteSet.has(record.target_note_id)).length;
+  counts.tags = (await store.list("note_tag")).filter((record) => noteSet.has(record.note_id)).length;
+  counts.attachments = (await store.list("attachment")).filter((record) => noteSet.has(record.note_id)).length;
+  const purgedBlobIds = new Set((await store.list("attachment")).filter((record) => noteSet.has(record.note_id)).map((record) => record.blob_id));
+  counts.blobs = (await store.list("attachment_blob")).filter((record) => purgedBlobIds.has(record.id)).length;
+  counts.source_identities = (await store.list("source_identity")).filter((record) => noteSet.has(record.note_id)).length;
+  return counts;
+}
+async function previewRecordStorePurge(store, selector) {
+  return { selector_hash: hashSelector(selector), counts: await count(store, await selectedNoteIds2(store, selector)) };
+}
+async function purgeRecordStoreGraph(store, selector, operationKey) {
+  if (!store.applyBatch) throw new Error("RecordStore purge requires atomic applyBatch() support");
+  const prior = (await store.list("deletion_receipt")).find((receipt2) => receipt2.operation_key === operationKey);
+  if (prior) return {
+    id: prior.id,
+    operation_key: prior.operation_key,
+    tenant_id: prior.tenant_id,
+    archive_id: prior.archive_id,
+    selector_hash: prior.selector_hash,
+    outcome: "completed",
+    counts: prior.counts,
+    completed_at: prior.completed_at,
+    policy: prior.policy
+  };
+  const noteIds = await selectedNoteIds2(store, selector);
+  const noteSet = new Set(noteIds);
+  const counts = await count(store, noteIds);
+  const mutations = [];
+  for (const collection of ["note_revised_current", "note_original", "note_tag", "collection_note", "attachment", "source_identity"]) {
+    for (const record of await store.list(collection)) {
+      const noteId = collection === "note_revised_current" ? record.id : "note_id" in record && typeof record.note_id === "string" ? record.note_id : null;
+      if (noteId && noteSet.has(noteId)) {
+        mutations.push({ op: "delete", collection, id: record.id });
+      }
+    }
+  }
+  for (const record of await store.list("link")) {
+    if (noteSet.has(record.source_note_id) || noteSet.has(record.target_note_id)) mutations.push({ op: "delete", collection: "link", id: record.id });
+  }
+  for (const record of await store.list("note")) {
+    if (noteSet.has(record.id)) mutations.push({ op: "delete", collection: "note", id: record.id });
+  }
+  const liveBlobIds = new Set((await store.list("attachment")).filter((record) => !noteSet.has(record.note_id)).map((record) => record.blob_id));
+  for (const record of await store.list("attachment_blob")) {
+    if (!liveBlobIds.has(record.id)) mutations.push({ op: "delete", collection: "attachment_blob", id: record.id });
+  }
+  const receipt = {
+    id: generateId(),
+    operation_key: operationKey,
+    tenant_id: selector.tenant_id ?? "default",
+    archive_id: selector.archive_id ?? null,
+    selector_hash: hashSelector(selector),
+    outcome: "completed",
+    counts,
+    completed_at: (/* @__PURE__ */ new Date()).toISOString(),
+    policy: {
+      authority: "fortemi#1092",
+      mode: "terminal-purge",
+      receipt_contains_content: false
+    }
+  };
+  mutations.push({ op: "put", collection: "deletion_receipt", record: receipt });
+  await store.applyBatch(mutations);
+  return {
+    id: receipt.id,
+    operation_key: receipt.operation_key,
+    tenant_id: receipt.tenant_id,
+    archive_id: receipt.archive_id,
+    selector_hash: receipt.selector_hash,
+    outcome: "completed",
+    counts,
+    completed_at: receipt.completed_at,
+    policy: receipt.policy
+  };
+}
+
 // src/index.ts
-var VERSION = "2026.7.15";
+var VERSION = "2026.8.0";
 
-export { AIWG_SCAN_REQUIRED_FIELDS, AllowlistTrustStore, ArchiveManager, AttachmentsRepository, CORE_V1_COMPONENTS, 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, FORTEMI_SERVER_COMPATIBILITY_REVISION, 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, aiwgFortemiIndexToKnowledgeShardWithReport, 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, createShardCapabilityReport, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, exportShardFromRecords, exportShardFromRecordsWithReport, exportShardWithReport, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardContractReceipt, getKnowledgeShardProfileRegistry, 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, profileSupportError, 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, validateCoreV1ShardArchive, validateFortemiCompatibilityResponse, validateFullV1ShardArchive, validateRecordV1ShardArchive, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };
+export { AIWG_SCAN_REQUIRED_FIELDS, AllowlistTrustStore, ArchiveManager, AttachmentsRepository, CORE_V1_COMPONENTS, 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, FORTEMI_SERVER_COMPATIBILITY_REVISION, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, IdbRecordStore, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LOCAL_ENDPOINTS, LifecyclePurgeRepository, 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, REGISTERED_METADATA_PATHS, SHARD_FORMAT, SIGNATURE_ENTRY, SIGNING_ENVELOPE_VERSION, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, SourceUpsertRepository, TagsRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexFromKnowledgeShard, aiwgFortemiIndexToCommunityGraph, aiwgFortemiIndexToKnowledgeShard, aiwgFortemiIndexToKnowledgeShardWithReport, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, assertShardComponentRecord, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, buildMetadataPredicateConditions, 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, createShardCapabilityReport, createWorkerEmbedFunction, defaultStorageBackendFactory, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, exportShard, exportShardFromRecords, exportShardFromRecordsWithReport, exportShardWithReport, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getEmbedFunction, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardContractReceipt, getKnowledgeShardProfileRegistry, 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, previewRecordStorePurge, profileSupportError, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, purgeRecordStoreGraph, 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, upsertRecordStoreSources, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateAiwgStaticEmbeddingSet, validateChecksums, validateCoreV1ShardArchive, validateFortemiCompatibilityResponse, validateFullV1ShardArchive, validateRecordV1ShardArchive, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map