@fortemi/core 2026.7.3 → 2026.7.4

package/dist/aiwg-index.js

@@ -1,5 +1,7 @@
 import { sha256 } from '@noble/hashes/sha256';
+import '@noble/hashes/blake3';
 import { bytesToHex } from '@noble/hashes/utils';
+import Ajv2020 from 'ajv/dist/2020.js';
 
 // src/hash.ts
 function computeHash(data) {
@@ -7,6 +9,720 @@ function computeHash(data) {
   return `sha256:${bytesToHex(digest)}`;
 }
 
+// schemas/aiwg-fortemi-index-export.schema.json
+var aiwg_fortemi_index_export_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://aiwg.io/schemas/aiwg-fortemi-index-export.json",
+  title: "AIWG Fortemi Index Export",
+  type: "object",
+  additionalProperties: false,
+  required: ["schema_version", "generated_at", "source", "items"],
+  properties: {
+    schema_version: {
+      enum: ["aiwg.fortemi.index.export.v1", "aiwg.fortemi.index.export.v2"]
+    },
+    generated_at: {
+      type: "string",
+      format: "date-time"
+    },
+    source: {
+      type: "object",
+      additionalProperties: false,
+      required: ["repo", "privacy"],
+      properties: {
+        repo: {
+          type: "string",
+          minLength: 1
+        },
+        privacy: {
+          $ref: "#/$defs/privacy"
+        },
+        graph: {
+          type: "string",
+          minLength: 1
+        }
+      }
+    },
+    compatibility: {
+      type: "object",
+      additionalProperties: false,
+      required: ["previous_schema_version", "strategy"],
+      properties: {
+        previous_schema_version: {
+          const: "aiwg.fortemi.index.export.v1"
+        },
+        strategy: {
+          const: "supported"
+        }
+      }
+    },
+    items: {
+      type: "array",
+      items: {
+        $ref: "#/$defs/record"
+      }
+    }
+  },
+  allOf: [
+    {
+      if: {
+        properties: {
+          schema_version: {
+            const: "aiwg.fortemi.index.export.v1"
+          }
+        }
+      },
+      then: {
+        not: {
+          required: ["compatibility"]
+        },
+        properties: {
+          source: {
+            not: {
+              required: ["graph"]
+            }
+          },
+          items: {
+            items: {
+              allOf: [
+                {
+                  properties: {
+                    schema_version: {
+                      const: "aiwg.fortemi.index.record.v1"
+                    }
+                  }
+                },
+                {
+                  $ref: "#/$defs/v1RecordCompatibility"
+                }
+              ]
+            }
+          }
+        }
+      }
+    },
+    {
+      if: {
+        properties: {
+          schema_version: {
+            const: "aiwg.fortemi.index.export.v2"
+          }
+        }
+      },
+      then: {
+        required: ["compatibility"],
+        properties: {
+          source: {
+            required: ["graph"]
+          },
+          items: {
+            items: {
+              properties: {
+                schema_version: {
+                  const: "aiwg.fortemi.index.record.v2"
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  ],
+  $defs: {
+    privacy: {
+      enum: ["private", "sanitized", "public"]
+    },
+    recordType: {
+      type: "string",
+      minLength: 1
+    },
+    stringArray: {
+      type: "array",
+      items: {
+        type: "string"
+      }
+    },
+    numberArray: {
+      type: "array",
+      items: {
+        type: "number"
+      }
+    },
+    v1RecordCompatibility: {
+      type: "object",
+      not: {
+        anyOf: [
+          {
+            required: ["name"]
+          },
+          {
+            required: ["summary"]
+          },
+          {
+            required: ["search"]
+          },
+          {
+            required: ["chunks"]
+          },
+          {
+            required: ["embeddings"]
+          },
+          {
+            required: ["compatibility"]
+          },
+          {
+            required: ["skos_concepts"]
+          },
+          {
+            required: ["skos_relations"]
+          },
+          {
+            required: ["provenance_events"]
+          }
+        ]
+      },
+      properties: {
+        source: {
+          not: {
+            anyOf: [
+              {
+                required: ["origin"]
+              },
+              {
+                required: ["generated"]
+              },
+              {
+                required: ["checksum"]
+              },
+              {
+                required: ["updated_at"]
+              }
+            ]
+          }
+        },
+        relationships: {
+          items: {
+            not: {
+              anyOf: [
+                {
+                  required: ["target_path"]
+                },
+                {
+                  required: ["direction"]
+                },
+                {
+                  required: ["label"]
+                },
+                {
+                  required: ["confidence"]
+                },
+                {
+                  required: ["privacy"]
+                },
+                {
+                  required: ["metadata"]
+                }
+              ]
+            }
+          }
+        },
+        privacy: {
+          not: {
+            required: ["locality"]
+          }
+        }
+      }
+    },
+    record: {
+      type: "object",
+      additionalProperties: false,
+      required: [
+        "schema_version",
+        "id",
+        "type",
+        "source",
+        "title",
+        "text",
+        "facets",
+        "tags",
+        "concepts",
+        "relationships",
+        "provenance",
+        "privacy",
+        "updated_at"
+      ],
+      properties: {
+        schema_version: {
+          enum: [
+            "aiwg.fortemi.index.record.v1",
+            "aiwg.fortemi.index.record.v2"
+          ]
+        },
+        id: {
+          type: "string",
+          minLength: 1
+        },
+        type: {
+          $ref: "#/$defs/recordType"
+        },
+        source: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path", "repo_relative_path", "locator"],
+          properties: {
+            path: {
+              type: "string",
+              minLength: 1
+            },
+            repo_relative_path: {
+              type: "string",
+              minLength: 1
+            },
+            locator: {
+              type: "string",
+              minLength: 1
+            },
+            origin: {
+              type: "string",
+              minLength: 1
+            },
+            generated: {
+              type: "boolean"
+            },
+            checksum: {
+              type: "string"
+            },
+            updated_at: {
+              type: "string",
+              format: "date-time"
+            }
+          }
+        },
+        title: {
+          type: "string"
+        },
+        name: {
+          type: "string"
+        },
+        summary: {
+          type: "string"
+        },
+        text: {
+          type: "string"
+        },
+        search: {
+          type: "object",
+          additionalProperties: false,
+          required: [
+            "title",
+            "body",
+            "triggers",
+            "aliases",
+            "tags",
+            "frontmatter"
+          ],
+          properties: {
+            title: {
+              type: "string"
+            },
+            name: {
+              type: "string"
+            },
+            summary: {
+              type: "string"
+            },
+            body: {
+              type: "string"
+            },
+            triggers: {
+              $ref: "#/$defs/stringArray"
+            },
+            aliases: {
+              $ref: "#/$defs/stringArray"
+            },
+            capability: {
+              type: "string"
+            },
+            tags: {
+              $ref: "#/$defs/stringArray"
+            },
+            phase: {
+              type: "string"
+            },
+            type: {
+              type: "string"
+            },
+            frontmatter: {
+              type: "object"
+            }
+          }
+        },
+        facets: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        },
+        tags: {
+          $ref: "#/$defs/stringArray"
+        },
+        concepts: {
+          $ref: "#/$defs/stringArray"
+        },
+        relationships: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "target_id"],
+            properties: {
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              target_id: {
+                type: "string",
+                minLength: 1
+              },
+              source_path: {
+                type: "string"
+              },
+              target_path: {
+                type: "string"
+              },
+              direction: {
+                enum: ["upstream", "downstream", "related"]
+              },
+              label: {
+                type: "string"
+              },
+              confidence: {
+                type: "number"
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        provenance: {
+          type: "array",
+          minItems: 1,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["field", "source", "path", "confidence", "privacy"],
+            properties: {
+              field: {
+                type: "string",
+                minLength: 1
+              },
+              source: {
+                type: "string",
+                minLength: 1
+              },
+              path: {
+                type: "string",
+                minLength: 1
+              },
+              confidence: {
+                enum: ["source", "candidate", "reviewed", "rejected"]
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              }
+            }
+          }
+        },
+        privacy: {
+          type: "object",
+          additionalProperties: false,
+          required: ["classification", "pii"],
+          properties: {
+            classification: {
+              $ref: "#/$defs/privacy"
+            },
+            pii: {
+              type: "boolean"
+            },
+            locality: {
+              enum: ["project", "framework", "external"]
+            }
+          }
+        },
+        chunks: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              text: {
+                type: "string"
+              },
+              body: {
+                type: "string"
+              },
+              summary: {
+                type: "string"
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              },
+              checksum: {
+                type: "string"
+              }
+            }
+          }
+        },
+        embeddings: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              id: {
+                type: "string"
+              },
+              model: {
+                type: "string"
+              },
+              embedding: {
+                $ref: "#/$defs/numberArray"
+              },
+              vector: {
+                $ref: "#/$defs/numberArray"
+              },
+              granularity: {
+                type: "string"
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              },
+              chunk_id: {
+                type: "string"
+              },
+              vector_ref: {
+                type: "string"
+              },
+              input_hash: {
+                type: "string"
+              }
+            }
+          }
+        },
+        compatibility: {
+          type: "object"
+        },
+        skos_concepts: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["id", "prefLabel"],
+            properties: {
+              id: {
+                type: "string",
+                minLength: 1
+              },
+              prefLabel: {
+                type: "string",
+                minLength: 1
+              },
+              definition: {
+                type: "string"
+              },
+              scheme: {
+                type: "string"
+              },
+              notation: {
+                type: "string"
+              },
+              uri: {
+                type: "string"
+              },
+              altLabels: {
+                $ref: "#/$defs/stringArray"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        skos_relations: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["type", "source_id", "target_id"],
+            properties: {
+              type: {
+                type: "string",
+                minLength: 1
+              },
+              source_id: {
+                type: "string",
+                minLength: 1
+              },
+              target_id: {
+                type: "string",
+                minLength: 1
+              },
+              source_path: {
+                type: "string"
+              },
+              metadata: {
+                type: "object"
+              }
+            }
+          }
+        },
+        provenance_events: {
+          type: "array",
+          items: {
+            type: "object",
+            additionalProperties: false,
+            required: ["activity"],
+            properties: {
+              id: {
+                type: "string"
+              },
+              activity: {
+                type: "string",
+                minLength: 1
+              },
+              agent: {
+                type: "string"
+              },
+              started_at: {
+                type: "string",
+                format: "date-time"
+              },
+              ended_at: {
+                type: "string",
+                format: "date-time"
+              },
+              source: {
+                type: "string"
+              },
+              path: {
+                type: "string"
+              },
+              confidence: {
+                enum: ["source", "candidate", "reviewed", "rejected"]
+              },
+              privacy: {
+                $ref: "#/$defs/privacy"
+              },
+              attributes: {
+                type: "object"
+              }
+            }
+          }
+        },
+        updated_at: {
+          type: "string",
+          format: "date-time"
+        }
+      }
+    }
+  }
+};
+
+// src/aiwg-index-schema.ts
+var PROJECTED_FIELDS = [
+  "schema_version",
+  "id",
+  "type",
+  "title",
+  "text",
+  "facets",
+  "tags",
+  "concepts",
+  "privacy"
+];
+var ajvInstance;
+var exportValidator;
+var projectedRecordValidator;
+function getAjv() {
+  if (!ajvInstance) {
+    ajvInstance = new Ajv2020({
+      allErrors: true,
+      strict: false,
+      validateFormats: false
+    });
+    ajvInstance.addSchema(aiwg_fortemi_index_export_schema_default);
+  }
+  return ajvInstance;
+}
+function formatErrors(errors) {
+  return (errors ?? []).map((error) => {
+    const path = error.instancePath || "(root)";
+    return `${path} ${error.message ?? "is invalid"}`;
+  });
+}
+function getExportValidator() {
+  exportValidator ??= getAjv().getSchema(aiwg_fortemi_index_export_schema_default.$id) ?? getAjv().compile(aiwg_fortemi_index_export_schema_default);
+  return exportValidator;
+}
+function getProjectedRecordValidator() {
+  if (!projectedRecordValidator) {
+    const properties = Object.fromEntries(Object.keys(aiwg_fortemi_index_export_schema_default.$defs.record.properties).map((field) => [
+      field,
+      { $ref: `${aiwg_fortemi_index_export_schema_default.$id}#/$defs/record/properties/${field}` }
+    ]));
+    projectedRecordValidator = getAjv().compile({
+      type: "object",
+      required: PROJECTED_FIELDS,
+      properties,
+      additionalProperties: true,
+      allOf: [
+        {
+          if: {
+            properties: {
+              schema_version: { const: "aiwg.fortemi.index.record.v1" }
+            }
+          },
+          then: { $ref: `${aiwg_fortemi_index_export_schema_default.$id}#/$defs/v1RecordCompatibility` }
+        }
+      ]
+    });
+  }
+  return projectedRecordValidator;
+}
+function validateAiwgFortemiIndexExportSchema(value) {
+  const validate = getExportValidator();
+  const schemaValue = value && typeof value === "object" && Array.isArray(value.items) ? {
+    ...value,
+    items: value.items.map((item) => {
+      if (!item || typeof item !== "object" || Array.isArray(item)) return item;
+      const schemaRecord = { ...item };
+      Reflect.deleteProperty(schemaRecord, "binary_sources");
+      return schemaRecord;
+    })
+  } : value;
+  const valid = validate(schemaValue);
+  return { valid, errors: formatErrors(validate.errors) };
+}
+function validateAiwgFortemiProjectedRecordSchema(value) {
+  const validate = getProjectedRecordValidator();
+  const valid = validate(value);
+  return { valid, errors: formatErrors(validate.errors) };
+}
+
 // src/aiwg-index.ts
 var AIWG_SCAN_REQUIRED_FIELDS = [
   "schema_version",
@@ -21,7 +737,7 @@ var AIWG_SCAN_REQUIRED_FIELDS = [
 ];
 function isPrivacyExcluded(record, options) {
   const privacy = record.privacy;
-  if (!privacy) return false;
+  if (!privacy || !isPrivacyClassification(privacy.classification) || typeof privacy.pii !== "boolean") return true;
   if (privacy.classification === "private" && !options?.includePrivate) return true;
   if (privacy.pii && !options?.includePii) return true;
   return false;
@@ -90,6 +806,10 @@ function validateOptionalRichMetadata(item, index, errors) {
       errors.push("items[" + index + "].skos_concepts must be an array when present");
     } else {
       for (const [conceptIndex, concept] of item.skos_concepts.entries()) {
+        if (!isPlainRecord(concept)) {
+          errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "] must be an object");
+          continue;
+        }
         if (!hasString(concept.id)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].id is required");
         if (!hasString(concept.prefLabel)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].prefLabel is required");
         if (!isOptionalStringArray(concept.altLabels)) errors.push("items[" + index + "].skos_concepts[" + conceptIndex + "].altLabels must be a string array");
@@ -104,6 +824,10 @@ function validateOptionalRichMetadata(item, index, errors) {
       errors.push("items[" + index + "].skos_relations must be an array when present");
     } else {
       for (const [relationIndex, relation] of item.skos_relations.entries()) {
+        if (!isPlainRecord(relation)) {
+          errors.push("items[" + index + "].skos_relations[" + relationIndex + "] must be an object");
+          continue;
+        }
         if (!hasString(relation.type)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].type is required");
         if (!hasString(relation.source_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].source_id is required");
         if (!hasString(relation.target_id)) errors.push("items[" + index + "].skos_relations[" + relationIndex + "].target_id is required");
@@ -118,6 +842,10 @@ function validateOptionalRichMetadata(item, index, errors) {
       errors.push("items[" + index + "].provenance_events must be an array when present");
     } else {
       for (const [eventIndex, event] of item.provenance_events.entries()) {
+        if (!isPlainRecord(event)) {
+          errors.push("items[" + index + "].provenance_events[" + eventIndex + "] must be an object");
+          continue;
+        }
         if (!hasString(event.activity)) errors.push("items[" + index + "].provenance_events[" + eventIndex + "].activity is required");
         if (event.attributes !== void 0 && !isPlainRecord(event.attributes)) {
           errors.push("items[" + index + "].provenance_events[" + eventIndex + "].attributes must be an object");
@@ -127,6 +855,10 @@ function validateOptionalRichMetadata(item, index, errors) {
   }
   if (Array.isArray(item.relationships)) {
     for (const [relationshipIndex, relationship] of item.relationships.entries()) {
+      if (!isPlainRecord(relationship)) {
+        errors.push("items[" + index + "].relationships[" + relationshipIndex + "] must be an object");
+        continue;
+      }
       if (relationship.metadata !== void 0 && !isPlainRecord(relationship.metadata)) {
         errors.push("items[" + index + "].relationships[" + relationshipIndex + "].metadata must be an object");
       }
@@ -155,7 +887,10 @@ function validateOptionalRichMetadata(item, index, errors) {
       errors.push("items[" + index + "].chunks must be an array when present");
     } else {
       for (const [chunkIndex, chunk] of item.chunks.entries()) {
-        if (!isPlainRecord(chunk)) errors.push("items[" + index + "].chunks[" + chunkIndex + "] must be an object");
+        if (!isPlainRecord(chunk)) {
+          errors.push("items[" + index + "].chunks[" + chunkIndex + "] must be an object");
+          continue;
+        }
         if (chunk.metadata !== void 0 && !isPlainRecord(chunk.metadata)) {
           errors.push("items[" + index + "].chunks[" + chunkIndex + "].metadata must be an object");
         }
@@ -167,7 +902,10 @@ function validateOptionalRichMetadata(item, index, errors) {
       errors.push("items[" + index + "].embeddings must be an array when present");
     } else {
       for (const [embeddingIndex, embedding] of item.embeddings.entries()) {
-        if (!isPlainRecord(embedding)) errors.push("items[" + index + "].embeddings[" + embeddingIndex + "] must be an object");
+        if (!isPlainRecord(embedding)) {
+          errors.push("items[" + index + "].embeddings[" + embeddingIndex + "] must be an object");
+          continue;
+        }
         const vector = embedding.embedding ?? embedding.vector;
         if (vector !== void 0 && (!Array.isArray(vector) || !vector.every((entry) => typeof entry === "number"))) {
           errors.push("items[" + index + "].embeddings[" + embeddingIndex + "].embedding/vector must be a number array");
@@ -234,9 +972,10 @@ function forbidV2FieldsOnV1Record(item, index, errors) {
   }
 }
 function validateAiwgFortemiIndexExport(value) {
-  const errors = [];
-  const counts = {};
-  const data = value;
+  const errors = validateAiwgFortemiIndexExportSchema(value).errors;
+  const counts = /* @__PURE__ */ Object.create(null);
+  const data = isPlainRecord(value) ? value : {};
+  if (!isPlainRecord(value)) errors.push("index export must be an object");
   if (!isSupportedIndexSchemaVersion(data?.schema_version)) {
     errors.push("schema_version must be aiwg.fortemi.index.export.v1 or aiwg.fortemi.index.export.v2");
   }
@@ -260,7 +999,12 @@ function validateAiwgFortemiIndexExport(value) {
   }
   const ids = /* @__PURE__ */ new Set();
   let previousId = "";
-  for (const [index, item] of (data.items ?? []).entries()) {
+  const items = Array.isArray(data.items) ? data.items : [];
+  for (const [index, item] of items.entries()) {
+    if (!isPlainRecord(item)) {
+      errors.push("items[" + index + "] must be an object");
+      continue;
+    }
     for (const field of REQUIRED_RECORD_FIELDS) {
       if (!(field in item)) errors.push("items[" + index + "]." + field + " is required");
     }
@@ -270,7 +1014,7 @@ function validateAiwgFortemiIndexExport(value) {
     if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
     if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
     if (hasString(item.id)) ids.add(item.id);
-    if (previousId && hasString(item.id) && previousId.localeCompare(item.id) > 0) {
+    if (previousId && hasString(item.id) && previousId > item.id) {
       errors.push("items must be sorted by id: " + previousId + " before " + item.id);
     }
     if (hasString(item.id)) previousId = item.id;
@@ -311,7 +1055,8 @@ function assertAiwgFortemiIndexExport(value) {
 }
 function validateAiwgFortemiChunkManifest(value) {
   const errors = [];
-  const data = value;
+  const data = isPlainRecord(value) ? value : {};
+  if (!isPlainRecord(value)) errors.push("chunk manifest must be an object");
   if (data?.schema_version !== "aiwg.fortemi.index.chunk-manifest.v1") {
     errors.push("schema_version must be aiwg.fortemi.index.chunk-manifest.v1");
   }
@@ -336,7 +1081,9 @@ function validateAiwgFortemiChunkManifest(value) {
       }
     }
   }
-  if (data.detail !== void 0) {
+  if (data.detail !== void 0 && !isPlainRecord(data.detail)) {
+    errors.push("detail must be an object");
+  } else if (data.detail !== void 0) {
     if (!hasString(data.detail.href)) errors.push("detail.href is required");
     else if (!data.detail.href.includes("{id}")) errors.push("detail.href must contain the {id} placeholder");
     if (data.detail.encoding !== void 0 && data.detail.encoding !== "uri" && data.detail.encoding !== "base64url") {
@@ -347,6 +1094,10 @@ function validateAiwgFortemiChunkManifest(value) {
   let expectedOffset = 0;
   const parts = Array.isArray(data?.parts) ? data.parts : [];
   for (const [index, part] of parts.entries()) {
+    if (!isPlainRecord(part)) {
+      errors.push("parts[" + index + "] must be an object");
+      continue;
+    }
     if (!hasString(part.href)) errors.push("parts[" + index + "].href is required");
     if (!hasNonNegativeInteger(part.offset)) errors.push("parts[" + index + "].offset must be a non-negative integer");
     if (!hasNonNegativeInteger(part.count)) errors.push("parts[" + index + "].count must be a non-negative integer");
@@ -367,18 +1118,28 @@ function assertAiwgFortemiChunkManifest(value) {
   }
   return value;
 }
-function validateProjectedRecords(items) {
+function validateProjectedRecords(items, sourceSchemaVersion) {
   const errors = [];
   const ids = /* @__PURE__ */ new Set();
   let previousId = "";
   for (const [index, item] of items.entries()) {
+    if (!isPlainRecord(item)) {
+      errors.push("items[" + index + "] must be an object");
+      continue;
+    }
+    const schemaValidation = validateAiwgFortemiProjectedRecordSchema(item);
+    errors.push(...schemaValidation.errors.map((error) => `items[${index}]${error}`));
+    const expectedRecordVersion = sourceSchemaVersion === "aiwg.fortemi.index.export.v2" ? "aiwg.fortemi.index.record.v2" : "aiwg.fortemi.index.record.v1";
+    if (item.schema_version !== expectedRecordVersion) {
+      errors.push(`items[${index}].schema_version must match ${sourceSchemaVersion}`);
+    }
     if (!isSupportedRecordSchemaVersion(item.schema_version)) {
       errors.push("items[" + index + "].schema_version must be aiwg.fortemi.index.record.v1 or aiwg.fortemi.index.record.v2");
     }
     if (!hasString(item.id)) errors.push("items[" + index + "].id is required");
     if (hasString(item.id) && ids.has(item.id)) errors.push("duplicate id: " + item.id);
     if (hasString(item.id)) ids.add(item.id);
-    if (previousId && hasString(item.id) && previousId.localeCompare(item.id) > 0) {
+    if (previousId && hasString(item.id) && previousId > item.id) {
       errors.push("items must be sorted by id: " + previousId + " before " + item.id);
     }
     if (hasString(item.id)) previousId = item.id;
@@ -394,15 +1155,13 @@ function validateProjectedRecords(items) {
     }
     if (!Array.isArray(item.tags)) errors.push("items[" + index + "].tags must be an array");
     if (!Array.isArray(item.concepts)) errors.push("items[" + index + "].concepts must be an array");
-    if (!item.privacy || !hasString(item.privacy.classification)) {
-      errors.push("items[" + index + "].privacy.classification is required");
-    }
   }
   return errors;
 }
 function validateAiwgFortemiChunkPart(value, partRef, manifest) {
   const errors = [];
-  const data = value;
+  const data = isPlainRecord(value) ? value : {};
+  if (!isPlainRecord(value)) errors.push("chunk part must be an object");
   if (data?.schema_version !== "aiwg.fortemi.index.chunk.v1") {
     errors.push("schema_version must be aiwg.fortemi.index.chunk.v1");
   }
@@ -419,12 +1178,16 @@ function validateAiwgFortemiChunkPart(value, partRef, manifest) {
   }
   if (Array.isArray(data?.items)) {
     if (manifest?.projection) {
-      errors.push(...validateProjectedRecords(data.items).map((error) => "items." + error));
+      errors.push(...validateProjectedRecords(
+        data.items,
+        manifest.source_export_schema_version ?? "aiwg.fortemi.index.export.v1"
+      ).map((error) => "items." + error));
     } else {
       const validation = validateAiwgFortemiIndexExport({
-        schema_version: "aiwg.fortemi.index.export.v1",
+        schema_version: manifest?.source_export_schema_version ?? "aiwg.fortemi.index.export.v1",
         generated_at: manifest?.generated_at ?? "1970-01-01T00:00:00.000Z",
         source: manifest?.source ?? { repo: "chunk", privacy: "public" },
+        ...(manifest?.source_export_schema_version ?? "aiwg.fortemi.index.export.v1") === "aiwg.fortemi.index.export.v2" ? { compatibility: { previous_schema_version: "aiwg.fortemi.index.export.v1", strategy: "supported" } } : {},
         items: data.items
       });
       errors.push(...validation.errors.map((error) => "items." + error));
@@ -511,15 +1274,17 @@ function recordTitle(item) {
 }
 function recordText(item) {
   const base = item.text ?? item.search?.body ?? item.search?.summary ?? item.chunks?.map((chunk) => chunk.text ?? chunk.body ?? chunk.summary ?? "").filter(Boolean).join("\n") ?? "";
-  const extractedText = "binary_sources" in item ? item.binary_sources?.map((source) => source.extracted_text).filter(Boolean).join("\n") ?? "" : "";
+  const extractedText = binarySourceText(item);
   return [base, extractedText].filter(Boolean).join("\n");
 }
+function binarySourceText(item) {
+  return "binary_sources" in item ? item.binary_sources?.map((source) => source.extracted_text).filter(Boolean).join("\n") ?? "" : "";
+}
 function defaultEmbeddingInput(record, granularity) {
   const title = recordTitle(record);
   const text = recordText(record);
   if (granularity === "title-summary") {
-    const extractedText = record.binary_sources?.map((source) => source.extracted_text).filter(Boolean).join("\n") ?? "";
-    return [title, record.search?.summary ?? "", extractedText].filter(Boolean).join("\n");
+    return [title, record.search?.summary ?? "", binarySourceText(record)].filter(Boolean).join("\n");
   }
   return [title, text].filter(Boolean).join("\n");
 }
@@ -587,6 +1352,7 @@ function recordSearchValues(item) {
   return values.filter((value) => typeof value === "string" && value.length > 0);
 }
 function buildAiwgChunkedIndex(index, options = {}) {
+  assertAiwgFortemiIndexExport(index);
   const partSize = hasPositiveInteger(options.partSize) ? options.partSize : 500;
   const projection = options.projection;
   const idEncoding = options.idEncoding ?? "base64url";
@@ -666,35 +1432,88 @@ function queryMatches(item, q) {
   return matches;
 }
 var DISCOVERY_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
   "a",
   "an",
   "and",
-  "are",
-  "as",
+  "or",
+  "of",
   "for",
-  "from",
-  "how",
-  "i",
+  "to",
   "in",
+  "on",
+  "with",
+  "into",
+  "from",
   "is",
+  "are",
+  "be",
+  "i",
+  "we",
+  "my",
+  "it",
+  "you",
   "me",
-  "of",
-  "on",
-  "or",
+  "us",
+  "your",
+  "our",
+  "this",
+  "that",
+  "these",
+  "those",
+  "there",
+  "here",
+  "some",
+  "any",
+  "all",
+  "also",
   "please",
-  "the",
-  "to",
-  "use",
-  "with"
+  "about",
+  "how",
+  "what",
+  "which",
+  "where",
+  "when",
+  "who",
+  "why",
+  "find",
+  "give",
+  "show",
+  "need",
+  "want",
+  "looking",
+  "look",
+  "help",
+  "do",
+  "does",
+  "did",
+  "can",
+  "could",
+  "should",
+  "would",
+  "will",
+  "handle",
+  "handles",
+  "handling",
+  "aiwg",
+  "skill",
+  "skills",
+  "agent",
+  "agents",
+  "command",
+  "commands",
+  "rule",
+  "rules",
+  "flow",
+  "flows",
+  "workflow",
+  "workflows"
 ]);
-function normalizeDiscoveryText(value) {
-  return value.toLowerCase().replace(/[_/]+/g, " ").replace(/[^a-z0-9.-]+/g, " ").trim();
-}
-function canonicalDiscoveryName(value) {
-  return normalizeDiscoveryText(value).replace(/[\s.-]+/g, "");
+function normalizeDiscoveryName(value) {
+  return value.toLowerCase().replace(/[-_\s]+/g, " ").trim();
 }
 function discoveryTokens(value) {
-  return normalizeDiscoveryText(value).split(/\s+/).filter((token) => token.length > 1 && !DISCOVERY_STOPWORDS.has(token));
+  return value.toLowerCase().split(/[^a-z0-9-]+/).filter((token) => token.length > 1 && !DISCOVERY_STOPWORDS.has(token));
 }
 function facetValues(item, names) {
   return names.flatMap((name) => item.facets[name] ?? []);
@@ -704,17 +1523,58 @@ function addDiscoveryMatch(matches, match) {
     matches.push(match);
   }
 }
-function tokenOverlapScore(tokens, value) {
-  if (tokens.length === 0 || !value) return 0;
-  const normalized = normalizeDiscoveryText(value);
-  const hits = tokens.filter((token) => normalized.includes(token)).length;
-  return hits / tokens.length;
+function damerauLevenshteinAtMostOne(left, right) {
+  if (left === right) return true;
+  if (Math.abs(left.length - right.length) > 1) return false;
+  if (left.length === right.length) {
+    let firstDiff = -1;
+    let diffCount = 0;
+    for (let index = 0; index < left.length; index += 1) {
+      if (left[index] !== right[index]) {
+        if (firstDiff < 0) firstDiff = index;
+        diffCount += 1;
+      }
+    }
+    if (diffCount === 1) return true;
+    return diffCount === 2 && firstDiff + 1 < left.length && left[firstDiff] === right[firstDiff + 1] && left[firstDiff + 1] === right[firstDiff];
+  }
+  const shorter = left.length < right.length ? left : right;
+  const longer = left.length < right.length ? right : left;
+  let shorterIndex = 0;
+  let longerIndex = 0;
+  let edits = 0;
+  while (shorterIndex < shorter.length && longerIndex < longer.length) {
+    if (shorter[shorterIndex] === longer[longerIndex]) {
+      shorterIndex += 1;
+      longerIndex += 1;
+    } else {
+      edits += 1;
+      if (edits > 1) return false;
+      longerIndex += 1;
+    }
+  }
+  return true;
 }
-function discoveryMatches(item, query) {
+function nearDiscoveryNameMatch(query, name) {
+  const queryParts = normalizeDiscoveryName(query).split(/\s+/).filter(Boolean);
+  const nameParts = normalizeDiscoveryName(name).split(/\s+/).filter(Boolean);
+  if (queryParts.length !== nameParts.length) return false;
+  return queryParts.every((part, index) => {
+    const target = nameParts[index];
+    if (part === target) return true;
+    if (part.length < 5 || target.length < 5) return false;
+    return damerauLevenshteinAtMostOne(part, target);
+  });
+}
+function lowerValues(values) {
+  return values.map((value) => value.toLowerCase());
+}
+function discoveryMatches(item, query, options = {}) {
   if (!query) return [];
   const matches = [];
   const tokens = discoveryTokens(query);
-  const canonicalQuery = canonicalDiscoveryName(query);
+  const lower = tokens.length > 0 ? tokens.join(" ") : query.toLowerCase().trim();
+  const rawLower = query.toLowerCase().trim();
   const idParts = item.id.split(/[:/]/);
   const names = [
     item.id,
@@ -740,33 +1600,66 @@ function discoveryMatches(item, query) {
     ...item.tags
   ].filter((value) => hasString(value));
   const sourceValues = [item.source?.path, item.source?.repo_relative_path, item.source?.locator].filter((value) => hasString(value));
+  const title = recordTitle(item);
+  const summary = [item.search?.summary, recordText(item)].filter((value) => hasString(value)).join("\n");
+  const type = item.search?.type ?? item.type;
+  const tags = [...item.search?.tags ?? [], ...item.tags];
+  const useMultiToken = tokens.length > 1;
+  const minHits = useMultiToken ? options.relaxOverlap ? 1 : Math.ceil(tokens.length / 2) : 1;
+  const overlapOK = (hits) => useMultiToken && hits >= minHits;
+  const addInfo = (match) => addDiscoveryMatch(matches, { ...match, score: 0 });
+  const addScore = (score2) => {
+    if (score2 > 0) addDiscoveryMatch(matches, { field: "id", value: item.id, score: score2, reason: "aiwg discovery score" });
+  };
   for (const name of names) {
-    const canonicalName = canonicalDiscoveryName(name);
-    if (!canonicalName) continue;
-    if (canonicalName === canonicalQuery) {
-      addDiscoveryMatch(matches, { field: "id", value: name, score: 80, reason: "exact canonical name" });
-    } else if (canonicalName.includes(canonicalQuery) || canonicalQuery.includes(canonicalName)) {
-      addDiscoveryMatch(matches, { field: "id", value: name, score: 48, reason: "near canonical name" });
+    if (normalizeDiscoveryName(query) === normalizeDiscoveryName(name)) {
+      addInfo({ field: "id", value: name, reason: "exact canonical name" });
+      addScore(1.001);
+      return matches;
+    }
+    if (nearDiscoveryNameMatch(query, name)) {
+      addInfo({ field: "id", value: name, reason: "near canonical name" });
+      addScore(0.951);
+      return matches;
     }
   }
-  const title = recordTitle(item);
-  const titleOverlap = tokenOverlapScore(tokens, title);
-  if (titleOverlap > 0) addDiscoveryMatch(matches, { field: "title", value: title, score: 18 * titleOverlap, reason: "title token overlap" });
-  for (const trigger of triggers) {
-    const overlap = tokenOverlapScore(tokens, trigger);
-    if (overlap > 0) addDiscoveryMatch(matches, { field: "facet", value: trigger, score: 34 * overlap, reason: "trigger phrase" });
+  let score = 0;
+  const scoreText = (field, value, reason, exactScore, overlapScore, weight, exactBonus = 0) => {
+    const normalized = value.toLowerCase();
+    if (normalized.includes(lower)) {
+      score += exactScore * weight;
+      if (normalized === lower) score += exactBonus;
+      addInfo({ field, value, reason });
+    } else if (useMultiToken) {
+      const hits = tokens.filter((token) => normalized.includes(token)).length;
+      if (overlapOK(hits)) {
+        score += overlapScore * weight * (hits / tokens.length);
+        addInfo({ field, value, reason });
+      }
+    }
+  };
+  for (const trigger of lowerValues(triggers)) {
+    if (trigger === lower || trigger === rawLower) {
+      addInfo({ field: "facet", value: trigger, reason: "trigger phrase" });
+      addScore(1.0008);
+      return matches;
+    }
   }
-  for (const capability of capabilities) {
-    const overlap = tokenOverlapScore(tokens, capability);
-    if (overlap > 0) addDiscoveryMatch(matches, { field: "concept", value: capability, score: 22 * overlap, reason: "capability overlap" });
+  for (const trigger of triggers) {
+    scoreText("facet", trigger, "trigger phrase", 0.25, 0.06, 4);
   }
-  const text = recordText(item);
-  const textOverlap = tokenOverlapScore(tokens, text);
-  if (textOverlap > 0) addDiscoveryMatch(matches, { field: "text", value: text, score: 8 * textOverlap, reason: "body token overlap" });
+  for (const capability of capabilities) scoreText("concept", capability, "capability overlap", 0.2, 0.1, 2);
+  scoreText("title", title, "title token overlap", 0.3, 0.08, 3, 0.2);
+  for (const tag of tags) scoreText("tag", tag, "tag token overlap", 0.2, 0.05, 2);
+  if (summary) scoreText("text", summary, "body token overlap", 0.15, 0.04, 1);
   for (const source of sourceValues) {
-    const overlap = tokenOverlapScore(tokens, source);
-    if (overlap > 0) addDiscoveryMatch(matches, { field: "source", value: source, score: 2 * overlap, reason: "path overlap" });
+    scoreText("source", source, "path overlap", 0.1, 0.03, 1);
   }
+  if (type.toLowerCase().includes(lower)) {
+    score += 0.1;
+    addInfo({ field: "facet", value: type, reason: "type overlap" });
+  }
+  addScore(Math.min(score, 1));
   return matches;
 }
 function rankMatches(matches, weights) {
@@ -792,13 +1685,13 @@ function createSnippet(item, matches, q, maxLength) {
   const firstMatch = textMatch ?? titleMatch ?? matches[0];
   return clipSnippet(firstMatch?.value ?? recordText(item), q, maxLength);
 }
-function createRankedEntries(items, q, options, ordinalBase = 0) {
+function createRankedEntries(items, q, options, ordinalBase = 0, discoveryOptions = {}) {
   const weights = { ...DEFAULT_QUERY_WEIGHTS, ...options.weights };
   const profile = options.searchProfile ?? "default";
   return items.map((item, ordinal) => ({
     item,
     ordinal: ordinalBase + ordinal,
-    matches: profile === "aiwg-discovery" ? discoveryMatches(item, q) : queryMatches(item, q)
+    matches: profile === "aiwg-discovery" ? discoveryMatches(item, q, discoveryOptions) : queryMatches(item, q)
   })).filter(({ item, matches }) => {
     if (q && matches.length === 0) return false;
     if (options.types && !options.types.includes(item.type)) return false;
@@ -848,8 +1741,7 @@ function queryAiwgFortemiIndex(index, query = "", options = {}) {
   const q = query.trim().toLowerCase();
   const entries = createRankedEntries(index.items, q, options);
   if (entries.length === 0 && q && options.searchProfile === "aiwg-discovery") {
-    const relaxed = discoveryTokens(q).join(" ");
-    return createQueryResultFromRankedEntries(createRankedEntries(index.items, relaxed, options), relaxed, options);
+    return createQueryResultFromRankedEntries(createRankedEntries(index.items, q, options, 0, { relaxOverlap: true }), q, options);
   }
   return createQueryResultFromRankedEntries(entries, q, options);
 }
@@ -870,7 +1762,8 @@ function cosineSimilarity(left, right) {
 }
 function validateAiwgStaticEmbeddingSet(value) {
   const errors = [];
-  const data = value;
+  const data = isPlainRecord(value) ? value : {};
+  if (!isPlainRecord(value)) errors.push("embedding set must be an object");
   if (data?.schema_version !== "aiwg.fortemi.embedding.set.v1") errors.push("schema_version must be aiwg.fortemi.embedding.set.v1");
   if (!hasString(data?.id)) errors.push("id is required");
   if (!hasString(data?.model)) errors.push("model is required");
@@ -878,7 +1771,12 @@ function validateAiwgStaticEmbeddingSet(value) {
   if (!hasString(data?.generated_at)) errors.push("generated_at is required");
   if (!hasString(data?.granularity)) errors.push("granularity is required");
   if (!Array.isArray(data?.embeddings)) errors.push("embeddings must be an array");
-  for (const [index, embedding] of (data.embeddings ?? []).entries()) {
+  const embeddings = Array.isArray(data.embeddings) ? data.embeddings : [];
+  for (const [index, embedding] of embeddings.entries()) {
+    if (!isPlainRecord(embedding)) {
+      errors.push("embeddings[" + index + "] must be an object");
+      continue;
+    }
     if (!hasString(embedding.record_id)) errors.push("embeddings[" + index + "].record_id is required");
     if (!hasString(embedding.input_hash)) errors.push("embeddings[" + index + "].input_hash is required");
     if (!Array.isArray(embedding.embedding)) errors.push("embeddings[" + index + "].embedding must be an array");
@@ -908,7 +1806,10 @@ function queryAiwgSemanticIndex(index, embeddingSet, queryEmbedding, options = {
   }).filter((result) => result !== null && result.score >= (options.minScore ?? -1)).sort((left, right) => right.score - left.score || left.item.id.localeCompare(right.item.id)).slice(offset, offset + limit);
 }
 function queryAiwgHybridIndex(index, embeddingSet, query, queryEmbedding, options = {}) {
-  const lexical = queryAiwgFortemiIndex(index, query, { ...options, rank: true });
+  const lexicalOptions = { ...options };
+  delete lexicalOptions.limit;
+  delete lexicalOptions.offset;
+  const lexical = queryAiwgFortemiIndex(index, query, { ...lexicalOptions, rank: true });
   const semantic = queryAiwgSemanticIndex(index, embeddingSet, queryEmbedding, { limit: index.items.length });
   const lexicalWeight = options.lexicalWeight ?? 0.5;
   const semanticWeight = options.semanticWeight ?? 0.5;
@@ -978,6 +1879,7 @@ function matchSetCacheKey(q, options) {
     concepts: options.concepts ?? null,
     privacy: options.privacy ?? null,
     rel: options.relationshipTargetId ?? null,
+    searchProfile: options.searchProfile ?? "default",
     weights: { ...DEFAULT_QUERY_WEIGHTS, ...options.weights }
   });
 }
@@ -1066,15 +1968,21 @@ function edgeFromRelationship(sourceId, relationship) {
 }
 function relationshipMatches(edge, options = {}) {
   const type = relationshipTypeFilter(options);
-  const direction = options.direction ?? "both";
   if (type && edge.type !== type) return false;
   if (options.relationshipDirection && edge.direction !== options.relationshipDirection) return false;
   if (options.sourceId && edge.source_id !== options.sourceId) return false;
   if (options.targetId && edge.target_id !== options.targetId) return false;
-  if (direction === "out" && options.targetId && edge.target_id !== options.targetId) return false;
-  if (direction === "in" && options.sourceId && edge.source_id !== options.sourceId) return false;
+  if (options.endpointId && edge.source_id !== options.endpointId && edge.target_id !== options.endpointId) return false;
   return true;
 }
+function assertRelationshipDirectionAnchor(options) {
+  if (options.direction === "out" && !options.sourceId) {
+    throw new Error("relationship direction 'out' requires sourceId");
+  }
+  if (options.direction === "in" && !options.targetId) {
+    throw new Error("relationship direction 'in' requires targetId");
+  }
+}
 function nodeSummary(item) {
   return { id: item.id, type: item.type, title: recordTitle(item) };
 }
@@ -1082,6 +1990,7 @@ function addNode(nodes, item) {
   if (item) nodes.set(item.id, nodeSummary(item));
 }
 function relationshipResultFromRecords(records, options = {}) {
+  assertRelationshipDirectionAnchor(options);
   const byId = new Map(records.map((record) => [record.id, record]));
   const edges = [];
   for (const record of records) {
@@ -1091,7 +2000,8 @@ function relationshipResultFromRecords(records, options = {}) {
       edges.push(edge);
     }
   }
-  const limitedEdges = (options.limit ? edges.slice(0, options.limit) : edges).sort((left, right) => left.source_id.localeCompare(right.source_id) || left.target_id.localeCompare(right.target_id) || left.type.localeCompare(right.type));
+  const sortedEdges = edges.sort((left, right) => left.source_id.localeCompare(right.source_id) || left.target_id.localeCompare(right.target_id) || left.type.localeCompare(right.type));
+  const limitedEdges = options.limit ? sortedEdges.slice(0, options.limit) : sortedEdges;
   const nodes = /* @__PURE__ */ new Map();
   for (const edge of limitedEdges) {
     addNode(nodes, byId.get(edge.source_id));
@@ -1108,7 +2018,8 @@ function neighborQueryOptions(id, options = {}) {
   return {
     ...options,
     ...direction === "out" ? { sourceId: id } : {},
-    ...direction === "in" ? { targetId: id } : {}
+    ...direction === "in" ? { targetId: id } : {},
+    ...direction === "both" ? { endpointId: id } : {}
   };
 }
 function filterNeighborResult(id, result, options = {}) {
@@ -1417,13 +2328,14 @@ function createAiwgIndexController(initialIndex) {
 }
 function aiwgFortemiIndexToCommunityGraph(index, options = {}) {
   const ids = new Set(index.items.map((item) => item.id));
-  const relationshipWeights = options.relationshipWeights ?? {};
+  const relationshipWeights = options.relationshipWeights ?? /* @__PURE__ */ Object.create(null);
   const edgeCounts = /* @__PURE__ */ new Map();
   for (const item of index.items) {
     for (const relationship of item.relationships) {
       if (!ids.has(relationship.target_id) && !options.includeDanglingRelationships) continue;
       const kind = relationship.type;
-      const baseWeight = relationshipWeights[kind] ?? 1;
+      const configuredWeight = Object.prototype.hasOwnProperty.call(relationshipWeights, kind) ? relationshipWeights[kind] : void 0;
+      const baseWeight = typeof configuredWeight === "number" && Number.isFinite(configuredWeight) ? configuredWeight : 1;
       const key = `${item.id}\0${relationship.target_id}\0${kind}`;
       const existing = edgeCounts.get(key);
       if (existing) existing.weight += baseWeight;