@semiont/sdk 0.4.21

package/dist/index.js

@@ -0,0 +1,3030 @@
+import { annotationId, resourceId, email, googleCredential, refreshToken, EventBus, accessToken, baseUrl, isHighlight, isComment, isAssessment, isReference, isTag, decodeWithCharset, getPrimaryMediaType, userDID, searchQuery } from '@semiont/core';
+import { merge, firstValueFrom, BehaviorSubject, map as map$1, distinctUntilChanged, Observable, Subject, Subscription, of, filter as filter$1, take as take$1, timeout as timeout$1 } from 'rxjs';
+import { filter, map, take, timeout, takeUntil, startWith, debounceTime, distinctUntilChanged as distinctUntilChanged$1, switchMap } from 'rxjs/operators';
+import { HttpTransport, HttpContentTransport, createActorVM, APIError } from '@semiont/api-client';
+export { APIError, DEGRADED_THRESHOLD_MS, HttpContentTransport, HttpTransport, createActorVM } from '@semiont/api-client';
+
+// src/client.ts
+var BusRequestError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BusRequestError";
+  }
+};
+async function busRequest(bus, emitChannel, payload, resultChannel, failureChannel, timeoutMs = 3e4) {
+  const correlationId = crypto.randomUUID();
+  const fullPayload = { ...payload, correlationId };
+  const result$ = merge(
+    bus.stream(resultChannel).pipe(
+      filter((e) => e.correlationId === correlationId),
+      map((e) => ({ ok: true, response: e.response }))
+    ),
+    bus.stream(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 bus.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);
+      }
+    },
+    dispose() {
+      store$.complete();
+      obsCache.clear();
+      inflight.clear();
+    }
+  };
+}
+
+// src/namespaces/browse.ts
+var ENTITY_TYPES_KEY = "_";
+var BrowseNamespace = class {
+  constructor(transport, bus, content) {
+    this.transport = transport;
+    this.bus = bus;
+    this.content = content;
+    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.transport,
+        "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.transport,
+        "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.transport,
+        "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`);
+      }
+      const result = await busRequest(
+        this.transport,
+        "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.transport,
+        "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.transport,
+        "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.transport,
+        "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`.
+  //
+  // 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();
+  // ── 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);
+    }
+    return obs;
+  }
+  annotation(resourceId, annotationId) {
+    this.annotationResources.set(annotationId, resourceId);
+    return this.annotationDetailCache.observe(annotationId);
+  }
+  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__;
+  }
+  referencedBy(resourceId) {
+    return this.referencedByCache.observe(resourceId);
+  }
+  events(resourceId) {
+    return this.resourceEventsCache.observe(resourceId);
+  }
+  // ── One-shot reads ──────────────────────────────────────────────────────
+  async resourceContent(resourceId) {
+    const result = await this.content.getBinary(resourceId, { accept: "text/plain" });
+    const decoder = new TextDecoder();
+    return decoder.decode(result.data);
+  }
+  async resourceRepresentation(resourceId, options) {
+    return this.content.getBinary(resourceId, options?.accept ? { accept: options.accept } : void 0);
+  }
+  async resourceRepresentationStream(resourceId, options) {
+    return this.content.getBinaryStream(resourceId, options?.accept ? { accept: options.accept } : void 0);
+  }
+  async resourceEvents(resourceId) {
+    const result = await busRequest(
+      this.transport,
+      "browse:events-requested",
+      { resourceId },
+      "browse:events-result",
+      "browse:events-failed"
+    );
+    return result.events;
+  }
+  async annotationHistory(resourceId, annotationId) {
+    return busRequest(
+      this.transport,
+      "browse:annotation-history-requested",
+      { resourceId, annotationId },
+      "browse:annotation-history-result",
+      "browse:annotation-history-failed"
+    );
+  }
+  async connections(_resourceId) {
+    throw new Error("Not implemented: connections endpoint does not exist yet");
+  }
+  async backlinks(_resourceId) {
+    throw new Error("Not implemented: backlinks endpoint does not exist yet");
+  }
+  async resourcesByName(_query, _limit) {
+    throw new Error("Not implemented: resourcesByName endpoint does not exist yet");
+  }
+  async files(dirPath, sort) {
+    return busRequest(
+      this.transport,
+      "browse:directory-requested",
+      { path: dirPath ?? ".", sort: sort ?? "name" },
+      "browse:directory-result",
+      "browse:directory-failed"
+    );
+  }
+  // ── UI signals (local bus fan-out) ────────────────────────────────────
+  click(annotationId, motivation) {
+    this.bus.get("browse:click").next({ annotationId, motivation });
+  }
+  navigateReference(resourceId) {
+    this.bus.get("browse:reference-navigate").next({ resourceId });
+  }
+  // ── 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);
+  }
+  removeAnnotationDetail(annotationId) {
+    this.annotationDetailCache.remove(annotationId);
+    this.annotationResources.delete(annotationId);
+  }
+  invalidateResourceDetail(id) {
+    this.resourceCache.invalidate(id);
+  }
+  invalidateResourceLists() {
+    this.resourceListCache.invalidateAll();
+  }
+  invalidateEntityTypes() {
+    this.entityTypesCache.invalidate(ENTITY_TYPES_KEY);
+  }
+  invalidateReferencedBy(resourceId) {
+    this.referencedByCache.invalidate(resourceId);
+  }
+  invalidateResourceEvents(resourceId) {
+    this.resourceEventsCache.invalidate(resourceId);
+  }
+  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);
+  }
+  // ── 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.bus.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);
+      }
+    });
+    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(transport, bus) {
+    this.transport = transport;
+    this.bus = bus;
+  }
+  async annotation(resourceId, input) {
+    return busRequest(
+      this.transport,
+      "mark:create-request",
+      { resourceId, request: input },
+      "mark:create-ok",
+      "mark:create-failed"
+    );
+  }
+  async delete(resourceId, annotationId) {
+    await this.transport.emit("mark:delete", { annotationId, resourceId });
+  }
+  async entityType(type) {
+    await this.transport.emit("mark:add-entity-type", { tag: type });
+  }
+  async entityTypes(types) {
+    for (const tag of types) {
+      await this.transport.emit("mark:add-entity-type", { tag });
+    }
+  }
+  async archive(resourceId) {
+    await this.transport.emit("mark:archive", { resourceId });
+  }
+  async unarchive(resourceId) {
+    await this.transport.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.transport,
+              "job:status-requested",
+              { jobId },
+              "job:status-result",
+              "job:status-failed"
+            ).then((status) => {
+              if (done) return;
+              if (status.status === "complete") {
+                cleanup();
+                subscriber.next({
+                  kind: "complete",
+                  data: {
+                    jobId,
+                    jobType: status.jobType ?? "annotation",
+                    resourceId,
+                    result: 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.bus.get("job:report-progress").pipe(
+        filter((e) => e.jobId === activeJobId)
+      );
+      const complete$ = this.bus.get("job:complete").pipe(
+        filter((e) => e.jobId === activeJobId)
+      );
+      const fail$ = this.bus.get("job:fail").pipe(
+        filter((e) => e.jobId === activeJobId)
+      );
+      const progressSub = progress$.pipe(takeUntil(merge(complete$, fail$))).subscribe((e) => {
+        if (e.progress) subscriber.next({ kind: "progress", data: e.progress });
+        if (activeJobId) resetPollTimer(activeJobId);
+      });
+      const completeSub = complete$.subscribe((e) => {
+        cleanup();
+        subscriber.next({ kind: "complete", data: e });
+        subscriber.complete();
+      });
+      const failSub = fail$.subscribe((e) => {
+        cleanup();
+        subscriber.error(new Error(e.error));
+      });
+      this.dispatchAssist(resourceId, motivation, options).then(({ jobId }) => {
+        if (jobId && !done) {
+          activeJobId = jobId;
+          resetPollTimer(jobId);
+        }
+      }).catch((error) => {
+        cleanup();
+        subscriber.error(error);
+      });
+      return () => {
+        cleanup();
+        progressSub.unsubscribe();
+        completeSub.unsubscribe();
+        failSub.unsubscribe();
+      };
+    });
+  }
+  request(selector, motivation) {
+    this.bus.get("mark:requested").next({ selector, motivation });
+  }
+  requestAssist(motivation, options, correlationId) {
+    this.bus.get("mark:assist-request").next({
+      motivation,
+      options,
+      ...correlationId ? { correlationId } : {}
+    });
+  }
+  submit(input) {
+    this.bus.get("mark:submit").next(input);
+  }
+  cancelPending() {
+    this.bus.get("mark:cancel-pending").next(void 0);
+  }
+  dismissProgress() {
+    this.bus.get("mark:progress-dismiss").next(void 0);
+  }
+  changeSelection(motivation) {
+    this.bus.get("mark:selection-changed").next({ motivation });
+  }
+  changeClick(action) {
+    this.bus.get("mark:click-changed").next({ action });
+  }
+  changeShape(shape) {
+    this.bus.get("mark:shape-changed").next({ shape });
+  }
+  toggleMode() {
+    this.bus.get("mark:mode-toggled").next(void 0);
+  }
+  async dispatchAssist(resourceId, motivation, options) {
+    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.transport,
+      "job:create",
+      { jobType, resourceId, params },
+      "job:created",
+      "job:create-failed"
+    );
+  }
+};
+
+// src/namespaces/bind.ts
+var BindNamespace = class {
+  constructor(transport, bus) {
+    this.transport = transport;
+    this.bus = bus;
+  }
+  async body(resourceId, annotationId, operations) {
+    await this.transport.emit("bind:update-body", {
+      correlationId: crypto.randomUUID(),
+      annotationId,
+      resourceId,
+      operations
+    });
+  }
+  initiate(input) {
+    this.bus.get("bind:initiate").next(input);
+  }
+};
+var GatherNamespace = class {
+  constructor(transport, bus) {
+    this.transport = transport;
+    this.bus = bus;
+  }
+  annotation(annotationId, resourceId, options) {
+    return new Observable((subscriber) => {
+      const correlationId = crypto.randomUUID();
+      const complete$ = this.bus.get("gather:complete").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const failed$ = this.bus.get("gather:failed").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const sub = merge(
+        this.bus.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.transport.emit("gather:requested", {
+        correlationId,
+        annotationId,
+        resourceId,
+        options: { contextWindow: options?.contextWindow ?? 2e3 }
+      }).catch((error) => {
+        subscriber.error(error);
+      });
+      return () => {
+        sub.unsubscribe();
+        completeSub.unsubscribe();
+        failedSub.unsubscribe();
+      };
+    });
+  }
+  resource(_resourceId, _options) {
+    throw new Error("Not implemented: gather.resource() \u2014 no backend route yet");
+  }
+};
+var MatchNamespace = class {
+  constructor(transport, bus) {
+    this.transport = transport;
+    this.bus = bus;
+  }
+  requestSearch(input) {
+    this.bus.get("match:search-requested").next(input);
+  }
+  search(resourceId, referenceId, context, options) {
+    return new Observable((subscriber) => {
+      const correlationId = crypto.randomUUID();
+      const result$ = this.bus.get("match:search-results").pipe(
+        filter((e) => e.correlationId === correlationId)
+      );
+      const failed$ = this.bus.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.transport.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();
+      };
+    });
+  }
+};
+var YieldNamespace = class {
+  constructor(transport, bus, content) {
+    this.transport = transport;
+    this.bus = bus;
+    this.content = content;
+  }
+  async resource(data) {
+    const result = await this.content.putBinary({
+      name: data.name,
+      file: data.file,
+      format: data.format,
+      storageUri: data.storageUri,
+      ...data.entityTypes ? { entityTypes: data.entityTypes } : {},
+      ...data.language ? { language: data.language } : {},
+      ...data.creationMethod ? { creationMethod: data.creationMethod } : {},
+      ...data.sourceAnnotationId ? { sourceAnnotationId: data.sourceAnnotationId } : {},
+      ...data.sourceResourceId ? { sourceResourceId: data.sourceResourceId } : {},
+      ...data.generationPrompt ? { generationPrompt: data.generationPrompt } : {},
+      ...data.generator ? { generator: data.generator } : {},
+      ...data.isDraft !== void 0 ? { isDraft: data.isDraft } : {}
+    });
+    return { resourceId: result.resourceId };
+  }
+  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;
+        }
+      };
+      const resetPollTimer = (jid) => {
+        if (pollTimer) clearTimeout(pollTimer);
+        if (pollInterval) {
+          clearInterval(pollInterval);
+          pollInterval = null;
+        }
+        pollTimer = setTimeout(() => {
+          if (done) return;
+          pollInterval = setInterval(() => {
+            if (done) return;
+            busRequest(
+              this.transport,
+              "job:status-requested",
+              { jobId: jid },
+              "job:status-result",
+              "job:status-failed"
+            ).then((status) => {
+              if (done) return;
+              if (status.status === "complete") {
+                cleanup();
+                subscriber.next({
+                  kind: "complete",
+                  data: {
+                    jobId: jid,
+                    jobType: status.jobType ?? "generation",
+                    resourceId,
+                    result: status.result
+                  }
+                });
+                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.bus.get("job:report-progress").pipe(
+        filter((e) => e.jobId === activeJobId)
+      );
+      const complete$ = this.bus.get("job:complete").pipe(
+        filter((e) => e.jobId === activeJobId)
+      );
+      const fail$ = this.bus.get("job:fail").pipe(
+        filter((e) => e.jobId === activeJobId)
+      );
+      const progressSub = progress$.pipe(takeUntil(merge(complete$, fail$))).subscribe((e) => {
+        if (e.progress) subscriber.next({ kind: "progress", data: e.progress });
+        if (activeJobId) resetPollTimer(activeJobId);
+      });
+      const completeSub = complete$.subscribe((e) => {
+        cleanup();
+        subscriber.next({ kind: "complete", data: e });
+        subscriber.complete();
+      });
+      const failSub = fail$.subscribe((e) => {
+        cleanup();
+        subscriber.error(new Error(e.error));
+      });
+      busRequest(
+        this.transport,
+        "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);
+        }
+      }).catch((error) => {
+        cleanup();
+        subscriber.error(error);
+      });
+      return () => {
+        cleanup();
+        progressSub.unsubscribe();
+        completeSub.unsubscribe();
+        failSub.unsubscribe();
+      };
+    });
+  }
+  async cloneToken(resourceId) {
+    return busRequest(
+      this.transport,
+      "yield:clone-token-requested",
+      { resourceId },
+      "yield:clone-token-generated",
+      "yield:clone-token-failed"
+    );
+  }
+  async fromToken(token) {
+    const result = await busRequest(
+      this.transport,
+      "yield:clone-resource-requested",
+      { token },
+      "yield:clone-resource-result",
+      "yield:clone-resource-failed"
+    );
+    return result.sourceResource;
+  }
+  async createFromToken(options) {
+    return busRequest(
+      this.transport,
+      "yield:clone-create",
+      options,
+      "yield:clone-created",
+      "yield:clone-create-failed"
+    );
+  }
+  clone() {
+    this.bus.get("yield:clone").next(void 0);
+  }
+};
+
+// src/namespaces/beckon.ts
+var BeckonNamespace = class {
+  constructor(transport, bus) {
+    this.transport = transport;
+    this.bus = bus;
+  }
+  attention(annotationId, resourceId) {
+    void this.transport.emit("beckon:focus", { annotationId, resourceId });
+  }
+  hover(annotationId) {
+    this.bus.get("beckon:hover").next({ annotationId });
+  }
+  sparkle(annotationId) {
+    this.bus.get("beckon:sparkle").next({ annotationId });
+  }
+};
+
+// src/namespaces/job.ts
+var JobNamespace = class {
+  constructor(transport, bus) {
+    this.transport = transport;
+    this.bus = bus;
+  }
+  /**
+   * Live stream of `job:queued` events. Surfaces a typed view onto the
+   * underlying bus channel for consumers (CLIs, MCP handlers, widgets)
+   * that orchestrate jobs and need to react to lifecycle transitions.
+   */
+  get queued$() {
+    return this.bus.get("job:queued");
+  }
+  /** Live stream of `job:report-progress` events. */
+  get progress$() {
+    return this.bus.get("job:report-progress");
+  }
+  /** Live stream of `job:complete` events. */
+  get complete$() {
+    return this.bus.get("job:complete");
+  }
+  /** Live stream of `job:fail` events. */
+  get fail$() {
+    return this.bus.get("job:fail");
+  }
+  async status(jobId) {
+    return busRequest(
+      this.transport,
+      "job:status-requested",
+      { jobId },
+      "job:status-result",
+      "job:status-failed"
+    );
+  }
+  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));
+    }
+  }
+  async cancel(_jobId, type) {
+    await this.transport.emit("job:cancel-requested", {
+      jobType: type === "generation" ? "generation" : "annotation"
+    });
+  }
+  cancelRequest(jobType) {
+    this.bus.get("job:cancel-requested").next({ jobType });
+  }
+};
+var AuthNamespace = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async password(emailStr, passwordStr) {
+    return this.transport.authenticatePassword(email(emailStr), passwordStr);
+  }
+  async google(credential) {
+    return this.transport.authenticateGoogle(googleCredential(credential));
+  }
+  async refresh(token) {
+    return this.transport.refreshAccessToken(refreshToken(token));
+  }
+  async logout() {
+    await this.transport.logout();
+  }
+  async me() {
+    return this.transport.getCurrentUser();
+  }
+  async acceptTerms() {
+    await this.transport.acceptTerms();
+  }
+  async mcpToken() {
+    return this.transport.generateMcpToken();
+  }
+  async mediaToken(resourceId) {
+    return this.transport.getMediaToken(resourceId);
+  }
+};
+
+// src/namespaces/admin.ts
+var AdminNamespace = class {
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async users() {
+    const result = await this.transport.listUsers();
+    return result.users;
+  }
+  async userStats() {
+    return this.transport.getUserStats();
+  }
+  async updateUser(userId, data) {
+    const result = await this.transport.updateUser(userId, data);
+    return result.user;
+  }
+  async oauthConfig() {
+    return this.transport.getOAuthConfig();
+  }
+  async healthCheck() {
+    return this.transport.healthCheck();
+  }
+  async status() {
+    return this.transport.getStatus();
+  }
+  async backup() {
+    return this.transport.backupKnowledgeBase();
+  }
+  async restore(file, onProgress) {
+    return this.transport.restoreKnowledgeBase(file, onProgress);
+  }
+  async exportKnowledgeBase(params) {
+    return this.transport.exportKnowledgeBase(params);
+  }
+  async importKnowledgeBase(file, onProgress) {
+    return this.transport.importKnowledgeBase(file, onProgress);
+  }
+};
+var SemiontClient = class {
+  /**
+   * The wire-facing transport. Owns bus actor, HTTP, auth, admin, exchange,
+   * system. Exposed for advanced consumers (workers, custom job adapters)
+   * that need raw `transport.emit(channel, payload, scope)` access. Ordinary
+   * consumers go through typed namespace methods.
+   */
+  transport;
+  /** Binary I/O transport. */
+  content;
+  /**
+   * Per-client local EventBus. Wire events flow in via the transport
+   * bridge. Read-only public so `SemiontSession.subscribe(channel, …)`
+   * can wire arbitrary-channel subscriptions; everything else uses
+   * typed namespace methods.
+   */
+  bus;
+  baseUrl;
+  // ── Verb-oriented namespace API ──────────────────────────────────────────
+  browse;
+  mark;
+  bind;
+  gather;
+  match;
+  yield;
+  beckon;
+  job;
+  auth;
+  admin;
+  /**
+   * The client *owns* its bus. The constructor creates a fresh `EventBus`
+   * and hands it to the transport via `transport.bridgeInto(this.bus)`.
+   * The reference flows client → transport, never the other way:
+   * the transport stores the reference and publishes the events it
+   * receives onto that bus. `HttpTransport` does so for every channel
+   * delivered on its SSE wire; in-process transports adapt their
+   * internal source.
+   *
+   * Callers do not pass a bus in. If they need to interact with the bus
+   * (e.g. for tests or to subscribe to arbitrary channels), they read it
+   * back via `client.bus`.
+   */
+  constructor(transport, content) {
+    this.transport = transport;
+    this.content = content;
+    this.baseUrl = transport.baseUrl;
+    this.bus = new EventBus();
+    this.transport.bridgeInto(this.bus);
+    this.browse = new BrowseNamespace(this.transport, this.bus, this.content);
+    this.mark = new MarkNamespace(this.transport, this.bus);
+    this.bind = new BindNamespace(this.transport, this.bus);
+    this.gather = new GatherNamespace(this.transport, this.bus);
+    this.match = new MatchNamespace(this.transport, this.bus);
+    this.yield = new YieldNamespace(this.transport, this.bus, this.content);
+    this.beckon = new BeckonNamespace(this.transport, this.bus);
+    this.job = new JobNamespace(this.transport, this.bus);
+    this.auth = new AuthNamespace(this.transport);
+    this.admin = new AdminNamespace(this.transport);
+  }
+  /** Transport-level connection state. HTTP reflects SSE health; local is always 'connected'. */
+  get state$() {
+    return this.transport.state$;
+  }
+  subscribeToResource(resourceId) {
+    return this.transport.subscribeToResource(resourceId);
+  }
+  dispose() {
+    this.transport.dispose();
+    this.content.dispose();
+  }
+};
+
+// 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 ?? (() => {
+    });
+    this.client = config.client;
+    this.token$ = config.token$;
+    this.user$ = new BehaviorSubject(null);
+    const stored = getStoredSession(this.storage, this.kb.id);
+    if (stored && !isJwtExpired(stored.access) && this.token$.getValue() === null) {
+      this.token$.next(accessToken(stored.access));
+    }
+    const initialToken = this.token$.getValue();
+    this.streamState$ = this.client.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) ? this.doRefresh ? await this.doRefresh() : null : 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 = this.doRefresh ? await this.doRefresh() : null;
+          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;
+    if (!this.doRefresh) 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;
+  }
+  /**
+   * Subscribe to a session-bus channel. The single sanctioned escape hatch
+   * for generic-channel subscription (the case `useEventSubscription` needs
+   * — channel name is a hook parameter, not known statically). All other
+   * consumers must call typed namespace methods (e.g. `session.client.mark.archive(...)`).
+   *
+   * @returns disposer that unsubscribes the handler.
+   */
+  subscribe(channel, handler) {
+    const sub = this.client.bus.get(channel).subscribe(handler);
+    return () => sub.unsubscribe();
+  }
+  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 `SemiontClient`, 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 token$ = new BehaviorSubject(null);
+      let session;
+      const transport = new HttpTransport({
+        baseUrl: baseUrl(kbBackendUrl(kb)),
+        token$,
+        tokenRefresher: () => session.refresh().then((t) => t ?? null)
+      });
+      const content = new HttpContentTransport(transport);
+      const client = new SemiontClient(transport, content);
+      session = new SemiontSession({
+        kb,
+        storage: this.storage,
+        client,
+        token$,
+        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 `SemiontClient` 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 throwawayTransport = new HttpTransport({ baseUrl: baseUrl(kbBackendUrl(kb)) });
+      const throwaway = new SemiontClient(throwawayTransport, new HttpContentTransport(throwawayTransport));
+      try {
+        const response = await throwaway.auth.refresh(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 `auth.me` on a throwaway
+   * client. The session uses this once at startup to populate
+   * `user$`; 401 triggers a refresh-then-retry inside the session.
+   *
+   * The throwaway transport is seeded with the specific token to
+   * validate so the request actually carries it (HttpTransport
+   * sources `Authorization` from its `token$`).
+   */
+  async performValidate(kb, token) {
+    const tokenSubject = new BehaviorSubject(token);
+    const throwawayTransport = new HttpTransport({
+      baseUrl: baseUrl(kbBackendUrl(kb)),
+      token$: tokenSubject
+    });
+    const throwaway = new SemiontClient(throwawayTransport, new HttpContentTransport(throwawayTransport));
+    try {
+      const data = await throwaway.auth.me();
+      return data;
+    } finally {
+      throwaway.dispose();
+      tokenSubject.complete();
+    }
+  }
+  // ── 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(fetch, 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 fetch(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.bus.get("beckon:hover").subscribe(({ annotationId }) => {
+    hovered$.next(annotationId);
+    if (annotationId) {
+      client.bus.get("beckon:sparkle").next({ annotationId });
+    }
+  }));
+  subs.push(client.bus.get("browse:click").subscribe(({ annotationId }) => {
+    client.bus.get("beckon:focus").next({ annotationId });
+  }));
+  return {
+    hoveredAnnotationId$: hovered$.asObservable(),
+    hover: (annotationId) => client.bus.get("beckon:hover").next({ annotationId }),
+    focus: (annotationId) => client.bus.get("beckon:focus").next({ annotationId }),
+    sparkle: (annotationId) => client.bus.get("beckon:sparkle").next({ 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.bus.get("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.bus.get("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.bus.get("match:search-results").next(result),
+      error: (err) => client.bus.get("match:search-failed").next({
+        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: (e) => {
+        if (e.kind === "progress") {
+          progress$.next(e.data);
+          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.bus.get("mark:requested").subscribe(handleAnnotationRequested));
+  subs.push(client.bus.get("mark:select-comment").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "commenting" })));
+  subs.push(client.bus.get("mark:select-tag").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "tagging" })));
+  subs.push(client.bus.get("mark:select-assessment").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "assessing" })));
+  subs.push(client.bus.get("mark:select-reference").subscribe((s) => handleAnnotationRequested({ selector: selectionToSelector(s), motivation: "linking" })));
+  subs.push(client.bus.get("mark:cancel-pending").subscribe(() => pendingAnnotation$.next(null)));
+  subs.push(client.bus.get("mark:create-ok").subscribe(() => pendingAnnotation$.next(null)));
+  subs.push(client.bus.get("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.bus.get("mark:create-ok").next({ annotationId: result.annotationId });
+    } catch (error) {
+      client.bus.get("mark:create-failed").next({ message: error instanceof Error ? error.message : String(error) });
+    }
+  }));
+  subs.push(client.bus.get("mark:delete").subscribe(async (event) => {
+    try {
+      await client.mark.delete(resourceId, event.annotationId);
+      client.bus.get("mark:delete-ok").next({ annotationId: event.annotationId });
+    } catch (error) {
+      client.bus.get("mark:delete-failed").next({ message: error instanceof Error ? error.message : String(error) });
+    }
+  }));
+  subs.push(client.bus.get("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: (e) => {
+        if (e.kind === "progress") progress$.next(e.data);
+      },
+      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.bus.get("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.admin.users().then((data) => {
+      users$.next(data.users ?? []);
+      usersLoading$.next(false);
+    }).catch(() => usersLoading$.next(false));
+  };
+  const fetchStats = () => {
+    statsLoading$.next(true);
+    client.admin.userStats().then((data) => {
+      stats$.next(data.stats ?? null);
+      statsLoading$.next(false);
+    }).catch(() => statsLoading$.next(false));
+  };
+  fetchUsers();
+  fetchStats();
+  const updateUser = async (id, data) => {
+    await client.admin.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.admin.oauthConfig().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.auth.me().then((data) => userData$.next(data)).catch(() => {
+  });
+  const acceptTerms = async () => {
+    isProcessing$.next(true);
+    try {
+      await client.auth.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.auth.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.bus.get("job:queued").subscribe((event) => {
+      const job = {
+        jobId: event.jobId,
+        type: event.jobType,
+        status: "pending",
+        resourceId: event.resourceId,
+        userId: event.userId,
+        created: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      addOrUpdate(job);
+      jobCreated$.next(job);
+    }),
+    client.bus.get("job:complete").subscribe((event) => {
+      if (!event._userId) {
+        throw new Error("job:complete missing _userId (gateway injection)");
+      }
+      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.bus.get("job:fail").subscribe((event) => {
+      if (!event._userId) {
+        throw new Error("job:fail missing _userId (gateway injection)");
+      }
+      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
+      };
+      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();
+    }
+  };
+}
+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.bus.get("bind:initiate").subscribe((event) => {
+    wizard$.next({
+      open: true,
+      annotationId: event.annotationId,
+      resourceId: event.resourceId,
+      defaultTitle: event.defaultTitle,
+      entityTypes: event.entityTypes
+    });
+    client.bus.get("gather:requested").next({
+      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();
+    }
+  };
+}
+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.browse.resourceRepresentation(rId, {
+            accept: mediaType
+          });
+          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();
+    }
+  };
+}
+
+export { AdminNamespace, AuthNamespace, BeckonNamespace, BindNamespace, BrowseNamespace, BusRequestError, COMMON_PANELS, FrontendSessionSignals, GatherNamespace, HOVER_DELAY_MS, InMemorySessionStorage, JobNamespace, MarkNamespace, MatchNamespace, RESOURCE_PANELS, SemiontBrowser, SemiontClient, SemiontError, SemiontSession, YieldNamespace, busRequest, createAdminSecurityVM, createAdminUsersVM, createBeckonVM, createCache, createComposePageVM, createDiscoverVM, createDisposer, createEntityTagsVM, createExchangeVM, createGatherVM, createHoverHandlers, createJobClaimAdapter, createJobQueueVM, createMarkVM, createMatchVM, createResourceLoaderVM, createResourceViewerPageVM, createSearchPipeline, createSessionVM, createShellVM, createSmelterActorVM, createWelcomeVM, createYieldVM, defaultProtocol, getBrowser, isValidHostname, kbBackendUrl, notifyPermissionDenied, notifySessionExpired, setStoredSession };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map