@semiont/api-client 0.4.13 → 0.4.15

package/dist/index.js

@@ -1,24 +1,19 @@
-import ky from 'ky';
-import { Subscription, BehaviorSubject, merge, firstValueFrom } from 'rxjs';
-import { resourceId, annotationId } from '@semiont/core';
+import ky, { HTTPError } from 'ky';
+import { BehaviorSubject, Observable, merge } from 'rxjs';
+import { map, distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';
+import { annotationId, resourceId, email, googleCredential, refreshToken } from '@semiont/core';
 export { getFragmentSelector, getSvgSelector, getTextPositionSelector, validateSvgMarkup } from '@semiont/core';
-import { map, distinctUntilChanged, filter, take, timeout } from 'rxjs/operators';
 
 // src/client.ts
 
 // src/sse/stream.ts
-var DOMAIN_EVENT_TO_UI_CHANNEL = {
-  "annotation.added": "mark:added",
-  "annotation.removed": "mark:removed",
-  "annotation.body.updated": "mark:body-updated",
-  "resource.archived": "mark:archived",
-  "resource.unarchived": "mark:unarchived",
-  "entitytag.added": "mark:entity-tag-added",
-  "entitytag.removed": "mark:entity-tag-removed"
-};
 function createSSEStream(url, fetchOptions, config, logger) {
-  const abortController = new AbortController();
+  let abortController = new AbortController();
   let closed = false;
+  let lastEventId = null;
+  const RECONNECT_INITIAL_MS = 1e3;
+  const RECONNECT_MAX_MS = 3e4;
+  let reconnectDelayMs = RECONNECT_INITIAL_MS;
   const connect = async () => {
     try {
       logger?.debug("SSE Stream Request", {
@@ -27,13 +22,17 @@ function createSSEStream(url, fetchOptions, config, logger) {
         method: fetchOptions.method || "GET",
         timestamp: Date.now()
       });
+      const headers = {
+        ...fetchOptions.headers,
+        "Accept": "text/event-stream"
+      };
+      if (lastEventId !== null) {
+        headers["Last-Event-ID"] = lastEventId;
+      }
       const response = await fetch(url, {
         ...fetchOptions,
         signal: abortController.signal,
-        headers: {
-          ...fetchOptions.headers,
-          "Accept": "text/event-stream"
-        }
+        headers
       });
       if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));
@@ -117,10 +116,13 @@ function createSSEStream(url, fetchOptions, config, logger) {
       }
     }
   };
-  const handleEvent = (eventType, data, _id) => {
+  const handleEvent = (eventType, data, id) => {
     if (data.startsWith(":")) {
       return;
     }
+    if (id) {
+      lastEventId = id;
+    }
     try {
       const parsed = JSON.parse(data);
       logger?.debug("SSE Event Received", {
@@ -129,13 +131,8 @@ function createSSEStream(url, fetchOptions, config, logger) {
         event: eventType || "message",
         hasData: !!data
       });
-      if (typeof parsed === "object" && parsed !== null && "type" in parsed) {
+      if (typeof parsed === "object" && parsed !== null && "metadata" in parsed) {
         config.eventBus.get(eventType).next(parsed);
-        const uiChannel = DOMAIN_EVENT_TO_UI_CHANNEL[parsed.type];
-        if (uiChannel) {
-          config.eventBus.get(uiChannel).next(parsed);
-        }
-        config.eventBus.get("make-meaning:event").next(parsed);
         return;
       }
       config.eventBus.get(eventType).next(parsed);
@@ -150,9 +147,33 @@ function createSSEStream(url, fetchOptions, config, logger) {
       logger?.error("SSE Failed to parse event data", { error, eventType, data });
     }
   };
-  connect();
+  const runConnect = async () => {
+    if (!config.reconnect) {
+      return connect();
+    }
+    while (!closed) {
+      abortController = new AbortController();
+      try {
+        await connect();
+        if (closed) return;
+        logger?.info("SSE Stream ended cleanly; reconnecting", { url });
+      } catch (error) {
+        if (closed) return;
+        if (error instanceof Error && error.name === "AbortError") return;
+        logger?.warn("SSE Stream errored; reconnecting", {
+          url,
+          error: error instanceof Error ? error.message : String(error),
+          delayMs: reconnectDelayMs
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, reconnectDelayMs));
+      reconnectDelayMs = Math.min(reconnectDelayMs * 2, RECONNECT_MAX_MS);
+    }
+  };
+  void runConnect();
   return {
     close() {
+      closed = true;
       abortController.abort();
     }
   };
@@ -179,459 +200,6 @@ var SSEClient = class {
     }
     return headers;
   }
-  /**
-   * Detect annotations in a resource (streaming)
-   *
-   * Streams entity detection progress via Server-Sent Events.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param request - Detection configuration (entity types to detect)
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.markReferences(
-   *   'http://localhost:4000/resources/doc-123',
-   *   { entityTypes: ['Person', 'Organization'] },
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((progress) => {
-   *   console.log(`Scanning: ${progress.currentEntityType}`);
-   *   console.log(`Progress: ${progress.processedEntityTypes}/${progress.totalEntityTypes}`);
-   * });
-   *
-   * stream.onComplete((result) => {
-   *   console.log(`Detection complete! Found ${result.foundCount} entities`);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Detection failed:', error.message);
-   * });
-   *
-   * // Cleanup when done
-   * stream.close();
-   * ```
-   */
-  markReferences(resourceId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotate-references-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["mark:progress"],
-        completeEvent: "mark:assist-finished",
-        errorEvent: "mark:assist-failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Generate resource from annotation (streaming)
-   *
-   * Streams resource generation progress via Server-Sent Events.
-   *
-   * @param resourceId - Source resource URI or ID
-   * @param annotationId - Annotation URI or ID to use as generation source
-   * @param request - Generation options (title, prompt, language)
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.yieldResource(
-   *   'http://localhost:4000/resources/doc-123',
-   *   'http://localhost:4000/annotations/ann-456',
-   *   { language: 'es', title: 'Spanish Summary' },
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((progress) => {
-   *   console.log(`${progress.status}: ${progress.percentage}%`);
-   *   console.log(progress.message);
-   * });
-   *
-   * stream.onComplete((result) => {
-   *   console.log(`Yielded resource: ${result.resourceId}`);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Yield failed:', error.message);
-   * });
-   *
-   * // Cleanup when done
-   * stream.close();
-   * ```
-   */
-  yieldResource(resourceId, annotationId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/yield-resource-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["yield:progress"],
-        completeEvent: "yield:finished",
-        errorEvent: "yield:failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Detect highlights in a resource (streaming)
-   *
-   * Streams highlight annotation progress via Server-Sent Events.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param request - Detection configuration (optional instructions)
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.markHighlights(
-   *   'http://localhost:4000/resources/doc-123',
-   *   { instructions: 'Focus on key technical points' },
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((progress) => {
-   *   console.log(`${progress.status}: ${progress.percentage}%`);
-   *   console.log(progress.message);
-   * });
-   *
-   * stream.onComplete((result) => {
-   *   console.log(`Detection complete! Created ${result.createdCount} highlights`);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Detection failed:', error.message);
-   * });
-   *
-   * // Cleanup when done
-   * stream.close();
-   * ```
-   */
-  markHighlights(resourceId, request = {}, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotate-highlights-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["mark:progress"],
-        completeEvent: "mark:assist-finished",
-        errorEvent: "mark:assist-failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Detect assessments in a resource (streaming)
-   *
-   * Streams assessment annotation progress via Server-Sent Events.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param request - Detection configuration (optional instructions)
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.markAssessments(
-   *   'http://localhost:4000/resources/doc-123',
-   *   { instructions: 'Evaluate claims for accuracy' },
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((progress) => {
-   *   console.log(`${progress.status}: ${progress.percentage}%`);
-   *   console.log(progress.message);
-   * });
-   *
-   * stream.onComplete((result) => {
-   *   console.log(`Detection complete! Created ${result.createdCount} assessments`);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Detection failed:', error.message);
-   * });
-   *
-   * // Cleanup when done
-   * stream.close();
-   * ```
-   */
-  markAssessments(resourceId, request = {}, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotate-assessments-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["mark:progress"],
-        completeEvent: "mark:assist-finished",
-        errorEvent: "mark:assist-failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Detect comments in a resource (streaming)
-   *
-   * Streams comment annotation progress via Server-Sent Events.
-   * Uses AI to identify passages that would benefit from explanatory comments
-   * and creates comment annotations with contextual information.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param request - Detection configuration (optional instructions and tone)
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.markComments(
-   *   'http://localhost:4000/resources/doc-123',
-   *   {
-   *     instructions: 'Focus on technical terminology',
-   *     tone: 'scholarly'
-   *   },
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((progress) => {
-   *   console.log(`${progress.status}: ${progress.percentage}%`);
-   * });
-   *
-   * stream.onComplete((result) => {
-   *   console.log(`Detection complete! Created ${result.createdCount} comments`);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Detection failed:', error.message);
-   * });
-   *
-   * // Cleanup when done
-   * stream.close();
-   * ```
-   */
-  markComments(resourceId, request = {}, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotate-comments-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["mark:progress"],
-        completeEvent: "mark:assist-finished",
-        errorEvent: "mark:assist-failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Detect tags in a resource (streaming)
-   *
-   * Streams tag annotation progress via Server-Sent Events.
-   * Uses AI to identify passages serving specific structural roles
-   * (e.g., IRAC, IMRAD, Toulmin) and creates tag annotations with dual-body structure.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param request - Detection configuration (schema and categories to detect)
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.markTags(
-   *   'http://localhost:4000/resources/doc-123',
-   *   {
-   *     schemaId: 'legal-irac',
-   *     categories: ['Issue', 'Rule', 'Application', 'Conclusion']
-   *   },
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((progress) => {
-   *   console.log(`${progress.status}: ${progress.percentage}%`);
-   *   console.log(`Processing ${progress.currentCategory}...`);
-   * });
-   *
-   * stream.onComplete((result) => {
-   *   console.log(`Detection complete! Created ${result.tagsCreated} tags`);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Detection failed:', error.message);
-   * });
-   *
-   * // Cleanup when done
-   * stream.close();
-   * ```
-   */
-  markTags(resourceId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotate-tags-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["mark:progress"],
-        completeEvent: "mark:assist-finished",
-        errorEvent: "mark:assist-failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Gather LLM context for a resource (streaming)
-   *
-   * Streams resource LLM context gathering progress via Server-Sent Events.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param request - Gather configuration (depth, maxResources, includeContent, includeSummary)
-   * @param options - Request options (auth token, eventBus)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   */
-  gatherResource(resourceId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/gather-resource-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["gather:progress"],
-        completeEvent: "gather:finished",
-        errorEvent: "gather:failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Gather LLM context for an annotation (streaming)
-   *
-   * Streams annotation LLM context gathering progress via Server-Sent Events.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param annotationId - Annotation URI or ID
-   * @param request - Gather configuration (contextWindow)
-   * @param options - Request options (auth token, eventBus)
-   * @returns SSE stream controller with progress/complete/error callbacks
-   */
-  gatherAnnotation(resourceId, annotationId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/gather-annotation-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: ["gather:annotation-progress"],
-        completeEvent: "gather:annotation-finished",
-        errorEvent: "gather:failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Bind annotation body (streaming)
-   *
-   * Applies annotation body operations and streams completion via Server-Sent Events.
-   *
-   * @param resourceId - Resource URI or ID
-   * @param annotationId - Annotation URI or ID
-   * @param request - Bind operations (resourceId + operations array)
-   * @param options - Request options (auth token, eventBus)
-   * @returns SSE stream controller with complete/error callbacks
-   */
-  bindAnnotation(resourceId, annotationId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/bind-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: [],
-        completeEvent: "bind:finished",
-        errorEvent: "bind:failed",
-        eventBus: options.eventBus,
-        eventPrefix: void 0
-      },
-      this.logger
-    );
-  }
-  /**
-   * Search for binding candidates (streaming)
-   *
-   * Bridges match:search-requested to the backend Matcher actor via SSE.
-   * Results emit as match:search-results on the browser EventBus.
-   *
-   * @param resourceId - Resource the annotation belongs to
-   * @param request - Search configuration (referenceId, context, limit)
-   * @param options - Request options (auth token, eventBus)
-   * @returns SSE stream controller
-   */
-  matchSearch(resourceId, request, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/match-search-stream`;
-    return createSSEStream(
-      url,
-      {
-        method: "POST",
-        headers: this.getHeaders(options.auth),
-        body: JSON.stringify(request)
-      },
-      {
-        progressEvents: [],
-        completeEvent: "match:search-results",
-        errorEvent: "match:search-failed",
-        eventBus: options.eventBus
-      },
-      this.logger
-    );
-  }
   /**
    * Subscribe to resource events (long-lived stream)
    *
@@ -681,7 +249,8 @@ var SSEClient = class {
         // Never completes (long-lived)
         errorEvent: null,
         // No error event (errors throw)
-        eventBus: options.eventBus
+        eventBus: options.eventBus,
+        reconnect: true
       },
       this.logger
     );
@@ -706,11 +275,9 @@ var SSEClient = class {
    * ```typescript
    * const stream = sseClient.globalEvents({ auth: 'your-token', eventBus });
    *
-   * // Events auto-emit to EventBus — subscribe there
-   * eventBus.get('make-meaning:event').subscribe((event) => {
-   *   if (event.type === 'entitytype.added') {
-   *     // Invalidate entity types query
-   *   }
+   * // Events auto-emit to EventBus typed channels — subscribe there
+   * eventBus.get('mark:entity-type-added').subscribe((stored) => {
+   *   // Invalidate entity types query
    * });
    *
    * // Close when no longer needed
@@ -729,7 +296,8 @@ var SSEClient = class {
         progressEvents: ["*"],
         completeEvent: null,
         errorEvent: null,
-        eventBus: options.eventBus
+        eventBus: options.eventBus,
+        reconnect: true
       },
       this.logger
     );
@@ -765,7 +333,8 @@ var SSEClient = class {
         progressEvents: ["*"],
         completeEvent: null,
         errorEvent: null,
-        eventBus: options.eventBus
+        eventBus: options.eventBus,
+        reconnect: true
       },
       this.logger
     );
@@ -778,497 +347,693 @@ var SSEClient = class {
     return stream;
   }
 };
-var FlowEngine = class {
-  constructor(eventBus, sse, http) {
-    this.eventBus = eventBus;
-    this.sse = sse;
+var BrowseNamespace = class {
+  constructor(http, eventBus, getToken) {
     this.http = http;
+    this.eventBus = eventBus;
+    this.getToken = getToken;
+    this.subscribeToEvents();
+  }
+  // ── Annotation list cache ───────────────────────────────────────────────
+  annotationList$ = new BehaviorSubject(/* @__PURE__ */ new Map());
+  fetchingAnnotationList = /* @__PURE__ */ new Set();
+  annotationListObs$ = /* @__PURE__ */ new Map();
+  // ── Annotation detail cache ─────────────────────────────────────────────
+  annotationDetail$ = new BehaviorSubject(/* @__PURE__ */ new Map());
+  fetchingAnnotationDetail = /* @__PURE__ */ new Set();
+  annotationDetailObs$ = /* @__PURE__ */ new Map();
+  // ── Resource detail cache ───────────────────────────────────────────────
+  resourceDetail$ = new BehaviorSubject(/* @__PURE__ */ new Map());
+  fetchingResourceDetail = /* @__PURE__ */ new Set();
+  resourceDetailObs$ = /* @__PURE__ */ new Map();
+  // ── Resource list cache ─────────────────────────────────────────────────
+  resourceList$ = new BehaviorSubject(/* @__PURE__ */ new Map());
+  fetchingResourceList = /* @__PURE__ */ new Set();
+  resourceListObs$ = /* @__PURE__ */ new Map();
+  // ── Entity types cache ──────────────────────────────────────────────────
+  entityTypes$ = new BehaviorSubject(void 0);
+  fetchingEntityTypes = false;
+  // ── Referenced-by cache ─────────────────────────────────────────────────
+  referencedBy$ = new BehaviorSubject(/* @__PURE__ */ new Map());
+  fetchingReferencedBy = /* @__PURE__ */ new Set();
+  referencedByObs$ = /* @__PURE__ */ new Map();
+  getToken;
+  // ── Live queries ────────────────────────────────────────────────────────
+  resource(resourceId) {
+    if (!this.resourceDetail$.value.has(resourceId) && !this.fetchingResourceDetail.has(resourceId)) {
+      this.fetchResourceDetail(resourceId);
+    }
+    let obs = this.resourceDetailObs$.get(resourceId);
+    if (!obs) {
+      obs = this.resourceDetail$.pipe(map((m) => m.get(resourceId)), distinctUntilChanged());
+      this.resourceDetailObs$.set(resourceId, obs);
+    }
+    return obs;
   }
-  // ─── bind flow ─────────────────────────────────────────────────────────────
-  /**
-   * Activate the bind flow for a resource.
-   *
-   * @subscribes bind:update-body  — calls SSE bindAnnotation
-   * @subscribes match:search-requested — calls SSE bindSearch
-   * @emits bind:body-updated, bind:body-update-failed
-   */
-  bind(rUri, getToken) {
-    const sub = new Subscription();
-    sub.add(
-      this.eventBus.get("bind:update-body").subscribe((event) => {
-        const annotationId = event.annotationId;
-        const finishedSub = this.eventBus.get("bind:finished").subscribe((finishedEvent) => {
-          if (finishedEvent.annotationId !== annotationId) return;
-          finishedSub.unsubscribe();
-          failedSub.unsubscribe();
-          this.eventBus.get("bind:body-updated").next({ annotationId });
-        });
-        const failedSub = this.eventBus.get("bind:failed").subscribe(() => {
-          finishedSub.unsubscribe();
-          failedSub.unsubscribe();
-          this.eventBus.get("bind:body-update-failed").next({ error: new Error("Bind failed") });
-        });
-        this.sse.bindAnnotation(
-          rUri,
-          annotationId,
-          { resourceId: event.resourceId, operations: event.operations },
-          { auth: getToken(), eventBus: this.eventBus }
-        );
-      })
-    );
-    sub.add(
-      this.eventBus.get("match:search-requested").subscribe((event) => {
-        this.sse.matchSearch(rUri, {
-          correlationId: event.correlationId,
-          referenceId: event.referenceId,
-          context: event.context,
-          limit: event.limit,
-          useSemanticScoring: event.useSemanticScoring
-        }, { auth: getToken(), eventBus: this.eventBus });
-      })
-    );
-    return sub;
+  resources(filters) {
+    const key = JSON.stringify(filters ?? {});
+    if (!this.resourceList$.value.has(key) && !this.fetchingResourceList.has(key)) {
+      this.fetchResourceList(key, filters);
+    }
+    let obs = this.resourceListObs$.get(key);
+    if (!obs) {
+      obs = this.resourceList$.pipe(map((m) => m.get(key)), distinctUntilChanged());
+      this.resourceListObs$.set(key, obs);
+    }
+    return obs;
   }
-  // ─── yield flow ────────────────────────────────────────────────────────────
-  /**
-   * Activate the yield (generation) flow for a resource.
-   *
-   * @subscribes yield:request — calls SSE yieldResource
-   * @subscribes yield:finished — links generated resource back to the reference annotation via bind:update-body
-   * @subscribes job:cancel-requested (generation) — aborts in-flight stream
-   */
-  yield(_rUri, getToken) {
-    const sub = new Subscription();
-    let abortController = null;
-    sub.add(
-      this.eventBus.get("yield:request").subscribe((event) => {
-        abortController?.abort();
-        abortController = new AbortController();
-        this.sse.yieldResource(
-          event.resourceId,
-          event.annotationId,
-          event.options,
-          { auth: getToken(), eventBus: this.eventBus }
-        );
-      })
-    );
-    sub.add(
-      this.eventBus.get("yield:finished").subscribe((event) => {
-        if (!event.resourceId || !event.referenceId || !event.sourceResourceId) return;
-        this.eventBus.get("bind:update-body").next({
-          annotationId: annotationId(event.referenceId),
-          resourceId: resourceId(event.sourceResourceId),
-          operations: [{ op: "add", item: { type: "SpecificResource", source: event.resourceId } }]
-        });
-      })
-    );
-    sub.add(
-      this.eventBus.get("job:cancel-requested").subscribe((event) => {
-        if (event.jobType === "generation") {
-          abortController?.abort();
-          abortController = null;
-        }
-      })
-    );
-    sub.add(new Subscription(() => {
-      abortController?.abort();
-    }));
-    return sub;
+  annotations(resourceId) {
+    if (!this.annotationList$.value.has(resourceId) && !this.fetchingAnnotationList.has(resourceId)) {
+      this.fetchAnnotationList(resourceId);
+    }
+    let obs = this.annotationListObs$.get(resourceId);
+    if (!obs) {
+      obs = this.annotationList$.pipe(
+        map((m) => m.get(resourceId)?.annotations),
+        distinctUntilChanged()
+      );
+      this.annotationListObs$.set(resourceId, obs);
+    }
+    return obs;
   }
-  // ─── mark flow ─────────────────────────────────────────────────────────────
-  /**
-   * Activate the mark (annotation CRUD + assist) flow for a resource.
-   *
-   * @subscribes mark:submit — HTTP markAnnotation
-   * @subscribes mark:delete — HTTP deleteAnnotation
-   * @subscribes mark:assist-request — SSE mark* (by motivation)
-   * @subscribes job:cancel-requested (annotation) — aborts in-flight assist
-   * @emits mark:created, mark:create-failed, mark:deleted, mark:delete-failed
-   */
-  mark(rUri, getToken) {
-    const sub = new Subscription();
-    let assistAbort = null;
-    sub.add(
-      this.eventBus.get("mark:submit").subscribe(async (event) => {
-        try {
-          const result = await this.http.markAnnotation(rUri, {
-            motivation: event.motivation,
-            target: { source: rUri, selector: event.selector },
-            body: event.body
-          }, { auth: getToken() });
-          this.eventBus.get("mark:created").next({ annotationId: annotationId(result.annotationId) });
-        } catch (error) {
-          this.eventBus.get("mark:create-failed").next({ error });
-        }
-      })
-    );
-    sub.add(
-      this.eventBus.get("mark:delete").subscribe(async (event) => {
-        try {
-          await this.http.deleteAnnotation(rUri, event.annotationId, { auth: getToken() });
-          this.eventBus.get("mark:deleted").next({ annotationId: event.annotationId });
-        } catch (error) {
-          this.eventBus.get("mark:delete-failed").next({ error });
-        }
-      })
-    );
-    sub.add(
-      this.eventBus.get("mark:assist-request").subscribe(async (event) => {
-        assistAbort?.abort();
-        assistAbort = new AbortController();
-        const opts = { auth: getToken(), eventBus: this.eventBus };
-        const { motivation, options } = event;
-        try {
-          if (motivation === "tagging") {
-            const { schemaId, categories } = options;
-            if (!schemaId || !categories?.length) throw new Error("Tag assist requires schemaId and categories");
-            this.sse.markTags(rUri, { schemaId, categories }, opts);
-          } else if (motivation === "linking") {
-            const { entityTypes, includeDescriptiveReferences } = options;
-            if (!entityTypes?.length) throw new Error("Reference assist requires entityTypes");
-            this.sse.markReferences(rUri, {
-              entityTypes,
-              includeDescriptiveReferences: includeDescriptiveReferences ?? false
-            }, opts);
-          } else if (motivation === "highlighting") {
-            this.sse.markHighlights(rUri, { instructions: options.instructions, density: options.density }, opts);
-          } else if (motivation === "assessing") {
-            this.sse.markAssessments(rUri, {
-              instructions: options.instructions,
-              tone: options.tone,
-              density: options.density,
-              language: options.language
-            }, opts);
-          } else if (motivation === "commenting") {
-            this.sse.markComments(rUri, {
-              instructions: options.instructions,
-              tone: options.tone,
-              density: options.density,
-              language: options.language
-            }, opts);
-          }
-        } catch (error) {
-          if (error instanceof Error && error.name === "AbortError") {
-            this.eventBus.get("mark:assist-cancelled").next(void 0);
-          }
-        }
-      })
-    );
-    sub.add(
-      this.eventBus.get("job:cancel-requested").subscribe((event) => {
-        if (event.jobType === "annotation") {
-          assistAbort?.abort();
-          assistAbort = null;
-        }
-      })
-    );
-    sub.add(new Subscription(() => {
-      assistAbort?.abort();
-    }));
-    return sub;
+  annotation(resourceId, annotationId) {
+    if (!this.annotationDetail$.value.has(annotationId) && !this.fetchingAnnotationDetail.has(annotationId)) {
+      this.fetchAnnotationDetail(resourceId, annotationId);
+    }
+    let obs = this.annotationDetailObs$.get(annotationId);
+    if (!obs) {
+      obs = this.annotationDetail$.pipe(map((m) => m.get(annotationId)), distinctUntilChanged());
+      this.annotationDetailObs$.set(annotationId, obs);
+    }
+    return obs;
   }
-  // ─── gatherContext flow ─────────────────────────────────────────────────────
-  /**
-   * Activate the gather-context flow for a resource.
-   *
-   * @subscribes gather:requested — calls SSE gatherAnnotation, threads correlationId
-   * @emits gather:complete (re-emitted from SSE gather:annotation-finished)
-   */
-  gatherContext(rUri, getToken) {
-    return this.eventBus.get("gather:requested").subscribe((event) => {
-      const { correlationId } = event;
-      const contextWindow = event.options?.contextWindow ?? 2e3;
-      const finishedSub = this.eventBus.get("gather:annotation-finished").subscribe((finishedEvent) => {
-        if (finishedEvent.correlationId !== correlationId) return;
-        finishedSub.unsubscribe();
-        failedSub.unsubscribe();
-        this.eventBus.get("gather:complete").next({
-          correlationId,
-          annotationId: finishedEvent.annotationId,
-          response: finishedEvent.response
-        });
-      });
-      const failedSub = this.eventBus.get("gather:failed").subscribe((failedEvent) => {
-        if (failedEvent.correlationId !== correlationId) return;
-        finishedSub.unsubscribe();
-        failedSub.unsubscribe();
-      });
-      this.sse.gatherAnnotation(
-        rUri,
-        event.annotationId,
-        { contextWindow, correlationId },
-        { auth: getToken(), eventBus: this.eventBus }
-      );
+  entityTypes() {
+    if (this.entityTypes$.value === void 0 && !this.fetchingEntityTypes) {
+      this.fetchEntityTypes();
+    }
+    return this.entityTypes$.asObservable();
+  }
+  referencedBy(resourceId) {
+    if (!this.referencedBy$.value.has(resourceId) && !this.fetchingReferencedBy.has(resourceId)) {
+      this.fetchReferencedBy(resourceId);
+    }
+    let obs = this.referencedByObs$.get(resourceId);
+    if (!obs) {
+      obs = this.referencedBy$.pipe(map((m) => m.get(resourceId)), distinctUntilChanged());
+      this.referencedByObs$.set(resourceId, obs);
+    }
+    return obs;
+  }
+  // ── One-shot reads ──────────────────────────────────────────────────────
+  async resourceContent(resourceId) {
+    const result = await this.http.getResourceRepresentation(resourceId, {
+      accept: "text/plain",
+      auth: this.getToken()
     });
+    const decoder = new TextDecoder();
+    return decoder.decode(result.data);
   }
-  // ─── resourceEvents flow ───────────────────────────────────────────────────
-  /**
-   * Open the long-lived resource-events SSE stream.
-   * Returns a Subscription whose teardown closes the stream.
-   */
-  resourceEvents(rUri, getToken) {
-    const stream = this.sse.resourceEvents(rUri, {
-      auth: getToken(),
-      eventBus: this.eventBus
+  async resourceRepresentation(resourceId, options) {
+    return this.http.getResourceRepresentation(resourceId, {
+      accept: options?.accept,
+      auth: this.getToken()
     });
-    return new Subscription(() => stream.close());
   }
-  // ─── attentionStream flow ──────────────────────────────────────────────────
-  /**
-   * Open the long-lived participant attention SSE stream.
-   * Returns a Subscription whose teardown closes the stream.
-   */
-  attentionStream(getToken) {
-    const stream = this.sse.attentionStream({
-      auth: getToken(),
-      eventBus: this.eventBus
+  async resourceRepresentationStream(resourceId, options) {
+    return this.http.getResourceRepresentationStream(resourceId, {
+      accept: options?.accept,
+      auth: this.getToken()
     });
-    return new Subscription(() => stream.close());
   }
-};
-var ResourceStore = class {
-  constructor(http, eventBus) {
-    this.http = http;
-    eventBus.get("yield:created").subscribe((event) => {
-      this.fetchDetail(event.resourceId);
-      this.invalidateLists();
+  async resourceEvents(resourceId) {
+    const result = await this.http.getResourceEvents(resourceId, { auth: this.getToken() });
+    return result.events;
+  }
+  async annotationHistory(resourceId, annotationId) {
+    return this.http.getAnnotationHistory(resourceId, annotationId, { auth: this.getToken() });
+  }
+  async connections(_resourceId) {
+    throw new Error("Not implemented: connections endpoint does not exist yet");
+  }
+  async backlinks(_resourceId) {
+    throw new Error("Not implemented: backlinks endpoint does not exist yet");
+  }
+  async resourcesByName(_query, _limit) {
+    throw new Error("Not implemented: resourcesByName endpoint does not exist yet");
+  }
+  async files(dirPath, sort) {
+    return this.http.browseFiles(dirPath, sort, { auth: this.getToken() });
+  }
+  // ── Invalidation (exposed for other namespaces) ─────────────────────────
+  invalidateAnnotationList(resourceId) {
+    const next = new Map(this.annotationList$.value);
+    next.delete(resourceId);
+    this.annotationList$.next(next);
+    this.fetchAnnotationList(resourceId);
+  }
+  invalidateAnnotationDetail(annotationId) {
+    const next = new Map(this.annotationDetail$.value);
+    next.delete(annotationId);
+    this.annotationDetail$.next(next);
+  }
+  invalidateResourceDetail(id) {
+    const next = new Map(this.resourceDetail$.value);
+    next.delete(id);
+    this.resourceDetail$.next(next);
+    this.fetchResourceDetail(id);
+  }
+  invalidateResourceLists() {
+    this.resourceList$.next(/* @__PURE__ */ new Map());
+  }
+  invalidateEntityTypes() {
+    this.entityTypes$.next(void 0);
+    this.fetchEntityTypes();
+  }
+  invalidateReferencedBy(resourceId) {
+    const next = new Map(this.referencedBy$.value);
+    next.delete(resourceId);
+    this.referencedBy$.next(next);
+    this.fetchReferencedBy(resourceId);
+  }
+  updateAnnotationInPlace(resourceId, annotation) {
+    const currentList = this.annotationList$.value.get(resourceId);
+    if (!currentList) return;
+    const existingIdx = currentList.annotations.findIndex((a) => a.id === annotation.id);
+    const nextAnnotations = existingIdx >= 0 ? currentList.annotations.map((a, i) => i === existingIdx ? annotation : a) : [...currentList.annotations, annotation];
+    const nextList = { ...currentList, annotations: nextAnnotations };
+    const nextMap = new Map(this.annotationList$.value);
+    nextMap.set(resourceId, nextList);
+    this.annotationList$.next(nextMap);
+  }
+  // ── EventBus subscriptions ──────────────────────────────────────────────
+  subscribeToEvents() {
+    const bus = this.eventBus;
+    bus.get("mark:delete-ok").subscribe((event) => {
+      this.invalidateAnnotationDetail(annotationId(event.annotationId));
     });
-    eventBus.get("yield:updated").subscribe((event) => {
-      this.invalidateDetail(event.resourceId);
-      this.invalidateLists();
+    bus.get("mark:added").subscribe((stored) => {
+      if (stored.resourceId) {
+        this.invalidateAnnotationList(stored.resourceId);
+      }
     });
-    eventBus.get("mark:archived").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateDetail(event.resourceId);
-        this.invalidateLists();
+    bus.get("mark:removed").subscribe((stored) => {
+      if (stored.resourceId) {
+        this.invalidateAnnotationList(stored.resourceId);
+      }
+      this.invalidateAnnotationDetail(annotationId(stored.payload.annotationId));
+    });
+    bus.get("mark:body-updated").subscribe((event) => {
+      const enriched = event;
+      if (!enriched.resourceId || !enriched.annotation) return;
+      this.updateAnnotationInPlace(enriched.resourceId, enriched.annotation);
+      this.invalidateAnnotationDetail(annotationId(enriched.annotation.id));
+    });
+    bus.get("mark:entity-tag-added").subscribe((stored) => {
+      if (stored.resourceId) {
+        this.invalidateAnnotationList(stored.resourceId);
+        this.invalidateResourceDetail(stored.resourceId);
+      }
+    });
+    bus.get("mark:entity-tag-removed").subscribe((stored) => {
+      if (stored.resourceId) {
+        this.invalidateAnnotationList(stored.resourceId);
+        this.invalidateResourceDetail(stored.resourceId);
       }
     });
-    eventBus.get("mark:unarchived").subscribe((event) => {
+    bus.get("replay-window-exceeded").subscribe((event) => {
       if (event.resourceId) {
-        this.invalidateDetail(event.resourceId);
-        this.invalidateLists();
+        this.invalidateAnnotationList(event.resourceId);
       }
     });
-    eventBus.get("mark:entity-tag-added").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateDetail(event.resourceId);
+    bus.get("yield:create-ok").subscribe((event) => {
+      this.fetchResourceDetail(resourceId(event.resourceId));
+      this.invalidateResourceLists();
+    });
+    bus.get("yield:update-ok").subscribe((event) => {
+      this.invalidateResourceDetail(resourceId(event.resourceId));
+      this.invalidateResourceLists();
+    });
+    bus.get("mark:archived").subscribe((stored) => {
+      if (stored.resourceId) {
+        this.invalidateResourceDetail(stored.resourceId);
+        this.invalidateResourceLists();
       }
     });
-    eventBus.get("mark:entity-tag-removed").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateDetail(event.resourceId);
+    bus.get("mark:unarchived").subscribe((stored) => {
+      if (stored.resourceId) {
+        this.invalidateResourceDetail(stored.resourceId);
+        this.invalidateResourceLists();
       }
     });
+    bus.get("mark:entity-type-added").subscribe(() => {
+      this.invalidateEntityTypes();
+    });
   }
-  /** Cache of individual resource details, keyed by ResourceId */
-  detail$ = new BehaviorSubject(/* @__PURE__ */ new Map());
-  /** Cache of list responses, keyed by a serialized options string */
-  list$ = new BehaviorSubject(/* @__PURE__ */ new Map());
-  /** Track in-flight fetches to avoid duplicate requests */
-  fetchingDetail = /* @__PURE__ */ new Set();
-  fetchingList = /* @__PURE__ */ new Set();
-  /** Memoized Observables — same instance returned for the same key */
-  detailObs$ = /* @__PURE__ */ new Map();
-  listObs$ = /* @__PURE__ */ new Map();
-  /** Mutable token getter — updated from the React layer when auth changes */
-  getToken = () => void 0;
-  /** Update the token getter (called from React when auth token changes) */
-  setTokenGetter(getter) {
-    this.getToken = getter;
-  }
-  /**
-   * Get a single resource by ID as an Observable.
-   * Triggers a fetch if not cached.
-   */
-  get(id) {
-    if (!this.detail$.value.has(id) && !this.fetchingDetail.has(id)) {
-      this.fetchDetail(id);
-    }
-    let obs = this.detailObs$.get(id);
-    if (!obs) {
-      obs = this.detail$.pipe(map((m) => m.get(id)), distinctUntilChanged());
-      this.detailObs$.set(id, obs);
+  // ── Fetch helpers ───────────────────────────────────────────────────────
+  async fetchAnnotationList(resourceId) {
+    if (this.fetchingAnnotationList.has(resourceId)) return;
+    this.fetchingAnnotationList.add(resourceId);
+    try {
+      const result = await this.http.browseAnnotations(resourceId, void 0, { auth: this.getToken() });
+      const next = new Map(this.annotationList$.value);
+      next.set(resourceId, result);
+      this.annotationList$.next(next);
+    } catch {
+    } finally {
+      this.fetchingAnnotationList.delete(resourceId);
     }
-    return obs;
   }
-  /**
-   * List resources as an Observable.
-   * Triggers a fetch if not cached.
-   */
-  list(options) {
-    const key = JSON.stringify(options ?? {});
-    if (!this.list$.value.has(key) && !this.fetchingList.has(key)) {
-      this.fetchList(key, options);
-    }
-    let obs = this.listObs$.get(key);
-    if (!obs) {
-      obs = this.list$.pipe(map((m) => m.get(key)), distinctUntilChanged());
-      this.listObs$.set(key, obs);
+  async fetchAnnotationDetail(resourceId, annotationId) {
+    if (this.fetchingAnnotationDetail.has(annotationId)) return;
+    this.fetchingAnnotationDetail.add(annotationId);
+    try {
+      const result = await this.http.browseAnnotation(resourceId, annotationId, { auth: this.getToken() });
+      const next = new Map(this.annotationDetail$.value);
+      next.set(annotationId, result.annotation);
+      this.annotationDetail$.next(next);
+    } catch {
+    } finally {
+      this.fetchingAnnotationDetail.delete(annotationId);
     }
-    return obs;
   }
-  /** Invalidate and re-fetch a specific resource detail */
-  invalidateDetail(id) {
-    const next = new Map(this.detail$.value);
-    next.delete(id);
-    this.detail$.next(next);
-    this.fetchDetail(id);
+  async fetchResourceDetail(id) {
+    if (this.fetchingResourceDetail.has(id)) return;
+    this.fetchingResourceDetail.add(id);
+    try {
+      const result = await this.http.browseResource(id, { auth: this.getToken() });
+      const next = new Map(this.resourceDetail$.value);
+      next.set(id, result.resource);
+      this.resourceDetail$.next(next);
+    } catch {
+    } finally {
+      this.fetchingResourceDetail.delete(id);
+    }
   }
-  /** Remove all list caches (triggers re-fetch on next subscribe) */
-  invalidateLists() {
-    this.list$.next(/* @__PURE__ */ new Map());
+  async fetchResourceList(key, filters) {
+    if (this.fetchingResourceList.has(key)) return;
+    this.fetchingResourceList.add(key);
+    try {
+      const result = await this.http.browseResources(filters?.limit, filters?.archived, void 0, { auth: this.getToken() });
+      const next = new Map(this.resourceList$.value);
+      next.set(key, result.resources);
+      this.resourceList$.next(next);
+    } catch {
+    } finally {
+      this.fetchingResourceList.delete(key);
+    }
   }
-  async fetchDetail(id) {
-    if (this.fetchingDetail.has(id)) return;
-    this.fetchingDetail.add(id);
+  async fetchEntityTypes() {
+    if (this.fetchingEntityTypes) return;
+    this.fetchingEntityTypes = true;
     try {
-      const resource = await this.http.browseResource(id, { auth: this.getToken() });
-      const next = new Map(this.detail$.value);
-      next.set(id, resource);
-      this.detail$.next(next);
+      const result = await this.http.listEntityTypes({ auth: this.getToken() });
+      this.entityTypes$.next(result.entityTypes);
     } catch {
     } finally {
-      this.fetchingDetail.delete(id);
+      this.fetchingEntityTypes = false;
     }
   }
-  async fetchList(key, options) {
-    if (this.fetchingList.has(key)) return;
-    this.fetchingList.add(key);
+  async fetchReferencedBy(resourceId) {
+    if (this.fetchingReferencedBy.has(resourceId)) return;
+    this.fetchingReferencedBy.add(resourceId);
     try {
-      const result = await this.http.browseResources(options?.limit, options?.archived, void 0, { auth: this.getToken() });
-      const next = new Map(this.list$.value);
-      next.set(key, result);
-      this.list$.next(next);
+      const result = await this.http.browseReferences(resourceId, { auth: this.getToken() });
+      const next = new Map(this.referencedBy$.value);
+      next.set(resourceId, result.referencedBy);
+      this.referencedBy$.next(next);
     } catch {
     } finally {
-      this.fetchingList.delete(key);
+      this.fetchingReferencedBy.delete(resourceId);
     }
   }
 };
-var AnnotationStore = class {
-  constructor(http, eventBus) {
+var MarkNamespace = class {
+  constructor(http, eventBus, getToken) {
     this.http = http;
-    eventBus.get("mark:deleted").subscribe((event) => {
-      this.removeFromDetailCache(event.annotationId);
+    this.eventBus = eventBus;
+    this.getToken = getToken;
+  }
+  async annotation(resourceId, input) {
+    return this.http.markAnnotation(resourceId, input, { auth: this.getToken() });
+  }
+  async delete(resourceId, annotationId) {
+    return this.http.deleteAnnotation(resourceId, annotationId, { auth: this.getToken() });
+  }
+  async entityType(type) {
+    return this.http.addEntityType(type, { auth: this.getToken() });
+  }
+  async entityTypes(types) {
+    return this.http.addEntityTypesBulk(types, { auth: this.getToken() });
+  }
+  async updateResource(resourceId, data) {
+    return this.http.updateResource(resourceId, data, { auth: this.getToken() });
+  }
+  async archive(resourceId) {
+    return this.http.updateResource(resourceId, { archived: true }, { auth: this.getToken() });
+  }
+  async unarchive(resourceId) {
+    return this.http.updateResource(resourceId, { archived: false }, { auth: this.getToken() });
+  }
+  assist(resourceId, motivation, options) {
+    return new Observable((subscriber) => {
+      const progress$ = this.eventBus.get("mark:progress").pipe(
+        filter((e) => e.resourceId === resourceId)
+      );
+      const finished$ = this.eventBus.get("mark:assist-finished").pipe(
+        filter((e) => e.resourceId === resourceId && e.motivation === motivation)
+      );
+      const failed$ = this.eventBus.get("mark:assist-failed").pipe(
+        filter((e) => e.resourceId === resourceId)
+      );
+      const progressSub = progress$.pipe(takeUntil(merge(finished$, failed$))).subscribe((e) => subscriber.next(e));
+      const finishedSub = finished$.subscribe((e) => {
+        subscriber.next(e);
+        subscriber.complete();
+      });
+      const failedSub = failed$.subscribe((e) => {
+        subscriber.error(new Error(e.message));
+      });
+      const auth = this.getToken();
+      const postPromise = this.dispatchAssist(resourceId, motivation, options, auth);
+      postPromise.catch((error) => {
+        subscriber.error(error);
+      });
+      return () => {
+        progressSub.unsubscribe();
+        finishedSub.unsubscribe();
+        failedSub.unsubscribe();
+      };
     });
-    eventBus.get("mark:added").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateList(event.resourceId);
-      }
+  }
+  async dispatchAssist(resourceId, motivation, options, auth) {
+    if (motivation === "tagging") {
+      const { schemaId, categories } = options;
+      if (!schemaId || !categories?.length) throw new Error("Tag assist requires schemaId and categories");
+      await this.http.annotateTags(resourceId, { schemaId, categories }, { auth });
+    } else if (motivation === "linking") {
+      const { entityTypes, includeDescriptiveReferences } = options;
+      if (!entityTypes?.length) throw new Error("Reference assist requires entityTypes");
+      await this.http.annotateReferences(resourceId, {
+        entityTypes,
+        includeDescriptiveReferences: includeDescriptiveReferences ?? false
+      }, { auth });
+    } else if (motivation === "highlighting") {
+      await this.http.annotateHighlights(resourceId, {
+        instructions: options.instructions,
+        density: options.density
+      }, { auth });
+    } else if (motivation === "assessing") {
+      await this.http.annotateAssessments(resourceId, {
+        instructions: options.instructions,
+        tone: options.tone,
+        density: options.density,
+        language: options.language
+      }, { auth });
+    } else if (motivation === "commenting") {
+      await this.http.annotateComments(resourceId, {
+        instructions: options.instructions,
+        tone: options.tone,
+        density: options.density,
+        language: options.language
+      }, { auth });
+    }
+  }
+};
+
+// src/namespaces/bind.ts
+var BindNamespace = class {
+  constructor(http, getToken) {
+    this.http = http;
+    this.getToken = getToken;
+  }
+  async body(resourceId, annotationId, operations) {
+    await this.http.bindAnnotation(resourceId, annotationId, { operations }, { auth: this.getToken() });
+  }
+};
+var GatherNamespace = class {
+  constructor(http, eventBus, getToken) {
+    this.http = http;
+    this.eventBus = eventBus;
+    this.getToken = getToken;
+  }
+  annotation(annotationId$1, resourceId, options) {
+    return new Observable((subscriber) => {
+      const correlationId = crypto.randomUUID();
+      const complete$ = this.eventBus.get("gather:complete").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const failed$ = this.eventBus.get("gather:failed").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const sub = merge(
+        this.eventBus.get("gather:annotation-progress").pipe(
+          // Progress events don't carry correlationId, so match by annotationId
+          filter((e) => e.annotationId === annotationId$1),
+          map((e) => e)
+        ),
+        complete$.pipe(map((e) => e))
+      ).pipe(takeUntil(merge(complete$, failed$))).subscribe({
+        next: (v) => subscriber.next(v),
+        error: (e) => subscriber.error(e)
+      });
+      const completeSub = complete$.subscribe((e) => {
+        subscriber.next(e);
+        subscriber.complete();
+      });
+      const failedSub = failed$.subscribe((e) => {
+        subscriber.error(new Error(e.message));
+      });
+      this.http.gatherAnnotationContext(
+        resourceId,
+        annotationId(annotationId$1),
+        { correlationId, contextWindow: options?.contextWindow ?? 2e3 },
+        { auth: this.getToken() }
+      ).catch((error) => {
+        subscriber.error(error);
+      });
+      return () => {
+        sub.unsubscribe();
+        completeSub.unsubscribe();
+        failedSub.unsubscribe();
+      };
     });
-    eventBus.get("mark:removed").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateList(event.resourceId);
-      }
-      this.invalidateDetail(event.payload.annotationId);
+  }
+  resource(_resourceId, _options) {
+    throw new Error("Not implemented: gather.resource() \u2014 no backend route yet");
+  }
+};
+var MatchNamespace = class {
+  constructor(http, eventBus, getToken) {
+    this.http = http;
+    this.eventBus = eventBus;
+    this.getToken = getToken;
+  }
+  search(resourceId, referenceId, context, options) {
+    return new Observable((subscriber) => {
+      const correlationId = crypto.randomUUID();
+      const result$ = this.eventBus.get("match:search-results").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const failed$ = this.eventBus.get("match:search-failed").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const resultSub = result$.subscribe((e) => {
+        subscriber.next(e);
+        subscriber.complete();
+      });
+      const failedSub = failed$.subscribe((e) => {
+        subscriber.error(new Error(e.error));
+      });
+      this.http.matchSearch(
+        resourceId,
+        {
+          correlationId,
+          referenceId,
+          context,
+          limit: options?.limit,
+          useSemanticScoring: options?.useSemanticScoring
+        },
+        { auth: this.getToken() }
+      ).catch((error) => {
+        subscriber.error(error);
+      });
+      return () => {
+        resultSub.unsubscribe();
+        failedSub.unsubscribe();
+      };
     });
-    eventBus.get("mark:body-updated").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateList(event.resourceId);
-      }
-      this.invalidateDetail(event.payload.annotationId);
+  }
+};
+var YieldNamespace = class {
+  constructor(http, eventBus, getToken) {
+    this.http = http;
+    this.eventBus = eventBus;
+    this.getToken = getToken;
+  }
+  async resource(data) {
+    return this.http.yieldResource(data, { auth: this.getToken() });
+  }
+  fromAnnotation(resourceId$1, annotationId$1, options) {
+    return new Observable((subscriber) => {
+      const progress$ = this.eventBus.get("yield:progress").pipe(
+        filter((e) => e.referenceId === annotationId$1)
+      );
+      const finished$ = this.eventBus.get("yield:finished").pipe(
+        filter((e) => e.referenceId === annotationId$1)
+      );
+      const failed$ = this.eventBus.get("yield:failed").pipe(
+        filter((e) => e.referenceId === annotationId$1)
+      );
+      const progressSub = progress$.pipe(takeUntil(merge(finished$, failed$))).subscribe((e) => subscriber.next(e));
+      const finishedSub = finished$.subscribe((event) => {
+        subscriber.next(event);
+        subscriber.complete();
+        if (event.resourceId && event.referenceId && event.sourceResourceId) {
+          this.eventBus.get("bind:update-body").next({
+            correlationId: crypto.randomUUID(),
+            annotationId: annotationId(event.referenceId),
+            resourceId: resourceId(event.sourceResourceId),
+            operations: [{ op: "add", item: { type: "SpecificResource", source: event.resourceId } }]
+          });
+        }
+      });
+      const failedSub = failed$.subscribe((e) => {
+        subscriber.error(new Error(e.error ?? e.message ?? "Generation failed"));
+      });
+      this.http.yieldResourceFromAnnotation(
+        resourceId$1,
+        annotationId$1,
+        options,
+        { auth: this.getToken() }
+      ).catch((error) => {
+        subscriber.error(error);
+      });
+      return () => {
+        progressSub.unsubscribe();
+        finishedSub.unsubscribe();
+        failedSub.unsubscribe();
+      };
     });
-    eventBus.get("mark:entity-tag-added").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateList(event.resourceId);
-      }
+  }
+  async cloneToken(resourceId) {
+    const result = await this.http.generateCloneToken(resourceId, { auth: this.getToken() });
+    return result;
+  }
+  async fromToken(token) {
+    const result = await this.http.getResourceByToken(token, { auth: this.getToken() });
+    return result.sourceResource;
+  }
+  async createFromToken(options) {
+    return this.http.createResourceFromToken(options, { auth: this.getToken() });
+  }
+};
+
+// src/namespaces/beckon.ts
+var BeckonNamespace = class {
+  constructor(http, getToken) {
+    this.http = http;
+    this.getToken = getToken;
+  }
+  attention(annotationId, resourceId) {
+    this.http.beckonAttention(
+      "me",
+      // participantId — always 'me' for self-identification
+      { annotationId, resourceId },
+      { auth: this.getToken() }
+    ).catch(() => {
     });
-    eventBus.get("mark:entity-tag-removed").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateList(event.resourceId);
-      }
+  }
+};
+
+// src/namespaces/job.ts
+var JobNamespace = class {
+  constructor(http, getToken) {
+    this.http = http;
+    this.getToken = getToken;
+  }
+  async status(jobId) {
+    return this.http.getJobStatus(jobId, { auth: this.getToken() });
+  }
+  async pollUntilComplete(jobId, options) {
+    return this.http.pollJobUntilComplete(jobId, {
+      interval: options?.interval,
+      timeout: options?.timeout,
+      onProgress: options?.onProgress,
+      auth: this.getToken()
     });
   }
-  /** Annotation list responses keyed by ResourceId */
-  list$ = new BehaviorSubject(/* @__PURE__ */ new Map());
-  /** Individual annotation details keyed by AnnotationId */
-  detail$ = new BehaviorSubject(/* @__PURE__ */ new Map());
-  /** Track in-flight fetches */
-  fetchingList = /* @__PURE__ */ new Set();
-  fetchingDetail = /* @__PURE__ */ new Set();
-  /** Memoized Observables — same instance returned for the same key */
-  listObs$ = /* @__PURE__ */ new Map();
-  detailObs$ = /* @__PURE__ */ new Map();
-  /** Mutable token getter — updated from the React layer when auth changes */
-  getToken = () => void 0;
-  /** Update the token getter (called from React when auth token changes) */
-  setTokenGetter(getter) {
-    this.getToken = getter;
+  async cancel(jobId, type) {
+    throw new Error(`Not implemented: job.cancel(${jobId}, ${type}) \u2014 needs EventBus wiring`);
   }
-  /**
-   * Get annotations for a resource as an Observable.
-   * Triggers a fetch if not cached.
-   */
-  listForResource(resourceId) {
-    if (!this.list$.value.has(resourceId) && !this.fetchingList.has(resourceId)) {
-      this.fetchList(resourceId);
-    }
-    let obs = this.listObs$.get(resourceId);
-    if (!obs) {
-      obs = this.list$.pipe(map((m) => m.get(resourceId)), distinctUntilChanged());
-      this.listObs$.set(resourceId, obs);
-    }
-    return obs;
+};
+var AuthNamespace = class {
+  constructor(http, getToken) {
+    this.http = http;
+    this.getToken = getToken;
   }
-  /**
-   * Get a single annotation detail as an Observable.
-   * Triggers a fetch if not cached.
-   */
-  get(resourceId, annotationId) {
-    if (!this.detail$.value.has(annotationId) && !this.fetchingDetail.has(annotationId)) {
-      this.fetchDetail(resourceId, annotationId);
-    }
-    let obs = this.detailObs$.get(annotationId);
-    if (!obs) {
-      obs = this.detail$.pipe(map((m) => m.get(annotationId)), distinctUntilChanged());
-      this.detailObs$.set(annotationId, obs);
-    }
-    return obs;
+  async password(emailStr, passwordStr) {
+    return this.http.authenticatePassword(email(emailStr), passwordStr);
   }
-  /** Invalidate and re-fetch a resource's annotation list */
-  invalidateList(resourceId) {
-    const next = new Map(this.list$.value);
-    next.delete(resourceId);
-    this.list$.next(next);
-    this.fetchList(resourceId);
+  async google(credential) {
+    return this.http.authenticateGoogle(googleCredential(credential));
   }
-  /** Invalidate a single annotation detail (re-fetched on next subscribe) */
-  invalidateDetail(annotationId) {
-    const next = new Map(this.detail$.value);
-    next.delete(annotationId);
-    this.detail$.next(next);
+  async refresh(token) {
+    return this.http.refreshToken(refreshToken(token));
   }
-  /** Remove an annotation from the detail cache without re-fetching */
-  removeFromDetailCache(annotationId) {
-    const next = new Map(this.detail$.value);
-    next.delete(annotationId);
-    this.detail$.next(next);
+  async logout() {
+    await this.http.logout({ auth: this.getToken() });
   }
-  async fetchList(resourceId) {
-    if (this.fetchingList.has(resourceId)) return;
-    this.fetchingList.add(resourceId);
-    try {
-      const result = await this.http.browseAnnotations(resourceId, void 0, { auth: this.getToken() });
-      const next = new Map(this.list$.value);
-      next.set(resourceId, result);
-      this.list$.next(next);
-    } catch {
-    } finally {
-      this.fetchingList.delete(resourceId);
-    }
+  async me() {
+    return this.http.getMe({ auth: this.getToken() });
   }
-  async fetchDetail(resourceId, annotationId) {
-    if (this.fetchingDetail.has(annotationId)) return;
-    this.fetchingDetail.add(annotationId);
-    try {
-      const result = await this.http.browseAnnotation(resourceId, annotationId, { auth: this.getToken() });
-      const next = new Map(this.detail$.value);
-      next.set(annotationId, result);
-      this.detail$.next(next);
-    } catch {
-    } finally {
-      this.fetchingDetail.delete(annotationId);
-    }
+  async acceptTerms() {
+    await this.http.acceptTerms({ auth: this.getToken() });
+  }
+  async mcpToken() {
+    return this.http.generateMCPToken({ auth: this.getToken() });
+  }
+  async mediaToken(resourceId) {
+    return this.http.getMediaToken(resourceId, { auth: this.getToken() });
+  }
+};
+
+// src/namespaces/admin.ts
+var AdminNamespace = class {
+  constructor(http, getToken) {
+    this.http = http;
+    this.getToken = getToken;
+  }
+  async users() {
+    const result = await this.http.listUsers({ auth: this.getToken() });
+    return result.users;
+  }
+  async userStats() {
+    return this.http.getUserStats({ auth: this.getToken() });
+  }
+  async updateUser(userId, data) {
+    const result = await this.http.updateUser(userId, data, { auth: this.getToken() });
+    return result.user;
+  }
+  async oauthConfig() {
+    return this.http.getOAuthConfig({ auth: this.getToken() });
+  }
+  async healthCheck() {
+    return this.http.healthCheck({ auth: this.getToken() });
+  }
+  async status() {
+    return this.http.getStatus({ auth: this.getToken() });
+  }
+  async backup() {
+    return this.http.backupKnowledgeBase({ auth: this.getToken() });
+  }
+  async restore(file, onProgress) {
+    return this.http.restoreKnowledgeBase(file, { auth: this.getToken(), onProgress });
+  }
+  async exportKnowledgeBase(params) {
+    return this.http.exportKnowledgeBase(params, { auth: this.getToken() });
+  }
+  async importKnowledgeBase(file, onProgress) {
+    return this.http.importKnowledgeBase(file, { auth: this.getToken(), onProgress });
   }
 };
 
@@ -1288,6 +1053,11 @@ var SemiontApiClient = class {
   /** The workspace-scoped EventBus this client was constructed with. */
   eventBus;
   logger;
+  /**
+   * Shared mutable token getter. All verb namespaces read from this.
+   * Updated via setTokenGetter() from the React auth layer.
+   */
+  _getToken = () => void 0;
   /**
    * SSE streaming client for real-time operations
    *
@@ -1295,25 +1065,30 @@ var SemiontApiClient = class {
    * Uses native fetch() instead of ky for SSE support.
    */
   sse;
-  /**
-   * Framework-agnostic flow orchestration.
-   * Each method returns a Subscription; call .unsubscribe() to tear down.
-   */
-  flows;
-  /**
-   * Per-workspace observable stores for entity data.
-   * Call stores.resources.setTokenGetter() / stores.annotations.setTokenGetter()
-   * from the React layer when the auth token changes.
-   */
-  stores;
+  // ── Verb-oriented namespace API ──────────────────────────────────────────
+  browse;
+  mark;
+  bind;
+  gather;
+  match;
+  yield;
+  beckon;
+  job;
+  auth;
+  admin;
   constructor(config) {
-    const { baseUrl, eventBus, timeout: timeout2 = 3e4, retry = 2, logger } = config;
+    const { baseUrl, eventBus, timeout = 3e4, retry = 2, logger, tokenRefresher } = config;
     this.eventBus = eventBus;
     this.logger = logger;
     this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    const retryConfig = tokenRefresher ? {
+      limit: 1,
+      methods: ["get", "post", "put", "patch", "delete", "head", "options"],
+      statusCodes: [401, 408, 413, 429, 500, 502, 503, 504]
+    } : retry;
     this.http = ky.create({
-      timeout: timeout2,
-      retry,
+      timeout,
+      retry: retryConfig,
       credentials: "include",
       hooks: {
         beforeRequest: [
@@ -1329,6 +1104,21 @@ var SemiontApiClient = class {
             }
           }
         ],
+        beforeRetry: tokenRefresher ? [
+          async ({ request, error }) => {
+            if (!(error instanceof HTTPError) || error.response.status !== 401) {
+              return void 0;
+            }
+            try {
+              const newToken = await tokenRefresher();
+              if (!newToken) return ky.stop;
+              request.headers.set("Authorization", `Bearer ${newToken}`);
+              return void 0;
+            } catch {
+              return ky.stop;
+            }
+          }
+        ] : [],
         afterResponse: [
           (request, _options, response) => {
             if (this.logger) {
@@ -1374,11 +1164,26 @@ var SemiontApiClient = class {
       baseUrl: this.baseUrl,
       logger: this.logger
     });
-    this.flows = new FlowEngine(this.eventBus, this.sse, this);
-    this.stores = {
-      resources: new ResourceStore(this, this.eventBus),
-      annotations: new AnnotationStore(this, this.eventBus)
-    };
+    if (config.getToken) this._getToken = config.getToken;
+    const getToken = () => this._getToken();
+    this.browse = new BrowseNamespace(this, this.eventBus, getToken);
+    this.mark = new MarkNamespace(this, this.eventBus, getToken);
+    this.bind = new BindNamespace(this, getToken);
+    this.gather = new GatherNamespace(this, this.eventBus, getToken);
+    this.match = new MatchNamespace(this, this.eventBus, getToken);
+    this.yield = new YieldNamespace(this, this.eventBus, getToken);
+    this.beckon = new BeckonNamespace(this, getToken);
+    this.job = new JobNamespace(this, getToken);
+    this.auth = new AuthNamespace(this, getToken);
+    this.admin = new AdminNamespace(this, getToken);
+  }
+  /**
+   * Update the token getter for all verb namespaces.
+   * Called from the React auth layer when the token changes.
+   * All namespaces share this getter via closure — no per-namespace sync needed.
+   */
+  setTokenGetter(getter) {
+    this._getToken = getter;
   }
   authHeaders(options) {
     return options?.auth ? { Authorization: `Bearer ${options.auth}` } : {};
@@ -1645,16 +1450,64 @@ var SemiontApiClient = class {
     });
   }
   async bindAnnotation(resourceId, annotationId, data, options) {
-    await this.http.put(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/body`, {
-      json: data,
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/bind`, {
+      json: { resourceId, ...data },
       headers: this.authHeaders(options)
-    });
+    }).json();
   }
   async getAnnotationHistory(resourceId, annotationId, options) {
     return this.http.get(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/history`, {
       headers: this.authHeaders(options)
     }).json();
   }
+  async annotateReferences(resourceId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-references`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async annotateHighlights(resourceId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-highlights`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async annotateAssessments(resourceId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-assessments`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async annotateComments(resourceId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-comments`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async annotateTags(resourceId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-tags`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async yieldResourceFromAnnotation(resourceId, annotationId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/yield-resource`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async gatherAnnotationContext(resourceId, annotationId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/gather`, {
+      json: data,
+      headers: this.authHeaders(options)
+    }).json();
+  }
+  async matchSearch(resourceId, data, options) {
+    return this.http.post(`${this.baseUrl}/resources/${resourceId}/match-search`, {
+      json: { resourceId, ...data },
+      headers: this.authHeaders(options)
+    }).json();
+  }
   // ============================================================================
   // ENTITY TYPES
   // ============================================================================
@@ -1801,7 +1654,7 @@ var SemiontApiClient = class {
    */
   async pollJobUntilComplete(id, options) {
     const interval = options?.interval ?? 1e3;
-    const timeout2 = options?.timeout ?? 6e4;
+    const timeout = options?.timeout ?? 6e4;
     const startTime = Date.now();
     while (true) {
       const status = await this.getJobStatus(id, { auth: options?.auth });
@@ -1811,8 +1664,8 @@ var SemiontApiClient = class {
       if (status.status === "complete" || status.status === "failed" || status.status === "cancelled") {
         return status;
       }
-      if (Date.now() - startTime > timeout2) {
-        throw new Error(`Job polling timeout after ${timeout2}ms`);
+      if (Date.now() - startTime > timeout) {
+        throw new Error(`Job polling timeout after ${timeout}ms`);
       }
       await new Promise((resolve) => setTimeout(resolve, interval));
     }
@@ -1840,273 +1693,6 @@ var SemiontApiClient = class {
     }).json();
   }
 };
-async function eventBusRequest(eventBus, requestEvent, payload, successEvent, failureEvent, timeoutMs = 3e4) {
-  const { correlationId } = payload;
-  const result$ = merge(
-    eventBus.get(successEvent).pipe(
-      filter((e) => e.correlationId === correlationId),
-      map((e) => ({ ok: true, response: e.response }))
-    ),
-    eventBus.get(failureEvent).pipe(
-      filter((e) => e.correlationId === correlationId),
-      map((e) => ({ ok: false, error: e.error }))
-    )
-  ).pipe(take(1), timeout(timeoutMs));
-  const resultPromise = firstValueFrom(result$);
-  eventBus.get(requestEvent).next(payload);
-  const result = await resultPromise;
-  if (!result.ok) {
-    throw result.error;
-  }
-  return result.response;
-}
-var EventBusClient = class {
-  constructor(eventBus, timeoutMs = 3e4) {
-    this.eventBus = eventBus;
-    this.timeoutMs = timeoutMs;
-  }
-  // ========================================================================
-  // Browse Flow — Resource reads
-  // ========================================================================
-  async browseResource(resourceId) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:resource-requested",
-      { correlationId: crypto.randomUUID(), resourceId },
-      "browse:resource-result",
-      "browse:resource-failed",
-      this.timeoutMs
-    );
-  }
-  async browseResources(options) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:resources-requested",
-      { correlationId: crypto.randomUUID(), ...options },
-      "browse:resources-result",
-      "browse:resources-failed",
-      this.timeoutMs
-    );
-  }
-  // ========================================================================
-  // Browse Flow — Annotation reads
-  // ========================================================================
-  async getAnnotations(resourceId) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:annotations-requested",
-      { correlationId: crypto.randomUUID(), resourceId },
-      "browse:annotations-result",
-      "browse:annotations-failed",
-      this.timeoutMs
-    );
-  }
-  async getAnnotation(resourceId, annotationId) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:annotation-requested",
-      { correlationId: crypto.randomUUID(), resourceId, annotationId },
-      "browse:annotation-result",
-      "browse:annotation-failed",
-      this.timeoutMs
-    );
-  }
-  // ========================================================================
-  // Browse Flow — Event history
-  // ========================================================================
-  async getEvents(resourceId, options) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:events-requested",
-      { correlationId: crypto.randomUUID(), resourceId, ...options },
-      "browse:events-result",
-      "browse:events-failed",
-      this.timeoutMs
-    );
-  }
-  async getAnnotationHistory(resourceId, annotationId) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:annotation-history-requested",
-      { correlationId: crypto.randomUUID(), resourceId, annotationId },
-      "browse:annotation-history-result",
-      "browse:annotation-history-failed",
-      this.timeoutMs
-    );
-  }
-  // ========================================================================
-  // Bind Flow — Graph queries
-  // ========================================================================
-  async getReferencedBy(resourceId, motivation) {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:referenced-by-requested",
-      { correlationId: crypto.randomUUID(), resourceId, motivation },
-      "browse:referenced-by-result",
-      "browse:referenced-by-failed",
-      this.timeoutMs
-    );
-  }
-  // ========================================================================
-  // Mark Flow — Entity types
-  // ========================================================================
-  async listEntityTypes() {
-    return eventBusRequest(
-      this.eventBus,
-      "browse:entity-types-requested",
-      { correlationId: crypto.randomUUID() },
-      "browse:entity-types-result",
-      "browse:entity-types-failed",
-      this.timeoutMs
-    );
-  }
-  addEntityType(tag, userId) {
-    this.eventBus.get("mark:add-entity-type").next({ tag, userId });
-  }
-  // ========================================================================
-  // Yield Flow — Clone tokens
-  // ========================================================================
-  async generateCloneToken(resourceId) {
-    return eventBusRequest(
-      this.eventBus,
-      "yield:clone-token-requested",
-      { correlationId: crypto.randomUUID(), resourceId },
-      "yield:clone-token-generated",
-      "yield:clone-token-failed",
-      this.timeoutMs
-    );
-  }
-  async getResourceByToken(token) {
-    return eventBusRequest(
-      this.eventBus,
-      "yield:clone-resource-requested",
-      { correlationId: crypto.randomUUID(), token },
-      "yield:clone-resource-result",
-      "yield:clone-resource-failed",
-      this.timeoutMs
-    );
-  }
-  async createResourceFromToken(options) {
-    return eventBusRequest(
-      this.eventBus,
-      "yield:clone-create",
-      { correlationId: crypto.randomUUID(), ...options },
-      "yield:clone-created",
-      "yield:clone-create-failed",
-      this.timeoutMs
-    );
-  }
-  // ========================================================================
-  // Job Control
-  // ========================================================================
-  async getJobStatus(jobId) {
-    return eventBusRequest(
-      this.eventBus,
-      "job:status-requested",
-      { correlationId: crypto.randomUUID(), jobId },
-      "job:status-result",
-      "job:status-failed",
-      this.timeoutMs
-    );
-  }
-  // ========================================================================
-  // Gather Flow — LLM context
-  // ========================================================================
-  async gatherAnnotation(annotationId, resourceId, options) {
-    const correlationId = crypto.randomUUID();
-    const result$ = merge(
-      this.eventBus.get("gather:complete").pipe(
-        filter((e) => e.correlationId === correlationId),
-        map((e) => ({ ok: true, response: e.response }))
-      ),
-      this.eventBus.get("gather:failed").pipe(
-        filter((e) => e.correlationId === correlationId),
-        map((e) => ({ ok: false, error: e.error }))
-      )
-    ).pipe(take(1), timeout(this.timeoutMs));
-    const resultPromise = firstValueFrom(result$);
-    this.eventBus.get("gather:requested").next({
-      correlationId,
-      annotationId,
-      resourceId,
-      options
-    });
-    const result = await resultPromise;
-    if (!result.ok) {
-      throw result.error;
-    }
-    return result.response;
-  }
-  async gatherResource(resourceId, options) {
-    const correlationId = crypto.randomUUID();
-    const result$ = merge(
-      this.eventBus.get("gather:resource-complete").pipe(
-        filter((e) => e.correlationId === correlationId),
-        map((e) => ({ ok: true, response: e.response }))
-      ),
-      this.eventBus.get("gather:resource-failed").pipe(
-        filter((e) => e.correlationId === correlationId),
-        map((e) => ({ ok: false, error: e.error }))
-      )
-    ).pipe(take(1), timeout(this.timeoutMs));
-    const resultPromise = firstValueFrom(result$);
-    this.eventBus.get("gather:resource-requested").next({
-      correlationId,
-      resourceId,
-      options
-    });
-    const result = await resultPromise;
-    if (!result.ok) {
-      throw result.error;
-    }
-    return result.response;
-  }
-  // ========================================================================
-  // Bind Flow — Search
-  // ========================================================================
-  async searchResources(searchTerm) {
-    const correlationId = crypto.randomUUID();
-    const referenceId = correlationId;
-    const result$ = merge(
-      this.eventBus.get("match:search-results").pipe(
-        filter((e) => e.correlationId === correlationId),
-        map((e) => ({ ok: true, response: e.response }))
-      ),
-      this.eventBus.get("match:search-failed").pipe(
-        filter((e) => e.correlationId === correlationId),
-        map((e) => ({ ok: false, error: new Error(e.error) }))
-      )
-    ).pipe(take(1), timeout(this.timeoutMs));
-    const resultPromise = firstValueFrom(result$);
-    this.eventBus.get("match:search-requested").next({
-      correlationId,
-      referenceId,
-      context: {
-        annotation: {
-          "@context": "http://www.w3.org/ns/anno.jsonld",
-          type: "Annotation",
-          id: referenceId,
-          motivation: "linking",
-          target: referenceId,
-          body: []
-        },
-        sourceResource: {
-          "@context": "https://schema.org",
-          "@id": referenceId,
-          name: searchTerm,
-          format: "text/plain",
-          representations: []
-        },
-        sourceContext: { selected: searchTerm }
-      }
-    });
-    const result = await resultPromise;
-    if (!result.ok) {
-      throw result.error;
-    }
-    return result.response;
-  }
-};
 function getBodySource(body) {
   if (Array.isArray(body)) {
     for (const item of body) {
@@ -2749,14 +2335,14 @@ function isValidEmail(email) {
 
 // src/mime-utils.ts
 function getExtensionForMimeType(mimeType) {
-  const map4 = {
+  const map3 = {
     "text/plain": "txt",
     "text/markdown": "md",
     "image/png": "png",
     "image/jpeg": "jpg",
     "application/pdf": "pdf"
   };
-  return map4[mimeType] || "dat";
+  return map3[mimeType] || "dat";
 }
 function isImageMimeType(mimeType) {
   return mimeType === "image/png" || mimeType === "image/jpeg";
@@ -2777,6 +2363,6 @@ function getMimeCategory(mimeType) {
   return "unsupported";
 }
 
-export { APIError, AnnotationStore, EventBusClient, FlowEngine, JWTTokenSchema, LOCALES, ResourceStore, SSEClient, SSE_STREAM_CONNECTED, SemiontApiClient, buildContentCache, createCircleSvg, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findTextWithContext, formatLocaleDisplay, getAllLocaleCodes, getAnnotationExactText, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getExtensionForMimeType, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getTargetSelector, getTargetSource, getTextQuoteSelector, hasTargetSelector, isArchived, isAssessment, isBodyResolved, isComment, isDraft, isHighlight, isImageMimeType, isPdfMimeType, isReference, isResolvedReference, isStubReference, isTag, isTextMimeType, isValidEmail, normalizeCoordinates, normalizeText, parseSvgSelector, scaleSvgToNative, validateAndCorrectOffsets, validateData, verifyPosition };
+export { APIError, AdminNamespace, AuthNamespace, BeckonNamespace, BindNamespace, BrowseNamespace, GatherNamespace, JWTTokenSchema, JobNamespace, LOCALES, MarkNamespace, MatchNamespace, SSEClient, SSE_STREAM_CONNECTED, SemiontApiClient, YieldNamespace, buildContentCache, createCircleSvg, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findTextWithContext, formatLocaleDisplay, getAllLocaleCodes, getAnnotationExactText, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getExtensionForMimeType, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getTargetSelector, getTargetSource, getTextQuoteSelector, hasTargetSelector, isArchived, isAssessment, isBodyResolved, isComment, isDraft, isHighlight, isImageMimeType, isPdfMimeType, isReference, isResolvedReference, isStubReference, isTag, isTextMimeType, isValidEmail, normalizeCoordinates, normalizeText, parseSvgSelector, scaleSvgToNative, validateAndCorrectOffsets, validateData, verifyPosition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map