@semiont/make-meaning 0.2.46 → 0.3.0

package/dist/index.js

@@ -3634,7 +3634,7 @@ var require_firstValueFrom = __commonJS({
     exports.firstValueFrom = void 0;
     var EmptyError_1 = require_EmptyError();
     var Subscriber_1 = require_Subscriber();
-    function firstValueFrom3(source, config) {
+    function firstValueFrom5(source, config) {
       var hasConfig = typeof config === "object";
       return new Promise(function(resolve4, reject) {
         var subscriber = new Subscriber_1.SafeSubscriber({
@@ -3654,7 +3654,7 @@ var require_firstValueFrom = __commonJS({
         source.subscribe(subscriber);
       });
     }
-    exports.firstValueFrom = firstValueFrom3;
+    exports.firstValueFrom = firstValueFrom5;
   }
 });
 
@@ -3799,7 +3799,7 @@ var require_map = __commonJS({
     exports.map = void 0;
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function map3(project, thisArg) {
+    function map5(project, thisArg) {
       return lift_1.operate(function(source, subscriber) {
         var index = 0;
         source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
@@ -3807,7 +3807,7 @@ var require_map = __commonJS({
         }));
       });
     }
-    exports.map = map3;
+    exports.map = map5;
   }
 });
 
@@ -4657,7 +4657,7 @@ var require_timer = __commonJS({
     var async_1 = require_async();
     var isScheduler_1 = require_isScheduler();
     var isDate_1 = require_isDate();
-    function timer3(dueTime, intervalOrScheduler, scheduler) {
+    function timer5(dueTime, intervalOrScheduler, scheduler) {
       if (dueTime === void 0) {
         dueTime = 0;
       }
@@ -4690,7 +4690,7 @@ var require_timer = __commonJS({
         }, due);
       });
     }
-    exports.timer = timer3;
+    exports.timer = timer5;
   }
 });
 
@@ -4890,7 +4890,7 @@ var require_race = __commonJS({
     var innerFrom_1 = require_innerFrom();
     var argsOrArgArray_1 = require_argsOrArgArray();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function race3() {
+    function race5() {
       var sources = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         sources[_i] = arguments[_i];
@@ -4898,7 +4898,7 @@ var require_race = __commonJS({
       sources = argsOrArgArray_1.argsOrArgArray(sources);
       return sources.length === 1 ? innerFrom_1.innerFrom(sources[0]) : new Observable_1.Observable(raceInit(sources));
     }
-    exports.race = race3;
+    exports.race = race5;
     function raceInit(sources) {
       return function(subscriber) {
         var subscriptions = [];
@@ -9468,14 +9468,14 @@ var require_race2 = __commonJS({
     exports.race = void 0;
     var argsOrArgArray_1 = require_argsOrArgArray();
     var raceWith_1 = require_raceWith();
-    function race3() {
+    function race5() {
       var args = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
       }
       return raceWith_1.raceWith.apply(void 0, __spreadArray([], __read(argsOrArgArray_1.argsOrArgArray(args))));
     }
-    exports.race = race3;
+    exports.race = race5;
   }
 });
 
@@ -9966,11 +9966,9 @@ var import_rxjs = __toESM(require_cjs(), 1);
 var import_operators = __toESM(require_operators(), 1);
 import { EventQuery } from "@semiont/event-sourcing";
 import { didToAgent, burstBuffer } from "@semiont/core";
-import { resourceId as makeResourceId, findBodyItem } from "@semiont/core";
-import { toResourceUri, toAnnotationUri } from "@semiont/event-sourcing";
+import { resourceId as makeResourceId, annotationId as makeAnnotationId, findBodyItem } from "@semiont/core";
 var GraphDBConsumer = class _GraphDBConsumer {
-  constructor(config, eventStore, graphDb, logger) {
-    this.config = config;
+  constructor(eventStore, graphDb, logger) {
     this.eventStore = eventStore;
     this.graphDb = graphDb;
     this.logger = logger;
@@ -10163,13 +10161,9 @@ var GraphDBConsumer = class _GraphDBConsumer {
     if (!event.resourceId) {
       throw new Error("resource.created requires resourceId");
     }
-    const resourceUri = toResourceUri(
-      { baseUrl: this.config.services.backend.publicURL },
-      event.resourceId
-    );
     return {
       "@context": "https://schema.org/",
-      "@id": resourceUri,
+      "@id": event.resourceId,
       name: event.payload.name,
       entityTypes: event.payload.entityTypes || [],
       representations: [{
@@ -10203,13 +10197,13 @@ var GraphDBConsumer = class _GraphDBConsumer {
       }
       case "resource.archived":
         if (!event.resourceId) throw new Error("resource.archived requires resourceId");
-        await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+        await graphDb.updateResource(makeResourceId(event.resourceId), {
           archived: true
         });
         break;
       case "resource.unarchived":
         if (!event.resourceId) throw new Error("resource.unarchived requires resourceId");
-        await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+        await graphDb.updateResource(makeResourceId(event.resourceId), {
           archived: false
         });
         break;
@@ -10226,7 +10220,7 @@ var GraphDBConsumer = class _GraphDBConsumer {
         });
         break;
       case "annotation.removed":
-        await graphDb.deleteAnnotation(toAnnotationUri({ baseUrl: this.config.services.backend.publicURL }, event.payload.annotationId));
+        await graphDb.deleteAnnotation(makeAnnotationId(event.payload.annotationId));
         break;
       case "annotation.body.updated":
         this.logger.debug("Processing annotation.body.updated event", {
@@ -10234,8 +10228,8 @@ var GraphDBConsumer = class _GraphDBConsumer {
           payload: event.payload
         });
         try {
-          const annotationUri = toAnnotationUri({ baseUrl: this.config.services.backend.publicURL }, event.payload.annotationId);
-          const currentAnnotation = await graphDb.getAnnotation(annotationUri);
+          const annId = makeAnnotationId(event.payload.annotationId);
+          const currentAnnotation = await graphDb.getAnnotation(annId);
           if (currentAnnotation) {
             let bodyArray = Array.isArray(currentAnnotation.body) ? [...currentAnnotation.body] : currentAnnotation.body ? [currentAnnotation.body] : [];
             for (const op of event.payload.operations) {
@@ -10256,7 +10250,7 @@ var GraphDBConsumer = class _GraphDBConsumer {
                 }
               }
             }
-            await graphDb.updateAnnotation(annotationUri, {
+            await graphDb.updateAnnotation(annId, {
               body: bodyArray
             });
             this.logger.info("updateAnnotation completed successfully");
@@ -10274,9 +10268,10 @@ var GraphDBConsumer = class _GraphDBConsumer {
       case "entitytag.added":
         if (!event.resourceId) throw new Error("entitytag.added requires resourceId");
         {
-          const doc = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
+          const rid = makeResourceId(event.resourceId);
+          const doc = await graphDb.getResource(rid);
           if (doc) {
-            await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+            await graphDb.updateResource(rid, {
               entityTypes: [...doc.entityTypes || [], event.payload.entityType]
             });
           }
@@ -10285,9 +10280,10 @@ var GraphDBConsumer = class _GraphDBConsumer {
       case "entitytag.removed":
         if (!event.resourceId) throw new Error("entitytag.removed requires resourceId");
         {
-          const doc = await graphDb.getResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId));
+          const rid = makeResourceId(event.resourceId);
+          const doc = await graphDb.getResource(rid);
           if (doc) {
-            await graphDb.updateResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, event.resourceId), {
+            await graphDb.updateResource(rid, {
               entityTypes: (doc.entityTypes || []).filter((t) => t !== event.payload.entityType)
             });
           }
@@ -10304,20 +10300,20 @@ var GraphDBConsumer = class _GraphDBConsumer {
    * Rebuild entire resource from events.
    * Bypasses the live pipeline — reads directly from event store.
    */
-  async rebuildResource(resourceId2) {
+  async rebuildResource(resourceId4) {
     const graphDb = this.ensureInitialized();
-    this.logger.info("Rebuilding resource from events", { resourceId: resourceId2 });
+    this.logger.info("Rebuilding resource from events", { resourceId: resourceId4 });
     try {
-      await graphDb.deleteResource(toResourceUri({ baseUrl: this.config.services.backend.publicURL }, makeResourceId(resourceId2)));
+      await graphDb.deleteResource(resourceId4);
     } catch (error) {
-      this.logger.debug("No existing resource to delete", { resourceId: resourceId2 });
+      this.logger.debug("No existing resource to delete", { resourceId: resourceId4 });
     }
     const query = new EventQuery(this.eventStore.log.storage);
-    const events = await query.getResourceEvents(resourceId2);
+    const events = await query.getResourceEvents(resourceId4);
     for (const storedEvent of events) {
       await this.applyEventToGraph(storedEvent);
     }
-    this.logger.info("Resource rebuild complete", { resourceId: resourceId2, eventCount: events.length });
+    this.logger.info("Resource rebuild complete", { resourceId: resourceId4, eventCount: events.length });
   }
   /**
    * Rebuild entire GraphDB from all events.
@@ -10333,8 +10329,8 @@ var GraphDBConsumer = class _GraphDBConsumer {
     const allResourceIds = await this.eventStore.log.getAllResourceIds();
     this.logger.info("Found resources to rebuild", { count: allResourceIds.length });
     this.logger.info("PASS 1: Creating all nodes (resources + annotations)");
-    for (const resourceId2 of allResourceIds) {
-      const events = await query.getResourceEvents(makeResourceId(resourceId2));
+    for (const resourceId4 of allResourceIds) {
+      const events = await query.getResourceEvents(makeResourceId(resourceId4));
       for (const storedEvent of events) {
         if (storedEvent.event.type === "annotation.body.updated") {
           continue;
@@ -10344,8 +10340,8 @@ var GraphDBConsumer = class _GraphDBConsumer {
     }
     this.logger.info("Pass 1 complete - all nodes created");
     this.logger.info("PASS 2: Creating all REFERENCES edges");
-    for (const resourceId2 of allResourceIds) {
-      const events = await query.getResourceEvents(makeResourceId(resourceId2));
+    for (const resourceId4 of allResourceIds) {
+      const events = await query.getResourceEvents(makeResourceId(resourceId4));
       for (const storedEvent of events) {
         if (storedEvent.event.type === "annotation.body.updated") {
           await this.applyEventToGraph(storedEvent);
@@ -10387,7 +10383,10 @@ async function bootstrapEntityTypes(eventBus, config, logger) {
     logger?.debug("Entity types bootstrap already completed, skipping");
     return;
   }
-  const configuredPath = config.services.filesystem.path;
+  const configuredPath = config.services.filesystem?.path;
+  if (!configuredPath) {
+    throw new Error("services.filesystem.path is required for entity types bootstrap");
+  }
   const projectRoot = config._metadata?.projectRoot;
   let basePath;
   if (path.isAbsolute(configuredPath)) {
@@ -10451,13 +10450,12 @@ function createKnowledgeBase(eventStore, basePath, projectRoot, graphDb, logger)
 // src/gatherer.ts
 var import_rxjs3 = __toESM(require_cjs(), 1);
 var import_operators3 = __toESM(require_operators(), 1);
-import { annotationUri as makeAnnotationUri, uriToResourceId as uriToResourceId2, resourceId as makeResourceId3 } from "@semiont/core";
+import { annotationId as makeAnnotationId2, resourceId } from "@semiont/core";
 import { EventQuery as EventQuery2 } from "@semiont/event-sourcing";
 import { getResourceEntityTypes as getResourceEntityTypes4, getBodySource as getBodySource2 } from "@semiont/api-client";
 import { getEntityTypes as getEntityTypes2 } from "@semiont/ontology";
 
 // src/generation/resource-generation.ts
-import { getLocaleEnglishName } from "@semiont/api-client";
 async function generateResourceSummary(resourceName, content, entityTypes, client) {
   const truncatedContent = content.length > 2e3 ? content.substring(0, 2e3) + "..." : content;
   const prompt = `Create a brief, intelligent summary of this resource titled "${resourceName}".
@@ -10483,6 +10481,7 @@ Format as a simple list, one suggestion per line.`;
 // src/annotation-context.ts
 import {
   getBodySource,
+  getResourceId,
   getTargetSource,
   getTargetSelector,
   getResourceEntityTypes,
@@ -10490,7 +10489,7 @@ import {
   getPrimaryRepresentation as getPrimaryRepresentation2,
   decodeRepresentation as decodeRepresentation2
 } from "@semiont/api-client";
-import { resourceId as createResourceId, uriToResourceId } from "@semiont/core";
+import { resourceId as createResourceId } from "@semiont/core";
 import { getEntityTypes } from "@semiont/ontology";
 
 // src/resource-context.ts
@@ -10499,8 +10498,8 @@ var ResourceContext = class {
   /**
    * Get resource metadata from view storage
    */
-  static async getResourceMetadata(resourceId2, kb) {
-    const view = await kb.views.get(resourceId2);
+  static async getResourceMetadata(resourceId4, kb) {
+    const view = await kb.views.get(resourceId4);
     if (!view) {
       return null;
     }
@@ -10572,7 +10571,7 @@ var AnnotationContext = class {
   /**
    * Build LLM context for an annotation
    *
-   * @param annotationUri - Full annotation URI (e.g., http://localhost:4000/annotations/abc123)
+   * @param annotationId - Bare annotation ID
    * @param resourceId - Source resource ID
    * @param kb - Knowledge base stores
    * @param options - Context building options
@@ -10580,7 +10579,7 @@ var AnnotationContext = class {
    * @returns Rich context for LLM processing
    * @throws Error if annotation or resource not found
    */
-  static async buildLLMContext(annotationUri, resourceId2, kb, options = {}, inferenceClient, logger) {
+  static async buildLLMContext(annotationId2, resourceId4, kb, options = {}, inferenceClient, logger) {
     const {
       includeSourceContext = true,
       includeTargetContext = true,
@@ -10589,47 +10588,41 @@ var AnnotationContext = class {
     if (contextWindow < 100 || contextWindow > 5e3) {
       throw new Error("contextWindow must be between 100 and 5000");
     }
-    logger?.debug("Building LLM context", { annotationUri, resourceId: resourceId2 });
-    logger?.debug("Getting view for resource", { resourceId: resourceId2 });
+    logger?.debug("Building LLM context", { annotationId: annotationId2, resourceId: resourceId4 });
+    logger?.debug("Getting view for resource", { resourceId: resourceId4 });
     let sourceView;
     try {
-      sourceView = await kb.views.get(resourceId2);
+      sourceView = await kb.views.get(resourceId4);
       logger?.debug("Retrieved view", { hasView: !!sourceView });
       if (!sourceView) {
         throw new Error("Source resource not found");
       }
     } catch (error) {
-      logger?.error("Error getting view", { resourceId: resourceId2, error });
+      logger?.error("Error getting view", { resourceId: resourceId4, error });
       throw error;
     }
     logger?.debug("Looking for annotation in resource", {
-      annotationUri,
-      resourceId: resourceId2,
+      annotationId: annotationId2,
+      resourceId: resourceId4,
       totalAnnotations: sourceView.annotations.annotations.length,
       firstFiveIds: sourceView.annotations.annotations.slice(0, 5).map((a) => a.id)
     });
-    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationUri);
+    const annotation = sourceView.annotations.annotations.find((a) => a.id === annotationId2);
     logger?.debug("Annotation search result", { found: !!annotation });
     if (!annotation) {
       throw new Error("Annotation not found in view");
     }
     const targetSource = getTargetSource(annotation.target);
-    const targetResourceId = targetSource.split("/").pop();
-    logger?.debug("Validating target resource", { targetSource, expectedResourceId: resourceId2, extractedId: targetResourceId });
-    if (targetResourceId !== resourceId2) {
-      throw new Error(`Annotation target resource ID (${targetResourceId}) does not match expected resource ID (${resourceId2})`);
+    logger?.debug("Validating target resource", { targetSource, expectedResourceId: resourceId4 });
+    if (targetSource !== String(resourceId4)) {
+      throw new Error(`Annotation target resource ID (${targetSource}) does not match expected resource ID (${resourceId4})`);
     }
     const sourceDoc = sourceView.resource;
     const bodySource = getBodySource(annotation.body);
     let targetDoc = null;
     if (bodySource) {
-      const parts = bodySource.split("/");
-      const lastPart = parts[parts.length - 1];
-      if (!lastPart) {
-        throw new Error(`Invalid body source URI: ${bodySource}`);
-      }
-      const targetResourceId2 = createResourceId(lastPart);
-      const targetView = await kb.views.get(targetResourceId2);
+      const targetResourceId = createResourceId(bodySource);
+      const targetView = await kb.views.get(targetResourceId);
       targetDoc = targetView?.resource || null;
     }
     let sourceContext;
@@ -10686,7 +10679,83 @@ var AnnotationContext = class {
       }
     }
     const suggestedResolution = void 0;
+    logger?.debug("Building graph context", { resourceId: resourceId4 });
+    const [connections, referencedByAnnotations, entityTypeStats] = await Promise.all([
+      kb.graph.getResourceConnections(resourceId4),
+      kb.graph.getResourceReferencedBy(resourceId4),
+      kb.graph.getEntityTypeStats()
+    ]);
+    const citedByMap = /* @__PURE__ */ new Map();
+    for (const ann of referencedByAnnotations) {
+      const source = getTargetSource(ann.target);
+      if (source && source !== String(resourceId4)) {
+        const sourceResId = createResourceId(source);
+        const sourceView2 = await kb.views.get(sourceResId);
+        if (sourceView2?.resource) {
+          citedByMap.set(source, sourceView2.resource.name);
+        }
+      }
+    }
+    const annotationEntityTypes = getEntityTypes(annotation);
+    const siblingEntityTypes = /* @__PURE__ */ new Set();
+    for (const ann of sourceView.annotations.annotations) {
+      if (ann.id !== annotationId2) {
+        for (const et of getEntityTypes(ann)) {
+          siblingEntityTypes.add(et);
+        }
+      }
+    }
+    const entityTypeFrequencies = {};
+    for (const stat of entityTypeStats) {
+      entityTypeFrequencies[stat.type] = stat.count;
+    }
+    let inferredRelationshipSummary;
+    if (inferenceClient && sourceContext) {
+      try {
+        const connNames = connections.map((c) => c.targetResource.name).slice(0, 10);
+        const citedByNames = Array.from(citedByMap.values()).slice(0, 5);
+        const siblingTypes = Array.from(siblingEntityTypes).slice(0, 10);
+        const parts = [];
+        parts.push(`Passage: "${sourceContext.selected}"`);
+        if (connNames.length > 0) parts.push(`Connected resources: ${connNames.join(", ")}`);
+        if (citedByNames.length > 0) parts.push(`Cited by: ${citedByNames.join(", ")}`);
+        if (siblingTypes.length > 0) parts.push(`Sibling entity types: ${siblingTypes.join(", ")}`);
+        if (annotationEntityTypes.length > 0) parts.push(`Annotation entity types: ${annotationEntityTypes.join(", ")}`);
+        const relationshipPrompt = `Given this annotation passage and its knowledge graph neighborhood, write a 1-2 sentence summary of how this passage relates to its surrounding resources and what kind of resource would best resolve this reference.
+
+${parts.join("\n")}
+
+Summary:`;
+        inferredRelationshipSummary = await inferenceClient.generateText(relationshipPrompt, 150, 0.3);
+        logger?.debug("Generated inferred relationship summary", { length: inferredRelationshipSummary.length });
+      } catch (error) {
+        logger?.warn("Failed to generate inferred relationship summary", { error });
+      }
+    }
+    const graphContext = {
+      connections: connections.map((conn) => ({
+        resourceId: getResourceId(conn.targetResource) ?? "",
+        resourceName: conn.targetResource.name,
+        entityTypes: getResourceEntityTypes(conn.targetResource),
+        bidirectional: conn.bidirectional
+      })),
+      citedByCount: citedByMap.size,
+      citedBy: Array.from(citedByMap.entries()).map(([id, name]) => ({
+        resourceId: id,
+        resourceName: name
+      })),
+      siblingEntityTypes: Array.from(siblingEntityTypes),
+      entityTypeFrequencies,
+      ...inferredRelationshipSummary ? { inferredRelationshipSummary } : {}
+    };
+    logger?.debug("Built graph context", {
+      connections: connections.length,
+      citedByCount: citedByMap.size,
+      siblingEntityTypes: siblingEntityTypes.size
+    });
     const generationContext = sourceContext ? {
+      annotation,
+      sourceResource: sourceDoc,
       sourceContext: {
         before: sourceContext.before || "",
         selected: sourceContext.selected,
@@ -10695,8 +10764,9 @@ var AnnotationContext = class {
       metadata: {
         resourceType: "document",
         language: sourceDoc.language,
-        entityTypes: getEntityTypes(annotation)
-      }
+        entityTypes: annotationEntityTypes
+      },
+      graphContext
     } : void 0;
     const response = {
       annotation,
@@ -10714,10 +10784,10 @@ var AnnotationContext = class {
    * Get resource annotations from view storage (fast path)
    * Throws if view missing
    */
-  static async getResourceAnnotations(resourceId2, kb) {
-    const view = await kb.views.get(resourceId2);
+  static async getResourceAnnotations(resourceId4, kb) {
+    const view = await kb.views.get(resourceId4);
     if (!view) {
-      throw new Error(`Resource ${resourceId2} not found in view storage`);
+      throw new Error(`Resource ${resourceId4} not found in view storage`);
     }
     return view.annotations;
   }
@@ -10725,8 +10795,8 @@ var AnnotationContext = class {
    * Get all annotations
    * @returns Array of all annotation objects
    */
-  static async getAllAnnotations(resourceId2, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId2, kb);
+  static async getAllAnnotations(resourceId4, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId4, kb);
     return await this.enrichResolvedReferences(annotations.annotations, kb);
   }
   /**
@@ -10735,28 +10805,26 @@ var AnnotationContext = class {
    * @private
    */
   static async enrichResolvedReferences(annotations, kb) {
-    const resolvedUris = /* @__PURE__ */ new Set();
+    const resolvedIds = /* @__PURE__ */ new Set();
     for (const ann of annotations) {
       if (ann.motivation === "linking" && ann.body) {
         const body = Array.isArray(ann.body) ? ann.body : [ann.body];
         for (const item of body) {
           if (item.type === "SpecificResource" && item.purpose === "linking" && item.source) {
-            resolvedUris.add(item.source);
+            resolvedIds.add(item.source);
           }
         }
       }
     }
-    if (resolvedUris.size === 0) {
+    if (resolvedIds.size === 0) {
       return annotations;
     }
-    const metadataPromises = Array.from(resolvedUris).map(async (uri) => {
-      const docId = uri.split("/resources/")[1];
-      if (!docId) return null;
+    const metadataPromises = Array.from(resolvedIds).map(async (id) => {
       try {
-        const view = await kb.views.get(docId);
+        const view = await kb.views.get(id);
         if (view?.resource?.name) {
           return {
-            uri,
+            id,
             metadata: {
               name: view.resource.name,
               mediaType: view.resource.mediaType
@@ -10768,10 +10836,10 @@ var AnnotationContext = class {
       return null;
     });
     const results = await Promise.all(metadataPromises);
-    const uriToMetadata = /* @__PURE__ */ new Map();
+    const idToMetadata = /* @__PURE__ */ new Map();
     for (const result of results) {
       if (result) {
-        uriToMetadata.set(result.uri, result.metadata);
+        idToMetadata.set(result.id, result.metadata);
       }
     }
     return annotations.map((ann) => {
@@ -10779,7 +10847,7 @@ var AnnotationContext = class {
         const body = Array.isArray(ann.body) ? ann.body : [ann.body];
         for (const item of body) {
           if (item.type === "SpecificResource" && item.purpose === "linking" && item.source) {
-            const metadata = uriToMetadata.get(item.source);
+            const metadata = idToMetadata.get(item.source);
             if (metadata) {
               return {
                 ...ann,
@@ -10797,8 +10865,8 @@ var AnnotationContext = class {
    * Get resource stats (version info)
    * @returns Version and timestamp info for the annotations
    */
-  static async getResourceStats(resourceId2, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId2, kb);
+  static async getResourceStats(resourceId4, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId4, kb);
     return {
       resourceId: annotations.resourceId,
       version: annotations.version,
@@ -10808,19 +10876,16 @@ var AnnotationContext = class {
   /**
    * Check if resource exists in view storage
    */
-  static async resourceExists(resourceId2, kb) {
-    return await kb.views.exists(resourceId2);
+  static async resourceExists(resourceId4, kb) {
+    return await kb.views.exists(resourceId4);
   }
   /**
    * Get a single annotation by ID
    * O(1) lookup using resource ID to access view storage
    */
-  static async getAnnotation(annotationId2, resourceId2, kb) {
-    const annotations = await this.getResourceAnnotations(resourceId2, kb);
-    return annotations.annotations.find((a) => {
-      const shortId = a.id.split("/").pop();
-      return shortId === annotationId2;
-    }) || null;
+  static async getAnnotation(annotationId2, resourceId4, kb) {
+    const annotations = await this.getResourceAnnotations(resourceId4, kb);
+    return annotations.annotations.find((a) => a.id === annotationId2) || null;
   }
   /**
    * List annotations with optional filtering
@@ -10836,13 +10901,13 @@ var AnnotationContext = class {
   /**
    * Get annotation context (selected text with surrounding context)
    */
-  static async getAnnotationContext(annotationId2, resourceId2, contextBefore, contextAfter, kb) {
-    const annotation = await this.getAnnotation(annotationId2, resourceId2, kb);
+  static async getAnnotationContext(annotationId2, resourceId4, contextBefore, contextAfter, kb) {
+    const annotation = await this.getAnnotation(annotationId2, resourceId4, kb);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
     const resource = await ResourceContext.getResourceMetadata(
-      uriToResourceId(getTargetSource(annotation.target)),
+      createResourceId(getTargetSource(annotation.target)),
       kb
     );
     if (!resource) {
@@ -10869,13 +10934,13 @@ var AnnotationContext = class {
   /**
    * Generate AI summary of annotation in context
    */
-  static async generateAnnotationSummary(annotationId2, resourceId2, kb, inferenceClient) {
-    const annotation = await this.getAnnotation(annotationId2, resourceId2, kb);
+  static async generateAnnotationSummary(annotationId2, resourceId4, kb, inferenceClient) {
+    const annotation = await this.getAnnotation(annotationId2, resourceId4, kb);
     if (!annotation) {
       throw new Error("Annotation not found");
     }
     const resource = await ResourceContext.getResourceMetadata(
-      uriToResourceId(getTargetSource(annotation.target)),
+      createResourceId(getTargetSource(annotation.target)),
       kb
     );
     if (!resource) {
@@ -10950,16 +11015,14 @@ Entity types: ${entityTypes.join(", ")}`;
 };
 
 // src/graph-context.ts
-import { resourceIdToURI } from "@semiont/core";
-import { getResourceId, getResourceEntityTypes as getResourceEntityTypes2 } from "@semiont/api-client";
+import { getResourceId as getResourceId2, getResourceEntityTypes as getResourceEntityTypes2 } from "@semiont/api-client";
 var GraphContext = class {
   /**
    * Get all resources referencing this resource (backlinks)
    * Requires graph traversal - must use graph database
    */
-  static async getBacklinks(resourceId2, kb, publicURL) {
-    const resourceUri = resourceIdToURI(resourceId2, publicURL);
-    return await kb.graph.getResourceReferencedBy(resourceUri);
+  static async getBacklinks(resourceId4, kb) {
+    return await kb.graph.getResourceReferencedBy(resourceId4);
   }
   /**
    * Find shortest path between two resources
@@ -10972,8 +11035,8 @@ var GraphContext = class {
    * Get resource connections (graph edges)
    * Requires graph traversal - must use graph database
    */
-  static async getResourceConnections(resourceId2, kb) {
-    return await kb.graph.getResourceConnections(resourceId2);
+  static async getResourceConnections(resourceId4, kb) {
+    return await kb.graph.getResourceConnections(resourceId4);
   }
   /**
    * Search resources by name (cross-resource query)
@@ -10986,31 +11049,30 @@ var GraphContext = class {
    * Build graph representation with nodes and edges for a resource and its connections
    * Retrieves connections from graph and builds visualization-ready structure
    */
-  static async buildGraphRepresentation(resourceId2, maxRelated, kb, publicURL) {
-    const resourceUri = resourceIdToURI(resourceId2, publicURL);
-    const mainDoc = await kb.graph.getResource(resourceUri);
+  static async buildGraphRepresentation(resourceId4, maxRelated, kb) {
+    const mainDoc = await kb.graph.getResource(resourceId4);
     if (!mainDoc) {
       throw new Error("Resource not found");
     }
-    const connections = await kb.graph.getResourceConnections(resourceId2);
+    const connections = await kb.graph.getResourceConnections(resourceId4);
     const relatedDocs = connections.map((conn) => conn.targetResource).slice(0, maxRelated - 1);
     const nodes = [
       {
-        id: getResourceId(mainDoc),
+        id: getResourceId2(mainDoc),
         type: "resource",
         label: mainDoc.name,
         metadata: { entityTypes: getResourceEntityTypes2(mainDoc) }
       },
       ...relatedDocs.map((doc) => ({
-        id: getResourceId(doc),
+        id: getResourceId2(doc),
         type: "resource",
         label: doc.name,
         metadata: { entityTypes: getResourceEntityTypes2(doc) }
       }))
     ].filter((node) => node.id !== void 0);
     const edges = connections.slice(0, maxRelated - 1).map((conn) => ({
-      source: resourceId2,
-      target: getResourceId(conn.targetResource),
+      source: resourceId4,
+      target: getResourceId2(conn.targetResource),
       type: conn.relationshipType || "link",
       metadata: {}
     })).filter((edge) => edge.target !== void 0);
@@ -11019,27 +11081,26 @@ var GraphContext = class {
 };
 
 // src/llm-context.ts
-import { getResourceEntityTypes as getResourceEntityTypes3, getResourceId as getResourceId2 } from "@semiont/api-client";
+import { getResourceEntityTypes as getResourceEntityTypes3, getResourceId as getResourceId3 } from "@semiont/api-client";
 import { resourceId as makeResourceId2 } from "@semiont/core";
 var LLMContext = class {
   /**
    * Get comprehensive LLM context for a resource
    * Includes: main resource, related resources, annotations, graph, content, summary, references
    */
-  static async getResourceContext(resourceId2, options, kb, publicURL, inferenceClient) {
-    const mainDoc = await ResourceContext.getResourceMetadata(resourceId2, kb);
+  static async getResourceContext(resourceId4, options, kb, inferenceClient) {
+    const mainDoc = await ResourceContext.getResourceMetadata(resourceId4, kb);
     if (!mainDoc) {
       throw new Error("Resource not found");
     }
     const mainContent = options.includeContent ? await ResourceContext.getResourceContent(mainDoc, kb) : void 0;
     const graph = await GraphContext.buildGraphRepresentation(
-      resourceId2,
+      resourceId4,
       options.maxResources,
-      kb,
-      publicURL
+      kb
     );
     const relatedDocs = [];
-    const resourceIdStr = resourceId2.toString();
+    const resourceIdStr = resourceId4.toString();
     for (const node of graph.nodes) {
       if (node.id !== resourceIdStr) {
         const relatedDoc = await ResourceContext.getResourceMetadata(makeResourceId2(node.id), kb);
@@ -11052,7 +11113,7 @@ var LLMContext = class {
     if (options.includeContent) {
       await Promise.all(
         relatedDocs.map(async (doc) => {
-          const docId = getResourceId2(doc);
+          const docId = getResourceId3(doc);
           if (!docId) return;
           const content = await ResourceContext.getResourceContent(doc, kb);
           if (content) {
@@ -11061,7 +11122,7 @@ var LLMContext = class {
         })
       );
     }
-    const annotations = await AnnotationContext.getAllAnnotations(resourceId2, kb);
+    const annotations = await AnnotationContext.getAllAnnotations(resourceId4, kb);
     const summary = options.includeSummary && mainContent ? await generateResourceSummary(
       mainDoc.name,
       mainContent,
@@ -11086,7 +11147,10 @@ var LLMContext = class {
 import { promises as fs2 } from "fs";
 import * as path2 from "path";
 async function readEntityTypesProjection(config) {
-  const configuredPath = config.services.filesystem.path;
+  const configuredPath = config.services.filesystem?.path;
+  if (!configuredPath) {
+    throw new Error("services.filesystem.path is required for entity types reader");
+  }
   const projectRoot = config._metadata?.projectRoot;
   let basePath;
   if (path2.isAbsolute(configuredPath)) {
@@ -11116,8 +11180,7 @@ async function readEntityTypesProjection(config) {
 
 // src/gatherer.ts
 var Gatherer = class {
-  constructor(publicURL, kb, eventBus, inferenceClient, logger, config) {
-    this.publicURL = publicURL;
+  constructor(kb, eventBus, inferenceClient, logger, config) {
     this.kb = kb;
     this.eventBus = eventBus;
     this.inferenceClient = inferenceClient;
@@ -11130,7 +11193,7 @@ var Gatherer = class {
     this.logger.info("Gatherer actor initialized");
     const errorHandler = (err) => this.logger.error("Gatherer pipeline error", { error: err });
     const annotationGather$ = this.eventBus.get("gather:requested").pipe(
-      (0, import_operators3.groupBy)((event) => event.resourceUri),
+      (0, import_operators3.groupBy)((event) => event.resourceId),
       (0, import_operators3.mergeMap)(
         (group$) => group$.pipe(
           (0, import_operators3.concatMap)((event) => (0, import_rxjs3.from)(this.handleAnnotationGather(event)))
@@ -11138,7 +11201,7 @@ var Gatherer = class {
       )
     );
     const resourceGather$ = this.eventBus.get("gather:resource-requested").pipe(
-      (0, import_operators3.groupBy)((event) => event.resourceUri),
+      (0, import_operators3.groupBy)((event) => event.resourceId),
       (0, import_operators3.mergeMap)(
         (group$) => group$.pipe(
           (0, import_operators3.concatMap)((event) => (0, import_rxjs3.from)(this.handleResourceGather(event)))
@@ -11184,28 +11247,28 @@ var Gatherer = class {
   async handleAnnotationGather(event) {
     try {
       this.logger.debug("Gathering annotation context", {
-        annotationUri: event.annotationUri,
-        resourceUri: event.resourceUri
+        annotationId: event.annotationId,
+        resourceId: event.resourceId
       });
       const response = await AnnotationContext.buildLLMContext(
-        makeAnnotationUri(event.annotationUri),
-        uriToResourceId2(event.resourceUri),
+        makeAnnotationId2(event.annotationId),
+        event.resourceId,
         this.kb,
         event.options ?? {},
         this.inferenceClient,
         this.logger
       );
       this.eventBus.get("gather:complete").next({
-        annotationUri: event.annotationUri,
+        annotationId: event.annotationId,
         response
       });
     } catch (error) {
       this.logger.error("Gather annotation context failed", {
-        annotationUri: event.annotationUri,
+        annotationId: event.annotationId,
         error
       });
       this.eventBus.get("gather:failed").next({
-        annotationUri: event.annotationUri,
+        annotationId: event.annotationId,
         error: error instanceof Error ? error : new Error(String(error))
       });
     }
@@ -11213,27 +11276,25 @@ var Gatherer = class {
   async handleResourceGather(event) {
     try {
       this.logger.debug("Gathering resource context", {
-        resourceUri: event.resourceUri
+        resourceId: event.resourceId
       });
-      const publicURL = this.publicURL;
       const result = await LLMContext.getResourceContext(
-        uriToResourceId2(event.resourceUri),
+        event.resourceId,
         event.options,
         this.kb,
-        publicURL,
         this.inferenceClient
       );
       this.eventBus.get("gather:resource-complete").next({
-        resourceUri: event.resourceUri,
+        resourceId: event.resourceId,
         context: result
       });
     } catch (error) {
       this.logger.error("Gather resource context failed", {
-        resourceUri: event.resourceUri,
+        resourceId: event.resourceId,
         error
       });
       this.eventBus.get("gather:resource-failed").next({
-        resourceUri: event.resourceUri,
+        resourceId: event.resourceId,
         error: error instanceof Error ? error : new Error(String(error))
       });
     }
@@ -11336,8 +11397,7 @@ var Gatherer = class {
       let resolvedResource = null;
       const bodySource = getBodySource2(annotation.body);
       if (bodySource) {
-        const resolvedId = bodySource.split("/").pop();
-        resolvedResource = await ResourceContext.getResourceMetadata(makeResourceId3(resolvedId), this.kb);
+        resolvedResource = await ResourceContext.getResourceMetadata(resourceId(bodySource), this.kb);
       }
       this.eventBus.get("browse:annotation-result").next({
         correlationId: event.correlationId,
@@ -11457,7 +11517,7 @@ var Gatherer = class {
   async handleEntityTypes(event) {
     try {
       if (!this.config) {
-        throw new Error("EnvironmentConfig required for entity type reads");
+        throw new Error("MakeMeaningConfig required for entity type reads");
       }
       const entityTypes = await readEntityTypesProjection(this.config);
       this.eventBus.get("mark:entity-types-result").next({
@@ -11484,13 +11544,13 @@ var Gatherer = class {
 // src/binder.ts
 var import_rxjs4 = __toESM(require_cjs(), 1);
 var import_operators4 = __toESM(require_operators(), 1);
-import { resourceIdToURI as resourceIdToURI2, resourceUri as makeResourceUri } from "@semiont/core";
-import { getExactText, getTargetSource as getTargetSource2, getTargetSelector as getTargetSelector2 } from "@semiont/api-client";
+import { resourceId as resourceId2 } from "@semiont/core";
+import { getExactText, getResourceId as getResourceId4, getResourceEntityTypes as getResourceEntityTypes5, getTargetSource as getTargetSource2, getTargetSelector as getTargetSelector2 } from "@semiont/api-client";
 var Binder = class {
-  constructor(kb, eventBus, logger, publicURL) {
+  constructor(kb, eventBus, logger, inferenceClient) {
     this.kb = kb;
     this.eventBus = eventBus;
-    this.publicURL = publicURL;
+    this.inferenceClient = inferenceClient;
     this.logger = logger;
   }
   subscriptions = [];
@@ -11511,15 +11571,24 @@ var Binder = class {
   }
   async handleSearch(event) {
     try {
+      const context = event.context;
+      const searchTerm = context.sourceContext?.selected ?? "";
       this.logger.debug("Searching for binding candidates", {
         referenceId: event.referenceId,
-        searchTerm: event.searchTerm
-      });
-      const results = await this.kb.graph.searchResources(event.searchTerm);
+        searchTerm,
+        limit: event.limit,
+        useSemanticScoring: event.useSemanticScoring
+      });
+      const scored = await this.contextDrivenSearch(
+        searchTerm,
+        context,
+        event.useSemanticScoring
+      );
+      const limited = event.limit ? scored.slice(0, event.limit) : scored;
       this.eventBus.get("bind:search-results").next({
         referenceId: event.referenceId,
-        searchTerm: event.searchTerm,
-        results
+        results: limited,
+        correlationId: event.correlationId
       });
     } catch (error) {
       this.logger.error("Bind search failed", {
@@ -11528,24 +11597,240 @@ var Binder = class {
       });
       this.eventBus.get("bind:search-failed").next({
         referenceId: event.referenceId,
-        error: error instanceof Error ? error : new Error(String(error))
+        error: error instanceof Error ? error : new Error(String(error)),
+        correlationId: event.correlationId
       });
     }
   }
+  /**
+   * Context-driven search: multi-source retrieval + composite scoring
+   *
+   * Retrieval sources:
+   * 1. Name match — graph.searchResources(searchTerm)
+   * 2. Entity type match — graph.listResources({ entityTypes })
+   * 3. Graph neighborhood — connections from GatheredContext
+   *
+   * Ranking signals:
+   * - Entity type overlap (Jaccard similarity)
+   * - Bidirectionality (already connected both ways)
+   * - Citation weight (well-connected = important)
+   * - Name match quality (exact > prefix > contains)
+   * - Recency (newer resources scored higher)
+   */
+  async contextDrivenSearch(searchTerm, context, useSemanticScoring) {
+    const annotationEntityTypes = context.metadata?.entityTypes ?? [];
+    const connections = context.graphContext?.connections ?? [];
+    const [nameMatches, entityTypeMatches] = await Promise.all([
+      this.kb.graph.searchResources(searchTerm),
+      annotationEntityTypes.length > 0 ? this.kb.graph.listResources({ entityTypes: annotationEntityTypes, limit: 50 }).then((r) => r.resources) : Promise.resolve([])
+    ]);
+    const neighborResources = await Promise.all(
+      connections.map(
+        (conn) => this.kb.graph.getResource(resourceId2(conn.resourceId)).catch(() => null)
+      )
+    );
+    const candidateMap = /* @__PURE__ */ new Map();
+    const addCandidate = (resource, source) => {
+      const id = getResourceId4(resource);
+      if (!id) return;
+      const existing = candidateMap.get(id);
+      if (existing) {
+        existing.sources.add(source);
+      } else {
+        candidateMap.set(id, { resource, sources: /* @__PURE__ */ new Set([source]) });
+      }
+    };
+    for (const r of nameMatches) addCandidate(r, "name");
+    for (const r of entityTypeMatches) addCandidate(r, "entityType");
+    for (const r of neighborResources) {
+      if (r) addCandidate(r, "neighborhood");
+    }
+    this.logger.debug("Candidate retrieval", {
+      nameMatches: nameMatches.length,
+      entityTypeMatches: entityTypeMatches.length,
+      neighborResources: neighborResources.filter(Boolean).length,
+      totalCandidates: candidateMap.size
+    });
+    const connectionIds = new Set(connections.map((c) => c.resourceId));
+    const bidirectionalIds = new Set(
+      connections.filter((c) => c.bidirectional).map((c) => c.resourceId)
+    );
+    const entityTypeFreqs = context.graphContext?.entityTypeFrequencies ?? {};
+    const searchTermLower = searchTerm.toLowerCase();
+    const scored = Array.from(candidateMap.values()).map(({ resource, sources }) => {
+      const id = getResourceId4(resource) ?? "";
+      const candidateEntityTypes = getResourceEntityTypes5(resource);
+      const reasons = [];
+      let score = 0;
+      if (annotationEntityTypes.length > 0 && candidateEntityTypes.length > 0) {
+        const intersection = annotationEntityTypes.filter((t) => candidateEntityTypes.includes(t));
+        const union = /* @__PURE__ */ new Set([...annotationEntityTypes, ...candidateEntityTypes]);
+        const jaccard = intersection.length / union.size;
+        let idfBoost = 0;
+        for (const t of intersection) {
+          const freq = entityTypeFreqs[t] ?? 1;
+          idfBoost += 1 / Math.log2(freq + 1);
+        }
+        const entityScore = jaccard * 30 + idfBoost * 5;
+        score += entityScore;
+        if (intersection.length > 0) {
+          reasons.push(`entity types: ${intersection.join(", ")}`);
+        }
+      }
+      if (bidirectionalIds.has(id)) {
+        score += 20;
+        reasons.push("bidirectional connection");
+      } else if (connectionIds.has(id)) {
+        score += 10;
+        reasons.push("connected");
+      }
+      const citedByCount = context.graphContext?.citedByCount ?? 0;
+      if (sources.has("neighborhood") && citedByCount > 0) {
+        score += Math.min(citedByCount * 2, 15);
+      }
+      const nameLower = (resource.name ?? "").toLowerCase();
+      if (nameLower === searchTermLower) {
+        score += 25;
+        reasons.push("exact name match");
+      } else if (nameLower.startsWith(searchTermLower)) {
+        score += 15;
+        reasons.push("prefix name match");
+      } else if (nameLower.includes(searchTermLower)) {
+        score += 10;
+        reasons.push("contains name match");
+      }
+      const dateCreated = resource.dateCreated;
+      if (dateCreated) {
+        const ageMs = Date.now() - new Date(dateCreated).getTime();
+        const ageDays = ageMs / (1e3 * 60 * 60 * 24);
+        score += Math.max(0, 5 * (1 - ageDays / 30));
+      }
+      if (sources.size > 1) {
+        score += sources.size * 3;
+        reasons.push(`${sources.size} retrieval sources`);
+      }
+      return {
+        ...resource,
+        score: Math.round(score * 100) / 100,
+        matchReason: reasons.join("; ") || "candidate"
+      };
+    });
+    if (this.inferenceClient && scored.length > 0 && useSemanticScoring !== false) {
+      try {
+        const inferenceScores = await this.inferenceSemanticScore(
+          searchTerm,
+          context,
+          scored.slice(0, 20)
+          // Limit to top 20 candidates for cost
+        );
+        for (const item of scored) {
+          const id = getResourceId4(item) ?? "";
+          const inferenceScore = inferenceScores.get(id);
+          if (inferenceScore !== void 0) {
+            item.score += inferenceScore * 25;
+            item.score = Math.round(item.score * 100) / 100;
+            if (inferenceScore > 0.5) {
+              item.matchReason = item.matchReason ? `${item.matchReason}; semantic match` : "semantic match";
+            }
+          }
+        }
+      } catch (error) {
+        this.logger.warn("Inference semantic scoring failed, using structural scores only", { error });
+      }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    this.logger.debug("Search results scored", {
+      total: scored.length,
+      topScore: scored[0]?.score,
+      topReason: scored[0]?.matchReason
+    });
+    return scored;
+  }
+  /**
+   * LLM-based semantic relevance scoring (GraphRAG-style)
+   *
+   * Batches candidates into a single prompt asking the LLM to score
+   * each candidate's semantic relevance given the passage and graph context.
+   *
+   * @returns Map of resourceId → score (0-1)
+   */
+  async inferenceSemanticScore(searchTerm, context, candidates) {
+    if (!this.inferenceClient) return /* @__PURE__ */ new Map();
+    const passage = context.sourceContext?.selected ?? searchTerm;
+    const entityTypes = context.metadata?.entityTypes ?? [];
+    const graphConnections = context.graphContext?.connections;
+    const connections = graphConnections ?? [];
+    const candidateLines = candidates.map((c, i) => {
+      const id = getResourceId4(c) ?? "";
+      const cEntityTypes = getResourceEntityTypes5(c);
+      return `${i + 1}. "${c.name}" (id: ${id}, types: ${cEntityTypes.join(", ") || "none"})`;
+    }).join("\n");
+    const contextParts = [];
+    contextParts.push(`Annotation motivation: ${context.annotation.motivation}`);
+    contextParts.push(`Source resource: ${context.sourceResource.name}`);
+    const { motivation, body } = context.annotation;
+    if (motivation === "commenting" || motivation === "assessing") {
+      const bodyItem = Array.isArray(body) ? body[0] : body;
+      if (bodyItem && "value" in bodyItem && bodyItem.value) {
+        const label = motivation === "commenting" ? "Comment" : "Assessment";
+        contextParts.push(`${label}: ${bodyItem.value}`);
+      }
+    }
+    if (entityTypes.length > 0) contextParts.push(`Annotation entity types: ${entityTypes.join(", ")}`);
+    if (connections.length > 0) {
+      const connNames = connections.slice(0, 5).map((c) => c.resourceName);
+      contextParts.push(`Connected resources: ${connNames.join(", ")}`);
+    }
+    if (context.graphContext?.inferredRelationshipSummary) {
+      contextParts.push(`Relationship context: ${context.graphContext.inferredRelationshipSummary}`);
+    }
+    const prompt = `Given this passage and context, score each candidate resource's semantic relevance on a scale of 0.0 to 1.0.
+
+Passage: "${passage}"
+Search term: "${searchTerm}"
+${contextParts.length > 0 ? contextParts.join("\n") : ""}
+
+Candidates:
+${candidateLines}
+
+For each candidate, output ONLY a line with the number and score, like:
+1. 0.8
+2. 0.3
+No explanations.`;
+    const response = await this.inferenceClient.generateText(prompt, 200, 0.1);
+    const scores = /* @__PURE__ */ new Map();
+    const lines = response.trim().split("\n");
+    for (const line of lines) {
+      const match = line.match(/^(\d+)\.\s*([\d.]+)/);
+      if (match) {
+        const index = parseInt(match[1], 10) - 1;
+        const score = parseFloat(match[2]);
+        if (index >= 0 && index < candidates.length && !isNaN(score) && score >= 0 && score <= 1) {
+          const id = getResourceId4(candidates[index]) ?? "";
+          if (id) scores.set(id, score);
+        }
+      }
+    }
+    this.logger.debug("Inference semantic scores", {
+      candidateCount: candidates.length,
+      scoredCount: scores.size
+    });
+    return scores;
+  }
   async handleReferencedBy(event) {
     try {
-      if (!this.publicURL) {
-        throw new Error("publicURL required for referenced-by queries");
-      }
-      const resourceUri = resourceIdToURI2(event.resourceId, this.publicURL);
       this.logger.debug("Looking for annotations referencing resource", {
         resourceId: event.resourceId,
-        resourceUri,
         motivation: event.motivation || "all"
       });
-      const references = await this.kb.graph.getResourceReferencedBy(resourceUri, event.motivation);
-      const docIds = [...new Set(references.map((ref) => getTargetSource2(ref.target)))];
-      const resources = await Promise.all(docIds.map((docId) => this.kb.graph.getResource(makeResourceUri(docId))));
+      const references = await this.kb.graph.getResourceReferencedBy(event.resourceId, event.motivation);
+      const sourceIds = [...new Set(references.map((ref) => getTargetSource2(ref.target)))];
+      const resources = await Promise.all(sourceIds.map((id) => this.kb.graph.getResource(resourceId2(id))));
+      for (let i = 0; i < sourceIds.length; i++) {
+        if (resources[i] === null) {
+          this.logger.warn("Referenced resource not found in graph", { resourceId: sourceIds[i] });
+        }
+      }
       const docMap = new Map(resources.filter((doc) => doc !== null).map((doc) => [doc["@id"], doc]));
       const referencedBy = references.map((ref) => {
         const targetSource = getTargetSource2(ref.target);
@@ -11589,11 +11874,10 @@ var Binder = class {
 // src/stower.ts
 var import_rxjs5 = __toESM(require_cjs(), 1);
 var import_operators5 = __toESM(require_operators(), 1);
-import { resourceId, uriToAnnotationId, CREATION_METHODS, generateUuid } from "@semiont/core";
+import { resourceId as resourceId3, annotationId as makeAnnotationId3, CREATION_METHODS, generateUuid } from "@semiont/core";
 var Stower = class {
-  constructor(kb, publicURL, eventBus, logger) {
+  constructor(kb, eventBus, logger) {
     this.kb = kb;
-    this.publicURL = publicURL;
     this.eventBus = eventBus;
     this.logger = logger;
   }
@@ -11624,7 +11908,7 @@ var Stower = class {
   // ========================================================================
   async handleYieldCreate(event) {
     try {
-      const rId = resourceId(generateUuid());
+      const rId = resourceId3(generateUuid());
       const storedRep = await this.kb.content.store(event.content, {
         mediaType: event.format,
         language: event.language || void 0,
@@ -11650,10 +11934,9 @@ var Stower = class {
           generationPrompt: event.generationPrompt
         }
       });
-      const normalizedBase = this.publicURL.endsWith("/") ? this.publicURL.slice(0, -1) : this.publicURL;
       const resource = {
         "@context": "https://schema.org/",
-        "@id": `${normalizedBase}/resources/${rId}`,
+        "@id": rId,
         name: event.name,
         archived: false,
         entityTypes: event.entityTypes || [],
@@ -11687,7 +11970,7 @@ var Stower = class {
         version: 1,
         payload: { annotation: event.annotation }
       });
-      this.eventBus.get("mark:created").next({ annotationId: uriToAnnotationId(event.annotation.id) });
+      this.eventBus.get("mark:created").next({ annotationId: makeAnnotationId3(event.annotation.id) });
     } catch (error) {
       this.logger.error("Failed to create annotation", { error });
       this.eventBus.get("mark:create-failed").next({
@@ -11854,7 +12137,7 @@ var Stower = class {
 var import_rxjs7 = __toESM(require_cjs(), 1);
 var import_operators7 = __toESM(require_operators(), 1);
 import { CREATION_METHODS as CREATION_METHODS2, cloneToken as makeCloneToken } from "@semiont/core";
-import { getPrimaryRepresentation as getPrimaryRepresentation3, getResourceEntityTypes as getResourceEntityTypes5 } from "@semiont/api-client";
+import { getPrimaryRepresentation as getPrimaryRepresentation3, getResourceEntityTypes as getResourceEntityTypes6 } from "@semiont/api-client";
 
 // src/resource-operations.ts
 var import_rxjs6 = __toESM(require_cjs(), 1);
@@ -12062,12 +12345,12 @@ var CloneTokenManager = class {
       const mediaType = primaryRep?.mediaType || "text/plain";
       const validFormats = ["text/plain", "text/markdown"];
       const format = validFormats.includes(mediaType) ? mediaType : "text/plain";
-      const resourceId2 = await ResourceOperations.createResource(
+      const resourceId4 = await ResourceOperations.createResource(
         {
           name: event.name,
           content: Buffer.from(event.content),
           format,
-          entityTypes: getResourceEntityTypes5(sourceDoc),
+          entityTypes: getResourceEntityTypes6(sourceDoc),
           creationMethod: CREATION_METHODS2.CLONE
         },
         event.userId,
@@ -12087,7 +12370,7 @@ var CloneTokenManager = class {
       this.tokens.delete(token);
       this.eventBus.get("yield:clone-created").next({
         correlationId: event.correlationId,
-        response: { resourceId: resourceId2 }
+        response: { resourceId: resourceId4 }
       });
     } catch (error) {
       this.logger.error("Clone create failed", { token: event.token, error });
@@ -12109,14 +12392,15 @@ var CloneTokenManager = class {
 
 // src/service.ts
 async function startMakeMeaning(config, eventBus, logger) {
-  const configuredPath = config.services?.filesystem?.path;
-  if (!configuredPath) {
+  const filesystemConfig = config.services?.filesystem;
+  if (!filesystemConfig?.path) {
     throw new Error("services.filesystem.path is required for make-meaning service");
   }
-  const baseUrl = config.services?.backend?.publicURL;
-  if (!baseUrl) {
-    throw new Error("services.backend.publicURL is required for make-meaning service");
+  const graphConfig = config.services?.graph;
+  if (!graphConfig) {
+    throw new Error("services.graph is required for make-meaning service");
   }
+  const configuredPath = filesystemConfig.path;
   const projectRoot = config._metadata?.projectRoot;
   let basePath;
   if (path3.isAbsolute(configuredPath)) {
@@ -12166,30 +12450,34 @@ async function startMakeMeaning(config, eventBus, logger) {
     error: (err) => jobQueueLogger.error("Job status pipeline error", { error: err })
   });
   const eventStoreLogger = logger.child({ component: "event-store" });
-  const eventStore = createEventStoreCore(basePath, baseUrl, void 0, eventBus, eventStoreLogger);
+  const eventStore = createEventStoreCore(basePath, void 0, eventBus, eventStoreLogger);
   const inferenceLogger = logger.child({ component: "inference-client" });
-  const inferenceClient = await getInferenceClient(config, inferenceLogger);
-  const graphDb = await getGraphDatabase(config);
+  const inferenceConfig = config.services?.inference;
+  if (!inferenceConfig) {
+    throw new Error("services.inference is required for make-meaning service");
+  }
+  const inferenceClient = await getInferenceClient(inferenceConfig, inferenceLogger);
+  const graphDb = await getGraphDatabase(graphConfig);
   const kb = createKnowledgeBase(eventStore, basePath, projectRoot, graphDb, logger);
   const graphConsumerLogger = logger.child({ component: "graph-consumer" });
-  const graphConsumer = new GraphDBConsumer(config, eventStore, graphDb, graphConsumerLogger);
+  const graphConsumer = new GraphDBConsumer(eventStore, graphDb, graphConsumerLogger);
   await graphConsumer.initialize();
   const stowerLogger = logger.child({ component: "stower" });
-  const stower = new Stower(kb, baseUrl, eventBus, stowerLogger);
+  const stower = new Stower(kb, eventBus, stowerLogger);
   await stower.initialize();
   const bootstrapLogger = logger.child({ component: "entity-types-bootstrap" });
   await bootstrapEntityTypes(eventBus, config, bootstrapLogger);
   const gathererLogger = logger.child({ component: "gatherer" });
-  const gatherer = new Gatherer(baseUrl, kb, eventBus, inferenceClient, gathererLogger, config);
+  const gatherer = new Gatherer(kb, eventBus, inferenceClient, gathererLogger, config);
   await gatherer.initialize();
   const binderLogger = logger.child({ component: "binder" });
-  const binder = new Binder(kb, eventBus, binderLogger, baseUrl);
+  const binder = new Binder(kb, eventBus, binderLogger, inferenceClient);
   await binder.initialize();
   const cloneTokenLogger = logger.child({ component: "clone-token-manager" });
   const cloneTokenManager = new CloneTokenManager(kb, eventBus, cloneTokenLogger);
   await cloneTokenManager.initialize();
-  const contentFetcher = async (resourceId2) => {
-    const view = await kb.views.get(resourceId2);
+  const contentFetcher = async (resourceId4) => {
+    const view = await kb.views.get(resourceId4);
     if (!view) return null;
     const primaryRep = getPrimaryRepresentation4(view.resource);
     if (!primaryRep?.checksum || !primaryRep?.mediaType) return null;
@@ -12204,12 +12492,12 @@ async function startMakeMeaning(config, eventBus, logger) {
   const commentLogger = logger.child({ component: "comment-detection-worker" });
   const tagLogger = logger.child({ component: "tag-detection-worker" });
   const workers = {
-    detection: new ReferenceAnnotationWorker(jobQueue, config, inferenceClient, eventBus, contentFetcher, detectionLogger),
-    generation: new GenerationWorker(jobQueue, config, inferenceClient, eventBus, generationLogger),
-    highlight: new HighlightAnnotationWorker(jobQueue, config, inferenceClient, eventBus, contentFetcher, highlightLogger),
-    assessment: new AssessmentAnnotationWorker(jobQueue, config, inferenceClient, eventBus, contentFetcher, assessmentLogger),
-    comment: new CommentAnnotationWorker(jobQueue, config, inferenceClient, eventBus, contentFetcher, commentLogger),
-    tag: new TagAnnotationWorker(jobQueue, config, inferenceClient, eventBus, contentFetcher, tagLogger)
+    detection: new ReferenceAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, detectionLogger),
+    generation: new GenerationWorker(jobQueue, inferenceClient, eventBus, generationLogger),
+    highlight: new HighlightAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, highlightLogger),
+    assessment: new AssessmentAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, assessmentLogger),
+    comment: new CommentAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, commentLogger),
+    tag: new TagAnnotationWorker(jobQueue, inferenceClient, eventBus, contentFetcher, tagLogger)
   };
   workers.detection.start().catch((error) => {
     detectionLogger.error("Worker stopped unexpectedly", { error });
@@ -12263,6 +12551,858 @@ async function startMakeMeaning(config, eventBus, logger) {
   };
 }
 
+// src/exchange/backup-exporter.ts
+import { getExtensionForMimeType } from "@semiont/content";
+
+// src/exchange/tar.ts
+import { createGzip, createGunzip } from "zlib";
+import { Readable as Readable2, pipeline } from "stream";
+import { promisify } from "util";
+var pipelineAsync = promisify(pipeline);
+var BLOCK_SIZE = 512;
+function createTarHeader(name, size) {
+  const header = Buffer.alloc(BLOCK_SIZE, 0);
+  header.write(name.slice(0, 100), 0, 100, "utf8");
+  header.write("0000644\0", 100, 8, "utf8");
+  header.write("0000000\0", 108, 8, "utf8");
+  header.write("0000000\0", 116, 8, "utf8");
+  header.write(size.toString(8).padStart(11, "0") + "\0", 124, 12, "utf8");
+  const mtime = Math.floor(Date.now() / 1e3);
+  header.write(mtime.toString(8).padStart(11, "0") + "\0", 136, 12, "utf8");
+  header.write("        ", 148, 8, "utf8");
+  header.write("0", 156, 1, "utf8");
+  header.write("ustar\0", 257, 6, "utf8");
+  header.write("00", 263, 2, "utf8");
+  let checksum = 0;
+  for (let i = 0; i < BLOCK_SIZE; i++) {
+    checksum += header[i];
+  }
+  header.write(checksum.toString(8).padStart(6, "0") + "\0 ", 148, 8, "utf8");
+  return header;
+}
+function paddingBytes(size) {
+  const remainder = size % BLOCK_SIZE;
+  return remainder === 0 ? 0 : BLOCK_SIZE - remainder;
+}
+async function writeTarGz(entries, output) {
+  const gzip = createGzip();
+  const tarStream = new Readable2({ read() {
+  } });
+  const pipePromise = pipelineAsync(tarStream, gzip, output);
+  for await (const entry of entries) {
+    const header = createTarHeader(entry.name, entry.data.length);
+    tarStream.push(header);
+    tarStream.push(entry.data);
+    const pad = paddingBytes(entry.data.length);
+    if (pad > 0) {
+      tarStream.push(Buffer.alloc(pad, 0));
+    }
+  }
+  tarStream.push(Buffer.alloc(BLOCK_SIZE * 2, 0));
+  tarStream.push(null);
+  await pipePromise;
+}
+async function decompressStream(input) {
+  const gunzip = createGunzip();
+  const chunks = [];
+  return new Promise((resolve4, reject) => {
+    gunzip.on("data", (chunk) => chunks.push(chunk));
+    gunzip.on("end", () => resolve4(Buffer.concat(chunks)));
+    gunzip.on("error", reject);
+    input.on("error", reject);
+    input.pipe(gunzip);
+  });
+}
+function* parseTarEntries(decompressed) {
+  let offset = 0;
+  while (offset + BLOCK_SIZE <= decompressed.length) {
+    const header = decompressed.subarray(offset, offset + BLOCK_SIZE);
+    if (header.every((b) => b === 0)) break;
+    const nameEnd = header.indexOf(0, 0);
+    const name = header.subarray(0, Math.min(nameEnd, 100)).toString("utf8");
+    const sizeStr = header.subarray(124, 135).toString("utf8").trim();
+    const size = parseInt(sizeStr, 8);
+    offset += BLOCK_SIZE;
+    const data = decompressed.subarray(offset, offset + size);
+    offset += size;
+    offset += paddingBytes(size);
+    yield { name, size, data };
+  }
+}
+async function* readTarGz(input) {
+  const decompressed = await decompressStream(input);
+  yield* parseTarEntries(decompressed);
+}
+
+// src/exchange/manifest.ts
+var BACKUP_FORMAT = "semiont-backup";
+var FORMAT_VERSION = 1;
+var LINKED_DATA_FORMAT = "semiont-linked-data";
+function isLinkedDataManifest(obj) {
+  return typeof obj === "object" && obj !== null && obj["semiont:format"] === LINKED_DATA_FORMAT;
+}
+function isBackupManifest(obj) {
+  return typeof obj === "object" && obj !== null && obj.format === BACKUP_FORMAT;
+}
+function validateManifestVersion(version) {
+  if (version > FORMAT_VERSION) {
+    throw new Error(
+      `Unsupported format version ${version}. This tool supports version ${FORMAT_VERSION}.`
+    );
+  }
+}
+
+// src/exchange/backup-exporter.ts
+var SYSTEM_STREAM = "__system__";
+async function exportBackup(options, output) {
+  const { eventStore, content, sourceUrl, logger } = options;
+  const resourceIds = await eventStore.log.storage.getAllResourceIds();
+  logger?.info("Backup export: enumerating streams", { resourceCount: resourceIds.length });
+  const allStreamIds = [SYSTEM_STREAM, ...resourceIds];
+  const streamData = /* @__PURE__ */ new Map();
+  let totalEvents = 0;
+  for (const id of allStreamIds) {
+    const events = await eventStore.log.getEvents(id);
+    if (events.length > 0) {
+      streamData.set(id, events);
+      totalEvents += events.length;
+    }
+  }
+  const contentRefs = collectContentRefs(streamData);
+  logger?.info("Backup export: collected content refs", {
+    streams: streamData.size,
+    events: totalEvents,
+    blobs: contentRefs.size
+  });
+  const contentBlobs = /* @__PURE__ */ new Map();
+  let totalContentBytes = 0;
+  for (const [checksum, mediaType] of contentRefs) {
+    const data = await content.retrieve(checksum, mediaType);
+    const ext = getExtensionForMimeType(mediaType);
+    contentBlobs.set(checksum, { data, ext });
+    totalContentBytes += data.length;
+  }
+  const streamSummaries = [];
+  for (const [streamId, events] of streamData) {
+    streamSummaries.push({
+      stream: streamId,
+      eventCount: events.length,
+      firstChecksum: events[0].metadata.checksum || "",
+      lastChecksum: events[events.length - 1].metadata.checksum || ""
+    });
+  }
+  const manifestHeader = {
+    format: BACKUP_FORMAT,
+    version: FORMAT_VERSION,
+    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    sourceUrl,
+    stats: {
+      streams: streamData.size,
+      events: totalEvents,
+      blobs: contentBlobs.size,
+      contentBytes: totalContentBytes
+    }
+  };
+  async function* generateEntries() {
+    const manifestLines = [
+      JSON.stringify(manifestHeader),
+      ...streamSummaries.map((s) => JSON.stringify(s))
+    ].join("\n") + "\n";
+    yield { name: ".semiont/manifest.jsonl", data: Buffer.from(manifestLines, "utf8") };
+    for (const [streamId, events] of streamData) {
+      const fileName = streamId === SYSTEM_STREAM ? ".semiont/events/__system__.jsonl" : `.semiont/events/${streamId}.jsonl`;
+      const jsonl = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+      yield { name: fileName, data: Buffer.from(jsonl, "utf8") };
+    }
+    for (const [checksum, { data, ext }] of contentBlobs) {
+      yield { name: `${checksum}${ext}`, data };
+    }
+  }
+  await writeTarGz(generateEntries(), output);
+  logger?.info("Backup export complete", {
+    streams: streamData.size,
+    events: totalEvents,
+    blobs: contentBlobs.size,
+    contentBytes: totalContentBytes
+  });
+  return manifestHeader;
+}
+function collectContentRefs(streamData) {
+  const refs = /* @__PURE__ */ new Map();
+  for (const [, events] of streamData) {
+    for (const stored of events) {
+      if (stored.event.type === "resource.created") {
+        const payload = stored.event.payload;
+        if (payload.contentChecksum && payload.format) {
+          refs.set(payload.contentChecksum, payload.format);
+        }
+      }
+    }
+  }
+  return refs;
+}
+
+// src/exchange/replay.ts
+var import_rxjs9 = __toESM(require_cjs(), 1);
+var import_operators9 = __toESM(require_operators(), 1);
+var REPLAY_TIMEOUT_MS = 3e4;
+async function replayEventStream(jsonl, eventBus, resolveBlob, logger) {
+  const lines = jsonl.trim().split("\n").filter((l) => l.length > 0);
+  const storedEvents = lines.map((line) => JSON.parse(line));
+  const stats = {
+    eventsReplayed: 0,
+    resourcesCreated: 0,
+    annotationsCreated: 0,
+    entityTypesAdded: 0
+  };
+  let hashChainValid = true;
+  for (let i = 1; i < storedEvents.length; i++) {
+    const prev = storedEvents[i - 1];
+    const curr = storedEvents[i];
+    if (curr.metadata.prevEventHash && prev.metadata.checksum) {
+      if (curr.metadata.prevEventHash !== prev.metadata.checksum) {
+        logger?.warn("Hash chain break", {
+          index: i,
+          expected: prev.metadata.checksum,
+          got: curr.metadata.prevEventHash
+        });
+        hashChainValid = false;
+      }
+    }
+  }
+  for (const stored of storedEvents) {
+    await replayEvent(stored.event, eventBus, resolveBlob, stats, logger);
+    stats.eventsReplayed++;
+  }
+  return { stats, hashChainValid };
+}
+async function replayEvent(event, eventBus, resolveBlob, stats, logger) {
+  switch (event.type) {
+    case "entitytype.added":
+      await replayEntityTypeAdded(event, eventBus, logger);
+      stats.entityTypesAdded++;
+      break;
+    case "resource.created":
+      await replayResourceCreated(event, eventBus, resolveBlob, logger);
+      stats.resourcesCreated++;
+      break;
+    case "annotation.added":
+      await replayAnnotationAdded(event, eventBus, logger);
+      stats.annotationsCreated++;
+      break;
+    case "annotation.body.updated":
+      await replayAnnotationBodyUpdated(event, eventBus, logger);
+      break;
+    case "annotation.removed":
+      await replayAnnotationRemoved(event, eventBus, logger);
+      break;
+    case "resource.archived":
+      await replayResourceArchived(event, eventBus, logger);
+      break;
+    case "resource.unarchived":
+      await replayResourceUnarchived(event, eventBus, logger);
+      break;
+    case "entitytag.added":
+    case "entitytag.removed":
+      await replayEntityTagChange(event, eventBus, logger);
+      break;
+    // Job events are transient — skip during replay
+    case "job.started":
+    case "job.progress":
+    case "job.completed":
+    case "job.failed":
+      logger?.debug("Skipping job event during replay", { type: event.type });
+      break;
+    // Representation events — content is already stored via resource.created replay
+    case "representation.added":
+    case "representation.removed":
+      logger?.debug("Skipping representation event during replay", { type: event.type });
+      break;
+    default:
+      logger?.warn("Unknown event type during replay", { type: event.type });
+  }
+}
+async function replayEntityTypeAdded(event, eventBus, logger) {
+  const result$ = (0, import_rxjs9.race)(
+    eventBus.get("mark:entity-type-added").pipe((0, import_operators9.map)(() => "ok")),
+    eventBus.get("mark:entity-type-add-failed").pipe((0, import_operators9.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs9.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators9.map)(() => {
+      throw new Error("Timeout waiting for mark:entity-type-added");
+    }))
+  );
+  eventBus.get("mark:add-entity-type").next({
+    tag: event.payload.entityType,
+    userId: event.userId
+  });
+  await (0, import_rxjs9.firstValueFrom)(result$);
+  logger?.debug("Replayed entitytype.added", { entityType: event.payload.entityType });
+}
+async function replayResourceCreated(event, eventBus, resolveBlob, logger) {
+  const { payload } = event;
+  const blob = resolveBlob(payload.contentChecksum);
+  if (!blob) {
+    throw new Error(`Missing content blob for checksum ${payload.contentChecksum}`);
+  }
+  const result$ = (0, import_rxjs9.race)(
+    eventBus.get("yield:created").pipe((0, import_operators9.map)((r) => r)),
+    eventBus.get("yield:create-failed").pipe((0, import_operators9.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs9.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators9.map)(() => {
+      throw new Error("Timeout waiting for yield:created");
+    }))
+  );
+  eventBus.get("yield:create").next({
+    name: payload.name,
+    content: blob,
+    format: payload.format,
+    userId: event.userId,
+    language: payload.language,
+    entityTypes: payload.entityTypes,
+    creationMethod: payload.creationMethod,
+    isDraft: payload.isDraft,
+    generatedFrom: payload.generatedFrom,
+    generationPrompt: payload.generationPrompt
+  });
+  await (0, import_rxjs9.firstValueFrom)(result$);
+  logger?.debug("Replayed resource.created", { name: payload.name });
+}
+async function replayAnnotationAdded(event, eventBus, logger) {
+  const result$ = (0, import_rxjs9.race)(
+    eventBus.get("mark:created").pipe((0, import_operators9.map)(() => "ok")),
+    eventBus.get("mark:create-failed").pipe((0, import_operators9.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs9.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators9.map)(() => {
+      throw new Error("Timeout waiting for mark:created");
+    }))
+  );
+  eventBus.get("mark:create").next({
+    annotation: event.payload.annotation,
+    userId: event.userId,
+    resourceId: event.resourceId
+  });
+  await (0, import_rxjs9.firstValueFrom)(result$);
+  logger?.debug("Replayed annotation.added", { annotationId: event.payload.annotation.id });
+}
+async function replayAnnotationBodyUpdated(event, eventBus, logger) {
+  const result$ = (0, import_rxjs9.race)(
+    eventBus.get("mark:body-updated").pipe((0, import_operators9.map)(() => "ok")),
+    eventBus.get("mark:body-update-failed").pipe((0, import_operators9.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs9.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators9.map)(() => {
+      throw new Error("Timeout waiting for mark:body-updated");
+    }))
+  );
+  eventBus.get("mark:update-body").next({
+    annotationId: event.payload.annotationId,
+    userId: event.userId,
+    resourceId: event.resourceId,
+    operations: event.payload.operations
+  });
+  await (0, import_rxjs9.firstValueFrom)(result$);
+  logger?.debug("Replayed annotation.body.updated", { annotationId: event.payload.annotationId });
+}
+async function replayAnnotationRemoved(event, eventBus, logger) {
+  const result$ = (0, import_rxjs9.race)(
+    eventBus.get("mark:deleted").pipe((0, import_operators9.map)(() => "ok")),
+    eventBus.get("mark:delete-failed").pipe((0, import_operators9.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs9.timer)(REPLAY_TIMEOUT_MS).pipe((0, import_operators9.map)(() => {
+      throw new Error("Timeout waiting for mark:deleted");
+    }))
+  );
+  eventBus.get("mark:delete").next({
+    annotationId: event.payload.annotationId,
+    userId: event.userId,
+    resourceId: event.resourceId
+  });
+  await (0, import_rxjs9.firstValueFrom)(result$);
+  logger?.debug("Replayed annotation.removed", { annotationId: event.payload.annotationId });
+}
+async function replayResourceArchived(event, eventBus, logger) {
+  eventBus.get("mark:archive").next({
+    userId: event.userId,
+    resourceId: event.resourceId
+  });
+  logger?.debug("Replayed resource.archived", { resourceId: event.resourceId });
+}
+async function replayResourceUnarchived(event, eventBus, logger) {
+  eventBus.get("mark:unarchive").next({
+    userId: event.userId,
+    resourceId: event.resourceId
+  });
+  logger?.debug("Replayed resource.unarchived", { resourceId: event.resourceId });
+}
+async function replayEntityTagChange(event, eventBus, logger) {
+  const resourceId4 = event.resourceId;
+  const entityType = event.payload.entityType;
+  if (event.type === "entitytag.added") {
+    eventBus.get("mark:update-entity-types").next({
+      resourceId: resourceId4,
+      userId: event.userId,
+      currentEntityTypes: [],
+      updatedEntityTypes: [entityType]
+    });
+  } else {
+    eventBus.get("mark:update-entity-types").next({
+      resourceId: resourceId4,
+      userId: event.userId,
+      currentEntityTypes: [entityType],
+      updatedEntityTypes: []
+    });
+  }
+  logger?.debug("Replayed entity tag change", { type: event.type, entityType });
+}
+
+// src/exchange/backup-importer.ts
+function buildBlobResolver(entries) {
+  const checksumIndex = /* @__PURE__ */ new Map();
+  for (const name of entries.keys()) {
+    if (!name.startsWith(".semiont/")) {
+      const dotIndex = name.lastIndexOf(".");
+      const checksum = dotIndex >= 0 ? name.slice(0, dotIndex) : name;
+      checksumIndex.set(checksum, name);
+    }
+  }
+  return (checksum) => {
+    const entryName = checksumIndex.get(checksum);
+    return entryName ? entries.get(entryName) : void 0;
+  };
+}
+async function importBackup(archive, options) {
+  const { eventBus, logger } = options;
+  const entries = /* @__PURE__ */ new Map();
+  for await (const entry of readTarGz(archive)) {
+    entries.set(entry.name, entry.data);
+  }
+  const manifestData = entries.get(".semiont/manifest.jsonl");
+  if (!manifestData) {
+    throw new Error("Invalid backup: missing .semiont/manifest.jsonl");
+  }
+  const manifestLines = manifestData.toString("utf8").trim().split("\n");
+  const header = JSON.parse(manifestLines[0]);
+  if (!isBackupManifest(header)) {
+    throw new Error(`Invalid backup: expected format "${BACKUP_FORMAT}", got "${header.format}"`);
+  }
+  validateManifestVersion(header.version);
+  const streamSummaries = manifestLines.slice(1).map((line) => JSON.parse(line));
+  logger?.info("Backup import: parsed manifest", {
+    streams: header.stats.streams,
+    events: header.stats.events,
+    blobs: header.stats.blobs
+  });
+  const resolveBlob = buildBlobResolver(entries);
+  const systemData = entries.get(".semiont/events/__system__.jsonl");
+  let stats = { eventsReplayed: 0, resourcesCreated: 0, annotationsCreated: 0, entityTypesAdded: 0 };
+  let hashChainValid = true;
+  if (systemData) {
+    const result = await replayEventStream(
+      systemData.toString("utf8"),
+      eventBus,
+      resolveBlob,
+      logger
+    );
+    stats = mergeStats(stats, result.stats);
+    if (!result.hashChainValid) hashChainValid = false;
+  }
+  for (const summary of streamSummaries) {
+    if (summary.stream === "__system__") continue;
+    const eventData = entries.get(`.semiont/events/${summary.stream}.jsonl`);
+    if (!eventData) {
+      logger?.warn("Backup import: missing event stream", { stream: summary.stream });
+      continue;
+    }
+    const result = await replayEventStream(
+      eventData.toString("utf8"),
+      eventBus,
+      resolveBlob,
+      logger
+    );
+    stats = mergeStats(stats, result.stats);
+    if (!result.hashChainValid) hashChainValid = false;
+  }
+  logger?.info("Backup import complete", { ...stats, hashChainValid });
+  return { manifest: header, stats, hashChainValid };
+}
+function mergeStats(a, b) {
+  return {
+    eventsReplayed: a.eventsReplayed + b.eventsReplayed,
+    resourcesCreated: a.resourcesCreated + b.resourcesCreated,
+    annotationsCreated: a.annotationsCreated + b.annotationsCreated,
+    entityTypesAdded: a.entityTypesAdded + b.entityTypesAdded
+  };
+}
+
+// src/exchange/linked-data-exporter.ts
+import { getExtensionForMimeType as getExtensionForMimeType2 } from "@semiont/content";
+var SEMIONT_CONTEXT = [
+  "https://schema.org/",
+  "http://www.w3.org/ns/anno.jsonld",
+  {
+    "semiont": "https://semiont.org/vocab/",
+    "entityTypes": "semiont:entityTypes",
+    "creationMethod": "semiont:creationMethod",
+    "archived": "semiont:archived",
+    "representations": { "@id": "semiont:representations", "@container": "@set" },
+    "annotations": { "@id": "semiont:annotations", "@container": "@set" }
+  }
+];
+var MANIFEST_CONTEXT = {
+  "semiont": "https://semiont.org/vocab/",
+  "schema": "https://schema.org/",
+  "dct": "http://purl.org/dc/terms/",
+  "prov": "http://www.w3.org/ns/prov#",
+  "void": "http://rdfs.org/ns/void#"
+};
+function hydrateAnnotation(annotation, baseUrl) {
+  const hydrated = { ...annotation };
+  if (hydrated.id && !hydrated.id.startsWith("http")) {
+    hydrated.id = `${baseUrl}/annotations/${hydrated.id}`;
+  }
+  if (typeof hydrated.target === "string") {
+    if (!hydrated.target.startsWith("http")) {
+      hydrated.target = `${baseUrl}/resources/${hydrated.target}`;
+    }
+  } else if (hydrated.target && typeof hydrated.target === "object") {
+    const target = { ...hydrated.target };
+    if (target.source && !target.source.startsWith("http")) {
+      target.source = `${baseUrl}/resources/${target.source}`;
+    }
+    hydrated.target = target;
+  }
+  hydrated.body = hydrateBody(hydrated.body, baseUrl);
+  return hydrated;
+}
+function hydrateBody(body, baseUrl) {
+  if (Array.isArray(body)) {
+    return body.map((b) => hydrateBodyItem(b, baseUrl));
+  }
+  return hydrateBodyItem(body, baseUrl);
+}
+function hydrateBodyItem(item, baseUrl) {
+  if (item && typeof item === "object" && "source" in item) {
+    const source = item.source;
+    if (typeof source === "string" && !source.startsWith("http")) {
+      return { ...item, source: `${baseUrl}/resources/${source}` };
+    }
+  }
+  return item;
+}
+async function exportLinkedData(options, output) {
+  const { views, content, sourceUrl, entityTypes, includeArchived, logger } = options;
+  const allViews = await views.getAll();
+  const resourceViews = includeArchived ? allViews : allViews.filter((v) => !v.resource.archived);
+  logger?.info("Linked data export: enumerating resources", { count: resourceViews.length });
+  const contentRefs = /* @__PURE__ */ new Map();
+  for (const view of resourceViews) {
+    collectContentRefsFromResource(view.resource, contentRefs);
+  }
+  const contentBlobs = /* @__PURE__ */ new Map();
+  for (const [checksum, mediaType] of contentRefs) {
+    try {
+      const data = await content.retrieve(checksum, mediaType);
+      const ext = getExtensionForMimeType2(mediaType);
+      contentBlobs.set(checksum, { data, ext });
+    } catch (err) {
+      logger?.warn("Failed to retrieve content blob", { checksum, mediaType, error: String(err) });
+    }
+  }
+  const manifest = {
+    "@context": MANIFEST_CONTEXT,
+    "@type": "void:Dataset",
+    "semiont:format": LINKED_DATA_FORMAT,
+    "semiont:version": FORMAT_VERSION,
+    "dct:created": (/* @__PURE__ */ new Date()).toISOString(),
+    "prov:wasGeneratedBy": {
+      "@type": "prov:Activity",
+      "prov:used": sourceUrl
+    },
+    "semiont:entityTypes": entityTypes,
+    "void:entities": resourceViews.length
+  };
+  async function* generateEntries() {
+    yield {
+      name: ".semiont/manifest.jsonld",
+      data: Buffer.from(JSON.stringify(manifest, null, 2), "utf8")
+    };
+    for (const view of resourceViews) {
+      const resourceId4 = view.resource["@id"];
+      const jsonld = buildResourceJsonLd(view.resource, view.annotations.annotations, sourceUrl);
+      yield {
+        name: `.semiont/resources/${resourceId4}.jsonld`,
+        data: Buffer.from(JSON.stringify(jsonld, null, 2), "utf8")
+      };
+    }
+    for (const [checksum, { data, ext }] of contentBlobs) {
+      yield { name: `${checksum}${ext}`, data };
+    }
+  }
+  await writeTarGz(generateEntries(), output);
+  logger?.info("Linked data export complete", {
+    resources: resourceViews.length,
+    blobs: contentBlobs.size
+  });
+  return manifest;
+}
+function buildResourceJsonLd(resource, annotations, sourceUrl) {
+  const resourceId4 = resource["@id"];
+  const resourceUri = resourceId4.startsWith("http") ? resourceId4 : `${sourceUrl}/resources/${resourceId4}`;
+  const doc = {
+    "@context": SEMIONT_CONTEXT,
+    "@id": resourceUri,
+    "@type": resource["@type"] ?? "DigitalDocument",
+    "name": resource.name
+  };
+  if (resource.dateCreated) doc["dateCreated"] = resource.dateCreated;
+  if (resource.dateModified) doc["dateModified"] = resource.dateModified;
+  if (resource.description) doc["description"] = resource.description;
+  const reps = normalizeRepresentations(resource.representations);
+  if (reps.length > 0) {
+    const primary = reps[0];
+    if (primary.language) doc["inLanguage"] = primary.language;
+    if (primary.mediaType) doc["encodingFormat"] = primary.mediaType;
+  }
+  if (resource.creationMethod) doc["creationMethod"] = resource.creationMethod;
+  if (resource.entityTypes && resource.entityTypes.length > 0) doc["entityTypes"] = resource.entityTypes;
+  if (resource.archived) doc["archived"] = resource.archived;
+  if (resource.wasDerivedFrom) doc["wasDerivedFrom"] = resource.wasDerivedFrom;
+  if (resource.wasAttributedTo) doc["wasAttributedTo"] = resource.wasAttributedTo;
+  if (resource.sameAs && resource.sameAs.length > 0) doc["sameAs"] = resource.sameAs;
+  if (resource.isPartOf && resource.isPartOf.length > 0) doc["isPartOf"] = resource.isPartOf;
+  if (resource.hasPart && resource.hasPart.length > 0) doc["hasPart"] = resource.hasPart;
+  if (reps.length > 0) {
+    doc["representations"] = reps.map((rep) => {
+      const mediaObj = {
+        "@type": "schema:MediaObject",
+        "encodingFormat": rep.mediaType
+      };
+      if (rep.byteSize !== void 0) mediaObj["contentSize"] = rep.byteSize;
+      if (rep.checksum) {
+        const rawChecksum = rep.checksum.startsWith("sha256:") ? rep.checksum.slice(7) : rep.checksum;
+        mediaObj["sha256"] = rawChecksum;
+        const ext = getExtensionForMimeType2(rep.mediaType);
+        mediaObj["name"] = `${rawChecksum}${ext}`;
+      }
+      if (rep.language) mediaObj["inLanguage"] = rep.language;
+      return mediaObj;
+    });
+  }
+  if (annotations.length > 0) {
+    doc["annotations"] = annotations.map((ann) => hydrateAnnotation(ann, sourceUrl));
+  }
+  return doc;
+}
+function normalizeRepresentations(reps) {
+  if (!reps) return [];
+  if (Array.isArray(reps)) return reps;
+  return [reps];
+}
+function collectContentRefsFromResource(resource, refs) {
+  const reps = normalizeRepresentations(resource.representations);
+  for (const rep of reps) {
+    if (rep.checksum && rep.mediaType) {
+      const rawChecksum = rep.checksum.startsWith("sha256:") ? rep.checksum.slice(7) : rep.checksum;
+      refs.set(rawChecksum, rep.mediaType);
+    }
+  }
+}
+
+// src/exchange/linked-data-importer.ts
+var import_rxjs10 = __toESM(require_cjs(), 1);
+var import_operators10 = __toESM(require_operators(), 1);
+var IMPORT_TIMEOUT_MS = 3e4;
+function stripUriToId(uri) {
+  if (!uri.includes("/")) return uri;
+  const lastSlash = uri.lastIndexOf("/");
+  return uri.slice(lastSlash + 1);
+}
+function dehydrateAnnotation(annotation) {
+  const dehydrated = { ...annotation };
+  if (dehydrated.id) {
+    dehydrated.id = stripUriToId(dehydrated.id);
+  }
+  if (typeof dehydrated.target === "string") {
+    dehydrated.target = stripUriToId(dehydrated.target);
+  } else if (dehydrated.target && typeof dehydrated.target === "object") {
+    const target = { ...dehydrated.target };
+    if (target.source) {
+      target.source = stripUriToId(target.source);
+    }
+    dehydrated.target = target;
+  }
+  dehydrated.body = dehydrateBody(dehydrated.body);
+  return dehydrated;
+}
+function dehydrateBody(body) {
+  if (Array.isArray(body)) {
+    return body.map((b) => dehydrateBodyItem(b));
+  }
+  return dehydrateBodyItem(body);
+}
+function dehydrateBodyItem(item) {
+  if (item && typeof item === "object" && "source" in item) {
+    const source = item.source;
+    if (typeof source === "string" && source.includes("/")) {
+      return { ...item, source: stripUriToId(source) };
+    }
+  }
+  return item;
+}
+function buildBlobResolver2(entries) {
+  const checksumIndex = /* @__PURE__ */ new Map();
+  for (const name of entries.keys()) {
+    if (!name.startsWith(".semiont/")) {
+      const dotIndex = name.lastIndexOf(".");
+      const checksum = dotIndex >= 0 ? name.slice(0, dotIndex) : name;
+      checksumIndex.set(checksum, name);
+    }
+  }
+  return (checksum) => {
+    const entryName = checksumIndex.get(checksum);
+    return entryName ? entries.get(entryName) : void 0;
+  };
+}
+async function importLinkedData(archive, options) {
+  const { eventBus, userId: userId2, logger } = options;
+  const entries = /* @__PURE__ */ new Map();
+  for await (const entry of readTarGz(archive)) {
+    entries.set(entry.name, entry.data);
+  }
+  const manifestData = entries.get(".semiont/manifest.jsonld");
+  if (!manifestData) {
+    throw new Error("Invalid linked data archive: missing .semiont/manifest.jsonld");
+  }
+  const manifest = JSON.parse(manifestData.toString("utf8"));
+  if (!isLinkedDataManifest(manifest)) {
+    throw new Error(
+      `Invalid linked data archive: expected format "${LINKED_DATA_FORMAT}", got "${manifest["semiont:format"]}"`
+    );
+  }
+  validateManifestVersion(manifest["semiont:version"]);
+  logger?.info("Linked data import: parsed manifest", {
+    entityTypes: manifest["semiont:entityTypes"].length,
+    resources: manifest["void:entities"]
+  });
+  const resolveBlob = buildBlobResolver2(entries);
+  let entityTypesAdded = 0;
+  for (const entityType of manifest["semiont:entityTypes"]) {
+    await addEntityType(entityType, userId2, eventBus, logger);
+    entityTypesAdded++;
+  }
+  const resourceEntries = [...entries.keys()].filter((name) => name.startsWith(".semiont/resources/") && name.endsWith(".jsonld")).sort();
+  let resourcesCreated = 0;
+  let annotationsCreated = 0;
+  for (const entryName of resourceEntries) {
+    const resourceDoc = JSON.parse(entries.get(entryName).toString("utf8"));
+    const result = await importResource(resourceDoc, userId2, eventBus, resolveBlob, logger);
+    resourcesCreated++;
+    annotationsCreated += result.annotationsCreated;
+  }
+  logger?.info("Linked data import complete", {
+    resourcesCreated,
+    annotationsCreated,
+    entityTypesAdded
+  });
+  return {
+    manifest,
+    resourcesCreated,
+    annotationsCreated,
+    entityTypesAdded
+  };
+}
+async function addEntityType(entityType, userId2, eventBus, logger) {
+  const result$ = (0, import_rxjs10.race)(
+    eventBus.get("mark:entity-type-added").pipe((0, import_operators10.map)(() => "ok")),
+    eventBus.get("mark:entity-type-add-failed").pipe((0, import_operators10.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs10.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+      throw new Error("Timeout waiting for mark:entity-type-added");
+    }))
+  );
+  eventBus.get("mark:add-entity-type").next({
+    tag: entityType,
+    userId: userId2
+  });
+  await (0, import_rxjs10.firstValueFrom)(result$);
+  logger?.debug("Added entity type", { entityType });
+}
+async function importResource(doc, userId2, eventBus, resolveBlob, logger) {
+  const name = doc["name"];
+  const representations = doc["representations"];
+  const annotations = doc["annotations"];
+  const entityTypes = doc["entityTypes"];
+  const creationMethod = doc["creationMethod"];
+  let format = "text/markdown";
+  let language;
+  let contentChecksum;
+  if (representations && representations.length > 0) {
+    const primary = representations[0];
+    if (primary["encodingFormat"]) format = primary["encodingFormat"];
+    if (primary["inLanguage"]) language = primary["inLanguage"];
+    if (primary["sha256"]) contentChecksum = primary["sha256"];
+  }
+  if (!contentChecksum) {
+    throw new Error(`Resource "${name}" has no content checksum in representations`);
+  }
+  const blob = resolveBlob(contentChecksum);
+  if (!blob) {
+    throw new Error(`Missing content blob for checksum ${contentChecksum} (resource "${name}")`);
+  }
+  const createResult$ = (0, import_rxjs10.race)(
+    eventBus.get("yield:created").pipe((0, import_operators10.map)((r) => r)),
+    eventBus.get("yield:create-failed").pipe((0, import_operators10.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs10.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+      throw new Error("Timeout waiting for yield:created");
+    }))
+  );
+  eventBus.get("yield:create").next({
+    name,
+    content: blob,
+    format,
+    userId: userId2,
+    language,
+    entityTypes: entityTypes ?? [],
+    creationMethod
+  });
+  const created = await (0, import_rxjs10.firstValueFrom)(createResult$);
+  const resourceId4 = created.resourceId;
+  logger?.debug("Created resource from JSON-LD", { name, resourceId: resourceId4 });
+  let annotationsCreated = 0;
+  if (annotations && annotations.length > 0) {
+    for (const annotation of annotations) {
+      await createAnnotation(annotation, resourceId4, userId2, eventBus, logger);
+      annotationsCreated++;
+    }
+  }
+  return { annotationsCreated };
+}
+async function createAnnotation(annotation, resourceId4, userId2, eventBus, logger) {
+  const result$ = (0, import_rxjs10.race)(
+    eventBus.get("mark:created").pipe((0, import_operators10.map)(() => "ok")),
+    eventBus.get("mark:create-failed").pipe((0, import_operators10.map)((e) => {
+      throw e.error;
+    })),
+    (0, import_rxjs10.timer)(IMPORT_TIMEOUT_MS).pipe((0, import_operators10.map)(() => {
+      throw new Error("Timeout waiting for mark:created");
+    }))
+  );
+  eventBus.get("mark:create").next({
+    annotation: dehydrateAnnotation(annotation),
+    userId: userId2,
+    resourceId: resourceId4
+  });
+  await (0, import_rxjs10.firstValueFrom)(result$);
+  logger?.debug("Created annotation", { annotationId: annotation.id });
+}
+
 // src/annotation-assembly.ts
 import {
   assembleAnnotation,
@@ -12270,19 +13410,18 @@ import {
 } from "@semiont/core";
 
 // src/annotation-operations.ts
-import { getTargetSource as getTargetSource3 } from "@semiont/api-client";
-import { annotationId, uriToResourceId as uriToResourceId3, uriToAnnotationId as uriToAnnotationId2, assembleAnnotation as assembleAnnotation2, applyBodyOperations as applyBodyOperations2 } from "@semiont/core";
+import { annotationId, resourceId as makeResourceId3, assembleAnnotation as assembleAnnotation2, applyBodyOperations as applyBodyOperations2 } from "@semiont/core";
 var AnnotationOperations = class {
   /**
    * Create a new annotation via EventBus → Stower
    */
-  static async createAnnotation(request, userId2, creator, eventBus, publicURL) {
-    const { annotation } = assembleAnnotation2(request, creator, publicURL);
-    const resourceId2 = uriToResourceId3(request.target.source);
+  static async createAnnotation(request, userId2, creator, eventBus) {
+    const { annotation } = assembleAnnotation2(request, creator);
+    const resId = makeResourceId3(request.target.source);
     eventBus.get("mark:create").next({
       annotation,
       userId: userId2,
-      resourceId: resourceId2
+      resourceId: resId
     });
     return { annotation };
   }
@@ -12290,19 +13429,19 @@ var AnnotationOperations = class {
    * Update annotation body via EventBus → Stower
    */
   static async updateAnnotationBody(id, request, userId2, eventBus, kb) {
+    const resId = makeResourceId3(request.resourceId);
     const annotation = await AnnotationContext.getAnnotation(
       annotationId(id),
-      uriToResourceId3(request.resourceId),
+      resId,
       kb
     );
     if (!annotation) {
       throw new Error("Annotation not found");
     }
-    const resourceId2 = uriToResourceId3(getTargetSource3(annotation.target));
     eventBus.get("mark:update-body").next({
       annotationId: annotationId(id),
       userId: userId2,
-      resourceId: resourceId2,
+      resourceId: resId,
       operations: request.operations
     });
     const updatedBody = applyBodyOperations2(annotation.body, request.operations);
@@ -12316,8 +13455,8 @@ var AnnotationOperations = class {
   /**
    * Delete an annotation via EventBus → Stower
    */
-  static async deleteAnnotation(id, resourceIdUri, userId2, eventBus, kb, logger) {
-    const resId = uriToResourceId3(resourceIdUri);
+  static async deleteAnnotation(id, resourceIdStr, userId2, eventBus, kb, logger) {
+    const resId = makeResourceId3(resourceIdStr);
     const projection = await AnnotationContext.getResourceAnnotations(resId, kb);
     const annotation = projection.annotations.find((a) => a.id === id);
     if (!annotation) {
@@ -12325,7 +13464,7 @@ var AnnotationOperations = class {
     }
     logger?.debug("Removing annotation via EventBus", { annotationId: id });
     eventBus.get("mark:delete").next({
-      annotationId: uriToAnnotationId2(id),
+      annotationId: annotationId(id),
       userId: userId2,
       resourceId: resId
     });
@@ -12339,8 +13478,10 @@ var VERSION = "0.1.0";
 export {
   AnnotationContext,
   AnnotationOperations,
+  BACKUP_FORMAT,
   Binder,
   CloneTokenManager,
+  FORMAT_VERSION,
   Gatherer,
   GraphContext,
   GraphDBConsumer,
@@ -12354,10 +13495,16 @@ export {
   assembleAnnotation,
   bootstrapEntityTypes,
   createKnowledgeBase,
+  exportBackup,
+  exportLinkedData,
   generateReferenceSuggestions,
   generateResourceSummary,
+  importBackup,
+  importLinkedData,
+  isBackupManifest,
   readEntityTypesProjection,
   resetBootstrap,
-  startMakeMeaning
+  startMakeMeaning,
+  validateManifestVersion
 };
 //# sourceMappingURL=index.js.map