@semiont/api-client 0.4.21 → 0.4.22

package/dist/index.js

@@ -1,18 +1,10 @@
 import ky, { HTTPError } from 'ky';
-import { RESOURCE_BROADCAST_TYPES, PERSISTED_EVENT_TYPES, annotationId, resourceId, email, googleCredential, refreshToken, EventBus, accessToken, baseUrl, userDID, searchQuery } from '@semiont/core';
-export { getFragmentSelector, getSvgSelector, getTextPositionSelector, validateSvgMarkup } from '@semiont/core';
-import { Subject, BehaviorSubject, merge, firstValueFrom, map as map$1, distinctUntilChanged, Observable, Subscription, of, filter as filter$1, take as take$1, timeout as timeout$1 } from 'rxjs';
-import { share, filter, map, take, timeout, takeUntil, startWith, debounceTime, distinctUntilChanged as distinctUntilChanged$1, switchMap } from 'rxjs/operators';
+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
-function busLog(direction, channel, payload, scope) {
-  if (typeof globalThis === "undefined") return;
-  const g = globalThis;
-  if (!g.__SEMIONT_BUS_LOG__) return;
-  const cid = payload?.correlationId;
-  const tag = `[bus ${direction}] ${channel}` + (scope ? ` scope=${scope}` : "") + (cid ? ` cid=${String(cid).slice(0, 8)}` : "");
-  console.debug(tag, payload);
-}
+// src/transport/http-transport.ts
 var DEGRADED_THRESHOLD_MS = 3e3;
 var ALLOWED_TRANSITIONS = {
   initial: ["connecting", "closed"],
@@ -23,12 +15,12 @@ var ALLOWED_TRANSITIONS = {
   closed: []
 };
 function createActorVM(options) {
-  const { baseUrl: baseUrl3, token: tokenOrGetter, channels: initialChannels, scope: initialScope, reconnectMs = 5e3 } = 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=${baseUrl3})`);
+  console.debug(`[diag] ActorVM #${actorSerial} constructed (baseUrl=${baseUrl})`);
   const globalChannels = new Set(initialChannels);
   const scopedChannels = /* @__PURE__ */ new Set();
   let activeScope = initialScope;
@@ -95,7 +87,7 @@ function createActorVM(options) {
         params.append("scoped", ch);
       }
     }
-    const url = `${baseUrl3}/bus/subscribe?${params.toString()}`;
+    const url = `${baseUrl}/bus/subscribe?${params.toString()}`;
     const controller = new AbortController();
     inflightControllers.add(controller);
     try {
@@ -130,7 +122,25 @@ function createActorVM(options) {
               if (currentId !== void 0) lastEventId = currentId;
               const parsed = JSON.parse(currentData);
               busLog("RECV", parsed.channel, parsed.payload, parsed.scope);
-              events$.next(parsed);
+              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 = "";
@@ -175,15 +185,20 @@ function createActorVM(options) {
       );
     },
     emit: async (channel, payload, emitScope) => {
-      busLog("EMIT", channel, payload, emitScope);
       const body = { channel, payload };
       if (emitScope) body.scope = emitScope;
-      await fetch(`${baseUrl3}/bus/emit`, {
+      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;
+      }
+      await fetch(`${baseUrl}/bus/emit`, {
         method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Authorization: `Bearer ${getToken()}`
-        },
+        headers,
         body: JSON.stringify(body)
       });
     },
@@ -255,4316 +270,505 @@ function createActorVM(options) {
     }
   };
 }
-var BusRequestError = class extends Error {
-  constructor(message) {
+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);
-    this.name = "BusRequestError";
+    this.status = status;
+    this.statusText = statusText;
+    this.details = details;
+    this.name = "APIError";
   }
 };
-async function busRequest(actor, emitChannel, payload, resultChannel, failureChannel, timeoutMs = 3e4) {
-  const correlationId = crypto.randomUUID();
-  const fullPayload = { ...payload, correlationId };
-  const result$ = merge(
-    actor.on$(resultChannel).pipe(
-      filter((e) => e.correlationId === correlationId),
-      map((e) => ({ ok: true, response: e.response }))
-    ),
-    actor.on$(failureChannel).pipe(
-      filter((e) => e.correlationId === correlationId),
-      map((e) => ({ ok: false, error: new BusRequestError(e.message) }))
-    )
-  ).pipe(take(1), timeout(timeoutMs));
-  const resultPromise = firstValueFrom(result$);
-  await actor.emit(emitChannel, fullPayload);
-  const result = await resultPromise;
-  if (!result.ok) {
-    throw result.error;
-  }
-  return result.response;
-}
-function createCache(fetchFn) {
-  const store$ = new BehaviorSubject(/* @__PURE__ */ new Map());
-  const inflight = /* @__PURE__ */ new Set();
-  const obsCache = /* @__PURE__ */ new Map();
-  const doFetch = async (key) => {
-    if (inflight.has(key)) return;
-    inflight.add(key);
-    try {
-      const value = await fetchFn(key);
-      const next = new Map(store$.value);
-      next.set(key, value);
-      store$.next(next);
-    } catch {
-    } finally {
-      inflight.delete(key);
-    }
-  };
-  return {
-    observe(key) {
-      if (!store$.value.has(key) && !inflight.has(key)) {
-        void doFetch(key);
-      }
-      let obs = obsCache.get(key);
-      if (!obs) {
-        obs = store$.pipe(
-          map$1((m) => m.get(key)),
-          distinctUntilChanged()
-        );
-        obsCache.set(key, obs);
-      }
-      return obs;
-    },
-    get(key) {
-      return store$.value.get(key);
-    },
-    keys() {
-      return [...store$.value.keys()];
-    },
-    invalidate(key) {
-      inflight.delete(key);
-      void doFetch(key);
-    },
-    remove(key) {
-      const next = new Map(store$.value);
-      next.delete(key);
-      store$.next(next);
-      inflight.delete(key);
-    },
-    set(key, value) {
-      const next = new Map(store$.value);
-      next.set(key, value);
-      store$.next(next);
-    },
-    invalidateAll() {
-      for (const key of store$.value.keys()) {
-        inflight.delete(key);
-        void doFetch(key);
+var HttpTransport = class {
+  baseUrl;
+  http;
+  token$;
+  logger;
+  _actor = null;
+  _actorStarted = false;
+  disposed = false;
+  activeResource = null;
+  /** Buses we've been asked to bridge wire events into. */
+  bridges = [];
+  constructor(config) {
+    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"],
+      statusCodes: [401, 408, 413, 429, 500, 502, 503, 504]
+    } : retry;
+    this.http = ky.create({
+      timeout,
+      retry: retryConfig,
+      credentials: "include",
+      hooks: {
+        beforeRequest: [
+          (request) => {
+            if (this.logger) {
+              this.logger.debug("HTTP Request", {
+                type: "http_request",
+                url: request.url,
+                method: request.method,
+                timestamp: Date.now(),
+                hasAuth: request.headers.has("Authorization")
+              });
+            }
+          }
+        ],
+        beforeRetry: tokenRefresher ? [
+          async ({ request, error }) => {
+            if (!(error instanceof HTTPError) || error.response.status !== 401) {
+              return void 0;
+            }
+            try {
+              const newToken = await tokenRefresher();
+              if (!newToken) return ky.stop;
+              request.headers.set("Authorization", `Bearer ${newToken}`);
+              return void 0;
+            } catch {
+              return ky.stop;
+            }
+          }
+        ] : [],
+        afterResponse: [
+          (request, _options, response) => {
+            if (this.logger) {
+              this.logger.debug("HTTP Response", {
+                type: "http_response",
+                url: request.url,
+                method: request.method,
+                status: response.status,
+                statusText: response.statusText
+              });
+            }
+            return response;
+          }
+        ],
+        beforeError: [
+          async (error) => {
+            const { response, request } = error;
+            if (response) {
+              const body = await response.json().catch(() => ({}));
+              if (this.logger) {
+                this.logger.error("HTTP Request Failed", {
+                  type: "http_error",
+                  url: request.url,
+                  method: request.method,
+                  status: response.status,
+                  statusText: response.statusText,
+                  error: body.message || `HTTP ${response.status}: ${response.statusText}`
+                });
+              }
+              throw new APIError(
+                body.message || `HTTP ${response.status}: ${response.statusText}`,
+                response.status,
+                response.statusText,
+                body
+              );
+            }
+            return error;
+          }
+        ]
       }
-    },
-    dispose() {
-      store$.complete();
-      obsCache.clear();
-      inflight.clear();
-    }
-  };
-}
-
-// src/namespaces/browse.ts
-var ENTITY_TYPES_KEY = "_";
-var BrowseNamespace = class {
-  constructor(http, eventBus, getToken, actor) {
-    this.http = http;
-    this.eventBus = eventBus;
-    this.getToken = getToken;
-    this.actor = actor;
-    const g = globalThis;
-    g.__SEMIONT_BROWSE_INSTANCES__ = (g.__SEMIONT_BROWSE_INSTANCES__ ?? 0) + 1;
-    const browseSerial = g.__SEMIONT_BROWSE_INSTANCES__;
-    this.__serial__ = browseSerial;
-    console.debug(`[diag] BrowseNamespace #${browseSerial} constructed`);
-    this.resourceCache = createCache(async (id) => {
-      const result = await busRequest(
-        this.actor,
-        "browse:resource-requested",
-        { resourceId: id },
-        "browse:resource-result",
-        "browse:resource-failed"
-      );
-      return result.resource;
-    });
-    this.resourceListCache = createCache(async (key) => {
-      const filters = this.resourceListFilters.get(key) ?? {};
-      const search = filters.search ? searchQuery(filters.search) : void 0;
-      const result = await busRequest(
-        this.actor,
-        "browse:resources-requested",
-        { search, archived: filters.archived, limit: filters.limit ?? 100, offset: 0 },
-        "browse:resources-result",
-        "browse:resources-failed"
-      );
-      return result.resources;
-    });
-    this.annotationListCache = createCache(async (resourceId) => {
-      return busRequest(
-        this.actor,
-        "browse:annotations-requested",
-        { resourceId },
-        "browse:annotations-result",
-        "browse:annotations-failed"
-      );
     });
-    this.annotationDetailCache = createCache(async (annotationId) => {
-      const resourceId = this.annotationResources.get(annotationId);
-      if (!resourceId) {
-        throw new Error(`Cannot fetch annotation ${annotationId}: no resourceId known`);
+    this.token$.subscribe((token) => {
+      if (token && !this._actorStarted && !this.disposed) {
+        this._actorStarted = true;
+        this.actor.start();
       }
-      const result = await busRequest(
-        this.actor,
-        "browse:annotation-requested",
-        { resourceId, annotationId },
-        "browse:annotation-result",
-        "browse:annotation-failed"
-      );
-      return result.annotation;
-    });
-    this.entityTypesCache = createCache(async () => {
-      const serial = this.__serial__;
-      console.debug(`[diag] BrowseNamespace#${serial} entityTypes fetchFn START`);
-      const result = await busRequest(
-        this.actor,
-        "browse:entity-types-requested",
-        {},
-        "browse:entity-types-result",
-        "browse:entity-types-failed"
-      );
-      console.debug(`[diag] BrowseNamespace#${serial} entityTypes fetchFn RESOLVE`, JSON.stringify(result.entityTypes).slice(0, 200));
-      return result.entityTypes;
-    });
-    this.referencedByCache = createCache(async (resourceId) => {
-      const result = await busRequest(
-        this.actor,
-        "browse:referenced-by-requested",
-        { resourceId },
-        "browse:referenced-by-result",
-        "browse:referenced-by-failed"
-      );
-      return result.referencedBy;
-    });
-    this.resourceEventsCache = createCache(async (resourceId) => {
-      const result = await busRequest(
-        this.actor,
-        "browse:events-requested",
-        { resourceId },
-        "browse:events-result",
-        "browse:events-failed"
-      );
-      return result.events;
     });
-    this.subscribeToEvents();
   }
-  // ── Caches, backed by the RxJS-native `Cache<K, V>` primitive ───────────
-  //
-  // Each cache encapsulates the BehaviorSubject store, in-flight guard,
-  // and per-key observable memoization that was previously open-coded
-  // here. Behavioral contract: `packages/api-client/docs/CACHE-SEMANTICS.md`.
+  // ── Lazy actor construction + per-channel fan-in to bridges ───────────
   //
-  // Public surface (`resource()`, `annotations()`, etc.) is unchanged;
-  // the caches are an implementation detail of this namespace.
-  resourceCache;
-  resourceListCache;
-  annotationListCache;
-  /**
-   * Annotation-detail cache keyed by `annotationId` only — the resourceId
-   * is a routing hint for the backend fetch, not an identity component.
-   * We track the most recent resourceId per annotationId in a side-map
-   * so `mark:delete-ok` (which carries only `annotationId`) can reach
-   * the right cache entry. Aligns with the pre-refactor semantics.
-   */
-  annotationDetailCache;
-  annotationResources = /* @__PURE__ */ new Map();
-  entityTypesCache;
-  referencedByCache;
-  resourceEventsCache;
-  /** Filter-blob memory so `invalidateResourceLists` can replay per-key. */
-  resourceListFilters = /* @__PURE__ */ new Map();
-  /**
-   * Per-key memo for `annotations()` observables. The cache stores the
-   * full `AnnotationsListResponse`; the public shape is just the inner
-   * `Annotation[]`. Without this memo, every call to `annotations(rId)`
-   * would produce a fresh `.pipe(map(...))` observable, violating B4
-   * (per-key observable stability). Consumers that compare observable
-   * identity — React hooks depending on the observable reference,
-   * `distinctUntilChanged` at a higher level — would misbehave.
-   */
-  annotationListObs = /* @__PURE__ */ new Map();
-  getToken;
-  actor;
-  // ── Live queries ────────────────────────────────────────────────────────
-  resource(resourceId) {
-    return this.resourceCache.observe(resourceId);
-  }
-  resources(filters) {
-    const key = JSON.stringify(filters ?? {});
-    this.resourceListFilters.set(key, filters ?? {});
-    return this.resourceListCache.observe(key);
-  }
-  annotations(resourceId) {
-    let obs = this.annotationListObs.get(resourceId);
-    if (!obs) {
-      obs = this.annotationListCache.observe(resourceId).pipe(map$1((r) => r?.annotations));
-      this.annotationListObs.set(resourceId, obs);
+  // `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 obs;
+    return this._actor;
   }
-  annotation(resourceId, annotationId) {
-    this.annotationResources.set(annotationId, resourceId);
-    return this.annotationDetailCache.observe(annotationId);
+  // ── 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 } : {}
+        }
+      }
+    );
   }
-  entityTypes() {
-    const serial = this.__serial__;
-    console.debug(`[diag] BrowseNamespace#${serial} entityTypes() called`);
-    const self = this;
-    if (!self.__entityTypesDiag__) {
-      self.__entityTypesDiag__ = this.entityTypesCache.observe(ENTITY_TYPES_KEY).pipe(map$1((v) => {
-        console.debug(`[diag] BrowseNamespace#${serial} entityTypes$ EMIT`, v === void 0 ? "undefined" : JSON.stringify(v).slice(0, 200));
-        return v;
-      }));
-    }
-    return self.__entityTypesDiag__;
+  on(channel, handler) {
+    const sub = this.actor.on$(channel).subscribe(handler);
+    return () => sub.unsubscribe();
   }
-  referencedBy(resourceId) {
-    return this.referencedByCache.observe(resourceId);
+  stream(channel) {
+    return this.actor.on$(channel);
   }
-  events(resourceId) {
-    return this.resourceEventsCache.observe(resourceId);
+  /**
+   * 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);
   }
-  // ── 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);
+  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();
   }
-  async resourceRepresentation(resourceId, options) {
-    return this.http.getResourceRepresentation(resourceId, {
-      accept: options?.accept,
-      auth: this.getToken()
-    });
+  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 resourceRepresentationStream(resourceId, options) {
-    return this.http.getResourceRepresentationStream(resourceId, {
-      accept: options?.accept,
-      auth: this.getToken()
-    });
+  get state$() {
+    return this.actor.state$;
   }
-  async resourceEvents(resourceId) {
-    const result = await busRequest(
-      this.actor,
-      "browse:events-requested",
-      { resourceId },
-      "browse:events-result",
-      "browse:events-failed"
-    );
-    return result.events;
+  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 annotationHistory(resourceId, annotationId) {
-    return busRequest(
-      this.actor,
-      "browse:annotation-history-requested",
-      { resourceId, annotationId },
-      "browse:annotation-history-result",
-      "browse:annotation-history-failed"
-    );
+  // ── Auth ──────────────────────────────────────────────────────────────
+  authHeaders() {
+    const token = this.token$.getValue() ?? void 0;
+    return token ? { Authorization: `Bearer ${token}` } : {};
   }
-  async connections(_resourceId) {
-    throw new Error("Not implemented: connections endpoint does not exist yet");
+  async authenticatePassword(email, password) {
+    return this.http.post(`${this.baseUrl}/api/tokens/password`, {
+      json: { email, password },
+      headers: this.authHeaders()
+    }).json();
   }
-  async backlinks(_resourceId) {
-    throw new Error("Not implemented: backlinks endpoint does not exist yet");
+  async authenticateGoogle(credential) {
+    return this.http.post(`${this.baseUrl}/api/tokens/google`, {
+      json: { credential },
+      headers: this.authHeaders()
+    }).json();
   }
-  async resourcesByName(_query, _limit) {
-    throw new Error("Not implemented: resourcesByName endpoint does not exist yet");
+  async refreshAccessToken(token) {
+    return this.http.post(`${this.baseUrl}/api/tokens/refresh`, {
+      json: { refreshToken: token },
+      headers: this.authHeaders()
+    }).json();
   }
-  async files(dirPath, sort) {
-    return busRequest(
-      this.actor,
-      "browse:directory-requested",
-      { path: dirPath ?? ".", sort: sort ?? "name" },
-      "browse:directory-result",
-      "browse:directory-failed"
-    );
+  async logout() {
+    await this.http.post(`${this.baseUrl}/api/users/logout`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  // ── Cache-mutation API (used by the bus-event subscribers below and by
-  //    other namespaces that know about specific updates) ─────────────────
-  //
-  //  - `invalidate*`     — SWR refetch (B7). Keeps prior value visible.
-  //  - `removeAnnotationDetail` — drops the entry (B13a: entity gone).
-  //  - `updateAnnotationInPlace` — write-through (B13b: new value known).
-  invalidateAnnotationList(resourceId) {
-    this.annotationListCache.invalidate(resourceId);
+  async acceptTerms() {
+    await this.http.post(`${this.baseUrl}/api/users/accept-terms`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  removeAnnotationDetail(annotationId) {
-    this.annotationDetailCache.remove(annotationId);
-    this.annotationResources.delete(annotationId);
+  async getCurrentUser() {
+    return this.http.get(`${this.baseUrl}/api/users/me`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  invalidateResourceDetail(id) {
-    this.resourceCache.invalidate(id);
+  async generateMcpToken() {
+    return this.http.post(`${this.baseUrl}/api/tokens/mcp-generate`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  invalidateResourceLists() {
-    this.resourceListCache.invalidateAll();
+  async getMediaToken(resourceId) {
+    return this.http.post(`${this.baseUrl}/api/tokens/media`, {
+      json: { resourceId },
+      headers: this.authHeaders()
+    }).json();
   }
-  invalidateEntityTypes() {
-    this.entityTypesCache.invalidate(ENTITY_TYPES_KEY);
+  // ── Admin ─────────────────────────────────────────────────────────────
+  async listUsers() {
+    return this.http.get(`${this.baseUrl}/api/admin/users`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  invalidateReferencedBy(resourceId) {
-    this.referencedByCache.invalidate(resourceId);
+  async getUserStats() {
+    return this.http.get(`${this.baseUrl}/api/admin/users/stats`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  invalidateResourceEvents(resourceId) {
-    this.resourceEventsCache.invalidate(resourceId);
+  async updateUser(id, data) {
+    return this.http.patch(`${this.baseUrl}/api/admin/users/${id}`, {
+      json: data,
+      headers: this.authHeaders()
+    }).json();
   }
-  updateAnnotationInPlace(resourceId, annotation) {
-    const currentList = this.annotationListCache.get(resourceId);
-    if (currentList) {
-      const idx = currentList.annotations.findIndex((a) => a.id === annotation.id);
-      const nextAnnotations = idx >= 0 ? currentList.annotations.map((a, i) => i === idx ? annotation : a) : [...currentList.annotations, annotation];
-      this.annotationListCache.set(resourceId, { ...currentList, annotations: nextAnnotations });
-    }
-    const aId = annotationId(annotation.id);
-    this.annotationResources.set(aId, resourceId);
-    this.annotationDetailCache.set(aId, annotation);
+  async getOAuthConfig() {
+    return this.http.get(`${this.baseUrl}/api/admin/oauth/config`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  // ── EventBus subscriptions ──────────────────────────────────────────────
-  /**
-   * Typed shorthand for `eventBus.get(channel).subscribe(handler)`.
-   * Preserves per-channel payload typing so handlers read
-   * `EventMap[K]` without any casts.
-   */
-  on(channel, handler) {
-    this.eventBus.get(channel).subscribe(handler);
-  }
-  /**
-   * Handler shared by `mark:entity-tag-added` and `mark:entity-tag-removed`.
-   * Both events carry the same effect: the annotation list, the
-   * resource descriptor, and the event log for that resource all may
-   * now reflect different entity tagging, so invalidate all three.
-   */
-  onEntityTagChanged = (stored) => {
-    if (!stored.resourceId) return;
-    this.invalidateAnnotationList(stored.resourceId);
-    this.invalidateResourceDetail(stored.resourceId);
-    this.invalidateResourceEvents(stored.resourceId);
-  };
-  /**
-   * Handler shared by `mark:archived` and `mark:unarchived`. Both
-   * change a resource's archived flag, which is stored on the resource
-   * descriptor and affects the resource-list filter.
-   */
-  onArchiveToggled = (stored) => {
-    if (!stored.resourceId) return;
-    this.invalidateResourceDetail(stored.resourceId);
-    this.invalidateResourceLists();
-  };
-  /**
-   * Handler shared by `yield:create-ok` and `yield:update-ok`. Both
-   * report a resource mutation with the resourceId as a string (not
-   * yet branded), so we brand and apply the same effect as
-   * `onArchiveToggled`.
-   */
-  onYieldResourceMutated = (event) => {
-    const rId = resourceId(event.resourceId);
-    this.invalidateResourceDetail(rId);
-    this.invalidateResourceLists();
-  };
-  subscribeToEvents() {
-    this.on("bus:resume-gap", (event) => {
-      const gapScope = event.scope;
-      if (gapScope) {
-        const rId = gapScope;
-        this.invalidateAnnotationList(rId);
-        this.invalidateResourceDetail(rId);
-        this.invalidateResourceEvents(rId);
-        this.invalidateReferencedBy(rId);
-      } else {
-        this.invalidateResourceLists();
-        for (const rId of this.annotationListCache.keys()) this.invalidateAnnotationList(rId);
-        for (const rId of this.resourceCache.keys()) this.invalidateResourceDetail(rId);
-        for (const rId of this.resourceEventsCache.keys()) this.invalidateResourceEvents(rId);
-        for (const rId of this.referencedByCache.keys()) this.invalidateReferencedBy(rId);
-      }
-      this.invalidateEntityTypes();
-    });
-    this.on("mark:delete-ok", (event) => {
-      this.removeAnnotationDetail(annotationId(event.annotationId));
-    });
-    this.on("mark:added", (stored) => {
-      if (stored.resourceId) {
-        this.invalidateAnnotationList(stored.resourceId);
-        this.invalidateResourceEvents(stored.resourceId);
-      }
-    });
-    this.on("mark:removed", (stored) => {
-      if (stored.resourceId) {
-        this.invalidateAnnotationList(stored.resourceId);
-        this.invalidateResourceEvents(stored.resourceId);
-      }
-      this.removeAnnotationDetail(annotationId(stored.payload.annotationId));
-    });
-    this.on("mark:body-updated", (event) => {
-      const enriched = event;
-      if (!enriched.resourceId || !enriched.annotation) return;
-      this.updateAnnotationInPlace(enriched.resourceId, enriched.annotation);
-      this.invalidateResourceEvents(enriched.resourceId);
-    });
-    this.on("mark:entity-tag-added", this.onEntityTagChanged);
-    this.on("mark:entity-tag-removed", this.onEntityTagChanged);
-    this.on("replay-window-exceeded", (event) => {
-      if (event.resourceId) {
-        this.invalidateAnnotationList(event.resourceId);
-      }
+  // ── Exchange (backup/restore/export/import) ───────────────────────────
+  async backupKnowledgeBase() {
+    return this.http.post(`${this.baseUrl}/api/admin/exchange/backup`, {
+      headers: this.authHeaders()
     });
-    this.on("yield:create-ok", this.onYieldResourceMutated);
-    this.on("yield:update-ok", this.onYieldResourceMutated);
-    this.on("mark:archived", this.onArchiveToggled);
-    this.on("mark:unarchived", this.onArchiveToggled);
-    this.on("mark:entity-type-added", () => this.invalidateEntityTypes());
-  }
-};
-var MarkNamespace = class {
-  constructor(http, eventBus, getToken, actor) {
-    this.http = http;
-    this.eventBus = eventBus;
-    this.getToken = getToken;
-    this.actor = actor;
-  }
-  async annotation(resourceId, input) {
-    return busRequest(
-      this.actor,
-      "mark:create-request",
-      { resourceId, request: input },
-      "mark:create-ok",
-      "mark:create-failed"
-    );
-  }
-  async delete(resourceId, annotationId) {
-    await this.actor.emit("mark:delete", { annotationId, resourceId });
-  }
-  async entityType(type) {
-    await this.actor.emit("mark:add-entity-type", { tag: type });
-  }
-  async entityTypes(types) {
-    for (const tag of types) {
-      await this.actor.emit("mark:add-entity-type", { tag });
-    }
-  }
-  async updateResource(resourceId, data) {
-    return this.http.updateResource(resourceId, data, { auth: this.getToken() });
-  }
-  async archive(resourceId) {
-    await this.actor.emit("mark:archive", { resourceId });
-  }
-  async unarchive(resourceId) {
-    await this.actor.emit("mark:unarchive", { resourceId });
   }
-  assist(resourceId, motivation, options) {
-    return new Observable((subscriber) => {
-      let done = false;
-      let pollTimer = null;
-      let pollInterval = null;
-      const cleanup = () => {
-        done = true;
-        if (pollTimer) {
-          clearTimeout(pollTimer);
-          pollTimer = null;
-        }
-        if (pollInterval) {
-          clearInterval(pollInterval);
-          pollInterval = null;
-        }
-      };
-      const resetPollTimer = (jobId) => {
-        if (pollTimer) clearTimeout(pollTimer);
-        if (pollInterval) {
-          clearInterval(pollInterval);
-          pollInterval = null;
-        }
-        pollTimer = setTimeout(() => {
-          if (done) return;
-          pollInterval = setInterval(() => {
-            if (done) return;
-            busRequest(
-              this.actor,
-              "job:status-requested",
-              { jobId },
-              "job:status-result",
-              "job:status-failed"
-            ).then((status) => {
-              if (done) return;
-              if (status.status === "complete") {
-                cleanup();
-                subscriber.next({ motivation, resourceId, progress: status.result });
-                subscriber.complete();
-              } else if (status.status === "failed") {
-                cleanup();
-                subscriber.error(new Error(status.error ?? "Job failed"));
-              }
-            }).catch(() => {
-            });
-          }, 5e3);
-        }, 1e4);
-      };
-      let activeJobId = null;
-      const progress$ = this.eventBus.get("job:report-progress").pipe(
-        filter((e) => e.jobId === activeJobId)
-      );
-      const complete$ = this.eventBus.get("job:complete").pipe(
-        filter((e) => e.jobId === activeJobId)
-      );
-      const fail$ = this.eventBus.get("job:fail").pipe(
-        filter((e) => e.jobId === activeJobId)
-      );
-      const progressSub = progress$.pipe(takeUntil(merge(complete$, fail$))).subscribe((e) => {
-        subscriber.next(e.progress);
-        if (activeJobId) resetPollTimer(activeJobId);
-      });
-      const completeSub = complete$.subscribe(() => {
-        cleanup();
-        subscriber.complete();
-      });
-      const failSub = fail$.subscribe((e) => {
-        cleanup();
-        subscriber.error(new Error(e.error));
-      });
-      const auth = this.getToken();
-      this.dispatchAssist(resourceId, motivation, options, auth).then(({ jobId }) => {
-        if (jobId && !done) {
-          activeJobId = jobId;
-          resetPollTimer(jobId);
-        }
-      }).catch((error) => {
-        cleanup();
-        subscriber.error(error);
-      });
-      return () => {
-        cleanup();
-        progressSub.unsubscribe();
-        completeSub.unsubscribe();
-        failSub.unsubscribe();
-      };
+  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()
     });
+    return this.parseSSEStream(response, onProgress);
   }
-  async dispatchAssist(resourceId, motivation, options, _auth) {
-    const jobTypeMap = {
-      tagging: "tag-annotation",
-      linking: "reference-annotation",
-      highlighting: "highlight-annotation",
-      assessing: "assessment-annotation",
-      commenting: "comment-annotation"
-    };
-    const jobType = jobTypeMap[motivation];
-    if (!jobType) throw new Error(`Unsupported motivation: ${motivation}`);
-    if (motivation === "tagging") {
-      if (!options.schemaId || !options.categories?.length) throw new Error("Tag assist requires schemaId and categories");
-    } else if (motivation === "linking") {
-      if (!options.entityTypes?.length) throw new Error("Reference assist requires entityTypes");
-    }
-    const params = {};
-    if (options.entityTypes) params.entityTypes = options.entityTypes;
-    if (options.includeDescriptiveReferences !== void 0) params.includeDescriptiveReferences = options.includeDescriptiveReferences;
-    if (options.instructions !== void 0) params.instructions = options.instructions;
-    if (options.density !== void 0) params.density = options.density;
-    if (options.tone !== void 0) params.tone = options.tone;
-    if (options.language !== void 0) params.language = options.language;
-    if (options.schemaId !== void 0) params.schemaId = options.schemaId;
-    if (options.categories !== void 0) params.categories = options.categories;
-    return busRequest(
-      this.actor,
-      "job:create",
-      { jobType, resourceId, params },
-      "job:created",
-      "job:create-failed"
-    );
-  }
-};
-
-// src/namespaces/bind.ts
-var BindNamespace = class {
-  constructor(actor) {
-    this.actor = actor;
-  }
-  async body(resourceId, annotationId, operations) {
-    await this.actor.emit("bind:update-body", {
-      correlationId: crypto.randomUUID(),
-      annotationId,
-      resourceId,
-      operations
+  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(),
+      ...searchParams ? { searchParams } : {}
     });
   }
-};
-var GatherNamespace = class {
-  constructor(eventBus, actor) {
-    this.eventBus = eventBus;
-    this.actor = actor;
-  }
-  annotation(annotationId, 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(
-          filter((e) => e.annotationId === annotationId),
-          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.actor.emit("gather:requested", {
-        correlationId,
-        annotationId,
-        resourceId,
-        contextWindow: options?.contextWindow ?? 2e3
-      }).catch((error) => {
-        subscriber.error(error);
-      });
-      return () => {
-        sub.unsubscribe();
-        completeSub.unsubscribe();
-        failedSub.unsubscribe();
-      };
+  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()
     });
+    return this.parseSSEStream(response, onProgress);
   }
-  resource(_resourceId, _options) {
-    throw new Error("Not implemented: gather.resource() \u2014 no backend route yet");
+  async parseSSEStream(response, onProgress) {
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finalResult = { phase: "unknown" };
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop();
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          const event = JSON.parse(line.slice(6));
+          onProgress?.(event);
+          if (event.phase === "complete" || event.phase === "error" || event.phase === "failed") {
+            finalResult = event;
+          }
+        }
+      }
+    }
+    return finalResult;
   }
-};
-var MatchNamespace = class {
-  constructor(eventBus, actor) {
-    this.eventBus = eventBus;
-    this.actor = actor;
+  // ── System status ─────────────────────────────────────────────────────
+  async healthCheck() {
+    return this.http.get(`${this.baseUrl}/api/health`, {
+      headers: this.authHeaders()
+    }).json();
   }
-  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.actor.emit("match:search-requested", {
-        correlationId,
-        resourceId,
-        referenceId,
-        context,
-        limit: options?.limit ?? 10,
-        useSemanticScoring: options?.useSemanticScoring ?? true
-      }).catch((error) => {
-        subscriber.error(error);
-      });
-      return () => {
-        resultSub.unsubscribe();
-        failedSub.unsubscribe();
-      };
-    });
+  async getStatus() {
+    return this.http.get(`${this.baseUrl}/api/status`, {
+      headers: this.authHeaders()
+    }).json();
   }
-};
-var YieldNamespace = class {
-  constructor(http, eventBus, getToken, actor) {
-    this.http = http;
-    this.eventBus = eventBus;
-    this.getToken = getToken;
-    this.actor = actor;
+  // ── 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;
   }
-  async resource(data) {
-    return this.http.yieldResource(data, { auth: this.getToken() });
+  /**
+   * 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;
   }
-  fromAnnotation(resourceId, annotationId, options) {
-    return new Observable((subscriber) => {
-      let done = false;
-      let pollTimer = null;
-      let pollInterval = null;
-      const cleanup = () => {
-        done = true;
-        if (pollTimer) {
-          clearTimeout(pollTimer);
-          pollTimer = null;
-        }
-        if (pollInterval) {
-          clearInterval(pollInterval);
-          pollInterval = null;
+};
+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");
         }
-      };
-      const resetPollTimer = (jid) => {
-        if (pollTimer) clearTimeout(pollTimer);
-        if (pollInterval) {
-          clearInterval(pollInterval);
-          pollInterval = null;
+        if (request.entityTypes && request.entityTypes.length > 0) {
+          formData.append("entityTypes", JSON.stringify(request.entityTypes));
         }
-        pollTimer = setTimeout(() => {
-          if (done) return;
-          pollInterval = setInterval(() => {
-            if (done) return;
-            busRequest(
-              this.actor,
-              "job:status-requested",
-              { jobId: jid },
-              "job:status-result",
-              "job:status-failed"
-            ).then((status) => {
-              if (done) return;
-              if (status.status === "complete") {
-                cleanup();
-                subscriber.next({ stage: "complete", percentage: 100, message: "Generation complete" });
-                subscriber.complete();
-              } else if (status.status === "failed") {
-                cleanup();
-                subscriber.error(new Error(status.error ?? "Generation failed"));
-              }
-            }).catch(() => {
-            });
-          }, 5e3);
-        }, 1e4);
-      };
-      let activeJobId = null;
-      const progress$ = this.eventBus.get("job:report-progress").pipe(
-        filter((e) => e.jobId === activeJobId)
-      );
-      const complete$ = this.eventBus.get("job:complete").pipe(
-        filter((e) => e.jobId === activeJobId)
-      );
-      const fail$ = this.eventBus.get("job:fail").pipe(
-        filter((e) => e.jobId === activeJobId)
-      );
-      const progressSub = progress$.pipe(takeUntil(merge(complete$, fail$))).subscribe((e) => {
-        subscriber.next(e.progress);
-        if (activeJobId) resetPollTimer(activeJobId);
-      });
-      const completeSub = complete$.subscribe(() => {
-        cleanup();
-        subscriber.complete();
-      });
-      const failSub = fail$.subscribe((e) => {
-        cleanup();
-        subscriber.error(new Error(e.error));
-      });
-      busRequest(
-        this.actor,
-        "job:create",
-        {
-          jobType: "generation",
-          resourceId,
-          params: {
-            referenceId: annotationId,
-            title: options.title,
-            prompt: options.prompt,
-            language: options.language,
-            temperature: options.temperature,
-            maxTokens: options.maxTokens,
-            storageUri: options.storageUri,
-            context: options.context
-          }
-        },
-        "job:created",
-        "job:create-failed"
-      ).then(({ jobId }) => {
-        if (jobId && !done) {
-          activeJobId = jobId;
-          resetPollTimer(jobId);
+        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
         }
-      }).catch((error) => {
-        cleanup();
-        subscriber.error(error);
-      });
-      return () => {
-        cleanup();
-        progressSub.unsubscribe();
-        completeSub.unsubscribe();
-        failSub.unsubscribe();
-      };
-    });
-  }
-  async cloneToken(resourceId) {
-    return busRequest(
-      this.actor,
-      "yield:clone-token-requested",
-      { resourceId },
-      "yield:clone-token-generated",
-      "yield:clone-token-failed"
+      }
     );
   }
-  async fromToken(token) {
-    const result = await busRequest(
-      this.actor,
-      "yield:clone-resource-requested",
-      { token },
-      "yield:clone-resource-result",
-      "yield:clone-resource-failed"
+  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 } }
     );
-    return result.sourceResource;
   }
-  async createFromToken(options) {
-    return busRequest(
-      this.actor,
-      "yield:clone-create",
-      options,
-      "yield:clone-created",
-      "yield:clone-create-failed"
+  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 }
+      }
     );
   }
-};
-
-// src/namespaces/beckon.ts
-var BeckonNamespace = class {
-  constructor(actor) {
-    this.actor = actor;
-  }
-  attention(annotationId, resourceId) {
-    this.actor.emit("beckon:focus", { annotationId, resourceId }).catch(() => {
-    });
-  }
-};
-
-// src/namespaces/job.ts
-var JobNamespace = class {
-  constructor(actor) {
-    this.actor = actor;
-  }
-  async status(jobId) {
-    return busRequest(
-      this.actor,
-      "job:status-requested",
-      { jobId },
-      "job:status-result",
-      "job:status-failed"
-    );
+  dispose() {
   }
-  async pollUntilComplete(jobId, options) {
-    const interval = options?.interval ?? 1e3;
-    const timeout7 = options?.timeout ?? 6e4;
-    const startTime = Date.now();
-    while (true) {
-      const status = await this.status(jobId);
-      if (options?.onProgress) options.onProgress(status);
-      if (status.status === "complete" || status.status === "failed" || status.status === "cancelled") {
-        return status;
-      }
-      if (Date.now() - startTime > timeout7) {
-        throw new Error(`Job polling timeout after ${timeout7}ms`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, interval));
+  /** 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;
     }
-  }
-  async cancel(jobId, type) {
-    await this.actor.emit("job:cancel-requested", { jobId, type });
-  }
-};
-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 });
-  }
-};
-var RESOURCE_SCOPED_CHANNELS = [
-  ...PERSISTED_EVENT_TYPES.filter((t) => t !== "mark:entity-type-added"),
-  ...RESOURCE_BROADCAST_TYPES
-];
-var BUS_RESULT_CHANNELS = [
-  "browse:resources-result",
-  "browse:resources-failed",
-  "browse:resource-result",
-  "browse:resource-failed",
-  "browse:annotations-result",
-  "browse:annotations-failed",
-  "browse:annotation-result",
-  "browse:annotation-failed",
-  "browse:annotation-history-result",
-  "browse:annotation-history-failed",
-  "browse:events-result",
-  "browse:events-failed",
-  "browse:referenced-by-result",
-  "browse:referenced-by-failed",
-  "browse:entity-types-result",
-  "browse:entity-types-failed",
-  "browse:directory-result",
-  "browse:directory-failed",
-  "browse:annotation-context-result",
-  "browse:annotation-context-failed",
-  "mark:delete-ok",
-  "mark:delete-failed",
-  "mark:create-ok",
-  "mark:create-failed",
-  "match:search-results",
-  "match:search-failed",
-  "gather:complete",
-  "gather:failed",
-  "gather:annotation-progress",
-  "gather:annotation-finished",
-  "gather:summary-result",
-  "gather:summary-failed",
-  "bind:body-updated",
-  "bind:body-update-failed",
-  "job:report-progress",
-  "job:complete",
-  "job:fail",
-  "job:status-result",
-  "job:status-failed",
-  "job:created",
-  "job:create-failed",
-  "job:claimed",
-  "job:claim-failed",
-  "yield:clone-token-generated",
-  "yield:clone-token-failed",
-  "yield:clone-resource-result",
-  "yield:clone-resource-failed",
-  "yield:clone-created",
-  "yield:clone-create-failed",
-  "mark:entity-type-added",
-  "beckon:focus",
-  "beckon:sparkle",
-  "bus:resume-gap"
-];
-var ACTOR_TO_LOCAL_BRIDGES = BUS_RESULT_CHANNELS;
-var APIError = class extends Error {
-  constructor(message, status, statusText, details) {
-    super(message);
-    this.status = status;
-    this.statusText = statusText;
-    this.details = details;
-    this.name = "APIError";
+    return headers;
   }
 };
-var SemiontApiClient = class {
-  http;
-  baseUrl;
-  /**
-   * Workspace-scoped EventBus — owned by the client, constructed
-   * internally, never accepted from config. Private: all bus access
-   * goes through `client.emit` / `client.on` / `client.stream`.
-   */
-  eventBus;
-  logger;
-  /**
-   * Observable token source. All auth reads from this.
-   */
-  token$;
-  _actor = null;
-  // ── Verb-oriented namespace API ──────────────────────────────────────────
-  browse;
-  mark;
-  bind;
-  gather;
-  match;
-  yield;
-  beckon;
-  job;
-  auth;
-  admin;
-  constructor(config) {
-    const { baseUrl: baseUrl3, timeout: timeout7 = 3e4, retry = 2, logger, tokenRefresher } = config;
-    this.eventBus = new EventBus();
-    this.logger = logger;
-    this.baseUrl = baseUrl3.endsWith("/") ? baseUrl3.slice(0, -1) : baseUrl3;
-    const retryConfig = tokenRefresher ? {
-      limit: 1,
-      methods: ["get", "post", "put", "patch", "delete", "head", "options"],
-      statusCodes: [401, 408, 413, 429, 500, 502, 503, 504]
-    } : retry;
-    this.http = ky.create({
-      timeout: timeout7,
-      retry: retryConfig,
-      credentials: "include",
-      hooks: {
-        beforeRequest: [
-          (request) => {
-            if (this.logger) {
-              this.logger.debug("HTTP Request", {
-                type: "http_request",
-                url: request.url,
-                method: request.method,
-                timestamp: Date.now(),
-                hasAuth: request.headers.has("Authorization")
-              });
-            }
-          }
-        ],
-        beforeRetry: tokenRefresher ? [
-          async ({ request, error }) => {
-            if (!(error instanceof HTTPError) || error.response.status !== 401) {
-              return void 0;
-            }
-            try {
-              const newToken = await tokenRefresher();
-              if (!newToken) return ky.stop;
-              request.headers.set("Authorization", `Bearer ${newToken}`);
-              return void 0;
-            } catch {
-              return ky.stop;
-            }
-          }
-        ] : [],
-        afterResponse: [
-          (request, _options, response) => {
-            if (this.logger) {
-              this.logger.debug("HTTP Response", {
-                type: "http_response",
-                url: request.url,
-                method: request.method,
-                status: response.status,
-                statusText: response.statusText
-              });
-            }
-            return response;
-          }
-        ],
-        beforeError: [
-          async (error) => {
-            const { response, request } = error;
-            if (response) {
-              const body = await response.json().catch(() => ({}));
-              if (this.logger) {
-                this.logger.error("HTTP Request Failed", {
-                  type: "http_error",
-                  url: request.url,
-                  method: request.method,
-                  status: response.status,
-                  statusText: response.statusText,
-                  error: body.message || `HTTP ${response.status}: ${response.statusText}`
-                });
-              }
-              throw new APIError(
-                body.message || `HTTP ${response.status}: ${response.statusText}`,
-                response.status,
-                response.statusText,
-                body
-              );
-            }
-            return error;
-          }
-        ]
-      }
-    });
-    this.token$ = config.token$ ?? new BehaviorSubject(null);
-    const getToken = () => this.token$.getValue() ?? void 0;
-    this.browse = new BrowseNamespace(this, this.eventBus, getToken, this.actor);
-    this.mark = new MarkNamespace(this, this.eventBus, getToken, this.actor);
-    this.bind = new BindNamespace(this.actor);
-    this.gather = new GatherNamespace(this.eventBus, this.actor);
-    this.match = new MatchNamespace(this.eventBus, this.actor);
-    this.yield = new YieldNamespace(this, this.eventBus, getToken, this.actor);
-    this.beckon = new BeckonNamespace(this.actor);
-    this.job = new JobNamespace(this.actor);
-    this.auth = new AuthNamespace(this, getToken);
-    this.admin = new AdminNamespace(this, getToken);
-    this.token$.subscribe((token) => {
-      if (token && !this._actorStarted) {
-        this._actorStarted = true;
-        this.actor.start();
-      }
-    });
-  }
-  _actorStarted = false;
-  get actor() {
-    if (!this._actor) {
-      this._actor = createActorVM({
-        baseUrl: this.baseUrl,
-        token: () => this.token$.getValue() ?? "",
-        channels: [...BUS_RESULT_CHANNELS]
-      });
-      for (const channel of ACTOR_TO_LOCAL_BRIDGES) {
-        this._actor.on$(channel).subscribe((payload) => {
-          this.eventBus.get(channel).next(payload);
-        });
-      }
-    }
-    return this._actor;
-  }
-  activeResource = null;
-  /**
-   * Subscribe the bus actor to the resource-scoped SSE stream for a single
-   * resource and bridge incoming scoped events into the workspace event bus.
-   *
-   * **One distinct scope at a time**: the client supports subscriptions
-   * to a single resource scope concurrently. Multiple calls with the
-   * **same** resourceId are ref-counted — each returns an independent
-   * unsubscribe; the underlying SSE scope is torn down only when the
-   * last unsubscribe fires. Calling with a **different** resourceId
-   * while a subscription is live throws. Widening this to multiple
-   * concurrent scopes is deferred until a product requirement (e.g.
-   * split-pane viewer, headless fleet-watcher) forces the design.
-   *
-   * @returns a disposer that decrements the ref count (and tears down
-   *          the SSE scope + bridges when it reaches zero).
-   */
-  subscribeToResource(resourceId) {
-    if (this.activeResource) {
-      if (this.activeResource.resourceId !== resourceId) {
-        throw new Error(
-          `SemiontApiClient 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) => {
-          this.eventBus.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;
-    };
-  }
-  dispose() {
-    if (this.activeResource) {
-      for (const sub of this.activeResource.bridgeSubs) sub.unsubscribe();
-      this.activeResource = null;
-    }
-    if (this._actor) {
-      this._actor.dispose();
-      this._actor = null;
-    }
-  }
-  // ── Event bus surface ─────────────────────────────────────────
-  // The ONE public path to the workspace bus. VMs, session, and
-  // components route through these methods; `this.eventBus` remains
-  // the internal owner and will be privatized once all callers
-  // have migrated.
-  /** Emit an event on the internal bus. */
-  emit(channel, payload) {
-    this.eventBus.get(channel).next(payload);
-  }
-  /** Subscribe to an event on the internal bus; returns unsubscribe. */
-  on(channel, handler) {
-    const sub = this.eventBus.get(channel).subscribe(handler);
-    return () => sub.unsubscribe();
-  }
-  /** Read-only observable for a bus channel. Consumers `.pipe(...)` over this. */
-  stream(channel) {
-    return this.eventBus.get(channel).asObservable();
-  }
-  /**
-   * Build the `Authorization: Bearer <token>` header. If the caller passed
-   * an explicit `{ auth }` it wins (used by session-internal throwaway
-   * clients that need to run a validation request with a specific token).
-   * Otherwise the current value of `this.token$` is used, so external
-   * callers never have to plumb the token themselves.
-   */
-  authHeaders(options) {
-    const token = options?.auth ?? this.token$.getValue() ?? void 0;
-    return token ? { Authorization: `Bearer ${token}` } : {};
-  }
-  // ============================================================================
-  // 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 data.generationPrompt - Optional prompt that drove AI generation
-   * @param data.generator - Optional Agent(s) that generated the content
-   * @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);
-    }
-    if (data.generationPrompt) {
-      formData.append("generationPrompt", data.generationPrompt);
-    }
-    if (data.generator) {
-      formData.append("generator", JSON.stringify(data.generator));
-    }
-    if (data.isDraft !== void 0) {
-      formData.append("isDraft", String(data.isDraft));
-    }
-    return this.http.post(`${this.baseUrl}/resources`, {
-      body: formData,
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async browseResource(id, _options) {
-    return busRequest(this.actor, "browse:resource-requested", { resourceId: id }, "browse:resource-result", "browse:resource-failed");
-  }
-  /**
-   * 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)
-      }
-    });
-    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) {
-    return busRequest(
-      this.actor,
-      "browse:resources-requested",
-      { search: query, archived, limit: limit ?? 100, offset: 0 },
-      "browse:resources-result",
-      "browse:resources-failed"
-    );
-  }
-  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 busRequest(this.actor, "browse:events-requested", { resourceId: id }, "browse:events-result", "browse:events-failed");
-  }
-  async browseReferences(id, _options) {
-    return busRequest(this.actor, "browse:referenced-by-requested", { resourceId: id }, "browse:referenced-by-result", "browse:referenced-by-failed");
-  }
-  async generateCloneToken(id, _options) {
-    return busRequest(this.actor, "yield:clone-token-requested", { resourceId: id }, "yield:clone-token-generated", "yield:clone-token-failed");
-  }
-  async getResourceByToken(token, _options) {
-    return busRequest(this.actor, "yield:clone-resource-requested", { token }, "yield:clone-resource-result", "yield:clone-resource-failed");
-  }
-  async createResourceFromToken(data, _options) {
-    return busRequest(this.actor, "yield:clone-create", data, "yield:clone-created", "yield:clone-create-failed");
-  }
-  // ============================================================================
-  // ANNOTATIONS
-  // ============================================================================
-  async markAnnotation(id, data, _options) {
-    return busRequest(
-      this.actor,
-      "mark:create-request",
-      { resourceId: id, request: data },
-      "mark:create-ok",
-      "mark:create-failed"
-    );
-  }
-  async getAnnotation(id, _options) {
-    return busRequest(this.actor, "browse:annotation-requested", { annotationId: id }, "browse:annotation-result", "browse:annotation-failed");
-  }
-  async browseAnnotation(resourceId, annotationId, _options) {
-    return busRequest(this.actor, "browse:annotation-requested", { resourceId, annotationId }, "browse:annotation-result", "browse:annotation-failed");
-  }
-  async browseAnnotations(id, _motivation, _options) {
-    return busRequest(this.actor, "browse:annotations-requested", { resourceId: id }, "browse:annotations-result", "browse:annotations-failed");
-  }
-  async deleteAnnotation(resourceId, annotationId, _options) {
-    await this.actor.emit("mark:delete", { annotationId, resourceId });
-  }
-  async bindAnnotation(resourceId, annotationId, data, _options) {
-    const correlationId = crypto.randomUUID();
-    await this.actor.emit("bind:update-body", { correlationId, annotationId, resourceId, operations: data.operations });
-    return { correlationId };
-  }
-  async getAnnotationHistory(resourceId, annotationId, _options) {
-    return busRequest(this.actor, "browse:annotation-history-requested", { resourceId, annotationId }, "browse:annotation-history-result", "browse:annotation-history-failed");
-  }
-  async annotateReferences(resourceId, data, _options) {
-    const { jobId } = await busRequest(
-      this.actor,
-      "job:create",
-      { jobType: "reference-annotation", resourceId, params: data },
-      "job:created",
-      "job:create-failed"
-    );
-    return { correlationId: crypto.randomUUID(), jobId };
-  }
-  async annotateHighlights(resourceId, data, _options) {
-    const { jobId } = await busRequest(
-      this.actor,
-      "job:create",
-      { jobType: "highlight-annotation", resourceId, params: data },
-      "job:created",
-      "job:create-failed"
-    );
-    return { correlationId: crypto.randomUUID(), jobId };
-  }
-  async annotateAssessments(resourceId, data, _options) {
-    const { jobId } = await busRequest(
-      this.actor,
-      "job:create",
-      { jobType: "assessment-annotation", resourceId, params: data },
-      "job:created",
-      "job:create-failed"
-    );
-    return { correlationId: crypto.randomUUID(), jobId };
-  }
-  async annotateComments(resourceId, data, _options) {
-    const { jobId } = await busRequest(
-      this.actor,
-      "job:create",
-      { jobType: "comment-annotation", resourceId, params: data },
-      "job:created",
-      "job:create-failed"
-    );
-    return { correlationId: crypto.randomUUID(), jobId };
-  }
-  async annotateTags(resourceId, data, _options) {
-    const { jobId } = await busRequest(
-      this.actor,
-      "job:create",
-      { jobType: "tag-annotation", resourceId, params: data },
-      "job:created",
-      "job:create-failed"
-    );
-    return { correlationId: crypto.randomUUID(), jobId };
-  }
-  async yieldResourceFromAnnotation(resourceId, annotationId, data, _options) {
-    const { jobId } = await busRequest(
-      this.actor,
-      "job:create",
-      { jobType: "generation", resourceId, params: { referenceId: annotationId, ...data } },
-      "job:created",
-      "job:create-failed"
-    );
-    return { correlationId: crypto.randomUUID(), jobId };
-  }
-  async gatherAnnotationContext(resourceId, annotationId, data, _options) {
-    await this.actor.emit("gather:requested", {
-      correlationId: data.correlationId,
-      annotationId,
-      resourceId,
-      contextWindow: data.contextWindow ?? 2e3
-    });
-    return { correlationId: data.correlationId };
-  }
-  async matchSearch(resourceId, data, _options) {
-    await this.actor.emit("match:search-requested", {
-      correlationId: data.correlationId,
-      resourceId,
-      referenceId: data.referenceId,
-      context: data.context,
-      limit: data.limit ?? 10,
-      useSemanticScoring: data.useSemanticScoring ?? true
-    });
-    return { correlationId: data.correlationId };
-  }
-  // ============================================================================
-  // ENTITY TYPES
-  // ============================================================================
-  async addEntityType(type, _options) {
-    await this.actor.emit("mark:add-entity-type", { tag: type });
-  }
-  async addEntityTypesBulk(types, _options) {
-    for (const tag of types) {
-      await this.actor.emit("mark:add-entity-type", { tag });
-    }
-  }
-  async listEntityTypes(_options) {
-    return busRequest(this.actor, "browse:entity-types-requested", {}, "browse:entity-types-result", "browse:entity-types-failed");
-  }
-  // ============================================================================
-  // PARTICIPANTS
-  // ============================================================================
-  async beckonAttention(_participantId, data, _options) {
-    await this.actor.emit("beckon:focus", data);
-    return {};
-  }
-  // ============================================================================
-  // ADMIN
-  // ============================================================================
-  async listUsers(options) {
-    return this.http.get(`${this.baseUrl}/api/admin/users`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async getUserStats(options) {
-    return this.http.get(`${this.baseUrl}/api/admin/users/stats`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  /**
-   * Update a user by ID
-   * Note: Users use DID identifiers (did:web:domain:users:id), not HTTP URIs.
-   */
-  async updateUser(id, data, options) {
-    return this.http.patch(`${this.baseUrl}/api/admin/users/${id}`, {
-      json: data,
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async getOAuthConfig(options) {
-    return this.http.get(`${this.baseUrl}/api/admin/oauth/config`, {
-      headers: this.authHeaders(options)
-    }).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) {
-    return this.http.post(`${this.baseUrl}/api/admin/exchange/backup`, {
-      headers: this.authHeaders(options)
-    });
-  }
-  /**
-   * 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) {
-    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)
-    });
-    return this.parseSSEStream(response, options?.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) {
-    const searchParams = params?.includeArchived ? new URLSearchParams({ includeArchived: "true" }) : void 0;
-    return this.http.post(`${this.baseUrl}/api/moderate/exchange/export`, {
-      headers: this.authHeaders(options),
-      ...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) {
-    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)
-    });
-    return this.parseSSEStream(response, options?.onProgress);
-  }
-  async parseSSEStream(response, onProgress) {
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    let finalResult = { phase: "unknown" };
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop();
-      for (const line of lines) {
-        if (line.startsWith("data: ")) {
-          const event = JSON.parse(line.slice(6));
-          onProgress?.(event);
-          finalResult = event;
-        }
-      }
-    }
-    return finalResult;
-  }
-  // ============================================================================
-  // JOB STATUS
-  // ============================================================================
-  async getJobStatus(id, _options) {
-    return busRequest(this.actor, "job:status-requested", { jobId: id }, "job:status-result", "job:status-failed");
-  }
-  /**
-   * 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 timeout7 = 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 > timeout7) {
-        throw new Error(`Job polling timeout after ${timeout7}ms`);
-      }
-      await new Promise((resolve) => setTimeout(resolve, interval));
-    }
-  }
-  // ============================================================================
-  // SYSTEM STATUS
-  // ============================================================================
-  async healthCheck(options) {
-    return this.http.get(`${this.baseUrl}/api/health`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async getStatus(options) {
-    return this.http.get(`${this.baseUrl}/api/status`, {
-      headers: this.authHeaders(options)
-    }).json();
-  }
-  async browseFiles(dirPath, sort, _options) {
-    return busRequest(
-      this.actor,
-      "browse:directory-requested",
-      { path: dirPath ?? ".", sort: sort ?? "name" },
-      "browse:directory-result",
-      "browse:directory-failed"
-    );
-  }
-};
-
-// src/session/storage.ts
-var SESSION_PREFIX = "semiont.session.";
-var STORAGE_KEY = "semiont.knowledgeBases";
-var ACTIVE_KEY = "semiont.activeKnowledgeBaseId";
-var REFRESH_BEFORE_EXP_MS = 5 * 60 * 1e3;
-function sessionKey(kbId) {
-  return `${SESSION_PREFIX}${kbId}`;
-}
-function getStoredSession(storage, kbId) {
-  const raw = storage.get(sessionKey(kbId));
-  if (!raw) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed.access === "string" && typeof parsed.refresh === "string") {
-      return { access: parsed.access, refresh: parsed.refresh };
-    }
-  } catch {
-  }
-  return null;
-}
-function setStoredSession(storage, kbId, session) {
-  storage.set(sessionKey(kbId), JSON.stringify(session));
-}
-function clearStoredSession(storage, kbId) {
-  storage.delete(sessionKey(kbId));
-}
-function parseJwtExpiry(token) {
-  try {
-    const parts = token.split(".");
-    if (parts.length !== 3 || !parts[1]) return null;
-    const payload = JSON.parse(atob(parts[1]));
-    if (!payload.exp) return null;
-    return new Date(payload.exp * 1e3);
-  } catch {
-    return null;
-  }
-}
-function isJwtExpired(token) {
-  const expiry = parseJwtExpiry(token);
-  if (!expiry) return true;
-  return expiry.getTime() < Date.now();
-}
-function migrateLegacyEntry(entry) {
-  if (entry.host !== void 0) return entry;
-  try {
-    const url = new URL(entry.backendUrl);
-    return {
-      id: entry.id,
-      label: entry.label,
-      host: url.hostname,
-      port: parseInt(url.port, 10) || (url.protocol === "https:" ? 443 : 80),
-      protocol: url.protocol === "https:" ? "https" : "http",
-      email: ""
-    };
-  } catch {
-    return {
-      id: entry.id,
-      label: entry.label || "Unknown",
-      host: "localhost",
-      port: 4e3,
-      protocol: "http",
-      email: ""
-    };
-  }
-}
-function loadKnowledgeBases(storage) {
-  try {
-    const raw = storage.get(STORAGE_KEY);
-    if (!raw) return [];
-    const entries = JSON.parse(raw);
-    return entries.map(migrateLegacyEntry);
-  } catch {
-    return [];
-  }
-}
-function saveKnowledgeBases(storage, knowledgeBases) {
-  storage.set(STORAGE_KEY, JSON.stringify(knowledgeBases));
-}
-function defaultProtocol(host) {
-  return host === "localhost" || host === "127.0.0.1" ? "http" : "https";
-}
-var HOSTNAME_RE = /^(([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)*[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?|localhost|\d{1,3}(\.\d{1,3}){3})$/;
-function isValidHostname(host) {
-  return HOSTNAME_RE.test(host);
-}
-function kbBackendUrl(kb) {
-  if (!isValidHostname(kb.host)) {
-    throw new Error(`Invalid KB hostname: "${kb.host}"`);
-  }
-  const url = new URL("http://x");
-  url.protocol = kb.protocol + ":";
-  url.hostname = kb.host;
-  url.port = String(kb.port);
-  return `${kb.protocol}://${url.hostname}:${kb.port}`;
-}
-function generateKbId() {
-  return crypto.randomUUID();
-}
-
-// src/session/errors.ts
-var SemiontError = class extends Error {
-  code;
-  kbId;
-  constructor(code, message, kbId = null) {
-    super(message);
-    this.name = "SemiontError";
-    this.code = code;
-    this.kbId = kbId;
-  }
-};
-
-// src/session/semiont-session.ts
-var SemiontSession = class {
-  kb;
-  client;
-  token$;
-  user$;
-  streamState$;
-  /** Resolves after the initial validation round-trip completes (success or failure). */
-  ready;
-  storage;
-  doRefresh;
-  doValidate;
-  onAuthFailed;
-  onError;
-  refreshTimer = null;
-  unsubscribeStorage = null;
-  disposed = false;
-  constructor(config) {
-    this.kb = config.kb;
-    this.storage = config.storage;
-    this.doRefresh = config.refresh;
-    this.doValidate = config.validate;
-    this.onAuthFailed = config.onAuthFailed ?? (() => {
-    });
-    this.onError = config.onError ?? (() => {
-    });
-    const stored = getStoredSession(this.storage, this.kb.id);
-    const initialToken = stored && !isJwtExpired(stored.access) ? accessToken(stored.access) : null;
-    this.token$ = new BehaviorSubject(initialToken);
-    this.user$ = new BehaviorSubject(null);
-    this.client = new SemiontApiClient({
-      baseUrl: baseUrl(kbBackendUrl(this.kb)),
-      token$: this.token$,
-      tokenRefresher: () => this.refresh().then((t) => t ?? null)
-    });
-    this.streamState$ = this.client.actor.state$;
-    if (initialToken) {
-      this.scheduleProactiveRefresh(initialToken);
-    }
-    this.unsubscribeStorage = this.storage.subscribe?.((key, newValue) => {
-      this.handleStorageChange(key, newValue);
-    }) ?? null;
-    this.ready = this.validate(stored);
-  }
-  /**
-   * Run the initial mount-time validation. If a stored access token is
-   * present and unexpired, call the configured `validate` with it to
-   * confirm it still works and populate `user$`. If expired, try
-   * refresh first. On 401 from validate, try refresh once. Surfaces
-   * auth-failed on terminal failure.
-   *
-   * When no `validate` callback is provided (service principals), this
-   * still runs through the refresh-if-expired step so the stored
-   * token is current — it just skips the user-validation round trip.
-   */
-  async validate(stored) {
-    if (!stored) return;
-    const startToken = isJwtExpired(stored.access) ? await this.doRefresh() : stored.access;
-    if (!startToken) {
-      if (isJwtExpired(stored.access)) {
-        clearStoredSession(this.storage, this.kb.id);
-      }
-      return;
-    }
-    if (startToken !== stored.access) {
-      this.token$.next(accessToken(startToken));
-      this.scheduleProactiveRefresh(startToken);
-    }
-    if (!this.doValidate) return;
-    const attempt = async (token) => {
-      if (this.disposed) return;
-      try {
-        const data = await this.doValidate(accessToken(token));
-        if (this.disposed) return;
-        this.user$.next(data);
-      } catch (err) {
-        if (this.disposed) return;
-        if (err instanceof APIError && err.status === 401) {
-          const refreshed = await this.doRefresh();
-          if (this.disposed) return;
-          if (refreshed) {
-            this.token$.next(accessToken(refreshed));
-            this.scheduleProactiveRefresh(refreshed);
-            await attempt(refreshed);
-            return;
-          }
-          clearStoredSession(this.storage, this.kb.id);
-          this.token$.next(null);
-          this.onAuthFailed("Your session has expired. Please sign in again.");
-        } else {
-          this.onError(
-            new SemiontError(
-              "session.auth-failed",
-              err instanceof Error ? err.message : String(err),
-              this.kb.id
-            )
-          );
-        }
-      }
-    };
-    await attempt(startToken);
-  }
-  /**
-   * Refresh the access token via the configured `refresh` callback.
-   * On success, pushes the new token into `token$` and schedules the
-   * next proactive refresh. On failure, clears persisted state and
-   * fires `onAuthFailed` — the frontend's wiring of that callback is
-   * what surfaces the session-expired modal.
-   */
-  async refresh() {
-    if (this.disposed) return null;
-    const newAccess = await this.doRefresh();
-    if (this.disposed) return null;
-    if (newAccess) {
-      const tok = accessToken(newAccess);
-      this.token$.next(tok);
-      this.scheduleProactiveRefresh(newAccess);
-      return tok;
-    }
-    this.token$.next(null);
-    clearStoredSession(this.storage, this.kb.id);
-    this.onAuthFailed("Your session has expired. Please sign in again.");
-    this.onError(
-      new SemiontError("session.refresh-exhausted", "Token refresh failed", this.kb.id)
-    );
-    return null;
-  }
-  scheduleProactiveRefresh(token) {
-    this.clearRefreshTimer();
-    const expiresAt = parseJwtExpiry(token);
-    if (!expiresAt) return;
-    const refreshAt = expiresAt.getTime() - REFRESH_BEFORE_EXP_MS;
-    const delay = Math.max(0, refreshAt - Date.now());
-    this.refreshTimer = setTimeout(() => {
-      this.refreshTimer = null;
-      if (!this.disposed) void this.refresh();
-    }, delay);
-  }
-  clearRefreshTimer() {
-    if (this.refreshTimer) {
-      clearTimeout(this.refreshTimer);
-      this.refreshTimer = null;
-    }
-  }
-  /**
-   * Cross-context sync: another tab/process refreshed or signed out this
-   * KB. Mirror the change into our in-memory state.
-   */
-  handleStorageChange(key, newValue) {
-    if (this.disposed) return;
-    if (key !== sessionKey(this.kb.id)) return;
-    if (!newValue) {
-      this.token$.next(null);
-      this.user$.next(null);
-      this.clearRefreshTimer();
-      return;
-    }
-    try {
-      const parsed = JSON.parse(newValue);
-      if (typeof parsed.access === "string") {
-        this.token$.next(accessToken(parsed.access));
-        this.scheduleProactiveRefresh(parsed.access);
-      }
-    } catch {
-    }
-  }
-  get expiresAt() {
-    const token = this.token$.getValue();
-    return token ? parseJwtExpiry(token) : null;
-  }
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.clearRefreshTimer();
-    if (this.unsubscribeStorage) {
-      this.unsubscribeStorage();
-      this.unsubscribeStorage = null;
-    }
-    this.client.dispose();
-    this.token$.complete();
-    this.user$.complete();
-  }
-};
-
-// src/session/notify.ts
-var activeOnSessionExpired = null;
-var activeOnPermissionDenied = null;
-function notifySessionExpired(message) {
-  activeOnSessionExpired?.(message);
-}
-function notifyPermissionDenied(message) {
-  activeOnPermissionDenied?.(message);
-}
-function registerAuthNotifyHandlers(handlers) {
-  activeOnSessionExpired = handlers.onSessionExpired;
-  activeOnPermissionDenied = handlers.onPermissionDenied;
-  return () => {
-    activeOnSessionExpired = null;
-    activeOnPermissionDenied = null;
-  };
-}
-var FrontendSessionSignals = class {
-  sessionExpiredAt$;
-  sessionExpiredMessage$;
-  permissionDeniedAt$;
-  permissionDeniedMessage$;
-  constructor() {
-    this.sessionExpiredAt$ = new BehaviorSubject(null);
-    this.sessionExpiredMessage$ = new BehaviorSubject(null);
-    this.permissionDeniedAt$ = new BehaviorSubject(null);
-    this.permissionDeniedMessage$ = new BehaviorSubject(null);
-  }
-  notifySessionExpired(message) {
-    this.sessionExpiredMessage$.next(
-      message ?? "Your session has expired. Please sign in again."
-    );
-    this.sessionExpiredAt$.next(Date.now());
-  }
-  notifyPermissionDenied(message) {
-    this.permissionDeniedMessage$.next(
-      message ?? "You do not have permission to perform this action."
-    );
-    this.permissionDeniedAt$.next(Date.now());
-  }
-  acknowledgeSessionExpired() {
-    this.sessionExpiredAt$.next(null);
-    this.sessionExpiredMessage$.next(null);
-  }
-  acknowledgePermissionDenied() {
-    this.permissionDeniedAt$.next(null);
-    this.permissionDeniedMessage$.next(null);
-  }
-  dispose() {
-    this.sessionExpiredAt$.complete();
-    this.sessionExpiredMessage$.complete();
-    this.permissionDeniedAt$.complete();
-    this.permissionDeniedMessage$.complete();
-  }
-};
-
-// src/session/semiont-browser.ts
-var OPEN_RESOURCES_KEY = "openDocuments";
-function sortOpenResources(resources) {
-  return [...resources].sort((a, b) => {
-    if (a.order !== void 0 && b.order !== void 0) return a.order - b.order;
-    return a.openedAt - b.openedAt;
-  });
-}
-function loadOpenResources(storage) {
-  try {
-    const stored = storage.get(OPEN_RESOURCES_KEY);
-    if (stored) return sortOpenResources(JSON.parse(stored));
-  } catch {
-  }
-  return [];
-}
-var SemiontBrowser = class {
-  kbs$;
-  activeKbId$;
-  activeSession$;
-  /**
-   * Modal signals (session-expired / permission-denied) for the
-   * currently-active session. Parallels `activeSession$` — always
-   * non-null when `activeSession$` is non-null, always null when it
-   * is. Extracted from the session itself so headless sessions
-   * (workers, CLIs, tests) don't carry dead modal observables.
-   * See [FrontendSessionSignals](./frontend-session-signals.ts).
-   */
-  activeSignals$;
-  /**
-   * True while a session is actively being constructed (setActiveKb /
-   * signIn in flight, awaiting `session.ready`). Distinguishes the
-   * "session about to arrive" intermediate state from "session
-   * intentionally null" (after signOut, or when the active KB has no
-   * stored credentials). UIs that want a loading spinner should gate
-   * on this; otherwise they get stuck spinning after every signOut.
-   */
-  sessionActivating$;
-  openResources$;
-  error$;
-  identityToken$;
-  storage;
-  /**
-   * App-scoped EventBus. Hosts UI-shell events that must work regardless
-   * of whether a KB session is active: panel toggles, sidebar state,
-   * tab reorders, routing, settings, etc. Disjoint from the per-session
-   * bus inside `SemiontApiClient`, which carries KB-content events
-   * (mark:*, beckon:*, gather:*, match:*, bind:*, yield:*, browse:click).
-   */
-  eventBus = new EventBus();
-  unregisterNotify = null;
-  unsubscribeStorage = null;
-  disposed = false;
-  activating = null;
-  /**
-   * Per-KB in-flight refresh dedup. Simultaneous 401s for the same
-   * KB converge on a single `/api/tokens/refresh` network call.
-   * Was previously module-scoped in `refresh.ts`; moved here when
-   * that file was deleted — SemiontBrowser is a singleton so the
-   * scoping is equivalent.
-   */
-  inFlightRefreshes = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.storage = config.storage;
-    const kbs = loadKnowledgeBases(this.storage);
-    const storedActive = this.storage.get(ACTIVE_KEY);
-    const initialActive = storedActive && kbs.some((kb) => kb.id === storedActive) ? storedActive : kbs[0]?.id ?? null;
-    this.kbs$ = new BehaviorSubject(kbs);
-    this.activeKbId$ = new BehaviorSubject(initialActive);
-    this.activeSession$ = new BehaviorSubject(null);
-    this.activeSignals$ = new BehaviorSubject(null);
-    this.sessionActivating$ = new BehaviorSubject(false);
-    this.openResources$ = new BehaviorSubject(loadOpenResources(this.storage));
-    this.error$ = new Subject();
-    this.identityToken$ = new BehaviorSubject(null);
-    this.kbs$.subscribe((next) => saveKnowledgeBases(this.storage, next));
-    this.activeKbId$.subscribe((id) => {
-      if (id) this.storage.set(ACTIVE_KEY, id);
-      else this.storage.delete(ACTIVE_KEY);
-    });
-    this.openResources$.subscribe((list) => {
-      this.storage.set(OPEN_RESOURCES_KEY, JSON.stringify(list));
-    });
-    this.unsubscribeStorage = this.storage.subscribe?.((key, newValue) => {
-      if (key !== OPEN_RESOURCES_KEY || !newValue) return;
-      try {
-        this.openResources$.next(sortOpenResources(JSON.parse(newValue)));
-      } catch {
-      }
-    }) ?? null;
-    this.unregisterNotify = registerAuthNotifyHandlers({
-      onSessionExpired: (message) => {
-        this.activeSignals$.getValue()?.notifySessionExpired(message ?? null);
-      },
-      onPermissionDenied: (message) => {
-        this.activeSignals$.getValue()?.notifyPermissionDenied(message ?? null);
-      }
-    });
-    if (initialActive) {
-      void this.setActiveKb(initialActive);
-    }
-  }
-  // ── App-scoped event bus ──────────────────────────────────────────────
-  /** Emit an event on the browser's app-scoped bus. */
-  emit(channel, payload) {
-    if (this.disposed) return;
-    this.eventBus.get(channel).next(payload);
-  }
-  /** Subscribe to an event; returns unsubscribe. */
-  on(channel, handler) {
-    const sub = this.eventBus.get(channel).subscribe(handler);
-    return () => sub.unsubscribe();
-  }
-  /** Read-only observable for an app-scoped channel. */
-  stream(channel) {
-    return this.eventBus.get(channel).asObservable();
-  }
-  // ── Identity token (NextAuth bridge; D1) ──────────────────────────────
-  /**
-   * Set the app-level identity token (from NextAuth's useSession).
-   * Called at the root layout via a single `useEffect`. No other site
-   * in the codebase should call this.
-   */
-  setIdentityToken(token) {
-    if (this.disposed) return;
-    this.identityToken$.next(token);
-  }
-  // ── KB list management ────────────────────────────────────────────────
-  addKb(input, access, refresh) {
-    const kb = { id: generateKbId(), ...input };
-    setStoredSession(this.storage, kb.id, { access, refresh });
-    this.kbs$.next([...this.kbs$.getValue(), kb]);
-    void this.setActiveKb(kb.id);
-    return kb;
-  }
-  removeKb(id) {
-    clearStoredSession(this.storage, id);
-    const next = this.kbs$.getValue().filter((kb) => kb.id !== id);
-    this.kbs$.next(next);
-    if (this.activeKbId$.getValue() === id) {
-      void this.setActiveKb(next[0]?.id ?? null);
-    }
-  }
-  updateKb(id, updates) {
-    this.kbs$.next(
-      this.kbs$.getValue().map((kb) => kb.id === id ? { ...kb, ...updates } : kb)
-    );
-  }
-  /**
-   * Read the locally-stored credential status for a KB. Pure / synchronous —
-   * does not subscribe to context changes. Used by KB-list UI to color status
-   * dots without requiring re-renders on every tick.
-   */
-  getKbSessionStatus(kbId) {
-    const stored = getStoredSession(this.storage, kbId);
-    if (!stored) return "signed-out";
-    return isJwtExpired(stored.access) ? "expired" : "authenticated";
-  }
-  /**
-   * Switch the active KB. Follows the D2 disposal contract:
-   *   1. Synchronously announce the new id on `activeKbId$` and null out
-   *      `activeSession$` so views see a safe empty state first.
-   *   2. Serialize overlapping calls — if an activation is in flight, wait
-   *      for it before proceeding.
-   *   3. Dispose whatever session is currently live.
-   *   4. Construct the next session and await `session.ready`.
-   *   5. Before emitting, re-check `activeKbId$` — if a newer call superseded
-   *      us while we waited, dispose our session and skip the emit.
-   *   6. Emit the new session.
-   */
-  async setActiveKb(id) {
-    if (this.disposed) return;
-    const prevId = this.activeKbId$.getValue();
-    const prevSession = this.activeSession$.getValue();
-    if (id === prevId && prevSession) return;
-    if (prevId !== id) this.activeKbId$.next(id);
-    if (prevSession) {
-      this.activeSession$.next(null);
-      this.activeSignals$.next(null);
-    }
-    while (this.activating) {
-      const current = this.activating;
-      await current;
-      if (this.disposed) return;
-      if (this.activeKbId$.getValue() !== id) return;
-    }
-    const activation = (async () => {
-      const toDispose = this.activeSession$.getValue();
-      const signalsToDispose = this.activeSignals$.getValue();
-      if (toDispose) {
-        this.activeSession$.next(null);
-        this.activeSignals$.next(null);
-        await toDispose.dispose();
-        signalsToDispose?.dispose();
-      }
-      if (!id) return;
-      const kb = this.kbs$.getValue().find((k) => k.id === id);
-      if (!kb) return;
-      const signals = new FrontendSessionSignals();
-      const session = new SemiontSession({
-        kb,
-        storage: this.storage,
-        refresh: () => this.performRefresh(kb),
-        validate: (token) => this.performValidate(kb, token),
-        onAuthFailed: (msg) => signals.notifySessionExpired(msg),
-        onError: (err) => this.error$.next(err)
-      });
-      try {
-        await session.ready;
-      } catch (err) {
-        this.error$.next(
-          new SemiontError(
-            "session.construct-failed",
-            err instanceof Error ? err.message : String(err),
-            id
-          )
-        );
-        await session.dispose();
-        signals.dispose();
-        return;
-      }
-      if (this.disposed || this.activeKbId$.getValue() !== id) {
-        await session.dispose();
-        signals.dispose();
-        return;
-      }
-      this.activeSession$.next(session);
-      this.activeSignals$.next(signals);
-    })();
-    this.activating = activation;
-    this.sessionActivating$.next(true);
-    try {
-      await activation;
-    } finally {
-      if (this.activating === activation) {
-        this.activating = null;
-        this.sessionActivating$.next(false);
-      }
-    }
-  }
-  /**
-   * Sign in to an existing KB: store the tokens and (re)activate the
-   * session. If the KB is already active, the current session is disposed
-   * and replaced so the new tokens take effect.
-   */
-  async signIn(id, access, refresh) {
-    if (this.disposed) return;
-    setStoredSession(this.storage, id, { access, refresh });
-    if (this.activeKbId$.getValue() === id) {
-      const prevSession = this.activeSession$.getValue();
-      const prevSignals = this.activeSignals$.getValue();
-      this.activeSession$.next(null);
-      this.activeSignals$.next(null);
-      if (prevSession) await prevSession.dispose();
-      prevSignals?.dispose();
-      await this.setActiveKb(id);
-      return;
-    }
-    await this.setActiveKb(id);
-  }
-  /**
-   * Sign out of a KB: clear stored tokens. If the KB is active, dispose
-   * its session + signals and emit null for both.
-   */
-  async signOut(id) {
-    if (this.disposed) return;
-    clearStoredSession(this.storage, id);
-    this.kbs$.next([...this.kbs$.getValue()]);
-    if (this.activeKbId$.getValue() === id) {
-      const prevSession = this.activeSession$.getValue();
-      const prevSignals = this.activeSignals$.getValue();
-      this.activeSession$.next(null);
-      this.activeSignals$.next(null);
-      if (prevSession) await prevSession.dispose();
-      prevSignals?.dispose();
-    }
-  }
-  // ── Open resources ────────────────────────────────────────────────────
-  addOpenResource(id, name, mediaType, storageUri) {
-    const existing = this.openResources$.getValue();
-    const idx = existing.findIndex((r) => r.id === id);
-    if (idx >= 0) {
-      const prev = existing[idx];
-      const updated = {
-        ...prev,
-        name,
-        ...mediaType !== void 0 ? { mediaType } : {},
-        ...storageUri !== void 0 ? { storageUri } : {}
-      };
-      const next = [...existing];
-      next[idx] = updated;
-      this.openResources$.next(next);
-      return;
-    }
-    const resource = {
-      id,
-      name,
-      openedAt: Date.now(),
-      order: existing.length,
-      ...mediaType !== void 0 ? { mediaType } : {},
-      ...storageUri !== void 0 ? { storageUri } : {}
-    };
-    this.openResources$.next([...existing, resource]);
-  }
-  removeOpenResource(id) {
-    this.openResources$.next(this.openResources$.getValue().filter((r) => r.id !== id));
-  }
-  updateOpenResourceName(id, name) {
-    this.openResources$.next(
-      this.openResources$.getValue().map((r) => r.id === id ? { ...r, name } : r)
-    );
-  }
-  reorderOpenResources(oldIndex, newIndex) {
-    const list = [...this.openResources$.getValue()];
-    if (oldIndex < 0 || oldIndex >= list.length || newIndex < 0 || newIndex >= list.length) {
-      return;
-    }
-    const [moved] = list.splice(oldIndex, 1);
-    if (moved) list.splice(newIndex, 0, moved);
-    this.openResources$.next(list);
-  }
-  // ── Auth callbacks bound per session ──────────────────────────────────
-  //
-  // These closures back the `refresh` and `validate` callbacks passed
-  // to `SemiontSession` in `setActiveKb`. Factored out as methods
-  // (rather than inline in the activation closure) so test-doubles
-  // can override them cleanly, and so the in-flight dedup map
-  // survives across activations of the same KB.
-  /**
-   * Refresh the active KB's access token. Returns the new token on
-   * success, null on failure. Concurrent calls for the same KB
-   * dedupe through `inFlightRefreshes`, so simultaneous 401s trigger
-   * only one `/api/tokens/refresh` round trip.
-   *
-   * Uses a throwaway `SemiontApiClient` with no `tokenRefresher` —
-   * a refresh call returning 401 would otherwise re-enter this
-   * function infinitely.
-   */
-  async performRefresh(kb) {
-    const existing = this.inFlightRefreshes.get(kb.id);
-    if (existing) return existing;
-    const promise = (async () => {
-      const stored = getStoredSession(this.storage, kb.id);
-      if (!stored) return null;
-      const throwaway = new SemiontApiClient({
-        baseUrl: baseUrl(kbBackendUrl(kb))
-      });
-      try {
-        const response = await throwaway.refreshToken(refreshToken(stored.refresh));
-        const newAccess = response.access_token;
-        if (!newAccess) return null;
-        setStoredSession(this.storage, kb.id, { access: newAccess, refresh: stored.refresh });
-        return newAccess;
-      } catch {
-        return null;
-      } finally {
-        throwaway.dispose();
-      }
-    })();
-    this.inFlightRefreshes.set(kb.id, promise);
-    try {
-      return await promise;
-    } finally {
-      this.inFlightRefreshes.delete(kb.id);
-    }
-  }
-  /**
-   * Validate an access token by calling `getMe` on a throwaway
-   * client. The session uses this once at startup to populate
-   * `user$`; 401 triggers a refresh-then-retry inside the session.
-   */
-  async performValidate(kb, token) {
-    const throwaway = new SemiontApiClient({
-      baseUrl: baseUrl(kbBackendUrl(kb))
-    });
-    try {
-      const data = await throwaway.getMe({ auth: token });
-      return data;
-    } finally {
-      throwaway.dispose();
-    }
-  }
-  // ── Lifecycle ─────────────────────────────────────────────────────────
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.unregisterNotify?.();
-    this.unregisterNotify = null;
-    if (this.unsubscribeStorage) {
-      this.unsubscribeStorage();
-      this.unsubscribeStorage = null;
-    }
-    const prevSession = this.activeSession$.getValue();
-    const prevSignals = this.activeSignals$.getValue();
-    this.activeSession$.next(null);
-    this.activeSignals$.next(null);
-    if (prevSession) await prevSession.dispose();
-    prevSignals?.dispose();
-    this.kbs$.complete();
-    this.activeKbId$.complete();
-    this.activeSession$.complete();
-    this.activeSignals$.complete();
-    this.openResources$.complete();
-    this.error$.complete();
-    this.identityToken$.complete();
-    this.eventBus.destroy();
-  }
-};
-
-// src/session/registry.ts
-var instance = null;
-function getBrowser(options) {
-  if (!instance) {
-    instance = new SemiontBrowser({ storage: options.storage });
-  }
-  return instance;
-}
-
-// src/session/session-storage.ts
-var InMemorySessionStorage = class {
-  map = /* @__PURE__ */ new Map();
-  get(key) {
-    return this.map.has(key) ? this.map.get(key) : null;
-  }
-  set(key, value) {
-    this.map.set(key, value);
-  }
-  delete(key) {
-    this.map.delete(key);
-  }
-};
-function createDisposer() {
-  const sub = new Subscription();
-  return {
-    add: (item) => sub.add(typeof item === "function" ? item : () => item.dispose()),
-    dispose: () => sub.unsubscribe()
-  };
-}
-function createSearchPipeline(fetch2, options = {}) {
-  const debounceMs = options.debounceMs ?? 250;
-  const initial = options.initialQuery ?? "";
-  const input$ = new Subject();
-  const query$ = input$.pipe(startWith(initial));
-  const state$ = input$.pipe(
-    startWith(initial),
-    debounceTime(debounceMs),
-    distinctUntilChanged$1(),
-    switchMap((q) => {
-      const trimmed = q.trim();
-      if (!trimmed) {
-        return of({ results: [], isSearching: false });
-      }
-      return fetch2(trimmed).pipe(
-        map((results) => ({
-          results: results ?? [],
-          isSearching: results === void 0
-        })),
-        startWith({ results: [], isSearching: true })
-      );
-    })
-  );
-  return {
-    query$,
-    state$,
-    setQuery: (value) => input$.next(value),
-    dispose: () => input$.complete()
-  };
-}
-function createBeckonVM(client) {
-  const subs = [];
-  const hovered$ = new BehaviorSubject(null);
-  subs.push(client.stream("beckon:hover").subscribe(({ annotationId }) => {
-    hovered$.next(annotationId);
-    if (annotationId) {
-      client.emit("beckon:sparkle", { annotationId });
-    }
-  }));
-  subs.push(client.stream("browse:click").subscribe(({ annotationId }) => {
-    client.emit("beckon:focus", { annotationId });
-  }));
-  return {
-    hoveredAnnotationId$: hovered$.asObservable(),
-    hover: (annotationId) => client.emit("beckon:hover", { annotationId }),
-    focus: (annotationId) => client.emit("beckon:focus", { annotationId }),
-    sparkle: (annotationId) => client.emit("beckon:sparkle", { annotationId }),
-    dispose() {
-      subs.forEach((s) => s.unsubscribe());
-      hovered$.complete();
-    }
-  };
-}
-var HOVER_DELAY_MS = 150;
-function createHoverHandlers(emit, delayMs) {
-  let currentHover = null;
-  let timer = null;
-  const cancelTimer = () => {
-    if (timer !== null) {
-      clearTimeout(timer);
-      timer = null;
-    }
-  };
-  const handleMouseEnter = (annotationId) => {
-    if (currentHover === annotationId) return;
-    cancelTimer();
-    timer = setTimeout(() => {
-      timer = null;
-      currentHover = annotationId;
-      emit(annotationId);
-    }, delayMs);
-  };
-  const handleMouseLeave = () => {
-    cancelTimer();
-    if (currentHover !== null) {
-      currentHover = null;
-      emit(null);
-    }
-  };
-  return { handleMouseEnter, handleMouseLeave, cleanup: cancelTimer };
-}
-var COMMON_PANELS = ["knowledge-base", "user", "settings"];
-var RESOURCE_PANELS = ["history", "info", "annotations", "collaboration", "jsonld"];
-var MOTIVATION_TO_TAB = {
-  "linking": "reference",
-  "commenting": "comment",
-  "tagging": "tag",
-  "highlighting": "highlight",
-  "assessing": "assessment"
-};
-var tabGenerationCounter = 0;
-function createShellVM(browser, options) {
-  const subs = [];
-  const activePanel$ = new BehaviorSubject(options?.initialPanel ?? null);
-  const scrollToAnnotationId$ = new BehaviorSubject(null);
-  const panelInitialTab$ = new BehaviorSubject(null);
-  if (options?.onPanelChange) {
-    const cb = options.onPanelChange;
-    subs.push(activePanel$.subscribe(cb));
-  }
-  subs.push(browser.stream("panel:toggle").subscribe(({ panel }) => {
-    const current = activePanel$.getValue();
-    activePanel$.next(current === panel ? null : panel);
-  }));
-  subs.push(browser.stream("panel:open").subscribe(({ panel, scrollToAnnotationId, motivation }) => {
-    if (scrollToAnnotationId) {
-      scrollToAnnotationId$.next(scrollToAnnotationId);
-    }
-    if (motivation) {
-      const tab = MOTIVATION_TO_TAB[motivation] || "highlight";
-      panelInitialTab$.next({ tab, generation: ++tabGenerationCounter });
-    }
-    activePanel$.next(panel);
-  }));
-  subs.push(browser.stream("panel:close").subscribe(() => {
-    activePanel$.next(null);
-  }));
-  return {
-    activePanel$: activePanel$.asObservable(),
-    scrollToAnnotationId$: scrollToAnnotationId$.asObservable(),
-    panelInitialTab$: panelInitialTab$.asObservable(),
-    openPanel: (panel) => browser.emit("panel:open", { panel }),
-    closePanel: () => browser.emit("panel:close", void 0),
-    togglePanel: (panel) => browser.emit("panel:toggle", { panel }),
-    onScrollCompleted: () => scrollToAnnotationId$.next(null),
-    dispose() {
-      subs.forEach((s) => s.unsubscribe());
-      activePanel$.complete();
-      scrollToAnnotationId$.complete();
-      panelInitialTab$.complete();
-    }
-  };
-}
-function createGatherVM(client, resourceId) {
-  const subs = [];
-  const context$ = new BehaviorSubject(null);
-  const loading$ = new BehaviorSubject(false);
-  const error$ = new BehaviorSubject(null);
-  const annotationId$ = new BehaviorSubject(null);
-  subs.push(client.stream("gather:requested").subscribe((event) => {
-    loading$.next(true);
-    error$.next(null);
-    context$.next(null);
-    annotationId$.next(annotationId(event.annotationId));
-    const gatherSub = client.gather.annotation(
-      annotationId(event.annotationId),
-      resourceId,
-      { contextWindow: event.options?.contextWindow ?? 2e3 }
-    ).pipe(
-      timeout(6e4)
-    ).subscribe({
-      next: (progress) => {
-        if ("response" in progress && progress.response) {
-          context$.next(
-            progress.response.context ?? null
-          );
-          loading$.next(false);
-        }
-      },
-      error: (err) => {
-        error$.next(err instanceof Error ? err : new Error(String(err)));
-        loading$.next(false);
-      },
-      complete: () => {
-        loading$.next(false);
-      }
-    });
-    subs.push(gatherSub);
-  }));
-  return {
-    context$: context$.asObservable(),
-    loading$: loading$.asObservable(),
-    error$: error$.asObservable(),
-    annotationId$: annotationId$.asObservable(),
-    dispose() {
-      subs.forEach((s) => s.unsubscribe());
-      context$.complete();
-      loading$.complete();
-      error$.complete();
-      annotationId$.complete();
-    }
-  };
-}
-function createMatchVM(client, _resourceId) {
-  const subs = [];
-  subs.push(client.stream("match:search-requested").subscribe((event) => {
-    const searchSub = client.match.search(
-      resourceId(event.resourceId),
-      event.referenceId,
-      event.context,
-      { limit: event.limit, useSemanticScoring: event.useSemanticScoring }
-    ).pipe(
-      timeout(6e4)
-    ).subscribe({
-      next: (result) => client.emit("match:search-results", result),
-      error: (err) => client.emit("match:search-failed", {
-        correlationId: event.correlationId,
-        referenceId: event.referenceId,
-        error: err instanceof Error ? err.message : String(err)
-      })
-    });
-    subs.push(searchSub);
-  }));
-  return {
-    dispose() {
-      subs.forEach((s) => s.unsubscribe());
-    }
-  };
-}
-function createYieldVM(client, resourceId$1, locale) {
-  const subs = [];
-  const isGenerating$ = new BehaviorSubject(false);
-  const progress$ = new BehaviorSubject(null);
-  let clearTimer = null;
-  const generate = (referenceId, options) => {
-    const genSub = client.yield.fromAnnotation(
-      resourceId(resourceId$1),
-      annotationId(referenceId),
-      { ...options, language: options.language || locale }
-    ).pipe(
-      timeout({ each: 3e5 })
-    ).subscribe({
-      next: (chunk) => {
-        progress$.next(chunk);
-        isGenerating$.next(true);
-      },
-      complete: () => {
-        isGenerating$.next(false);
-        if (clearTimer) clearTimeout(clearTimer);
-        clearTimer = setTimeout(() => {
-          progress$.next(null);
-          clearTimer = null;
-        }, 2e3);
-      },
-      error: () => {
-        progress$.next(null);
-        isGenerating$.next(false);
-      }
-    });
-    subs.push(genSub);
-  };
-  return {
-    isGenerating$: isGenerating$.asObservable(),
-    progress$: progress$.asObservable(),
-    generate,
-    dispose() {
-      subs.forEach((s) => s.unsubscribe());
-      if (clearTimer) clearTimeout(clearTimer);
-      isGenerating$.complete();
-      progress$.complete();
-    }
-  };
-}
-function selectionToSelector(selection) {
-  if (selection.svgSelector) return { type: "SvgSelector", value: selection.svgSelector };
-  if (selection.fragmentSelector) {
-    const selectors = [{ type: "FragmentSelector", value: selection.fragmentSelector, ...selection.conformsTo && { conformsTo: selection.conformsTo } }];
-    if (selection.exact) selectors.push({ type: "TextQuoteSelector", exact: selection.exact, ...selection.prefix && { prefix: selection.prefix }, ...selection.suffix && { suffix: selection.suffix } });
-    return selectors;
-  }
-  return { type: "TextQuoteSelector", exact: selection.exact, ...selection.prefix && { prefix: selection.prefix }, ...selection.suffix && { suffix: selection.suffix } };
-}
-function createMarkVM(client, resourceId) {
-  const subs = [];
-  const pendingAnnotation$ = new BehaviorSubject(null);
-  const assistingMotivation$ = new BehaviorSubject(null);
-  const progress$ = new BehaviorSubject(null);
-  let progressDismissTimer = null;
-  const clearProgressTimer = () => {
-    if (progressDismissTimer) {
-      clearTimeout(progressDismissTimer);
-      progressDismissTimer = null;
-    }
-  };
-  const handleAnnotationRequested = (pending) => {
-    pendingAnnotation$.next(pending);
-  };
-  subs.push(client.stream("mark:requested").subscribe(handleAnnotationRequested));
-  subs.push(client.stream("mark:select-comment").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "commenting" })));
-  subs.push(client.stream("mark:select-tag").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "tagging" })));
-  subs.push(client.stream("mark:select-assessment").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "assessing" })));
-  subs.push(client.stream("mark:select-reference").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "linking" })));
-  subs.push(client.stream("mark:cancel-pending").subscribe(() => pendingAnnotation$.next(null)));
-  subs.push(client.stream("mark:create-ok").subscribe(() => pendingAnnotation$.next(null)));
-  subs.push(client.stream("mark:submit").subscribe(async (event) => {
-    try {
-      const result = await client.mark.annotation(resourceId, {
-        motivation: event.motivation,
-        target: { source: resourceId, selector: event.selector },
-        body: event.body
-      });
-      client.emit("mark:create-ok", { annotationId: result.annotationId });
-    } catch (error) {
-      client.emit("mark:create-failed", { message: error instanceof Error ? error.message : String(error) });
-    }
-  }));
-  subs.push(client.stream("mark:delete").subscribe(async (event) => {
-    try {
-      await client.mark.delete(resourceId, event.annotationId);
-      client.emit("mark:delete-ok", { annotationId: event.annotationId });
-    } catch (error) {
-      client.emit("mark:delete-failed", { message: error instanceof Error ? error.message : String(error) });
-    }
-  }));
-  subs.push(client.stream("mark:assist-request").subscribe((event) => {
-    clearProgressTimer();
-    assistingMotivation$.next(event.motivation);
-    progress$.next(null);
-    const assistSub = client.mark.assist(resourceId, event.motivation, event.options).pipe(
-      timeout({ each: 18e4 })
-    ).subscribe({
-      next: (p) => progress$.next(p),
-      complete: () => {
-        assistingMotivation$.next(null);
-        clearProgressTimer();
-        progressDismissTimer = setTimeout(() => {
-          progress$.next(null);
-          progressDismissTimer = null;
-        }, 5e3);
-      },
-      error: () => {
-        clearProgressTimer();
-        assistingMotivation$.next(null);
-        progress$.next(null);
-      }
-    });
-    subs.push(assistSub);
-  }));
-  subs.push(client.stream("mark:progress-dismiss").subscribe(() => {
-    clearProgressTimer();
-    progress$.next(null);
-  }));
-  return {
-    pendingAnnotation$: pendingAnnotation$.asObservable(),
-    assistingMotivation$: assistingMotivation$.asObservable(),
-    progress$: progress$.asObservable(),
-    dispose() {
-      subs.forEach((s) => s.unsubscribe());
-      clearProgressTimer();
-      pendingAnnotation$.complete();
-      assistingMotivation$.complete();
-      progress$.complete();
-    }
-  };
-}
-var RECENT_LIMIT = 10;
-var SEARCH_LIMIT = 20;
-function createDiscoverVM(client, browse) {
-  const disposer = createDisposer();
-  const search = createSearchPipeline(
-    (q) => client.browse.resources({ search: q, limit: SEARCH_LIMIT })
-  );
-  disposer.add(search);
-  disposer.add(browse);
-  const recent$ = client.browse.resources({ limit: RECENT_LIMIT, archived: false });
-  const recentResources$ = recent$.pipe(
-    map$1((r) => r ?? [])
-  );
-  const isLoadingRecent$ = recent$.pipe(
-    map$1((r) => r === void 0)
-  );
-  const entityTypes$ = client.browse.entityTypes().pipe(
-    map$1((e) => e ?? [])
-  );
-  return {
-    browse,
-    search,
-    recentResources$,
-    entityTypes$,
-    isLoadingRecent$,
-    dispose: () => disposer.dispose()
-  };
-}
-function createEntityTagsVM(client, browse) {
-  const disposer = createDisposer();
-  disposer.add(browse);
-  const newTag$ = new BehaviorSubject("");
-  const error$ = new BehaviorSubject("");
-  const isAdding$ = new BehaviorSubject(false);
-  const raw$ = client.browse.entityTypes();
-  const entityTypes$ = raw$.pipe(map$1((e) => e ?? []));
-  const isLoading$ = raw$.pipe(map$1((e) => e === void 0));
-  const addTag = async () => {
-    const tag = newTag$.getValue().trim();
-    if (!tag) return;
-    error$.next("");
-    isAdding$.next(true);
-    try {
-      await client.mark.entityType(tag);
-      newTag$.next("");
-    } catch (err) {
-      error$.next(err instanceof Error ? err.message : "Failed to add entity type");
-    } finally {
-      isAdding$.next(false);
-    }
-  };
-  return {
-    browse,
-    entityTypes$,
-    isLoading$,
-    newTag$: newTag$.asObservable(),
-    error$: error$.asObservable(),
-    isAdding$: isAdding$.asObservable(),
-    setNewTag: (v) => newTag$.next(v),
-    addTag,
-    dispose: () => {
-      newTag$.complete();
-      error$.complete();
-      isAdding$.complete();
-      disposer.dispose();
-    }
-  };
-}
-function createExchangeVM(browse, exportFn, importFn) {
-  const disposer = createDisposer();
-  disposer.add(browse);
-  const selectedFile$ = new BehaviorSubject(null);
-  const preview$ = new BehaviorSubject(null);
-  const importPhase$ = new BehaviorSubject(null);
-  const importMessage$ = new BehaviorSubject(void 0);
-  const importResult$ = new BehaviorSubject(void 0);
-  const isExporting$ = new BehaviorSubject(false);
-  const isImporting$ = new BehaviorSubject(false);
-  const selectFile = (file) => {
-    selectedFile$.next(file);
-    importPhase$.next(null);
-    importMessage$.next(void 0);
-    importResult$.next(void 0);
-    preview$.next({
-      format: file.name.endsWith(".tar.gz") || file.name.endsWith(".gz") ? "semiont-linked-data" : "unknown",
-      version: 1,
-      sourceUrl: "",
-      stats: {}
-    });
-  };
-  const cancelImport = () => {
-    selectedFile$.next(null);
-    preview$.next(null);
-    importPhase$.next(null);
-    importMessage$.next(void 0);
-    importResult$.next(void 0);
-  };
-  const doExport = async () => {
-    isExporting$.next(true);
-    try {
-      const response = await exportFn();
-      if (!response.ok) throw new Error(`Export failed: ${response.status} ${response.statusText}`);
-      const blob = await response.blob();
-      const contentDisposition = response.headers.get("Content-Disposition");
-      const filename = contentDisposition?.match(/filename="(.+?)"/)?.[1] ?? `semiont-export-${Date.now()}.tar.gz`;
-      return { blob, filename };
-    } finally {
-      isExporting$.next(false);
-    }
-  };
-  const doImport = async () => {
-    const file = selectedFile$.getValue();
-    if (!file) return;
-    isImporting$.next(true);
-    importPhase$.next("started");
-    importMessage$.next(void 0);
-    importResult$.next(void 0);
-    try {
-      await importFn(file, {
-        onProgress: (event) => {
-          importPhase$.next(event.phase);
-          importMessage$.next(event.message);
-          if (event.result) importResult$.next(event.result);
-        }
-      });
-    } finally {
-      isImporting$.next(false);
-    }
-  };
-  return {
-    browse,
-    selectedFile$: selectedFile$.asObservable(),
-    preview$: preview$.asObservable(),
-    importPhase$: importPhase$.asObservable(),
-    importMessage$: importMessage$.asObservable(),
-    importResult$: importResult$.asObservable(),
-    isExporting$: isExporting$.asObservable(),
-    isImporting$: isImporting$.asObservable(),
-    selectFile,
-    cancelImport,
-    doExport,
-    doImport,
-    dispose: () => {
-      selectedFile$.complete();
-      preview$.complete();
-      importPhase$.complete();
-      importMessage$.complete();
-      importResult$.complete();
-      isExporting$.complete();
-      isImporting$.complete();
-      disposer.dispose();
-    }
-  };
-}
-function createAdminUsersVM(client, browse) {
-  const disposer = createDisposer();
-  disposer.add(browse);
-  const users$ = new BehaviorSubject([]);
-  const stats$ = new BehaviorSubject(null);
-  const usersLoading$ = new BehaviorSubject(true);
-  const statsLoading$ = new BehaviorSubject(true);
-  const fetchUsers = () => {
-    usersLoading$.next(true);
-    client.listUsers().then((data) => {
-      users$.next(data.users ?? []);
-      usersLoading$.next(false);
-    }).catch(() => usersLoading$.next(false));
-  };
-  const fetchStats = () => {
-    statsLoading$.next(true);
-    client.getUserStats().then((data) => {
-      stats$.next(data.stats ?? null);
-      statsLoading$.next(false);
-    }).catch(() => statsLoading$.next(false));
-  };
-  fetchUsers();
-  fetchStats();
-  const updateUser = async (id, data) => {
-    await client.updateUser(userDID(id), data);
-    fetchUsers();
-    fetchStats();
-  };
-  return {
-    browse,
-    users$: users$.asObservable(),
-    stats$: stats$.asObservable(),
-    usersLoading$: usersLoading$.asObservable(),
-    statsLoading$: statsLoading$.asObservable(),
-    updateUser,
-    dispose: () => {
-      users$.complete();
-      stats$.complete();
-      usersLoading$.complete();
-      statsLoading$.complete();
-      disposer.dispose();
-    }
-  };
-}
-function createAdminSecurityVM(client, browse) {
-  const disposer = createDisposer();
-  disposer.add(browse);
-  const providers$ = new BehaviorSubject([]);
-  const allowedDomains$ = new BehaviorSubject([]);
-  const isLoading$ = new BehaviorSubject(true);
-  client.getOAuthConfig().then((data) => {
-    const config = data;
-    providers$.next(config.providers ?? []);
-    allowedDomains$.next(config.allowedDomains ?? []);
-    isLoading$.next(false);
-  }).catch(() => isLoading$.next(false));
-  return {
-    browse,
-    providers$: providers$.asObservable(),
-    allowedDomains$: allowedDomains$.asObservable(),
-    isLoading$: isLoading$.asObservable(),
-    dispose: () => {
-      providers$.complete();
-      allowedDomains$.complete();
-      isLoading$.complete();
-      disposer.dispose();
-    }
-  };
-}
-function createWelcomeVM(client) {
-  const disposer = createDisposer();
-  const userData$ = new BehaviorSubject(null);
-  const isProcessing$ = new BehaviorSubject(false);
-  client.getMe().then((data) => userData$.next(data)).catch(() => {
-  });
-  const acceptTerms = async () => {
-    isProcessing$.next(true);
-    try {
-      await client.acceptTerms();
-      userData$.next({ ...userData$.getValue(), termsAcceptedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    } finally {
-      isProcessing$.next(false);
-    }
-  };
-  return {
-    userData$: userData$.asObservable(),
-    isProcessing$: isProcessing$.asObservable(),
-    acceptTerms,
-    dispose: () => {
-      userData$.complete();
-      isProcessing$.complete();
-      disposer.dispose();
-    }
-  };
-}
-function createResourceLoaderVM(client, resourceId) {
-  const raw$ = client.browse.resource(resourceId);
-  const resource$ = raw$;
-  const isLoading$ = raw$.pipe(map$1((r) => r === void 0));
-  return {
-    resource$,
-    isLoading$,
-    invalidate: () => client.browse.invalidateResourceDetail(resourceId),
-    dispose: () => {
-    }
-  };
-}
-function createSessionVM(client) {
-  const isLoggingOut$ = new BehaviorSubject(false);
-  const logout = async () => {
-    isLoggingOut$.next(true);
-    try {
-      await client.logout();
-    } catch {
-    } finally {
-      isLoggingOut$.next(false);
-    }
-  };
-  return {
-    isLoggingOut$: isLoggingOut$.asObservable(),
-    logout,
-    dispose: () => {
-      isLoggingOut$.complete();
-    }
-  };
-}
-var SMELTER_CHANNELS = [
-  "yield:created",
-  "yield:updated",
-  "yield:representation-added",
-  "mark:archived",
-  "mark:added",
-  "mark:removed"
-];
-function createSmelterActorVM(options) {
-  const actor = createActorVM({
-    baseUrl: options.baseUrl,
-    token: options.token,
-    channels: [...SMELTER_CHANNELS],
-    reconnectMs: options.reconnectMs
-  });
-  const events$ = merge(
-    ...SMELTER_CHANNELS.map(
-      (channel) => actor.on$(channel).pipe(
-        map((payload) => ({
-          type: channel,
-          resourceId: payload.resourceId,
-          payload
-        }))
-      )
-    )
-  );
-  return {
-    events$,
-    state$: actor.state$,
-    emit: (channel, payload) => actor.emit(channel, payload),
-    start: () => actor.start(),
-    stop: () => actor.stop(),
-    dispose: () => actor.dispose()
-  };
-}
-function createJobClaimAdapter(options) {
-  const { actor, jobTypes } = options;
-  const activeJob$ = new BehaviorSubject(null);
-  const isProcessing$ = new BehaviorSubject(false);
-  const jobsCompleted$ = new BehaviorSubject(0);
-  const errors$ = new Subject();
-  let jobSubscription = null;
-  let started = false;
-  const claimJob = async (assignment) => {
-    try {
-      const correlationId = crypto.randomUUID();
-      const result$ = merge(
-        actor.on$("job:claimed").pipe(
-          filter$1((e) => e.correlationId === correlationId),
-          map$1((e) => ({ ok: true, response: e.response }))
-        ),
-        actor.on$("job:claim-failed").pipe(
-          filter$1((e) => e.correlationId === correlationId),
-          map$1(() => ({ ok: false }))
-        )
-      ).pipe(take$1(1), timeout$1(1e4));
-      const resultPromise = firstValueFrom(result$);
-      await actor.emit("job:claim", { correlationId, jobId: assignment.jobId });
-      const result = await resultPromise;
-      if (!result.ok) return null;
-      const job = result.response;
-      return {
-        jobId: assignment.jobId,
-        type: assignment.type,
-        resourceId: assignment.resourceId,
-        userId: job.metadata?.userId ?? "",
-        params: job.params ?? {}
-      };
-    } catch {
-      return null;
-    }
-  };
-  return {
-    activeJob$: activeJob$.asObservable(),
-    isProcessing$: isProcessing$.asObservable(),
-    jobsCompleted$: jobsCompleted$.asObservable(),
-    errors$: errors$.asObservable(),
-    start: () => {
-      if (started) return;
-      started = true;
-      actor.addChannels(["job:queued"]);
-      jobSubscription = actor.on$("job:queued").subscribe((event) => {
-        const jobType = event.jobType;
-        if (jobTypes.length > 0 && !jobTypes.includes(jobType)) return;
-        if (isProcessing$.getValue()) return;
-        isProcessing$.next(true);
-        claimJob({ jobId: event.jobId, type: jobType, resourceId: event.resourceId }).then((job) => {
-          if (job) {
-            activeJob$.next(job);
-          } else {
-            isProcessing$.next(false);
-          }
-        }).catch(() => {
-          isProcessing$.next(false);
-        });
-      });
-    },
-    stop: () => {
-      jobSubscription?.unsubscribe();
-      jobSubscription = null;
-      started = false;
-    },
-    completeJob: () => {
-      activeJob$.next(null);
-      isProcessing$.next(false);
-      jobsCompleted$.next(jobsCompleted$.getValue() + 1);
-    },
-    failJob: (jid, error) => {
-      activeJob$.next(null);
-      isProcessing$.next(false);
-      errors$.next({ jobId: jid, error });
-    },
-    dispose: () => {
-      jobSubscription?.unsubscribe();
-      jobSubscription = null;
-      started = false;
-      activeJob$.complete();
-      isProcessing$.complete();
-      jobsCompleted$.complete();
-      errors$.complete();
-    }
-  };
-}
-function createJobQueueVM(client) {
-  const jobs$ = new BehaviorSubject([]);
-  const jobCreated$ = new Subject();
-  const jobCompleted$ = new Subject();
-  const jobFailed$ = new Subject();
-  const pendingByType$ = jobs$.pipe(
-    map$1((all) => {
-      const counts = /* @__PURE__ */ new Map();
-      for (const j of all) {
-        if (j.status === "pending") {
-          counts.set(j.type, (counts.get(j.type) ?? 0) + 1);
-        }
-      }
-      return counts;
-    })
-  );
-  const runningJobs$ = jobs$.pipe(
-    map$1((all) => all.filter((j) => j.status === "running"))
-  );
-  const addOrUpdate = (job) => {
-    const current = jobs$.getValue();
-    const idx = current.findIndex((j) => j.jobId === job.jobId);
-    if (idx >= 0) {
-      const next = [...current];
-      next[idx] = job;
-      jobs$.next(next);
-    } else {
-      jobs$.next([...current, job]);
-    }
-  };
-  const subs = [
-    client.stream("job:queued").subscribe((event) => {
-      const job = {
-        jobId: event.jobId,
-        type: event.jobType,
-        status: "pending",
-        resourceId: event.resourceId ?? "",
-        userId: "",
-        created: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      addOrUpdate(job);
-      jobCreated$.next(job);
-    }),
-    client.stream("job:complete").subscribe((event) => {
-      const job = {
-        jobId: event.jobId,
-        type: event.jobType ?? "",
-        status: "complete",
-        resourceId: event.resourceId ?? "",
-        userId: event.userId ?? "",
-        created: "",
-        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        result: event.result
-      };
-      addOrUpdate(job);
-      jobCompleted$.next(job);
-    }),
-    client.stream("job:fail").subscribe((event) => {
-      const job = {
-        jobId: event.jobId,
-        type: event.jobType ?? "",
-        status: "failed",
-        resourceId: event.resourceId ?? "",
-        userId: event.userId ?? "",
-        created: "",
-        completedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        error: event.error ?? "Unknown error"
-      };
-      addOrUpdate(job);
-      jobFailed$.next(job);
-    })
-  ];
-  return {
-    jobs$: jobs$.asObservable(),
-    pendingByType$,
-    runningJobs$,
-    jobCreated$: jobCreated$.asObservable(),
-    jobCompleted$: jobCompleted$.asObservable(),
-    jobFailed$: jobFailed$.asObservable(),
-    dispose: () => {
-      subs.forEach((s) => s.unsubscribe());
-      jobs$.complete();
-      jobCreated$.complete();
-      jobCompleted$.complete();
-      jobFailed$.complete();
-    }
-  };
-}
-
-// 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);
-}
-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;
-        }
-      }
-    }
-    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/view-models/pages/resource-viewer-page-vm.ts
-var WIZARD_CLOSED = {
-  open: false,
-  annotationId: null,
-  resourceId: null,
-  defaultTitle: "",
-  entityTypes: []
-};
-function createResourceViewerPageVM(client, resourceId, locale, browse, options) {
-  const disposer = createDisposer();
-  const beckon = createBeckonVM(client);
-  const mark = createMarkVM(client, resourceId);
-  const gather = createGatherVM(client, resourceId);
-  const matchVM = createMatchVM(client);
-  const yieldVM = createYieldVM(client, resourceId, locale);
-  disposer.add(beckon);
-  disposer.add(browse);
-  disposer.add(mark);
-  disposer.add(gather);
-  disposer.add(matchVM);
-  disposer.add(yieldVM);
-  const annotations$ = client.browse.annotations(resourceId).pipe(
-    map$1((a) => a ?? [])
-  );
-  const annotationGroups$ = annotations$.pipe(
-    map$1((anns) => {
-      const groups = { highlights: [], comments: [], assessments: [], references: [], tags: [] };
-      for (const ann of anns) {
-        if (isHighlight(ann)) groups.highlights.push(ann);
-        else if (isComment(ann)) groups.comments.push(ann);
-        else if (isAssessment(ann)) groups.assessments.push(ann);
-        else if (isReference(ann)) groups.references.push(ann);
-        else if (isTag(ann)) groups.tags.push(ann);
-      }
-      return groups;
-    })
-  );
-  const entityTypes$ = client.browse.entityTypes().pipe(
-    map$1((e) => e ?? [])
-  );
-  const events$ = client.browse.events(resourceId).pipe(
-    map$1((e) => e ?? [])
-  );
-  const referencedBy$ = client.browse.referencedBy(resourceId).pipe(
-    map$1((r) => r ?? [])
-  );
-  const content$ = new BehaviorSubject("");
-  const contentLoading$ = new BehaviorSubject(false);
-  const mediaToken$ = new BehaviorSubject(null);
-  const mediaType = options?.mediaType || "text/plain";
-  const isBinaryType = mediaType.startsWith("image/") || mediaType === "application/pdf";
-  if (!isBinaryType && mediaType) {
-    contentLoading$.next(true);
-    client.browse.resourceRepresentation(resourceId, { accept: mediaType }).then(({ data }) => {
-      content$.next(decodeWithCharset(data, mediaType));
-      contentLoading$.next(false);
-    }).catch(() => {
-      contentLoading$.next(false);
-    });
-  }
-  if (isBinaryType) {
-    client.auth.mediaToken(resourceId).then(({ token }) => mediaToken$.next(token)).catch(() => {
-    });
-  }
-  const wizard$ = new BehaviorSubject(WIZARD_CLOSED);
-  const unsubscribeResource = client.subscribeToResource(resourceId);
-  disposer.add(unsubscribeResource);
-  const bindInitiateSub = client.stream("bind:initiate").subscribe((event) => {
-    wizard$.next({
-      open: true,
-      annotationId: event.annotationId,
-      resourceId: event.resourceId,
-      defaultTitle: event.defaultTitle,
-      entityTypes: event.entityTypes
-    });
-    client.emit("gather:requested", {
-      correlationId: crypto.randomUUID(),
-      annotationId: event.annotationId,
-      resourceId: event.resourceId,
-      options: { contextWindow: 2e3 }
-    });
-  });
-  disposer.add(() => bindInitiateSub.unsubscribe());
-  return {
-    beckon,
-    browse,
-    mark,
-    gather,
-    yield: yieldVM,
-    annotations$,
-    annotationGroups$,
-    entityTypes$,
-    events$,
-    referencedBy$,
-    content$: content$.asObservable(),
-    contentLoading$: contentLoading$.asObservable(),
-    mediaToken$: mediaToken$.asObservable(),
-    wizard$: wizard$.asObservable(),
-    closeWizard: () => wizard$.next(WIZARD_CLOSED),
-    dispose: () => {
-      wizard$.complete();
-      content$.complete();
-      contentLoading$.complete();
-      mediaToken$.complete();
-      disposer.dispose();
-    }
-  };
-}
-
-// 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);
-  }
-  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;
-      }
-      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/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"
-      };
-    }
-  }
-};
-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/view-models/pages/compose-page-vm.ts
-function createComposePageVM(client, browse, params, auth) {
-  const disposer = createDisposer();
-  disposer.add(browse);
-  const isReferenceMode = Boolean(params.annotationUri && params.sourceDocumentId && params.name);
-  const isCloneMode = params.mode === "clone" && Boolean(params.token);
-  const pageMode = isCloneMode ? "clone" : isReferenceMode ? "reference" : "new";
-  const mode$ = new BehaviorSubject(pageMode);
-  const loading$ = new BehaviorSubject(true);
-  const cloneData$ = new BehaviorSubject(null);
-  const referenceData$ = new BehaviorSubject(null);
-  const gatheredContext$ = new BehaviorSubject(null);
-  const entityTypes$ = client.browse.entityTypes().pipe(
-    map$1((e) => e ?? [])
-  );
-  if (isReferenceMode) {
-    const entityTypes = params.entityTypes ? params.entityTypes.split(",") : [];
-    referenceData$.next({
-      annotationUri: params.annotationUri,
-      sourceDocumentId: params.sourceDocumentId,
-      name: params.name,
-      entityTypes
-    });
-    if (params.storedContext) {
-      try {
-        gatheredContext$.next(JSON.parse(params.storedContext));
-      } catch {
-      }
-    }
-    loading$.next(false);
-  } else if (isCloneMode) {
-    void (async () => {
-      try {
-        const tokenResult = await client.yield.fromToken(params.token);
-        if (tokenResult && auth) {
-          const rId = resourceId(tokenResult["@id"]);
-          const mediaType = getPrimaryMediaType(tokenResult) || "text/plain";
-          const { data } = await client.getResourceRepresentation(rId, {
-            accept: mediaType,
-            auth
-          });
-          const content = decodeWithCharset(data, mediaType);
-          cloneData$.next({ sourceResource: tokenResult, sourceContent: content });
-        }
-      } catch {
-      }
-      loading$.next(false);
-    })();
-  } else {
-    loading$.next(false);
-  }
-  const save = async (saveParams) => {
-    if (saveParams.mode === "clone") {
-      const response2 = await client.yield.createFromToken({
-        token: params.token,
-        name: saveParams.name,
-        content: saveParams.content,
-        archiveOriginal: saveParams.archiveOriginal ?? true
-      });
-      return response2.resourceId;
-    }
-    let fileToUpload;
-    let mimeType;
-    if (saveParams.file) {
-      fileToUpload = saveParams.file;
-      mimeType = saveParams.format ?? "application/octet-stream";
-    } else {
-      const blob = new Blob([saveParams.content || ""], { type: saveParams.format ?? "application/octet-stream" });
-      const extension = saveParams.format === "text/plain" ? ".txt" : saveParams.format === "text/html" ? ".html" : ".md";
-      fileToUpload = new File([blob], saveParams.name + extension, { type: saveParams.format ?? "application/octet-stream" });
-      mimeType = saveParams.format ?? "application/octet-stream";
-    }
-    const format = saveParams.charset && !saveParams.file ? `${mimeType}; charset=${saveParams.charset}` : mimeType;
-    const response = await client.yield.resource({
-      name: saveParams.name,
-      file: fileToUpload,
-      format,
-      entityTypes: saveParams.entityTypes || [],
-      language: saveParams.language,
-      creationMethod: "ui",
-      storageUri: saveParams.storageUri
-    });
-    const newResourceId = response.resourceId;
-    if (saveParams.mode === "reference" && saveParams.annotationUri && saveParams.sourceDocumentId) {
-      await client.bind.body(
-        resourceId(saveParams.sourceDocumentId),
-        annotationId(saveParams.annotationUri),
-        [{ op: "add", item: { type: "SpecificResource", source: newResourceId, purpose: "linking" } }]
-      );
-    }
-    return newResourceId;
-  };
-  return {
-    browse,
-    mode$: mode$.asObservable(),
-    loading$: loading$.asObservable(),
-    cloneData$: cloneData$.asObservable(),
-    referenceData$: referenceData$.asObservable(),
-    gatheredContext$: gatheredContext$.asObservable(),
-    entityTypes$,
-    save,
-    dispose: () => {
-      mode$.complete();
-      loading$.complete();
-      cloneData$.complete();
-      referenceData$.complete();
-      gatheredContext$.complete();
-      disposer.dispose();
-    }
-  };
-}
-
-// src/mime-utils.ts
-function getExtensionForMimeType(mimeType) {
-  const map15 = {
-    "text/plain": "txt",
-    "text/markdown": "md",
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "application/pdf": "pdf"
-  };
-  return map15[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, BusRequestError, COMMON_PANELS, DEGRADED_THRESHOLD_MS, FrontendSessionSignals, GatherNamespace, HOVER_DELAY_MS, InMemorySessionStorage, JWTTokenSchema, JobNamespace, LOCALES, MarkNamespace, MatchNamespace, RESOURCE_PANELS, SemiontApiClient, SemiontBrowser, SemiontError, SemiontSession, YieldNamespace, buildContentCache, busRequest, createActorVM, createAdminSecurityVM, createAdminUsersVM, createBeckonVM, createCache, createCircleSvg, createComposePageVM, createDiscoverVM, createDisposer, createEntityTagsVM, createExchangeVM, createGatherVM, createHoverHandlers, createJobClaimAdapter, createJobQueueVM, createMarkVM, createMatchVM, createPolygonSvg, createRectangleSvg, createResourceLoaderVM, createResourceViewerPageVM, createSearchPipeline, createSessionVM, createShellVM, createSmelterActorVM, createWelcomeVM, createYieldVM, decodeRepresentation, decodeWithCharset, defaultProtocol, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findTextWithContext, formatLocaleDisplay, getAllLocaleCodes, getAnnotationExactText, getBodySource, getBodyType, getBrowser, 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, isValidHostname, kbBackendUrl, normalizeCoordinates, normalizeText, notifyPermissionDenied, notifySessionExpired, parseSvgSelector, scaleSvgToNative, setStoredSession, validateAndCorrectOffsets, validateData, verifyPosition };
+export { APIError, DEGRADED_THRESHOLD_MS, HttpContentTransport, HttpTransport, createActorVM };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map