@semiont/api-client 0.4.20 → 0.4.22

package/dist/index.js

@@ -1,1044 +1,279 @@
 import ky, { HTTPError } from 'ky';
-import { BehaviorSubject, Observable, merge } from 'rxjs';
-import { map, distinctUntilChanged, filter, takeUntil } from 'rxjs/operators';
-import { annotationId, resourceId, searchQuery, email, googleCredential, refreshToken } from '@semiont/core';
-export { getFragmentSelector, getSvgSelector, getTextPositionSelector, validateSvgMarkup } from '@semiont/core';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { RESOURCE_BROADCAST_TYPES, PERSISTED_EVENT_TYPES, BRIDGED_CHANNELS, busLog } from '@semiont/core';
+import { getActiveTraceparent, recordBusEmit, withSpan, SpanKind, extractTraceparent, withTraceparent } from '@semiont/observability';
+import { share, filter, map } from 'rxjs/operators';
 
-// src/client.ts
-
-// src/sse/stream.ts
-function createSSEStream(url, fetchOptions, config, logger) {
-  let abortController = new AbortController();
-  let closed = false;
+// src/transport/http-transport.ts
+var DEGRADED_THRESHOLD_MS = 3e3;
+var ALLOWED_TRANSITIONS = {
+  initial: ["connecting", "closed"],
+  connecting: ["open", "reconnecting", "closed"],
+  open: ["reconnecting", "closed"],
+  reconnecting: ["connecting", "degraded", "closed"],
+  degraded: ["connecting", "closed"],
+  closed: []
+};
+function createActorVM(options) {
+  const { baseUrl, token: tokenOrGetter, channels: initialChannels, scope: initialScope, reconnectMs = 5e3 } = options;
+  const getToken = typeof tokenOrGetter === "function" ? tokenOrGetter : () => tokenOrGetter;
+  const g = globalThis;
+  g.__SEMIONT_ACTOR_INSTANCES__ = (g.__SEMIONT_ACTOR_INSTANCES__ ?? 0) + 1;
+  const actorSerial = g.__SEMIONT_ACTOR_INSTANCES__;
+  console.debug(`[diag] ActorVM #${actorSerial} constructed (baseUrl=${baseUrl})`);
+  const globalChannels = new Set(initialChannels);
+  const scopedChannels = /* @__PURE__ */ new Set();
+  let activeScope = initialScope;
+  const events$ = new Subject();
+  const state$ = new BehaviorSubject("initial");
+  let currentState = "initial";
+  let degradedTimer = null;
+  const transition = (next) => {
+    if (currentState === next) return;
+    const allowed = ALLOWED_TRANSITIONS[currentState];
+    if (!allowed.includes(next)) {
+      throw new Error(`Invalid connection state transition: ${currentState} \u2192 ${next}`);
+    }
+    const prev = currentState;
+    currentState = next;
+    if (next === "reconnecting" && prev !== "reconnecting") {
+      if (degradedTimer) clearTimeout(degradedTimer);
+      degradedTimer = setTimeout(() => {
+        if (currentState === "reconnecting") transition("degraded");
+      }, DEGRADED_THRESHOLD_MS);
+    }
+    if (prev === "reconnecting" && next !== "reconnecting") {
+      if (degradedTimer) {
+        clearTimeout(degradedTimer);
+        degradedTimer = null;
+      }
+    }
+    state$.next(next);
+  };
+  let running = false;
+  const inflightControllers = /* @__PURE__ */ new Set();
+  let reconnectTimer = null;
   let lastEventId = null;
-  const RECONNECT_INITIAL_MS = 1e3;
-  const RECONNECT_MAX_MS = 3e4;
-  let reconnectDelayMs = RECONNECT_INITIAL_MS;
+  const shared$ = events$.pipe(share());
+  const disconnect = () => {
+    for (const c of inflightControllers) {
+      try {
+        c.abort();
+      } catch {
+      }
+    }
+    inflightControllers.clear();
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+  };
   const connect = async () => {
-    try {
-      logger?.debug("SSE Stream Request", {
-        type: "sse_request",
-        url,
-        method: fetchOptions.method || "GET",
-        timestamp: Date.now()
-      });
-      const headers = {
-        ...fetchOptions.headers,
-        "Accept": "text/event-stream"
-      };
-      if (lastEventId !== null) {
-        headers["Last-Event-ID"] = lastEventId;
+    transition("connecting");
+    for (const c of inflightControllers) {
+      try {
+        c.abort();
+      } catch {
       }
-      const response = await fetch(url, {
-        ...fetchOptions,
-        signal: abortController.signal,
-        headers
-      });
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        const error = new Error(errorData.message || `HTTP ${response.status}: ${response.statusText}`);
-        logger?.error("SSE Stream Error", {
-          type: "sse_error",
-          url,
-          error: error.message,
-          status: response.status,
-          phase: "connect"
-        });
-        throw error;
+    }
+    inflightControllers.clear();
+    const params = new URLSearchParams();
+    for (const ch of globalChannels) {
+      params.append("channel", ch);
+    }
+    if (activeScope && scopedChannels.size > 0) {
+      params.append("scope", activeScope);
+      for (const ch of scopedChannels) {
+        params.append("scoped", ch);
       }
-      if (!response.body) {
-        const error = new Error("Response body is null - server did not return a stream");
-        logger?.error("SSE Stream Error", {
-          type: "sse_error",
-          url,
-          error: error.message,
-          phase: "connect"
-        });
-        throw error;
+    }
+    const url = `${baseUrl}/bus/subscribe?${params.toString()}`;
+    const controller = new AbortController();
+    inflightControllers.add(controller);
+    try {
+      const headers = { Authorization: `Bearer ${getToken()}` };
+      if (lastEventId) headers["Last-Event-ID"] = lastEventId;
+      const response = await fetch(url, { headers, signal: controller.signal });
+      if (!response.ok || !response.body) {
+        throw new Error(`SSE connect failed: ${response.status}`);
       }
-      logger?.info("SSE Stream Connected", {
-        type: "sse_connected",
-        url,
-        status: response.status,
-        contentType: response.headers.get("content-type") || "unknown"
-      });
+      transition("open");
       const reader = response.body.getReader();
       const decoder = new TextDecoder();
       let buffer = "";
-      let eventType = "";
-      let eventData = "";
-      let eventId = "";
-      while (true) {
+      let currentEvent = "";
+      let currentData = "";
+      let currentId;
+      while (running && inflightControllers.has(controller)) {
         const { done, value } = await reader.read();
-        if (done || closed) break;
-        const chunk = decoder.decode(value, { stream: true });
-        buffer += chunk;
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
         const lines = buffer.split("\n");
-        buffer = lines.pop() || "";
+        buffer = lines.pop() ?? "";
         for (const line of lines) {
-          if (line.startsWith("event:")) {
-            eventType = line.slice(6).trim();
-          } else if (line.startsWith("data:")) {
-            eventData = line.slice(5).trim();
-          } else if (line.startsWith("id:")) {
-            eventId = line.slice(3).trim();
+          if (line.startsWith("event: ")) {
+            currentEvent = line.slice(7);
+          } else if (line.startsWith("data: ")) {
+            currentData = line.slice(6);
+          } else if (line.startsWith("id: ")) {
+            currentId = line.slice(4);
           } else if (line === "") {
-            if (eventData && !closed) {
-              handleEvent(eventType, eventData, eventId);
-              if (closed) break;
-              eventType = "";
-              eventData = "";
-              eventId = "";
+            if (currentEvent === "bus-event" && currentData) {
+              if (currentId !== void 0) lastEventId = currentId;
+              const parsed = JSON.parse(currentData);
+              busLog("RECV", parsed.channel, parsed.payload, parsed.scope);
+              const carrier = extractTraceparent(
+                parsed.payload
+              );
+              await withTraceparent(
+                carrier,
+                () => withSpan(
+                  `bus.recv:${parsed.channel}`,
+                  () => {
+                    events$.next(parsed);
+                  },
+                  {
+                    kind: SpanKind.CONSUMER,
+                    attrs: {
+                      "bus.channel": parsed.channel,
+                      ...parsed.scope ? { "bus.scope": parsed.scope } : {}
+                    }
+                  }
+                )
+              );
             }
+            currentEvent = "";
+            currentData = "";
+            currentId = void 0;
           }
         }
-        if (closed) break;
-      }
-      logger?.info("SSE Stream Closed", {
-        type: "sse_closed",
-        url,
-        reason: "complete"
-      });
-    } catch (error) {
-      if (error instanceof Error && error.name !== "AbortError") {
-        logger?.error("SSE Stream Error", {
-          type: "sse_error",
-          url,
-          error: error.message,
-          phase: "stream"
-        });
-      } else if (error instanceof Error && error.name === "AbortError") {
-        logger?.info("SSE Stream Closed", {
-          type: "sse_closed",
-          url,
-          reason: "abort"
-        });
       }
+    } catch (err) {
+      if (err.name === "AbortError") return;
+    } finally {
+      inflightControllers.delete(controller);
     }
-  };
-  const handleEvent = (eventType, data, id) => {
-    if (data.startsWith(":")) {
-      return;
-    }
-    if (id) {
-      lastEventId = id;
-    }
-    try {
-      const parsed = JSON.parse(data);
-      logger?.debug("SSE Event Received", {
-        type: "sse_event",
-        url,
-        event: eventType || "message",
-        hasData: !!data
-      });
-      if (typeof parsed === "object" && parsed !== null && "metadata" in parsed) {
-        config.eventBus.get(eventType).next(parsed);
-        return;
-      }
-      config.eventBus.get(eventType).next(parsed);
-      if (config.completeEvent && eventType === config.completeEvent) {
-        closed = true;
-        abortController.abort();
-      } else if (config.errorEvent && eventType === config.errorEvent) {
-        closed = true;
-        abortController.abort();
-      }
-    } catch (error) {
-      logger?.error("SSE Failed to parse event data", { error, eventType, data });
+    if (running) {
+      transition("reconnecting");
+      reconnectTimer = setTimeout(() => {
+        if (running) connect();
+      }, reconnectMs);
     }
   };
-  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);
+  const reconnect = () => {
+    if (!running) return;
+    if (currentState === "open" || currentState === "connecting" || currentState === "degraded") {
+      transition("reconnecting");
     }
+    disconnect();
+    connect();
   };
-  void runConnect();
-  return {
-    close() {
-      closed = true;
-      abortController.abort();
-    }
+  let reconnectTimer2 = null;
+  const RECONNECT_DEBOUNCE_MS = 100;
+  const scheduleReconnect = () => {
+    if (reconnectTimer2) clearTimeout(reconnectTimer2);
+    reconnectTimer2 = setTimeout(() => {
+      reconnectTimer2 = null;
+      reconnect();
+    }, RECONNECT_DEBOUNCE_MS);
   };
-}
-
-// src/sse/index.ts
-var SSE_STREAM_CONNECTED = "stream-connected";
-var SSEClient = class {
-  baseUrl;
-  logger;
-  constructor(config) {
-    this.baseUrl = config.baseUrl.endsWith("/") ? config.baseUrl.slice(0, -1) : config.baseUrl;
-    this.logger = config.logger;
-  }
-  /**
-   * Get common headers for SSE requests
-   */
-  getHeaders(auth) {
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (auth) {
-      headers["Authorization"] = `Bearer ${auth}`;
-    }
-    return headers;
-  }
-  /**
-   * Subscribe to resource events (long-lived stream)
-   *
-   * Opens a long-lived SSE connection to receive real-time events for a resource.
-   * Used for collaborative editing - see events from other users as they happen.
-   *
-   * This stream does NOT have a complete event - it stays open until explicitly closed.
-   *
-   * @param resourceId - Resource URI or ID to subscribe to
-   * @param options - Request options (auth token)
-   * @returns SSE stream controller with event callback
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.resourceEvents(
-   *   'http://localhost:4000/resources/doc-123',
-   *   { auth: 'your-token' }
-   * );
-   *
-   * stream.onProgress((event) => {
-   *   console.log(`Event: ${event.type}`);
-   *   console.log(`User: ${event.userId}`);
-   *   console.log(`Sequence: ${event.metadata.sequenceNumber}`);
-   *   console.log(`Payload:`, event.payload);
-   * });
-   *
-   * stream.onError((error) => {
-   *   console.error('Stream error:', error.message);
-   * });
-   *
-   * // Close when no longer needed (e.g., component unmount)
-   * stream.close();
-   * ```
-   */
-  resourceEvents(resourceId, options) {
-    const url = `${this.baseUrl}/resources/${resourceId}/events/stream`;
-    const stream = createSSEStream(
-      url,
-      {
-        method: "GET",
-        headers: this.getHeaders(options.auth)
-      },
-      {
-        progressEvents: ["*"],
-        // Accept all event types (long-lived stream)
-        completeEvent: null,
-        // Never completes (long-lived)
-        errorEvent: null,
-        // No error event (errors throw)
-        eventBus: options.eventBus,
-        reconnect: true
-      },
-      this.logger
-    );
-    if (options.onConnected) {
-      const sub = options.eventBus.get(SSE_STREAM_CONNECTED).subscribe(() => {
-        options.onConnected();
-        sub.unsubscribe();
-      });
-    }
-    return stream;
-  }
-  /**
-   * Subscribe to global system events (long-lived stream)
-   *
-   * Opens a long-lived SSE connection to receive system-level domain events
-   * (entity type additions, etc.) that are not scoped to a specific resource.
-   *
-   * @param options - Request options (auth token, eventBus)
-   * @returns SSE stream controller
-   *
-   * @example
-   * ```typescript
-   * const stream = sseClient.globalEvents({ auth: 'your-token', eventBus });
-   *
-   * // 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
-   * stream.close();
-   * ```
-   */
-  globalEvents(options) {
-    const url = `${this.baseUrl}/api/events/stream`;
-    const stream = createSSEStream(
-      url,
-      {
-        method: "GET",
-        headers: this.getHeaders(options.auth)
-      },
-      {
-        progressEvents: ["*"],
-        completeEvent: null,
-        errorEvent: null,
-        eventBus: options.eventBus,
-        reconnect: true
-      },
-      this.logger
-    );
-    if (options.onConnected) {
-      const sub = options.eventBus.get(SSE_STREAM_CONNECTED).subscribe(() => {
-        options.onConnected();
-        sub.unsubscribe();
-      });
-    }
-    return stream;
-  }
-  /**
-   * Subscribe to participant attention stream (long-lived stream)
-   *
-   * Opens a participant-scoped SSE connection to receive cross-participant
-   * beckon signals. Signals are delivered as 'beckon:focus' events routed
-   * to the EventBus — the existing scroll/highlight machinery handles them.
-   *
-   * Signals are ephemeral — delivered if connected, dropped if not.
-   *
-   * @param options - Request options (auth token, eventBus)
-   * @returns SSE stream controller
-   */
-  attentionStream(options) {
-    const url = `${this.baseUrl}/api/participants/me/attention-stream`;
-    const stream = createSSEStream(
-      url,
-      {
-        method: "GET",
-        headers: this.getHeaders(options.auth)
-      },
-      {
-        progressEvents: ["*"],
-        completeEvent: null,
-        errorEvent: null,
-        eventBus: options.eventBus,
-        reconnect: true
-      },
-      this.logger
-    );
-    if (options.onConnected) {
-      const sub = options.eventBus.get(SSE_STREAM_CONNECTED).subscribe(() => {
-        options.onConnected();
-        sub.unsubscribe();
-      });
-    }
-    return stream;
-  }
-};
-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;
-  }
-  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;
-  }
-  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()
+  return {
+    on$(channel) {
+      return shared$.pipe(
+        filter((e) => e.channel === channel),
+        map((e) => e.payload)
       );
-      this.annotationListObs$.set(resourceId, obs);
-    }
-    return obs;
-  }
-  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;
-  }
-  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);
-  }
-  async resourceRepresentation(resourceId, options) {
-    return this.http.getResourceRepresentation(resourceId, {
-      accept: options?.accept,
-      auth: this.getToken()
-    });
-  }
-  async resourceRepresentationStream(resourceId, options) {
-    return this.http.getResourceRepresentationStream(resourceId, {
-      accept: options?.accept,
-      auth: this.getToken()
-    });
-  }
-  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));
-    });
-    bus.get("mark:added").subscribe((stored) => {
-      if (stored.resourceId) {
-        this.invalidateAnnotationList(stored.resourceId);
+    },
+    emit: async (channel, payload, emitScope) => {
+      const body = { channel, payload };
+      if (emitScope) body.scope = emitScope;
+      const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${getToken()}`
+      };
+      const trace = getActiveTraceparent();
+      if (trace) {
+        headers["traceparent"] = trace.traceparent;
+        if (trace.tracestate) headers["tracestate"] = trace.tracestate;
       }
-    });
-    bus.get("mark:removed").subscribe((stored) => {
-      if (stored.resourceId) {
-        this.invalidateAnnotationList(stored.resourceId);
+      await fetch(`${baseUrl}/bus/emit`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+    },
+    state$: state$.asObservable(),
+    addChannels: (channels, scope) => {
+      let changed = false;
+      if (scope !== void 0) {
+        for (const ch of channels) {
+          if (!scopedChannels.has(ch)) {
+            scopedChannels.add(ch);
+            changed = true;
+          }
+        }
+        if (scope !== activeScope) {
+          activeScope = scope;
+          changed = true;
+        }
+      } else {
+        for (const ch of channels) {
+          if (!globalChannels.has(ch)) {
+            globalChannels.add(ch);
+            changed = true;
+          }
+        }
       }
-      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);
+      if (changed) scheduleReconnect();
+    },
+    removeChannels: (channels) => {
+      let changed = false;
+      for (const ch of channels) {
+        if (scopedChannels.delete(ch)) changed = true;
+        if (globalChannels.delete(ch)) changed = true;
       }
-    });
-    bus.get("mark:entity-tag-removed").subscribe((stored) => {
-      if (stored.resourceId) {
-        this.invalidateAnnotationList(stored.resourceId);
-        this.invalidateResourceDetail(stored.resourceId);
+      if (scopedChannels.size === 0) activeScope = void 0;
+      if (changed) scheduleReconnect();
+    },
+    start: () => {
+      if (running) return;
+      running = true;
+      connect();
+    },
+    stop: () => {
+      running = false;
+      if (currentState !== "closed") transition("closed");
+      if (reconnectTimer2) {
+        clearTimeout(reconnectTimer2);
+        reconnectTimer2 = null;
       }
-    });
-    bus.get("replay-window-exceeded").subscribe((event) => {
-      if (event.resourceId) {
-        this.invalidateAnnotationList(event.resourceId);
+      if (degradedTimer) {
+        clearTimeout(degradedTimer);
+        degradedTimer = null;
       }
-    });
-    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();
+      disconnect();
+    },
+    dispose: () => {
+      running = false;
+      if (currentState !== "closed") transition("closed");
+      if (reconnectTimer2) {
+        clearTimeout(reconnectTimer2);
+        reconnectTimer2 = null;
       }
-    });
-    bus.get("mark:unarchived").subscribe((stored) => {
-      if (stored.resourceId) {
-        this.invalidateResourceDetail(stored.resourceId);
-        this.invalidateResourceLists();
+      if (degradedTimer) {
+        clearTimeout(degradedTimer);
+        degradedTimer = null;
       }
-    });
-    bus.get("mark:entity-type-added").subscribe(() => {
-      this.invalidateEntityTypes();
-    });
-  }
-  // ── 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);
-    }
-  }
-  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);
-    }
-  }
-  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);
-    }
-  }
-  async fetchResourceList(key, filters) {
-    if (this.fetchingResourceList.has(key)) return;
-    this.fetchingResourceList.add(key);
-    try {
-      const search = filters?.search ? searchQuery(filters.search) : void 0;
-      const result = await this.http.browseResources(filters?.limit, filters?.archived, search, { 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 fetchEntityTypes() {
-    if (this.fetchingEntityTypes) return;
-    this.fetchingEntityTypes = true;
-    try {
-      const result = await this.http.listEntityTypes({ auth: this.getToken() });
-      this.entityTypes$.next(result.entityTypes);
-    } catch {
-    } finally {
-      this.fetchingEntityTypes = false;
-    }
-  }
-  async fetchReferencedBy(resourceId) {
-    if (this.fetchingReferencedBy.has(resourceId)) return;
-    this.fetchingReferencedBy.add(resourceId);
-    try {
-      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.fetchingReferencedBy.delete(resourceId);
-    }
-  }
-};
-var MarkNamespace = class {
-  constructor(http, eventBus, getToken) {
-    this.http = http;
-    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();
-      };
-    });
-  }
-  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 });
+      disconnect();
+      events$.complete();
+      state$.complete();
     }
-  }
-};
-
-// 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();
-      };
-    });
-  }
-  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();
-      };
-    });
-  }
-};
-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();
-      };
-    });
-  }
-  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(() => {
-    });
-  }
-};
-
-// 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()
-    });
-  }
-  async cancel(jobId, type) {
-    throw new Error(`Not implemented: job.cancel(${jobId}, ${type}) \u2014 needs EventBus wiring`);
-  }
-};
-var AuthNamespace = class {
-  constructor(http, getToken) {
-    this.http = http;
-    this.getToken = getToken;
-  }
-  async password(emailStr, passwordStr) {
-    return this.http.authenticatePassword(email(emailStr), passwordStr);
-  }
-  async google(credential) {
-    return this.http.authenticateGoogle(googleCredential(credential));
-  }
-  async refresh(token) {
-    return this.http.refreshToken(refreshToken(token));
-  }
-  async logout() {
-    await this.http.logout({ auth: this.getToken() });
-  }
-  async me() {
-    return this.http.getMe({ auth: this.getToken() });
-  }
-  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 });
-  }
-};
-
-// src/client.ts
+  };
+}
+var RESOURCE_SCOPED_CHANNELS = [
+  ...PERSISTED_EVENT_TYPES.filter((t) => t !== "mark:entity-type-added"),
+  ...RESOURCE_BROADCAST_TYPES
+];
 var APIError = class extends Error {
   constructor(message, status, statusText, details) {
     super(message);
@@ -1048,40 +283,22 @@ var APIError = class extends Error {
     this.name = "APIError";
   }
 };
-var SemiontApiClient = class {
-  http;
+var HttpTransport = class {
   baseUrl;
-  /** The workspace-scoped EventBus this client was constructed with. */
-  eventBus;
+  http;
+  token$;
   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
-   *
-   * Separate from the main HTTP client to clearly mark streaming endpoints.
-   * Uses native fetch() instead of ky for SSE support.
-   */
-  sse;
-  // ── Verb-oriented namespace API ──────────────────────────────────────────
-  browse;
-  mark;
-  bind;
-  gather;
-  match;
-  yield;
-  beckon;
-  job;
-  auth;
-  admin;
+  _actor = null;
+  _actorStarted = false;
+  disposed = false;
+  activeResource = null;
+  /** Buses we've been asked to bridge wire events into. */
+  bridges = [];
   constructor(config) {
-    const { baseUrl, eventBus, timeout = 3e4, retry = 2, logger, tokenRefresher } = config;
-    this.eventBus = eventBus;
-    this.logger = logger;
+    const { baseUrl, timeout = 3e4, retry = 2, logger, tokenRefresher } = config;
     this.baseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    this.token$ = config.token$ ?? new BehaviorSubject(null);
+    this.logger = logger;
     const retryConfig = tokenRefresher ? {
       limit: 1,
       methods: ["get", "post", "put", "patch", "delete", "head", "options"],
@@ -1161,462 +378,234 @@ var SemiontApiClient = class {
         ]
       }
     });
-    this.sse = new SSEClient({
-      baseUrl: this.baseUrl,
-      logger: this.logger
-    });
-    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}` } : {};
-  }
-  // ============================================================================
-  // AUTHENTICATION
-  // ============================================================================
-  async authenticatePassword(email, password, options) {
-    return this.http.post(`${this.baseUrl}/api/tokens/password`, {
-      json: { email, password },
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async refreshToken(token, options) {
-    return this.http.post(`${this.baseUrl}/api/tokens/refresh`, {
-      json: { refreshToken: token },
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async authenticateGoogle(credential, options) {
-    return this.http.post(`${this.baseUrl}/api/tokens/google`, {
-      json: { credential },
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async generateMCPToken(options) {
-    return this.http.post(`${this.baseUrl}/api/tokens/mcp-generate`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async getMediaToken(resourceId, options) {
-    return this.http.post(`${this.baseUrl}/api/tokens/media`, {
-      json: { resourceId },
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  // ============================================================================
-  // USERS
-  // ============================================================================
-  async getMe(options) {
-    return this.http.get(`${this.baseUrl}/api/users/me`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async acceptTerms(options) {
-    return this.http.post(`${this.baseUrl}/api/users/accept-terms`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async logout(options) {
-    return this.http.post(`${this.baseUrl}/api/users/logout`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  // ============================================================================
-  // RESOURCES
-  // ============================================================================
-  /**
-   * Create a new resource with binary content support
-   *
-   * @param data - Resource creation data
-   * @param data.name - Resource name
-   * @param data.file - File object or Buffer with binary content
-   * @param data.format - MIME type (e.g., 'text/markdown', 'image/png')
-   * @param data.entityTypes - Optional array of entity types
-   * @param data.language - Optional ISO 639-1 language code
-   * @param data.creationMethod - Optional creation method
-   * @param data.sourceAnnotationId - Optional source annotation ID
-   * @param data.sourceResourceId - Optional source resource ID
-   * @param options - Request options including auth
-   */
-  async yieldResource(data, options) {
-    const formData = new FormData();
-    formData.append("name", data.name);
-    formData.append("format", data.format);
-    formData.append("storageUri", data.storageUri);
-    if (data.file instanceof File) {
-      formData.append("file", data.file);
-    } else if (Buffer.isBuffer(data.file)) {
-      const blob = new Blob([new Uint8Array(data.file)], { type: data.format });
-      formData.append("file", blob, data.name);
-    } else {
-      throw new Error("file must be a File or Buffer");
-    }
-    if (data.entityTypes && data.entityTypes.length > 0) {
-      formData.append("entityTypes", JSON.stringify(data.entityTypes));
-    }
-    if (data.language) {
-      formData.append("language", data.language);
-    }
-    if (data.creationMethod) {
-      formData.append("creationMethod", data.creationMethod);
-    }
-    if (data.sourceAnnotationId) {
-      formData.append("sourceAnnotationId", data.sourceAnnotationId);
-    }
-    if (data.sourceResourceId) {
-      formData.append("sourceResourceId", data.sourceResourceId);
-    }
-    return this.http.post(`${this.baseUrl}/resources`, {
-      body: formData,
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async browseResource(id, options) {
-    return this.http.get(`${this.baseUrl}/resources/${id}`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  /**
-   * Get resource representation using W3C content negotiation
-   * Returns raw binary content (images, PDFs, text, etc.) with content type
-   *
-   * @param resourceUri - Full resource URI
-   * @param options - Options including Accept header for content negotiation and auth
-   * @returns Object with data (ArrayBuffer) and contentType (string)
-   *
-   * @example
-   * ```typescript
-   * // Get markdown representation
-   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'text/markdown', auth: token });
-   * const markdown = new TextDecoder().decode(data);
-   *
-   * // Get image representation
-   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'image/png', auth: token });
-   * const blob = new Blob([data], { type: contentType });
-   *
-   * // Get PDF representation
-   * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'application/pdf', auth: token });
-   * ```
-   */
-  async getResourceRepresentation(id, options) {
-    const response = await this.http.get(`${this.baseUrl}/resources/${id}`, {
-      headers: {
-        Accept: options?.accept || "text/plain",
-        ...this.authHeaders(options)
-      }
-    });
-    const contentType = response.headers.get("content-type") || "application/octet-stream";
-    const data = await response.arrayBuffer();
-    return { data, contentType };
-  }
-  /**
-   * Get resource representation as a stream using W3C content negotiation
-   * Returns streaming binary content (for large files: videos, large PDFs, etc.)
-   *
-   * Use this for large files to avoid loading entire content into memory.
-   * The stream is consumed incrementally and the backend connection stays open
-   * until the stream is fully consumed or closed.
-   *
-   * @param resourceUri - Full resource URI
-   * @param options - Options including Accept header for content negotiation and auth
-   * @returns Object with stream (ReadableStream) and contentType (string)
-   *
-   * @example
-   * ```typescript
-   * // Stream large file
-   * const { stream, contentType } = await client.getResourceRepresentationStream(rUri, {
-   *   accept: 'video/mp4',
-   *   auth: token
-   * });
-   *
-   * // Consume stream chunk by chunk (never loads entire file into memory)
-   * for await (const chunk of stream) {
-   *   // Process chunk
-   *   console.log(`Received ${chunk.length} bytes`);
-   * }
-   *
-   * // Or pipe to a file in Node.js
-   * const fileStream = fs.createWriteStream('output.mp4');
-   * const reader = stream.getReader();
-   * while (true) {
-   *   const { done, value } = await reader.read();
-   *   if (done) break;
-   *   fileStream.write(value);
-   * }
-   * ```
-   */
-  async getResourceRepresentationStream(id, options) {
-    const response = await this.http.get(`${this.baseUrl}/resources/${id}`, {
-      headers: {
-        Accept: options?.accept || "text/plain",
-        ...this.authHeaders(options)
+    this.token$.subscribe((token) => {
+      if (token && !this._actorStarted && !this.disposed) {
+        this._actorStarted = true;
+        this.actor.start();
       }
     });
-    const contentType = response.headers.get("content-type") || "application/octet-stream";
-    if (!response.body) {
-      throw new Error("Response body is null - cannot create stream");
-    }
-    return { stream: response.body, contentType };
-  }
-  async browseResources(limit, archived, query, options) {
-    const searchParams = new URLSearchParams();
-    if (limit) searchParams.append("limit", limit.toString());
-    if (archived !== void 0) searchParams.append("archived", archived.toString());
-    if (query) searchParams.append("q", query);
-    return this.http.get(`${this.baseUrl}/resources`, {
-      searchParams,
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async updateResource(id, data, options) {
-    await this.http.patch(`${this.baseUrl}/resources/${id}`, {
-      json: data,
-      headers: this.authHeaders(options)
-    }).text();
-  }
-  async getResourceEvents(id, options) {
-    return this.http.get(`${this.baseUrl}/resources/${id}/events`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async browseReferences(id, options) {
-    return this.http.get(`${this.baseUrl}/resources/${id}/referenced-by`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async generateCloneToken(id, options) {
-    return this.http.post(`${this.baseUrl}/resources/${id}/clone-with-token`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async getResourceByToken(token, options) {
-    return this.http.get(`${this.baseUrl}/api/clone-tokens/${token}`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async createResourceFromToken(data, options) {
-    return this.http.post(`${this.baseUrl}/api/clone-tokens/create-resource`, {
-      json: data,
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  // ============================================================================
-  // ANNOTATIONS
-  // ============================================================================
-  async markAnnotation(id, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${id}/annotations`, {
-      json: data,
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async getAnnotation(id, options) {
-    return this.http.get(`${this.baseUrl}/annotations/${id}`, {
-      headers: this.authHeaders(options)
-    }).json();
   }
-  async browseAnnotation(resourceId, annotationId, options) {
-    return this.http.get(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}`, {
-      headers: this.authHeaders(options)
-    }).json();
+  // ── Lazy actor construction + per-channel fan-in to bridges ───────────
+  //
+  // `actor` is exposed so the legacy `SemiontClient` can keep `.actor`
+  // pointing at the same ActorVM during the transport-abstraction
+  // migration. Once SemiontClient is removed, this should be made
+  // private again — external callers should use emit/on/stream/state$.
+  get actor() {
+    if (!this._actor) {
+      this._actor = createActorVM({
+        baseUrl: this.baseUrl,
+        token: () => this.token$.getValue() ?? "",
+        channels: [...BRIDGED_CHANNELS]
+      });
+      for (const channel of BRIDGED_CHANNELS) {
+        this._actor.on$(channel).subscribe((payload) => {
+          for (const bus of this.bridges) {
+            bus.get(channel).next(payload);
+          }
+        });
+      }
+    }
+    return this._actor;
+  }
+  // ── ITransport — bus primitives ───────────────────────────────────────
+  async emit(channel, payload, resourceScope) {
+    busLog("EMIT", channel, payload, resourceScope);
+    recordBusEmit(channel, resourceScope);
+    await withSpan(
+      `bus.emit:${channel}`,
+      async () => {
+        if (resourceScope !== void 0) {
+          await this.actor.emit(
+            channel,
+            payload,
+            resourceScope
+          );
+        } else {
+          await this.actor.emit(
+            channel,
+            payload
+          );
+        }
+      },
+      {
+        kind: SpanKind.PRODUCER,
+        attrs: {
+          "bus.channel": channel,
+          ...resourceScope ? { "bus.scope": resourceScope } : {}
+        }
+      }
+    );
   }
-  async browseAnnotations(id, motivation, options) {
-    const searchParams = new URLSearchParams();
-    if (motivation) searchParams.append("motivation", motivation);
-    return this.http.get(`${this.baseUrl}/resources/${id}/annotations`, {
-      searchParams,
-      headers: this.authHeaders(options)
-    }).json();
+  on(channel, handler) {
+    const sub = this.actor.on$(channel).subscribe(handler);
+    return () => sub.unsubscribe();
   }
-  async deleteAnnotation(resourceId, annotationId, options) {
-    await this.http.delete(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}`, {
-      headers: this.authHeaders(options)
-    });
+  stream(channel) {
+    return this.actor.on$(channel);
   }
-  async bindAnnotation(resourceId, annotationId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/bind`, {
-      json: { resourceId, ...data },
-      headers: this.authHeaders(options)
-    }).json();
+  /**
+   * Wire this transport's SSE fan-in into the given bus. Every channel
+   * in `BRIDGED_CHANNELS` (and subsequently per-resource scoped channels
+   * opened by `subscribeToResource`) is published on the bus. Safe to
+   * call multiple times — each bus is added to the fan-out list.
+   */
+  bridgeInto(bus) {
+    this.bridges.push(bus);
+  }
+  subscribeToResource(resourceId) {
+    if (this.activeResource) {
+      if (this.activeResource.resourceId !== resourceId) {
+        throw new Error(
+          `HttpTransport already subscribed to resource ${this.activeResource.resourceId}; call the unsubscribe returned from the previous subscribeToResource before subscribing to ${resourceId}.`
+        );
+      }
+      this.activeResource.refCount++;
+      return this.makeUnsubscriber();
+    }
+    this.actor.addChannels([...RESOURCE_SCOPED_CHANNELS], resourceId);
+    const bridgeSubs = [];
+    for (const channel of RESOURCE_SCOPED_CHANNELS) {
+      bridgeSubs.push(
+        this.actor.on$(channel).subscribe((payload) => {
+          for (const bus of this.bridges) {
+            bus.get(channel).next(payload);
+          }
+        })
+      );
+    }
+    this.activeResource = { resourceId, refCount: 1, bridgeSubs };
+    return this.makeUnsubscriber();
+  }
+  makeUnsubscriber() {
+    let called = false;
+    return () => {
+      if (called) return;
+      called = true;
+      if (!this.activeResource) return;
+      this.activeResource.refCount--;
+      if (this.activeResource.refCount > 0) return;
+      for (const sub of this.activeResource.bridgeSubs) sub.unsubscribe();
+      this.actor.removeChannels([...RESOURCE_SCOPED_CHANNELS]);
+      this.activeResource = null;
+    };
   }
-  async getAnnotationHistory(resourceId, annotationId, options) {
-    return this.http.get(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/history`, {
-      headers: this.authHeaders(options)
-    }).json();
+  get state$() {
+    return this.actor.state$;
   }
-  async annotateReferences(resourceId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-references`, {
-      json: data,
-      headers: this.authHeaders(options)
-    }).json();
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    if (this.activeResource) {
+      for (const sub of this.activeResource.bridgeSubs) sub.unsubscribe();
+      this.activeResource = null;
+    }
+    if (this._actor) {
+      this._actor.dispose();
+      this._actor = null;
+    }
   }
-  async annotateHighlights(resourceId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-highlights`, {
-      json: data,
-      headers: this.authHeaders(options)
-    }).json();
+  // ── Auth ──────────────────────────────────────────────────────────────
+  authHeaders() {
+    const token = this.token$.getValue() ?? void 0;
+    return token ? { Authorization: `Bearer ${token}` } : {};
   }
-  async annotateAssessments(resourceId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-assessments`, {
-      json: data,
-      headers: this.authHeaders(options)
+  async authenticatePassword(email, password) {
+    return this.http.post(`${this.baseUrl}/api/tokens/password`, {
+      json: { email, password },
+      headers: this.authHeaders()
     }).json();
   }
-  async annotateComments(resourceId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-comments`, {
-      json: data,
-      headers: this.authHeaders(options)
+  async authenticateGoogle(credential) {
+    return this.http.post(`${this.baseUrl}/api/tokens/google`, {
+      json: { credential },
+      headers: this.authHeaders()
     }).json();
   }
-  async annotateTags(resourceId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotate-tags`, {
-      json: data,
-      headers: this.authHeaders(options)
+  async refreshAccessToken(token) {
+    return this.http.post(`${this.baseUrl}/api/tokens/refresh`, {
+      json: { refreshToken: token },
+      headers: this.authHeaders()
     }).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)
+  async logout() {
+    await this.http.post(`${this.baseUrl}/api/users/logout`, {
+      headers: this.authHeaders()
     }).json();
   }
-  async gatherAnnotationContext(resourceId, annotationId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/annotations/${annotationId}/gather`, {
-      json: data,
-      headers: this.authHeaders(options)
+  async acceptTerms() {
+    await this.http.post(`${this.baseUrl}/api/users/accept-terms`, {
+      headers: this.authHeaders()
     }).json();
   }
-  async matchSearch(resourceId, data, options) {
-    return this.http.post(`${this.baseUrl}/resources/${resourceId}/match-search`, {
-      json: { resourceId, ...data },
-      headers: this.authHeaders(options)
+  async getCurrentUser() {
+    return this.http.get(`${this.baseUrl}/api/users/me`, {
+      headers: this.authHeaders()
     }).json();
   }
-  // ============================================================================
-  // ENTITY TYPES
-  // ============================================================================
-  async addEntityType(type, options) {
-    await this.http.post(`${this.baseUrl}/api/entity-types`, {
-      json: { tag: type },
-      headers: this.authHeaders(options)
-    });
-  }
-  async addEntityTypesBulk(types, options) {
-    await this.http.post(`${this.baseUrl}/api/entity-types/bulk`, {
-      json: { tags: types },
-      headers: this.authHeaders(options)
-    });
-  }
-  async listEntityTypes(options) {
-    return this.http.get(`${this.baseUrl}/api/entity-types`, {
-      headers: this.authHeaders(options)
+  async generateMcpToken() {
+    return this.http.post(`${this.baseUrl}/api/tokens/mcp-generate`, {
+      headers: this.authHeaders()
     }).json();
   }
-  // ============================================================================
-  // PARTICIPANTS
-  // ============================================================================
-  async beckonAttention(participantId, data, options) {
-    return this.http.post(`${this.baseUrl}/api/participants/${participantId}/attention`, {
-      json: data,
-      headers: this.authHeaders(options)
+  async getMediaToken(resourceId) {
+    return this.http.post(`${this.baseUrl}/api/tokens/media`, {
+      json: { resourceId },
+      headers: this.authHeaders()
     }).json();
   }
-  // ============================================================================
-  // ADMIN
-  // ============================================================================
-  async listUsers(options) {
+  // ── Admin ─────────────────────────────────────────────────────────────
+  async listUsers() {
     return this.http.get(`${this.baseUrl}/api/admin/users`, {
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     }).json();
   }
-  async getUserStats(options) {
+  async getUserStats() {
     return this.http.get(`${this.baseUrl}/api/admin/users/stats`, {
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     }).json();
   }
-  /**
-   * Update a user by ID
-   * Note: Users use DID identifiers (did:web:domain:users:id), not HTTP URIs.
-   */
-  async updateUser(id, data, options) {
+  async updateUser(id, data) {
     return this.http.patch(`${this.baseUrl}/api/admin/users/${id}`, {
       json: data,
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     }).json();
   }
-  async getOAuthConfig(options) {
+  async getOAuthConfig() {
     return this.http.get(`${this.baseUrl}/api/admin/oauth/config`, {
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     }).json();
   }
-  // ============================================================================
-  // ADMIN — EXCHANGE (Backup/Restore)
-  // ============================================================================
-  /**
-   * Create a backup of the knowledge base. Returns raw Response for streaming download.
-   * Caller should use response.blob() to trigger a file download.
-   */
-  async backupKnowledgeBase(options) {
+  // ── Exchange (backup/restore/export/import) ───────────────────────────
+  async backupKnowledgeBase() {
     return this.http.post(`${this.baseUrl}/api/admin/exchange/backup`, {
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     });
   }
-  /**
-   * Restore knowledge base from a backup file. Parses SSE progress events and calls onProgress.
-   * Returns the final SSE event (phase: 'complete' or 'error').
-   */
-  async restoreKnowledgeBase(file, options) {
+  async restoreKnowledgeBase(file, onProgress) {
     const formData = new FormData();
     formData.append("file", file);
     const response = await this.http.post(`${this.baseUrl}/api/admin/exchange/restore`, {
       body: formData,
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     });
-    return this.parseSSEStream(response, options?.onProgress);
+    return this.parseSSEStream(response, onProgress);
   }
-  // ============================================================================
-  // ADMIN — EXCHANGE (Linked Data Export/Import)
-  // ============================================================================
-  /**
-   * Export the knowledge base as a JSON-LD Linked Data archive. Returns raw Response for streaming download.
-   * Caller should use response.blob() to trigger a file download.
-   */
-  async exportKnowledgeBase(params, options) {
+  async exportKnowledgeBase(params) {
     const searchParams = params?.includeArchived ? new URLSearchParams({ includeArchived: "true" }) : void 0;
     return this.http.post(`${this.baseUrl}/api/moderate/exchange/export`, {
-      headers: this.authHeaders(options),
+      headers: this.authHeaders(),
       ...searchParams ? { searchParams } : {}
     });
   }
-  /**
-   * Import a JSON-LD Linked Data archive into the knowledge base. Parses SSE progress events and calls onProgress.
-   * Returns the final SSE event (phase: 'complete' or 'error').
-   */
-  async importKnowledgeBase(file, options) {
+  async importKnowledgeBase(file, onProgress) {
     const formData = new FormData();
     formData.append("file", file);
     const response = await this.http.post(`${this.baseUrl}/api/moderate/exchange/import`, {
       body: formData,
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     });
-    return this.parseSSEStream(response, options?.onProgress);
+    return this.parseSSEStream(response, onProgress);
   }
   async parseSSEStream(response, onProgress) {
     const reader = response.body.getReader();
@@ -1633,737 +622,153 @@ var SemiontApiClient = class {
         if (line.startsWith("data: ")) {
           const event = JSON.parse(line.slice(6));
           onProgress?.(event);
-          finalResult = event;
+          if (event.phase === "complete" || event.phase === "error" || event.phase === "failed") {
+            finalResult = event;
+          }
         }
       }
     }
     return finalResult;
   }
-  // ============================================================================
-  // JOB STATUS
-  // ============================================================================
-  async getJobStatus(id, options) {
-    return this.http.get(`${this.baseUrl}/api/jobs/${id}`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  /**
-   * Poll a job until it completes or fails
-   * @param id - The job ID to poll
-   * @param options - Polling options
-   * @returns The final job status
-   */
-  async pollJobUntilComplete(id, options) {
-    const interval = options?.interval ?? 1e3;
-    const timeout = options?.timeout ?? 6e4;
-    const startTime = Date.now();
-    while (true) {
-      const status = await this.getJobStatus(id, { auth: options?.auth });
-      if (options?.onProgress) {
-        options.onProgress(status);
-      }
-      if (status.status === "complete" || status.status === "failed" || status.status === "cancelled") {
-        return status;
-      }
-      if (Date.now() - startTime > timeout) {
-        throw new Error(`Job polling timeout after ${timeout}ms`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-  }
-  // ============================================================================
-  // SYSTEM STATUS
-  // ============================================================================
-  async healthCheck(options) {
+  // ── System status ─────────────────────────────────────────────────────
+  async healthCheck() {
     return this.http.get(`${this.baseUrl}/api/health`, {
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     }).json();
   }
-  async getStatus(options) {
+  async getStatus() {
     return this.http.get(`${this.baseUrl}/api/status`, {
-      headers: this.authHeaders(options)
+      headers: this.authHeaders()
     }).json();
   }
-  async browseFiles(dirPath, sort, options) {
-    const searchParams = new URLSearchParams();
-    if (dirPath) searchParams.append("path", dirPath);
-    if (sort) searchParams.append("sort", sort);
-    return this.http.get(`${this.baseUrl}/api/browse/files`, {
-      searchParams,
-      headers: this.authHeaders(options)
-    }).json();
+  // ── Internal: ky accessor for legacy passthroughs (temporary) ─────────
+  /**
+   * Temporary escape hatch for the ongoing transport migration: namespaces
+   * that still need to issue ad-hoc HTTP calls (e.g. legacy browse/mark
+   * HTTP fallbacks) can borrow the configured `ky` instance here. Will be
+   * deleted once all namespaces route through bus channels or through
+   * typed methods on this transport.
+   */
+  get rawHttp() {
+    return this.http;
+  }
+  /**
+   * Current access token (synchronously read from the BehaviorSubject).
+   * Used by content-transport and legacy namespace HTTP fallbacks that
+   * need to pass `auth: token` through some code paths.
+   */
+  getToken() {
+    return this.token$.getValue() ?? void 0;
   }
 };
-function getBodySource(body) {
-  if (Array.isArray(body)) {
-    for (const item of body) {
-      if (typeof item === "object" && item !== null && "type" in item && "source" in item) {
-        const itemType = item.type;
-        const itemSource = item.source;
-        if (itemType === "SpecificResource" && typeof itemSource === "string") {
-          return itemSource;
+var HttpContentTransport = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async putBinary(request, options) {
+    const sizeBytes = request.file instanceof File ? request.file.size : request.file.length;
+    busLog("PUT", "content", {
+      name: request.name,
+      format: request.format,
+      storageUri: request.storageUri,
+      sizeBytes
+    });
+    return withSpan(
+      "content.put",
+      async () => {
+        const formData = new FormData();
+        formData.append("name", request.name);
+        formData.append("format", request.format);
+        formData.append("storageUri", request.storageUri);
+        if (request.file instanceof File) {
+          formData.append("file", request.file);
+        } else if (Buffer.isBuffer(request.file)) {
+          const blob = new Blob([new Uint8Array(request.file)], { type: request.format });
+          formData.append("file", blob, request.name);
+        } else {
+          throw new Error("file must be a File or Buffer");
+        }
+        if (request.entityTypes && request.entityTypes.length > 0) {
+          formData.append("entityTypes", JSON.stringify(request.entityTypes));
+        }
+        if (request.language) formData.append("language", request.language);
+        if (request.creationMethod) formData.append("creationMethod", String(request.creationMethod));
+        if (request.sourceAnnotationId) formData.append("sourceAnnotationId", String(request.sourceAnnotationId));
+        if (request.sourceResourceId) formData.append("sourceResourceId", String(request.sourceResourceId));
+        if (request.generationPrompt) formData.append("generationPrompt", request.generationPrompt);
+        if (request.generator) formData.append("generator", JSON.stringify(request.generator));
+        if (request.isDraft !== void 0) formData.append("isDraft", String(request.isDraft));
+        const result = await this.transport.rawHttp.post(`${this.transport.baseUrl}/resources`, {
+          body: formData,
+          headers: this.requestHeaders(options?.auth)
+        }).json();
+        return { resourceId: result.resourceId };
+      },
+      {
+        kind: SpanKind.CLIENT,
+        attrs: {
+          "content.format": request.format,
+          "content.size_bytes": sizeBytes
         }
       }
-    }
-    return null;
-  }
-  if (typeof body === "object" && body !== null && "type" in body && "source" in body) {
-    const bodyType = body.type;
-    const bodySource = body.source;
-    if (bodyType === "SpecificResource" && typeof bodySource === "string") {
-      return bodySource;
-    }
-  }
-  return null;
-}
-function getBodyType(body) {
-  if (Array.isArray(body)) {
-    if (body.length === 0) {
-      return null;
-    }
-    if (typeof body[0] === "object" && body[0] !== null && "type" in body[0]) {
-      const firstType = body[0].type;
-      if (firstType === "TextualBody" || firstType === "SpecificResource") {
-        return firstType;
-      }
-    }
-    return null;
-  }
-  if (typeof body === "object" && body !== null && "type" in body) {
-    const bodyType = body.type;
-    if (bodyType === "TextualBody" || bodyType === "SpecificResource") {
-      return bodyType;
-    }
-  }
-  return null;
-}
-function isBodyResolved(body) {
-  return getBodySource(body) !== null;
-}
-function getTargetSource(target) {
-  if (typeof target === "string") {
-    return target;
-  }
-  return target.source;
-}
-function getTargetSelector(target) {
-  if (typeof target === "string") {
-    return void 0;
-  }
-  return target.selector;
-}
-function hasTargetSelector(target) {
-  return typeof target !== "string" && target.selector !== void 0;
-}
-function isHighlight(annotation) {
-  return annotation.motivation === "highlighting";
-}
-function isReference(annotation) {
-  return annotation.motivation === "linking";
-}
-function isAssessment(annotation) {
-  return annotation.motivation === "assessing";
-}
-function isComment(annotation) {
-  return annotation.motivation === "commenting";
-}
-function isTag(annotation) {
-  return annotation.motivation === "tagging";
-}
-function getCommentText(annotation) {
-  if (!isComment(annotation)) return void 0;
-  const body = Array.isArray(annotation.body) ? annotation.body[0] : annotation.body;
-  if (body && "value" in body) {
-    return body.value;
-  }
-  return void 0;
-}
-function isStubReference(annotation) {
-  return isReference(annotation) && !isBodyResolved(annotation.body);
-}
-function isResolvedReference(annotation) {
-  return isReference(annotation) && isBodyResolved(annotation.body);
-}
-function getExactText(selector) {
-  if (!selector) {
-    return "";
-  }
-  const selectors = Array.isArray(selector) ? selector : [selector];
-  const quoteSelector = selectors.find((s) => s.type === "TextQuoteSelector");
-  if (quoteSelector) {
-    return quoteSelector.exact;
-  }
-  return "";
-}
-function getAnnotationExactText(annotation) {
-  const selector = getTargetSelector(annotation.target);
-  return getExactText(selector);
-}
-function getPrimarySelector(selector) {
-  if (Array.isArray(selector)) {
-    if (selector.length === 0) {
-      throw new Error("Empty selector array");
-    }
-    const first = selector[0];
-    if (!first) {
-      throw new Error("Invalid selector array");
-    }
-    return first;
-  }
-  return selector;
-}
-function getTextQuoteSelector(selector) {
-  const selectors = Array.isArray(selector) ? selector : [selector];
-  const found = selectors.find((s) => s.type === "TextQuoteSelector");
-  if (!found) return null;
-  return found.type === "TextQuoteSelector" ? found : null;
-}
-function extractBoundingBox(svg) {
-  const viewBoxMatch = svg.match(/<svg[^>]*viewBox="([^"]+)"/);
-  if (viewBoxMatch) {
-    const values = viewBoxMatch[1].split(/\s+/).map(parseFloat);
-    if (values.length === 4 && values.every((v) => !isNaN(v))) {
-      return {
-        x: values[0],
-        y: values[1],
-        width: values[2],
-        height: values[3]
-      };
-    }
-  }
-  const svgTagMatch = svg.match(/<svg[^>]*>/);
-  if (svgTagMatch) {
-    const svgTag = svgTagMatch[0];
-    const widthMatch = svgTag.match(/width="([^"]+)"/);
-    const heightMatch = svgTag.match(/height="([^"]+)"/);
-    if (widthMatch && heightMatch) {
-      const width = parseFloat(widthMatch[1]);
-      const height = parseFloat(heightMatch[1]);
-      if (!isNaN(width) && !isNaN(height)) {
-        return { x: 0, y: 0, width, height };
-      }
-    }
-  }
-  return null;
-}
-
-// src/utils/fuzzy-anchor.ts
-function normalizeText(text) {
-  return text.replace(/\s+/g, " ").replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"').replace(/\u2014/g, "--").replace(/\u2013/g, "-").trim();
-}
-function levenshteinDistance(str1, str2) {
-  const len1 = str1.length;
-  const len2 = str2.length;
-  const matrix = [];
-  for (let i = 0; i <= len1; i++) {
-    matrix[i] = [i];
-  }
-  for (let j = 0; j <= len2; j++) {
-    matrix[0][j] = j;
-  }
-  for (let i = 1; i <= len1; i++) {
-    for (let j = 1; j <= len2; j++) {
-      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
-      const deletion = matrix[i - 1][j] + 1;
-      const insertion = matrix[i][j - 1] + 1;
-      const substitution = matrix[i - 1][j - 1] + cost;
-      matrix[i][j] = Math.min(deletion, insertion, substitution);
-    }
-  }
-  return matrix[len1][len2];
-}
-function buildContentCache(content) {
-  return {
-    normalizedContent: normalizeText(content),
-    lowerContent: content.toLowerCase()
-  };
-}
-function findBestTextMatch(content, searchText, positionHint, cache) {
-  const maxFuzzyDistance = Math.max(5, Math.floor(searchText.length * 0.05));
-  const exactIndex = content.indexOf(searchText);
-  if (exactIndex !== -1) {
-    return {
-      start: exactIndex,
-      end: exactIndex + searchText.length,
-      matchQuality: "exact"
-    };
-  }
-  const normalizedSearch = normalizeText(searchText);
-  const normalizedIndex = cache.normalizedContent.indexOf(normalizedSearch);
-  if (normalizedIndex !== -1) {
-    let actualPos = 0;
-    let normalizedPos = 0;
-    while (normalizedPos < normalizedIndex && actualPos < content.length) {
-      const char = content[actualPos];
-      const normalizedChar = normalizeText(char);
-      if (normalizedChar) {
-        normalizedPos += normalizedChar.length;
-      }
-      actualPos++;
-    }
-    return {
-      start: actualPos,
-      end: actualPos + searchText.length,
-      matchQuality: "normalized"
-    };
-  }
-  const lowerSearch = searchText.toLowerCase();
-  const caseInsensitiveIndex = cache.lowerContent.indexOf(lowerSearch);
-  if (caseInsensitiveIndex !== -1) {
-    return {
-      start: caseInsensitiveIndex,
-      end: caseInsensitiveIndex + searchText.length,
-      matchQuality: "case-insensitive"
-    };
-  }
-  const windowSize = searchText.length;
-  const searchRadius = Math.min(500, content.length);
-  const searchStart = positionHint !== void 0 ? Math.max(0, positionHint - searchRadius) : 0;
-  const searchEnd = positionHint !== void 0 ? Math.min(content.length, positionHint + searchRadius) : content.length;
-  let bestMatch = null;
-  for (let i = searchStart; i <= searchEnd - windowSize; i++) {
-    const candidate = content.substring(i, i + windowSize);
-    const distance = levenshteinDistance(searchText, candidate);
-    if (distance <= maxFuzzyDistance) {
-      if (!bestMatch || distance < bestMatch.distance) {
-        bestMatch = { start: i, distance };
-      }
-    }
-  }
-  if (bestMatch) {
-    return {
-      start: bestMatch.start,
-      end: bestMatch.start + windowSize,
-      matchQuality: "fuzzy"
-    };
-  }
-  return null;
-}
-function findTextWithContext(content, exact, prefix, suffix, positionHint, cache) {
-  if (!exact) return null;
-  if (positionHint !== void 0 && positionHint >= 0 && positionHint + exact.length <= content.length) {
-    if (content.substring(positionHint, positionHint + exact.length) === exact) {
-      return { start: positionHint, end: positionHint + exact.length };
-    }
-  }
-  const occurrences = [];
-  let index = content.indexOf(exact);
-  while (index !== -1) {
-    occurrences.push(index);
-    index = content.indexOf(exact, index + 1);
-  }
-  if (occurrences.length === 0) {
-    const fuzzyMatch = findBestTextMatch(content, exact, positionHint, cache);
-    if (fuzzyMatch) {
-      return { start: fuzzyMatch.start, end: fuzzyMatch.end };
-    }
-    return null;
-  }
-  if (occurrences.length === 1) {
-    const pos2 = occurrences[0];
-    return { start: pos2, end: pos2 + exact.length };
-  }
-  if (prefix || suffix) {
-    for (const pos2 of occurrences) {
-      const actualPrefixStart = Math.max(0, pos2 - (prefix?.length || 0));
-      const actualPrefix = content.substring(actualPrefixStart, pos2);
-      const actualSuffixEnd = Math.min(content.length, pos2 + exact.length + (suffix?.length || 0));
-      const actualSuffix = content.substring(pos2 + exact.length, actualSuffixEnd);
-      const prefixMatch = !prefix || actualPrefix.endsWith(prefix);
-      const suffixMatch = !suffix || actualSuffix.startsWith(suffix);
-      if (prefixMatch && suffixMatch) {
-        return { start: pos2, end: pos2 + exact.length };
-      }
-    }
-    for (const pos2 of occurrences) {
-      const actualPrefix = content.substring(Math.max(0, pos2 - (prefix?.length || 0)), pos2);
-      const actualSuffix = content.substring(pos2 + exact.length, pos2 + exact.length + (suffix?.length || 0));
-      const fuzzyPrefixMatch = !prefix || actualPrefix.includes(prefix.trim());
-      const fuzzySuffixMatch = !suffix || actualSuffix.includes(suffix.trim());
-      if (fuzzyPrefixMatch && fuzzySuffixMatch) {
-        return { start: pos2, end: pos2 + exact.length };
-      }
-    }
-  }
-  const pos = occurrences[0];
-  return { start: pos, end: pos + exact.length };
-}
-function verifyPosition(content, position, expectedExact) {
-  const actualText = content.substring(position.start, position.end);
-  return actualText === expectedExact;
-}
-
-// src/utils/locales.ts
-var LOCALES = [
-  { code: "ar", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", englishName: "Arabic" },
-  { code: "bn", nativeName: "\u09AC\u09BE\u0982\u09B2\u09BE", englishName: "Bengali" },
-  { code: "cs", nativeName: "\u010Ce\u0161tina", englishName: "Czech" },
-  { code: "da", nativeName: "Dansk", englishName: "Danish" },
-  { code: "de", nativeName: "Deutsch", englishName: "German" },
-  { code: "el", nativeName: "\u0395\u03BB\u03BB\u03B7\u03BD\u03B9\u03BA\u03AC", englishName: "Greek" },
-  { code: "en", nativeName: "English", englishName: "English" },
-  { code: "es", nativeName: "Espa\xF1ol", englishName: "Spanish" },
-  { code: "fa", nativeName: "\u0641\u0627\u0631\u0633\u06CC", englishName: "Persian" },
-  { code: "fi", nativeName: "Suomi", englishName: "Finnish" },
-  { code: "fr", nativeName: "Fran\xE7ais", englishName: "French" },
-  { code: "he", nativeName: "\u05E2\u05D1\u05E8\u05D9\u05EA", englishName: "Hebrew" },
-  { code: "hi", nativeName: "\u0939\u093F\u0928\u094D\u0926\u0940", englishName: "Hindi" },
-  { code: "id", nativeName: "Bahasa Indonesia", englishName: "Indonesian" },
-  { code: "it", nativeName: "Italiano", englishName: "Italian" },
-  { code: "ja", nativeName: "\u65E5\u672C\u8A9E", englishName: "Japanese" },
-  { code: "ko", nativeName: "\uD55C\uAD6D\uC5B4", englishName: "Korean" },
-  { code: "ms", nativeName: "Bahasa Melayu", englishName: "Malay" },
-  { code: "nl", nativeName: "Nederlands", englishName: "Dutch" },
-  { code: "no", nativeName: "Norsk", englishName: "Norwegian" },
-  { code: "pl", nativeName: "Polski", englishName: "Polish" },
-  { code: "pt", nativeName: "Portugu\xEAs", englishName: "Portuguese" },
-  { code: "ro", nativeName: "Rom\xE2n\u0103", englishName: "Romanian" },
-  { code: "sv", nativeName: "Svenska", englishName: "Swedish" },
-  { code: "th", nativeName: "\u0E44\u0E17\u0E22", englishName: "Thai" },
-  { code: "tr", nativeName: "T\xFCrk\xE7e", englishName: "Turkish" },
-  { code: "uk", nativeName: "\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430", englishName: "Ukrainian" },
-  { code: "vi", nativeName: "Ti\u1EBFng Vi\u1EC7t", englishName: "Vietnamese" },
-  { code: "zh", nativeName: "\u4E2D\u6587", englishName: "Chinese" }
-];
-var localeByCode = new Map(
-  LOCALES.map((locale) => [locale.code.toLowerCase(), locale])
-);
-function getLocaleInfo(code) {
-  if (!code) return void 0;
-  return localeByCode.get(code.toLowerCase());
-}
-function getLocaleNativeName(code) {
-  return getLocaleInfo(code)?.nativeName;
-}
-function getLocaleEnglishName(code) {
-  return getLocaleInfo(code)?.englishName;
-}
-function formatLocaleDisplay(code) {
-  if (!code) return void 0;
-  const info = getLocaleInfo(code);
-  if (!info) return code;
-  return `${info.nativeName} (${code.toLowerCase()})`;
-}
-function getAllLocaleCodes() {
-  return LOCALES.map((l) => l.code);
-}
-
-// src/utils/resources.ts
-function getResourceId(resource) {
-  if (!resource) return void 0;
-  return resource["@id"] || void 0;
-}
-function getPrimaryRepresentation(resource) {
-  if (!resource?.representations) return void 0;
-  const reps = Array.isArray(resource.representations) ? resource.representations : [resource.representations];
-  return reps[0];
-}
-function getPrimaryMediaType(resource) {
-  return getPrimaryRepresentation(resource)?.mediaType;
-}
-function getChecksum(resource) {
-  return getPrimaryRepresentation(resource)?.checksum;
-}
-function getLanguage(resource) {
-  return getPrimaryRepresentation(resource)?.language;
-}
-function getStorageUri(resource) {
-  return getPrimaryRepresentation(resource)?.storageUri;
-}
-function getCreator(resource) {
-  if (!resource?.wasAttributedTo) return void 0;
-  return Array.isArray(resource.wasAttributedTo) ? resource.wasAttributedTo[0] : resource.wasAttributedTo;
-}
-function getDerivedFrom(resource) {
-  if (!resource?.wasDerivedFrom) return void 0;
-  return Array.isArray(resource.wasDerivedFrom) ? resource.wasDerivedFrom[0] : resource.wasDerivedFrom;
-}
-function isArchived(resource) {
-  return resource?.archived === true;
-}
-function getResourceEntityTypes(resource) {
-  return resource?.entityTypes || [];
-}
-function isDraft(resource) {
-  return resource?.isDraft === true;
-}
-function getNodeEncoding(charset) {
-  const normalized = charset.toLowerCase().replace(/[-_]/g, "");
-  const charsetMap = {
-    "utf8": "utf8",
-    "iso88591": "latin1",
-    "latin1": "latin1",
-    "ascii": "ascii",
-    "usascii": "ascii",
-    "utf16le": "utf16le",
-    "ucs2": "ucs2",
-    "binary": "binary",
-    "windows1252": "latin1",
-    // Windows-1252 is a superset of Latin-1
-    "cp1252": "latin1"
-  };
-  return charsetMap[normalized] || "utf8";
-}
-function decodeRepresentation(buffer, mediaType) {
-  const charsetMatch = mediaType.match(/charset=([^\s;]+)/i);
-  const charset = (charsetMatch?.[1] || "utf-8").toLowerCase();
-  const encoding = getNodeEncoding(charset);
-  return buffer.toString(encoding);
-}
-
-// src/utils/svg-utils.ts
-function createRectangleSvg(start, end) {
-  const x = Math.min(start.x, end.x);
-  const y = Math.min(start.y, end.y);
-  const width = Math.abs(end.x - start.x);
-  const height = Math.abs(end.y - start.y);
-  return `<svg xmlns="http://www.w3.org/2000/svg"><rect x="${x}" y="${y}" width="${width}" height="${height}"/></svg>`;
-}
-function createPolygonSvg(points) {
-  if (points.length < 3) {
-    throw new Error("Polygon requires at least 3 points");
-  }
-  const pointsStr = points.map((p) => `${p.x},${p.y}`).join(" ");
-  return `<svg xmlns="http://www.w3.org/2000/svg"><polygon points="${pointsStr}"/></svg>`;
-}
-function createCircleSvg(center, radius) {
-  if (radius <= 0) {
-    throw new Error("Circle radius must be positive");
-  }
-  return `<svg xmlns="http://www.w3.org/2000/svg"><circle cx="${center.x}" cy="${center.y}" r="${radius}"/></svg>`;
-}
-function parseSvgSelector(svg) {
-  const rectMatch = svg.match(/<rect\s+([^>]+)\/>/);
-  if (rectMatch && rectMatch[1]) {
-    const attrs = rectMatch[1];
-    const x = parseFloat(attrs.match(/x="([^"]+)"/)?.[1] || "0");
-    const y = parseFloat(attrs.match(/y="([^"]+)"/)?.[1] || "0");
-    const width = parseFloat(attrs.match(/width="([^"]+)"/)?.[1] || "0");
-    const height = parseFloat(attrs.match(/height="([^"]+)"/)?.[1] || "0");
-    return {
-      type: "rect",
-      data: { x, y, width, height }
-    };
-  }
-  const polygonMatch = svg.match(/<polygon\s+points="([^"]+)"/);
-  if (polygonMatch && polygonMatch[1]) {
-    const pointsStr = polygonMatch[1];
-    const points = pointsStr.split(/\s+/).map((pair) => {
-      const [x, y] = pair.split(",").map(parseFloat);
-      return { x, y };
-    });
-    return {
-      type: "polygon",
-      data: { points }
-    };
-  }
-  const circleMatch = svg.match(/<circle\s+([^>]+)\/>/);
-  if (circleMatch && circleMatch[1]) {
-    const attrs = circleMatch[1];
-    const cx = parseFloat(attrs.match(/cx="([^"]+)"/)?.[1] || "0");
-    const cy = parseFloat(attrs.match(/cy="([^"]+)"/)?.[1] || "0");
-    const r = parseFloat(attrs.match(/r="([^"]+)"/)?.[1] || "0");
-    return {
-      type: "circle",
-      data: { cx, cy, r }
-    };
-  }
-  return null;
-}
-function normalizeCoordinates(point, displayWidth, displayHeight, imageWidth, imageHeight) {
-  return {
-    x: point.x / displayWidth * imageWidth,
-    y: point.y / displayHeight * imageHeight
-  };
-}
-function scaleSvgToNative(svg, displayWidth, displayHeight, imageWidth, imageHeight) {
-  const parsed = parseSvgSelector(svg);
-  if (!parsed) return svg;
-  const scaleX = imageWidth / displayWidth;
-  const scaleY = imageHeight / displayHeight;
-  switch (parsed.type) {
-    case "rect": {
-      const { x, y, width, height } = parsed.data;
-      return createRectangleSvg(
-        { x: x * scaleX, y: y * scaleY },
-        { x: (x + width) * scaleX, y: (y + height) * scaleY }
-      );
-    }
-    case "circle": {
-      const { cx, cy, r } = parsed.data;
-      return createCircleSvg(
-        { x: cx * scaleX, y: cy * scaleY },
-        r * Math.min(scaleX, scaleY)
-      );
-    }
-    case "polygon": {
-      const points = parsed.data.points.map((p) => ({
-        x: p.x * scaleX,
-        y: p.y * scaleY
-      }));
-      return createPolygonSvg(points);
-    }
+    );
   }
-  return svg;
-}
-
-// src/utils/text-context.ts
-function extractContext(content, start, end) {
-  const CONTEXT_LENGTH = 64;
-  const MAX_EXTENSION = 32;
-  let prefix;
-  if (start > 0) {
-    let prefixStart = Math.max(0, start - CONTEXT_LENGTH);
-    let extensionCount = 0;
-    while (prefixStart > 0 && extensionCount < MAX_EXTENSION) {
-      const char = content[prefixStart - 1];
-      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) {
-        break;
-      }
-      prefixStart--;
-      extensionCount++;
-    }
-    prefix = content.substring(prefixStart, start);
+  async getBinary(resourceId, options) {
+    busLog("GET", "content", { resourceId, accept: options?.accept });
+    return withSpan(
+      "content.get",
+      async () => {
+        const response = await this.transport.rawHttp.get(`${this.transport.baseUrl}/resources/${resourceId}`, {
+          headers: {
+            Accept: options?.accept ?? "text/plain",
+            ...this.requestHeaders(options?.auth)
+          }
+        });
+        const contentType = response.headers.get("content-type") || "application/octet-stream";
+        const data = await response.arrayBuffer();
+        return { data, contentType };
+      },
+      { kind: SpanKind.CLIENT, attrs: { "resource.id": resourceId } }
+    );
   }
-  let suffix;
-  if (end < content.length) {
-    let suffixEnd = Math.min(content.length, end + CONTEXT_LENGTH);
-    let extensionCount = 0;
-    while (suffixEnd < content.length && extensionCount < MAX_EXTENSION) {
-      const char = content[suffixEnd];
-      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) {
-        break;
+  async getBinaryStream(resourceId, options) {
+    busLog("GET", "content", { resourceId, accept: options?.accept, stream: true });
+    return withSpan(
+      "content.get",
+      async () => {
+        const response = await this.transport.rawHttp.get(`${this.transport.baseUrl}/resources/${resourceId}`, {
+          headers: {
+            Accept: options?.accept ?? "text/plain",
+            ...this.requestHeaders(options?.auth)
+          }
+        });
+        const contentType = response.headers.get("content-type") || "application/octet-stream";
+        if (!response.body) {
+          throw new Error("Response body is null - cannot create stream");
+        }
+        return { stream: response.body, contentType };
+      },
+      {
+        kind: SpanKind.CLIENT,
+        attrs: { "resource.id": resourceId, "content.stream": true }
       }
-      suffixEnd++;
-      extensionCount++;
-    }
-    suffix = content.substring(end, suffixEnd);
-  }
-  return { prefix, suffix };
-}
-function validateAndCorrectOffsets(content, aiStart, aiEnd, exact) {
-  const textAtOffset = content.substring(aiStart, aiEnd);
-  if (textAtOffset === exact) {
-    const context2 = extractContext(content, aiStart, aiEnd);
-    return {
-      start: aiStart,
-      end: aiEnd,
-      exact,
-      prefix: context2.prefix,
-      suffix: context2.suffix,
-      corrected: false,
-      matchQuality: "exact"
-    };
-  }
-  const cache = buildContentCache(content);
-  const match = findBestTextMatch(content, exact, aiStart, cache);
-  if (!match) {
-    throw new Error(
-      "Cannot find acceptable match for text in content. All search strategies failed. Text may be hallucinated."
     );
   }
-  const actualText = content.substring(match.start, match.end);
-  const context = extractContext(content, match.start, match.end);
-  return {
-    start: match.start,
-    end: match.end,
-    exact: actualText,
-    // Use actual text from document, not AI's version
-    prefix: context.prefix,
-    suffix: context.suffix,
-    corrected: true,
-    fuzzyMatched: match.matchQuality !== "exact",
-    matchQuality: match.matchQuality
-  };
-}
-
-// src/utils/text-encoding.ts
-function extractCharset(mediaType) {
-  const charsetMatch = mediaType.match(/charset=([^\s;]+)/i);
-  return (charsetMatch?.[1] || "utf-8").toLowerCase();
-}
-function decodeWithCharset(buffer, mediaType) {
-  const charset = extractCharset(mediaType);
-  const decoder = new TextDecoder(charset);
-  return decoder.decode(buffer);
-}
-
-// src/utils/validation.ts
-var JWTTokenSchema = {
-  parse(token) {
-    if (typeof token !== "string") {
-      throw new Error("Token must be a string");
-    }
-    if (!token || token.length === 0) {
-      throw new Error("Token is required");
-    }
-    const jwtRegex = /^[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]+\.[A-Za-z0-9\-_]*$/;
-    if (!jwtRegex.test(token)) {
-      throw new Error("Invalid JWT token format");
-    }
-    return token;
-  },
-  safeParse(token) {
-    try {
-      const validated = this.parse(token);
-      return { success: true, data: validated };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Invalid JWT token"
-      };
+  dispose() {
+  }
+  /** Auth header + W3C trace propagation for the active span. */
+  requestHeaders(override) {
+    const token = override ?? this.transport.getToken();
+    const headers = token ? { Authorization: `Bearer ${token}` } : {};
+    const trace = getActiveTraceparent();
+    if (trace) {
+      headers["traceparent"] = trace.traceparent;
+      if (trace.tracestate) headers["tracestate"] = trace.tracestate;
     }
+    return headers;
   }
 };
-function validateData(schema, data) {
-  try {
-    const validated = schema.parse(data);
-    return { success: true, data: validated };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Validation failed"
-    };
-  }
-}
-function isValidEmail(email) {
-  if (email.length < 1 || email.length > 255) {
-    return false;
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-}
-
-// src/mime-utils.ts
-function getExtensionForMimeType(mimeType) {
-  const map3 = {
-    "text/plain": "txt",
-    "text/markdown": "md",
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "application/pdf": "pdf"
-  };
-  return map3[mimeType] || "dat";
-}
-function isImageMimeType(mimeType) {
-  return mimeType === "image/png" || mimeType === "image/jpeg";
-}
-function isTextMimeType(mimeType) {
-  return mimeType === "text/plain" || mimeType === "text/markdown";
-}
-function isPdfMimeType(mimeType) {
-  return mimeType === "application/pdf";
-}
-function getMimeCategory(mimeType) {
-  if (isTextMimeType(mimeType)) {
-    return "text";
-  }
-  if (isImageMimeType(mimeType) || isPdfMimeType(mimeType)) {
-    return "image";
-  }
-  return "unsupported";
-}
 
-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 };
+export { APIError, DEGRADED_THRESHOLD_MS, HttpContentTransport, HttpTransport, createActorVM };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map