@semiont/graph 0.2.28-build.40

package/dist/index.js

@@ -0,0 +1,2708 @@
+// src/implementations/neptune.ts
+import { getBodySource } from "@semiont/api-client";
+import { getEntityTypes } from "@semiont/ontology";
+import { getExactText } from "@semiont/api-client";
+import { v4 as uuidv4 } from "uuid";
+import { getTargetSource, getTargetSelector } from "@semiont/api-client";
+import { getPrimaryRepresentation, getResourceId } from "@semiont/api-client";
+var NeptuneClient;
+var DescribeDBClustersCommand;
+var gremlin;
+var process2;
+var TextP;
+var order;
+var cardinality;
+var __;
+async function loadDependencies() {
+  if (!NeptuneClient) {
+    const neptuneModule = await import("@aws-sdk/client-neptune");
+    NeptuneClient = neptuneModule.NeptuneClient;
+    DescribeDBClustersCommand = neptuneModule.DescribeDBClustersCommand;
+  }
+  if (!gremlin) {
+    gremlin = await import("gremlin");
+    process2 = gremlin.process;
+    TextP = process2.TextP;
+    order = process2.order;
+    cardinality = process2.cardinality;
+    __ = process2.statics;
+  }
+}
+function vertexToResource(vertex) {
+  const props = vertex.properties || vertex;
+  const getValue = (key, required = false) => {
+    const prop = props[key];
+    if (!prop) {
+      if (required) {
+        throw new Error(`Resource ${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];
+    }
+    return prop.value !== void 0 ? prop.value : prop;
+  };
+  const id = getValue("id", true);
+  const name = getValue("name", true);
+  const entityTypesRaw = getValue("entityTypes", true);
+  const mediaType = getValue("mediaType", true);
+  const archived = getValue("archived", true);
+  const dateCreated = getValue("dateCreated", true);
+  const checksum = getValue("checksum", true);
+  const creatorRaw = getValue("creator", true);
+  const resource = {
+    "@context": "https://schema.org/",
+    "@id": id,
+    name,
+    entityTypes: JSON.parse(entityTypesRaw),
+    representations: [{
+      mediaType,
+      checksum,
+      rel: "original"
+    }],
+    archived: archived === "true" || archived === true,
+    dateCreated,
+    wasAttributedTo: typeof creatorRaw === "string" ? JSON.parse(creatorRaw) : creatorRaw,
+    creationMethod: getValue("creationMethod", true)
+  };
+  const sourceResourceId = getValue("sourceResourceId");
+  if (sourceResourceId) resource.sourceResourceId = sourceResourceId;
+  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;
+}
+var NeptuneGraphDatabase = class {
+  connected = false;
+  neptuneEndpoint;
+  neptunePort = 8182;
+  region;
+  g;
+  // Gremlin graph traversal source
+  connection;
+  // Gremlin connection
+  // Helper method to fetch annotations with their entity types
+  async fetchAnnotationsWithEntityTypes(annotationVertices) {
+    const annotations = [];
+    for (const vertex of annotationVertices) {
+      const id = vertex.properties?.id?.[0]?.value || vertex.id;
+      const entityTypesResult = await this.g.V().hasLabel("Annotation").has("id", id).out("TAGGED_AS").hasLabel("EntityType").values("name").toList();
+      const entityTypes = entityTypesResult || [];
+      annotations.push(vertexToAnnotation(vertex, entityTypes));
+    }
+    return annotations;
+  }
+  constructor(config = {}) {
+    if (config.endpoint) this.neptuneEndpoint = config.endpoint;
+    this.neptunePort = config.port || 8182;
+    if (config.region) this.region = config.region;
+  }
+  async discoverNeptuneEndpoint() {
+    if (this.neptuneEndpoint) {
+      return;
+    }
+    if (!this.region) {
+      throw new Error("AWS region must be configured in environment JSON file (aws.region) for Neptune endpoint discovery");
+    }
+    try {
+      await loadDependencies();
+      const client = new NeptuneClient({ region: this.region });
+      const command = new DescribeDBClustersCommand({});
+      const response = await client.send(command);
+      if (!response.DBClusters || response.DBClusters.length === 0) {
+        throw new Error("No Neptune clusters found in region " + this.region);
+      }
+      let cluster = null;
+      for (const dbCluster of response.DBClusters) {
+        const tagsCommand = new DescribeDBClustersCommand({
+          DBClusterIdentifier: dbCluster.DBClusterIdentifier
+        });
+        const clusterDetails = await client.send(tagsCommand);
+        if (clusterDetails.DBClusters && clusterDetails.DBClusters[0]) {
+          const clusterInfo = clusterDetails.DBClusters[0];
+          if (clusterInfo.DBClusterIdentifier?.includes("Semiont") || clusterInfo.DBClusterIdentifier?.includes("semiont")) {
+            cluster = clusterInfo;
+            break;
+          }
+        }
+      }
+      if (!cluster) {
+        throw new Error("No Semiont Neptune cluster found in region " + this.region);
+      }
+      this.neptuneEndpoint = cluster.Endpoint;
+      this.neptunePort = cluster.Port || 8182;
+      console.log(`Discovered Neptune endpoint: ${this.neptuneEndpoint}:${this.neptunePort}`);
+    } catch (error) {
+      console.error("Failed to discover Neptune endpoint:", error);
+      throw error;
+    }
+  }
+  async connect() {
+    await this.discoverNeptuneEndpoint();
+    try {
+      await loadDependencies();
+      const traversal2 = gremlin.process.AnonymousTraversalSource.traversal;
+      const DriverRemoteConnection2 = gremlin.driver.DriverRemoteConnection;
+      const connectionUrl = `wss://${this.neptuneEndpoint}:${this.neptunePort}/gremlin`;
+      console.log(`Connecting to Neptune at ${connectionUrl}`);
+      this.connection = new DriverRemoteConnection2(connectionUrl, {
+        authenticator: null,
+        // Neptune uses IAM authentication via task role
+        rejectUnauthorized: true,
+        traversalSource: "g"
+      });
+      this.g = traversal2().withRemote(this.connection);
+      const count = await this.g.V().limit(1).count().next();
+      console.log(`Connected to Neptune. Vertex count test: ${count.value}`);
+      this.connected = true;
+    } catch (error) {
+      console.error("Failed to connect to Neptune:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.connection) {
+      try {
+        await this.connection.close();
+      } catch (error) {
+        console.error("Error closing Neptune connection:", error);
+      }
+    }
+    this.connected = false;
+    console.log("Disconnected from Neptune");
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async createResource(resource) {
+    const id = getResourceId(resource);
+    const primaryRep = getPrimaryRepresentation(resource);
+    if (!primaryRep) {
+      throw new Error("Resource must have at least one representation");
+    }
+    try {
+      const vertex = this.g.addV("Resource").property("id", id).property("name", resource.name).property("mediaType", primaryRep.mediaType).property("archived", resource.archived || false).property("dateCreated", resource.dateCreated).property("creator", JSON.stringify(resource.wasAttributedTo)).property("creationMethod", resource.creationMethod).property("checksum", primaryRep.checksum).property("entityTypes", JSON.stringify(resource.entityTypes));
+      if (resource.sourceResourceId) {
+        vertex.property("sourceResourceId", resource.sourceResourceId);
+      }
+      await vertex.next();
+      console.log(`Created resource vertex in Neptune: ${id}`);
+      return resource;
+    } catch (error) {
+      console.error("Failed to create resource in Neptune:", error);
+      throw error;
+    }
+  }
+  async getResource(id) {
+    try {
+      const result = await this.g.V().hasLabel("Resource").has("id", id).elementMap().next();
+      if (!result.value) {
+        return null;
+      }
+      return vertexToResource(result.value);
+    } catch (error) {
+      console.error("Failed to get resource from Neptune:", error);
+      throw error;
+    }
+  }
+  async updateResource(id, input) {
+    if (Object.keys(input).length !== 1 || input.archived === void 0) {
+      throw new Error("Resources are immutable. Only archiving is allowed.");
+    }
+    try {
+      const result = await this.g.V().hasLabel("Resource").has("id", id).property("archived", input.archived).elementMap().next();
+      if (!result.value) {
+        throw new Error("Resource not found");
+      }
+      return vertexToResource(result.value);
+    } catch (error) {
+      console.error("Failed to update resource in Neptune:", error);
+      throw error;
+    }
+  }
+  async deleteResource(id) {
+    try {
+      await this.g.V().hasLabel("Resource").has("id", id).drop().iterate();
+      console.log(`Deleted resource from Neptune: ${id}`);
+    } catch (error) {
+      console.error("Failed to delete resource from Neptune:", error);
+      throw error;
+    }
+  }
+  async listResources(filter) {
+    try {
+      let traversal2 = this.g.V().hasLabel("Resource");
+      if (filter.entityTypes && filter.entityTypes.length > 0) {
+        traversal2 = traversal2.filter(
+          process2.statics.or(
+            ...filter.entityTypes.map(
+              (type) => process2.statics.has("entityTypes", TextP.containing(`"${type}"`))
+            )
+          )
+        );
+      }
+      if (filter.search) {
+        traversal2 = traversal2.has("name", TextP.containing(filter.search));
+      }
+      const totalResult = await traversal2.clone().count().next();
+      const total = totalResult.value || 0;
+      const offset = filter.offset || 0;
+      const limit = filter.limit || 20;
+      const results = await traversal2.order().by("created", order.desc).range(offset, offset + limit).elementMap().toList();
+      const resources = results.map(vertexToResource);
+      return { resources, total };
+    } catch (error) {
+      console.error("Failed to list resources from Neptune:", error);
+      throw error;
+    }
+  }
+  async searchResources(query, limit = 20) {
+    try {
+      const results = await this.g.V().hasLabel("Resource").has("name", TextP.containing(query)).order().by("created", order.desc).limit(limit).elementMap().toList();
+      return results.map(vertexToResource);
+    } catch (error) {
+      console.error("Failed to search resources in Neptune:", error);
+      throw error;
+    }
+  }
+  async createAnnotation(input) {
+    const id = this.generateId();
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      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 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);
+      }
+      const newVertex = await vertex.next();
+      await this.g.V(newVertex.value).addE("BELONGS_TO").to(this.g.V().hasLabel("Resource").has("id", targetSource)).next();
+      if (bodySource) {
+        await this.g.V(newVertex.value).addE("REFERENCES").to(this.g.V().hasLabel("Resource").has("id", bodySource)).next();
+      }
+      for (const entityType of entityTypes) {
+        const etVertex = await this.g.V().hasLabel("EntityType").has("name", entityType).fold().coalesce(
+          __.unfold(),
+          this.g.addV("EntityType").property("name", entityType)
+        ).next();
+        await this.g.V(newVertex.value).addE("TAGGED_AS").to(this.g.V(etVertex.value)).next();
+      }
+      console.log(`Created annotation vertex in Neptune: ${annotation.id}`);
+      return annotation;
+    } catch (error) {
+      console.error("Failed to create annotation in Neptune:", error);
+      throw error;
+    }
+  }
+  async getAnnotation(id) {
+    try {
+      const result = await this.g.V().hasLabel("Annotation").has("id", id).elementMap().next();
+      if (!result.value) {
+        return null;
+      }
+      const entityTypesResult = await this.g.V().hasLabel("Annotation").has("id", id).out("TAGGED_AS").hasLabel("EntityType").values("name").toList();
+      const entityTypes = entityTypesResult || [];
+      return vertexToAnnotation(result.value, entityTypes);
+    } catch (error) {
+      console.error("Failed to get annotation from Neptune:", error);
+      throw error;
+    }
+  }
+  async updateAnnotation(id, updates) {
+    try {
+      let traversal2 = this.g.V().hasLabel("Annotation").has("id", id);
+      if (updates.target !== void 0 && typeof updates.target !== "string") {
+        if (updates.target.selector !== void 0) {
+          traversal2 = traversal2.property("text", getExactText(updates.target.selector));
+        }
+      }
+      if (updates.body !== void 0) {
+        const bodySource = getBodySource(updates.body);
+        const entityTypes2 = getEntityTypes({ body: updates.body });
+        if (bodySource) {
+          traversal2 = traversal2.property("source", bodySource);
+        }
+        if (entityTypes2.length >= 0) {
+          await this.g.V().hasLabel("Annotation").has("id", id).outE("TAGGED_AS").drop().iterate();
+          for (const entityType of entityTypes2) {
+            const etVertex = await this.g.V().hasLabel("EntityType").has("name", entityType).fold().coalesce(
+              __.unfold(),
+              this.g.addV("EntityType").property("name", entityType)
+            ).next();
+            await this.g.V().hasLabel("Annotation").has("id", id).addE("TAGGED_AS").to(this.g.V(etVertex.value)).next();
+          }
+        }
+      }
+      if (updates.modified !== void 0) {
+        traversal2 = traversal2.property("modified", updates.modified);
+      }
+      if (updates.generator !== void 0) {
+        traversal2 = traversal2.property("generator", JSON.stringify(updates.generator));
+      }
+      const result = await traversal2.elementMap().next();
+      if (!result.value) {
+        throw new Error("Annotation not found");
+      }
+      const entityTypesResult = await this.g.V().hasLabel("Annotation").has("id", id).out("TAGGED_AS").hasLabel("EntityType").values("name").toList();
+      const entityTypes = entityTypesResult || [];
+      return vertexToAnnotation(result.value, entityTypes);
+    } catch (error) {
+      console.error("Failed to update annotation in Neptune:", error);
+      throw error;
+    }
+  }
+  async deleteAnnotation(id) {
+    try {
+      await this.g.V().hasLabel("Annotation").has("id", id).drop().iterate();
+      console.log(`Deleted annotation from Neptune: ${id}`);
+    } catch (error) {
+      console.error("Failed to delete annotation from Neptune:", error);
+      throw error;
+    }
+  }
+  async listAnnotations(filter) {
+    try {
+      let traversal2 = this.g.V().hasLabel("Annotation");
+      if (filter.resourceId) {
+        traversal2 = traversal2.has("resourceId", filter.resourceId);
+      }
+      if (filter.type) {
+        const w3cType = filter.type === "highlight" ? "TextualBody" : "SpecificResource";
+        traversal2 = traversal2.has("type", w3cType);
+      }
+      const results = await traversal2.elementMap().toList();
+      const annotations = await this.fetchAnnotationsWithEntityTypes(results);
+      return { annotations, total: annotations.length };
+    } catch (error) {
+      console.error("Failed to list annotations from Neptune:", error);
+      throw error;
+    }
+  }
+  async getHighlights(resourceId) {
+    try {
+      const results = await this.g.V().hasLabel("Annotation").has("resourceId", resourceId).hasNot("resolvedResourceId").elementMap().toList();
+      return await this.fetchAnnotationsWithEntityTypes(results);
+    } catch (error) {
+      console.error("Failed to get highlights from Neptune:", error);
+      throw error;
+    }
+  }
+  async resolveReference(annotationId, source) {
+    try {
+      const targetDocResult = await this.g.V().hasLabel("Resource").has("id", source).elementMap().next();
+      const targetDoc = targetDocResult.value ? vertexToResource(targetDocResult.value) : null;
+      const traversal2 = this.g.V().hasLabel("Annotation").has("id", annotationId).property("source", source).property("resolvedResourceName", targetDoc?.name).property("resolvedAt", (/* @__PURE__ */ new Date()).toISOString());
+      const result = await traversal2.elementMap().next();
+      if (!result.value) {
+        throw new Error("Annotation not found");
+      }
+      const annVertex = await this.g.V().hasLabel("Annotation").has("id", annotationId).next();
+      await this.g.V(annVertex.value).addE("REFERENCES").to(this.g.V().hasLabel("Resource").has("id", source)).next();
+      const entityTypesResult = await this.g.V().hasLabel("Annotation").has("id", annotationId).out("TAGGED_AS").hasLabel("EntityType").values("name").toList();
+      const entityTypes = entityTypesResult || [];
+      return vertexToAnnotation(result.value, entityTypes);
+    } catch (error) {
+      console.error("Failed to resolve reference in Neptune:", error);
+      throw error;
+    }
+  }
+  async getReferences(resourceId) {
+    try {
+      const results = await this.g.V().hasLabel("Annotation").has("resourceId", resourceId).has("resolvedResourceId").elementMap().toList();
+      return await this.fetchAnnotationsWithEntityTypes(results);
+    } catch (error) {
+      console.error("Failed to get references from Neptune:", error);
+      throw error;
+    }
+  }
+  async getEntityReferences(resourceId, entityTypes) {
+    try {
+      let traversal2 = this.g.V().hasLabel("Annotation").has("resourceId", resourceId).has("resolvedResourceId").has("entityTypes");
+      if (entityTypes && entityTypes.length > 0) {
+        traversal2 = traversal2.filter(
+          process2.statics.or(
+            ...entityTypes.map(
+              (type) => process2.statics.has("entityTypes", TextP.containing(`"${type}"`))
+            )
+          )
+        );
+      }
+      const results = await traversal2.elementMap().toList();
+      return await this.fetchAnnotationsWithEntityTypes(results);
+    } catch (error) {
+      console.error("Failed to get entity references from Neptune:", error);
+      throw error;
+    }
+  }
+  async getResourceAnnotations(resourceId) {
+    try {
+      const results = await this.g.V().hasLabel("Annotation").has("resourceId", resourceId).elementMap().toList();
+      return await this.fetchAnnotationsWithEntityTypes(results);
+    } catch (error) {
+      console.error("Failed to get resource annotations from Neptune:", error);
+      throw error;
+    }
+  }
+  async getResourceReferencedBy(resourceUri3, _motivation) {
+    try {
+      const results = await this.g.V().hasLabel("Annotation").has("resolvedResourceId", resourceUri3).elementMap().toList();
+      return await this.fetchAnnotationsWithEntityTypes(results);
+    } catch (error) {
+      console.error("Failed to get resource referenced by from Neptune:", error);
+      throw error;
+    }
+  }
+  async getResourceConnections(resourceId) {
+    try {
+      const outgoingAnnotations = await this.g.V().hasLabel("Annotation").has("resourceId", resourceId).has("source").elementMap().toList();
+      const incomingAnnotations = await this.g.V().hasLabel("Annotation").has("source", resourceId).elementMap().toList();
+      const connectionsMap = /* @__PURE__ */ new Map();
+      for (const annVertex of outgoingAnnotations) {
+        const id = annVertex.properties?.id?.[0]?.value || annVertex.id;
+        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);
+        if (!targetDocId) continue;
+        const targetDocResult = await this.g.V().hasLabel("Resource").has("id", targetDocId).elementMap().next();
+        if (targetDocResult.value) {
+          const targetDoc = vertexToResource(targetDocResult.value);
+          const targetDocId2 = getResourceId(targetDoc);
+          if (!targetDocId2) continue;
+          const existing = connectionsMap.get(targetDocId2);
+          if (existing) {
+            existing.annotations.push(annotation);
+          } else {
+            connectionsMap.set(targetDocId2, {
+              targetResource: targetDoc,
+              annotations: [annotation],
+              bidirectional: false
+            });
+          }
+        }
+      }
+      for (const annVertex of incomingAnnotations) {
+        const id = annVertex.properties?.id?.[0]?.value || annVertex.id;
+        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 existing = connectionsMap.get(sourceDocId);
+        if (existing) {
+          existing.bidirectional = true;
+        }
+      }
+      return Array.from(connectionsMap.values());
+    } catch (error) {
+      console.error("Failed to get resource connections from Neptune:", error);
+      throw error;
+    }
+  }
+  async findPath(fromResourceId, toResourceId, maxDepth = 5) {
+    try {
+      const results = await this.g.V().hasLabel("Resource").has("id", fromResourceId).repeat(
+        process2.statics.both("REFERENCES").simplePath()
+      ).times(maxDepth).emit().has("id", toResourceId).path().by(process2.statics.elementMap()).limit(10).toList();
+      const paths = [];
+      for (const pathResult of results) {
+        const resources = [];
+        for (let i = 0; i < pathResult.objects.length; i++) {
+          const element = pathResult.objects[i];
+          if (i % 2 === 0) {
+            resources.push(vertexToResource(element));
+          } else {
+          }
+        }
+        paths.push({ resources, annotations: [] });
+      }
+      return paths;
+    } catch (error) {
+      console.error("Failed to find paths in Neptune:", error);
+      throw error;
+    }
+  }
+  async getEntityTypeStats() {
+    try {
+      const results = await this.g.V().hasLabel("Resource").values("entityTypes").map((entityTypesJson) => {
+        const types = JSON.parse(entityTypesJson);
+        return types;
+      }).unfold().groupCount().next();
+      const stats = [];
+      if (results.value) {
+        for (const [type, count] of Object.entries(results.value)) {
+          stats.push({
+            type,
+            count
+          });
+        }
+      }
+      return stats;
+    } catch (error) {
+      console.error("Failed to get entity type stats from Neptune:", error);
+      throw error;
+    }
+  }
+  async getStats() {
+    try {
+      const docCountResult = await this.g.V().hasLabel("Resource").count().next();
+      const resourceCount = docCountResult.value || 0;
+      const selCountResult = await this.g.V().hasLabel("Annotation").count().next();
+      const annotationCount = selCountResult.value || 0;
+      const highlightCountResult = await this.g.V().hasLabel("Annotation").hasNot("resolvedResourceId").count().next();
+      const highlightCount = highlightCountResult.value || 0;
+      const referenceCountResult = await this.g.V().hasLabel("Annotation").has("resolvedResourceId").count().next();
+      const referenceCount = referenceCountResult.value || 0;
+      const entityRefCountResult = await this.g.V().hasLabel("Annotation").has("resolvedResourceId").has("entityTypes").count().next();
+      const entityReferenceCount = entityRefCountResult.value || 0;
+      const entityTypeStats = await this.getEntityTypeStats();
+      const entityTypes = {};
+      for (const stat of entityTypeStats) {
+        entityTypes[stat.type] = stat.count;
+      }
+      const contentTypeResult = await this.g.V().hasLabel("Resource").groupCount().by("contentType").next();
+      const contentTypes = contentTypeResult.value || {};
+      return {
+        resourceCount,
+        annotationCount,
+        highlightCount,
+        referenceCount,
+        entityReferenceCount,
+        entityTypes,
+        contentTypes
+      };
+    } catch (error) {
+      console.error("Failed to get stats from Neptune:", error);
+      throw error;
+    }
+  }
+  async createAnnotations(inputs) {
+    const results = [];
+    try {
+      for (const input of inputs) {
+        const annotation = await this.createAnnotation(input);
+        results.push(annotation);
+      }
+      return results;
+    } catch (error) {
+      console.error("Failed to create annotations in Neptune:", error);
+      throw error;
+    }
+  }
+  async resolveReferences(inputs) {
+    const results = [];
+    try {
+      for (const input of inputs) {
+        const annotation = await this.resolveReference(input.annotationId, input.source);
+        results.push(annotation);
+      }
+      return results;
+    } catch (error) {
+      console.error("Failed to resolve references in Neptune:", error);
+      throw error;
+    }
+  }
+  async detectAnnotations(_resourceId) {
+    return [];
+  }
+  // Tag Collections - stored as special vertices in the graph
+  entityTypesCollection = null;
+  async getEntityTypes() {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    return Array.from(this.entityTypesCollection).sort();
+  }
+  async addEntityType(tag) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    this.entityTypesCollection.add(tag);
+    try {
+      await this.g.V().has("tagCollection", "type", "entity-types").fold().coalesce(
+        __.unfold(),
+        __.addV("TagCollection").property("type", "entity-types")
+      ).property(cardinality.set, "tags", tag).iterate();
+    } catch (error) {
+      console.error("Failed to add entity type:", error);
+    }
+  }
+  async addEntityTypes(tags) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    tags.forEach((tag) => this.entityTypesCollection.add(tag));
+    try {
+      const vertex = await this.g.V().has("tagCollection", "type", "entity-types").fold().coalesce(
+        __.unfold(),
+        __.addV("TagCollection").property("type", "entity-types")
+      );
+      for (const tag of tags) {
+        await vertex.property(cardinality.set, "tags", tag).iterate();
+      }
+    } catch (error) {
+      console.error("Failed to add entity types:", error);
+    }
+  }
+  async initializeTagCollections() {
+    try {
+      const collections = await this.g.V().hasLabel("TagCollection").project("type", "tags").by("type").by(__.values("tags").fold()).toList();
+      for (const col of collections) {
+        if (col.type === "entity-types") {
+          this.entityTypesCollection = new Set(col.tags);
+        }
+      }
+    } catch (error) {
+      console.log("No existing tag collections found, will initialize with defaults");
+    }
+    if (this.entityTypesCollection === null) {
+      const { DEFAULT_ENTITY_TYPES } = await import("@semiont/ontology");
+      this.entityTypesCollection = new Set(DEFAULT_ENTITY_TYPES);
+      try {
+        const vertex = await this.g.addV("TagCollection").property("type", "entity-types").next();
+        for (const tag of DEFAULT_ENTITY_TYPES) {
+          await this.g.V(vertex.value.id).property(cardinality.set, "tags", tag).iterate();
+        }
+      } catch (error) {
+        console.error("Failed to initialize entity types:", error);
+      }
+    }
+  }
+  generateId() {
+    return uuidv4().replace(/-/g, "").substring(0, 12);
+  }
+  async clearDatabase() {
+    try {
+      await this.g.V().drop().iterate();
+      console.log("Cleared all data from Neptune");
+      this.entityTypesCollection = null;
+    } catch (error) {
+      console.error("Failed to clear Neptune database:", error);
+      throw error;
+    }
+  }
+};
+
+// src/implementations/neo4j.ts
+import neo4j from "neo4j-driver";
+import { getExactText as getExactText2 } from "@semiont/api-client";
+import { v4 as uuidv42 } from "uuid";
+import { getBodySource as getBodySource2, getTargetSource as getTargetSource2, getTargetSelector as getTargetSelector2 } from "@semiont/api-client";
+import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
+import { getPrimaryRepresentation as getPrimaryRepresentation2 } from "@semiont/api-client";
+function motivationToLabel(motivation) {
+  return motivation.charAt(0).toUpperCase() + motivation.slice(1);
+}
+var Neo4jGraphDatabase = class {
+  driver = null;
+  connected = false;
+  config;
+  // Tag Collections - cached in memory for performance
+  entityTypesCollection = null;
+  constructor(config = {}) {
+    this.config = config;
+  }
+  async connect() {
+    try {
+      const uri = this.config.uri;
+      const username = this.config.username;
+      const password = this.config.password;
+      const database = this.config.database;
+      if (!uri) {
+        throw new Error("Neo4j URI not configured! Pass uri in config.");
+      }
+      if (!username) {
+        throw new Error("Neo4j username not configured! Pass username in config.");
+      }
+      if (!password) {
+        throw new Error("Neo4j password not configured! Pass password in config.");
+      }
+      if (!database) {
+        throw new Error("Neo4j database not configured! Pass database in config.");
+      }
+      console.log(`Connecting to Neo4j at ${uri}...`);
+      this.driver = neo4j.driver(
+        uri,
+        neo4j.auth.basic(username, password),
+        {
+          maxConnectionPoolSize: 50,
+          connectionAcquisitionTimeout: 6e4
+        }
+      );
+      const session = this.driver.session({ database });
+      await session.run("RETURN 1 as test");
+      await session.close();
+      await this.ensureSchemaExists();
+      console.log("Successfully connected to Neo4j");
+      this.connected = true;
+    } catch (error) {
+      console.error("Failed to connect to Neo4j:", error);
+      throw new Error(`Neo4j connection failed: ${error}`);
+    }
+  }
+  async disconnect() {
+    if (this.driver) {
+      await this.driver.close();
+      this.driver = null;
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  getSession() {
+    if (!this.driver) {
+      throw new Error("Neo4j driver not initialized");
+    }
+    if (!this.config.database) {
+      throw new Error("Neo4j database not configured! Pass database in config.");
+    }
+    return this.driver.session({
+      database: this.config.database
+    });
+  }
+  async ensureSchemaExists() {
+    const session = this.getSession();
+    try {
+      const constraints = [
+        "CREATE CONSTRAINT doc_id IF NOT EXISTS FOR (d:Resource) REQUIRE d.id IS UNIQUE",
+        "CREATE CONSTRAINT sel_id IF NOT EXISTS FOR (s:Annotation) REQUIRE s.id IS UNIQUE",
+        "CREATE CONSTRAINT tag_id IF NOT EXISTS FOR (t:TagCollection) REQUIRE t.type IS UNIQUE"
+      ];
+      for (const constraint of constraints) {
+        try {
+          await session.run(constraint);
+        } catch (error) {
+          if (!error.message?.includes("already exists")) {
+            console.warn(`Schema creation warning: ${error.message}`);
+          }
+        }
+      }
+      const indexes = [
+        "CREATE INDEX doc_name IF NOT EXISTS FOR (d:Resource) ON (d.name)",
+        "CREATE INDEX doc_entity_types IF NOT EXISTS FOR (d:Resource) ON (d.entityTypes)",
+        "CREATE INDEX sel_doc_id IF NOT EXISTS FOR (s:Annotation) ON (s.resourceId)",
+        "CREATE INDEX sel_resolved_id IF NOT EXISTS FOR (s:Annotation) ON (s.resolvedResourceId)"
+      ];
+      for (const index of indexes) {
+        try {
+          await session.run(index);
+        } catch (error) {
+          if (!error.message?.includes("already exists")) {
+            console.warn(`Index creation warning: ${error.message}`);
+          }
+        }
+      }
+    } finally {
+      await session.close();
+    }
+  }
+  async createResource(resource) {
+    const session = this.getSession();
+    try {
+      const id = resource["@id"];
+      const primaryRep = getPrimaryRepresentation2(resource);
+      if (!primaryRep) {
+        throw new Error("Resource must have at least one representation");
+      }
+      const result = await session.run(
+        `CREATE (d:Resource {
+          id: $id,
+          name: $name,
+          entityTypes: $entityTypes,
+          format: $format,
+          archived: $archived,
+          created: datetime($created),
+          creator: $creator,
+          creationMethod: $creationMethod,
+          contentChecksum: $contentChecksum,
+          sourceAnnotationId: $sourceAnnotationId,
+          sourceResourceId: $sourceResourceId
+        }) RETURN d`,
+        {
+          id,
+          name: resource.name,
+          entityTypes: resource.entityTypes,
+          format: primaryRep.mediaType,
+          archived: resource.archived || false,
+          created: resource.dateCreated,
+          creator: JSON.stringify(resource.wasAttributedTo),
+          creationMethod: resource.creationMethod,
+          contentChecksum: primaryRep.checksum,
+          sourceAnnotationId: resource.sourceAnnotationId ?? null,
+          sourceResourceId: resource.sourceResourceId ?? null
+        }
+      );
+      return this.parseResourceNode(result.records[0].get("d"));
+    } finally {
+      await session.close();
+    }
+  }
+  async getResource(id) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        "MATCH (d:Resource {id: $id}) RETURN d",
+        { id }
+      );
+      if (result.records.length === 0) return null;
+      return this.parseResourceNode(result.records[0].get("d"));
+    } finally {
+      await session.close();
+    }
+  }
+  async updateResource(id, input) {
+    if (Object.keys(input).length !== 1 || input.archived === void 0) {
+      throw new Error("Resources are immutable. Only archiving is allowed.");
+    }
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (d:Resource {id: $id})
+         SET d.archived = $archived
+         RETURN d`,
+        { id, archived: input.archived }
+      );
+      if (result.records.length === 0) {
+        throw new Error("Resource not found");
+      }
+      return this.parseResourceNode(result.records[0].get("d"));
+    } finally {
+      await session.close();
+    }
+  }
+  async deleteResource(id) {
+    const session = this.getSession();
+    try {
+      await session.run(
+        `MATCH (d:Resource {id: $id})
+         OPTIONAL MATCH (a:Annotation)-[:BELONGS_TO|:REFERENCES]->(d)
+         DETACH DELETE d, a`,
+        { id }
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async listResources(filter) {
+    const session = this.getSession();
+    try {
+      let whereClause = "";
+      const params = {};
+      const conditions = [];
+      if (filter.entityTypes && filter.entityTypes.length > 0) {
+        conditions.push("ANY(type IN $entityTypes WHERE type IN d.entityTypes)");
+        params.entityTypes = filter.entityTypes;
+      }
+      if (filter.search) {
+        conditions.push("toLower(d.name) CONTAINS toLower($search)");
+        params.search = filter.search;
+      }
+      if (conditions.length > 0) {
+        whereClause = "WHERE " + conditions.join(" AND ");
+      }
+      const countResult = await session.run(
+        `MATCH (d:Resource) ${whereClause} RETURN count(d) as total`,
+        params
+      );
+      const total = countResult.records[0].get("total").toNumber();
+      params.skip = neo4j.int(filter.offset || 0);
+      params.limit = neo4j.int(filter.limit || 20);
+      const result = await session.run(
+        `MATCH (d:Resource) ${whereClause}
+         RETURN d
+         ORDER BY d.updatedAt DESC
+         SKIP $skip LIMIT $limit`,
+        params
+      );
+      const resources = result.records.map((record) => this.parseResourceNode(record.get("d")));
+      return { resources, total };
+    } finally {
+      await session.close();
+    }
+  }
+  async searchResources(query, limit = 20) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (d:Resource)
+         WHERE toLower(d.name) CONTAINS toLower($query)
+         RETURN d
+         ORDER BY d.updatedAt DESC
+         LIMIT $limit`,
+        { query, limit: neo4j.int(limit) }
+      );
+      return result.records.map((record) => this.parseResourceNode(record.get("d")));
+    } finally {
+      await session.close();
+    }
+  }
+  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,
+        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 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
+           })
+           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)
+           })
+           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),
+        created: annotation.created,
+        entityTypes,
+        source: bodySource || null
+      };
+      const result = await session.run(cypher, params);
+      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);
+    } finally {
+      await session.close();
+    }
+  }
+  async getAnnotation(id) {
+    console.log(`[Neo4j] getAnnotation called for: ${id}`);
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (a:Annotation {id: $id})
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes`,
+        { id }
+      );
+      if (result.records.length === 0) {
+        console.log(`[Neo4j] getAnnotation: Annotation ${id} NOT FOUND`);
+        return null;
+      }
+      console.log(`[Neo4j] getAnnotation: Annotation ${id} FOUND`);
+      return this.parseAnnotationNode(
+        result.records[0].get("a"),
+        result.records[0].get("entityTypes")
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async updateAnnotation(id, updates) {
+    const session = this.getSession();
+    try {
+      const setClauses = ["a.updatedAt = datetime()"];
+      const params = { id };
+      Object.entries(updates).forEach(([key, value]) => {
+        if (key !== "id" && key !== "updatedAt") {
+          setClauses.push(`a.${key} = $${key}`);
+          if (key === "selector" || key === "metadata" || key === "body") {
+            params[key] = JSON.stringify(value);
+          } else if (key === "created" || key === "resolvedAt") {
+            params[key] = value ? new Date(value).toISOString() : null;
+          } else {
+            params[key] = value;
+          }
+        }
+      });
+      const result = await session.run(
+        `MATCH (a:Annotation {id: $id})
+         SET ${setClauses.join(", ")}
+         WITH a
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes`,
+        params
+      );
+      if (result.records.length === 0) {
+        throw new Error("Annotation not found");
+      }
+      if (updates.motivation) {
+        const newLabel = motivationToLabel(updates.motivation);
+        console.log(`[Neo4j] Updating motivation label to: ${newLabel}`);
+        const allMotivations = [
+          "Assessing",
+          "Bookmarking",
+          "Classifying",
+          "Commenting",
+          "Describing",
+          "Editing",
+          "Highlighting",
+          "Identifying",
+          "Linking",
+          "Moderating",
+          "Questioning",
+          "Replying",
+          "Tagging"
+        ];
+        const removeLabels = allMotivations.filter((m) => m !== newLabel).map((m) => `a:${m}`).join(", ");
+        await session.run(
+          `MATCH (a:Annotation {id: $id})
+           REMOVE ${removeLabels}
+           SET a:${newLabel}`,
+          { id }
+        );
+        console.log(`[Neo4j] \u2705 Motivation label updated to: ${newLabel}`);
+      }
+      if (updates.body) {
+        console.log(`[Neo4j] ====== BODY UPDATE for Annotation ${id} ======`);
+        console.log(`[Neo4j] updates.body:`, JSON.stringify(updates.body));
+        const bodyArray = Array.isArray(updates.body) ? updates.body : [updates.body];
+        console.log(`[Neo4j] bodyArray length: ${bodyArray.length}`);
+        bodyArray.forEach((item, idx) => {
+          console.log(`[Neo4j]   Body item ${idx}:`, JSON.stringify(item));
+        });
+        const specificResource = bodyArray.find((item) => item.type === "SpecificResource" && item.purpose === "linking");
+        console.log(`[Neo4j] Found SpecificResource:`, specificResource ? JSON.stringify(specificResource) : "null");
+        if (specificResource && "source" in specificResource && specificResource.source) {
+          console.log(`[Neo4j] \u2705 Creating REFERENCES edge: ${id} -> ${specificResource.source}`);
+          const refResult = await session.run(
+            `MATCH (a:Annotation {id: $annotationId})
+             MATCH (target:Resource {id: $targetResourceId})
+             MERGE (a)-[:REFERENCES]->(target)
+             RETURN a, target`,
+            {
+              annotationId: id,
+              targetResourceId: specificResource.source
+            }
+          );
+          console.log(`[Neo4j] \u2705 REFERENCES edge created! Matched ${refResult.records.length} nodes`);
+          if (refResult.records.length > 0) {
+            console.log(`[Neo4j]   Annotation: ${refResult.records[0].get("a").properties.id}`);
+            console.log(`[Neo4j]   Target Resource: ${refResult.records[0].get("target").properties.id}`);
+          }
+        } else {
+          console.log(`[Neo4j] No SpecificResource in body - this is a stub reference (not yet resolved)`);
+        }
+      } else {
+        console.log(`[Neo4j] No body update for annotation ${id}`);
+      }
+      return this.parseAnnotationNode(
+        result.records[0].get("a"),
+        result.records[0].get("entityTypes")
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async deleteAnnotation(id) {
+    const session = this.getSession();
+    try {
+      await session.run(
+        "MATCH (a:Annotation {id: $id}) DETACH DELETE a",
+        { id }
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async listAnnotations(filter) {
+    const session = this.getSession();
+    try {
+      const conditions = [];
+      const params = {};
+      if (filter.resourceId) {
+        conditions.push("a.resourceId = $resourceId");
+        params.resourceId = filter.resourceId;
+      }
+      if (filter.type) {
+        const w3cType = filter.type === "highlight" ? "TextualBody" : "SpecificResource";
+        conditions.push("a.type = $type");
+        params.type = w3cType;
+      }
+      const whereClause = conditions.length > 0 ? "WHERE " + conditions.join(" AND ") : "";
+      const result = await session.run(
+        `MATCH (a:Annotation) ${whereClause}
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes`,
+        params
+      );
+      const annotations = result.records.map(
+        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+      );
+      return { annotations, total: annotations.length };
+    } finally {
+      await session.close();
+    }
+  }
+  async getHighlights(resourceId) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (a:Annotation {resourceId: $resourceId})
+         WHERE a.annotationCategory = 'highlight'
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes
+         ORDER BY a.created DESC`,
+        { resourceId }
+      );
+      return result.records.map(
+        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async resolveReference(annotationId, source) {
+    const session = this.getSession();
+    try {
+      const docResult = await session.run(
+        "MATCH (d:Resource {id: $id}) RETURN d.name as name",
+        { id: source }
+      );
+      const resourceName = docResult.records[0]?.get("name");
+      const result = await session.run(
+        `MATCH (a:Annotation {id: $annotationId})
+         MATCH (to:Resource {id: $source})
+         SET a.source = $source,
+             a.resolvedResourceName = $resourceName,
+             a.resolvedAt = datetime()
+         MERGE (a)-[:REFERENCES]->(to)
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes`,
+        { annotationId, source, resourceName }
+      );
+      if (result.records.length === 0) {
+        throw new Error("Annotation not found");
+      }
+      return this.parseAnnotationNode(
+        result.records[0].get("a"),
+        result.records[0].get("entityTypes")
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async getReferences(resourceId) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (a:Annotation {resourceId: $resourceId})
+         WHERE a.annotationCategory IN ['stub_reference', 'resolved_reference']
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes
+         ORDER BY a.created DESC`,
+        { resourceId }
+      );
+      return result.records.map(
+        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async getEntityReferences(resourceId, entityTypes) {
+    const session = this.getSession();
+    try {
+      let cypher = `MATCH (a:Annotation {resourceId: $resourceId})
+                    WHERE a.source IS NOT NULL`;
+      const params = { resourceId };
+      if (entityTypes && entityTypes.length > 0) {
+        cypher += `
+          MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+          WHERE et.name IN $entityTypes`;
+        params.entityTypes = entityTypes;
+      }
+      cypher += `
+        OPTIONAL MATCH (a)-[:TAGGED_AS]->(et2:EntityType)
+        RETURN a, collect(et2.name) as entityTypes
+        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"))
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async getResourceAnnotations(resourceId) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (a:Annotation {resourceId: $resourceId})
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes
+         ORDER BY a.created DESC`,
+        { resourceId }
+      );
+      return result.records.map(
+        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async getResourceReferencedBy(resourceUri3, motivation) {
+    const session = this.getSession();
+    try {
+      const filterDesc = motivation ? ` with motivation=${motivation}` : "";
+      console.log(`[Neo4j] getResourceReferencedBy: Searching for annotations${filterDesc} referencing ${resourceUri3}`);
+      const motivationLabel = motivation ? `:${motivationToLabel(motivation)}` : "";
+      const cypher = `MATCH (a:Annotation${motivationLabel})-[:REFERENCES]->(d:Resource {id: $resourceUri})
+         OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+         RETURN a, collect(et.name) as entityTypes
+         ORDER BY a.created DESC`;
+      const result = await session.run(cypher, { resourceUri: resourceUri3 });
+      console.log(`[Neo4j] getResourceReferencedBy: Found ${result.records.length} annotations`);
+      return result.records.map(
+        (record) => this.parseAnnotationNode(record.get("a"), record.get("entityTypes"))
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  async getResourceConnections(resourceId) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (d:Resource {id: $resourceId})
+         OPTIONAL MATCH (d)<-[:BELONGS_TO]-(a1:Annotation)-[:REFERENCES]->(other:Resource)
+         OPTIONAL MATCH (other)<-[:BELONGS_TO]-(a2:Annotation)-[:REFERENCES]->(d)
+         WITH other, COLLECT(DISTINCT a1) as outgoing, COLLECT(DISTINCT a2) as incoming
+         WHERE other IS NOT NULL
+         RETURN other, outgoing, incoming`,
+        { resourceId }
+      );
+      const connections = [];
+      for (const record of result.records) {
+        const targetResource = this.parseResourceNode(record.get("other"));
+        const outgoingNodes = record.get("outgoing");
+        const outgoing = [];
+        for (const annNode of outgoingNodes) {
+          const annId = annNode.properties.id;
+          const annResult = await session.run(
+            `MATCH (a:Annotation {id: $id})
+             OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+             RETURN a, collect(et.name) as entityTypes`,
+            { id: annId }
+          );
+          if (annResult.records.length > 0) {
+            outgoing.push(this.parseAnnotationNode(
+              annResult.records[0].get("a"),
+              annResult.records[0].get("entityTypes")
+            ));
+          }
+        }
+        const incomingNodes = record.get("incoming");
+        const incoming = [];
+        for (const annNode of incomingNodes) {
+          const annId = annNode.properties.id;
+          const annResult = await session.run(
+            `MATCH (a:Annotation {id: $id})
+             OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+             RETURN a, collect(et.name) as entityTypes`,
+            { id: annId }
+          );
+          if (annResult.records.length > 0) {
+            incoming.push(this.parseAnnotationNode(
+              annResult.records[0].get("a"),
+              annResult.records[0].get("entityTypes")
+            ));
+          }
+        }
+        connections.push({
+          targetResource,
+          annotations: outgoing,
+          bidirectional: incoming.length > 0
+        });
+      }
+      return connections;
+    } finally {
+      await session.close();
+    }
+  }
+  async findPath(fromResourceId, toResourceId, maxDepth = 5) {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH path = shortestPath((from:Resource {id: $fromId})-[:REFERENCES*..${maxDepth}]-(to:Resource {id: $toId}))
+         WITH path, nodes(path) as docs, relationships(path) as rels
+         RETURN docs, rels
+         LIMIT 10`,
+        { fromId: fromResourceId, toId: toResourceId }
+      );
+      const paths = [];
+      for (const record of result.records) {
+        const docs = record.get("docs").map((node) => this.parseResourceNode(node));
+        const rels = record.get("rels");
+        const annotationIds = rels.map((rel) => rel.properties.id).filter((id) => id);
+        const annotations = [];
+        if (annotationIds.length > 0) {
+          const selResult = await session.run(
+            `MATCH (a:Annotation) WHERE a.id IN $ids
+             OPTIONAL MATCH (a)-[:TAGGED_AS]->(et:EntityType)
+             RETURN a, collect(et.name) as entityTypes`,
+            { ids: annotationIds }
+          );
+          selResult.records.forEach((rec) => {
+            annotations.push(this.parseAnnotationNode(
+              rec.get("a"),
+              rec.get("entityTypes")
+            ));
+          });
+        }
+        paths.push({
+          resources: docs,
+          annotations
+        });
+      }
+      return paths;
+    } finally {
+      await session.close();
+    }
+  }
+  async getEntityTypeStats() {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        `MATCH (d:Resource)
+         UNWIND d.entityTypes AS type
+         RETURN type, count(*) AS count
+         ORDER BY count DESC`
+      );
+      return result.records.map((record) => ({
+        type: record.get("type"),
+        count: record.get("count").toNumber()
+      }));
+    } finally {
+      await session.close();
+    }
+  }
+  async getStats() {
+    const session = this.getSession();
+    try {
+      const docCountResult = await session.run("MATCH (d:Resource) RETURN count(d) as count");
+      const resourceCount = docCountResult.records[0].get("count").toNumber();
+      const selCountResult = await session.run("MATCH (a:Annotation) RETURN count(a) as count");
+      const annotationCount = selCountResult.records[0].get("count").toNumber();
+      const highlightCountResult = await session.run(
+        "MATCH (a:Annotation) WHERE a.resolvedResourceId IS NULL RETURN count(a) as count"
+      );
+      const highlightCount = highlightCountResult.records[0].get("count").toNumber();
+      const referenceCountResult = await session.run(
+        "MATCH (a:Annotation) WHERE a.resolvedResourceId IS NOT NULL RETURN count(a) as count"
+      );
+      const referenceCount = referenceCountResult.records[0].get("count").toNumber();
+      const entityRefCountResult = await session.run(
+        "MATCH (a:Annotation) WHERE a.resolvedResourceId IS NOT NULL AND size(a.entityTypes) > 0 RETURN count(a) as count"
+      );
+      const entityReferenceCount = entityRefCountResult.records[0].get("count").toNumber();
+      const entityTypeResult = await session.run(
+        `MATCH (d:Resource)
+         UNWIND d.entityTypes AS type
+         RETURN type, count(*) AS count`
+      );
+      const entityTypes = {};
+      entityTypeResult.records.forEach((record) => {
+        entityTypes[record.get("type")] = record.get("count").toNumber();
+      });
+      const contentTypeResult = await session.run(
+        `MATCH (d:Resource)
+         RETURN d.format as type, count(*) AS count`
+      );
+      const contentTypes = {};
+      contentTypeResult.records.forEach((record) => {
+        contentTypes[record.get("type")] = record.get("count").toNumber();
+      });
+      return {
+        resourceCount,
+        annotationCount,
+        highlightCount,
+        referenceCount,
+        entityReferenceCount,
+        entityTypes,
+        contentTypes
+      };
+    } finally {
+      await session.close();
+    }
+  }
+  async createAnnotations(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.createAnnotation(input));
+    }
+    return results;
+  }
+  async resolveReferences(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.resolveReference(input.annotationId, input.source));
+    }
+    return results;
+  }
+  async detectAnnotations(_resourceId) {
+    return [];
+  }
+  // Tag Collections
+  async getEntityTypes() {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    return Array.from(this.entityTypesCollection).sort();
+  }
+  async addEntityType(tag) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    this.entityTypesCollection.add(tag);
+    await this.persistTagCollection("entity-types", this.entityTypesCollection);
+  }
+  async addEntityTypes(tags) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    tags.forEach((tag) => this.entityTypesCollection.add(tag));
+    await this.persistTagCollection("entity-types", this.entityTypesCollection);
+  }
+  async initializeTagCollections() {
+    const session = this.getSession();
+    try {
+      const result = await session.run(
+        'MATCH (t:TagCollection {type: "entity-types"}) RETURN t.tags as tags'
+      );
+      let entityTypesFromDb = [];
+      if (result.records.length > 0) {
+        const record = result.records[0];
+        if (record) {
+          const tags = record.get("tags");
+          entityTypesFromDb = tags || [];
+        }
+      }
+      const { DEFAULT_ENTITY_TYPES } = await import("@semiont/ontology");
+      this.entityTypesCollection = /* @__PURE__ */ new Set([...DEFAULT_ENTITY_TYPES, ...entityTypesFromDb]);
+      await this.persistTagCollection("entity-types", this.entityTypesCollection);
+    } finally {
+      await session.close();
+    }
+  }
+  async persistTagCollection(type, collection) {
+    const session = this.getSession();
+    try {
+      await session.run(
+        "MERGE (t:TagCollection {type: $type}) SET t.tags = $tags",
+        { type, tags: Array.from(collection) }
+      );
+    } finally {
+      await session.close();
+    }
+  }
+  generateId() {
+    return uuidv42().replace(/-/g, "").substring(0, 12);
+  }
+  async clearDatabase() {
+    const session = this.getSession();
+    try {
+      await session.run("MATCH (n) DETACH DELETE n");
+      this.entityTypesCollection = null;
+    } finally {
+      await session.close();
+    }
+  }
+  // Helper methods to parse Neo4j nodes
+  parseResourceNode(node) {
+    const props = node.properties;
+    if (!props.id) throw new Error("Resource missing required field: id");
+    if (!props.name) throw new Error(`Resource ${props.id} missing required field: name`);
+    if (!props.entityTypes) throw new Error(`Resource ${props.id} missing required field: entityTypes`);
+    if (!props.format) throw new Error(`Resource ${props.id} missing required field: contentType`);
+    if (props.archived === void 0 || props.archived === null) throw new Error(`Resource ${props.id} missing required field: archived`);
+    if (!props.created) throw new Error(`Resource ${props.id} missing required field: created`);
+    if (!props.creator) throw new Error(`Resource ${props.id} missing required field: creator`);
+    if (!props.creationMethod) throw new Error(`Resource ${props.id} missing required field: creationMethod`);
+    if (!props.contentChecksum) throw new Error(`Resource ${props.id} missing required field: contentChecksum`);
+    const resource = {
+      "@context": "https://schema.org/",
+      "@id": props.id,
+      name: props.name,
+      entityTypes: props.entityTypes,
+      representations: [{
+        mediaType: props.format,
+        checksum: props.contentChecksum,
+        rel: "original"
+      }],
+      archived: props.archived,
+      dateCreated: props.created.toString(),
+      wasAttributedTo: typeof props.creator === "string" ? JSON.parse(props.creator) : props.creator,
+      creationMethod: props.creationMethod
+    };
+    if (props.sourceResourceId) resource.sourceResourceId = props.sourceResourceId;
+    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;
+  }
+};
+
+// src/implementations/janusgraph.ts
+import gremlin2 from "gremlin";
+import {
+  getBodySource as getBodySource3,
+  getPrimaryRepresentation as getPrimaryRepresentation3,
+  getResourceId as getResourceId2,
+  getExactText as getExactText3,
+  resourceUri
+} from "@semiont/api-client";
+import { getEntityTypes as getEntityTypes3 } from "@semiont/ontology";
+import { annotationIdToURI } from "@semiont/core";
+import { v4 as uuidv43 } from "uuid";
+var traversal = gremlin2.process.AnonymousTraversalSource.traversal;
+var DriverRemoteConnection = gremlin2.driver.DriverRemoteConnection;
+var JanusGraphDatabase = class {
+  constructor(graphConfig, envConfig) {
+    this.graphConfig = graphConfig;
+    this.envConfig = envConfig;
+  }
+  connected = false;
+  connection = null;
+  g = null;
+  // Tag Collections - cached in memory for performance
+  entityTypesCollection = null;
+  async connect() {
+    const host = this.graphConfig.host;
+    if (!host) {
+      throw new Error("JanusGraph host is required: provide in config");
+    }
+    const port = this.graphConfig.port;
+    if (!port) {
+      throw new Error("JanusGraph port is required: provide in config");
+    }
+    console.log(`Attempting to connect to JanusGraph at ws://${host}:${port}/gremlin`);
+    this.connection = new DriverRemoteConnection(
+      `ws://${host}:${port}/gremlin`,
+      {}
+    );
+    this.g = traversal().withRemote(this.connection);
+    await this.g.V().limit(1).toList();
+    this.connected = true;
+    console.log("Successfully connected to JanusGraph");
+    await this.initializeSchema();
+  }
+  async disconnect() {
+    if (this.connection) {
+      await this.connection.close();
+    }
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async initializeSchema() {
+    console.log("Schema initialization would happen here in production");
+  }
+  // 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 creationMethod = this.getPropertyValue(props, "creationMethod");
+    const contentChecksum = this.getPropertyValue(props, "contentChecksum");
+    const mediaType = this.getPropertyValue(props, "contentType");
+    if (!creatorRaw) throw new Error(`Resource ${id} missing required field: creator`);
+    if (!creationMethod) throw new Error(`Resource ${id} missing required field: creationMethod`);
+    if (!contentChecksum) throw new Error(`Resource ${id} missing required field: contentChecksum`);
+    if (!mediaType) throw new Error(`Resource ${id} missing required field: contentType`);
+    const creator = typeof creatorRaw === "string" ? JSON.parse(creatorRaw) : creatorRaw;
+    const resource = {
+      "@context": "https://schema.org/",
+      "@id": id,
+      name: this.getPropertyValue(props, "name"),
+      entityTypes: JSON.parse(this.getPropertyValue(props, "entityTypes") || "[]"),
+      representations: [{
+        mediaType,
+        checksum: contentChecksum,
+        rel: "original"
+      }],
+      archived: this.getPropertyValue(props, "archived") === "true",
+      dateCreated: this.getPropertyValue(props, "created"),
+      wasAttributedTo: creator,
+      creationMethod
+    };
+    const sourceAnnotationId = this.getPropertyValue(props, "sourceAnnotationId");
+    const sourceResourceId = this.getPropertyValue(props, "sourceResourceId");
+    if (sourceAnnotationId) resource.sourceAnnotationId = sourceAnnotationId;
+    if (sourceResourceId) resource.sourceResourceId = sourceResourceId;
+    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 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")
+      ).filter(Boolean);
+      annotations.push(this.vertexToAnnotation(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);
+    if (!primaryRep) {
+      throw new Error("Resource must have at least one representation");
+    }
+    const vertex = this.g.addV("Resource").property("id", id).property("name", resource.name).property("entityTypes", JSON.stringify(resource.entityTypes)).property("contentType", primaryRep.mediaType).property("archived", resource.archived || false).property("created", resource.dateCreated).property("creator", JSON.stringify(resource.wasAttributedTo)).property("creationMethod", resource.creationMethod).property("contentChecksum", primaryRep.checksum);
+    if (resource.sourceAnnotationId) {
+      vertex.property("sourceAnnotationId", resource.sourceAnnotationId);
+    }
+    if (resource.sourceResourceId) {
+      vertex.property("sourceResourceId", resource.sourceResourceId);
+    }
+    await vertex.next();
+    console.log("Created resource vertex in JanusGraph:", id);
+    return resource;
+  }
+  async getResource(id) {
+    const vertices = await this.g.V().has("Resource", "id", id).toList();
+    if (vertices.length === 0) {
+      return null;
+    }
+    return this.vertexToResource(vertices[0]);
+  }
+  async updateResource(id, input) {
+    if (Object.keys(input).length !== 1 || input.archived === void 0) {
+      throw new Error("Resources are immutable. Only archiving is allowed.");
+    }
+    await this.g.V().has("Resource", "id", id).property("archived", input.archived).next();
+    const updatedResource = await this.getResource(id);
+    if (!updatedResource) {
+      throw new Error("Resource not found");
+    }
+    return updatedResource;
+  }
+  async deleteResource(id) {
+    await this.g.V().has("Resource", "id", id).drop().next();
+    console.log("Deleted resource from JanusGraph:", id);
+  }
+  async listResources(filter) {
+    let traversalQuery = this.g.V().hasLabel("Resource");
+    if (filter.search) {
+      traversalQuery = traversalQuery.has("name", gremlin2.process.TextP.containing(filter.search));
+    }
+    const docs = await traversalQuery.toList();
+    let resources = docs.map((v) => this.vertexToResource(v));
+    if (filter.entityTypes && filter.entityTypes.length > 0) {
+      resources = resources.filter(
+        (doc) => filter.entityTypes.some((type) => doc.entityTypes?.includes(type))
+      );
+    }
+    const total = resources.length;
+    const offset = filter.offset || 0;
+    const limit = filter.limit || 50;
+    return {
+      resources: resources.slice(offset, offset + limit),
+      total
+    };
+  }
+  async searchResources(query, limit) {
+    const result = await this.listResources({ search: query, limit: limit || 10 });
+    return result.resources;
+  }
+  async createAnnotation(input) {
+    const id = this.generateId();
+    const motivation = input.motivation;
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      id,
+      motivation,
+      target: input.target,
+      body: input.body,
+      creator: input.creator,
+      created: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const bodySource = getBodySource3(input.body);
+    const entityTypes = getEntityTypes3(input);
+    const bodyType = 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);
+    }
+    const annVertex = await vertex.next();
+    await this.g.V(annVertex.value).addE("BELONGS_TO").to(this.g.V().has("Resource", "id", targetSource)).next();
+    if (bodySource) {
+      await this.g.V(annVertex.value).addE("REFERENCES").to(this.g.V().has("Resource", "id", bodySource)).next();
+    }
+    for (const entityType of entityTypes) {
+      const etResults = await this.g.V().has("EntityType", "name", entityType).toList();
+      let etVertex;
+      if (etResults.length === 0) {
+        etVertex = await this.g.addV("EntityType").property("name", entityType).next();
+      } else {
+        etVertex = { value: etResults[0] };
+      }
+      await this.g.V(annVertex.value).addE("TAGGED_AS").to(this.g.V(etVertex.value)).next();
+    }
+    console.log("Created annotation in JanusGraph:", id);
+    return annotation;
+  }
+  async getAnnotation(id) {
+    const vertices = await this.g.V().has("Annotation", "id", id).toList();
+    if (vertices.length === 0) {
+      return null;
+    }
+    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")
+    ).filter(Boolean);
+    return this.vertexToAnnotation(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();
+      }
+    }
+    if (updates.body !== void 0) {
+      const bodySource = getBodySource3(updates.body);
+      const entityTypes = getEntityTypes3({ body: updates.body });
+      if (bodySource) {
+        await traversalQuery.property("source", bodySource).next();
+      }
+      if (entityTypes.length >= 0) {
+        await this.g.V().has("Annotation", "id", id).outE("TAGGED_AS").drop().iterate();
+        for (const entityType of entityTypes) {
+          const etResults = await this.g.V().has("EntityType", "name", entityType).toList();
+          let etVertex;
+          if (etResults.length === 0) {
+            etVertex = await this.g.addV("EntityType").property("name", entityType).next();
+          } else {
+            etVertex = { value: etResults[0] };
+          }
+          const annVertices = await this.g.V().has("Annotation", "id", id).toList();
+          if (annVertices.length > 0) {
+            await this.g.V(annVertices[0]).addE("TAGGED_AS").to(this.g.V(etVertex.value)).next();
+          }
+        }
+      }
+    }
+    if (updates.modified !== void 0) {
+      await traversalQuery.property("modified", updates.modified).next();
+    }
+    if (updates.generator !== void 0) {
+      await traversalQuery.property("generator", JSON.stringify(updates.generator)).next();
+    }
+    const updatedAnnotation = await this.getAnnotation(id);
+    if (!updatedAnnotation) {
+      throw new Error("Annotation not found");
+    }
+    return updatedAnnotation;
+  }
+  async deleteAnnotation(id) {
+    await this.g.V().has("Annotation", "id", id).drop().next();
+    console.log("Deleted annotation from JanusGraph:", id);
+  }
+  async listAnnotations(filter) {
+    let traversalQuery = this.g.V().hasLabel("Annotation");
+    if (filter.resourceId) {
+      traversalQuery = traversalQuery.has("resourceId", filter.resourceId);
+    }
+    if (filter.type) {
+      const w3cType = filter.type === "highlight" ? "TextualBody" : "SpecificResource";
+      traversalQuery = traversalQuery.has("type", w3cType);
+    }
+    const vertices = await traversalQuery.toList();
+    const annotations = await this.fetchAnnotationsWithEntityTypes(vertices);
+    return {
+      annotations,
+      total: annotations.length
+    };
+  }
+  async getHighlights(resourceId) {
+    const { annotations } = await this.listAnnotations({
+      resourceId,
+      type: "highlight"
+    });
+    return annotations;
+  }
+  async resolveReference(annotationId, source) {
+    const publicURL = this.envConfig.services.backend.publicURL;
+    const annotation = await this.getAnnotation(annotationIdToURI(annotationId, publicURL));
+    if (!annotation) throw new Error("Annotation not found");
+    await this.updateAnnotation(annotationIdToURI(annotationId, publicURL), {
+      body: [
+        {
+          type: "SpecificResource",
+          source,
+          purpose: "linking"
+        }
+      ]
+    });
+    await this.g.V().has("Annotation", "id", annotationId).addE("REFERENCES").to(this.g.V().has("Resource", "id", source)).next();
+    const updatedAnnotation = await this.getAnnotation(annotationIdToURI(annotationId, publicURL));
+    if (!updatedAnnotation) {
+      throw new Error("Annotation not found after update");
+    }
+    return updatedAnnotation;
+  }
+  async getReferences(resourceId) {
+    const { annotations } = await this.listAnnotations({
+      resourceId,
+      type: "reference"
+    });
+    return annotations;
+  }
+  async getEntityReferences(resourceId, entityTypes) {
+    const { annotations } = await this.listAnnotations({
+      resourceId,
+      type: "reference"
+    });
+    if (entityTypes && entityTypes.length > 0) {
+      return annotations.filter((ann) => {
+        const annEntityTypes = getEntityTypes3(ann);
+        return annEntityTypes.some((type) => entityTypes.includes(type));
+      });
+    }
+    return annotations.filter((ann) => getEntityTypes3(ann).length > 0);
+  }
+  async getResourceAnnotations(resourceId) {
+    const { annotations } = await this.listAnnotations({ resourceId });
+    return annotations;
+  }
+  async getResourceReferencedBy(resourceUri3, _motivation) {
+    const vertices = await this.g.V().hasLabel("Annotation").has("source", resourceUri3).toList();
+    return await this.fetchAnnotationsWithEntityTypes(vertices);
+  }
+  async getResourceConnections(resourceId) {
+    const paths = await this.g.V().has("Resource", "id", resourceId).inE("BELONGS_TO").outV().outE("REFERENCES").inV().path().toList();
+    console.log("Found paths:", paths.length);
+    const connections = [];
+    const refs = await this.getReferences(resourceId);
+    for (const ref of refs) {
+      const bodySource = getBodySource3(ref.body);
+      if (bodySource) {
+        const targetDoc = await this.getResource(resourceUri(bodySource));
+        if (targetDoc) {
+          const existing = connections.find((c) => c.targetResource.id === targetDoc.id);
+          if (existing) {
+            existing.annotations.push(ref);
+          } else {
+            connections.push({
+              targetResource: targetDoc,
+              annotations: [ref],
+              relationshipType: void 0,
+              bidirectional: false
+            });
+          }
+        }
+      }
+    }
+    return connections;
+  }
+  async findPath(_fromResourceId, _toResourceId, _maxDepth) {
+    return [];
+  }
+  async getEntityTypeStats() {
+    const docs = await this.g.V().hasLabel("Resource").toList();
+    const resources = docs.map((v) => this.vertexToResource(v));
+    const stats = /* @__PURE__ */ new Map();
+    for (const doc of resources) {
+      for (const type of doc.entityTypes || []) {
+        stats.set(type, (stats.get(type) || 0) + 1);
+      }
+    }
+    return Array.from(stats.entries()).map(([type, count]) => ({ type, count }));
+  }
+  async getStats() {
+    const entityTypes = {};
+    const contentTypes = {};
+    const docs = await this.g.V().hasLabel("Resource").toList();
+    const resources = docs.map((v) => this.vertexToResource(v));
+    for (const doc of resources) {
+      for (const type of doc.entityTypes || []) {
+        entityTypes[type] = (entityTypes[type] || 0) + 1;
+      }
+      const primaryRep = getPrimaryRepresentation3(doc);
+      if (primaryRep?.mediaType) {
+        contentTypes[primaryRep.mediaType] = (contentTypes[primaryRep.mediaType] || 0) + 1;
+      }
+    }
+    const anns = await this.g.V().hasLabel("Annotation").toList();
+    const annotations = await this.fetchAnnotationsWithEntityTypes(anns);
+    const highlights = annotations.filter((a) => a.motivation === "highlighting");
+    const references = annotations.filter((a) => a.motivation === "linking");
+    const entityReferences = references.filter((a) => getEntityTypes3(a).length > 0);
+    return {
+      resourceCount: resources.length,
+      annotationCount: annotations.length,
+      highlightCount: highlights.length,
+      referenceCount: references.length,
+      entityReferenceCount: entityReferences.length,
+      entityTypes,
+      contentTypes
+    };
+  }
+  async createAnnotations(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.createAnnotation(input));
+    }
+    return results;
+  }
+  async resolveReferences(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.resolveReference(input.annotationId, input.source));
+    }
+    return results;
+  }
+  async detectAnnotations(_resourceId) {
+    return [];
+  }
+  async getEntityTypes() {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    return Array.from(this.entityTypesCollection).sort();
+  }
+  async addEntityType(tag) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    this.entityTypesCollection.add(tag);
+    try {
+      const existing = await this.g.V().hasLabel("TagCollection").has("type", "entity-types").toList();
+      if (existing.length > 0) {
+        await this.g.V(existing[0]).property("tags", JSON.stringify(Array.from(this.entityTypesCollection))).next();
+      } else {
+        await this.g.addV("TagCollection").property("type", "entity-types").property("tags", JSON.stringify(Array.from(this.entityTypesCollection))).next();
+      }
+    } catch (error) {
+      console.error("Failed to add entity type:", error);
+    }
+  }
+  async addEntityTypes(tags) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    tags.forEach((tag) => this.entityTypesCollection.add(tag));
+    try {
+      const existing = await this.g.V().hasLabel("TagCollection").has("type", "entity-types").toList();
+      if (existing.length > 0) {
+        await this.g.V(existing[0]).property("tags", JSON.stringify(Array.from(this.entityTypesCollection))).next();
+      } else {
+        await this.g.addV("TagCollection").property("type", "entity-types").property("tags", JSON.stringify(Array.from(this.entityTypesCollection))).next();
+      }
+    } catch (error) {
+      console.error("Failed to add entity types:", error);
+    }
+  }
+  async initializeTagCollections() {
+    const collections = await this.g.V().hasLabel("TagCollection").toList();
+    let entityTypesFromDb = [];
+    for (const vertex of collections) {
+      const props = vertex.properties || {};
+      const type = this.getPropertyValue(props, "type");
+      const tagsJson = this.getPropertyValue(props, "tags");
+      const tags = tagsJson ? JSON.parse(tagsJson) : [];
+      if (type === "entity-types") {
+        entityTypesFromDb = tags;
+      }
+    }
+    const { DEFAULT_ENTITY_TYPES } = await import("@semiont/ontology");
+    this.entityTypesCollection = /* @__PURE__ */ new Set([...DEFAULT_ENTITY_TYPES, ...entityTypesFromDb]);
+    if (entityTypesFromDb.length === 0) {
+      await this.addEntityTypes([]);
+    }
+  }
+  generateId() {
+    return uuidv43().replace(/-/g, "").substring(0, 12);
+  }
+  async clearDatabase() {
+    await this.g.V().drop().next();
+    this.entityTypesCollection = null;
+    console.log("Cleared JanusGraph database");
+  }
+};
+
+// src/implementations/memorygraph.ts
+import { getResourceEntityTypes } from "@semiont/api-client";
+import { getEntityTypes as getEntityTypes4 } from "@semiont/ontology";
+import { resourceId as makeResourceId } from "@semiont/core";
+import { resourceUri as resourceUri2 } from "@semiont/api-client";
+import { v4 as uuidv44 } from "uuid";
+import { getBodySource as getBodySource4, getTargetSource as getTargetSource3 } from "@semiont/api-client";
+import { getResourceId as getResourceId3, getPrimaryRepresentation as getPrimaryRepresentation4 } from "@semiont/api-client";
+var MemoryGraphDatabase = class {
+  connected = false;
+  // In-memory storage using Maps
+  resources = /* @__PURE__ */ new Map();
+  annotations = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    void config;
+  }
+  async connect() {
+    console.log("Using in-memory graph database...");
+    this.connected = true;
+  }
+  async disconnect() {
+    this.connected = false;
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async createResource(resource) {
+    const id = getResourceId3(resource);
+    if (!id) {
+      throw new Error("Resource must have an id");
+    }
+    this.resources.set(id, resource);
+    return resource;
+  }
+  async getResource(id) {
+    return this.resources.get(id) || null;
+  }
+  async updateResource(id, input) {
+    if (Object.keys(input).length !== 1 || input.archived === void 0) {
+      throw new Error("Resources are immutable. Only archiving is allowed.");
+    }
+    const doc = this.resources.get(id);
+    if (!doc) throw new Error("Resource not found");
+    doc.archived = input.archived;
+    return doc;
+  }
+  async deleteResource(id) {
+    this.resources.delete(id);
+    for (const [selId, sel] of this.annotations) {
+      if (getTargetSource3(sel.target) === id || getBodySource4(sel.body) === id) {
+        this.annotations.delete(selId);
+      }
+    }
+  }
+  async listResources(filter) {
+    let docs = Array.from(this.resources.values());
+    if (filter.entityTypes && filter.entityTypes.length > 0) {
+      docs = docs.filter(
+        (doc) => doc.entityTypes && doc.entityTypes.some((type) => filter.entityTypes.includes(type))
+      );
+    }
+    if (filter.search) {
+      const searchLower = filter.search.toLowerCase();
+      docs = docs.filter(
+        (doc) => doc.name.toLowerCase().includes(searchLower)
+      );
+    }
+    const total = docs.length;
+    const offset = filter.offset || 0;
+    const limit = filter.limit || 20;
+    docs = docs.slice(offset, offset + limit);
+    return { resources: docs, total };
+  }
+  async searchResources(query, limit = 20) {
+    const searchLower = query.toLowerCase();
+    const results = Array.from(this.resources.values()).filter((doc) => doc.name.toLowerCase().includes(searchLower)).slice(0, limit);
+    return results;
+  }
+  async createAnnotation(input) {
+    const id = this.generateId();
+    const annotation = {
+      "@context": "http://www.w3.org/ns/anno.jsonld",
+      "type": "Annotation",
+      id,
+      motivation: input.motivation,
+      target: input.target,
+      body: input.body,
+      creator: input.creator,
+      created: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.annotations.set(id, annotation);
+    console.log("Memory: Created annotation:", {
+      id,
+      motivation: annotation.motivation,
+      hasSource: !!getBodySource4(annotation.body),
+      targetSource: getTargetSource3(annotation.target)
+    });
+    return annotation;
+  }
+  async getAnnotation(id) {
+    return this.annotations.get(id) || null;
+  }
+  async updateAnnotation(id, updates) {
+    const annotation = this.annotations.get(id);
+    if (!annotation) throw new Error("Annotation not found");
+    const updated = {
+      ...annotation,
+      ...updates
+    };
+    this.annotations.set(id, updated);
+    return updated;
+  }
+  async deleteAnnotation(id) {
+    this.annotations.delete(id);
+  }
+  async listAnnotations(filter) {
+    let results = Array.from(this.annotations.values());
+    if (filter.resourceId) {
+      const resourceIdStr = String(filter.resourceId);
+      results = results.filter((a) => {
+        const targetSource = getTargetSource3(a.target);
+        return targetSource === resourceIdStr || targetSource === resourceUri2(resourceIdStr);
+      });
+    }
+    if (filter.type) {
+      const motivation = filter.type === "highlight" ? "highlighting" : "linking";
+      results = results.filter((a) => a.motivation === motivation);
+    }
+    return { annotations: results, total: results.length };
+  }
+  async getHighlights(resourceId) {
+    const resourceIdStr = String(resourceId);
+    const highlights = Array.from(this.annotations.values()).filter((sel) => {
+      const targetSource = getTargetSource3(sel.target);
+      return (targetSource === resourceIdStr || targetSource === resourceUri2(resourceIdStr)) && sel.motivation === "highlighting";
+    });
+    console.log(`Memory: getHighlights for ${resourceId} found ${highlights.length} highlights`);
+    return highlights;
+  }
+  async resolveReference(annotationId, source) {
+    const annotation = this.annotations.get(annotationId);
+    if (!annotation) throw new Error("Annotation not found");
+    const updated = {
+      ...annotation,
+      body: {
+        type: "SpecificResource",
+        source,
+        purpose: "linking"
+      }
+    };
+    this.annotations.set(annotationId, updated);
+    return updated;
+  }
+  async getReferences(resourceId) {
+    const resourceIdStr = String(resourceId);
+    const references = Array.from(this.annotations.values()).filter((sel) => {
+      const targetSource = getTargetSource3(sel.target);
+      return (targetSource === resourceIdStr || targetSource === resourceUri2(resourceIdStr)) && sel.motivation === "linking";
+    });
+    console.log(`Memory: getReferences for ${resourceId} found ${references.length} references`);
+    references.forEach((ref) => {
+      console.log("  Reference:", {
+        id: ref.id,
+        source: getBodySource4(ref.body),
+        entityTypes: getEntityTypes4(ref)
+        // from body
+      });
+    });
+    return references;
+  }
+  async getEntityReferences(resourceId, entityTypes) {
+    const resourceIdStr = String(resourceId);
+    let refs = Array.from(this.annotations.values()).filter((sel) => {
+      const selEntityTypes = getEntityTypes4(sel);
+      const targetSource = getTargetSource3(sel.target);
+      return (targetSource === resourceIdStr || targetSource === resourceUri2(resourceIdStr)) && selEntityTypes.length > 0;
+    });
+    if (entityTypes && entityTypes.length > 0) {
+      refs = refs.filter((sel) => {
+        const selEntityTypes = getEntityTypes4(sel);
+        return selEntityTypes.some((type) => entityTypes.includes(type));
+      });
+    }
+    return refs;
+  }
+  async getResourceAnnotations(resourceId) {
+    const resourceIdStr = String(resourceId);
+    return Array.from(this.annotations.values()).filter((sel) => {
+      const targetSource = getTargetSource3(sel.target);
+      return targetSource === resourceIdStr || targetSource === resourceUri2(resourceIdStr);
+    });
+  }
+  async getResourceReferencedBy(resourceUri3, _motivation) {
+    return Array.from(this.annotations.values()).filter((sel) => getBodySource4(sel.body) === resourceUri3);
+  }
+  async getResourceConnections(resourceId) {
+    const connections = [];
+    const refs = await this.getReferences(resourceId);
+    for (const ref of refs) {
+      const bodySource = getBodySource4(ref.body);
+      if (bodySource) {
+        const targetDoc = await this.getResource(resourceUri2(bodySource));
+        if (targetDoc) {
+          const reverseRefs = await this.getReferences(makeResourceId(bodySource));
+          const resourceIdStr = String(resourceId);
+          const bidirectional = reverseRefs.some((r) => {
+            const reverseBodySource = getBodySource4(r.body);
+            return reverseBodySource === resourceIdStr || reverseBodySource === resourceUri2(resourceIdStr);
+          });
+          connections.push({
+            targetResource: targetDoc,
+            annotations: [ref],
+            bidirectional
+          });
+        }
+      }
+    }
+    return connections;
+  }
+  async findPath(fromResourceId, toResourceId, maxDepth = 5) {
+    const visited = /* @__PURE__ */ new Set();
+    const queue = [];
+    const fromDoc = await this.getResource(resourceUri2(fromResourceId));
+    if (!fromDoc) return [];
+    queue.push({ docId: fromResourceId, path: [fromDoc], sels: [] });
+    visited.add(fromResourceId);
+    const paths = [];
+    while (queue.length > 0 && paths.length < 10) {
+      const { docId, path, sels } = queue.shift();
+      if (path.length > maxDepth) continue;
+      if (docId === toResourceId) {
+        paths.push({ resources: path, annotations: sels });
+        continue;
+      }
+      const connections = await this.getResourceConnections(makeResourceId(docId));
+      for (const conn of connections) {
+        const targetId = getResourceId3(conn.targetResource);
+        if (targetId && !visited.has(targetId)) {
+          visited.add(targetId);
+          queue.push({
+            docId: targetId,
+            path: [...path, conn.targetResource],
+            sels: [...sels, ...conn.annotations]
+          });
+        }
+      }
+    }
+    return paths;
+  }
+  async getEntityTypeStats() {
+    const typeCounts = /* @__PURE__ */ new Map();
+    for (const doc of this.resources.values()) {
+      const types = getResourceEntityTypes(doc);
+      for (const type of types) {
+        typeCounts.set(type, (typeCounts.get(type) || 0) + 1);
+      }
+    }
+    return Array.from(typeCounts.entries()).map(([type, count]) => ({
+      type,
+      count
+    }));
+  }
+  async getStats() {
+    const entityTypes = {};
+    const contentTypes = {};
+    for (const doc of this.resources.values()) {
+      for (const type of doc.entityTypes || []) {
+        entityTypes[type] = (entityTypes[type] || 0) + 1;
+      }
+      const primaryRep = getPrimaryRepresentation4(doc);
+      if (primaryRep?.mediaType) {
+        contentTypes[primaryRep.mediaType] = (contentTypes[primaryRep.mediaType] || 0) + 1;
+      }
+    }
+    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) => a.motivation === "linking" && getEntityTypes4(a).length > 0).length;
+    return {
+      resourceCount: this.resources.size,
+      annotationCount: this.annotations.size,
+      highlightCount,
+      referenceCount,
+      entityReferenceCount,
+      entityTypes,
+      contentTypes
+    };
+  }
+  async createAnnotations(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.createAnnotation(input));
+    }
+    return results;
+  }
+  async resolveReferences(inputs) {
+    const results = [];
+    for (const input of inputs) {
+      results.push(await this.resolveReference(input.annotationId, input.source));
+    }
+    return results;
+  }
+  async detectAnnotations(_resourceId) {
+    return [];
+  }
+  // Tag Collections - stored as special vertices in the graph
+  entityTypesCollection = null;
+  async getEntityTypes() {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    return Array.from(this.entityTypesCollection).sort();
+  }
+  async addEntityType(tag) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    this.entityTypesCollection.add(tag);
+  }
+  async addEntityTypes(tags) {
+    if (this.entityTypesCollection === null) {
+      await this.initializeTagCollections();
+    }
+    tags.forEach((tag) => this.entityTypesCollection.add(tag));
+  }
+  async initializeTagCollections() {
+    if (this.entityTypesCollection === null) {
+      const { DEFAULT_ENTITY_TYPES } = await import("@semiont/ontology");
+      this.entityTypesCollection = new Set(DEFAULT_ENTITY_TYPES);
+    }
+  }
+  generateId() {
+    return uuidv44().replace(/-/g, "").substring(0, 12);
+  }
+  async clearDatabase() {
+    this.resources.clear();
+    this.annotations.clear();
+    this.entityTypesCollection = null;
+  }
+};
+
+// src/factory.ts
+var graphDatabaseInstance = null;
+function createGraphDatabase(config, envConfig) {
+  switch (config.type) {
+    case "neptune": {
+      const neptuneConfig = {};
+      if (config.neptuneEndpoint !== void 0) neptuneConfig.endpoint = config.neptuneEndpoint;
+      if (config.neptunePort !== void 0) neptuneConfig.port = config.neptunePort;
+      if (config.neptuneRegion !== void 0) neptuneConfig.region = config.neptuneRegion;
+      return new NeptuneGraphDatabase(neptuneConfig);
+    }
+    case "neo4j": {
+      const neo4jConfig = {};
+      if (config.neo4jUri !== void 0) neo4jConfig.uri = config.neo4jUri;
+      if (config.neo4jUsername !== void 0) neo4jConfig.username = config.neo4jUsername;
+      if (config.neo4jPassword !== void 0) neo4jConfig.password = config.neo4jPassword;
+      if (config.neo4jDatabase !== void 0) neo4jConfig.database = config.neo4jDatabase;
+      return new Neo4jGraphDatabase(neo4jConfig);
+    }
+    case "janusgraph": {
+      const janusConfig = {};
+      if (config.janusHost !== void 0) janusConfig.host = config.janusHost;
+      if (config.janusPort !== void 0) janusConfig.port = config.janusPort;
+      if (config.janusStorageBackend !== void 0) janusConfig.storageBackend = config.janusStorageBackend;
+      if (config.janusIndexBackend !== void 0) janusConfig.indexBackend = config.janusIndexBackend;
+      return new JanusGraphDatabase(janusConfig, envConfig);
+    }
+    case "memory":
+      return new MemoryGraphDatabase({});
+    default:
+      throw new Error(`Unsupported graph database type: ${config.type}`);
+  }
+}
+function evaluateEnvVar(value) {
+  if (!value) return void 0;
+  return value.replace(/\$\{([^}]+)\}/g, (match, varName) => {
+    const envValue = process.env[varName];
+    if (!envValue) {
+      throw new Error(`Environment variable ${varName} is not set. Referenced in configuration as ${match}`);
+    }
+    return envValue;
+  });
+}
+async function getGraphDatabase(envConfig) {
+  if (!graphDatabaseInstance) {
+    const graphConfig = envConfig.services.graph;
+    const config = {
+      type: graphConfig.type
+    };
+    if (graphConfig.type === "janusgraph") {
+      if (graphConfig.host) {
+        config.janusHost = graphConfig.host;
+      }
+      if (graphConfig.port) {
+        config.janusPort = graphConfig.port;
+      }
+      if (graphConfig.storage) {
+        config.janusStorageBackend = graphConfig.storage;
+      }
+      if (graphConfig.index && graphConfig.index !== "none") {
+        config.janusIndexBackend = graphConfig.index;
+      }
+    } else if (graphConfig.type === "neptune") {
+      if (graphConfig.endpoint) {
+        config.neptuneEndpoint = graphConfig.endpoint;
+      }
+      if (graphConfig.port) {
+        config.neptunePort = graphConfig.port;
+      }
+      if (graphConfig.region) {
+        config.neptuneRegion = graphConfig.region;
+      }
+    } else if (graphConfig.type === "neo4j") {
+      if (graphConfig.uri) {
+        config.neo4jUri = evaluateEnvVar(graphConfig.uri);
+      }
+      if (graphConfig.username) {
+        config.neo4jUsername = evaluateEnvVar(graphConfig.username);
+      }
+      if (graphConfig.password) {
+        config.neo4jPassword = evaluateEnvVar(graphConfig.password);
+      }
+      if (graphConfig.database) {
+        config.neo4jDatabase = evaluateEnvVar(graphConfig.database);
+      }
+    }
+    graphDatabaseInstance = createGraphDatabase(config, envConfig);
+    await graphDatabaseInstance.connect();
+  }
+  if (!graphDatabaseInstance.isConnected()) {
+    await graphDatabaseInstance.connect();
+  }
+  return graphDatabaseInstance;
+}
+async function closeGraphDatabase() {
+  if (graphDatabaseInstance) {
+    await graphDatabaseInstance.disconnect();
+    graphDatabaseInstance = null;
+  }
+}
+export {
+  JanusGraphDatabase,
+  MemoryGraphDatabase,
+  Neo4jGraphDatabase,
+  NeptuneGraphDatabase,
+  closeGraphDatabase,
+  createGraphDatabase,
+  getGraphDatabase
+};
+//# sourceMappingURL=index.js.map