@fortemi/core 2026.9.4 → 2026.9.6

package/dist/index.js

@@ -1,8 +1,8 @@
 import { v7, v5 } from 'uuid';
 import { sha256 } from '@noble/hashes/sha256';
 import { blake3 } from '@noble/hashes/blake3';
-import { bytesToHex } from '@noble/hashes/utils';
-import Ajv20202 from 'ajv/dist/2020.js';
+import { bytesToHex, hexToBytes } from '@noble/hashes/utils';
+import Ajv20206 from 'ajv/dist/2020.js';
 import { gzipSync, gunzipSync } from 'fflate';
 import { z } from 'zod';
 
@@ -24,9 +24,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key2 of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key2) && key2 !== except)
-        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+    for (let key3 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key3) && key3 !== except)
+        __defProp(to, key3, { get: () => from[key3], enumerable: !(desc = __getOwnPropDesc(from, key3)) || desc.enumerable });
   }
   return to;
 };
@@ -1991,19 +1991,19 @@ var require_point = __commonJS({
     var Types = require_types();
     var BinaryWriter = require_binarywriter();
     var ZigZag = require_zigzag();
-    function Point2(x, y, z12, m, srid) {
+    function Point2(x, y, z13, m, srid) {
       Geometry2.call(this);
       this.x = x;
       this.y = y;
-      this.z = z12;
+      this.z = z13;
       this.m = m;
       this.srid = srid;
       this.hasZ = typeof this.z !== "undefined";
       this.hasM = typeof this.m !== "undefined";
     }
     util.inherits(Point2, Geometry2);
-    Point2.Z = function(x, y, z12, srid) {
-      var point = new Point2(x, y, z12, void 0, srid);
+    Point2.Z = function(x, y, z13, srid) {
+      var point = new Point2(x, y, z13, void 0, srid);
       point.hasZ = true;
       return point;
     };
@@ -2012,8 +2012,8 @@ var require_point = __commonJS({
       point.hasM = true;
       return point;
     };
-    Point2.ZM = function(x, y, z12, m, srid) {
-      var point = new Point2(x, y, z12, m, srid);
+    Point2.ZM = function(x, y, z13, m, srid) {
+      var point = new Point2(x, y, z13, m, srid);
       point.hasZ = true;
       point.hasM = true;
       return point;
@@ -2119,17 +2119,17 @@ var require_point = __commonJS({
     Point2.prototype._writeTwkbPoint = function(twkb, precision, previousPoint) {
       var x = this.x * precision.xyFactor;
       var y = this.y * precision.xyFactor;
-      var z12 = this.z * precision.zFactor;
+      var z13 = this.z * precision.zFactor;
       var m = this.m * precision.mFactor;
       twkb.writeVarInt(ZigZag.encode(x - previousPoint.x));
       twkb.writeVarInt(ZigZag.encode(y - previousPoint.y));
       if (this.hasZ)
-        twkb.writeVarInt(ZigZag.encode(z12 - previousPoint.z));
+        twkb.writeVarInt(ZigZag.encode(z13 - previousPoint.z));
       if (this.hasM)
         twkb.writeVarInt(ZigZag.encode(m - previousPoint.m));
       previousPoint.x = x;
       previousPoint.y = y;
-      previousPoint.z = z12;
+      previousPoint.z = z13;
       previousPoint.m = m;
     };
     Point2.prototype._getWkbSize = function() {
@@ -3615,14 +3615,14 @@ var MemoryDatasetIngestStore = class {
         receipts: /* @__PURE__ */ new Map()
       };
       const draft = {
-        records: new Map([...existing.records].map(([key2, value]) => [key2, clone(value)])),
-        receipts: new Map([...existing.receipts].map(([key2, value]) => [key2, clone(value)])),
+        records: new Map([...existing.records].map(([key3, value]) => [key3, clone(value)])),
+        receipts: new Map([...existing.receipts].map(([key3, value]) => [key3, clone(value)])),
         ...existing.checkpoint ? { checkpoint: clone(existing.checkpoint) } : {}
       };
       const transaction = {
         getRecord: (id) => draft.records.get(id),
         setRecord: (record) => draft.records.set(record.logicalId, clone(record)),
-        getReceipt: (key2) => draft.receipts.get(key2),
+        getReceipt: (key3) => draft.receipts.get(key3),
         setReceipt: (receipt) => draft.receipts.set(receipt.idempotencyKey, clone(receipt)),
         getCheckpoint: () => draft.checkpoint,
         setCheckpoint: (checkpoint) => {
@@ -3650,7 +3650,7 @@ var MemoryDatasetIngestStore = class {
 function canonicalJson(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
-  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key2, item]) => `${JSON.stringify(key2)}:${canonicalJson(item)}`).join(",")}}`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key3, item]) => `${JSON.stringify(key3)}:${canonicalJson(item)}`).join(",")}}`;
 }
 function digest(value) {
   return computeHash(new TextEncoder().encode(canonicalJson(value)));
@@ -3819,11 +3819,11 @@ var DatasetIngestExecutor = class {
     return this.store.getReceipt(datasetDestinationScopeKey(plan.destination), deriveDatasetIngestIdempotencyKey(plan, batch));
   }
   status(scope, expectedSourceRevision) {
-    const key2 = datasetDestinationScopeKey(scope);
-    const lastSuccessful = this.successes.get(key2);
+    const key3 = datasetDestinationScopeKey(scope);
+    const lastSuccessful = this.successes.get(key3);
     return {
       scope: clone(scope),
-      ...this.attempts.get(key2) ? { lastAttempt: clone(this.attempts.get(key2)) } : {},
+      ...this.attempts.get(key3) ? { lastAttempt: clone(this.attempts.get(key3)) } : {},
       ...lastSuccessful ? { lastSuccessful: clone(lastSuccessful) } : {},
       freshness: lastSuccessful ? expectedSourceRevision && expectedSourceRevision !== lastSuccessful.sourceRevision ? "stale" : "current" : "never"
     };
@@ -3877,7 +3877,7 @@ function canonicalJson2(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(canonicalJson2).join(",")}]`;
   const entries = Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right));
-  return `{${entries.map(([key2, item]) => `${JSON.stringify(key2)}:${canonicalJson2(item)}`).join(",")}}`;
+  return `{${entries.map(([key3, item]) => `${JSON.stringify(key3)}:${canonicalJson2(item)}`).join(",")}}`;
 }
 function computeLineageDigest(value) {
   return computeHash(new TextEncoder().encode(canonicalJson2(value)));
@@ -3957,9 +3957,9 @@ var DatasetLineageLedger = class _DatasetLineageLedger {
     if (item.payload !== void 0 && computeLineageDigest(item.payload) !== item.digest) {
       throw new LineageValidationError("EVIDENCE_DIGEST_MISMATCH", `Evidence ${item.id} payload does not match ${item.digest}`);
     }
-    const key2 = `${item.id}@${item.revision}`;
-    this.ensureUnique(this.evidence, key2, "evidence revision");
-    return this.append(this.evidence, key2, item);
+    const key3 = `${item.id}@${item.revision}`;
+    this.ensureUnique(this.evidence, key3, "evidence revision");
+    return this.append(this.evidence, key3, item);
   }
   appendAssertion(assertion) {
     requireIdentity(assertion.id, "assertion.id");
@@ -3995,13 +3995,13 @@ var DatasetLineageLedger = class _DatasetLineageLedger {
       if (item.digest !== reference.digest) throw new LineageValidationError("EVIDENCE_DIGEST_MISMATCH", `Evidence reference digest differs for ${reference.evidenceId}`);
       if (reference.locator && reference.locator !== item.locator) throw new LineageValidationError("EVIDENCE_DIGEST_MISMATCH", `Evidence locator differs for ${reference.evidenceId}`);
     }
-    const key2 = `${assertion.id}@${assertion.revision}`;
-    if (this.assertions.has(key2)) throw new LineageValidationError("IDENTITY_DUPLICATE", `Duplicate assertion revision ${key2}`);
+    const key3 = `${assertion.id}@${assertion.revision}`;
+    if (this.assertions.has(key3)) throw new LineageValidationError("IDENTITY_DUPLICATE", `Duplicate assertion revision ${key3}`);
     const prior = [...this.assertions.values()].some((entry) => entry.value.id === assertion.id);
     if (prior && !this.hasReplacementPermission(assertion.id, assertion.revision)) {
       throw new LineageValidationError("CORRECTION_INVALID", `Assertion ${assertion.id} can only receive revision ${assertion.revision} after an explicit correction`);
     }
-    return this.append(this.assertions, key2, assertion);
+    return this.append(this.assertions, key3, assertion);
   }
   appendCorrection(correction) {
     requireIdentity(correction.id, "correction.id");
@@ -4116,10 +4116,10 @@ var DatasetLineageLedger = class _DatasetLineageLedger {
       const correction = pending.splice(index, 1)[0];
       ledger.appendCorrection(correction);
       if (correction.replacementAssertionId && correction.replacementRevision) {
-        const key2 = `${correction.replacementAssertionId}@${correction.replacementRevision}`;
-        if (!ledger.assertions.has(key2)) {
-          const replacement = archive.assertions.find((item) => `${item.id}@${item.revision}` === key2);
-          if (!replacement) throw new LineageValidationError("IDENTITY_DANGLING", `Missing replacement assertion ${key2}`);
+        const key3 = `${correction.replacementAssertionId}@${correction.replacementRevision}`;
+        if (!ledger.assertions.has(key3)) {
+          const replacement = archive.assertions.find((item) => `${item.id}@${item.revision}` === key3);
+          if (!replacement) throw new LineageValidationError("IDENTITY_DANGLING", `Missing replacement assertion ${key3}`);
           ledger.appendAssertion(replacement);
         }
       }
@@ -4167,19 +4167,19 @@ var DatasetLineageLedger = class _DatasetLineageLedger {
       }
     });
   }
-  append(map, key2, value) {
+  append(map, key3, value) {
     this.sequence += 1;
-    map.set(key2, { sequence: this.sequence, value: clone2(value) });
+    map.set(key3, { sequence: this.sequence, value: clone2(value) });
     return this.sequence;
   }
-  ensureUnique(map, key2, label) {
-    if (map.has(key2)) throw new LineageValidationError("IDENTITY_DUPLICATE", `Duplicate ${label} identity ${key2}`);
+  ensureUnique(map, key3, label) {
+    if (map.has(key3)) throw new LineageValidationError("IDENTITY_DUPLICATE", `Duplicate ${label} identity ${key3}`);
   }
   visibleAt(map, snapshot) {
-    return new Map([...map].filter(([, entry]) => entry.sequence <= snapshot).map(([key2, entry]) => [key2, clone2(entry.value)]));
+    return new Map([...map].filter(([, entry]) => entry.sequence <= snapshot).map(([key3, entry]) => [key3, clone2(entry.value)]));
   }
-  sorted(map, key2 = (item) => item.id) {
-    return [...map.values()].sort((left, right) => key2(left).localeCompare(key2(right))).map(clone2);
+  sorted(map, key3 = (item) => item.id) {
+    return [...map.values()].sort((left, right) => key3(left).localeCompare(key3(right))).map(clone2);
   }
   hasReplacementPermission(assertionId, revision) {
     return [...this.corrections.values()].some((entry) => entry.value.action === "correct" && entry.value.replacementAssertionId === assertionId && entry.value.replacementRevision === revision);
@@ -4215,6 +4215,479 @@ function compareAssertions(left, right) {
 
 // src/dataset-execution-capabilities.ts
 init_geometry_buffer();
+
+// schemas/dataset-execution-capabilities/validation/1.0.1/schema.json
+var schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fortemi.dev/schemas/dataset-execution-capabilities/validation/1.0.1.schema.json",
+  title: "Dataset Capability Validation Revision 1.0.1 (v1 wire)",
+  oneOf: [
+    {
+      $ref: "#/$defs/descriptor"
+    },
+    {
+      $ref: "#/$defs/request"
+    },
+    {
+      $ref: "#/$defs/result"
+    }
+  ],
+  $defs: {
+    capabilityId: {
+      enum: [
+        "ingest.full",
+        "ingest.snapshot",
+        "ingest.incremental",
+        "ingest.stream",
+        "schema.inspect",
+        "identity.stable-revision",
+        "identity.record",
+        "mutation.upsert",
+        "mutation.tombstone",
+        "mutation.reconcile",
+        "checkpoint.read",
+        "checkpoint.write",
+        "execution.cancel",
+        "rejection.record",
+        "index.lexical",
+        "index.chunk",
+        "index.vector",
+        "index.hybrid",
+        "index.rerank",
+        "index.graph",
+        "index.community",
+        "lineage.dataset",
+        "lineage.record",
+        "lineage.field",
+        "lineage.relationship-evidence",
+        "transaction.atomic-batch",
+        "privacy.pre-materialization-filter",
+        "pagination.cursor",
+        "ordering.deterministic"
+      ]
+    },
+    semver: {
+      type: "string",
+      maxLength: 256,
+      pattern: "^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)(?:-((?:0|[1-9][0-9]*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\\.(?:0|[1-9][0-9]*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\\+([0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*))?$(?![\\s\\S])"
+    },
+    digest: {
+      type: "string",
+      pattern: "^[a-z0-9]+:[a-f0-9]+$"
+    },
+    limits: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxInputBytes: {
+          type: "integer",
+          minimum: 0,
+          maximum: 9007199254740991
+        },
+        maxRecordBytes: {
+          type: "integer",
+          minimum: 0,
+          maximum: 9007199254740991
+        },
+        maxBatchRecords: {
+          type: "integer",
+          minimum: 0,
+          maximum: 9007199254740991
+        },
+        maxConcurrency: {
+          type: "integer",
+          minimum: 0,
+          maximum: 9007199254740991
+        },
+        maxPageSize: {
+          type: "integer",
+          minimum: 0,
+          maximum: 9007199254740991
+        },
+        maxTraversalDepth: {
+          type: "integer",
+          minimum: 0,
+          maximum: 9007199254740991
+        }
+      }
+    },
+    evidence: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id",
+        "kind",
+        "uri"
+      ],
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        kind: {
+          enum: [
+            "fixture",
+            "conformance-report",
+            "live-qualification"
+          ]
+        },
+        uri: {
+          type: "string",
+          minLength: 1
+        },
+        digest: {
+          $ref: "#/$defs/digest"
+        }
+      }
+    },
+    capability: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id",
+        "version",
+        "status",
+        "evidence"
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/capabilityId"
+        },
+        version: {
+          $ref: "#/$defs/semver"
+        },
+        status: {
+          enum: [
+            "supported",
+            "experimental",
+            "unsupported"
+          ]
+        },
+        limits: {
+          $ref: "#/$defs/limits"
+        },
+        evidence: {
+          type: "array",
+          items: {
+            type: "string",
+            minLength: 1
+          },
+          uniqueItems: true
+        }
+      }
+    },
+    runtime: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id",
+        "version",
+        "plane",
+        "dataClass",
+        "maturity"
+      ],
+      properties: {
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        version: {
+          $ref: "#/$defs/semver"
+        },
+        plane: {
+          enum: [
+            "browser-local-archive",
+            "static-cache",
+            "portable-shard",
+            "server-process",
+            "live-remote-persistence"
+          ]
+        },
+        dataClass: {
+          enum: [
+            "canonical",
+            "regenerable-index",
+            "static-cache",
+            "portable-projection",
+            "remote-persistence"
+          ]
+        },
+        maturity: {
+          enum: [
+            "experimental",
+            "alpha",
+            "beta",
+            "stable"
+          ]
+        }
+      }
+    },
+    guarantees: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "transaction",
+        "isolation",
+        "durability",
+        "availability",
+        "ordering"
+      ],
+      properties: {
+        transaction: {
+          enum: [
+            "none",
+            "single-record",
+            "atomic-batch"
+          ]
+        },
+        isolation: {
+          enum: [
+            "none",
+            "snapshot",
+            "serializable"
+          ]
+        },
+        durability: {
+          enum: [
+            "process",
+            "memory",
+            "filesystem",
+            "wal",
+            "replicated"
+          ]
+        },
+        availability: {
+          enum: [
+            "local-process",
+            "single-host",
+            "remote-service"
+          ]
+        },
+        ordering: {
+          enum: [
+            "unspecified",
+            "stable-identity",
+            "backend-cursor"
+          ]
+        }
+      }
+    },
+    descriptor: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "contract",
+        "schemaVersion",
+        "runtime",
+        "guarantees",
+        "capabilities",
+        "evidence"
+      ],
+      properties: {
+        contract: {
+          const: "fortemi.dataset-execution-capabilities/v1"
+        },
+        schemaVersion: {
+          $ref: "#/$defs/semver"
+        },
+        runtime: {
+          $ref: "#/$defs/runtime"
+        },
+        guarantees: {
+          $ref: "#/$defs/guarantees"
+        },
+        capabilities: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/capability"
+          }
+        },
+        evidence: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/evidence"
+          }
+        }
+      }
+    },
+    requirement: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id"
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/capabilityId"
+        },
+        minimumVersion: {
+          $ref: "#/$defs/semver"
+        },
+        minimumLimits: {
+          $ref: "#/$defs/limits"
+        }
+      }
+    },
+    optionalRequirement: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "id"
+      ],
+      properties: {
+        id: {
+          $ref: "#/$defs/capabilityId"
+        },
+        minimumVersion: {
+          $ref: "#/$defs/semver"
+        },
+        minimumLimits: {
+          $ref: "#/$defs/limits"
+        },
+        fallback: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/capabilityId"
+          },
+          uniqueItems: true
+        }
+      }
+    },
+    request: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "contract",
+        "required"
+      ],
+      properties: {
+        contract: {
+          const: "fortemi.dataset-execution-capabilities/v1"
+        },
+        required: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/requirement"
+          }
+        },
+        optional: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/optionalRequirement"
+          }
+        }
+      }
+    },
+    diagnostic: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "code",
+        "message"
+      ],
+      properties: {
+        code: {
+          enum: [
+            "CONTRACT_MAJOR_UNSUPPORTED",
+            "SCHEMA_VERSION_UNSUPPORTED",
+            "DESCRIPTOR_INVALID",
+            "CAPABILITY_DUPLICATE",
+            "CAPABILITY_INCONSISTENT",
+            "REQUIRED_CAPABILITY_MISSING",
+            "CAPABILITY_VERSION_INSUFFICIENT",
+            "CAPABILITY_LIMIT_INSUFFICIENT"
+          ]
+        },
+        capability: {
+          $ref: "#/$defs/capabilityId"
+        },
+        path: {
+          type: "string"
+        },
+        message: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    degradation: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "requested",
+        "reason",
+        "changedGuarantees"
+      ],
+      properties: {
+        requested: {
+          $ref: "#/$defs/capabilityId"
+        },
+        selected: {
+          $ref: "#/$defs/capabilityId"
+        },
+        reason: {
+          enum: [
+            "unsupported",
+            "version-insufficient",
+            "limit-insufficient"
+          ]
+        },
+        changedGuarantees: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "string",
+            minLength: 1
+          }
+        }
+      }
+    },
+    result: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "contract",
+        "accepted",
+        "runtime",
+        "selected",
+        "degradations",
+        "diagnostics"
+      ],
+      properties: {
+        contract: {
+          const: "fortemi.dataset-execution-capabilities/v1"
+        },
+        accepted: {
+          type: "boolean"
+        },
+        runtime: {
+          $ref: "#/$defs/runtime"
+        },
+        selected: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/capabilityId"
+          },
+          uniqueItems: true
+        },
+        degradations: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/degradation"
+          }
+        },
+        diagnostics: {
+          type: "array",
+          items: {
+            $ref: "#/$defs/diagnostic"
+          }
+        }
+      }
+    }
+  }
+};
+
+// src/dataset-execution-capabilities.ts
 var DATASET_EXECUTION_CONTRACT = "fortemi.dataset-execution-capabilities/v1";
 var DATASET_EXECUTION_SCHEMA_VERSION = "1.0.0";
 var DATASET_EXECUTION_CAPABILITY_IDS = [
@@ -4250,27 +4723,64 @@ var DATASET_EXECUTION_CAPABILITY_IDS = [
 ];
 var ID_SET = new Set(DATASET_EXECUTION_CAPABILITY_IDS);
 var LIMIT_KEYS = ["maxInputBytes", "maxRecordBytes", "maxBatchRecords", "maxConcurrency", "maxPageSize", "maxTraversalDepth"];
+var versionPattern = new RegExp(schema_default.$defs.semver.pattern);
+var ajv = new Ajv20206({ strict: true, allErrors: false });
+ajv.addSchema(schema_default);
+var descriptorStructure = ajv.compile({ $ref: schema_default.$id + "#/$defs/descriptor" });
+var requestStructure = ajv.compile({ $ref: schema_default.$id + "#/$defs/request" });
+function parseVersion(value) {
+  if (typeof value !== "string" || value.length > 256) return null;
+  const match = versionPattern.exec(value);
+  if (!match || match[0] !== value) return null;
+  const core = match.slice(1, 4).map(Number);
+  if (!core.every(Number.isSafeInteger)) return null;
+  return { core, prerelease: match[4]?.split(".") ?? [] };
+}
 function major(version) {
-  const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version);
-  return match ? Number(match[1]) : null;
+  const parsed = parseVersion(version);
+  return parsed && parsed.prerelease.length === 0 ? parsed.core[0] : null;
 }
 function compareVersions(left, right) {
-  const parse = (value) => {
-    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(value);
-    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
-  };
-  const a = parse(left);
-  const b = parse(right);
+  const a = parseVersion(left);
+  const b = parseVersion(right);
   if (!a || !b) return null;
   for (let index = 0; index < 3; index++) {
-    if (a[index] !== b[index]) return a[index] > b[index] ? 1 : -1;
+    if (a.core[index] !== b.core[index]) return a.core[index] > b.core[index] ? 1 : -1;
+  }
+  if (!a.prerelease.length || !b.prerelease.length) {
+    return a.prerelease.length ? -1 : b.prerelease.length ? 1 : 0;
+  }
+  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index++) {
+    const leftPart = a.prerelease[index];
+    const rightPart = b.prerelease[index];
+    if (leftPart === rightPart) continue;
+    if (leftPart === void 0) return -1;
+    if (rightPart === void 0) return 1;
+    const leftNumeric = /^[0-9]+$/.test(leftPart);
+    const rightNumeric = /^[0-9]+$/.test(rightPart);
+    if (leftNumeric !== rightNumeric) return leftNumeric ? -1 : 1;
+    if (leftNumeric && leftPart.length !== rightPart.length) return leftPart.length > rightPart.length ? 1 : -1;
+    return leftPart > rightPart ? 1 : -1;
   }
   return 0;
 }
 function isSupported(capability) {
-  return capability !== void 0 && capability.status !== "unsupported";
+  return capability !== void 0 && (capability.status === "supported" || capability.status === "experimental");
+}
+function structuralDiagnostics(validate4, prefix = "") {
+  return (validate4.errors ?? []).slice(0, 8).map((error) => ({
+    code: "DESCRIPTOR_INVALID",
+    path: (prefix + error.instancePath).slice(0, 256),
+    message: "Invalid capability wire structure: " + error.keyword
+  }));
 }
 function validateDatasetExecutionDescriptor(descriptor) {
+  if (!descriptorStructure(descriptor)) {
+    if (descriptor && typeof descriptor === "object" && "contract" in descriptor && descriptor.contract !== DATASET_EXECUTION_CONTRACT) {
+      return [{ code: "CONTRACT_MAJOR_UNSUPPORTED", path: "/contract", message: "Unsupported descriptor contract" }];
+    }
+    return structuralDiagnostics(descriptorStructure);
+  }
   const diagnostics = [];
   if (descriptor.contract !== DATASET_EXECUTION_CONTRACT) {
     diagnostics.push({ code: "CONTRACT_MAJOR_UNSUPPORTED", path: "/contract", message: `Unsupported contract ${String(descriptor.contract)}` });
@@ -4278,6 +4788,9 @@ function validateDatasetExecutionDescriptor(descriptor) {
   if (major(descriptor.schemaVersion) !== 1) {
     diagnostics.push({ code: "SCHEMA_VERSION_UNSUPPORTED", path: "/schemaVersion", message: `Unsupported descriptor schema version ${descriptor.schemaVersion}` });
   }
+  if (!parseVersion(descriptor.runtime.version)) {
+    diagnostics.push({ code: "DESCRIPTOR_INVALID", path: "/runtime/version", message: "Invalid runtime semantic version" });
+  }
   const capabilities = /* @__PURE__ */ new Map();
   descriptor.capabilities.forEach((capability, index) => {
     if (!ID_SET.has(capability.id) || compareVersions(capability.version, capability.version) === null) {
@@ -4288,10 +4801,10 @@ function validateDatasetExecutionDescriptor(descriptor) {
       diagnostics.push({ code: "CAPABILITY_DUPLICATE", capability: capability.id, path: `/capabilities/${index}/id`, message: `Capability ${capability.id} is declared more than once` });
     }
     capabilities.set(capability.id, capability);
-    for (const key2 of LIMIT_KEYS) {
-      const value = capability.limits?.[key2];
+    for (const key3 of LIMIT_KEYS) {
+      const value = capability.limits?.[key3];
       if (value !== void 0 && (!Number.isSafeInteger(value) || value < 0)) {
-        diagnostics.push({ code: "DESCRIPTOR_INVALID", capability: capability.id, path: `/capabilities/${index}/limits/${key2}`, message: `${key2} must be a non-negative safe integer` });
+        diagnostics.push({ code: "DESCRIPTOR_INVALID", capability: capability.id, path: `/capabilities/${index}/limits/${key3}`, message: `${key3} must be a non-negative safe integer` });
       }
     }
     if (capability.status !== "unsupported" && capability.evidence.length === 0) {
@@ -4299,7 +4812,7 @@ function validateDatasetExecutionDescriptor(descriptor) {
     }
     for (const evidenceId of capability.evidence) {
       if (!descriptor.evidence.some((evidence) => evidence.id === evidenceId)) {
-        diagnostics.push({ code: "DESCRIPTOR_INVALID", capability: capability.id, path: `/capabilities/${index}/evidence`, message: `Unknown evidence ${evidenceId}` });
+        diagnostics.push({ code: "DESCRIPTOR_INVALID", capability: capability.id, path: `/capabilities/${index}/evidence`, message: "Capability references undeclared evidence" });
       }
     }
   });
@@ -4326,31 +4839,53 @@ function validateDatasetExecutionDescriptor(descriptor) {
   }
   return diagnostics;
 }
+function validateDatasetExecutionRequest(request) {
+  if (!requestStructure(request)) {
+    if (request && typeof request === "object" && "contract" in request && request.contract !== DATASET_EXECUTION_CONTRACT) {
+      return [{ code: "CONTRACT_MAJOR_UNSUPPORTED", path: "/request/contract", message: "Unsupported request contract" }];
+    }
+    return structuralDiagnostics(requestStructure, "/request");
+  }
+  const diagnostics = [];
+  for (const [group, requirements] of [["required", request.required], ["optional", request.optional ?? []]]) {
+    requirements.forEach((requirement, index) => {
+      if (requirement.minimumVersion !== void 0 && !parseVersion(requirement.minimumVersion)) {
+        diagnostics.push({ code: "DESCRIPTOR_INVALID", path: "/request/" + group + "/" + index + "/minimumVersion", message: "Invalid required semantic version" });
+      }
+    });
+  }
+  return diagnostics;
+}
+function negotiateDatasetExecutionCapabilitiesFromWire(descriptor, request) {
+  const diagnostics = [...validateDatasetExecutionDescriptor(descriptor), ...validateDatasetExecutionRequest(request)];
+  if (diagnostics.length) return { valid: false, diagnostics };
+  return {
+    valid: true,
+    result: negotiateDatasetExecutionCapabilities(descriptor, request)
+  };
+}
 function assessRequirement(requirement, capabilities) {
   const capability = capabilities.get(requirement.id);
   if (!isSupported(capability)) {
     return { ok: false, reason: "unsupported", diagnostics: [{ code: "REQUIRED_CAPABILITY_MISSING", capability: requirement.id, message: `Capability ${requirement.id} is unsupported` }] };
   }
-  if (requirement.minimumVersion) {
+  if (requirement.minimumVersion !== void 0) {
     const comparison = compareVersions(capability.version, requirement.minimumVersion);
     if (comparison === null || comparison < 0) {
       return { ok: false, reason: "version-insufficient", diagnostics: [{ code: "CAPABILITY_VERSION_INSUFFICIENT", capability: requirement.id, message: `${capability.version} does not satisfy ${requirement.minimumVersion}` }] };
     }
   }
-  for (const key2 of LIMIT_KEYS) {
-    const required = requirement.minimumLimits?.[key2];
-    if (required !== void 0 && (capability.limits?.[key2] ?? -1) < required) {
-      return { ok: false, reason: "limit-insufficient", diagnostics: [{ code: "CAPABILITY_LIMIT_INSUFFICIENT", capability: requirement.id, path: `/minimumLimits/${key2}`, message: `${key2} does not satisfy ${required}` }] };
+  for (const key3 of LIMIT_KEYS) {
+    const required = requirement.minimumLimits?.[key3];
+    if (required !== void 0 && (capability.limits?.[key3] ?? -1) < required) {
+      return { ok: false, reason: "limit-insufficient", diagnostics: [{ code: "CAPABILITY_LIMIT_INSUFFICIENT", capability: requirement.id, path: `/minimumLimits/${key3}`, message: `${key3} does not satisfy ${required}` }] };
     }
   }
   return { ok: true, diagnostics: [] };
 }
 function negotiateDatasetExecutionCapabilities(descriptor, request) {
-  const diagnostics = validateDatasetExecutionDescriptor(descriptor);
-  if (request.contract !== DATASET_EXECUTION_CONTRACT) {
-    diagnostics.push({ code: "CONTRACT_MAJOR_UNSUPPORTED", path: "/contract", message: `Unsupported request contract ${String(request.contract)}` });
-  }
-  const capabilities = new Map(descriptor.capabilities.map((capability) => [capability.id, capability]));
+  const diagnostics = [...validateDatasetExecutionDescriptor(descriptor), ...validateDatasetExecutionRequest(request)];
+  const capabilities = new Map(diagnostics.length ? [] : descriptor.capabilities.map((capability) => [capability.id, capability]));
   const selected = [];
   const degradations = [];
   if (diagnostics.length === 0) {
@@ -4378,7 +4913,7 @@ function negotiateDatasetExecutionCapabilities(descriptor, request) {
   return {
     contract: DATASET_EXECUTION_CONTRACT,
     accepted: diagnostics.length === 0,
-    runtime: { ...descriptor.runtime },
+    runtime: { ...descriptor?.runtime },
     selected: [...new Set(selected)],
     degradations,
     diagnostics
@@ -4451,7 +4986,7 @@ var encoder = new TextEncoder();
 function canonicalJson3(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
   if (Array.isArray(value)) return `[${value.map(canonicalJson3).join(",")}]`;
-  return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key2, item]) => `${JSON.stringify(key2)}:${canonicalJson3(item)}`).join(",")}}`;
+  return `{${Object.entries(value).filter(([, item]) => item !== void 0).sort(([left], [right]) => left.localeCompare(right)).map(([key3, item]) => `${JSON.stringify(key3)}:${canonicalJson3(item)}`).join(",")}}`;
 }
 function digestDatasetMaterializationValue(value) {
   return computeHash(encoder.encode(canonicalJson3(value)));
@@ -4542,7 +5077,7 @@ async function executeDatasetMaterialization(request, runtime, adapter, authoriz
   }
   const selected = [request.profile, ...options.fallbackProfiles ?? []].find((item) => item.id === negotiation.selectedProfile);
   try {
-    const validateConfiguration = new Ajv20202({ strict: true, allErrors: true }).compile(selected.configurationSchema);
+    const validateConfiguration = new Ajv20206({ strict: true, allErrors: true }).compile(selected.configurationSchema);
     if (!validateConfiguration(request.configuration)) {
       throw new DatasetMaterializationError("CONFIGURATION_INVALID", `Configuration does not satisfy ${selected.id}: ${JSON.stringify(validateConfiguration.errors)}`);
     }
@@ -6342,7 +6877,7 @@ function nativeIdentityKey(spec, row) {
 // src/migrations/0031_native_shard_lineage.ts
 var triggers = Object.entries(nativeIdentities).flatMap(([component, spec]) => (component === "links" ? ["link", "link_url_target"] : [spec.table]).map((table) => `
     CREATE TRIGGER native_lineage_delete AFTER DELETE ON ${table} FOR EACH ROW
-      EXECUTE FUNCTION delete_native_record_lineage('${component}', ${spec.keys.map((key2) => `'${key2}'`).join(", ")});`)).join("\n");
+      EXECUTE FUNCTION delete_native_record_lineage('${component}', ${spec.keys.map((key3) => `'${key3}'`).join(", ")});`)).join("\n");
 var migration0031 = {
   version: 31,
   name: "0031_native_shard_lineage",
@@ -6388,6 +6923,58 @@ var migration0032 = {
   `
 };
 
+// src/migrations/0033_typed_metadata_search.ts
+init_geometry_buffer();
+var migration0033 = {
+  version: 33,
+  name: "0033_typed_metadata_search",
+  sql: `
+    CREATE FUNCTION public.metadata_search_order_key_v1(value jsonb)
+    RETURNS numeric LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+    SET search_path = pg_catalog
+    AS $function$
+        SELECT CASE jsonb_typeof(value)
+            WHEN 'number' THEN trunc(greatest(-1e16::numeric,
+                least(1e16::numeric, (value #>> '{}')::numeric)), 18)
+            WHEN 'boolean' THEN CASE WHEN value = 'true'::jsonb THEN 1::numeric ELSE 0::numeric END
+            ELSE NULL::numeric
+        END
+    $function$;
+
+    CREATE FUNCTION public.metadata_search_text_key_v1(value jsonb)
+    RETURNS text LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE
+    SET search_path = pg_catalog
+    AS $function$
+        SELECT CASE WHEN jsonb_typeof(value) = 'string'
+            THEN left(value #>> '{}', 256) ELSE NULL::text END
+    $function$;
+
+    DO $metadata_indexes$
+    DECLARE metadata_path text;
+    BEGIN
+      FOREACH metadata_path IN ARRAY ARRAY['provider', 'model', 'role', 'event_kind', 'sensitivity']
+      LOOP
+        -- Superseded unbounded indexes can reject large values before query rechecks.
+        EXECUTE format('DROP INDEX %I', 'idx_note_metadata_' || metadata_path);
+        EXECUTE format('DROP INDEX %I', 'idx_note_native_metadata_' || metadata_path);
+        EXECUTE format(
+          'CREATE INDEX %I ON note (
+            (jsonb_typeof(metadata -> %L)),
+            (public.metadata_search_order_key_v1(metadata -> %L)),
+            (public.metadata_search_text_key_v1(metadata -> %L) COLLATE "C"))',
+          'idx_note_metadata_' || metadata_path || '_v1', metadata_path, metadata_path, metadata_path);
+      END LOOP;
+    END
+    $metadata_indexes$;
+
+    CREATE INDEX idx_source_identity_metadata_run_v1 ON source_identity
+      (tenant_id, import_run_id COLLATE "C", note_id);
+    CREATE INDEX idx_source_identity_metadata_note_v1 ON source_identity (tenant_id, note_id);
+    UPDATE metadata_index_path SET value_type = 'json-scalar-v1', indexed_at = now()
+      WHERE path IN ('provider', 'model', 'role', 'event_kind', 'sensitivity');
+  `
+};
+
 // src/migrations/index.ts
 var allMigrations = [
   migration0001,
@@ -6421,7 +7008,8 @@ var allMigrations = [
   migration0029,
   migration0030,
   migration0031,
-  migration0032
+  migration0032,
+  migration0033
 ];
 
 // src/data-archive.ts
@@ -7023,6 +7611,137 @@ var NotesRepository = class {
 // src/repositories/search-repository.ts
 init_geometry_buffer();
 
+// src/repositories/search-evidence-repository.ts
+init_geometry_buffer();
+
+// src/search-evidence.ts
+init_geometry_buffer();
+
+// schemas/metadata-search/candidate/1.0.0/evidence-locator.schema.json
+var evidence_locator_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fortemi.com/contracts/metadata-search/candidate/1.0.0/evidence-locator.schema.json",
+  title: "Candidate search evidence locator",
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "note_id", "unit", "content_digest", "span"],
+  properties: {
+    version: { const: "1.0.0" },
+    note_id: { $ref: "#/$defs/identifier" },
+    unit: {
+      type: "object",
+      additionalProperties: false,
+      required: ["kind", "id", "index"],
+      properties: {
+        kind: { enum: ["current", "title", "embedding", "attachment"] },
+        id: { $ref: "#/$defs/identifier" },
+        index: { type: "integer", minimum: 0, maximum: 2147483647 }
+      },
+      if: { properties: { kind: { enum: ["current", "title", "attachment"] } } },
+      then: { properties: { index: { const: 0 } } }
+    },
+    content_digest: { $ref: "#/$defs/digest" },
+    span: {
+      type: "object",
+      additionalProperties: false,
+      required: ["unit", "start", "end"],
+      properties: {
+        unit: { const: "utf8-bytes" },
+        start: { type: "integer", minimum: 0, maximum: 16777216 },
+        end: { type: "integer", minimum: 0, maximum: 16777216 }
+      }
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["namespace", "external_id_hash", "import_run_id", "schema_version"],
+      properties: {
+        namespace: { $ref: "#/$defs/identifier" },
+        external_id_hash: { $ref: "#/$defs/digest" },
+        import_run_id: { $ref: "#/$defs/identifier" },
+        schema_version: { $ref: "#/$defs/identifier" }
+      }
+    }
+  },
+  $defs: {
+    identifier: { type: "string", minLength: 1, maxLength: 200, pattern: "^[^\\u0000]+$" },
+    digest: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" }
+  }
+};
+
+// src/search-evidence.ts
+var MAX_EVIDENCE_BYTES = 16 * 1024 * 1024;
+var validateSchema = new Ajv20206({ strict: true, allErrors: false, ownProperties: true }).compile(evidence_locator_schema_default);
+var encoder2 = new TextEncoder();
+var decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+var invalid = () => new Error("SEARCH_EVIDENCE_INVALID");
+var unavailable = () => new Error("SEARCH_EVIDENCE_UNAVAILABLE");
+function wellFormed(value) {
+  for (let i = 0; i < value.length; i++) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(++i);
+      if (!(next >= 56320 && next <= 57343)) return false;
+    } else if (code >= 56320 && code <= 57343) return false;
+  }
+  return true;
+}
+function parseSearchEvidenceLocator(value) {
+  if (!validateSchema(value)) throw invalid();
+  const locator = value;
+  const strings = [locator.note_id, locator.unit.id, ...Object.values(locator.source ?? {})];
+  if (!strings.every(wellFormed) || locator.span.start > locator.span.end) throw invalid();
+  if ((locator.unit.kind === "current" || locator.unit.kind === "title") && locator.unit.id !== locator.note_id) throw invalid();
+  const copy = {
+    version: locator.version,
+    note_id: locator.note_id,
+    unit: Object.freeze({ kind: locator.unit.kind, id: locator.unit.id, index: locator.unit.index }),
+    content_digest: locator.content_digest,
+    span: Object.freeze({ unit: locator.span.unit, start: locator.span.start, end: locator.span.end }),
+    ...locator.source === void 0 ? {} : { source: Object.freeze({ ...locator.source }) }
+  };
+  return Object.freeze(copy);
+}
+function textBytes(content) {
+  if (typeof content !== "string" || content.length > MAX_EVIDENCE_BYTES || !wellFormed(content)) return null;
+  const bytes = encoder2.encode(content);
+  return bytes.length <= MAX_EVIDENCE_BYTES ? bytes : null;
+}
+function spanText(bytes, start, end) {
+  if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || start > end || end > bytes.length) return null;
+  if (start < bytes.length && (bytes[start] & 192) === 128 || end < bytes.length && (bytes[end] & 192) === 128) return null;
+  try {
+    return decoder.decode(bytes.subarray(start, end));
+  } catch {
+    return null;
+  }
+}
+function bindSearchEvidence(text, start, end) {
+  const bytes = textBytes(text.content);
+  if (!bytes || spanText(bytes, start, end) === null) throw invalid();
+  return parseSearchEvidenceLocator({
+    version: "1.0.0",
+    note_id: text.note_id,
+    unit: text.unit,
+    content_digest: computeHash(bytes),
+    span: { unit: "utf8-bytes", start, end },
+    ...text.source === void 0 ? {} : { source: text.source }
+  });
+}
+function sameSource(a, b) {
+  if (!a || !b) return a === b;
+  return a.namespace === b.namespace && a.external_id_hash === b.external_id_hash && a.import_run_id === b.import_run_id && a.schema_version === b.schema_version;
+}
+function resolveSearchEvidence(value, text) {
+  const locator = parseSearchEvidenceLocator(value);
+  if (!text || locator.note_id !== text.note_id || locator.unit.kind !== text.unit.kind || locator.unit.id !== text.unit.id || locator.unit.index !== text.unit.index || !sameSource(locator.source, text.source)) throw unavailable();
+  const bytes = textBytes(text.content);
+  if (!bytes || computeHash(bytes) !== locator.content_digest) throw unavailable();
+  const result = spanText(bytes, locator.span.start, locator.span.end);
+  if (result === null) throw unavailable();
+  return result;
+}
+
 // src/repositories/condition-builder.ts
 init_geometry_buffer();
 function buildNoteConditions(options, startIdx, includeDeleted = false) {
@@ -7038,6 +7757,11 @@ function buildNoteConditions(options, startIdx, includeDeleted = false) {
     );
     params.push(options.tags);
   }
+  if (options.tagsAll?.length) {
+    conditions.push(`NOT EXISTS (SELECT 1 FROM unnest($${idx++}::text[]) wanted(tag)
+      WHERE NOT EXISTS (SELECT 1 FROM note_tag nt WHERE nt.note_id = n.id AND nt.tag = wanted.tag))`);
+    params.push(options.tagsAll);
+  }
   if (options.collection_id) {
     conditions.push(
       `EXISTS (SELECT 1 FROM collection_note cn WHERE cn.note_id = n.id AND cn.collection_id = $${idx++})`
@@ -7068,6 +7792,10 @@ function buildNoteConditions(options, startIdx, includeDeleted = false) {
     conditions.push(`n.source = $${idx++}`);
     params.push(options.source);
   }
+  if (options.sources?.length) {
+    conditions.push(`n.source = ANY($${idx++}::text[])`);
+    params.push(options.sources);
+  }
   if (options.visibility) {
     conditions.push(`n.visibility = $${idx++}`);
     params.push(options.visibility);
@@ -7075,6 +7803,657 @@ function buildNoteConditions(options, startIdx, includeDeleted = false) {
   return { conditions, params, nextIdx: idx };
 }
 
+// src/repositories/metadata-predicates.ts
+init_geometry_buffer();
+
+// schemas/metadata-search/candidate/1.0.0/predicates.schema.json
+var predicates_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fortemi.dev/schemas/metadata-search/candidate/1.0.0/predicates.schema.json",
+  title: "Candidate typed metadata predicates",
+  type: "array",
+  maxItems: 8,
+  items: {
+    $ref: "#/$defs/predicate"
+  },
+  $defs: {
+    scalar: {
+      oneOf: [
+        {
+          type: "string",
+          maxLength: 256,
+          pattern: "^[^\\u0000]*$"
+        },
+        {
+          type: "number",
+          minimum: -9007199254740991,
+          maximum: 9007199254740991
+        },
+        {
+          type: "boolean"
+        },
+        {
+          type: "null"
+        }
+      ]
+    },
+    bound: {
+      oneOf: [
+        {
+          type: "string",
+          maxLength: 256,
+          pattern: "^[^\\u0000]*$"
+        },
+        {
+          type: "number",
+          minimum: -9007199254740991,
+          maximum: 9007199254740991
+        }
+      ]
+    },
+    predicate: {
+      oneOf: [
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "path",
+            "op",
+            "value"
+          ],
+          properties: {
+            path: {
+              enum: [
+                "provider",
+                "model",
+                "role",
+                "event_kind",
+                "sensitivity",
+                "import_run_id"
+              ]
+            },
+            op: {
+              const: "eq"
+            },
+            value: {
+              $ref: "#/$defs/scalar"
+            }
+          },
+          allOf: [
+            {
+              if: {
+                properties: {
+                  path: {
+                    const: "import_run_id"
+                  }
+                }
+              },
+              then: {
+                properties: {
+                  value: {
+                    type: "string",
+                    maxLength: 200,
+                    pattern: "^[^\\u0000]*$",
+                    minLength: 1
+                  }
+                }
+              }
+            }
+          ]
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "path",
+            "op",
+            "value"
+          ],
+          properties: {
+            path: {
+              enum: [
+                "provider",
+                "model",
+                "role",
+                "event_kind",
+                "sensitivity",
+                "import_run_id"
+              ]
+            },
+            op: {
+              const: "in"
+            },
+            value: {
+              type: "array",
+              maxItems: 32,
+              items: {
+                $ref: "#/$defs/scalar"
+              }
+            }
+          },
+          allOf: [
+            {
+              if: {
+                properties: {
+                  path: {
+                    const: "import_run_id"
+                  }
+                }
+              },
+              then: {
+                properties: {
+                  value: {
+                    type: "array",
+                    items: {
+                      type: "string",
+                      maxLength: 200,
+                      pattern: "^[^\\u0000]*$",
+                      minLength: 1
+                    }
+                  }
+                }
+              }
+            }
+          ]
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "path",
+            "op"
+          ],
+          properties: {
+            path: {
+              enum: [
+                "provider",
+                "model",
+                "role",
+                "event_kind",
+                "sensitivity",
+                "import_run_id"
+              ]
+            },
+            op: {
+              const: "range"
+            },
+            gte: {
+              $ref: "#/$defs/bound"
+            },
+            lte: {
+              $ref: "#/$defs/bound"
+            }
+          },
+          anyOf: [
+            {
+              properties: {
+                gte: {
+                  $ref: "#/$defs/bound"
+                }
+              },
+              required: [
+                "gte"
+              ]
+            },
+            {
+              properties: {
+                lte: {
+                  $ref: "#/$defs/bound"
+                }
+              },
+              required: [
+                "lte"
+              ]
+            }
+          ],
+          oneOf: [
+            {
+              properties: {
+                gte: {
+                  type: "string",
+                  maxLength: 256,
+                  pattern: "^[^\\u0000]*$"
+                },
+                lte: {
+                  type: "string",
+                  maxLength: 256,
+                  pattern: "^[^\\u0000]*$"
+                }
+              }
+            },
+            {
+              properties: {
+                gte: {
+                  type: "number",
+                  minimum: -9007199254740991,
+                  maximum: 9007199254740991
+                },
+                lte: {
+                  type: "number",
+                  minimum: -9007199254740991,
+                  maximum: 9007199254740991
+                }
+              }
+            }
+          ],
+          allOf: [
+            {
+              if: {
+                properties: {
+                  path: {
+                    const: "import_run_id"
+                  }
+                }
+              },
+              then: {
+                properties: {
+                  gte: {
+                    type: "string",
+                    maxLength: 200,
+                    pattern: "^[^\\u0000]*$",
+                    minLength: 1
+                  },
+                  lte: {
+                    type: "string",
+                    maxLength: 200,
+                    pattern: "^[^\\u0000]*$",
+                    minLength: 1
+                  }
+                }
+              }
+            }
+          ]
+        },
+        {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "path",
+            "op"
+          ],
+          properties: {
+            path: {
+              enum: [
+                "provider",
+                "model",
+                "role",
+                "event_kind",
+                "sensitivity",
+                "import_run_id"
+              ]
+            },
+            op: {
+              const: "exists"
+            },
+            value: {
+              type: "boolean"
+            }
+          }
+        }
+      ]
+    }
+  }
+};
+
+// src/repositories/metadata-predicates.ts
+var REGISTERED_METADATA_PATHS = [
+  "provider",
+  "model",
+  "role",
+  "event_kind",
+  "sensitivity",
+  "import_run_id"
+];
+var validateSchema2 = new Ajv20206({ strict: true, allErrors: false, ownProperties: true }).compile(predicates_schema_default);
+function compareStrings(left, right) {
+  const a = Array.from(left, (char) => char.codePointAt(0));
+  const b = Array.from(right, (char) => char.codePointAt(0));
+  for (let i = 0; i < Math.min(a.length, b.length); i++) {
+    if (a[i] !== b[i]) return a[i] - b[i];
+  }
+  return a.length - b.length;
+}
+function validateMetadataPredicates(value) {
+  if (!validateSchema2(value)) throw new Error("METADATA_PREDICATES_INVALID");
+  const predicates = value;
+  for (const predicate of predicates) {
+    const values = predicate.op === "range" ? [predicate.gte, predicate.lte] : predicate.op === "in" ? predicate.value : [predicate.value];
+    for (const scalar of values) {
+      if (typeof scalar === "string" && Array.from(scalar).some((char) => {
+        const code = char.codePointAt(0);
+        return code >= 55296 && code <= 57343;
+      })) throw new Error("METADATA_PREDICATES_INVALID");
+    }
+  }
+  for (const predicate of predicates) {
+    if (predicate.op !== "range" || predicate.gte === void 0 || predicate.lte === void 0) continue;
+    const reversed = typeof predicate.gte === "string" ? compareStrings(predicate.gte, predicate.lte) > 0 : predicate.gte > predicate.lte;
+    if (reversed) throw new Error("METADATA_RANGE_INVALID");
+  }
+}
+function predicateSql(predicate, compare, exists) {
+  switch (predicate.op) {
+    case "eq":
+      return compare(predicate.value, "=");
+    case "in":
+      return predicate.value.length ? `(${predicate.value.map((value) => compare(value, "=")).join(" OR ")})` : "FALSE";
+    case "range":
+      return `(${[
+        predicate.gte === void 0 ? null : compare(predicate.gte, ">="),
+        predicate.lte === void 0 ? null : compare(predicate.lte, "<=")
+      ].filter(Boolean).join(" AND ")})`;
+    case "exists":
+      return predicate.value === false ? `NOT (${exists})` : exists;
+  }
+}
+function buildMetadataSourceConditions(options, startIdx) {
+  const predicates = options.metadataPredicates === void 0 ? [] : options.metadataPredicates;
+  validateMetadataPredicates(predicates);
+  const params = [options.tenant_id ?? "default"];
+  let idx = startIdx + 1;
+  const conditions = [
+    `si.note_id = n.id`,
+    `si.tenant_id = $${startIdx}`,
+    "si.archive_id IS NOT DISTINCT FROM n.archive_id",
+    "si.import_run_id IS NOT NULL"
+  ];
+  for (const predicate of predicates.filter((p) => p.path === "import_run_id")) {
+    conditions.push(predicateSql(predicate, (value, op) => {
+      params.push(value);
+      return `si.import_run_id COLLATE "C" ${op} $${idx++}::text COLLATE "C"`;
+    }, "si.import_run_id IS NOT NULL"));
+  }
+  return { conditions, joins: [], params, nextIdx: idx };
+}
+function buildMetadataPredicateConditions(options, startIdx) {
+  const predicates = options.metadataPredicates === void 0 ? [] : options.metadataPredicates;
+  validateMetadataPredicates(predicates);
+  const conditions = [];
+  const params = [];
+  const joins = [];
+  let idx = startIdx;
+  if (options.archive_id !== void 0) {
+    conditions.push(`n.archive_id IS NOT DISTINCT FROM $${idx++}::text`);
+    params.push(options.archive_id);
+  }
+  if (options.tenant_id !== void 0) {
+    const source = buildMetadataSourceConditions({ ...options, metadataPredicates: [] }, idx);
+    const native = options.tenant_id === "default" ? " OR NOT EXISTS (SELECT 1 FROM source_identity si WHERE si.note_id = n.id)" : "";
+    conditions.push(`(EXISTS (SELECT 1 FROM source_identity si WHERE ${source.conditions.join(" AND ")})${native})`);
+    params.push(...source.params);
+    idx = source.nextIdx;
+  }
+  for (const predicate of predicates) {
+    if (predicate.path === "import_run_id") continue;
+    const lhs = `(n.metadata -> '${predicate.path}')`;
+    conditions.push(predicateSql(predicate, (value, op) => {
+      if (value === null) return `jsonb_typeof(${lhs}) = 'null'`;
+      const rhs = `$${idx++}::jsonb`;
+      params.push(JSON.stringify(value));
+      const type = typeof value;
+      if (type === "string") {
+        return `(jsonb_typeof(${lhs}) = 'string'
+          AND public.metadata_search_order_key_v1(${lhs}) IS NULL
+          AND public.metadata_search_text_key_v1(${lhs}) COLLATE "C" ${op} public.metadata_search_text_key_v1(${rhs}) COLLATE "C"
+          AND (${lhs} #>> '{}') COLLATE "C" ${op} (${rhs} #>> '{}') COLLATE "C")`;
+      }
+      return `(jsonb_typeof(${lhs}) = '${type}'
+        AND public.metadata_search_order_key_v1(${lhs}) ${op} public.metadata_search_order_key_v1(${rhs})
+        AND ${lhs} ${op} ${rhs})`;
+    }, `jsonb_typeof(${lhs}) IS NOT NULL`));
+  }
+  const runs = predicates.filter((p) => p.path === "import_run_id");
+  if (runs.length) {
+    const positive = runs.filter((p) => !(p.op === "exists" && p.value === false));
+    for (const [selected, negated] of [[positive, false], [[], true]]) {
+      if (negated ? !runs.some((p) => p.op === "exists" && p.value === false) : !positive.length) continue;
+      const source = buildMetadataSourceConditions({ ...options, metadataPredicates: selected }, idx);
+      conditions.push(`${negated ? "NOT " : ""}EXISTS (SELECT 1 FROM source_identity si WHERE ${source.conditions.join(" AND ")})`);
+      params.push(...source.params);
+      idx = source.nextIdx;
+    }
+  }
+  return { conditions, joins, params, nextIdx: idx };
+}
+
+// src/repositories/search-evidence-repository.ts
+function validateScope(scope) {
+  if (!scope || typeof scope !== "object" || Array.isArray(scope) || ![Object.prototype, null].includes(Object.getPrototypeOf(scope)) || Object.keys(scope).some((key3) => !["tenant_id", "archive_id", "visibility", "metadataPredicates"].includes(key3))) {
+    throw new Error("SEARCH_EVIDENCE_INVALID");
+  }
+  for (const key3 of ["tenant_id", "archive_id", "visibility"]) {
+    const value = scope[key3];
+    if (value === void 0 || key3 === "archive_id" && value === null) continue;
+    if (typeof value !== "string" || value.length === 0 || value.includes("\0") || Array.from(value).some((char) => {
+      const code = char.codePointAt(0);
+      return code >= 55296 && code <= 57343;
+    })) throw new Error("SEARCH_EVIDENCE_INVALID");
+  }
+}
+async function resolveStoredSearchEvidence(db, value, scope = {}) {
+  const locator = parseSearchEvidenceLocator(value);
+  validateScope(scope);
+  const options = { ...scope, tenant_id: scope.tenant_id ?? "default" };
+  const notes = buildNoteConditions(options, 5);
+  const metadata2 = buildMetadataPredicateConditions(options, notes.nextIdx);
+  const params = [
+    locator.note_id,
+    locator.unit.id,
+    locator.unit.index,
+    MAX_EVIDENCE_BYTES,
+    ...notes.params,
+    ...metadata2.params
+  ];
+  const conditions = ["n.id = $1", ...notes.conditions, ...metadata2.conditions];
+  let joins;
+  let content;
+  switch (locator.unit.kind) {
+    case "current":
+      joins = "JOIN note_revised_current c ON c.note_id = n.id";
+      content = "c.content";
+      conditions.push("n.id = $2", "$3::integer = 0");
+      break;
+    case "title":
+      joins = "";
+      content = "n.title";
+      conditions.push("n.id = $2", "$3::integer = 0");
+      break;
+    case "embedding":
+      joins = "JOIN embedding e ON e.note_id = n.id";
+      content = "e.text";
+      conditions.push("e.id = $2", "e.chunk_index = $3");
+      break;
+    case "attachment":
+      joins = "JOIN attachment a ON a.note_id = n.id";
+      content = "a.extracted_text";
+      conditions.push("a.id = $2", "$3::integer = 0", "a.status = 'completed'", "a.deleted_at IS NULL");
+      break;
+  }
+  if (locator.source) {
+    const source = buildMetadataSourceConditions(options, metadata2.nextIdx);
+    let idx = source.nextIdx;
+    conditions.push(`EXISTS (SELECT 1 FROM source_identity si
+      WHERE ${source.conditions.join(" AND ")}
+        AND si.namespace = $${idx++} AND si.external_id_hash = $${idx++}
+        AND si.import_run_id = $${idx++} AND si.source_schema_version = $${idx++})`);
+    params.push(
+      ...source.params,
+      locator.source.namespace,
+      locator.source.external_id_hash,
+      locator.source.import_run_id,
+      locator.source.schema_version
+    );
+  }
+  const result = await db.query(
+    `SELECT CASE WHEN octet_length(${content}) <= $4
+       THEN encode(convert_to(${content}, 'UTF8'), 'hex') ELSE NULL END AS content_hex
+     FROM note n ${joins} ${metadata2.joins.join(" ")}
+     WHERE ${conditions.join(" AND ")} LIMIT 1`,
+    params
+  );
+  const row = result.rows[0];
+  return resolveSearchEvidence(locator, row?.content_hex == null ? null : {
+    note_id: locator.note_id,
+    unit: locator.unit,
+    content: new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(hexToBytes(row.content_hex)),
+    ...locator.source === void 0 ? {} : { source: locator.source }
+  });
+}
+
+// src/repositories/search-evidence-projection.ts
+init_geometry_buffer();
+
+// src/search-evidence-set.ts
+init_geometry_buffer();
+
+// schemas/metadata-search/candidate/1.0.0/evidence-set.schema.json
+var evidence_set_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fortemi.com/contracts/metadata-search/candidate/1.0.0/evidence-set.schema.json",
+  title: "Candidate per-hit search evidence envelope",
+  type: "object",
+  additionalProperties: false,
+  required: ["version", "locators", "omissions"],
+  properties: {
+    version: { const: "1.0.0" },
+    locators: {
+      type: "array",
+      maxItems: 64,
+      uniqueItems: true,
+      items: { $ref: "evidence-locator.schema.json" }
+    },
+    omissions: {
+      type: "array",
+      maxItems: 2,
+      uniqueItems: true,
+      items: { enum: ["unavailable-unit", "locator-limit"] }
+    }
+  },
+  if: { properties: { locators: { type: "array", maxItems: 0 } } },
+  then: { properties: { omissions: { type: "array", minItems: 1 } } }
+};
+
+// src/search-evidence-set.ts
+var MAX_SEARCH_LOCATORS = 64;
+var EVIDENCE_OMISSIONS = ["unavailable-unit", "locator-limit"];
+var validate = new Ajv20206({ strict: true, allErrors: false, ownProperties: true }).addSchema(evidence_locator_schema_default).compile(evidence_set_schema_default);
+var invalid2 = () => new Error("SEARCH_EVIDENCE_INVALID");
+var priorities = { embedding: 0, title: 1, current: 2, attachment: 3 };
+function scalarCompare(left, right) {
+  const a = Array.from(left, (char) => char.codePointAt(0));
+  const b = Array.from(right, (char) => char.codePointAt(0));
+  for (let i = 0; i < Math.min(a.length, b.length); i++) if (a[i] !== b[i]) return a[i] - b[i];
+  return a.length - b.length;
+}
+function key(locator) {
+  return [
+    priorities[locator.unit.kind],
+    locator.unit.id,
+    locator.unit.index,
+    locator.content_digest,
+    locator.span.start,
+    locator.span.end,
+    locator.source ? 1 : 0,
+    locator.source?.namespace ?? "",
+    locator.source?.external_id_hash ?? "",
+    locator.source?.import_run_id ?? "",
+    locator.source?.schema_version ?? ""
+  ];
+}
+function compareSearchEvidence(left, right) {
+  const a = key(left), b = key(right);
+  for (let i = 0; i < a.length; i++) {
+    const cmp = typeof a[i] === "number" ? a[i] - b[i] : scalarCompare(a[i], b[i]);
+    if (cmp !== 0) return cmp;
+  }
+  return 0;
+}
+function parseSearchEvidenceSet(value, noteId) {
+  if (!validate(value)) throw invalid2();
+  const locators = value.locators.map(parseSearchEvidenceLocator);
+  if (locators.some((locator, i) => locator.note_id !== noteId || i > 0 && compareSearchEvidence(locators[i - 1], locator) >= 0)) throw invalid2();
+  if (value.omissions.some((reason, i) => i > 0 && EVIDENCE_OMISSIONS.indexOf(value.omissions[i - 1]) >= EVIDENCE_OMISSIONS.indexOf(reason))) throw invalid2();
+  return Object.freeze({ version: "1.0.0", locators: Object.freeze(locators), omissions: Object.freeze([...value.omissions]) });
+}
+function createSearchEvidenceSet(noteId, values, omissions = []) {
+  const parsed = values.map(parseSearchEvidenceLocator);
+  if (parsed.some((locator) => locator.note_id !== noteId) || omissions.some((reason) => !EVIDENCE_OMISSIONS.includes(reason))) throw invalid2();
+  const locators = parsed.sort(compareSearchEvidence).filter((locator, i, all) => i === 0 || compareSearchEvidence(all[i - 1], locator) !== 0);
+  const reasons = new Set(omissions);
+  if (locators.length > MAX_SEARCH_LOCATORS) reasons.add("locator-limit");
+  if (locators.length === 0) reasons.add("unavailable-unit");
+  return parseSearchEvidenceSet({
+    version: "1.0.0",
+    locators: locators.slice(0, MAX_SEARCH_LOCATORS),
+    omissions: EVIDENCE_OMISSIONS.filter((reason) => reasons.has(reason))
+  }, noteId);
+}
+function mergeSearchEvidenceSets(noteId, sets) {
+  const checked2 = sets.map((set) => parseSearchEvidenceSet(set, noteId));
+  return createSearchEvidenceSet(noteId, checked2.flatMap((set) => [...set.locators]), checked2.flatMap((set) => [...set.omissions]));
+}
+
+// src/repositories/search-evidence-projection.ts
+function buildSearchEvidenceProjection(options, startIdx, match) {
+  const source = buildMetadataSourceConditions(options, startIdx);
+  const scope = buildMetadataPredicateConditions({ tenant_id: options.tenant_id ?? "default", archive_id: options.archive_id }, source.nextIdx);
+  const units = [];
+  if (match.lexical) {
+    const query = `${match.lexical.fn}('english', $${match.lexical.parameter})`;
+    units.push(`SELECT 1 AS priority, 'title'::text AS kind, n.id AS id, 0 AS index, n.title AS content
+      WHERE to_tsvector('english', n.title) @@ ${query}`);
+    units.push(`SELECT 2, 'current', n.id, 0, c.content
+      WHERE to_tsvector('english', c.content) @@ ${query}`);
+    units.push(`SELECT 3, 'attachment', a.id, 0, a.extracted_text FROM attachment a
+      WHERE a.note_id = n.id AND a.deleted_at IS NULL AND a.status = 'completed'
+        AND to_tsvector('english', a.extracted_text) @@ ${query}`);
+  }
+  if (match.embedding) units.push("SELECT 0, 'embedding'::text, e.id, e.chunk_index, NULLIF(e.text, '')");
+  if (units.length === 0) throw new Error("SEARCH_EVIDENCE_INVALID");
+  return {
+    params: [...source.params, ...scope.params],
+    nextIdx: scope.nextIdx,
+    sql: `(WITH units(priority, kind, id, index, content) AS (${units.join(" UNION ALL ")}),
+      sources AS (
+        SELECT DISTINCT si.namespace COLLATE "C" AS namespace, si.external_id_hash COLLATE "C" AS external_id_hash,
+          si.import_run_id COLLATE "C" AS import_run_id, si.source_schema_version COLLATE "C" AS source_schema_version
+        FROM source_identity si WHERE ${source.conditions.join(" AND ")}
+        ORDER BY si.namespace COLLATE "C", si.external_id_hash COLLATE "C",
+          si.import_run_id COLLATE "C", si.source_schema_version COLLATE "C"
+        LIMIT ${MAX_SEARCH_LOCATORS + 1}
+      ), candidates AS MATERIALIZED (
+        SELECT u.*, s.namespace, s.external_id_hash, s.import_run_id, s.source_schema_version
+        FROM units u LEFT JOIN sources s ON true
+        ORDER BY u.priority, u.id COLLATE "C", u.index, s.namespace COLLATE "C",
+          s.external_id_hash COLLATE "C", s.import_run_id COLLATE "C", s.source_schema_version COLLATE "C"
+        LIMIT ${MAX_SEARCH_LOCATORS + 1}
+      ), bound AS (
+        SELECT CASE WHEN ${scope.conditions.join(" AND ")}
+          AND char_length(n.id) BETWEEN 1 AND 200 AND char_length(id) BETWEEN 1 AND 200
+          AND index BETWEEN 0 AND 2147483647 AND octet_length(content) <= ${MAX_EVIDENCE_BYTES}
+          AND (namespace IS NULL OR (char_length(namespace) BETWEEN 1 AND 200
+            AND external_id_hash ~ '^sha256:[a-f0-9]{64}$'
+            AND char_length(import_run_id) BETWEEN 1 AND 200
+            AND char_length(source_schema_version) BETWEEN 1 AND 200))
+        THEN jsonb_build_object('version', '1.0.0', 'note_id', n.id,
+          'unit', jsonb_build_object('kind', kind, 'id', id, 'index', index),
+          'content_digest', 'sha256:' || encode(sha256(convert_to(content, 'UTF8')), 'hex'),
+          'span', jsonb_build_object('unit', 'utf8-bytes', 'start', 0, 'end', octet_length(content)))
+          || CASE WHEN namespace IS NULL THEN '{}'::jsonb ELSE jsonb_build_object('source',
+            jsonb_build_object('namespace', namespace, 'external_id_hash', external_id_hash,
+              'import_run_id', import_run_id, 'schema_version', source_schema_version)) END
+        ELSE NULL END AS locator FROM candidates
+      ) SELECT jsonb_build_object('locators', coalesce(jsonb_agg(locator), '[]'::jsonb),
+        'limited', count(*) > ${MAX_SEARCH_LOCATORS}) FROM bound)`
+  };
+}
+function projectedSearchEvidence(noteId, value) {
+  return createSearchEvidenceSet(noteId, value.locators.filter((locator) => locator !== null), [
+    ...value.locators.some((locator) => locator === null) ? ["unavailable-unit"] : [],
+    ...value.limited ? ["locator-limit"] : []
+  ]);
+}
+
 // src/repositories/embedding-sets-repository.ts
 init_geometry_buffer();
 var ATTACHMENT_TEXT_JOIN = `
@@ -7654,91 +9033,6 @@ var EmbeddingSetsRepository = class {
   }
 };
 
-// src/repositories/metadata-predicates.ts
-init_geometry_buffer();
-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 `n.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 (
@@ -7760,6 +9054,10 @@ var SearchRepository = class {
     this.db = db;
     this.semanticAvailable = semanticAvailable;
   }
+  /** Candidate citation resolution with fresh local scope and content checks. */
+  async resolveEvidence(locator, scope = {}) {
+    return resolveStoredSearchEvidence(this.db, locator, scope);
+  }
   tsqueryFn(query) {
     return query.includes('"') ? "phraseto_tsquery" : "plainto_tsquery";
   }
@@ -7769,7 +9067,7 @@ var SearchRepository = class {
     const setFilter = embeddingSetId ? " AND embedding_set_id = $2" : "";
     if (embeddingSetId) params.push(embeddingSetId);
     const result = await this.db.query(
-      "SELECT note_id FROM embedding WHERE vector IS NOT NULL AND note_id = ANY($1)" + setFilter,
+      "SELECT to_jsonb(note_id) AS note_id FROM embedding WHERE vector IS NOT NULL AND note_id = ANY($1)" + setFilter,
       params
     );
     return new Set(result.rows.map((r) => r.note_id));
@@ -7813,15 +9111,17 @@ var SearchRepository = class {
   attachEmbeddingStatus(results, embeddingSet) {
     return results.map((r) => ({ ...r, has_embedding: embeddingSet.has(r.id) }));
   }
-  async fetchLocatorMap(noteIds, metadataPaths = []) {
+  async fetchLocatorMap(noteIds, options) {
     const locators = /* @__PURE__ */ new Map();
     if (noteIds.length === 0) return locators;
+    const metadataPaths = this.metadataPaths(options);
+    const source = buildMetadataSourceConditions(options, 2);
     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]
+      `SELECT to_jsonb(si.note_id) AS note_id, si.namespace, si.external_id_hash, si.import_run_id, si.source_schema_version
+       FROM source_identity si JOIN note n ON n.id = si.note_id
+       WHERE n.id = ANY($1) AND ${source.conditions.join(" AND ")}
+       ORDER BY si.created_at ASC, si.id ASC`,
+      [noteIds, ...source.params]
     );
     for (const row of result.rows) {
       const existing = locators.get(row.note_id) ?? [];
@@ -7849,6 +9149,7 @@ var SearchRepository = class {
     return [...new Set((options.metadataPredicates ?? []).map((predicate) => predicate.path))];
   }
   async search(query, options = {}, queryEmbedding) {
+    validateMetadataPredicates(options.metadataPredicates === void 0 ? [] : options.metadataPredicates);
     const { limit = 20, offset = 0 } = options;
     const mode = options.mode ?? "auto";
     if (mode === "text") {
@@ -7894,9 +9195,11 @@ var SearchRepository = class {
       allParams
     );
     const total = parseInt(countResult.rows[0].count, 10);
-    const searchParams = [...allParams, limit, offset];
+    const evidence = buildSearchEvidenceProjection(options, paramIdx, { lexical: { fn: tsqFn, parameter: 1 } });
+    paramIdx = evidence.nextIdx;
+    const searchParams = [...allParams, ...evidence.params, limit, offset];
     const result = await this.db.query(
-      `SELECT n.id, n.title, n.created_at, n.updated_at,
+      `SELECT to_jsonb(n.id) AS id, n.title, n.created_at, n.updated_at, ${evidence.sql} AS evidence_projection,
               ts_rank(
                 setweight(n.tsv, 'A') || setweight(${COMBINED_TEXT_VECTOR_SQL2}, 'B'),
                 ${tsqFn}('english', $1)
@@ -7924,7 +9227,7 @@ var SearchRepository = class {
     let facets;
     if (options.include_facets) {
       const idsResult = await this.db.query(
-        `SELECT n.id FROM note n
+        `SELECT to_jsonb(n.id) AS id FROM note n
          LEFT JOIN note_revised_current c ON c.note_id = n.id
          ${metadata2.joins.join("\n")}
          ${ATTACHMENT_TEXT_JOIN2}
@@ -7933,7 +9236,7 @@ var SearchRepository = class {
       );
       facets = await this.fetchFacets(idsResult.rows.map((r) => r.id));
     }
-    const locatorMap = await this.fetchLocatorMap(resultIds, this.metadataPaths(options));
+    const locatorMap = await this.fetchLocatorMap(resultIds, options);
     const baseResults = result.rows.map((r) => ({
       id: r.id,
       title: r.title,
@@ -7942,7 +9245,8 @@ var SearchRepository = class {
       created_at: r.created_at,
       updated_at: r.updated_at,
       tags: tagMap.get(r.id) ?? [],
-      locators: locatorMap.get(r.id) ?? []
+      locators: locatorMap.get(r.id) ?? [],
+      evidence: projectedSearchEvidence(r.id, r.evidence_projection)
     }));
     return {
       results: this.attachEmbeddingStatus(baseResults, embeddingSet),
@@ -7956,6 +9260,7 @@ var SearchRepository = class {
     };
   }
   async semanticSearch(queryEmbedding, options = {}) {
+    validateMetadataPredicates(options.metadataPredicates === void 0 ? [] : options.metadataPredicates);
     const { limit = 20, offset = 0 } = options;
     const vector = vectorColumn(queryEmbedding);
     const vectorStr = `[${queryEmbedding.join(",")}]`;
@@ -7977,11 +9282,14 @@ var SearchRepository = class {
       params
     );
     const total = parseInt(countResult.rows[0].count, 10);
+    const evidence = buildSearchEvidenceProjection(options, paramIdx, { embedding: true });
+    paramIdx = evidence.nextIdx;
     const vecIdx = paramIdx++;
     const limIdx = paramIdx++;
     const offIdx = paramIdx++;
     const result = await this.db.query(
-      `SELECT * FROM (SELECT DISTINCT ON (n.id) n.id, n.title, n.created_at, n.updated_at,
+      `SELECT * FROM (SELECT DISTINCT ON (n.id) to_jsonb(n.id) AS id, n.title, n.created_at, n.updated_at,
+              ${evidence.sql} AS evidence_projection,
               (${vector} <=> $${vecIdx}::vector) as distance,
               LEFT(${COMBINED_TEXT_SQL}, 200) as snippet
        FROM embedding e
@@ -7993,11 +9301,11 @@ var SearchRepository = class {
        ORDER BY n.id, ${vector} <=> $${vecIdx}::vector ASC, e.id) AS best_chunks
        ORDER BY distance ASC, id
        LIMIT $${limIdx} OFFSET $${offIdx}`,
-      [...params, vectorStr, limit, offset]
+      [...params, ...evidence.params, vectorStr, limit, offset]
     );
     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
+      `SELECT to_jsonb(n.id) AS 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
@@ -8005,7 +9313,7 @@ var SearchRepository = class {
            WHERE ${where}`,
       params
     )).rows.map((r) => r.id)) : void 0;
-    const locatorMap = await this.fetchLocatorMap(result.rows.map((r) => r.id), this.metadataPaths(options));
+    const locatorMap = await this.fetchLocatorMap(result.rows.map((r) => r.id), options);
     return {
       results: result.rows.map((r) => ({
         id: r.id,
@@ -8016,7 +9324,8 @@ var SearchRepository = class {
         updated_at: r.updated_at,
         tags: tagMap.get(r.id) ?? [],
         has_embedding: true,
-        locators: locatorMap.get(r.id) ?? []
+        locators: locatorMap.get(r.id) ?? [],
+        evidence: projectedSearchEvidence(r.id, r.evidence_projection)
       })),
       total,
       query: "",
@@ -8028,6 +9337,7 @@ var SearchRepository = class {
     };
   }
   async hybridSearch(query, queryEmbedding, options = {}) {
+    validateMetadataPredicates(options.metadataPredicates === void 0 ? [] : options.metadataPredicates);
     const { limit = 20, offset = 0 } = options;
     const vectorStr = `[${queryEmbedding.join(",")}]`;
     const k = 60;
@@ -8042,11 +9352,12 @@ var SearchRepository = class {
         ${COMBINED_TEXT_VECTOR_SQL2} @@ ${tsqFn}('english', $1))`
     ];
     textCond.params.push(...textMeta.params);
-    this.scopeToResolvedEmbeddingSet(textConditions, textCond.params, textMeta.nextIdx, resolvedEmbeddingSet);
+    const textNextIdx = this.scopeToResolvedEmbeddingSet(textConditions, textCond.params, textMeta.nextIdx, resolvedEmbeddingSet);
     const textWhere = textConditions.join(" AND ");
-    const textParams = [query, ...textCond.params];
+    const textEvidence = buildSearchEvidenceProjection(options, textNextIdx, { lexical: { fn: tsqFn, parameter: 1 } });
+    const textParams = [query, ...textCond.params, ...textEvidence.params];
     const textResult = await this.db.query(
-      `SELECT n.id,
+      `SELECT to_jsonb(n.id) AS id, ${textEvidence.sql} AS evidence_projection,
               ts_rank(
                 setweight(n.tsv, 'A') || setweight(${COMBINED_TEXT_VECTOR_SQL2}, 'B'),
                 ${tsqFn}('english', $1)
@@ -8068,9 +9379,11 @@ var SearchRepository = class {
     const vector = vectorColumn(queryEmbedding);
     vecCond.conditions.push(`vector_dims(e.vector) = ${queryEmbedding.length}`);
     const vecWhere = vecCond.conditions.join(" AND ");
-    const vecVecIdx = vecCond.nextIdx;
+    const vectorEvidence = buildSearchEvidenceProjection(options, vecCond.nextIdx, { embedding: true });
+    const vecVecIdx = vectorEvidence.nextIdx;
     const vectorResult = await this.db.query(
-      `SELECT * FROM (SELECT DISTINCT ON (n.id) n.id, (${vector} <=> $${vecVecIdx}::vector) as distance
+      `SELECT * FROM (SELECT DISTINCT ON (n.id) to_jsonb(n.id) AS id, ${vectorEvidence.sql} AS evidence_projection,
+              (${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
@@ -8079,9 +9392,15 @@ var SearchRepository = class {
        ORDER BY n.id, ${vector} <=> $${vecVecIdx}::vector ASC, e.id) AS best_chunks
        ORDER BY distance ASC, id
        LIMIT 100`,
-      [...vecCond.params, vectorStr]
+      [...vecCond.params, ...vectorEvidence.params, vectorStr]
     );
     const rrfScores = /* @__PURE__ */ new Map();
+    const evidenceMap = /* @__PURE__ */ new Map();
+    for (const row of [...textResult.rows, ...vectorResult.rows]) {
+      const existing = evidenceMap.get(row.id) ?? [];
+      existing.push(projectedSearchEvidence(row.id, row.evidence_projection));
+      evidenceMap.set(row.id, existing);
+    }
     textResult.rows.forEach((row, idx) => {
       rrfScores.set(row.id, (rrfScores.get(row.id) ?? 0) + 1 / (k + idx + 1));
     });
@@ -8094,21 +9413,24 @@ var SearchRepository = class {
     if (pageIds.length === 0) {
       return { results: [], total, query, mode: "hybrid", semantic_available: this.semanticAvailable, limit, offset };
     }
+    const displayConditions = buildNoteConditions(options, 2);
+    const displayMetadata = buildMetadataPredicateConditions(options, displayConditions.nextIdx);
     const noteResult = await this.db.query(
-      `SELECT n.id, n.title, n.created_at, n.updated_at,
+      `SELECT to_jsonb(n.id) AS id, n.title, n.created_at, n.updated_at,
               LEFT(${COMBINED_TEXT_SQL}, 200) as snippet
        FROM note n
        LEFT JOIN note_revised_current c ON c.note_id = n.id
        ${ATTACHMENT_TEXT_JOIN2}
-       WHERE n.id = ANY($1)`,
-      [pageIds]
+       ${displayMetadata.joins.join("\n")}
+       WHERE n.id = ANY($1) AND ${[...displayConditions.conditions, ...displayMetadata.conditions].join(" AND ")}`,
+      [pageIds, ...displayConditions.params, ...displayMetadata.params]
     );
     const noteMap = new Map(noteResult.rows.map((r) => [r.id, r]));
     const [tagMap, embeddingSet] = await Promise.all([
       this.fetchTagMap(pageIds),
       this.fetchEmbeddingStatus(pageIds, resolvedEmbeddingSet, options.embeddingSetId)
     ]);
-    const locatorMap = await this.fetchLocatorMap(pageIds, this.metadataPaths(options));
+    const locatorMap = await this.fetchLocatorMap(pageIds, options);
     const facets = options.include_facets ? await this.fetchFacets(sortedIds) : void 0;
     return {
       results: pageIds.map((id) => {
@@ -8123,7 +9445,8 @@ var SearchRepository = class {
           updated_at: r.updated_at,
           tags: tagMap.get(id) ?? [],
           has_embedding: embeddingSet.has(id),
-          locators: locatorMap.get(id) ?? []
+          locators: locatorMap.get(id) ?? [],
+          evidence: mergeSearchEvidenceSets(id, evidenceMap.get(id) ?? [])
         };
       }).filter((r) => r !== null),
       total,
@@ -8155,7 +9478,7 @@ var SearchRepository = class {
     const total = parseInt(countResult.rows[0].count, 10);
     const listParams = [...params, limit, offset];
     const result = await this.db.query(
-      `SELECT n.id, n.title, n.created_at, n.updated_at,
+      `SELECT to_jsonb(n.id) AS id, n.title, n.created_at, n.updated_at,
               LEFT(${COMBINED_TEXT_SQL}, 200) as snippet
        FROM note n
        LEFT JOIN note_revised_current c ON c.note_id = n.id
@@ -8168,7 +9491,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));
+    const locatorMap = await this.fetchLocatorMap(resultIds, options);
     return {
       results: result.rows.map((r) => ({
         id: r.id,
@@ -8213,7 +9536,7 @@ var SearchRepository = class {
     const tagMap = /* @__PURE__ */ new Map();
     if (noteIds.length === 0) return tagMap;
     const tagsResult = await this.db.query(
-      `SELECT note_id, tag FROM note_tag WHERE note_id = ANY($1) ORDER BY tag`,
+      `SELECT to_jsonb(note_id) AS note_id, tag FROM note_tag WHERE note_id = ANY($1) ORDER BY tag`,
       [noteIds]
     );
     for (const row of tagsResult.rows) {
@@ -8457,7 +9780,7 @@ init_geometry_buffer();
 // src/shard/full-v1-references.ts
 init_geometry_buffer();
 var uuid2 = (value) => typeof value === "string" ? value.toLowerCase() : value;
-var key = (...values) => JSON.stringify(values);
+var key2 = (...values) => JSON.stringify(values);
 var present = (value) => value !== null && value !== void 0;
 function fullV1ReferenceErrors(records) {
   const errors = [];
@@ -8515,7 +9838,7 @@ function fullV1ReferenceErrors(records) {
       const id = uuid2(attachment.id);
       check(!attachmentIds.has(id), "notes", index, "duplicate attachment identity");
       attachmentIds.add(id);
-      const declaration = key(attachment.bytes, attachment.mime);
+      const declaration = key2(attachment.bytes, attachment.mime);
       check(
         !digests.has(attachment.checksum) || digests.get(attachment.checksum) === declaration,
         "notes",
@@ -8541,7 +9864,7 @@ function fullV1ReferenceErrors(records) {
     }
   });
   ids2("note_original_history");
-  unique2("note_original_history", (row) => key(uuid2(row.note_id), row.version_number));
+  unique2("note_original_history", (row) => key2(uuid2(row.note_id), row.version_number));
   rows("note_original_history").forEach((row, index) => {
     ref(row, "note_id", notes, "note_original_history", index);
     const current = originals.get(uuid2(row.note_id));
@@ -8553,7 +9876,7 @@ function fullV1ReferenceErrors(records) {
     );
   });
   const revisionIds = ids2("note_revisions");
-  unique2("note_revisions", (row) => key(uuid2(row.note_id), row.revision_number));
+  unique2("note_revisions", (row) => key2(uuid2(row.note_id), row.revision_number));
   const revisions = new Map(rows("note_revisions").map((row) => [uuid2(row.id), row]));
   rows("note_revisions").forEach((row, index) => {
     ref(row, "note_id", notes, "note_revisions", index);
@@ -8608,7 +9931,7 @@ function fullV1ReferenceErrors(records) {
     ref(row, "named_location_id", namedLocations, "provenance_locations", index, true);
   });
   const devices = ids2("provenance_devices");
-  unique2("provenance_devices", (row) => key(row.device_make, row.device_model, uuid2(row.owner_id)));
+  unique2("provenance_devices", (row) => key2(row.device_make, row.device_model, uuid2(row.owner_id)));
   ids2("provenance_records");
   unique2("provenance_records", (row) => uuid2(row.note_id));
   rows("provenance_records").forEach((row, index) => {
@@ -8640,13 +9963,13 @@ function fullV1ReferenceErrors(records) {
     const config = configRows.get(uuid2(row.embedding_config_id));
     if (config) dimensions.set(uuid2(row.id), Number(row.truncate_dim ?? config.dimension));
   });
-  unique2("embedding_set_members", (row) => key(uuid2(row.embedding_set_id), uuid2(row.note_id)));
+  unique2("embedding_set_members", (row) => key2(uuid2(row.embedding_set_id), uuid2(row.note_id)));
   rows("embedding_set_members").forEach((row, index) => {
     ref(row, "embedding_set_id", sets, "embedding_set_members", index);
     ref(row, "note_id", notes, "embedding_set_members", index);
   });
   ids2("embeddings");
-  unique2("embeddings", (row) => present(row.note_id) && present(row.embedding_set_id) ? key(uuid2(row.note_id), uuid2(row.embedding_set_id), row.chunk_index) : null);
+  unique2("embeddings", (row) => present(row.note_id) && present(row.embedding_set_id) ? key2(uuid2(row.note_id), uuid2(row.embedding_set_id), row.chunk_index) : null);
   rows("embeddings").forEach((row, index) => {
     ref(row, "note_id", notes, "embeddings", index, true);
     ref(row, "embedding_set_id", sets, "embeddings", index, true);
@@ -8664,34 +9987,34 @@ function fullV1ReferenceErrors(records) {
   unique2("skos_schemes", (row) => row.uri);
   const concepts = ids2("skos_concepts");
   unique2("skos_concepts", (row) => row.uri);
-  unique2("skos_concepts", (row) => present(row.notation) ? key(uuid2(row.primary_scheme_id), row.notation) : null);
+  unique2("skos_concepts", (row) => present(row.notation) ? key2(uuid2(row.primary_scheme_id), row.notation) : null);
   rows("skos_concepts").forEach((row, index) => {
     ref(row, "primary_scheme_id", schemes, "skos_concepts", index);
     ref(row, "replaced_by_id", concepts, "skos_concepts", index, true);
     check(uuid2(row.replaced_by_id) !== uuid2(row.id), "skos_concepts", index, "concept replaces itself");
   });
   ids2("skos_labels");
-  unique2("skos_labels", (row) => key(uuid2(row.concept_id), row.label_type, row.language, row.value));
-  unique2("skos_labels", (row) => row.label_type === "pref_label" ? key(uuid2(row.concept_id), row.language) : null);
+  unique2("skos_labels", (row) => key2(uuid2(row.concept_id), row.label_type, row.language, row.value));
+  unique2("skos_labels", (row) => row.label_type === "pref_label" ? key2(uuid2(row.concept_id), row.language) : null);
   rows("skos_labels").forEach((row, index) => ref(row, "concept_id", concepts, "skos_labels", index));
   ids2("skos_notes");
   rows("skos_notes").forEach((row, index) => ref(row, "concept_id", concepts, "skos_notes", index));
   ids2("skos_relations");
-  unique2("skos_relations", (row) => key(uuid2(row.subject_id), uuid2(row.object_id), row.relation_type));
+  unique2("skos_relations", (row) => key2(uuid2(row.subject_id), uuid2(row.object_id), row.relation_type));
   rows("skos_relations").forEach((row, index) => {
     ref(row, "subject_id", concepts, "skos_relations", index);
     ref(row, "object_id", concepts, "skos_relations", index);
     check(uuid2(row.subject_id) !== uuid2(row.object_id), "skos_relations", index, "self relation is invalid");
   });
   ids2("skos_mapping_relations");
-  unique2("skos_mapping_relations", (row) => key(uuid2(row.concept_id), row.target_uri, row.relation_type));
+  unique2("skos_mapping_relations", (row) => key2(uuid2(row.concept_id), row.target_uri, row.relation_type));
   rows("skos_mapping_relations").forEach((row, index) => ref(row, "concept_id", concepts, "skos_mapping_relations", index));
-  unique2("skos_scheme_memberships", (row) => key(uuid2(row.concept_id), uuid2(row.scheme_id)));
+  unique2("skos_scheme_memberships", (row) => key2(uuid2(row.concept_id), uuid2(row.scheme_id)));
   rows("skos_scheme_memberships").forEach((row, index) => {
     ref(row, "concept_id", concepts, "skos_scheme_memberships", index);
     ref(row, "scheme_id", schemes, "skos_scheme_memberships", index);
   });
-  unique2("note_skos_tags", (row) => key(uuid2(row.note_id), uuid2(row.concept_id)));
+  unique2("note_skos_tags", (row) => key2(uuid2(row.note_id), uuid2(row.concept_id)));
   rows("note_skos_tags").forEach((row, index) => {
     ref(row, "note_id", notes, "note_skos_tags", index);
     ref(row, "concept_id", concepts, "note_skos_tags", index);
@@ -8699,7 +10022,7 @@ function fullV1ReferenceErrors(records) {
   const skosCollections = ids2("skos_collections");
   unique2("skos_collections", (row) => row.uri);
   rows("skos_collections").forEach((row, index) => ref(row, "scheme_id", schemes, "skos_collections", index, true));
-  unique2("skos_collection_members", (row) => key(uuid2(row.collection_id), uuid2(row.concept_id)));
+  unique2("skos_collection_members", (row) => key2(uuid2(row.collection_id), uuid2(row.concept_id)));
   rows("skos_collection_members").forEach((row, index) => {
     ref(row, "collection_id", skosCollections, "skos_collection_members", index);
     ref(row, "concept_id", concepts, "skos_collection_members", index);
@@ -8715,7 +10038,7 @@ function fullV1ReferenceErrors(records) {
       );
     }
   });
-  unique2("graph_edges", (row) => key(row.graph_source_id, uuid2(row.from_note_id), uuid2(row.to_note_id), row.kind));
+  unique2("graph_edges", (row) => key2(row.graph_source_id, uuid2(row.from_note_id), uuid2(row.to_note_id), row.kind));
   rows("graph_edges").forEach((row, index) => {
     ref(row, "graph_source_id", sources, "graph_edges", index, false, false);
     ref(row, "from_note_id", notes, "graph_edges", index);
@@ -8727,7 +10050,7 @@ function fullV1ReferenceErrors(records) {
   rows("communities").forEach((row, index) => {
     ref(row, "graph_source_id", sources, "communities", index, false, false);
     for (const community of row.communities) {
-      const id = key(row.id, community.id);
+      const id = key2(row.id, community.id);
       check(!communities.has(id), "communities", index, "duplicate community identity within set");
       communities.add(id);
       const representatives = /* @__PURE__ */ new Set();
@@ -8742,10 +10065,10 @@ function fullV1ReferenceErrors(records) {
       }
     }
   });
-  unique2("community_assignments", (row) => key(row.community_set_id, uuid2(row.note_id)));
+  unique2("community_assignments", (row) => key2(row.community_set_id, uuid2(row.note_id)));
   rows("community_assignments").forEach((row, index) => {
     check(
-      communities.has(key(row.community_set_id, row.community_id)),
+      communities.has(key2(row.community_set_id, row.community_id)),
       "community_assignments",
       index,
       "community does not belong to the declared set"
@@ -18704,15 +20027,15 @@ init_geometry_buffer();
 var CURRENT_SHARD_VERSION = "1.2.0";
 var MAX_SHARD_READER_VERSION = "2.0.0";
 var SHARD_FORMAT = "matric-shard";
-function parseVersion(value) {
+function parseVersion2(value) {
   return value.split(".").map((segment) => {
     const match = segment.match(/^\d+/);
     return match ? Number.parseInt(match[0], 10) : 0;
   });
 }
 function compareShardVersions(left, right) {
-  const leftParts = parseVersion(left);
-  const rightParts = parseVersion(right);
+  const leftParts = parseVersion2(left);
+  const rightParts = parseVersion2(right);
   const length = Math.max(leftParts.length, rightParts.length);
   for (let index = 0; index < length; index += 1) {
     const leftValue = leftParts[index] ?? 0;
@@ -18748,7 +20071,7 @@ function collectSidecarBlobs(files) {
 }
 
 // src/shard/schema-validator.ts
-var decoder = new TextDecoder();
+var decoder2 = new TextDecoder();
 var LEGACY_COMPONENT_SCHEMA_DEFS = {
   notes: "note",
   collections: "collection",
@@ -19004,13 +20327,13 @@ function getKnowledgeShardSchema() {
 function getKnowledgeShardContractReceipt() {
   return knowledge_shard_schema_receipt_default;
 }
-function addCanonicalFormats(ajv) {
-  ajv.addFormat("uuid", /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
-  ajv.addFormat("date-time", {
+function addCanonicalFormats(ajv3) {
+  ajv3.addFormat("uuid", /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+  ajv3.addFormat("date-time", {
     type: "string",
     validate: (value) => /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && !Number.isNaN(Date.parse(value))
   });
-  ajv.addFormat("uri", {
+  ajv3.addFormat("uri", {
     type: "string",
     validate: (value) => {
       try {
@@ -19023,7 +20346,7 @@ function addCanonicalFormats(ajv) {
 }
 function getLegacyAjv() {
   if (!legacyAjvInstance) {
-    legacyAjvInstance = new Ajv20202({
+    legacyAjvInstance = new Ajv20206({
       allErrors: true,
       strict: true,
       validateFormats: false
@@ -19034,7 +20357,7 @@ function getLegacyAjv() {
 }
 function getCoreAjv() {
   if (!coreAjvInstance) {
-    coreAjvInstance = new Ajv20202({
+    coreAjvInstance = new Ajv20206({
       allErrors: true,
       strict: true,
       validateFormats: true
@@ -19054,7 +20377,7 @@ function getCoreAjv() {
 }
 function getRecordAjv() {
   if (!recordAjvInstance) {
-    recordAjvInstance = new Ajv20202({
+    recordAjvInstance = new Ajv20206({
       allErrors: true,
       strict: true,
       validateFormats: true
@@ -19074,7 +20397,7 @@ function getRecordAjv() {
 }
 function getFullAjv() {
   if (!fullAjvInstance) {
-    fullAjvInstance = new Ajv20202({
+    fullAjvInstance = new Ajv20206({
       allErrors: true,
       strict: true,
       validateFormats: true
@@ -19109,30 +20432,30 @@ function fullSchemaVersion(value) {
   return value === "1.1.0" || value === "1.2.0" || value === "2.0.0" ? value : void 0;
 }
 function coreValidatorFor(name, version = CURRENT_SHARD_VERSION) {
-  const key2 = `${version}:${name}`;
-  const cached = coreValidators.get(key2);
+  const key3 = `${version}:${name}`;
+  const cached = coreValidators.get(key3);
   if (cached) return cached;
   const schema = CORE_V1_SCHEMAS[version][name];
   const validator = getCoreAjv().getSchema(schema.$id) ?? getCoreAjv().compile(schema);
-  coreValidators.set(key2, validator);
+  coreValidators.set(key3, validator);
   return validator;
 }
 function recordValidatorFor(name, version = CURRENT_SHARD_VERSION) {
-  const key2 = `${version}:${name}`;
-  const cached = recordValidators.get(key2);
+  const key3 = `${version}:${name}`;
+  const cached = recordValidators.get(key3);
   if (cached) return cached;
   const schema = RECORD_V1_SCHEMAS[version][name];
   const validator = getRecordAjv().getSchema(schema.$id) ?? getRecordAjv().compile(schema);
-  recordValidators.set(key2, validator);
+  recordValidators.set(key3, validator);
   return validator;
 }
 function fullValidatorFor(name, version = CURRENT_SHARD_VERSION) {
-  const key2 = `${version}:${name}`;
-  const cached = fullValidators.get(key2);
+  const key3 = `${version}:${name}`;
+  const cached = fullValidators.get(key3);
   if (cached) return cached;
   const schema = FULL_V1_SCHEMAS[version][name];
   const validator = getFullAjv().getSchema(schema.$id) ?? getFullAjv().compile(schema);
-  fullValidators.set(key2, validator);
+  fullValidators.set(key3, validator);
   return validator;
 }
 function formatErrors(errors) {
@@ -19147,7 +20470,7 @@ function profileOf(value) {
   return typeof profile === "string" ? profile : void 0;
 }
 function validateShardManifest(value) {
-  let validate3;
+  let validate4;
   const profile = profileOf(value);
   if (profile === "core-v1") {
     const version = value && typeof value === "object" && !Array.isArray(value) ? coreSchemaVersion(String(value.version ?? "")) : void 0;
@@ -19157,7 +20480,7 @@ function validateShardManifest(value) {
         errors: ["(root) uses an unsupported canonical core-v1 schema version"]
       };
     }
-    validate3 = coreValidatorFor("manifest", version);
+    validate4 = coreValidatorFor("manifest", version);
   } else if (profile === "record-v1") {
     const version = value && typeof value === "object" && !Array.isArray(value) ? recordSchemaVersion(String(value.version ?? "")) : void 0;
     if (!version) {
@@ -19166,7 +20489,7 @@ function validateShardManifest(value) {
         errors: ["(root) uses an unsupported canonical record-v1 schema version"]
       };
     }
-    validate3 = recordValidatorFor("manifest", version);
+    validate4 = recordValidatorFor("manifest", version);
   } else if (profile === "full-v1") {
     const version = value && typeof value === "object" && !Array.isArray(value) ? fullSchemaVersion(String(value.version ?? "")) : void 0;
     if (!version) {
@@ -19175,17 +20498,17 @@ function validateShardManifest(value) {
         errors: ["(root) uses an unsupported canonical full-v1 schema version"]
       };
     }
-    validate3 = fullValidatorFor("manifest", version);
+    validate4 = fullValidatorFor("manifest", version);
   } else {
-    validate3 = legacyValidatorFor("manifest");
+    validate4 = legacyValidatorFor("manifest");
   }
-  const valid = validate3(value);
-  return { valid, errors: formatErrors(validate3.errors) };
+  const valid = validate4(value);
+  return { valid, errors: formatErrors(validate4.errors) };
 }
 function parseJsonArray(bytes, path) {
   if (!bytes) return { records: [], errors: [] };
   try {
-    const value = JSON.parse(decoder.decode(bytes));
+    const value = JSON.parse(decoder2.decode(bytes));
     if (!Array.isArray(value)) return { records: [], errors: [`${path} must be a JSON array`] };
     return { records: value, errors: [] };
   } catch {
@@ -19194,7 +20517,7 @@ function parseJsonArray(bytes, path) {
 }
 function parseJsonl(bytes, path) {
   if (!bytes) return { records: [], errors: [] };
-  const text = decoder.decode(bytes).trim();
+  const text = decoder2.decode(bytes).trim();
   if (!text) return { records: [], errors: [] };
   const records = [];
   const errors = [];
@@ -19438,7 +20761,7 @@ function validateFullV1Structure(files, manifest) {
   const signatureBytes = files.get("signature.json");
   if (signatureBytes) {
     try {
-      const signature = JSON.parse(decoder.decode(signatureBytes));
+      const signature = JSON.parse(decoder2.decode(signatureBytes));
       const signatureValidator = fullValidatorFor("signature", schemaVersion);
       if (!signatureValidator(signature)) {
         errors.push(
@@ -19534,7 +20857,7 @@ function validateShardArchive(input) {
   if (!manifestBytes) return { valid: false, errors: ["manifest.json is missing"] };
   let manifest;
   try {
-    manifest = JSON.parse(decoder.decode(manifestBytes));
+    manifest = JSON.parse(decoder2.decode(manifestBytes));
   } catch {
     return { valid: false, errors: ["manifest.json failed to parse as JSON"] };
   }
@@ -19553,7 +20876,7 @@ async function validateCoreV1ShardArchive(input) {
   if (!manifestBytes) return { valid: false, errors: ["manifest.json is missing"] };
   let manifest;
   try {
-    manifest = JSON.parse(decoder.decode(manifestBytes));
+    manifest = JSON.parse(decoder2.decode(manifestBytes));
   } catch {
     return { valid: false, errors: ["manifest.json failed to parse as JSON"] };
   }
@@ -19576,7 +20899,7 @@ async function validateRecordV1ShardArchive(input) {
   if (!manifestBytes) return { valid: false, errors: ["manifest.json is missing"] };
   let manifest;
   try {
-    manifest = JSON.parse(decoder.decode(manifestBytes));
+    manifest = JSON.parse(decoder2.decode(manifestBytes));
   } catch {
     return { valid: false, errors: ["manifest.json failed to parse as JSON"] };
   }
@@ -19599,7 +20922,7 @@ async function validateFullV1ShardArchive(input) {
   if (!manifestBytes) return { valid: false, errors: ["manifest.json is missing"] };
   let manifest;
   try {
-    manifest = JSON.parse(decoder.decode(manifestBytes));
+    manifest = JSON.parse(decoder2.decode(manifestBytes));
   } catch {
     return { valid: false, errors: ["manifest.json failed to parse as JSON"] };
   }
@@ -19628,9 +20951,9 @@ async function validateFullV1ShardArchive(input) {
   return { valid: errors.length === 0, errors };
 }
 function validateShardComponentRecord(component, value, profile, version = CURRENT_SHARD_VERSION) {
-  let validate3;
+  let validate4;
   if (profile === "core-v1" && component in CORE_V1_COMPONENT_FILES) {
-    validate3 = coreValidatorFor(component, version);
+    validate4 = coreValidatorFor(component, version);
   } else if (profile === "record-v1" && component in RECORD_V1_COMPONENT_FILES) {
     const canonicalVersion = recordSchemaVersion(version);
     if (!canonicalVersion) {
@@ -19639,7 +20962,7 @@ function validateShardComponentRecord(component, value, profile, version = CURRE
         errors: [`(root) uses an unsupported canonical record-v1 schema version ${version}`]
       };
     }
-    validate3 = recordValidatorFor(component, canonicalVersion);
+    validate4 = recordValidatorFor(component, canonicalVersion);
   } else if (profile === "full-v1" && component in FULL_V1_COMPONENT_FILES) {
     const canonicalVersion = fullSchemaVersion(version);
     if (!canonicalVersion) {
@@ -19648,7 +20971,7 @@ function validateShardComponentRecord(component, value, profile, version = CURRE
         errors: [`(root) uses an unsupported canonical full-v1 schema version ${version}`]
       };
     }
-    validate3 = fullValidatorFor(component, canonicalVersion);
+    validate4 = fullValidatorFor(component, canonicalVersion);
   } else {
     const legacyDef = LEGACY_COMPONENT_SCHEMA_DEFS[component];
     if (!legacyDef) {
@@ -19657,10 +20980,10 @@ function validateShardComponentRecord(component, value, profile, version = CURRE
         errors: [`(root) component '${component}' requires an explicit full-v1 profile`]
       };
     }
-    validate3 = legacyValidatorFor(legacyDef);
+    validate4 = legacyValidatorFor(legacyDef);
   }
-  const valid = validate3(value);
-  return { valid, errors: formatErrors(validate3.errors) };
+  const valid = validate4(value);
+  return { valid, errors: formatErrors(validate4.errors) };
 }
 function assertShardComponentRecord(component, value, profile, version = CURRENT_SHARD_VERSION) {
   const result = validateShardComponentRecord(component, value, profile, version);
@@ -19977,6 +21300,12 @@ var ManageNoteInputSchema = z.object({
 });
 var SearchInputSchema = z.object({
   query: z.string(),
+  metadataPredicates: z.unknown().transform((value) => {
+    validateMetadataPredicates(value);
+    return value;
+  }).optional(),
+  tenant_id: z.string().min(1).optional(),
+  archive_id: z.string().min(1).nullable().optional(),
   mode: z.enum(["text", "semantic", "hybrid", "auto"]).default("text"),
   query_embedding: z.array(z.number()).optional(),
   embeddingSetId: z.string().optional(),
@@ -20041,6 +21370,366 @@ async function manageNote(db, rawInput, events) {
 
 // src/remote-contract.ts
 init_geometry_buffer();
+
+// src/remote-search-schema.ts
+init_geometry_buffer();
+
+// schemas/metadata-search/candidate/1.0.0/search-rest.schema.json
+var search_rest_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fortemi.com/contracts/metadata-search/candidate/1.0.0/search-rest.schema.json",
+  title: "Candidate canonical GET search request and response",
+  description: "Producer authority candidate. Schema validation is supplemented by same-note/canonical evidence binding, exact returned totals, strict-filter aggregate count and metadata range semantics. No auth grant or complete capability promotion.",
+  $defs: {
+    StrictSearchFilterInput: {
+      type: "object",
+      description: "Decoded strict_filter JSON. Unknown keys retain legacy ignored behavior. Sum of the five list lengths must not exceed 1000; name resolution still requires current authorized storage.",
+      additionalProperties: true,
+      properties: {
+        required_tags: {
+          type: "array",
+          maxItems: 1e3,
+          items: {
+            type: "string"
+          },
+          default: []
+        },
+        any_tags: {
+          type: "array",
+          maxItems: 1e3,
+          items: {
+            type: "string"
+          },
+          default: []
+        },
+        excluded_tags: {
+          type: "array",
+          maxItems: 1e3,
+          items: {
+            type: "string"
+          },
+          default: []
+        },
+        required_schemes: {
+          type: "array",
+          maxItems: 1e3,
+          items: {
+            type: "string"
+          },
+          default: []
+        },
+        excluded_schemes: {
+          type: "array",
+          maxItems: 1e3,
+          items: {
+            type: "string"
+          },
+          default: []
+        },
+        min_tag_count: {
+          type: ["integer", "null"],
+          minimum: -2147483648,
+          maximum: 2147483647
+        },
+        include_untagged: {
+          type: "boolean",
+          default: true
+        }
+      }
+    },
+    SearchRestRequest: {
+      type: "object",
+      description: "Decoded GET query parameters. JSON-content parameters are decoded to JSON values before this schema is applied. This is not a POST request body. Unknown query keys retain legacy ignored behavior and cannot grant tenant/archive authorization.",
+      required: [
+        "q"
+      ],
+      additionalProperties: true,
+      properties: {
+        q: {
+          type: "string",
+          description: "Search expression. Empty text remains accepted."
+        },
+        limit: {
+          type: "integer",
+          minimum: 0,
+          maximum: 1e3,
+          default: 20
+        },
+        filters: {
+          type: "string",
+          description: "Legacy filter expression; combined with comma-separated tags."
+        },
+        mode: {
+          type: "string",
+          default: "hybrid",
+          description: "fts selects lexical search, semantic selects vector search. hybrid, absent and other legacy values select hybrid; failures have explicit FTS degradation."
+        },
+        set: {
+          type: "string",
+          description: "Embedding-set slug resolved within the authorized memory and tenant."
+        },
+        created_after: {
+          type: "string",
+          format: "date-time"
+        },
+        created_before: {
+          type: "string",
+          format: "date-time"
+        },
+        updated_after: {
+          type: "string",
+          format: "date-time"
+        },
+        updated_before: {
+          type: "string",
+          format: "date-time"
+        },
+        since: {
+          type: "string",
+          description: "Relative created-after time; explicit created_after wins. Unrecognized relative text retains legacy ignored behavior."
+        },
+        tags: {
+          type: "string",
+          description: "Comma-separated tags; trimmed nonempty entries are AND requirements."
+        },
+        strict_filter: {
+          $ref: "#/$defs/StrictSearchFilterInput",
+          "x-fortemi-query-content": "application/json"
+        },
+        metadata_predicates: {
+          $ref: "predicates.schema.json",
+          "x-fortemi-query-content": "application/json",
+          "x-fortemi-max-encoded-utf8-bytes": 1048576
+        },
+        diversity: {
+          type: "number",
+          minimum: -34028234663852886e22,
+          maximum: 34028234663852886e22,
+          description: "Finite f32 input, clamped to [0,1] before MMR; zero is pure relevance."
+        }
+      }
+    },
+    SearchHitFields: {
+      type: "object",
+      required: [
+        "note_id",
+        "score",
+        "snippet"
+      ],
+      properties: {
+        note_id: {
+          type: "string",
+          format: "uuid"
+        },
+        score: {
+          type: "number",
+          description: "Finite retrieval/fusion score, not a probability."
+        },
+        snippet: {
+          type: [
+            "string",
+            "null"
+          ],
+          description: "Display only; not citation text or coordinates."
+        },
+        title: {
+          type: "string"
+        },
+        tags: {
+          type: "array",
+          items: {
+            type: "string"
+          }
+        },
+        embedding_status: {
+          enum: [
+            "ready",
+            "pending",
+            "failed",
+            "none"
+          ]
+        },
+        evidence: {
+          $ref: "evidence-set.schema.json"
+        }
+      }
+    },
+    SearchHit: {
+      type: "object",
+      allOf: [
+        {
+          $ref: "#/$defs/SearchHitFields"
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    ChainSearchInfo: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "chain_id",
+        "original_title",
+        "chunks_matched",
+        "best_chunk_sequence",
+        "total_chunks"
+      ],
+      description: "Legacy display aggregation. Index/count fields are currently heuristic, not native citation coordinates; use evidence for exact unit identity.",
+      properties: {
+        chain_id: {
+          type: "string",
+          format: "uuid"
+        },
+        original_title: {
+          type: "string"
+        },
+        chunks_matched: {
+          type: "integer",
+          minimum: 0
+        },
+        best_chunk_sequence: {
+          type: "integer",
+          minimum: 0,
+          maximum: 4294967295
+        },
+        total_chunks: {
+          type: "integer",
+          minimum: 0,
+          maximum: 4294967295
+        }
+      }
+    },
+    EnhancedSearchHit: {
+      type: "object",
+      allOf: [
+        {
+          $ref: "#/$defs/SearchHitFields"
+        },
+        {
+          type: "object",
+          properties: {
+            chain_info: {
+              $ref: "#/$defs/ChainSearchInfo"
+            }
+          }
+        }
+      ],
+      unevaluatedProperties: false
+    },
+    SearchDegradation: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "code",
+        "effective_mode"
+      ],
+      properties: {
+        code: {
+          type: "string",
+          pattern: "^[a-z][a-z0-9_]{0,63}$"
+        },
+        effective_mode: {
+          const: "fts"
+        }
+      }
+    },
+    SearchRestResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "results",
+        "query",
+        "total",
+        "degraded"
+      ],
+      properties: {
+        results: {
+          type: "array",
+          maxItems: 1e3,
+          items: {
+            $ref: "#/$defs/EnhancedSearchHit"
+          }
+        },
+        query: {
+          type: "string"
+        },
+        total: {
+          type: "integer",
+          minimum: 0,
+          maximum: 1e3,
+          description: "Returned hit count, exactly results.length; not total matches in storage."
+        },
+        degraded: {
+          type: "boolean"
+        },
+        degradation: {
+          $ref: "#/$defs/SearchDegradation"
+        }
+      },
+      if: {
+        properties: {
+          degraded: {
+            const: true
+          }
+        }
+      },
+      then: {
+        properties: {
+          degradation: {}
+        },
+        required: [
+          "degradation"
+        ]
+      },
+      else: {
+        not: {
+          properties: {
+            degradation: {}
+          },
+          required: [
+            "degradation"
+          ]
+        }
+      }
+    }
+  }
+};
+
+// schemas/metadata-search/candidate/1.0.0/evidence-resolution.schema.json
+var evidence_resolution_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fortemi.com/contracts/metadata-search/candidate/1.0.0/evidence-resolution.schema.json",
+  title: "Candidate current-storage evidence resolution",
+  $defs: {
+    SearchEvidenceResolveRequest: {
+      type: "object",
+      additionalProperties: false,
+      required: ["locator"],
+      properties: {
+        locator: { $ref: "evidence-locator.schema.json" },
+        metadata_predicates: { $ref: "predicates.schema.json" },
+        include_archived: { type: "boolean", default: false }
+      }
+    },
+    SearchEvidenceResolveResponse: {
+      type: "object",
+      additionalProperties: false,
+      required: ["text"],
+      properties: {
+        text: { type: "string", maxLength: 16777216 }
+      }
+    }
+  }
+};
+
+// src/remote-search-schema.ts
+var timestamp = z.string().datetime({ offset: true });
+var ajv2 = new Ajv20206({ strict: true, allErrors: false, ownProperties: true }).addFormat("uuid", /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).addFormat("date-time", { type: "string", validate: (value) => timestamp.safeParse(value).success }).addKeyword({ keyword: "x-fortemi-query-content", schemaType: "string", valid: true }).addKeyword({ keyword: "x-fortemi-max-encoded-utf8-bytes", schemaType: "number", valid: true }).addSchema([search_rest_schema_default, evidence_locator_schema_default, evidence_set_schema_default, evidence_resolution_schema_default]).addSchema(predicates_schema_default, new URL("predicates.schema.json", search_rest_schema_default.$id).href);
+var isSearchRestRequest = ajv2.compile({ $ref: search_rest_schema_default.$id + "#/$defs/SearchRestRequest" });
+var isSearchRestResponse = ajv2.compile({ $ref: search_rest_schema_default.$id + "#/$defs/SearchRestResponse" });
+var isEvidenceResolveRequest = ajv2.compile({ $ref: evidence_resolution_schema_default.$id + "#/$defs/SearchEvidenceResolveRequest" });
+var isEvidenceResolveResponse = ajv2.compile({ $ref: evidence_resolution_schema_default.$id + "#/$defs/SearchEvidenceResolveResponse" });
+
+// src/remote-contract.ts
 var uuid3 = z.string().uuid().transform((value) => value.toLowerCase());
 var metadata = z.object({
   id: uuid3,
@@ -20083,7 +21772,7 @@ function parseRemoteNoteDetail(value) {
     return { ...projectNote({ ...result.note, tags: result.tags }), content: result.revised.content };
   });
 }
-var timestamp = z.string().datetime({ offset: true });
+var timestamp2 = z.string().datetime({ offset: true });
 function remoteNoteId(value) {
   const parsed = uuid3.safeParse(value);
   if (!parsed.success) throw new RemoteBackendError("invalid-request");
@@ -20096,7 +21785,7 @@ var link = z.object({
   to_url: z.string().nullable(),
   kind: z.string(),
   score: z.number().finite(),
-  created_at_utc: timestamp,
+  created_at_utc: timestamp2,
   snippet: z.string().nullable(),
   metadata: z.unknown().refine((value) => value !== void 0)
 });
@@ -20135,7 +21824,7 @@ var conceptAssignment = z.tuple([
     source: z.string(),
     relevance_score: z.number().finite(),
     is_primary: z.boolean(),
-    created_at: timestamp,
+    created_at: timestamp2,
     confidence: z.number().finite().optional(),
     created_by: z.string().optional()
   }),
@@ -20143,8 +21832,8 @@ var conceptAssignment = z.tuple([
     id: uuid3,
     primary_scheme_id: uuid3,
     pref_label: z.string(),
-    created_at: timestamp,
-    updated_at: timestamp
+    created_at: timestamp2,
+    updated_at: timestamp2
   })
 ]);
 function parseRemoteConcepts(value, noteId) {
@@ -20179,8 +21868,8 @@ var provenanceActivity = z.object({
   revision_id: uuid3.nullable(),
   activity_type: z.string(),
   model_name: z.string().nullable(),
-  started_at: timestamp,
-  ended_at: timestamp.nullable(),
+  started_at: timestamp2,
+  ended_at: timestamp2.nullable(),
   metadata: z.unknown().refine((value) => value !== void 0)
 });
 var provenanceEdge = z.object({
@@ -20189,7 +21878,7 @@ var provenanceEdge = z.object({
   source_note_id: uuid3.nullable(),
   source_url: z.string().nullable(),
   relation: z.string(),
-  created_at_utc: timestamp
+  created_at_utc: timestamp2
 });
 var provenanceChain = z.object({
   note_id: uuid3,
@@ -20227,12 +21916,14 @@ function remoteSearchParameters(query, options) {
   if (typeof query !== "string" || !parsed.success) throw new RemoteBackendError("invalid-request");
   const value = parsed.data;
   if ((value.offset ?? 0) !== 0 || (value.source?.length ?? 0) > 0) throw new RemoteBackendError("unsupported-operation");
-  return {
+  const parameters = {
     q: query,
     mode: value.mode,
     limit: value.limit,
     ...value.tags?.length ? { tags: value.tags.join(",") } : {}
   };
+  if (!isSearchRestRequest(parameters)) throw new RemoteBackendError("invalid-request");
+  return parameters;
 }
 var searchHit = z.object({
   note_id: uuid3,
@@ -20241,6 +21932,7 @@ var searchHit = z.object({
   title: z.string().optional(),
   tags: z.array(z.string()).optional(),
   embedding_status: z.enum(["ready", "pending", "failed", "none"]).optional(),
+  evidence: z.unknown().optional(),
   chain_info: z.object({
     chain_id: uuid3,
     original_title: z.string(),
@@ -20248,10 +21940,13 @@ var searchHit = z.object({
     best_chunk_sequence: z.number().int().nonnegative(),
     total_chunks: z.number().int().nonnegative()
   }).optional()
-});
+}).transform(({ evidence, ...hit }) => ({
+  ...hit,
+  ...evidence === void 0 ? {} : { evidence: parseSearchEvidenceSet(evidence, hit.note_id) }
+}));
 var searchDegradation = z.object({
   code: z.string().regex(/^[a-z][a-z0-9_]{0,63}$/),
-  effective_mode: searchMode
+  effective_mode: z.literal("fts")
 });
 var searchResponse = z.object({
   query: z.string(),
@@ -20262,8 +21957,10 @@ var searchResponse = z.object({
 });
 function parseRemoteSearch(value, query, limit) {
   return remoteProjection(() => {
+    if (!isSearchRestResponse(value)) throw new Error("Invalid search schema");
     const result = searchResponse.parse(value);
     if (result.query !== query || result.total !== result.results.length || result.results.length > limit || result.degraded !== (result.degradation !== void 0)) throw new Error("Invalid search envelope");
+    if (result.results.some((hit) => hit.chain_info && hit.chain_info.chain_id !== hit.note_id)) throw new Error("Invalid chain identity");
     return result;
   });
 }
@@ -20299,6 +21996,135 @@ function parseRemoteRestored(value, id) {
   });
 }
 
+// src/backend-search-options.ts
+init_geometry_buffer();
+function validateBackendSearchOptions(options, support) {
+  if (options?.metadataPredicates !== void 0) {
+    validateMetadataPredicates(options.metadataPredicates);
+    if (!support.metadata) throw new Error("BACKEND_METADATA_PREDICATES_UNSUPPORTED");
+  }
+  if (options?.tenant_id !== void 0 || options?.archive_id !== void 0) {
+    if (!support.scope) throw new Error("BACKEND_SEARCH_SCOPE_UNSUPPORTED");
+    if (options.tenant_id !== void 0 && (typeof options.tenant_id !== "string" || !options.tenant_id.length) || options.archive_id !== void 0 && options.archive_id !== null && (typeof options.archive_id !== "string" || !options.archive_id.length)) {
+      throw new Error("BACKEND_SEARCH_SCOPE_INVALID");
+    }
+  }
+  if (options?.mode !== void 0 && support.modes && !support.modes.includes(options.mode)) {
+    throw new Error("BACKEND_SEARCH_MODE_UNSUPPORTED");
+  }
+}
+
+// src/remote-evidence-resolution.ts
+init_geometry_buffer();
+var encoder3 = new TextEncoder();
+var decoder3 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+var invalidRequest = () => new RemoteBackendError("invalid-request");
+var invalidResponse = () => new RemoteBackendError("invalid-response");
+function prepare(value, options = {}) {
+  try {
+    if (!options || typeof options !== "object" || Array.isArray(options) || ![Object.prototype, null].includes(Object.getPrototypeOf(options)) || Reflect.ownKeys(options).some((key3) => !["metadataPredicates", "includeArchived", "signal"].includes(String(key3)))) throw invalidRequest();
+    const locator = parseSearchEvidenceLocator(value);
+    if (locator.span.end > MAX_EVIDENCE_BYTES) throw invalidRequest();
+    const metadata2 = Object.hasOwn(options, "metadataPredicates") ? options.metadataPredicates : void 0;
+    const archived = Object.hasOwn(options, "includeArchived") ? options.includeArchived : void 0;
+    const signal = Object.hasOwn(options, "signal") ? options.signal : void 0;
+    if (signal !== void 0 && !(signal instanceof AbortSignal)) throw invalidRequest();
+    if (metadata2 !== void 0) validateMetadataPredicates(metadata2);
+    const request = {
+      locator,
+      ...metadata2 === void 0 ? {} : { metadata_predicates: metadata2 },
+      ...archived === void 0 ? {} : { include_archived: archived }
+    };
+    if (!isEvidenceResolveRequest(request)) throw invalidRequest();
+    const body = JSON.stringify(request);
+    if (encoder3.encode(body).length > 65536) throw invalidRequest();
+    const wire = JSON.parse(body);
+    if (!isEvidenceResolveRequest(wire)) throw invalidRequest();
+    const encoded = wire;
+    parseSearchEvidenceLocator(encoded.locator);
+    if (encoded.metadata_predicates !== void 0) validateMetadataPredicates(encoded.metadata_predicates);
+    return { body, signal, length: locator.span.end - locator.span.start };
+  } catch {
+    throw invalidRequest();
+  }
+}
+async function resolveRemoteEvidence(value, options, send) {
+  const prepared = prepare(value, options);
+  if (prepared.signal?.aborted) throw new RemoteBackendError("aborted");
+  const controller = new AbortController();
+  const abort = () => controller.abort();
+  prepared.signal?.addEventListener("abort", abort, { once: true });
+  const timer = setTimeout(abort, 3e4);
+  let reader;
+  let completed = false;
+  let rejectAbort = () => {
+  };
+  const aborted = new Promise((_resolve, reject) => {
+    rejectAbort = () => reject(new RemoteBackendError("aborted"));
+  });
+  controller.signal.addEventListener("abort", rejectAbort, { once: true });
+  async function perform() {
+    const response = await send(prepared.body, controller.signal);
+    if (controller.signal.aborted) {
+      void response.body?.cancel().catch(() => {
+      });
+      throw new RemoteBackendError("aborted");
+    }
+    reader = response.body?.getReader();
+    if (!response.ok) throw new RemoteBackendError("http", response.status);
+    if (response.status !== 200 || !reader || response.headers.get("content-type")?.split(";")[0].trim().toLowerCase() !== "application/json" || !response.headers.get("cache-control")?.split(",").some((part) => part.trim().toLowerCase() === "no-store")) throw invalidResponse();
+    const maximum = prepared.length * 6 + 64;
+    const advertised = response.headers.get("content-length");
+    if (advertised !== null && (!/^\d+$/.test(advertised) || Number(advertised) > maximum)) throw invalidResponse();
+    let bytes = new Uint8Array(Math.min(maximum, 4096));
+    let length = 0;
+    while (true) {
+      const { done, value: chunk } = await reader.read();
+      if (done) {
+        completed = true;
+        break;
+      }
+      const nextLength = length + chunk.byteLength;
+      if (nextLength > maximum) throw invalidResponse();
+      if (nextLength > bytes.length) {
+        const grown = new Uint8Array(Math.min(maximum, Math.max(nextLength, bytes.length * 2)));
+        grown.set(bytes.subarray(0, length));
+        bytes = grown;
+      }
+      bytes.set(chunk, length);
+      length = nextLength;
+    }
+    let data;
+    try {
+      data = JSON.parse(decoder3.decode(bytes.subarray(0, length)));
+    } catch {
+      throw invalidResponse();
+    }
+    if (!isEvidenceResolveResponse(data)) throw invalidResponse();
+    const text = data.text;
+    if (text.length > prepared.length) throw invalidResponse();
+    const textBytes2 = encoder3.encode(text);
+    if (textBytes2.length !== prepared.length || decoder3.decode(textBytes2) !== text) throw invalidResponse();
+    return text;
+  }
+  try {
+    return await Promise.race([perform(), aborted]);
+  } catch (error) {
+    if (error instanceof RemoteBackendError) throw error;
+    throw new RemoteBackendError(controller.signal.aborted || error instanceof Error && error.name === "AbortError" ? "aborted" : "transport");
+  } finally {
+    clearTimeout(timer);
+    prepared.signal?.removeEventListener("abort", abort);
+    controller.signal.removeEventListener("abort", rejectAbort);
+    controller.abort();
+    if (reader) {
+      if (!completed) void reader.cancel().catch(() => {
+      });
+      reader.releaseLock();
+    }
+  }
+}
+
 // src/data-backend.ts
 var SEMANTIC_RANK = {
   none: 0,
@@ -20313,6 +22139,8 @@ var STARTUP_RANK = {
 };
 function missingFor(request, caps) {
   const missing = [];
+  if (request.typedMetadataPredicates && !caps.typedMetadataPredicates) missing.push("typedMetadataPredicates");
+  if (request.evidenceLocators && !caps.evidenceLocators) missing.push("evidenceLocators");
   if (request.read && !caps.read) missing.push("read");
   if (request.write && !caps.write) missing.push("write");
   if (request.merge && !caps.merge) missing.push("merge");
@@ -20436,9 +22264,45 @@ function shardProvenanceToBackend(edge) {
 }
 function createPGliteBackend(db, options = {}) {
   const semanticAvailable = options.semanticAvailable ?? false;
+  const embedQuery = options.embedQuery;
+  const canEmbed = semanticAvailable && typeof embedQuery === "function";
   const notes = new NotesRepository(db);
   const search = new SearchRepository(db, semanticAvailable);
   const links = new LinksRepository(db);
+  async function searchNotes(query, o) {
+    validateBackendSearchOptions(o, {
+      metadata: true,
+      scope: true,
+      modes: canEmbed ? ["fts", "semantic", "hybrid"] : ["fts"]
+    });
+    const mode = o?.mode ?? "fts";
+    const vector = mode === "fts" ? void 0 : await embedQuery(query);
+    if (mode !== "fts" && (!Array.isArray(vector) || !vector.length || !Array.from(vector).every((value) => typeof value === "number" && Number.isFinite(value)))) {
+      throw new Error("BACKEND_QUERY_EMBEDDING_INVALID");
+    }
+    const r = await search.search(query, {
+      limit: o?.limit,
+      offset: o?.offset,
+      tagsAll: o?.tags,
+      sources: o?.source,
+      mode: mode === "fts" ? "text" : mode,
+      metadataPredicates: o?.metadataPredicates,
+      tenant_id: o?.tenant_id,
+      archive_id: o?.archive_id,
+      include_facets: true
+    }, vector);
+    return {
+      hits: r.results.map((res) => ({
+        note: searchResultToBackend(res),
+        rank: res.rank,
+        snippet: res.snippet,
+        locators: res.locators,
+        evidence: res.evidence
+      })),
+      total: r.total,
+      facets: r.facets ? { tags: Object.fromEntries(r.facets.tags.map((t) => [t.tag, t.count])) } : void 0
+    };
+  }
   async function linksOf(id) {
     const result = await links.listForNote(id);
     const urlLinks = await db.query(
@@ -20479,7 +22343,9 @@ function createPGliteBackend(db, options = {}) {
       write: true,
       merge: true,
       multiUser: false,
-      semantic: semanticAvailable ? "ann-full" : "none",
+      typedMetadataPredicates: true,
+      evidenceLocators: false,
+      semantic: canEmbed ? "ann-full" : "none",
       startupCost: "index-build"
     },
     async listNotes(o) {
@@ -20494,24 +22360,8 @@ function createPGliteBackend(db, options = {}) {
         return null;
       }
     },
-    async search(query, o) {
-      const r = await search.search(query, {
-        limit: o?.limit,
-        offset: o?.offset,
-        tags: o?.tags,
-        source: o?.source?.[0],
-        include_facets: true
-      });
-      const hits = r.results.map((res) => ({
-        note: searchResultToBackend(res),
-        rank: res.rank,
-        snippet: res.snippet
-      }));
-      const facets = r.facets ? {
-        tags: Object.fromEntries(r.facets.tags.map((t) => [t.tag, t.count]))
-      } : void 0;
-      return { hits, total: r.total, facets };
-    },
+    search: searchNotes,
+    ...canEmbed ? { semantic: async (query, k) => (await searchNotes(query, { mode: "semantic", limit: k })).hits } : {},
     async getNoteFull(id) {
       try {
         const f = await notes.get(id);
@@ -20537,6 +22387,7 @@ var DEFAULT_REMOTE_PATHS = {
   notes: "/api/v1/notes",
   note: "/api/v1/notes/:id",
   search: "/api/v1/search",
+  resolveEvidence: "/api/v1/search/evidence/resolve",
   links: "/api/v1/notes/:id/links",
   concepts: "/api/v1/notes/:id/concepts",
   provenance: "/api/v1/notes/:id/provenance",
@@ -20547,12 +22398,12 @@ function remotePath(template, id) {
 }
 function remoteUrl(baseUrl, path, params) {
   const url = new URL(path, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
-  for (const [key2, value] of Object.entries(params ?? {})) {
+  for (const [key3, value] of Object.entries(params ?? {})) {
     if (value === void 0) continue;
     if (Array.isArray(value)) {
-      for (const item of value) url.searchParams.append(key2, String(item));
+      for (const item of value) url.searchParams.append(key3, String(item));
     } else {
-      url.searchParams.set(key2, String(value));
+      url.searchParams.set(key3, String(value));
     }
   }
   return url.toString();
@@ -20608,6 +22459,7 @@ function createRemoteBackend(config) {
     return note;
   }
   async function searchRemote(query, options, requireSemantic = false) {
+    validateBackendSearchOptions(options, { metadata: false, scope: false });
     const params = remoteSearchParameters(query, options);
     const result = parseRemoteSearch(await getJson(paths.search, params), query, params.limit);
     if (requireSemantic && result.degraded) throw new RemoteBackendError("degraded-search");
@@ -20632,6 +22484,7 @@ function createRemoteBackend(config) {
         },
         rank: hit.score,
         ...hit.snippet === null ? {} : { snippet: hit.snippet },
+        ...hit.evidence === void 0 ? {} : { evidence: hit.evidence },
         remoteSearch: {
           ...hit.title === void 0 ? {} : { title: hit.title },
           ...hit.tags === void 0 ? {} : { tags: hit.tags },
@@ -20688,6 +22541,8 @@ function createRemoteBackend(config) {
       merge: false,
       multiUser: true,
       semantic: "server",
+      typedMetadataPredicates: false,
+      evidenceLocators: false,
       startupCost: "network"
     },
     async listNotes(o) {
@@ -20715,6 +22570,20 @@ function createRemoteBackend(config) {
       }
     },
     search: searchRemote,
+    async resolveEvidence(locator, options) {
+      return resolveRemoteEvidence(locator, options, async (body, signal) => {
+        const headers = await remoteHeaders(config, true);
+        signal.throwIfAborted();
+        return (config.fetchImpl ?? globalThis.fetch)(remoteUrl(config.baseUrl, paths.resolveEvidence ?? DEFAULT_REMOTE_PATHS.resolveEvidence), {
+          method: "POST",
+          headers,
+          body,
+          signal,
+          cache: "no-store",
+          redirect: "error"
+        });
+      });
+    },
     getNoteFull,
     linksOf,
     conceptsOf,
@@ -20784,6 +22653,8 @@ function createShardBackend(reader, options = {}) {
       merge: false,
       multiUser: false,
       semantic,
+      typedMetadataPredicates: false,
+      evidenceLocators: false,
       startupCost: "instant"
     },
     async listNotes(o) {
@@ -20795,6 +22666,7 @@ function createShardBackend(reader, options = {}) {
       return n ? shardNoteToBackend(n) : null;
     },
     async search(query, o) {
+      validateBackendSearchOptions(o, { metadata: false, scope: false, modes: ["fts"] });
       const r = await reader.search(query, { ...o, rank: true, snippets: true });
       const hits = r.rankedItems ? r.rankedItems.map((it) => ({
         note: shardNoteToBackend(it.note),
@@ -21338,26 +23210,26 @@ function isRecord(value) {
 function isSupportedState(value) {
   return typeof value === "string" && FORTEMI_COMPATIBILITY_STATES.includes(value);
 }
-function requireRecord(parent, key2, errors) {
-  const value = parent[key2];
+function requireRecord(parent, key3, errors) {
+  const value = parent[key3];
   if (!isRecord(value)) {
-    errors.push(`${key2} must be an object`);
+    errors.push(`${key3} must be an object`);
     return null;
   }
   return value;
 }
-function requireString(parent, key2, path, errors) {
-  const value = parent[key2];
+function requireString(parent, key3, path, errors) {
+  const value = parent[key3];
   if (typeof value !== "string" || value.length === 0) {
-    errors.push(`${path}.${key2} must be a non-empty string`);
+    errors.push(`${path}.${key3} must be a non-empty string`);
     return null;
   }
   return value;
 }
-function requireBoolean(parent, key2, path, errors) {
-  const value = parent[key2];
+function requireBoolean(parent, key3, path, errors) {
+  const value = parent[key3];
   if (typeof value !== "boolean") {
-    errors.push(`${path}.${key2} must be a boolean`);
+    errors.push(`${path}.${key3} must be a boolean`);
     return null;
   }
   return value;
@@ -21407,24 +23279,24 @@ function validateFortemiCompatibilityResponse(raw) {
   }
   const capabilities = requireRecord(raw, "capabilities", errors);
   if (capabilities) {
-    for (const key2 of FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES) {
-      if (!isRecord(capabilities[key2])) {
-        errors.push(`capabilities.${key2} must be present as an object`);
+    for (const key3 of FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES) {
+      if (!isRecord(capabilities[key3])) {
+        errors.push(`capabilities.${key3} must be present as an object`);
       }
     }
-    for (const [key2, value] of Object.entries(capabilities)) {
+    for (const [key3, value] of Object.entries(capabilities)) {
       if (!isRecord(value)) {
-        errors.push(`capabilities.${key2} must be an object`);
+        errors.push(`capabilities.${key3} must be an object`);
         continue;
       }
       if (!isSupportedState(value.state)) {
-        errors.push(`capabilities.${key2}.state must be one of ${FORTEMI_COMPATIBILITY_STATES.join(", ")}`);
+        errors.push(`capabilities.${key3}.state must be one of ${FORTEMI_COMPATIBILITY_STATES.join(", ")}`);
       }
       if ("reason_code" in value && typeof value.reason_code !== "string") {
-        errors.push(`capabilities.${key2}.reason_code must be a string when present`);
+        errors.push(`capabilities.${key3}.reason_code must be a string when present`);
       }
       if (value.state !== "available" && !value.reason_code) {
-        warnings.push(`capabilities.${key2} is ${String(value.state)} without reason_code`);
+        warnings.push(`capabilities.${key3} is ${String(value.state)} without reason_code`);
       }
     }
   }
@@ -21443,7 +23315,7 @@ function validateFortemiCompatibilityResponse(raw) {
   };
 }
 function formatFortemiCompatibilitySummary(response) {
-  const capabilitySummary = Object.entries(response.capabilities).map(([key2, value]) => `${key2}=${value.state}`).sort().join(", ");
+  const capabilitySummary = Object.entries(response.capabilities).map(([key3, value]) => `${key3}=${value.state}`).sort().join(", ");
   return [
     `Fortemi compatibility ${response.contract_revision}`,
     `api=${response.api.name}@${response.api.version}`,
@@ -23756,7 +25628,7 @@ var CollectionsRepository = class {
 
 // src/repositories/templates-repository.ts
 init_geometry_buffer();
-function validate(record) {
+function validate2(record) {
   if (!validateShardComponentRecord("templates", record, "full-v1", "2.0.0").valid) throw new Error("Invalid native template");
 }
 var TemplatesRepository = class {
@@ -23774,7 +25646,7 @@ var TemplatesRepository = class {
   async create(input) {
     const id = generateId();
     const now2 = (/* @__PURE__ */ new Date()).toISOString();
-    validate({
+    validate2({
       id,
       name: input.name,
       content: input.content,
@@ -23794,13 +25666,13 @@ var TemplatesRepository = class {
   }
   async update(id, input) {
     const current = await this.get(id);
-    validate({ ...current, ...Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0)) });
+    validate2({ ...current, ...Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0)) });
     const values = [];
     const assignments = ["updated_at = now()"];
-    for (const key2 of ["name", "content", "description", "format", "default_tags", "collection_id"]) {
-      if (input[key2] === void 0) continue;
-      values.push(key2 === "default_tags" ? JSON.stringify(input[key2]) : input[key2]);
-      assignments.push(`${key2} = $${values.length}${key2 === "default_tags" ? "::jsonb" : ""}`);
+    for (const key3 of ["name", "content", "description", "format", "default_tags", "collection_id"]) {
+      if (input[key3] === void 0) continue;
+      values.push(key3 === "default_tags" ? JSON.stringify(input[key3]) : input[key3]);
+      assignments.push(`${key3} = $${values.length}${key3 === "default_tags" ? "::jsonb" : ""}`);
     }
     values.push(id);
     await this.db.query(`UPDATE template SET ${assignments.join(", ")} WHERE id = $${values.length}`, values);
@@ -23961,8 +25833,8 @@ async function removeOmittedNativeSkos(tx, state, selectedNoteIds3) {
     await tx.query(
       `DELETE FROM ${table} existing WHERE existing.${owner} = ANY($1::text[])
       AND NOT EXISTS (SELECT 1 FROM UNNEST(${keys.map((_, index) => `$${index + 2}::text[]`).join(", ")}) incoming(${keys.join(", ")})
-        WHERE ${keys.map((key2) => `incoming.${key2} = existing.${key2}`).join(" AND ")})`,
-      [selected, ...keys.map((key2) => incoming.map((row) => nativeUuid(row[key2])))]
+        WHERE ${keys.map((key3) => `incoming.${key3} = existing.${key3}`).join(" AND ")})`,
+      [selected, ...keys.map((key3) => incoming.map((row) => nativeUuid(row[key3])))]
     );
   }
 }
@@ -24501,8 +26373,8 @@ async function captureKnowledge(db, rawInput, events) {
       if (!input.template) throw new Error("template is required for from_template action");
       let content = input.template;
       if (input.variables) {
-        for (const [key2, value] of Object.entries(input.variables)) {
-          content = content.replaceAll(`{{${key2}}}`, value);
+        for (const [key3, value] of Object.entries(input.variables)) {
+          content = content.replaceAll(`{{${key3}}}`, value);
         }
       }
       const note = await repo.create({
@@ -24528,6 +26400,9 @@ async function searchTool(db, rawInput) {
   }
   const repo = new SearchRepository(db, semanticAvailable);
   return repo.search(input.query, {
+    metadataPredicates: input.metadataPredicates,
+    tenant_id: input.tenant_id,
+    archive_id: input.archive_id,
     limit: input.limit,
     offset: input.offset,
     mode: input.mode,
@@ -24552,10 +26427,10 @@ function zodToJsonSchema(schema) {
     const shape = schema.shape;
     const properties = {};
     const required = [];
-    for (const [key2, value] of Object.entries(shape)) {
-      properties[key2] = resolvePropertySchema(value);
+    for (const [key3, value] of Object.entries(shape)) {
+      properties[key3] = resolvePropertySchema(value);
       if (!(value instanceof z.ZodOptional) && !(value instanceof z.ZodDefault)) {
-        required.push(key2);
+        required.push(key3);
       }
     }
     return {
@@ -26619,13 +28494,13 @@ var OpenAICompatibleProvider = class {
       throw new Error("Streaming not supported: response body is null");
     }
     const reader = response.body.getReader();
-    const decoder8 = new TextDecoder();
+    const decoder10 = new TextDecoder();
     let buffer = "";
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
-        buffer += decoder8.decode(value, { stream: true });
+        buffer += decoder10.decode(value, { stream: true });
         const lines = buffer.split("\n");
         buffer = lines.pop() ?? "";
         for (const line of lines) {
@@ -27686,8 +29561,8 @@ var AllowlistTrustStore = class {
   }
   /** Mark a key revoked without removing it (still resolvable, verdict `revoked`). */
   revoke(keyId) {
-    const key2 = this.keys.get(keyId);
-    if (key2) this.keys.set(keyId, { ...key2, revoked: true });
+    const key3 = this.keys.get(keyId);
+    if (key3) this.keys.set(keyId, { ...key3, revoked: true });
   }
 };
 function base64urlToBytes(s) {
@@ -27775,7 +29650,7 @@ async function verifyShardSignature(input) {
   };
   let signatureValid = false;
   try {
-    const key2 = await globalThis.crypto.subtle.importKey(
+    const key3 = await globalThis.crypto.subtle.importKey(
       "raw",
       toBufferSource(base64urlToBytes(trusted.public_key)),
       { name: "Ed25519" },
@@ -27785,7 +29660,7 @@ async function verifyShardSignature(input) {
     const digest2 = await sha256Hex(canonicalPayloadBytes(payload));
     signatureValid = await globalThis.crypto.subtle.verify(
       "Ed25519",
-      key2,
+      key3,
       toBufferSource(base64urlToBytes(envelope.signature)),
       toBufferSource(new TextEncoder().encode(digest2))
     );
@@ -36398,8 +38273,8 @@ function classifyPresenceValue(value) {
 function classifyOwnProperty(document2, pointer) {
   const resolved = parentAndKey(document2, pointer, false);
   if (!resolved) return "absent";
-  const { parent, key: key2 } = resolved;
-  return Object.hasOwn(parent, key2) ? classifyPresenceValue(parent[key2]) : "absent";
+  const { parent, key: key3 } = resolved;
+  return Object.hasOwn(parent, key3) ? classifyPresenceValue(parent[key3]) : "absent";
 }
 function capturePresence(document2, pointers) {
   return Object.fromEntries(pointers.flatMap(
@@ -36451,14 +38326,14 @@ function restoreStoredPresence(document2, presence) {
   for (const [pointer, stored] of Object.entries(presence)) {
     const resolved = parentAndKey(restored, pointer);
     if (!resolved) throw new Error(`JSON Pointer '${pointer}' parent is not an object`);
-    const { parent, key: key2 } = resolved;
+    const { parent, key: key3 } = resolved;
     if (stored === "legacy-indeterminate") {
       throw new Error(`Cannot emit schema 2.0 with legacy-indeterminate state at ${pointer}`);
     }
     if (stored === "absent") {
-      delete parent[key2];
+      delete parent[key3];
     } else if (stored === "null") {
-      parent[key2] = null;
+      parent[key3] = null;
     } else if (classifyOwnProperty(restored, pointer) !== stored) {
       throw new Error(`Stored ${stored} state at ${pointer} does not match the persisted value`);
     }
@@ -36777,7 +38652,7 @@ var rowKey = (component, row) => nativeIdentityKey(nativeIdentities[component],
 function canonical(value) {
   if (Array.isArray(value)) return value.map(canonical);
   if (value !== null && typeof value === "object") return Object.fromEntries(
-    Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key2, item]) => [key2, canonical(item)])
+    Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key3, item]) => [key3, canonical(item)])
   );
   return value;
 }
@@ -36839,7 +38714,7 @@ async function readNativeLineage(tx, state) {
 
 // src/shard/live-full-v1.ts
 var components2 = Object.keys(FULL_V1_COMPONENT_FILES);
-var encoder2 = new TextEncoder();
+var encoder4 = new TextEncoder();
 var scoped = (values) => values ? [...values] : void 0;
 var ids = (rows) => new Set(rows.map((row) => row.id));
 var nullableIn = (set, value) => value === null || set.has(value);
@@ -37175,7 +39050,7 @@ async function exportLiveFullV1(db, options) {
       for (const component of components2) {
         const spec = FULL_V1_COMPONENT_FILES[component];
         const rows = state[component];
-        const bytes = encoder2.encode(spec.encoding === "json-array" ? JSON.stringify(rows) : rows.map((row) => JSON.stringify(row)).join("\n"));
+        const bytes = encoder4.encode(spec.encoding === "json-array" ? JSON.stringify(rows) : rows.map((row) => JSON.stringify(row)).join("\n"));
         files.set(spec.file, bytes);
         counts[component] = rows.length;
         checksums[spec.file] = await sha256Hex(bytes);
@@ -37214,7 +39089,7 @@ async function exportLiveFullV1(db, options) {
         capability = { ...capability, losses: manifestLosses };
         return failure2("Generated live full-v1 manifest violates presence authority.");
       }
-      files.set("manifest.json", encoder2.encode(JSON.stringify(manifest, null, 2)));
+      files.set("manifest.json", encoder4.encode(JSON.stringify(manifest, null, 2)));
       for (const note of state.notes) for (const { attachment } of note.attachments) {
         const path = sidecarEntryName(attachment.checksum);
         if (files.has(path)) continue;
@@ -37237,7 +39112,7 @@ async function exportLiveFullV1(db, options) {
 }
 
 // src/shard/shard-export.ts
-var encoder3 = new TextEncoder();
+var encoder5 = new TextEncoder();
 var CORE_V1_FILES = /* @__PURE__ */ new Set([
   "notes.jsonl",
   "collections.json",
@@ -37643,11 +39518,11 @@ async function exportShardBytes(db, options, mode) {
       const slice = shardNotes.slice(offset, offset + clusterSize);
       const href = `notes/${String(offset).padStart(6, "0")}.jsonl`;
       clusters.push({ href, offset });
-      files.set(href, encoder3.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
+      files.set(href, encoder5.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
     }
     layout = { clusters: { notes: clusters } };
   } else {
-    files.set("notes.jsonl", encoder3.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
+    files.set("notes.jsonl", encoder5.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
   }
   components4.push("notes");
   counts.notes = notes.length;
@@ -37675,7 +39550,7 @@ async function exportShardBytes(db, options, mode) {
       mode?.nativeSchema2Presence
     );
   }
-  files.set("collections.json", encoder3.encode(JSON.stringify(shardCollections)));
+  files.set("collections.json", encoder5.encode(JSON.stringify(shardCollections)));
   components4.push("collections");
   counts.collections = shardCollections.length;
   const allTagRows = await db.query(
@@ -37691,7 +39566,7 @@ async function exportShardBytes(db, options, mode) {
   const shardTags = tagsToShard(
     relevantTags.map((r) => ({ name: r.tag, created_at: r.created_at }))
   );
-  files.set("tags.json", encoder3.encode(JSON.stringify(shardTags)));
+  files.set("tags.json", encoder5.encode(JSON.stringify(shardTags)));
   components4.push("tags");
   counts.tags = shardTags.length;
   const templateRows = await db.query(`SELECT * FROM template ORDER BY created_at, id`);
@@ -37707,7 +39582,7 @@ async function exportShardBytes(db, options, mode) {
         mode?.nativeSchema2Presence
       );
     }
-    files.set("templates.json", encoder3.encode(JSON.stringify(shardTemplates)));
+    files.set("templates.json", encoder5.encode(JSON.stringify(shardTemplates)));
     components4.push("templates");
     counts.templates = shardTemplates.length;
   }
@@ -37732,7 +39607,7 @@ async function exportShardBytes(db, options, mode) {
     );
   }
   const linksJsonl = shardLinks.map((l) => JSON.stringify(l)).join("\n");
-  files.set("links.jsonl", encoder3.encode(linksJsonl));
+  files.set("links.jsonl", encoder5.encode(linksJsonl));
   components4.push("links");
   counts.links = shardLinks.length;
   const allNoteSkosRows = await db.query(`SELECT * FROM note_skos_tag ORDER BY created_at`);
@@ -37749,25 +39624,25 @@ async function exportShardBytes(db, options, mode) {
     (row) => exportedConceptIds.has(row.source_concept_id) && exportedConceptIds.has(row.target_concept_id)
   ) : allRelationRows.rows;
   const shardSkosSchemes = filteredSchemeRows.map(skosSchemeToShard);
-  files.set("skos_schemes.json", encoder3.encode(JSON.stringify(shardSkosSchemes)));
+  files.set("skos_schemes.json", encoder5.encode(JSON.stringify(shardSkosSchemes)));
   components4.push("skos_schemes");
   counts.skos_schemes = shardSkosSchemes.length;
   const shardSkosConcepts = filteredConceptRows.map(skosConceptToShard);
-  files.set("skos_concepts.json", encoder3.encode(JSON.stringify(shardSkosConcepts)));
+  files.set("skos_concepts.json", encoder5.encode(JSON.stringify(shardSkosConcepts)));
   components4.push("skos_concepts");
   counts.skos_concepts = shardSkosConcepts.length;
   const skosRelationsJsonl = filteredRelationRows.map((row) => JSON.stringify(skosRelationToShard(row))).join("\n");
-  files.set("skos_relations.jsonl", encoder3.encode(skosRelationsJsonl));
+  files.set("skos_relations.jsonl", encoder5.encode(skosRelationsJsonl));
   components4.push("skos_relations");
   counts.skos_relations = filteredRelationRows.length;
   const noteSkosJsonl = filteredNoteSkosRows.map((row) => JSON.stringify(noteSkosTagToShard(row))).join("\n");
-  files.set("note_skos_tags.jsonl", encoder3.encode(noteSkosJsonl));
+  files.set("note_skos_tags.jsonl", encoder5.encode(noteSkosJsonl));
   components4.push("note_skos_tags");
   counts.note_skos_tags = filteredNoteSkosRows.length;
   const provenanceRows = await db.query(`SELECT * FROM provenance_edge ORDER BY started_at`);
   const filteredProvenanceRows = isFiltered ? provenanceRows.rows.filter((row) => row.entity_type !== "note" || exportedNoteIds.has(row.entity_id)) : provenanceRows.rows;
   const provenanceJsonl = filteredProvenanceRows.map((row) => JSON.stringify(provenanceEdgeToShard(row))).join("\n");
-  files.set("provenance_edges.jsonl", encoder3.encode(provenanceJsonl));
+  files.set("provenance_edges.jsonl", encoder5.encode(provenanceJsonl));
   components4.push("provenance_edges");
   counts.provenance_edges = filteredProvenanceRows.length;
   if (options?.includeEmbeddings) {
@@ -37807,7 +39682,7 @@ async function exportShardBytes(db, options, mode) {
         freshness_json: { status: "unknown" }
       } : row
     ));
-    files.set("embedding_sets.json", encoder3.encode(JSON.stringify(shardEmbSets)));
+    files.set("embedding_sets.json", encoder5.encode(JSON.stringify(shardEmbSets)));
     components4.push("embedding_sets");
     counts.embedding_sets = shardEmbSets.length;
     const embeddingConfigRows = await db.query(
@@ -37817,7 +39692,7 @@ async function exportShardBytes(db, options, mode) {
     );
     if (embeddingConfigRows.rows.length > 0) {
       const shardEmbeddingConfigs = embeddingConfigRows.rows.map((row) => embeddingConfigToShard(row));
-      files.set("embedding_configs.json", encoder3.encode(JSON.stringify(shardEmbeddingConfigs)));
+      files.set("embedding_configs.json", encoder5.encode(JSON.stringify(shardEmbeddingConfigs)));
       components4.push("embedding_configs");
       counts.embedding_configs = shardEmbeddingConfigs.length;
     }
@@ -37830,7 +39705,7 @@ async function exportShardBytes(db, options, mode) {
       (member) => exportedSetIds.has(member.embedding_set_id) && exportedNoteIds.has(member.note_id) && (includeMaterializedSelectors || !virtualSetIds.has(member.embedding_set_id))
     );
     const membersJsonl = scopedEmbMemberRows.map((m) => JSON.stringify(embeddingSetMemberToShard(m))).join("\n");
-    files.set("embedding_set_members.jsonl", encoder3.encode(membersJsonl));
+    files.set("embedding_set_members.jsonl", encoder5.encode(membersJsonl));
     components4.push("embedding_set_members");
     counts.embedding_set_members = scopedEmbMemberRows.length;
     const embRows = await db.query(
@@ -37856,7 +39731,7 @@ async function exportShardBytes(db, options, mode) {
       (embedding) => exportedSetIds.has(embedding.embedding_set_id) && exportedNoteIds.has(embedding.note_id) && (memberEmbeddingIds.size === 0 || memberEmbeddingIds.has(embedding.id))
     );
     const embJsonl = scopedEmbRows.map((e) => JSON.stringify(embeddingToShard(e))).join("\n");
-    files.set("embeddings.jsonl", encoder3.encode(embJsonl));
+    files.set("embeddings.jsonl", encoder5.encode(embJsonl));
     components4.push("embeddings");
     counts.embeddings = scopedEmbRows.length;
   }
@@ -37882,7 +39757,7 @@ async function exportShardBytes(db, options, mode) {
       freshness: jsonObject3(row.freshness_json) ?? { status: "unknown" },
       created_at: iso2(row.created_at)
     }));
-    files.set("graph_sources.json", encoder3.encode(JSON.stringify(shardGraphSources)));
+    files.set("graph_sources.json", encoder5.encode(JSON.stringify(shardGraphSources)));
     components4.push("graph_sources");
     counts.graph_sources = shardGraphSources.length;
   }
@@ -37898,7 +39773,7 @@ async function exportShardBytes(db, options, mode) {
       rank: row.rank,
       metadata: jsonObject3(row.metadata_json)
     })).join("\n");
-    files.set("graph_edges.jsonl", encoder3.encode(graphEdgesJsonl));
+    files.set("graph_edges.jsonl", encoder5.encode(graphEdgesJsonl));
     components4.push("graph_edges");
     counts.graph_edges = scopedGraphEdgeRows.length;
   }
@@ -37934,7 +39809,7 @@ async function exportShardBytes(db, options, mode) {
       })),
       created_at: iso2(row.created_at)
     }));
-    files.set("communities.json", encoder3.encode(JSON.stringify(shardCommunitySets)));
+    files.set("communities.json", encoder5.encode(JSON.stringify(shardCommunitySets)));
     components4.push("communities");
     counts.community_sets = shardCommunitySets.length;
     counts.communities = scopedCommunityRows.length;
@@ -37950,7 +39825,7 @@ async function exportShardBytes(db, options, mode) {
       source_type: row.source_type,
       metadata: jsonObject3(row.metadata_json)
     })).join("\n");
-    files.set("community_assignments.jsonl", encoder3.encode(assignmentsJsonl));
+    files.set("community_assignments.jsonl", encoder5.encode(assignmentsJsonl));
     components4.push("community_assignments");
     counts.community_assignments = scopedAssignmentRows.length;
   }
@@ -37973,10 +39848,10 @@ async function exportShardBytes(db, options, mode) {
     const coreTags = [...tagsByName.values()].sort(
       (left, right) => left.name.localeCompare(right.name)
     );
-    files.set("tags.json", encoder3.encode(JSON.stringify(coreTags)));
+    files.set("tags.json", encoder5.encode(JSON.stringify(coreTags)));
     components4.splice(0, components4.length, ...CORE_V1_COMPONENTS);
-    for (const key2 of Object.keys(counts)) {
-      if (!CORE_V1_COMPONENTS.includes(key2)) delete counts[key2];
+    for (const key3 of Object.keys(counts)) {
+      if (!CORE_V1_COMPONENTS.includes(key3)) delete counts[key3];
     }
     Object.assign(counts, {
       notes: shardNotes.length,
@@ -38013,7 +39888,7 @@ async function exportShardBytes(db, options, mode) {
     ...!coreV1 ? { migrated_from: null } : {},
     ...!coreV1 && layout ? { layout } : {}
   };
-  files.set("manifest.json", encoder3.encode(JSON.stringify(manifest, null, 2)));
+  files.set("manifest.json", encoder5.encode(JSON.stringify(manifest, null, 2)));
   if (options?.includeBlobs && options.blobStore) {
     const packed = /* @__PURE__ */ new Set();
     for (const row of attachmentRows.rows) {
@@ -38038,14 +39913,14 @@ init_geometry_buffer();
 
 // src/shard/parse.ts
 init_geometry_buffer();
-var decoder2 = new TextDecoder();
+var decoder4 = new TextDecoder();
 function parseJsonlBytes(data) {
   if (!data || data.byteLength === 0) return [];
-  return decoder2.decode(data).split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
+  return decoder4.decode(data).split("\n").filter((line) => line.trim()).map((line) => JSON.parse(line));
 }
 function parseJsonArrayBytes(data) {
   if (!data || data.byteLength === 0) return [];
-  return JSON.parse(decoder2.decode(data));
+  return JSON.parse(decoder4.decode(data));
 }
 
 // src/shard/blob-staging.ts
@@ -38109,8 +39984,8 @@ async function promoteBlobs(blobStore, blobs) {
 init_geometry_buffer();
 function instant(value) {
   if (value === null || value === void 0) return Number.NEGATIVE_INFINITY;
-  const timestamp3 = value instanceof Date ? value.getTime() : Date.parse(value);
-  return Number.isNaN(timestamp3) ? Number.NEGATIVE_INFINITY : timestamp3;
+  const timestamp4 = value instanceof Date ? value.getTime() : Date.parse(value);
+  return Number.isNaN(timestamp4) ? Number.NEGATIVE_INFINITY : timestamp4;
 }
 function shouldApplyReplacement(existing, incoming) {
   const existingDeleted = instant(existing.deleted_at);
@@ -38470,7 +40345,7 @@ async function importNativeFullV1(db, data, options = {}) {
 }
 
 // src/shard/shard-import.ts
-var decoder3 = new TextDecoder();
+var decoder5 = new TextDecoder();
 var DEFAULT_BATCH_SIZE = 250;
 function emptyCounts2() {
   return {
@@ -38607,7 +40482,7 @@ async function importShard(db, data, options) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(decoder3.decode(manifestData));
+    manifest = JSON.parse(decoder5.decode(manifestData));
     if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
       throw new Error("manifest must be a JSON object");
     }
@@ -38911,11 +40786,11 @@ async function importShard(db, data, options) {
           }
         }
       }
-      const skipExisting = async (key2, sql, params) => {
+      const skipExisting = async (key3, sql, params) => {
         if (strategy !== "skip") return false;
         const existing = await tx.query(sql, params);
         if (existing.rows.length === 0) return false;
-        skipped[key2] = (skipped[key2] ?? 0) + 1;
+        skipped[key3] = (skipped[key3] ?? 0) + 1;
         return true;
       };
       const storePresence = async (component, recordId, record) => {
@@ -39839,8 +41714,8 @@ function slugifyServerEmbeddingSet(value) {
 
 // src/shard/full-v1-store.ts
 init_geometry_buffer();
-var decoder4 = new TextDecoder();
-var encoder4 = new TextEncoder();
+var decoder6 = new TextDecoder();
+var encoder6 = new TextEncoder();
 function emptyCounts3() {
   return {
     notes: 0,
@@ -39894,12 +41769,12 @@ function componentRecords(component, bytes) {
 function canonicalJson4(value) {
   if (Array.isArray(value)) return `[${value.map(canonicalJson4).join(",")}]`;
   if (value && typeof value === "object") {
-    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key2, item]) => `${JSON.stringify(key2)}:${canonicalJson4(item)}`).join(",")}}`;
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key3, item]) => `${JSON.stringify(key3)}:${canonicalJson4(item)}`).join(",")}}`;
   }
   return JSON.stringify(value);
 }
 function encodeComponentRecords(component, records) {
-  return encoder4.encode(FULL_V1_COMPONENT_FILES[component].encoding === "json-array" ? JSON.stringify(records) : records.map((record) => JSON.stringify(record)).join("\n"));
+  return encoder6.encode(FULL_V1_COMPONENT_FILES[component].encoding === "json-array" ? JSON.stringify(records) : records.map((record) => JSON.stringify(record)).join("\n"));
 }
 function attachmentBlobReferences(files) {
   const refs = /* @__PURE__ */ new Map();
@@ -39936,7 +41811,7 @@ async function importFullV1Snapshot(db, data, options) {
     files = unpackTarGz(bytes);
     const manifestBytes = files.get("manifest.json");
     if (!manifestBytes) throw new Error("Missing manifest");
-    const parsed2 = JSON.parse(decoder4.decode(manifestBytes));
+    const parsed2 = JSON.parse(decoder6.decode(manifestBytes));
     if (!parsed2 || typeof parsed2 !== "object" || Array.isArray(parsed2)) {
       throw new Error("Manifest is not an object");
     }
@@ -40190,7 +42065,7 @@ async function exportFullV1Snapshot(db, blobStore) {
       name: "fortemi-react-full-v1-store",
       version: manifest.producer?.version ?? "unknown"
     };
-    files.set("manifest.json", encoder4.encode(JSON.stringify(manifest, null, 2)));
+    files.set("manifest.json", encoder6.encode(JSON.stringify(manifest, null, 2)));
     files.delete("signature.json");
     blobRefs = attachmentBlobReferences(files);
   } else {
@@ -40217,7 +42092,7 @@ async function exportFullV1Snapshot(db, blobStore) {
 
 // src/shard/shard-reader.ts
 init_geometry_buffer();
-var decoder5 = new TextDecoder();
+var decoder7 = new TextDecoder();
 function assertSafeComponentName(filename) {
   if (filename.length === 0 || filename.startsWith("/") || filename.includes("\\") || filename.includes("\0") || filename.includes(":") || filename.split("/").some((segment) => segment === "..")) {
     throw new Error(`Refusing to read unsafe shard component path: ${JSON.stringify(filename)}`);
@@ -40319,7 +42194,7 @@ async function resolveStore(source, maxComponentBytes) {
   const files = unpackTarGz(bytes);
   const manifestBytes = files.get("manifest.json");
   if (!manifestBytes) throw new Error("Missing manifest.json in shard archive");
-  const manifest = JSON.parse(decoder5.decode(manifestBytes));
+  const manifest = JSON.parse(decoder7.decode(manifestBytes));
   return new PackedComponentStore(files, manifest);
 }
 function tokenize(query) {
@@ -40456,14 +42331,14 @@ var ShardReaderImpl = class {
       weights: { ...DEFAULT_WEIGHTS, ...options.weights }
     });
   }
-  cacheMatches(key2, notes) {
-    this.matchCache.delete(key2);
-    this.matchCache.set(key2, notes);
+  cacheMatches(key3, notes) {
+    this.matchCache.delete(key3);
+    this.matchCache.set(key3, notes);
     let total = 0;
     for (const set of this.matchCache.values()) total += set.length;
     while (total > this.maxCachedMatches && this.matchCache.size > 1) {
       const oldest = this.matchCache.keys().next().value;
-      if (oldest === void 0 || oldest === key2) break;
+      if (oldest === void 0 || oldest === key3) break;
       total -= this.matchCache.get(oldest)?.length ?? 0;
       this.matchCache.delete(oldest);
     }
@@ -40473,12 +42348,12 @@ var ShardReaderImpl = class {
     const weights = { ...DEFAULT_WEIGHTS, ...options.weights };
     const offset = options.offset ?? 0;
     const limit = options.limit ?? Number.MAX_SAFE_INTEGER;
-    const key2 = this.matchKey(query, options);
-    let matched = this.matchCache.get(key2);
+    const key3 = this.matchKey(query, options);
+    let matched = this.matchCache.get(key3);
     let fetchedClusters = 0;
     if (matched) {
-      this.matchCache.delete(key2);
-      this.matchCache.set(key2, matched);
+      this.matchCache.delete(key3);
+      this.matchCache.set(key3, matched);
     } else {
       const { notes, fetched } = await this.loadAllNotes();
       fetchedClusters = fetched;
@@ -40486,7 +42361,7 @@ var ShardReaderImpl = class {
       if (tokens.length > 0 && options.rank !== false) {
         matched = [...matched].sort((a, b) => rankNote(b, tokens, weights) - rankNote(a, tokens, weights));
       }
-      this.cacheMatches(key2, matched);
+      this.cacheMatches(key3, matched);
     }
     const page = matched.slice(offset, offset + limit);
     const result = {
@@ -40605,7 +42480,7 @@ async function openShard(source, options = {}) {
 
 // src/shard/semantic-providers.ts
 init_geometry_buffer();
-var decoder6 = new TextDecoder();
+var decoder8 = new TextDecoder();
 function cosine(a, b) {
   let dot = 0;
   let normA = 0;
@@ -40629,7 +42504,7 @@ function createCosineSemanticProvider(options) {
         vectors = [];
         return;
       }
-      vectors = decoder6.decode(bytes).split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
+      vectors = decoder8.decode(bytes).split("\n").filter((line) => line.trim().length > 0).map((line) => JSON.parse(line));
     },
     async search(query, k) {
       const queryVector = await options.embedQuery(query);
@@ -42165,14 +44040,14 @@ function matchSetCacheKey(q, options) {
     weights: { ...DEFAULT_QUERY_WEIGHTS, ...options.weights }
   });
 }
-function cacheMatchEntries(runtime, key2, entries) {
-  runtime.matchCache.delete(key2);
-  runtime.matchCache.set(key2, entries);
+function cacheMatchEntries(runtime, key3, entries) {
+  runtime.matchCache.delete(key3);
+  runtime.matchCache.set(key3, entries);
   let total = 0;
   for (const set of runtime.matchCache.values()) total += set.length;
   while (total > runtime.maxCachedMatches && runtime.matchCache.size > 1) {
     const oldest = runtime.matchCache.keys().next().value;
-    if (oldest === void 0 || oldest === key2) break;
+    if (oldest === void 0 || oldest === key3) break;
     total -= runtime.matchCache.get(oldest)?.length ?? 0;
     runtime.matchCache.delete(oldest);
   }
@@ -42185,15 +44060,15 @@ function getPartsForRange(manifest, offset, limit) {
   return manifest.parts.filter((part) => part.count > 0 && part.offset < end && part.offset + part.count > offset);
 }
 async function loadChunkPart(runtime, part) {
-  const key2 = chunkPartCacheKey(part);
-  const cached = runtime.partCache.get(key2);
+  const key3 = chunkPartCacheKey(part);
+  const cached = runtime.partCache.get(key3);
   if (cached) {
-    runtime.partCache.delete(key2);
-    runtime.partCache.set(key2, cached);
+    runtime.partCache.delete(key3);
+    runtime.partCache.set(key3, cached);
     return { part: cached, fetched: false };
   }
   const parsed = assertAiwgFortemiChunkPart(await runtime.loader(part, runtime.manifest), part, runtime.manifest);
-  runtime.partCache.set(key2, parsed);
+  runtime.partCache.set(key3, parsed);
   while (runtime.partCache.size > runtime.maxCachedParts) {
     const oldest = runtime.partCache.keys().next().value;
     if (oldest === void 0) break;
@@ -42618,10 +44493,10 @@ function aiwgFortemiIndexToCommunityGraph(index, options = {}) {
       const kind = relationship.type;
       const configuredWeight = Object.prototype.hasOwnProperty.call(relationshipWeights, kind) ? relationshipWeights[kind] : void 0;
       const baseWeight = typeof configuredWeight === "number" && Number.isFinite(configuredWeight) ? configuredWeight : 1;
-      const key2 = `${item.id}\0${relationship.target_id}\0${kind}`;
-      const existing = edgeCounts.get(key2);
+      const key3 = `${item.id}\0${relationship.target_id}\0${kind}`;
+      const existing = edgeCounts.get(key3);
       if (existing) existing.weight += baseWeight;
-      else edgeCounts.set(key2, { source: item.id, target: relationship.target_id, kind, weight: baseWeight });
+      else edgeCounts.set(key3, { source: item.id, target: relationship.target_id, kind, weight: baseWeight });
     }
   }
   const communities = /* @__PURE__ */ new Map();
@@ -43361,7 +45236,7 @@ function getAiwgFortemiIndexExportSchema() {
 }
 function getAjv() {
   if (!ajvInstance) {
-    ajvInstance = new Ajv20202({
+    ajvInstance = new Ajv20206({
       allErrors: true,
       strict: false,
       validateFormats: false
@@ -43406,7 +45281,7 @@ function getProjectedRecordValidator() {
   return projectedRecordValidator;
 }
 function validateAiwgFortemiIndexExportSchema(value) {
-  const validate3 = getExportValidator();
+  const validate4 = getExportValidator();
   const schemaValue = value && typeof value === "object" && Array.isArray(value.items) ? {
     ...value,
     items: value.items.map((item) => {
@@ -43416,18 +45291,18 @@ function validateAiwgFortemiIndexExportSchema(value) {
       return schemaRecord;
     })
   } : value;
-  const valid = validate3(schemaValue);
-  return { valid, errors: formatErrors2(validate3.errors) };
+  const valid = validate4(schemaValue);
+  return { valid, errors: formatErrors2(validate4.errors) };
 }
 function validateAiwgFortemiProjectedRecordSchema(value) {
-  const validate3 = getProjectedRecordValidator();
-  const valid = validate3(value);
-  return { valid, errors: formatErrors2(validate3.errors) };
+  const validate4 = getProjectedRecordValidator();
+  const valid = validate4(value);
+  return { valid, errors: formatErrors2(validate4.errors) };
 }
 
 // src/aiwg-index-full-shard.ts
 init_geometry_buffer();
-var encoder5 = new TextEncoder();
+var encoder7 = new TextEncoder();
 var UUID_NAMESPACE = "7ab5d1f8-29d2-5e35-9e2f-3a45de171a9e";
 function uuid5(kind, id) {
   return v5(`${kind}:${id}`, UUID_NAMESPACE);
@@ -43435,7 +45310,7 @@ function uuid5(kind, id) {
 function own(value, field) {
   return Object.prototype.hasOwnProperty.call(value, field);
 }
-function timestamp2(value) {
+function timestamp3(value) {
   if (!value || Number.isNaN(Date.parse(value))) return void 0;
   return new Date(value).toISOString();
 }
@@ -43443,7 +45318,7 @@ function addLoss(losses, code, message, details = {}) {
   losses.push({ code, message, ...details });
 }
 function encode(values, encoding) {
-  return encoder5.encode(encoding === "json-array" ? JSON.stringify(values) : values.map((value) => JSON.stringify(value)).join("\n"));
+  return encoder7.encode(encoding === "json-array" ? JSON.stringify(values) : values.map((value) => JSON.stringify(value)).join("\n"));
 }
 function noteTitle(record, losses) {
   if (own(record, "title")) return record.title ?? null;
@@ -43508,7 +45383,7 @@ function noteContent(record, losses) {
   return "";
 }
 function createdAt(record, losses) {
-  const source = timestamp2(record.source.updated_at);
+  const source = timestamp3(record.source.updated_at);
   if (source) return source;
   addLoss(
     losses,
@@ -43538,7 +45413,7 @@ function schemeName(concept) {
 }
 async function convertAiwgIndexToFullV1(index, options = {}) {
   const losses = [];
-  const exportedAt = timestamp2(options.createdAt) ?? new Date(index.generated_at).toISOString();
+  const exportedAt = timestamp3(options.createdAt) ?? new Date(index.generated_at).toISOString();
   const records = [...index.items].sort((a, b) => a.id.localeCompare(b.id));
   const noteIds = new Map(records.map((record) => [record.id, uuid5("record", record.id)]));
   const rows = /* @__PURE__ */ new Map();
@@ -43611,7 +45486,7 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
       tags: recordTags,
       attachments: []
     });
-    const hash = await sha256Hex(encoder5.encode(content));
+    const hash = await sha256Hex(encoder7.encode(content));
     rows.get("note_originals").push({
       id: uuid5("note-original", record.id),
       note_id: noteId,
@@ -43633,9 +45508,9 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
   for (const record of records) {
     for (const [position, relationship] of record.relationships.entries()) {
       const target = noteIds.get(relationship.target_id) ?? null;
-      const key2 = `${record.id}\0${position}\0${relationship.type}\0${relationship.target_id}`;
+      const key3 = `${record.id}\0${position}\0${relationship.type}\0${relationship.target_id}`;
       rows.get("links").push({
-        id: uuid5("relationship", key2),
+        id: uuid5("relationship", key3),
         from_note_id: noteIds.get(record.id),
         to_note_id: target,
         to_url: target ? null : `aiwg://record/${encodeURIComponent(relationship.target_id)}`,
@@ -43703,7 +45578,7 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
       metric: null,
       algorithm: null,
       parameters: null,
-      input_hash: `sha256:${await sha256Hex(encoder5.encode(JSON.stringify(relationshipInput)))}`,
+      input_hash: `sha256:${await sha256Hex(encoder7.encode(JSON.stringify(relationshipInput)))}`,
       freshness: { status: "fresh", checked_at: exportedAt },
       created_at: exportedAt
     });
@@ -43792,7 +45667,7 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
         action: "omit"
       }
     );
-    const unmappedConceptMetadata = Object.keys(concept.metadata ?? {}).filter((key2) => key2 !== "domain");
+    const unmappedConceptMetadata = Object.keys(concept.metadata ?? {}).filter((key3) => key3 !== "domain");
     if (unmappedConceptMetadata.length > 0) addLoss(
       losses,
       "aiwg-skos-metadata-unmapped",
@@ -43935,7 +45810,7 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
   }
   for (const record of records) {
     for (const [position, event] of (record.provenance_events ?? []).entries()) {
-      const start = timestamp2(event.started_at);
+      const start = timestamp3(event.started_at);
       if (!start) addLoss(
         losses,
         "aiwg-provenance-start-unavailable",
@@ -43955,7 +45830,7 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
         activity_type: event.activity,
         model_name: event.agent ?? null,
         started_at: start ?? new Date(record.updated_at).toISOString(),
-        ended_at: timestamp2(event.ended_at) ?? null,
+        ended_at: timestamp3(event.ended_at) ?? null,
         metadata: {
           source: event.source ?? null,
           path: event.path ?? null,
@@ -44161,7 +46036,7 @@ async function convertAiwgIndexToFullV1(index, options = {}) {
     checksums,
     min_reader_version: "2.0.0"
   };
-  const manifestBytes = encoder5.encode(JSON.stringify(manifest, null, 2));
+  const manifestBytes = encoder7.encode(JSON.stringify(manifest, null, 2));
   files.set("manifest.json", manifestBytes);
   const validation = await validateFullV1ShardArchive(files);
   if (!validation.valid) {
@@ -44441,7 +46316,7 @@ var RECORD_STORE_CAPABILITIES = {
   sourceAddressedUpsert: true,
   deletionReceipts: true,
   typedMetadataPredicates: false,
-  evidenceLocators: true,
+  evidenceLocators: false,
   fullTextSearch: false,
   vectorSearch: false,
   sqlJoins: false
@@ -44828,7 +46703,7 @@ var CanonicalNotesRepository = class {
    * Bounded substring scan over title + revised content (case-insensitive).
    * This is deliberately not ranked FTS — see `store.capabilities`.
    */
-  async searchText(query, limit = 20) {
+  async searchText(query, limit = 20, accept) {
     const needle = query.toLowerCase();
     const revised = new Map(
       (await this.store.list("note_revised_current")).map((r) => [r.id, r.content])
@@ -44836,6 +46711,7 @@ var CanonicalNotesRepository = class {
     const hits = [];
     for (const note of await this.store.list("note")) {
       if (note.deleted_at !== null) continue;
+      if (accept && !accept(note)) continue;
       const haystack = `${note.title ?? ""}
 ${revised.get(note.id) ?? ""}`.toLowerCase();
       if (haystack.includes(needle)) {
@@ -45351,6 +47227,8 @@ function createRecordBackend(store, options = {}) {
       // via importShardToRecords (record-shard.ts)
       multiUser: false,
       semantic: "none",
+      typedMetadataPredicates: false,
+      evidenceLocators: false,
       startupCost: "instant"
     },
     async listNotes(o) {
@@ -45370,17 +47248,11 @@ function createRecordBackend(store, options = {}) {
       return noteToBackend(view.note, view.tags);
     },
     async search(query, o) {
+      validateBackendSearchOptions(o, { metadata: false, scope: false, modes: ["fts"] });
       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 matched = await notes.searchText(query, offset + limit, (n) => (!o?.tags?.length || o.tags.every((t) => (tags.get(n.id) ?? []).includes(t))) && (!o?.source?.length || o.source.includes(n.source)));
       const hits = matched.slice(offset, offset + limit).map((n) => ({ note: noteToBackend(n, tags.get(n.id) ?? []) }));
       return { hits, total: matched.length };
     },
@@ -45438,8 +47310,8 @@ function createRecordBackend(store, options = {}) {
 
 // src/records/record-shard.ts
 init_geometry_buffer();
-var encoder6 = new TextEncoder();
-var decoder7 = new TextDecoder();
+var encoder8 = new TextEncoder();
+var decoder9 = new TextDecoder();
 function emptyCounts4() {
   return {
     notes: 0,
@@ -45696,11 +47568,11 @@ async function buildRecordShardArchive(store, options, profile) {
       const slice = shardNotes.slice(offset, offset + clusterSize);
       const href = `notes/${String(offset).padStart(6, "0")}.jsonl`;
       clusters.push({ href, offset });
-      files.set(href, encoder6.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
+      files.set(href, encoder8.encode(slice.map((n) => JSON.stringify(n)).join("\n")));
     }
     layout = { clusters: { notes: clusters } };
   } else {
-    files.set("notes.jsonl", encoder6.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
+    files.set("notes.jsonl", encoder8.encode(shardNotes.map((n) => JSON.stringify(n)).join("\n")));
   }
   components4.push("notes");
   counts.notes = shardNotes.length;
@@ -45728,7 +47600,7 @@ async function buildRecordShardArchive(store, options, profile) {
       note_count: mapped.note_count ?? 0
     };
   });
-  files.set("collections.json", encoder6.encode(JSON.stringify(shardCollections)));
+  files.set("collections.json", encoder8.encode(JSON.stringify(shardCollections)));
   components4.push("collections");
   counts.collections = shardCollections.length;
   const distinctTags = [...new Set(
@@ -45745,7 +47617,7 @@ async function buildRecordShardArchive(store, options, profile) {
       created_at: tagCreatedAt.get(name) ?? (/* @__PURE__ */ new Date(0)).toISOString()
     }))
   );
-  files.set("tags.json", encoder6.encode(JSON.stringify(shardTags)));
+  files.set("tags.json", encoder8.encode(JSON.stringify(shardTags)));
   components4.push("tags");
   counts.tags = shardTags.length;
   const links = await store.list("link");
@@ -45767,7 +47639,7 @@ async function buildRecordShardArchive(store, options, profile) {
     }
     return shard;
   });
-  files.set("links.jsonl", encoder6.encode(shardLinks.map((l) => JSON.stringify(l)).join("\n")));
+  files.set("links.jsonl", encoder8.encode(shardLinks.map((l) => JSON.stringify(l)).join("\n")));
   components4.push("links");
   counts.links = shardLinks.length;
   const checksums = {};
@@ -45897,7 +47769,7 @@ async function buildRecordShardArchive(store, options, profile) {
       );
     }
   }
-  files.set("manifest.json", encoder6.encode(JSON.stringify(manifest, null, 2)));
+  files.set("manifest.json", encoder8.encode(JSON.stringify(manifest, null, 2)));
   if (options?.includeBlobs && options.blobStore) {
     const packed = /* @__PURE__ */ new Set();
     for (const checksum of exportedBlobChecksums) {
@@ -45977,7 +47849,7 @@ async function importShardToRecords(store, data, options) {
   }
   let manifest;
   try {
-    manifest = JSON.parse(decoder7.decode(manifestData));
+    manifest = JSON.parse(decoder9.decode(manifestData));
     if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
       throw new Error("manifest must be a JSON object");
     }
@@ -46114,8 +47986,8 @@ async function importShardToRecords(store, data, options) {
   for (const component of manifest.components ?? []) {
     if (UNSUPPORTED_COMPONENTS.includes(component)) {
       const count2 = manifest.counts?.[component];
-      const key2 = component === "communities" ? "communities" : component;
-      skipped[key2] = (skipped[key2] ?? 0) + (typeof count2 === "number" ? count2 : 0);
+      const key3 = component === "communities" ? "communities" : component;
+      skipped[key3] = (skipped[key3] ?? 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.`
       );
@@ -46283,7 +48155,7 @@ async function importShardToRecords(store, data, options) {
       id: existingOriginal?.id ?? generateId(),
       note_id: note.id,
       content: note.original_content,
-      content_hash: computeHash(encoder6.encode(note.original_content)),
+      content_hash: computeHash(encoder8.encode(note.original_content)),
       created_at: createdAt2
     };
     mutations.push({ op: "put", collection: "note_original", record: originalRecord });
@@ -46590,7 +48462,7 @@ async function upsertRecordStoreSources(store, items, options = {}) {
   const requestDigest = sourceRequestDigest(items, options);
   const batchId = options.batchId ?? deriveSourceBatchId(requestDigest);
   const batchReason = batchId.length === 0 || batchId.length > 200 ? "invalid_batch_metadata" : JSON.stringify(options.checkpoint ?? {}).length > 65536 ? "checkpoint_too_large" : void 0;
-  const validation = validate2(items, options.maxItems ?? 500, batchReason);
+  const validation = validate3(items, options.maxItems ?? 500, batchReason);
   if (validation) return finish2(importRunId, batchId, options.dryRun === true, "rejected", validation, options.checkpoint);
   const batches = await store.list("source_import_batch");
   const prior = batches.find((batch2) => batch2.tenant_id === (items[0].source.tenant_id ?? "default") && batch2.archive_id === (items[0].source.archive_id ?? null) && batch2.namespace === items[0].source.namespace && batch2.batch_id === batchId);
@@ -46774,7 +48646,7 @@ function addUpdateMutations(mutations, item, identity, note, current, original,
     mutations.push({ op: "put", collection: "note_revision", record: revision });
   }
 }
-function validate2(items, maxItems, initialReason) {
+function validate3(items, maxItems, initialReason) {
   let reason = initialReason ?? (items.length === 0 || items.length > maxItems ? "batch_size_out_of_bounds" : null);
   const seen = /* @__PURE__ */ new Set();
   const stableIds = /* @__PURE__ */ new Set();
@@ -46783,9 +48655,9 @@ function validate2(items, maxItems, initialReason) {
     if ((item.source.source_id?.length ?? 0) > 500 || item.source.source_id === "" || (item.source.workspace_id?.length ?? 0) > 500 || item.source.workspace_id === "") reason ??= "invalid_batch_metadata";
     if ((item.format ?? "markdown").length > 100 || (item.title?.length ?? 0) > 2e3 || JSON.stringify(item.metadata ?? {}).length > 262144) reason ??= "invalid_item";
     if (item.content_digest && item.content_digest !== sourceContentDigest(item.content)) reason ??= "content_digest_mismatch";
-    const key2 = `${item.source.tenant_id}\0${item.source.archive_id ?? ""}\0${item.source.namespace}\0${item.source.external_id}`;
-    if (seen.has(key2)) reason ??= "duplicate_external_id_in_batch";
-    seen.add(key2);
+    const key3 = `${item.source.tenant_id}\0${item.source.archive_id ?? ""}\0${item.source.namespace}\0${item.source.external_id}`;
+    if (seen.has(key3)) reason ??= "duplicate_external_id_in_batch";
+    seen.add(key3);
     if (item.source.caller_stable_id && stableIds.has(item.source.caller_stable_id)) reason ??= "caller_stable_id_conflict";
     if (item.source.caller_stable_id) stableIds.add(item.source.caller_stable_id);
   }
@@ -46917,7 +48789,7 @@ async function purgeRecordStoreGraph(store, selector, operationKey) {
 }
 
 // src/index.ts
-var VERSION = "2026.9.4";
+var VERSION = "2026.9.6";
 /*! Bundled license information:
 
 ieee754/index.js:
@@ -46932,6 +48804,6 @@ buffer/index.js:
    *)
 */
 
-export { AIWG_SCAN_REQUIRED_FIELDS, AllowlistTrustStore, ArchiveManager, AttachmentsRepository, BridgeInferenceProvider, CORE_V1_COMPONENTS, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, CanonicalAttachmentsRepository, CanonicalNotesRepository, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, DATASET_EXECUTION_CAPABILITY_IDS, DATASET_EXECUTION_CONTRACT, DATASET_EXECUTION_SCHEMA_VERSION, DATASET_INGEST_CONTRACT, DATASET_INGEST_SCHEMA_VERSION, DATASET_LINEAGE_CONTRACT, DATASET_LINEAGE_SCHEMA_VERSION, DATASET_MATERIALIZATION_CONTRACT, DATASET_MATERIALIZATION_KINDS, DATASET_MATERIALIZATION_SCHEMA_VERSION, DB_SNAPSHOT_SCHEMA_VERSION, DEFAULT_LARGE_DOCUMENT_CHARS, DEFAULT_LARGE_DOCUMENT_CHUNKS, DatasetIngestError, DatasetIngestExecutor, DatasetLineageLedger, DatasetMaterializationError, DbSnapshotVersionError, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, EmbeddingSetsRepository, FORTEMI_BROWSER_LOCAL_DATASET_EXECUTION_DESCRIPTOR, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_PORTABLE_SHARD_DATASET_EXECUTION_DESCRIPTOR, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FORTEMI_SERVER_COMPATIBILITY_REVISION, FORTEMI_STATIC_CACHE_DATASET_EXECUTION_DESCRIPTOR, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, IdbRecordStore, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LINEAGE_ENTITY_KINDS, LINEAGE_RELATIONSHIP_KINDS, LOCAL_ENDPOINTS, LifecyclePurgeRepository, LineageValidationError, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MemoryDatasetIngestStore, MemoryRecordStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProvenanceRepository, ProviderRegistry, RECORD_COLLECTIONS, RECORD_SCHEMA_VERSION, RECORD_STORE_CAPABILITIES, REGISTERED_METADATA_PATHS, RemoteBackendError, SHARD_FORMAT, SIGNATURE_ENTRY, SIGNING_ENVELOPE_VERSION, SOURCE_UPSERT_CONTRACT_VERSION, SOURCE_UPSERT_MAX_ITEMS, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, SourceUpsertRepository, TagsRepository, TemplatesRepository, 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, compareDatasetIncrementalParity, computeBlobHash, computeHash, computeLineageDigest, computeSri, conceptTaggingHandler, configureInferenceRuntime, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createBridgeInferenceProviders, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLazyBlobStore, createLegacyProvider, createLocalProviderProfile, createPGliteBackend, createPGliteInstance, createRecordBackend, createRecordStore, createRemoteBackend, createRoutes, createShardBackend, createShardCapabilityReport, createWorkerEmbedFunction, datasetDestinationScopeKey, defaultStorageBackendFactory, defineInferenceProvider, defineInferenceRuntime, defineLegacyInferenceProvider, defineOpenAICompatibleProvider, deriveDatasetIngestIdempotencyKey, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, digestDatasetMaterializationValue, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, executeDatasetMaterialization, executeDatasetRetrieval, exportFullV1Snapshot, exportShard, exportShardFromRecords, exportShardFromRecordsWithReport, exportShardWithReport, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getConfiguredInferenceProviderId, getEmbedFunction, getEmbeddingTaskSelectionOptions, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardContractReceipt, getKnowledgeShardProfileRegistry, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, getProviderRouteRequirementIssue, handleEmbedRequests, hasFortemiSecureSecrets, importFullV1Snapshot, importShard, importShardToRecords, inferInferenceTaskCapability, inferLocalEmbeddingDimensions, isPluginScriptAllowed, isShardPrefetched, isShardSigningSupported, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, mergeInferenceRuntimeConfigs, migrateLegacyBlobStore, negotiateDatasetExecutionCapabilities, negotiateDatasetMaterializationProfile, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, prefetchShard, previewRecordStorePurge, profileSupportError, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, providerSatisfiesRouteRequirements, purgeRecordStoreGraph, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, restoreDbSnapshot, searchTool, selectBackend, selectEmbeddingTask, selectLlmModel, setEmbedFunction, setEmbeddingTaskSelectionOptions, setLlmFunction, sha256Hex, sidecarBlobDigests, signShard, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, upsertRecordStoreRequest, upsertRecordStoreSources, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateAiwgStaticEmbeddingSet, validateChecksums, validateCoreV1ShardArchive, validateDatasetBenchmarkEvidence, validateDatasetExecutionDescriptor, validateFortemiCompatibilityResponse, validateFullV1ShardArchive, validateProviderRoute, validateRecordV1ShardArchive, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };
+export { AIWG_SCAN_REQUIRED_FIELDS, AllowlistTrustStore, ArchiveManager, AttachmentsRepository, BridgeInferenceProvider, CORE_V1_COMPONENTS, CURRENT_MIGRATION_HEAD, CURRENT_SHARD_VERSION, CanonicalAttachmentsRepository, CanonicalNotesRepository, CapabilityManager, CaptureKnowledgeInputSchema, CollectionsRepository, CommunitiesRepository, DATASET_EXECUTION_CAPABILITY_IDS, DATASET_EXECUTION_CONTRACT, DATASET_EXECUTION_SCHEMA_VERSION, DATASET_INGEST_CONTRACT, DATASET_INGEST_SCHEMA_VERSION, DATASET_LINEAGE_CONTRACT, DATASET_LINEAGE_SCHEMA_VERSION, DATASET_MATERIALIZATION_CONTRACT, DATASET_MATERIALIZATION_KINDS, DATASET_MATERIALIZATION_SCHEMA_VERSION, DB_SNAPSHOT_SCHEMA_VERSION, DEFAULT_LARGE_DOCUMENT_CHARS, DEFAULT_LARGE_DOCUMENT_CHUNKS, DatasetIngestError, DatasetIngestExecutor, DatasetLineageLedger, DatasetMaterializationError, DbSnapshotVersionError, EMBED_REQUEST_KIND, EMBED_RESPONSE_KIND, EmbeddingSetsRepository, FORTEMI_BROWSER_LOCAL_DATASET_EXECUTION_DESCRIPTOR, FORTEMI_COMPATIBILITY_PATH, FORTEMI_COMPATIBILITY_STATES, FORTEMI_PORTABLE_SHARD_DATASET_EXECUTION_DESCRIPTOR, FORTEMI_REQUIRED_COMPATIBILITY_CAPABILITIES, FORTEMI_SERVER_COMPATIBILITY_REVISION, FORTEMI_STATIC_CACHE_DATASET_EXECUTION_DESCRIPTOR, FallbackRouter, FortemiToolManifest, GetNoteInputSchema, GraphRepository, IdbRecordStore, JOB_CAPABILITIES, JOB_PRIORITIES, JobQueueWorker, LINEAGE_ENTITY_KINDS, LINEAGE_RELATIONSHIP_KINDS, LOCAL_ENDPOINTS, LifecyclePurgeRepository, LineageValidationError, LinksRepository, ListNotesInputSchema, ManageArchiveInputSchema, ManageAttachmentsInputSchema, ManageCapabilitiesInputSchema, ManageCollectionsInputSchema, ManageLinksInputSchema, ManageNoteInputSchema, ManageTagsInputSchema, MemoryBlobStore, MemoryDatasetIngestStore, MemoryRecordStore, MigrationRunner, NotesRepository, OpenAICompatibleProvider, PGliteStorageBackend, PGliteStorageBackendFactory, PGliteWorkerClient, PGliteWorkerStorageBackend, PGliteWorkerStorageBackendFactory, ProvenanceRepository, ProviderRegistry, RECORD_COLLECTIONS, RECORD_SCHEMA_VERSION, RECORD_STORE_CAPABILITIES, REGISTERED_METADATA_PATHS, RemoteBackendError, SHARD_FORMAT, SIGNATURE_ENTRY, SIGNING_ENVELOPE_VERSION, SOURCE_UPSERT_CONTRACT_VERSION, SOURCE_UPSERT_MAX_ITEMS, SUPPORTED_PGLITE_VERSION, SearchInputSchema, SearchRepository, SkosRepository, SourceUpsertRepository, TagsRepository, TemplatesRepository, TransactionProxy, TypedEventBus, VERSION, aiRevisionHandler, aiwgFortemiIndexFromKnowledgeShard, aiwgFortemiIndexToCommunityGraph, aiwgFortemiIndexToKnowledgeShard, aiwgFortemiIndexToKnowledgeShardWithReport, allMigrations, appendPluginScript, assertAiwgFortemiChunkManifest, assertAiwgFortemiChunkPart, assertAiwgFortemiIndexExport, assertAiwgStaticEmbeddingSet, assertShardComponentRecord, bindSearchEvidence, buildAiwgChunkedIndex, buildAiwgStaticEmbeddingSet, buildMetadataPredicateConditions, buildNoteConditions, buildPluginCsp, captureKnowledge, chunkText, classifyError, classifyModel, clearPrefetchedShard, collectionFromShard, collectionToShard, compareDatasetIncrementalParity, computeBlobHash, computeHash, computeLineageDigest, computeSri, conceptTaggingHandler, configureInferenceRuntime, cosineSimilarity, createAiwgFetchChunkLoader, createAiwgFetchDetailLoader, createAiwgIndexController, createAiwgReviewDecisionExport, createBlobStore, createBridgeInferenceProviders, createCosineSemanticProvider, createCspReportHandler, createFortemi, createLazyBlobStore, createLegacyProvider, createLocalProviderProfile, createPGliteBackend, createPGliteInstance, createRecordBackend, createRecordStore, createRemoteBackend, createRoutes, createSearchEvidenceSet, createShardBackend, createShardCapabilityReport, createWorkerEmbedFunction, datasetDestinationScopeKey, defaultStorageBackendFactory, defineInferenceProvider, defineInferenceRuntime, defineLegacyInferenceProvider, defineOpenAICompatibleProvider, deriveDatasetIngestIdempotencyKey, detectCommunities, detectGpuCapabilities, detectInferenceCapabilities, digestDatasetMaterializationValue, discoverLocalProviders, dropAttachmentProjection, dropNoteProjection, dumpDbSnapshot, embeddingConfigToShard, embeddingFromShard, embeddingGenerationHandler, embeddingSetFromShard, embeddingSetMemberToShard, embeddingSetToShard, embeddingToShard, enqueueFullWorkflow, enqueueJob, enqueueNoteCreationJobs, estimateModelFit, estimateVramMB, estimateVramTier, executeDatasetMaterialization, executeDatasetRetrieval, exportFullV1Snapshot, exportShard, exportShardFromRecords, exportShardFromRecordsWithReport, exportShardWithReport, fetchAndValidateFortemiCompatibility, fetchPluginScript, filterAiwgRecordsByPrivacy, findAiwgStaticDuplicatePairs, formatFortemiCompatibilitySummary, fortemiCompatibilityUrl, fortemiManifest, fromPrefetched, generateId, getAiwgFortemiFacets, getAiwgFortemiIndexExportSchema, getConfiguredInferenceProviderId, getEmbedFunction, getEmbeddingTaskSelectionOptions, getFortemiBridge, getFortemiSecretStore, getJobQueueStatus, getKnowledgeShardContractReceipt, getKnowledgeShardProfileRegistry, getKnowledgeShardSchema, getLlmFunction, getNote, getPrefetchedSha256, getProviderRouteRequirementIssue, handleEmbedRequests, hasFortemiSecureSecrets, importFullV1Snapshot, importShard, importShardToRecords, inferInferenceTaskCapability, inferLocalEmbeddingDimensions, isPluginScriptAllowed, isShardPrefetched, isShardSigningSupported, linkFromShard, linkToShard, linkingHandler, listNotes, manageArchive, manageAttachments, manageCapabilities, manageCollections, manageLinks, manageNote, manageTags, matchRoute, mergeInferenceRuntimeConfigs, mergeSearchEvidenceSets, migrateLegacyBlobStore, negotiateDatasetExecutionCapabilities, negotiateDatasetExecutionCapabilitiesFromWire, negotiateDatasetMaterializationProfile, noteFromShard, noteSkosTagToShard, noteToShard, openShard, packTarGz, parseCspReport, parseSearchEvidenceLocator, parseSearchEvidenceSet, prefetchShard, previewRecordStorePurge, profileSupportError, projectAttachments, projectNotes, projectRecords, provenanceEdgeToShard, providerSatisfiesRouteRequirements, purgeRecordStoreGraph, queryAiwgFortemiIndex, queryAiwgHybridIndex, queryAiwgSemanticIndex, registerLlmCapability, registerSemanticCapability, registerSemanticCapabilityWorker, registerServiceWorker, resolveSearchEvidence, restoreDbSnapshot, searchTool, selectBackend, selectEmbeddingTask, selectLlmModel, setEmbedFunction, setEmbeddingTaskSelectionOptions, setLlmFunction, sha256Hex, sidecarBlobDigests, signShard, skosConceptToShard, skosRelationToShard, skosSchemeToShard, suggestTags, tagsToShard, templateToShard, titleGenerationHandler, unpackTarGz, unregisterLlmCapability, unregisterSemanticCapability, upsertRecordStoreRequest, upsertRecordStoreSources, urlLinkToShard, validateAiwgFortemiChunkManifest, validateAiwgFortemiChunkPart, validateAiwgFortemiIndexExport, validateAiwgFortemiIndexExportSchema, validateAiwgFortemiProjectedRecordSchema, validateAiwgStaticEmbeddingSet, validateChecksums, validateCoreV1ShardArchive, validateDatasetBenchmarkEvidence, validateDatasetExecutionDescriptor, validateDatasetExecutionRequest, validateFortemiCompatibilityResponse, validateFullV1ShardArchive, validateProviderRoute, validateRecordV1ShardArchive, validateShardArchive, validateShardComponentRecord, validateShardManifest, verifyDbSnapshotMeta, verifyShardSignature, verifySri };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map