@semiont/graph 0.5.26 → 0.5.28

package/dist/index.js

@@ -57,9 +57,107 @@ function queryResources(all, filter) {
 
 // src/implementations/neptune.ts
 import { getEntityTypes } from "@semiont/ontology";
+
+// src/annotation-codec.ts
 import { annotationId as makeAnnotationId } from "@semiont/core";
+import { getBodySource, getExactText, getTargetSelector, getTargetSource } from "@semiont/core";
+function storedAnnotationType(motivation) {
+  return motivation === "highlighting" ? "TextualBody" : "SpecificResource";
+}
+function motivationForCategory(category) {
+  return category === "highlight" ? "highlighting" : "linking";
+}
+function buildAnnotation(input, created) {
+  const annotation = {
+    "@context": "http://www.w3.org/ns/anno.jsonld",
+    type: "Annotation",
+    id: makeAnnotationId(input.id),
+    motivation: input.motivation,
+    target: input.target,
+    creator: input.creator,
+    created
+  };
+  if (input.body && (!Array.isArray(input.body) || input.body.length > 0)) {
+    annotation.body = input.body;
+  }
+  return annotation;
+}
+function encodeAnnotation(annotation) {
+  const selector = getTargetSelector(annotation.target);
+  const bodySource = getBodySource(annotation.body);
+  const resourceId = getTargetSource(annotation.target);
+  if (!resourceId) throw new Error(`Annotation ${annotation.id} has no target source`);
+  if (!annotation.created) throw new Error(`Annotation ${annotation.id} has no created timestamp`);
+  const props = {
+    id: annotation.id,
+    resourceId,
+    type: storedAnnotationType(annotation.motivation),
+    motivation: annotation.motivation,
+    creator: JSON.stringify(annotation.creator),
+    created: annotation.created
+  };
+  if (selector) Object.assign(props, encodeSelector(selector));
+  if (bodySource) props.source = bodySource;
+  if (annotation.modified) props.modified = annotation.modified;
+  if (annotation.generator) props.generator = JSON.stringify(annotation.generator);
+  return props;
+}
+function encodeSelector(selector) {
+  const props = { selector: JSON.stringify(selector) };
+  const exact = getExactText(selector);
+  if (exact) props.exact = exact;
+  return props;
+}
+function decodeAnnotation(props, entityTypes = []) {
+  const id = props.id;
+  if (!id) throw new Error("Annotation missing required field: id");
+  const required = (key) => {
+    const value = props[key];
+    if (!value) throw new Error(`Annotation ${id} missing required field: ${key}`);
+    return value;
+  };
+  const resourceId = required("resourceId");
+  const creator = JSON.parse(required("creator"));
+  const motivation = required("motivation");
+  const created = required("created");
+  const body = [];
+  for (const entityType of entityTypes) {
+    if (entityType) body.push({ type: "TextualBody", value: entityType, purpose: "tagging" });
+  }
+  if (props.source) {
+    body.push({ type: "SpecificResource", source: props.source, purpose: "linking" });
+  }
+  const selector = decodeSelector(props.selector);
+  const target = selector ? { source: resourceId, selector } : { source: resourceId };
+  const annotation = {
+    "@context": "http://www.w3.org/ns/anno.jsonld",
+    type: "Annotation",
+    id: makeAnnotationId(id),
+    motivation,
+    target,
+    creator,
+    created
+  };
+  if (body.length > 0) annotation.body = body;
+  if (props.modified) annotation.modified = props.modified;
+  if (props.generator) {
+    try {
+      annotation.generator = JSON.parse(props.generator);
+    } catch {
+    }
+  }
+  return annotation;
+}
+function decodeSelector(raw) {
+  if (!raw) return void 0;
+  const parsed = JSON.parse(raw);
+  if (!parsed || Object.keys(parsed).length === 0) return void 0;
+  return parsed;
+}
+
+// src/implementations/neptune.ts
 import { v4 as uuidv4 } from "uuid";
-import { getBodySource, getExactText, getTargetSource, getTargetSelector, getPrimaryRepresentation, getResourceId } from "@semiont/core";
+import { getBodySource as getBodySource2, getTargetSource as getTargetSource2, getPrimaryRepresentation, getResourceId } from "@semiont/core";
 var NeptuneClient;
 var DescribeDBClustersCommand;
 var gremlin;
@@ -69,7 +167,7 @@ var cardinality;
 var __;
 async function loadDependencies() {
   if (!NeptuneClient) {
-    const neptuneModule = await import("./dist-es-BGEPUOPB.js");
+    const neptuneModule = await import("./dist-es-AET2QNVA.js");
     NeptuneClient = neptuneModule.NeptuneClient;
     DescribeDBClustersCommand = neptuneModule.DescribeDBClustersCommand;
   }
@@ -125,70 +223,22 @@ function vertexToResource(vertex) {
   return resource;
 }
 function vertexToAnnotation(vertex, entityTypes = []) {
-  const props = vertex.properties || vertex;
-  const getValue = (key, required = false) => {
-    const prop = props[key];
-    if (!prop) {
-      if (required) {
-        throw new Error(`Annotation ${vertex.id || "unknown"} missing required field: ${key}`);
-      }
-      return void 0;
-    }
-    if (Array.isArray(prop) && prop.length > 0) {
-      return prop[0].value !== void 0 ? prop[0].value : prop[0];
-    }
-    if (typeof prop === "object" && "value" in prop) return prop.value;
-    return prop;
-  };
-  const id = getValue("id", true);
-  const resourceId = getValue("resourceId", true);
-  const selectorRaw = getValue("selector", true);
-  const creatorRaw = getValue("creator", true);
-  const createdRaw = getValue("created", true);
-  const motivation = getValue("motivation") || "linking";
-  const creator = JSON.parse(creatorRaw);
-  const bodyArray = [];
-  for (const entityType of entityTypes) {
-    if (entityType) {
-      bodyArray.push({
-        type: "TextualBody",
-        value: entityType,
-        purpose: "tagging"
-      });
-    }
-  }
-  const bodySource = getValue("source");
-  if (bodySource) {
-    bodyArray.push({
-      type: "SpecificResource",
-      source: bodySource,
-      purpose: "linking"
-    });
-  }
-  const annotation = {
-    "@context": "http://www.w3.org/ns/anno.jsonld",
-    "type": "Annotation",
-    id,
-    motivation,
-    target: {
-      source: resourceId,
-      selector: JSON.parse(selectorRaw)
-    },
-    body: bodyArray,
-    creator,
-    created: createdRaw
-    // ISO string from DB
-  };
-  const modified = getValue("modified");
-  if (modified) annotation.modified = modified;
-  const generatorJson = getValue("generator");
-  if (generatorJson) {
-    try {
-      annotation.generator = JSON.parse(generatorJson);
-    } catch (e) {
-    }
-  }
-  return annotation;
+  return decodeAnnotation(normalizeProperties(vertex.properties || vertex), entityTypes);
+}
+function normalizeProperties(props) {
+  const normalized = {};
+  for (const [key, raw] of Object.entries(props ?? {})) {
+    const value = unwrap(raw);
+    if (value === void 0 || value === null) continue;
+    normalized[key] = typeof value === "string" ? value : String(value);
+  }
+  return normalized;
+}
+function unwrap(prop) {
+  if (prop === void 0 || prop === null) return void 0;
+  if (Array.isArray(prop)) return prop.length > 0 ? unwrap(prop[0]) : void 0;
+  if (typeof prop === "object" && "value" in prop) return prop.value;
+  return prop;
 }
 var NeptuneGraphDatabase = class {
   connected = false;
@@ -385,25 +435,15 @@ var NeptuneGraphDatabase = class {
     }
   }
   async createAnnotation(input) {
-    const id = input.id;
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      id: makeAnnotationId(id),
-      motivation: input.motivation,
-      target: input.target,
-      body: input.body,
-      creator: input.creator,
-      created: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const targetSource = getTargetSource(input.target);
-    const targetSelector = getTargetSelector(input.target);
-    const bodySource = getBodySource(input.body);
+    const annotation = buildAnnotation(input, (/* @__PURE__ */ new Date()).toISOString());
+    const props = encodeAnnotation(annotation);
+    const targetSource = props.resourceId;
+    const bodySource = props.source;
     const entityTypes = getEntityTypes(input);
     try {
-      const vertex = this.g.addV("Annotation").property("id", annotation.id).property("resourceId", targetSource).property("text", targetSelector ? getExactText(targetSelector) : "").property("selector", JSON.stringify(targetSelector || {})).property("type", "SpecificResource").property("motivation", annotation.motivation).property("creator", JSON.stringify(annotation.creator)).property("created", annotation.created);
-      if (bodySource) {
-        vertex.property("source", bodySource);
+      let vertex = this.g.addV("Annotation");
+      for (const [key, value] of Object.entries(props)) {
+        vertex = vertex.property(key, value);
       }
       const newVertex = await vertex.next();
       await this.g.V(newVertex.value).addE("BELONGS_TO").to(this.g.V().hasLabel("Resource").has("id", targetSource)).next();
@@ -443,11 +483,13 @@ var NeptuneGraphDatabase = class {
       let traversal = this.g.V().hasLabel("Annotation").has("id", id);
       if (updates.target !== void 0 && typeof updates.target !== "string") {
         if (updates.target.selector !== void 0) {
-          traversal = traversal.property("text", getExactText(updates.target.selector));
+          for (const [key, value] of Object.entries(encodeSelector(updates.target.selector))) {
+            traversal = traversal.property(key, value);
+          }
         }
       }
       if (updates.body !== void 0) {
-        const bodySource = getBodySource(updates.body);
+        const bodySource = getBodySource2(updates.body);
         const entityTypes2 = getEntityTypes({ body: updates.body });
         if (bodySource) {
           traversal = traversal.property("source", bodySource);
@@ -497,8 +539,7 @@ var NeptuneGraphDatabase = class {
         traversal = traversal.has("resourceId", filter.resourceId);
       }
       if (filter.type) {
-        const w3cType = filter.type === "highlight" ? "TextualBody" : "SpecificResource";
-        traversal = traversal.has("type", w3cType);
+        traversal = traversal.has("type", storedAnnotationType(motivationForCategory(filter.type)));
       }
       const results = await traversal.elementMap().toList();
       const annotations = await this.fetchAnnotationsWithEntityTypes(results);
@@ -592,7 +633,7 @@ var NeptuneGraphDatabase = class {
         const entityTypesResult = await this.g.V().hasLabel("Annotation").has("id", id).out("TAGGED_AS").hasLabel("EntityType").values("name").toList();
         const entityTypes = entityTypesResult || [];
         const annotation = vertexToAnnotation(annVertex, entityTypes);
-        const targetDocId = getBodySource(annotation.body);
+        const targetDocId = getBodySource2(annotation.body);
         if (!targetDocId) continue;
         const targetDocResult = await this.g.V().hasLabel("Resource").has("id", targetDocId).elementMap().next();
         if (targetDocResult.value) {
@@ -616,7 +657,7 @@ var NeptuneGraphDatabase = class {
         const entityTypesResult = await this.g.V().hasLabel("Annotation").has("id", id).out("TAGGED_AS").hasLabel("EntityType").values("name").toList();
         const entityTypes = entityTypesResult || [];
         const annotation = vertexToAnnotation(annVertex, entityTypes);
-        const sourceDocId = getTargetSource(annotation.target);
+        const sourceDocId = getTargetSource2(annotation.target);
         const existing = connectionsMap.get(sourceDocId);
         if (existing) {
           existing.bidirectional = true;
@@ -820,9 +861,8 @@ var NeptuneGraphDatabase = class {
 };
 
 // src/implementations/neo4j.ts
-import { annotationId as makeAnnotationId2 } from "@semiont/core";
 import { v4 as uuidv42 } from "uuid";
-import { getExactText as getExactText2, getBodySource as getBodySource2, getTargetSource as getTargetSource2, getTargetSelector as getTargetSelector2, getPrimaryRepresentation as getPrimaryRepresentation2 } from "@semiont/core";
+import { getPrimaryRepresentation as getPrimaryRepresentation2 } from "@semiont/core";
 import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
 function motivationToLabel(motivation) {
   return motivation.charAt(0).toUpperCase() + motivation.slice(1);
@@ -1089,85 +1129,42 @@ var Neo4jGraphDatabase = class {
   async createAnnotation(input) {
     const session = this.getSession();
     try {
-      const id = input.id;
-      const annotation = {
-        "@context": "http://www.w3.org/ns/anno.jsonld",
-        "type": "Annotation",
-        id: makeAnnotationId2(id),
-        motivation: input.motivation,
-        target: input.target,
-        body: input.body,
-        creator: input.creator,
-        created: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      const targetSource = getTargetSource2(input.target);
-      const targetSelector = getTargetSelector2(input.target);
-      const bodySource = getBodySource2(input.body);
+      const annotation = buildAnnotation(input, (/* @__PURE__ */ new Date()).toISOString());
+      const props = encodeAnnotation(annotation);
+      const targetSource = props.resourceId;
+      const bodySource = props.source;
       const entityTypes = getEntityTypes2(input);
       const motivationLabel = motivationToLabel(annotation.motivation);
-      let cypher;
-      if (bodySource) {
-        cypher = `MATCH (from:Resource {id: $fromId})
-           MATCH (to:Resource {id: $toId})
-           CREATE (a:Annotation:${motivationLabel} {
-             id: $id,
-             resourceId: $resourceId,
-             exact: $exact,
-             selector: $selector,
-             type: $type,
-             motivation: $motivation,
-             creator: $creator,
-             created: datetime($created),
-             source: $source
-           })
+      const cypher = bodySource ? `MATCH (from:Resource {id: $targetSource})
+           MATCH (to:Resource {id: $bodySource})
+           CREATE (a:Annotation:${motivationLabel})
+           SET a = $props, a.created = datetime($created)
            CREATE (a)-[:BELONGS_TO]->(from)
            CREATE (a)-[:REFERENCES]->(to)
            FOREACH (entityType IN $entityTypes |
              MERGE (et:EntityType {name: entityType})
              CREATE (a)-[:TAGGED_AS]->(et)
            )
-           RETURN a`;
-      } else {
-        cypher = `MATCH (d:Resource {id: $resourceId})
-           CREATE (a:Annotation:${motivationLabel} {
-             id: $id,
-             resourceId: $resourceId,
-             exact: $exact,
-             selector: $selector,
-             type: $type,
-             motivation: $motivation,
-             creator: $creator,
-             created: datetime($created)
-           })
+           RETURN a` : `MATCH (d:Resource {id: $targetSource})
+           CREATE (a:Annotation:${motivationLabel})
+           SET a = $props, a.created = datetime($created)
            CREATE (a)-[:BELONGS_TO]->(d)
            FOREACH (entityType IN $entityTypes |
              MERGE (et:EntityType {name: entityType})
              CREATE (a)-[:TAGGED_AS]->(et)
            )
            RETURN a`;
-      }
-      const params = {
-        id,
-        resourceId: targetSource,
-        // Store full URI
-        fromId: targetSource,
-        // Store full URI
-        toId: bodySource || null,
-        // Store full URI
-        exact: targetSelector ? getExactText2(targetSelector) : "",
-        selector: JSON.stringify(targetSelector || {}),
-        type: "SpecificResource",
-        motivation: annotation.motivation,
-        creator: JSON.stringify(annotation.creator),
+      const result = await session.run(cypher, {
+        props,
         created: annotation.created,
-        entityTypes,
-        source: bodySource || null
-      };
-      const result = await session.run(cypher, params);
+        targetSource,
+        bodySource: bodySource ?? null,
+        entityTypes
+      });
       if (result.records.length === 0) {
         throw new Error(`Failed to create annotation: Resource ${targetSource} not found in graph database`);
       }
-      return this.parseAnnotationNode(result.records[0].get("a"), entityTypes);
+      return parseAnnotationNode(result.records[0].get("a"), entityTypes);
     } finally {
       await session.close();
     }
@@ -1187,7 +1184,7 @@ var Neo4jGraphDatabase = class {
         return null;
       }
       this.logger?.debug("Annotation found", { id });
-      return this.parseAnnotationNode(
+      return parseAnnotationNode(
         result.records[0].get("a"),
         result.records[0].get("entityTypes")
       );
@@ -1203,9 +1200,9 @@ var Neo4jGraphDatabase = class {
       Object.entries(updates).forEach(([key, value]) => {
         if (key !== "id" && key !== "updatedAt") {
           setClauses.push(`a.${key} = $${key}`);
-          if (key === "selector" || key === "metadata" || key === "body") {
+          if (key === "body") {
             params[key] = JSON.stringify(value);
-          } else if (key === "created" || key === "resolvedAt") {
+          } else if (key === "created") {
             params[key] = value ? new Date(value).toISOString() : null;
           } else {
             params[key] = value;
@@ -1283,7 +1280,7 @@ var Neo4jGraphDatabase = class {
       } else {
         this.logger?.debug("No body update for annotation", { id });
       }
-      return this.parseAnnotationNode(
+      return parseAnnotationNode(
         result.records[0].get("a"),
         result.records[0].get("entityTypes")
       );
@@ -1312,9 +1309,8 @@ var Neo4jGraphDatabase = class {
         params.resourceId = filter.resourceId;
       }
       if (filter.type) {
-        const w3cType = filter.type === "highlight" ? "TextualBody" : "SpecificResource";
         conditions.push("a.type = $type");
-        params.type = w3cType;
+        params.type = storedAnnotationType(motivationForCategory(filter.type));
       }
       const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
       const result = await session.run(
@@ -1324,7 +1320,7 @@ var Neo4jGraphDatabase = class {
         params
       );
       const annotations = result.records.map(
-        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+        (record) => parseAnnotationNode(record.get("a"), record.get("entityTypes"))
       );
       return { annotations, total: annotations.length };
     } finally {
@@ -1343,7 +1339,7 @@ var Neo4jGraphDatabase = class {
         { resourceId }
       );
       return result.records.map(
-        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+        (record) => parseAnnotationNode(record.get("a"), record.get("entityTypes"))
       );
     } finally {
       await session.close();
@@ -1371,7 +1367,7 @@ var Neo4jGraphDatabase = class {
       if (result.records.length === 0) {
         throw new Error("Annotation not found");
       }
-      return this.parseAnnotationNode(
+      return parseAnnotationNode(
         result.records[0].get("a"),
         result.records[0].get("entityTypes")
       );
@@ -1391,7 +1387,7 @@ var Neo4jGraphDatabase = class {
         { resourceId }
       );
       return result.records.map(
-        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+        (record) => parseAnnotationNode(record.get("a"), record.get("entityTypes"))
       );
     } finally {
       await session.close();
@@ -1415,7 +1411,7 @@ var Neo4jGraphDatabase = class {
         ORDER BY a.created DESC`;
       const result = await session.run(cypher, params);
       return result.records.map(
-        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+        (record) => parseAnnotationNode(record.get("a"), record.get("entityTypes"))
       );
     } finally {
       await session.close();
@@ -1432,7 +1428,7 @@ var Neo4jGraphDatabase = class {
         { resourceId }
       );
       return result.records.map(
-        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+        (record) => parseAnnotationNode(record.get("a"), record.get("entityTypes"))
       );
     } finally {
       await session.close();
@@ -1450,7 +1446,7 @@ var Neo4jGraphDatabase = class {
       const result = await session.run(cypher, { resourceId });
       this.logger?.debug("Found annotations", { count: result.records.length });
       return result.records.map(
-        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+        (record) => parseAnnotationNode(record.get("a"), record.get("entityTypes"))
       );
     } finally {
       await session.close();
@@ -1482,7 +1478,7 @@ var Neo4jGraphDatabase = class {
             { id: annId }
           );
           if (annResult.records.length > 0) {
-            outgoing.push(this.parseAnnotationNode(
+            outgoing.push(parseAnnotationNode(
               annResult.records[0].get("a"),
               annResult.records[0].get("entityTypes")
             ));
@@ -1499,7 +1495,7 @@ var Neo4jGraphDatabase = class {
             { id: annId }
           );
           if (annResult.records.length > 0) {
-            incoming.push(this.parseAnnotationNode(
+            incoming.push(parseAnnotationNode(
               annResult.records[0].get("a"),
               annResult.records[0].get("entityTypes")
             ));
@@ -1540,7 +1536,7 @@ var Neo4jGraphDatabase = class {
             { ids: annotationIds }
           );
           selResult.records.forEach((rec) => {
-            annotations.push(this.parseAnnotationNode(
+            annotations.push(parseAnnotationNode(
               rec.get("a"),
               rec.get("entityTypes")
             ));
@@ -1777,62 +1773,39 @@ var Neo4jGraphDatabase = class {
     if (props.storageUri) resource.storageUri = props.storageUri;
     return resource;
   }
-  parseAnnotationNode(node, entityTypes = []) {
-    const props = node.properties;
-    if (!props.id) throw new Error("Annotation missing required field: id");
-    if (!props.resourceId) throw new Error(`Annotation ${props.id} missing required field: resourceId`);
-    if (!props.type) throw new Error(`Annotation ${props.id} missing required field: type`);
-    if (!props.selector) throw new Error(`Annotation ${props.id} missing required field: selector`);
-    if (!props.creator) throw new Error(`Annotation ${props.id} missing required field: creator`);
-    if (!props.motivation) throw new Error(`Annotation ${props.id} missing required field: motivation`);
-    const creator = JSON.parse(props.creator);
-    const bodyArray = [];
-    for (const entityType of entityTypes) {
-      if (entityType) {
-        bodyArray.push({
-          type: "TextualBody",
-          value: entityType,
-          purpose: "tagging"
-        });
-      }
-    }
-    if (props.source) {
-      bodyArray.push({
-        type: "SpecificResource",
-        source: props.source,
-        purpose: "linking"
-      });
-    }
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      id: props.id,
-      motivation: props.motivation,
-      target: {
-        source: props.resourceId,
-        selector: JSON.parse(props.selector)
-      },
-      body: bodyArray,
-      creator,
-      created: props.created
-      // ISO string from DB
-    };
-    if (props.modified) annotation.modified = props.modified.toString();
-    if (props.generator) {
-      try {
-        annotation.generator = JSON.parse(props.generator);
-      } catch (e) {
-      }
-    }
-    return annotation;
-  }
 };
+function parseAnnotationNode(node, entityTypes = []) {
+  return decodeAnnotation(normalizeProperties2(node.properties), entityTypes);
+}
+function normalizeProperties2(props) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(props ?? {})) {
+    if (value === null || value === void 0) continue;
+    normalized[key] = typeof value === "string" ? value : String(value);
+  }
+  return normalized;
+}
 
 // src/implementations/janusgraph.ts
-import { resourceId as makeResourceId, annotationId as makeAnnotationId3 } from "@semiont/core";
-import { getBodySource as getBodySource3, getPrimaryRepresentation as getPrimaryRepresentation3, getResourceId as getResourceId2, getExactText as getExactText3 } from "@semiont/core";
+import { resourceId as makeResourceId } from "@semiont/core";
+import { getBodySource as getBodySource3, getPrimaryRepresentation as getPrimaryRepresentation3, getResourceId as getResourceId2 } from "@semiont/core";
 import { getEntityTypes as getEntityTypes3 } from "@semiont/ontology";
 import { v4 as uuidv43 } from "uuid";
+function getPropertyValue(props, key) {
+  if (!props[key]) return void 0;
+  const prop = Array.isArray(props[key]) ? props[key][0] : props[key];
+  return prop?.value || prop;
+}
+function vertexToAnnotation2(vertex, entityTypes = []) {
+  const props = vertex.properties || {};
+  const normalized = {};
+  for (const key of Object.keys(props)) {
+    const value = getPropertyValue(props, key);
+    if (value === void 0 || value === null) continue;
+    normalized[key] = typeof value === "string" ? value : String(value);
+  }
+  return decodeAnnotation(normalized, entityTypes);
+}
 var JanusGraphDatabase = class {
   constructor(graphConfig) {
     this.graphConfig = graphConfig;
@@ -1883,10 +1856,10 @@ var JanusGraphDatabase = class {
   // Helper function to convert vertex to Resource
   vertexToResource(vertex) {
     const props = vertex.properties || {};
-    const id = this.getPropertyValue(props, "id");
-    const creatorRaw = this.getPropertyValue(props, "creator");
-    const contentChecksum = this.getPropertyValue(props, "contentChecksum");
-    const mediaType = this.getPropertyValue(props, "contentType");
+    const id = getPropertyValue(props, "id");
+    const creatorRaw = getPropertyValue(props, "creator");
+    const contentChecksum = getPropertyValue(props, "contentChecksum");
+    const mediaType = getPropertyValue(props, "contentType");
     if (!creatorRaw) throw new Error(`Resource ${id} missing required field: creator`);
     if (!contentChecksum) throw new Error(`Resource ${id} missing required field: contentChecksum`);
     if (!mediaType) throw new Error(`Resource ${id} missing required field: contentType`);
@@ -1894,95 +1867,38 @@ var JanusGraphDatabase = class {
     const resource = {
       "@context": "https://schema.org/",
       "@id": id,
-      name: this.getPropertyValue(props, "name"),
-      entityTypes: JSON.parse(this.getPropertyValue(props, "entityTypes") || "[]"),
+      name: getPropertyValue(props, "name"),
+      entityTypes: JSON.parse(getPropertyValue(props, "entityTypes") || "[]"),
       representations: [{
         mediaType,
         checksum: contentChecksum,
         rel: "original"
       }],
-      archived: this.getPropertyValue(props, "archived") === "true",
-      dateCreated: this.getPropertyValue(props, "created"),
+      archived: getPropertyValue(props, "archived") === "true",
+      dateCreated: getPropertyValue(props, "created"),
       wasAttributedTo: creator
     };
-    const sourceAnnotationId = this.getPropertyValue(props, "sourceAnnotationId");
-    const sourceResourceId = this.getPropertyValue(props, "sourceResourceId");
-    const storageUri = this.getPropertyValue(props, "storageUri");
+    const sourceAnnotationId = getPropertyValue(props, "sourceAnnotationId");
+    const sourceResourceId = getPropertyValue(props, "sourceResourceId");
+    const storageUri = getPropertyValue(props, "storageUri");
     if (sourceAnnotationId) resource.sourceAnnotationId = sourceAnnotationId;
     if (sourceResourceId) resource.sourceResourceId = sourceResourceId;
     if (storageUri) resource.storageUri = storageUri;
     return resource;
   }
-  // Helper to get property value from Gremlin vertex properties
-  getPropertyValue(props, key) {
-    if (!props[key]) return void 0;
-    const prop = Array.isArray(props[key]) ? props[key][0] : props[key];
-    return prop?.value || prop;
-  }
   // Helper method to fetch annotations with their entity types
   async fetchAnnotationsWithEntityTypes(annotationVertices) {
     const annotations = [];
     for (const vertex of annotationVertices) {
-      const id = this.getPropertyValue(vertex.properties || {}, "id");
+      const id = getPropertyValue(vertex.properties || {}, "id");
       const entityTypeVertices = await this.g.V().has("Annotation", "id", id).out("TAGGED_AS").has("EntityType").toList();
       const entityTypes = entityTypeVertices.map(
-        (v) => this.getPropertyValue(v.properties || {}, "name")
+        (v) => getPropertyValue(v.properties || {}, "name")
       ).filter(Boolean);
-      annotations.push(this.vertexToAnnotation(vertex, entityTypes));
+      annotations.push(vertexToAnnotation2(vertex, entityTypes));
     }
     return annotations;
   }
-  // Helper function to convert vertex to Annotation
-  vertexToAnnotation(vertex, entityTypes = []) {
-    const props = vertex.properties || {};
-    const motivation = this.getPropertyValue(props, "motivation") || "linking";
-    const creatorJson = this.getPropertyValue(props, "creator");
-    const creator = JSON.parse(creatorJson);
-    const bodyArray = [];
-    for (const entityType of entityTypes) {
-      if (entityType) {
-        bodyArray.push({
-          type: "TextualBody",
-          value: entityType,
-          purpose: "tagging"
-        });
-      }
-    }
-    const bodySource = this.getPropertyValue(props, "source");
-    if (bodySource) {
-      bodyArray.push({
-        type: "SpecificResource",
-        source: bodySource,
-        purpose: "linking"
-      });
-    }
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      id: this.getPropertyValue(props, "id"),
-      motivation,
-      target: {
-        source: this.getPropertyValue(props, "resourceId"),
-        selector: JSON.parse(this.getPropertyValue(props, "selector") || "{}")
-      },
-      body: bodyArray,
-      creator,
-      created: this.getPropertyValue(props, "created")
-      // ISO string from DB
-    };
-    const modified = this.getPropertyValue(props, "modified");
-    if (modified) {
-      annotation.modified = modified;
-    }
-    const generatorJson = this.getPropertyValue(props, "generator");
-    if (generatorJson) {
-      try {
-        annotation.generator = JSON.parse(generatorJson);
-      } catch (e) {
-      }
-    }
-    return annotation;
-  }
   async createResource(resource) {
     const id = getResourceId2(resource);
     const primaryRep = getPrimaryRepresentation3(resource);
@@ -2035,26 +1951,14 @@ var JanusGraphDatabase = class {
     return queryResources(docs.map((v) => this.vertexToResource(v)), filter);
   }
   async createAnnotation(input) {
-    const id = input.id;
-    const motivation = input.motivation;
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      id: makeAnnotationId3(id),
-      motivation,
-      target: input.target,
-      body: input.body,
-      creator: input.creator,
-      created: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    const bodySource = getBodySource3(input.body);
+    const annotation = buildAnnotation(input, (/* @__PURE__ */ new Date()).toISOString());
+    const props = encodeAnnotation(annotation);
+    const targetSource = props.resourceId;
+    const bodySource = props.source;
     const entityTypes = getEntityTypes3(input);
-    const bodyType = input.body === void 0 ? "None" : Array.isArray(input.body) ? "SpecificResource" : input.body.type;
-    const targetSource = typeof input.target === "string" ? input.target : input.target.source;
-    const targetSelector = typeof input.target === "string" ? void 0 : input.target.selector;
-    const vertex = this.g.addV("Annotation").property("id", id).property("resourceId", targetSource).property("text", targetSelector ? getExactText3(targetSelector) : "").property("selector", JSON.stringify(targetSelector || {})).property("type", bodyType).property("motivation", motivation).property("creator", JSON.stringify(input.creator)).property("created", annotation.created);
-    if (bodySource) {
-      vertex.property("source", bodySource);
+    let vertex = this.g.addV("Annotation");
+    for (const [key, value] of Object.entries(props)) {
+      vertex = vertex.property(key, value);
     }
     const annVertex = await vertex.next();
     await this.g.V(annVertex.value).addE("BELONGS_TO").to(this.g.V().has("Resource", "id", targetSource)).next();
@@ -2071,7 +1975,7 @@ var JanusGraphDatabase = class {
       }
       await this.g.V(annVertex.value).addE("TAGGED_AS").to(this.g.V(etVertex.value)).next();
     }
-    this.logger?.info("Created annotation in JanusGraph", { id });
+    this.logger?.info("Created annotation in JanusGraph", { id: annotation.id });
     return annotation;
   }
   async getAnnotation(id) {
@@ -2081,16 +1985,17 @@ var JanusGraphDatabase = class {
     }
     const entityTypeVertices = await this.g.V().has("Annotation", "id", id).out("TAGGED_AS").has("EntityType").toList();
     const entityTypes = entityTypeVertices.map(
-      (v) => this.getPropertyValue(v.properties || {}, "name")
+      (v) => getPropertyValue(v.properties || {}, "name")
     ).filter(Boolean);
-    return this.vertexToAnnotation(vertices[0], entityTypes);
+    return vertexToAnnotation2(vertices[0], entityTypes);
   }
   async updateAnnotation(id, updates) {
     const traversalQuery = this.g.V().has("Annotation", "id", id);
     if (updates.target !== void 0 && typeof updates.target !== "string") {
       if (updates.target.selector !== void 0) {
-        await traversalQuery.property("text", getExactText3(updates.target.selector)).next();
-        await traversalQuery.property("selector", JSON.stringify(updates.target.selector)).next();
+        for (const [key, value] of Object.entries(encodeSelector(updates.target.selector))) {
+          await traversalQuery.property(key, value).next();
+        }
       }
     }
     if (updates.body !== void 0) {
@@ -2138,8 +2043,7 @@ var JanusGraphDatabase = class {
       traversalQuery = traversalQuery.has("resourceId", filter.resourceId);
     }
     if (filter.type) {
-      const w3cType = filter.type === "highlight" ? "TextualBody" : "SpecificResource";
-      traversalQuery = traversalQuery.has("type", w3cType);
+      traversalQuery = traversalQuery.has("type", storedAnnotationType(motivationForCategory(filter.type)));
     }
     const vertices = await traversalQuery.toList();
     const annotations = await this.fetchAnnotationsWithEntityTypes(vertices);
@@ -2338,8 +2242,8 @@ var JanusGraphDatabase = class {
     let entityTypesFromDb = [];
     for (const vertex of collections) {
       const props = vertex.properties || {};
-      const type = this.getPropertyValue(props, "type");
-      const tagsJson = this.getPropertyValue(props, "tags");
+      const type = getPropertyValue(props, "type");
+      const tagsJson = getPropertyValue(props, "tags");
       const tags = tagsJson ? JSON.parse(tagsJson) : [];
       if (type === "entity-types") {
         entityTypesFromDb = tags;
@@ -2362,9 +2266,10 @@ var JanusGraphDatabase = class {
 };
 
 // src/implementations/memorygraph.ts
-import { resourceId as makeResourceId2, annotationId as makeAnnotationId4 } from "@semiont/core";
+import { resourceId as makeResourceId2 } from "@semiont/core";
 import { v4 as uuidv44 } from "uuid";
 import { getBodySource as getBodySource4, getTargetSource as getTargetSource3, getResourceId as getResourceId3, getPrimaryRepresentation as getPrimaryRepresentation4, getResourceEntityTypes as getResourceEntityTypes2 } from "@semiont/core";
+import { getEntityTypes as getEntityTypes4 } from "@semiont/ontology";
 var MemoryGraphDatabase = class {
   connected = false;
   logger;
@@ -2417,16 +2322,10 @@ var MemoryGraphDatabase = class {
   }
   async createAnnotation(input) {
     const id = input.id;
-    const annotation = {
-      "@context": "http://www.w3.org/ns/anno.jsonld",
-      "type": "Annotation",
-      id: makeAnnotationId4(id),
-      motivation: input.motivation,
-      target: input.target,
-      body: input.body,
-      creator: input.creator,
-      created: (/* @__PURE__ */ new Date()).toISOString()
-    };
+    const annotation = decodeAnnotation(
+      encodeAnnotation(buildAnnotation(input, (/* @__PURE__ */ new Date()).toISOString())),
+      getEntityTypes4(input)
+    );
     this.annotations.set(id, annotation);
     this.logger?.debug("Created annotation", {
       id,
@@ -2492,16 +2391,9 @@ var MemoryGraphDatabase = class {
   }
   async getEntityReferences(resourceId, entityTypes) {
     const resourceIdStr = String(resourceId);
-    let refs = Array.from(this.annotations.values()).filter((sel) => {
-      if (getTargetSource3(sel.target) !== resourceIdStr) return false;
-      const bodyEntityTypes = sel.body?.entityTypes;
-      return Array.isArray(bodyEntityTypes) && bodyEntityTypes.length > 0;
-    });
+    let refs = Array.from(this.annotations.values()).filter((sel) => getTargetSource3(sel.target) === resourceIdStr && getEntityTypes4(sel).length > 0);
     if (entityTypes && entityTypes.length > 0) {
-      refs = refs.filter((sel) => {
-        const bodyEntityTypes = sel.body?.entityTypes || [];
-        return bodyEntityTypes.some((type) => entityTypes.includes(type));
-      });
+      refs = refs.filter((sel) => getEntityTypes4(sel).some((type) => entityTypes.includes(type)));
     }
     return refs;
   }
@@ -2591,10 +2483,9 @@ var MemoryGraphDatabase = class {
     const annotations = Array.from(this.annotations.values());
     const highlightCount = annotations.filter((a) => a.motivation === "highlighting").length;
     const referenceCount = annotations.filter((a) => a.motivation === "linking").length;
-    const entityReferenceCount = annotations.filter((a) => {
-      const bodyEntityTypes = a.body?.entityTypes;
-      return a.motivation === "linking" && Array.isArray(bodyEntityTypes) && bodyEntityTypes.length > 0;
-    }).length;
+    const entityReferenceCount = annotations.filter(
+      (a) => a.motivation === "linking" && getEntityTypes4(a).length > 0
+    ).length;
     return {
       resourceCount: this.resources.size,
       annotationCount: this.annotations.size,