@semiont/backend 0.2.46 → 0.3.0

package/dist/index.js

@@ -2,12 +2,12 @@
 import winston from 'winston';
 import { z } from 'zod';
 import jwt from 'jsonwebtoken';
-import { createConfigLoader, email, userId, accessToken, googleCredential, annotationId, resourceId, EventBus, uriToResourceId, jobId, resourceUri, entityType, assembleAnnotation, userToAgent } from '@semiont/core';
+import { createConfigLoader, email, userId, accessToken, googleCredential, annotationId, resourceId, EventBus, jobId, entityType, assembleAnnotation, userToAgent } from '@semiont/core';
 import { cors } from 'hono/cors';
 import { serve } from '@hono/node-server';
 import { Hono } from 'hono';
 import { swaggerUI } from '@hono/swagger-ui';
-import { AnnotationContext, startMakeMeaning, ResourceContext, ResourceOperations } from '@semiont/make-meaning';
+import { exportBackup, importBackup, readEntityTypesProjection, exportLinkedData, importLinkedData, AnnotationContext, startMakeMeaning, ResourceContext, ResourceOperations } from '@semiont/make-meaning';
 import * as fs from 'fs';
 import * as path from 'path';
 import { PrismaClient } from '@prisma/client';
@@ -15,6 +15,7 @@ import { HTTPException } from 'hono/http-exception';
 import Ajv from 'ajv';
 import addFormats from 'ajv-formats';
 import * as argon2 from 'argon2';
+import { Writable, Readable } from 'stream';
 import { streamSSE } from 'hono/streaming';
 import crypto2, { randomUUID } from 'crypto';
 import { EventQuery } from '@semiont/event-sourcing';
@@ -66,8 +67,8 @@ __export(logger_exports, {
 function getLoggerConfig(logLevel) {
   const level = logLevel || process.env.LOG_LEVEL || "info";
   const format = process.env.LOG_FORMAT || "json";
-  const nodeEnv2 = process.env.NODE_ENV || "development";
-  if (nodeEnv2 === "test") {
+  const nodeEnv = process.env.NODE_ENV || "development";
+  if (nodeEnv === "test") {
     return {
       level: "error",
       format: "simple",
@@ -12073,8 +12074,8 @@ var getRouteLogger = /* @__PURE__ */ __name(() => getLogger().child({
 }), "getRouteLogger");
 var healthRouter = new Hono();
 healthRouter.get("/api/health", async (c) => {
-  const nodeEnv2 = process.env.NODE_ENV;
-  if (!nodeEnv2) {
+  const nodeEnv = process.env.NODE_ENV;
+  if (!nodeEnv) {
     throw new Error("NODE_ENV environment variable is required");
   }
   let startupFailed = false;
@@ -12098,7 +12099,7 @@ healthRouter.get("/api/health", async (c) => {
       version: "0.1.0",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       database: "unknown",
-      environment: nodeEnv2
+      environment: nodeEnv
     };
     return c.json(response2, 200);
   }
@@ -12109,7 +12110,7 @@ healthRouter.get("/api/health", async (c) => {
     version: "0.1.0",
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     database: dbStatus ? "connected" : "disconnected",
-    environment: nodeEnv2
+    environment: nodeEnv
   };
   return c.json(response, 200);
 });
@@ -12553,8 +12554,8 @@ var openapi_default = {
             ]
           },
           context: {
-            $ref: "#/components/schemas/YieldContext",
-            description: "Generation context for this annotation"
+            $ref: "#/components/schemas/GatheredContext",
+            description: "Gathered context for this annotation"
           },
           sourceContext: {
             type: "object",
@@ -13529,8 +13530,8 @@ var openapi_default = {
             description: 'Language locale for generated content (e.g., "es", "fr", "ja")'
           },
           context: {
-            $ref: "#/components/schemas/YieldContext",
-            description: "Generation context including source document excerpts and metadata"
+            $ref: "#/components/schemas/GatheredContext",
+            description: "Gathered context including source document excerpts, metadata, and graph context"
           },
           temperature: {
             type: "number",
@@ -14449,7 +14450,6 @@ var openapi_default = {
           },
           "@id": {
             type: "string",
-            format: "uri",
             description: "Canonical URI/URN of the resource being described."
           },
           "@type": {
@@ -14560,14 +14560,12 @@ var openapi_default = {
             description: "W3C PROV - source resources this was derived from",
             oneOf: [
               {
-                type: "string",
-                format: "uri"
+                type: "string"
               },
               {
                 type: "array",
                 items: {
-                  type: "string",
-                  format: "uri"
+                  type: "string"
                 }
               }
             ]
@@ -14657,6 +14655,11 @@ var openapi_default = {
           sourceResourceId: {
             type: "string",
             description: "Application-specific: ID of source resource for clones/derivatives"
+          },
+          originatedFrom: {
+            type: "string",
+            format: "uri",
+            description: "Original URI from a source knowledge base when this resource was imported"
           }
         }
       },
@@ -15159,10 +15162,18 @@ var openapi_default = {
           "value"
         ]
       },
-      YieldContext: {
+      GatheredContext: {
         type: "object",
-        description: "Context information used for AI generation. Includes source document excerpts and metadata.",
+        description: "Context gathered for an annotation. Includes source document excerpts, metadata, and graph-derived context. Used by both Find (bind) and Generate (yield) flows.",
         properties: {
+          annotation: {
+            $ref: "#/components/schemas/Annotation",
+            description: "The annotation this context was gathered for"
+          },
+          sourceResource: {
+            $ref: "#/components/schemas/ResourceDescriptor",
+            description: "The resource containing the annotation"
+          },
           sourceContext: {
             type: "object",
             description: "Text context from the source document",
@@ -15186,7 +15197,7 @@ var openapi_default = {
           },
           metadata: {
             type: "object",
-            description: "Additional context metadata (reserved for future use)",
+            description: "Context metadata about the annotation and its source",
             properties: {
               resourceType: {
                 type: "string",
@@ -15204,9 +15215,91 @@ var openapi_default = {
                 description: "Entity types associated with the annotation"
               }
             }
+          },
+          graphContext: {
+            type: "object",
+            description: "Graph-derived context from the knowledge base",
+            properties: {
+              connections: {
+                type: "array",
+                description: "Resources connected to the source resource via annotations",
+                items: {
+                  type: "object",
+                  properties: {
+                    resourceId: {
+                      type: "string",
+                      description: "ID of the connected resource"
+                    },
+                    resourceName: {
+                      type: "string",
+                      description: "Name of the connected resource"
+                    },
+                    entityTypes: {
+                      type: "array",
+                      items: {
+                        type: "string"
+                      },
+                      description: "Entity types on the connected resource"
+                    },
+                    bidirectional: {
+                      type: "boolean",
+                      description: "Whether the connection goes both ways"
+                    }
+                  },
+                  required: [
+                    "resourceId",
+                    "resourceName",
+                    "bidirectional"
+                  ]
+                }
+              },
+              citedByCount: {
+                type: "integer",
+                description: "Number of other resources that reference the source resource"
+              },
+              citedBy: {
+                type: "array",
+                description: "Resources that reference the source resource",
+                items: {
+                  type: "object",
+                  properties: {
+                    resourceId: {
+                      type: "string"
+                    },
+                    resourceName: {
+                      type: "string"
+                    }
+                  },
+                  required: [
+                    "resourceId",
+                    "resourceName"
+                  ]
+                }
+              },
+              siblingEntityTypes: {
+                type: "array",
+                items: {
+                  type: "string"
+                },
+                description: "Entity types from other annotations on the same resource"
+              },
+              entityTypeFrequencies: {
+                type: "object",
+                description: "Global frequency counts for entity types (for IDF-like weighting)",
+                additionalProperties: {
+                  type: "integer"
+                }
+              },
+              inferredRelationshipSummary: {
+                type: "string",
+                description: "LLM-generated summary of the annotation's relationships in the knowledge graph"
+              }
+            }
           }
         },
         required: [
+          "annotation",
+          "sourceResource",
           "sourceContext"
         ]
       }
@@ -16096,6 +16189,235 @@ adminRouter.get("/api/admin/oauth/config", async (c) => {
   };
   return c.json(response, 200);
 });
+var adminMiddleware2 = /* @__PURE__ */ __name(async (c, next) => {
+  const user = c.get("user");
+  if (!user || !user.isAdmin) {
+    return c.json({
+      error: "Forbidden: Admin access required"
+    }, 403);
+  }
+  return next();
+}, "adminMiddleware");
+var moderatorMiddleware = /* @__PURE__ */ __name(async (c, next) => {
+  const user = c.get("user");
+  if (!user || !user.isModerator && !user.isAdmin) {
+    return c.json({
+      error: "Forbidden: Moderator or Admin access required"
+    }, 403);
+  }
+  return next();
+}, "moderatorMiddleware");
+var exchangeRouter = new Hono();
+exchangeRouter.use("/api/admin/exchange/*", authMiddleware, adminMiddleware2);
+exchangeRouter.use("/api/moderate/exchange/*", authMiddleware, moderatorMiddleware);
+exchangeRouter.post("/api/admin/exchange/backup", async (c) => {
+  const mm = c.get("makeMeaning");
+  const config2 = c.get("config");
+  const sourceUrl = config2.services?.backend?.publicURL ?? "http://localhost:4000";
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = `semiont-backup-${timestamp}.tar.gz`;
+  let controller;
+  const webReadable = new ReadableStream({
+    start(ctrl) {
+      controller = ctrl;
+    }
+  });
+  const nodeWritable = new Writable({
+    write(chunk, _encoding, callback) {
+      controller.enqueue(chunk);
+      callback();
+    },
+    final(callback) {
+      controller.close();
+      callback();
+    }
+  });
+  (async () => {
+    try {
+      await exportBackup({
+        eventStore: mm.kb.eventStore,
+        content: mm.kb.content,
+        sourceUrl
+      }, nodeWritable);
+    } catch (err) {
+      controller.error(err);
+    }
+  })();
+  return new Response(webReadable, {
+    headers: {
+      "Content-Type": "application/gzip",
+      "Content-Disposition": `attachment; filename="${filename}"`,
+      "Cache-Control": "no-cache"
+    }
+  });
+});
+exchangeRouter.post("/api/admin/exchange/restore", async (c) => {
+  const formData = await c.req.formData();
+  const file = formData.get("file");
+  if (!file) {
+    return c.json({
+      error: "No file provided"
+    }, 400);
+  }
+  const eventBus2 = c.get("eventBus");
+  const buffer = Buffer.from(await file.arrayBuffer());
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = /* @__PURE__ */ __name((data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      }, "send");
+      try {
+        const input = new Readable({
+          read() {
+          }
+        });
+        input.push(buffer);
+        input.push(null);
+        send({
+          phase: "started",
+          message: "Restoring backup..."
+        });
+        const result = await importBackup(input, {
+          eventBus: eventBus2
+        });
+        send({
+          phase: "complete",
+          result: {
+            stats: result.stats,
+            hashChainValid: result.hashChainValid
+          }
+        });
+      } catch (err) {
+        send({
+          phase: "error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+});
+exchangeRouter.post("/api/moderate/exchange/export", async (c) => {
+  const mm = c.get("makeMeaning");
+  const config2 = c.get("config");
+  const sourceUrl = config2.services?.backend?.publicURL ?? "http://localhost:4000";
+  const includeArchived = c.req.query("includeArchived") === "true";
+  const entityTypes = await readEntityTypesProjection({
+    services: {
+      filesystem: config2.services?.filesystem
+    },
+    _metadata: config2._metadata
+  });
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const filename = `semiont-export-${timestamp}.tar.gz`;
+  let controller;
+  const webReadable = new ReadableStream({
+    start(ctrl) {
+      controller = ctrl;
+    }
+  });
+  const nodeWritable = new Writable({
+    write(chunk, _encoding, callback) {
+      controller.enqueue(chunk);
+      callback();
+    },
+    final(callback) {
+      controller.close();
+      callback();
+    }
+  });
+  (async () => {
+    try {
+      await exportLinkedData({
+        views: mm.kb.views,
+        content: mm.kb.content,
+        sourceUrl,
+        entityTypes,
+        includeArchived
+      }, nodeWritable);
+    } catch (err) {
+      controller.error(err);
+    }
+  })();
+  return new Response(webReadable, {
+    headers: {
+      "Content-Type": "application/gzip",
+      "Content-Disposition": `attachment; filename="${filename}"`,
+      "Cache-Control": "no-cache"
+    }
+  });
+});
+exchangeRouter.post("/api/moderate/exchange/import", async (c) => {
+  const formData = await c.req.formData();
+  const file = formData.get("file");
+  if (!file) {
+    return c.json({
+      error: "No file provided"
+    }, 400);
+  }
+  const eventBus2 = c.get("eventBus");
+  const user = c.get("user");
+  const buffer = Buffer.from(await file.arrayBuffer());
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const send = /* @__PURE__ */ __name((data) => {
+        controller.enqueue(encoder.encode(`data: ${JSON.stringify(data)}
+
+`));
+      }, "send");
+      try {
+        const input = new Readable({
+          read() {
+          }
+        });
+        input.push(buffer);
+        input.push(null);
+        send({
+          phase: "started",
+          message: "Importing linked data..."
+        });
+        const result = await importLinkedData(input, {
+          eventBus: eventBus2,
+          userId: userId(user.id)
+        });
+        send({
+          phase: "complete",
+          result: {
+            resourcesCreated: result.resourcesCreated,
+            annotationsCreated: result.annotationsCreated,
+            entityTypesAdded: result.entityTypesAdded
+          }
+        });
+      } catch (err) {
+        send({
+          phase: "error",
+          message: err instanceof Error ? err.message : String(err)
+        });
+      } finally {
+        controller.close();
+      }
+    }
+  });
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      "Connection": "keep-alive"
+    }
+  });
+});
 function createResourceRouter() {
   const router = new Hono();
   router.use("/api/resources/*", authMiddleware);
@@ -16129,7 +16451,7 @@ function registerCreateResource(router) {
     const arrayBuffer = await file.arrayBuffer();
     const contentBuffer = Buffer.from(arrayBuffer);
     const eventBus2 = c.get("eventBus");
-    const resourceId17 = await ResourceOperations.createResource({
+    const resourceId20 = await ResourceOperations.createResource({
       name,
       content: contentBuffer,
       format,
@@ -16138,7 +16460,7 @@ function registerCreateResource(router) {
       creationMethod: creationMethod || void 0
     }, userId(user.id), eventBus2);
     return c.json({
-      resourceId: resourceId17
+      resourceId: resourceId20
     }, 202);
   });
 }
@@ -16188,7 +16510,7 @@ function getBodySource(body) {
         const itemType = item.type;
         const itemSource = item.source;
         if (itemType === "SpecificResource" && typeof itemSource === "string") {
-          return resourceUri(itemSource);
+          return itemSource;
         }
       }
     }
@@ -16198,7 +16520,7 @@ function getBodySource(body) {
     const bodyType = body.type;
     const bodySource = body.source;
     if (bodyType === "SpecificResource" && typeof bodySource === "string") {
-      return resourceUri(bodySource);
+      return bodySource;
     }
   }
   return null;
@@ -17868,7 +18190,6 @@ function registerGetResourceLLMContext(router) {
   router.get("/resources/:id/llm-context", async (c) => {
     const { id } = c.req.param();
     const query = c.req.query();
-    const config2 = c.get("config");
     const eventBus2 = c.get("eventBus");
     const depth = query.depth ? Number(query.depth) : 2;
     const maxResources = query.maxResources ? Number(query.maxResources) : 10;
@@ -17884,9 +18205,8 @@ function registerGetResourceLLMContext(router) {
         message: 'Query parameter "maxResources" must be between 1 and 20'
       });
     }
-    const resourceUri3 = `${config2.services.backend.publicURL}/resources/${id}`;
     eventBus2.get("gather:resource-requested").next({
-      resourceUri: resourceUri3,
+      resourceId: resourceId(id),
       options: {
         depth,
         maxResources,
@@ -17895,10 +18215,10 @@ function registerGetResourceLLMContext(router) {
       }
     });
     try {
-      const result = await (0, import_rxjs2.firstValueFrom)((0, import_rxjs2.merge)(eventBus2.get("gather:resource-complete").pipe((0, import_operators2.filter)((e) => e.resourceUri === resourceUri3), (0, import_operators2.map)((e) => ({
+      const result = await (0, import_rxjs2.firstValueFrom)((0, import_rxjs2.merge)(eventBus2.get("gather:resource-complete").pipe((0, import_operators2.filter)((e) => e.resourceId === id), (0, import_operators2.map)((e) => ({
         ok: true,
         context: e.context
-      }))), eventBus2.get("gather:resource-failed").pipe((0, import_operators2.filter)((e) => e.resourceUri === resourceUri3), (0, import_operators2.map)((e) => ({
+      }))), eventBus2.get("gather:resource-failed").pipe((0, import_operators2.filter)((e) => e.resourceId === id), (0, import_operators2.map)((e) => ({
         ok: false,
         error: e.error
       })))).pipe((0, import_operators2.take)(1), (0, import_operators2.timeout)(3e4)));
@@ -17932,7 +18252,6 @@ function registerGetAnnotationLLMContext(router) {
   router.get("/resources/:resourceId/annotations/:annotationId/llm-context", async (c) => {
     const { resourceId: resourceIdParam, annotationId: annotationIdParam } = c.req.param();
     const query = c.req.query();
-    const config2 = c.get("config");
     const eventBus2 = c.get("eventBus");
     const includeSourceContext = query.includeSourceContext === "false" ? false : true;
     const includeTargetContext = query.includeTargetContext === "false" ? false : true;
@@ -17942,11 +18261,9 @@ function registerGetAnnotationLLMContext(router) {
         message: 'Query parameter "contextWindow" must be between 100 and 5000'
       });
     }
-    const fullAnnotationUri = `${config2.services.backend.publicURL}/annotations/${annotationIdParam}`;
-    const resourceUri3 = `${config2.services.backend.publicURL}/resources/${resourceIdParam}`;
     eventBus2.get("gather:requested").next({
-      annotationUri: fullAnnotationUri,
-      resourceUri: resourceUri3,
+      annotationId: annotationId(annotationIdParam),
+      resourceId: resourceId(resourceIdParam),
       options: {
         includeSourceContext,
         includeTargetContext,
@@ -17954,10 +18271,10 @@ function registerGetAnnotationLLMContext(router) {
       }
     });
     try {
-      const result = await (0, import_rxjs3.firstValueFrom)((0, import_rxjs3.merge)(eventBus2.get("gather:complete").pipe((0, import_operators3.filter)((e) => e.annotationUri === fullAnnotationUri), (0, import_operators3.map)((e) => ({
+      const result = await (0, import_rxjs3.firstValueFrom)((0, import_rxjs3.merge)(eventBus2.get("gather:complete").pipe((0, import_operators3.filter)((e) => e.annotationId === annotationIdParam), (0, import_operators3.map)((e) => ({
         ok: true,
         response: e.response
-      }))), eventBus2.get("gather:failed").pipe((0, import_operators3.filter)((e) => e.annotationUri === fullAnnotationUri), (0, import_operators3.map)((e) => ({
+      }))), eventBus2.get("gather:failed").pipe((0, import_operators3.filter)((e) => e.annotationId === annotationIdParam), (0, import_operators3.map)((e) => ({
         ok: false,
         error: e.error
       })))).pipe((0, import_operators3.take)(1), (0, import_operators3.timeout)(3e4)));
@@ -18017,6 +18334,129 @@ function registerGetReferencedBy(router) {
   });
 }
 __name(registerGetReferencedBy, "registerGetReferencedBy");
+init_logger();
+function registerBindSearchStream(router) {
+  router.post("/resources/:id/bind-search-stream", async (c) => {
+    const { id } = c.req.param();
+    const logger2 = getLogger().child({
+      component: "bind-search-stream",
+      resourceId: id
+    });
+    const user = c.get("user");
+    if (!user) {
+      throw new HTTPException(401, {
+        message: "Authentication required"
+      });
+    }
+    const body = await c.req.json();
+    const { referenceId, context, limit, useSemanticScoring } = body;
+    if (!referenceId || !context) {
+      throw new HTTPException(400, {
+        message: "referenceId and context are required"
+      });
+    }
+    const eventBus2 = c.get("eventBus");
+    const { kb } = c.get("makeMeaning");
+    const resource = await ResourceContext.getResourceMetadata(resourceId(id), kb);
+    if (!resource) {
+      throw new HTTPException(404, {
+        message: "Resource not found"
+      });
+    }
+    const correlationId = crypto.randomUUID();
+    logger2.info("Starting bind search stream", {
+      referenceId,
+      correlationId
+    });
+    c.header("X-Accel-Buffering", "no");
+    c.header("Cache-Control", "no-cache, no-transform");
+    return streamSSE(c, async (stream) => {
+      let isStreamClosed = false;
+      const subscriptions = [];
+      let closeStreamCallback = null;
+      const streamPromise = new Promise((resolve2) => {
+        closeStreamCallback = resolve2;
+      });
+      const cleanup = /* @__PURE__ */ __name(() => {
+        if (isStreamClosed) return;
+        isStreamClosed = true;
+        subscriptions.forEach((sub) => sub.unsubscribe());
+        if (closeStreamCallback) closeStreamCallback();
+      }, "cleanup");
+      try {
+        subscriptions.push(eventBus2.get("bind:search-results").subscribe(async (event) => {
+          if (event.correlationId !== correlationId) return;
+          if (isStreamClosed) return;
+          logger2.info("Bind search completed", {
+            referenceId,
+            resultCount: event.results.length
+          });
+          try {
+            await writeTypedSSE(stream, {
+              data: JSON.stringify({
+                referenceId: event.referenceId,
+                results: event.results
+              }),
+              event: "bind:search-results",
+              id: String(Date.now())
+            });
+          } catch (error) {
+            logger2.warn("Client disconnected during results");
+          }
+          cleanup();
+        }));
+        subscriptions.push(eventBus2.get("bind:search-failed").subscribe(async (event) => {
+          if (event.correlationId !== correlationId) return;
+          if (isStreamClosed) return;
+          logger2.error("Bind search failed", {
+            referenceId,
+            error: event.error
+          });
+          try {
+            await writeTypedSSE(stream, {
+              data: JSON.stringify({
+                referenceId: event.referenceId,
+                error: event.error.message
+              }),
+              event: "bind:search-failed",
+              id: String(Date.now())
+            });
+          } catch (error) {
+            logger2.warn("Client disconnected during error");
+          }
+          cleanup();
+        }));
+        eventBus2.get("bind:search-requested").next({
+          correlationId,
+          referenceId,
+          context,
+          limit,
+          useSemanticScoring
+        });
+        c.req.raw.signal.addEventListener("abort", () => {
+          logger2.info("Client disconnected from bind search stream");
+          cleanup();
+        });
+      } catch (error) {
+        try {
+          await writeTypedSSE(stream, {
+            data: JSON.stringify({
+              referenceId,
+              error: error instanceof Error ? error.message : "Search failed"
+            }),
+            event: "bind:search-failed",
+            id: String(Date.now())
+          });
+        } catch (sseError) {
+          logger2.warn("Could not send error to client");
+        }
+        cleanup();
+      }
+      return streamPromise;
+    });
+  });
+}
+__name(registerBindSearchStream, "registerBindSearchStream");
 function registerTokenRoutes(router) {
   router.get("/api/clone-tokens/:token", async (c) => {
     const { token } = c.req.param();
@@ -18195,18 +18635,17 @@ init_logger();
 function registerGetEventStream(router) {
   router.get("/resources/:id/events/stream", async (c) => {
     const { id } = c.req.param();
-    const config2 = c.get("config");
     const logger2 = getLogger().child({
       component: "events-stream",
       resourceId: id
     });
-    const rUri = resourceUri(`${config2.services.backend.publicURL}/resources/${id}`);
+    const rId = resourceId(id);
     logger2.info("Client connecting to resource events stream", {
-      resourceUri: rUri
+      resourceId: rId
     });
     const { eventStore } = c.get("makeMeaning");
     const query = new EventQuery(eventStore.log.storage);
-    const events = await query.getResourceEvents(resourceId(id));
+    const events = await query.getResourceEvents(rId);
     if (events.length === 0) {
       logger2.warn("Resource not found - no events exist");
       throw new HTTPException(404, {
@@ -18249,11 +18688,11 @@ function registerGetEventStream(router) {
         }
       }, "cleanup");
       const streamId = `${id.substring(0, 16)}...${Math.random().toString(36).substring(7)}`;
-      logger2.info("Subscribing to events for resource URI", {
+      logger2.info("Subscribing to events for resource", {
         streamId,
-        resourceUri: rUri
+        resourceId: rId
       });
-      subscription = eventStore.bus.subscriptions.subscribe(rUri, async (storedEvent) => {
+      subscription = eventStore.bus.subscriptions.subscribe(rId, async (storedEvent) => {
         if (isStreamClosed) {
           logger2.info("Stream already closed, ignoring event", {
             streamId,
@@ -18284,14 +18723,7 @@ function registerGetEventStream(router) {
           });
           let jsonData;
           try {
-            const startStringify = Date.now();
             jsonData = JSON.stringify(eventData);
-            const stringifyTime = Date.now() - startStringify;
-            logger2.info("JSON.stringify completed", {
-              streamId,
-              time: stringifyTime,
-              size: jsonData.length
-            });
           } catch (stringifyError) {
             logger2.error("JSON.stringify FAILED", {
               streamId,
@@ -18299,23 +18731,14 @@ function registerGetEventStream(router) {
             });
             throw stringifyError;
           }
-          if (storedEvent.event.type === "annotation.body.updated") {
-            logger2.info("annotation.body.updated payload", {
-              streamId,
-              payload: storedEvent.event.payload
-            });
-          }
-          const startWrite = Date.now();
           await stream.writeSSE({
             data: jsonData,
             event: storedEvent.event.type,
             id: storedEvent.metadata.sequenceNumber.toString()
           });
-          const writeTime = Date.now() - startWrite;
           logger2.info("Successfully wrote event to SSE stream", {
             streamId,
-            eventType: storedEvent.event.type,
-            time: writeTime
+            eventType: storedEvent.event.type
           });
         } catch (error) {
           logger2.error("Error writing event to SSE stream", {
@@ -18355,16 +18778,9 @@ function registerCreateAnnotation(router) {
     const { id } = c.req.param();
     const request = c.get("validatedBody");
     const user = c.get("user");
-    const config2 = c.get("config");
-    const backendUrl = config2.services.backend?.publicURL;
-    if (!backendUrl) {
-      throw new HTTPException(500, {
-        message: "Backend publicURL not configured"
-      });
-    }
     let annotation;
     try {
-      ({ annotation } = assembleAnnotation(request, userToAgent(user), backendUrl));
+      ({ annotation } = assembleAnnotation(request, userToAgent(user)));
     } catch (error) {
       if (error instanceof Error) {
         throw new HTTPException(400, {
@@ -18459,7 +18875,6 @@ function registerYieldResourceStream(router, jobQueue) {
       body
     });
     const user = c.get("user");
-    const config2 = c.get("config");
     if (!user) {
       throw new HTTPException(401, {
         message: "Authentication required"
@@ -18476,14 +18891,13 @@ function registerYieldResourceStream(router, jobQueue) {
       count: linkingAnnotations.length,
       ids: linkingAnnotations.map((a) => a.id)
     });
-    const expectedAnnotationUri = `${config2.services.backend.publicURL}/annotations/${annotationIdParam}`;
-    logger2.info("Looking for annotation URI", {
-      expectedAnnotationUri
+    logger2.info("Looking for annotation", {
+      annotationId: annotationIdParam
     });
-    const reference = projection.annotations.find((a) => a.id === expectedAnnotationUri && a.motivation === "linking");
+    const reference = projection.annotations.find((a) => a.id === annotationIdParam && a.motivation === "linking");
     if (!reference) {
       logger2.warn("Annotation not found", {
-        expectedUri: expectedAnnotationUri,
+        expectedId: annotationIdParam,
         availableIds: projection.annotations.map((a) => a.id)
       });
       throw new HTTPException(404, {
@@ -18665,14 +19079,14 @@ function registerYieldResourceStream(router, jobQueue) {
 __name(registerYieldResourceStream, "registerYieldResourceStream");
 function registerGetAnnotationHistory(router) {
   router.get("/resources/:resourceId/annotations/:annotationId/history", async (c) => {
-    const { resourceId: resourceId17, annotationId: annotationId5 } = c.req.param();
+    const { resourceId: resourceId20, annotationId: annotationId6 } = c.req.param();
     const eventBus2 = c.get("eventBus");
     const correlationId = crypto.randomUUID();
     try {
       const response = await eventBusRequest(eventBus2, "browse:annotation-history-requested", {
         correlationId,
-        resourceId: resourceId(resourceId17),
-        annotationId: annotationId(annotationId5)
+        resourceId: resourceId(resourceId20),
+        annotationId: annotationId(annotationId6)
       }, "browse:annotation-history-result", "browse:annotation-history-failed");
       return c.json(response);
     } catch (error) {
@@ -18713,6 +19127,7 @@ function createResourcesRouter(jobQueue) {
   registerGetResourceLLMContext(resourcesRouter2);
   registerGetAnnotationLLMContext(resourcesRouter2);
   registerGetReferencedBy(resourcesRouter2);
+  registerBindSearchStream(resourcesRouter2);
   registerGetResourceAnnotations(resourcesRouter2);
   registerCreateAnnotation(resourcesRouter2);
   registerGetAnnotation(resourcesRouter2);
@@ -18739,39 +19154,30 @@ function registerGetAnnotationUri(router) {
     const { id } = c.req.param();
     const query = c.req.query();
     const { kb } = c.get("makeMeaning");
-    const resourceUriOrId = query.resourceId;
-    if (!resourceUriOrId) {
+    const resourceIdParam = query.resourceId;
+    if (!resourceIdParam) {
       throw new HTTPException(400, {
         message: "resourceId query parameter is required"
       });
     }
-    let extractedResourceId;
-    try {
-      extractedResourceId = resourceUriOrId.includes("://") ? uriToResourceId(resourceUriOrId) : resourceUriOrId;
-    } catch (error) {
-      throw new HTTPException(400, {
-        message: "Invalid resourceId parameter"
-      });
-    }
     if (prefersHtml(c)) {
       const frontendUrl = getFrontendUrl();
       const normalizedBase = frontendUrl.endsWith("/") ? frontendUrl.slice(0, -1) : frontendUrl;
-      const redirectUrl = `${normalizedBase}/annotations/${id}?resourceId=${extractedResourceId}`;
+      const redirectUrl = `${normalizedBase}/annotations/${id}?resourceId=${resourceIdParam}`;
       return c.redirect(redirectUrl, 302);
     }
-    const projection = await AnnotationContext.getResourceAnnotations(resourceId(extractedResourceId), kb);
+    const projection = await AnnotationContext.getResourceAnnotations(resourceId(resourceIdParam), kb);
     const annotation = projection.annotations.find((a) => a.id === id);
     if (!annotation) {
       throw new HTTPException(404, {
         message: "Annotation not found in resource"
       });
     }
-    const resource = await ResourceContext.getResourceMetadata(resourceId(extractedResourceId), kb);
+    const resource = await ResourceContext.getResourceMetadata(resourceId(resourceIdParam), kb);
     let resolvedResource = null;
     const bodySource = getBodySource(annotation.body);
     if (annotation.motivation === "linking" && bodySource) {
-      const bodyDocId = bodySource.includes("://") ? uriToResourceId(bodySource) : bodySource;
-      resolvedResource = await ResourceContext.getResourceMetadata(resourceId(bodyDocId), kb);
+      resolvedResource = await ResourceContext.getResourceMetadata(resourceId(bodySource), kb);
     }
     const response = {
       annotation,
@@ -18788,8 +19194,8 @@ operationsRouter.get("/api/annotations/:id/context", async (c) => {
   const { id } = c.req.param();
   const query = c.req.query();
   const { kb } = c.get("makeMeaning");
-  const resourceId17 = query.resourceId;
-  if (!resourceId17) {
+  const resourceId20 = query.resourceId;
+  if (!resourceId20) {
     throw new HTTPException(400, {
       message: "resourceId query parameter is required"
     });
@@ -18807,7 +19213,7 @@ operationsRouter.get("/api/annotations/:id/context", async (c) => {
     });
   }
   try {
-    const response = await AnnotationContext.getAnnotationContext(annotationId(id), resourceId(resourceId17), contextBefore, contextAfter, kb);
+    const response = await AnnotationContext.getAnnotationContext(annotationId(id), resourceId(resourceId20), contextBefore, contextAfter, kb);
     return c.json(response);
   } catch (error) {
     if (error instanceof Error && error.message === "Annotation not found") {
@@ -18837,14 +19243,14 @@ operationsRouter.get("/api/annotations/:id/summary", async (c) => {
   const { id } = c.req.param();
   const query = c.req.query();
   const { kb, inferenceClient } = c.get("makeMeaning");
-  const resourceId17 = query.resourceId;
-  if (!resourceId17) {
+  const resourceId20 = query.resourceId;
+  if (!resourceId20) {
     throw new HTTPException(400, {
       message: "resourceId query parameter is required"
     });
   }
   try {
-    const response = await AnnotationContext.generateAnnotationSummary(annotationId(id), resourceId(resourceId17), kb, inferenceClient);
+    const response = await AnnotationContext.generateAnnotationSummary(annotationId(id), resourceId(resourceId20), kb, inferenceClient);
     return c.json(response);
   } catch (error) {
     if (error instanceof Error && error.message === "Annotation not found") {
@@ -19205,6 +19611,7 @@ app.route("/", healthRouter);
 app.route("/", authRouter);
 app.route("/", statusRouter);
 app.route("/", adminRouter);
+app.route("/", exchangeRouter);
 var resourcesRouter = createResourcesRouter(makeMeaning.jobQueue);
 app.route("/", resourcesRouter);
 app.route("/", annotationsRouter);
@@ -19271,8 +19678,7 @@ app.all("/api/*", (c) => {
   }, 404);
 });
 var port = backendService.port || 4e3;
-var nodeEnv = config.env?.NODE_ENV || "development";
-if (nodeEnv !== "test") {
+if (config.env?.NODE_ENV !== "test") {
   serve({
     fetch: app.fetch,
     port,
@@ -19280,7 +19686,7 @@ if (nodeEnv !== "test") {
   }, async (info) => {
     logger.info("Semiont Backend ready", {
       url: `http://localhost:${info.port}/api`,
-      environment: nodeEnv
+      environment: config.env?.NODE_ENV ?? "development"
     });
     try {
       const { JWTService: JWTService2 } = await Promise.resolve().then(() => (init_jwt(), jwt_exports));