@semiont/api-client 0.4.20 → 0.4.22

package/dist/index.d.ts

@@ -1,1327 +1,173 @@
-import * as _semiont_core from '@semiont/core';
-import { BaseUrl, Logger, ResourceId, AccessToken, components, UserDID, paths, AnnotationId, GraphConnection, UpdateResourceInput, Motivation, MarkProgress, BodyOperation, GatheredContext, YieldProgress as YieldProgress$1, JobId, EventBus, Email, RefreshToken, GoogleCredential, ContentFormat, SearchQuery, CloneToken, EntityType } from '@semiont/core';
-export { Logger, Selector, getFragmentSelector, getSvgSelector, getTextPositionSelector, validateSvgMarkup } from '@semiont/core';
-import { Observable } from 'rxjs';
-export { BoundingBox, ContentCache, FragmentSelector, JWTTokenSchema, LOCALES, LocaleInfo, MatchQuality, Point, SvgSelector, TextPosition, TextPositionSelector, TextQuoteSelector, ValidatedAnnotation, ValidationFailure, ValidationResult, ValidationSuccess, buildContentCache, createCircleSvg, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findTextWithContext, formatLocaleDisplay, getAllLocaleCodes, getAnnotationExactText, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getTargetSelector, getTargetSource, getTextQuoteSelector, hasTargetSelector, isArchived, isAssessment, isBodyResolved, isComment, isDraft, isHighlight, isReference, isResolvedReference, isStubReference, isTag, isValidEmail, normalizeCoordinates, normalizeText, parseSvgSelector, scaleSvgToNative, validateAndCorrectOffsets, validateData, verifyPosition } from './utils/index.js';
+import { KyInstance } from 'ky';
+import { Observable, BehaviorSubject } from 'rxjs';
+import { ConnectionState, ITransport, BaseUrl, AccessToken, Logger, EventMap, ResourceId, EventBus, Email, components, GoogleCredential, RefreshToken, UserResponse, ListUsersResponse, UserDID, UpdateUserRequest, UpdateUserResponse, ProgressCallback, ProgressEvent, HealthCheckResponse, StatusResponse, IContentTransport, PutBinaryRequest, ContentFormat } from '@semiont/core';
 
-/**
- * TypeScript types for SSE event payloads.
- *
- * Progress and result types for events delivered via the long-lived
- * events-stream. These match the payloads emitted by job workers on
- * the resource-scoped EventBus. Used by the MCP server for type-safe
- * event handling.
- */
-/**
- * Progress event for reference/linking detection stream
- *
- * Sent by POST /resources/:id/annotate-references
- *
- * @example
- * ```typescript
- * stream.onProgress((progress: ReferenceDetectionProgress) => {
- *   if (progress.status === 'scanning') {
- *     console.log(`Scanning for ${progress.currentEntityType}...`);
- *     console.log(`Progress: ${progress.processedEntityTypes}/${progress.totalEntityTypes}`);
- *   }
- * });
- * ```
- */
-interface ReferenceDetectionProgress {
-    /** Current status of detection operation */
-    status: 'started' | 'scanning' | 'complete' | 'error';
-    /** Resource ID being scanned */
-    resourceId: string;
-    /** Currently scanning for this entity type (only present during 'scanning') */
-    currentEntityType?: string;
-    /** Total number of entity types to scan */
-    totalEntityTypes: number;
-    /** Number of entity types processed so far */
-    processedEntityTypes: number;
-    /** Human-readable status message */
-    message?: string;
-    /** Total entities found (only present in 'complete') */
-    foundCount?: number;
-}
-/**
- * Progress event for resource generation stream
- *
- * Sent by POST /resources/:resourceId/annotations/:annotationId/yield-resource
- *
- * @example
- * ```typescript
- * stream.onProgress((progress: YieldProgress) => {
- *   console.log(`${progress.status}: ${progress.percentage}%`);
- *   console.log(progress.message);
- * });
- * ```
- */
-interface YieldProgress {
-    /** Current stage of generation operation */
-    status: 'started' | 'fetching' | 'generating' | 'creating' | 'complete' | 'error';
-    /** Annotation ID being used as source */
-    referenceId: string;
-    /** Name of resource being generated */
-    resourceName?: string;
-    /** ID of generated resource (only present in 'complete') */
-    resourceId?: string;
-    /** ID of source resource */
-    sourceResourceId?: string;
-    /** Percentage complete (0-100) */
-    percentage: number;
-    /** Human-readable status message */
-    message?: string;
-}
-/**
- * Resource event from real-time event stream
- *
- * Sent by GET /resources/:id/events/stream
- *
- * This represents a single event from the event store, broadcast in real-time
- * as it occurs. Used for real-time collaboration - multiple users see each
- * other's changes as they happen.
- *
- * Re-exported from @semiont/core (authoritative source).
- * The discriminated union type provides type-safe event handling.
- *
- * @example
- * ```typescript
- * stream.onEvent((event) => {
- *   console.log(`Event: ${event.type}`);
- *   console.log(`User: ${event.userId}`);
- *   console.log(`Payload:`, event.payload);
- * });
- * ```
- */
-/**
- * SSE stream controller interface
- *
- * Returned by all SSE methods. Events auto-emit to EventBus (required).
- *
- * **Architecture Note**: All SSE methods require `eventBus` in options to enforce
- * event-driven architecture. This is enforced at compile time via TypeScript.
- *
- * @example
- * ```typescript
- * const eventBus = new EventBus();
- *
- * // Subscribe to events
- * eventBus.get('detection:progress').subscribe((p) => console.log(p.message));
- * eventBus.get('detection:complete').subscribe(() => console.log('Done!'));
- * eventBus.get('detection:failed').subscribe(({ error }) => console.error(error));
- *
- * // Start stream - eventBus is required (TypeScript enforced)
- * const stream = client.sse.markReferences(resourceId, request, { auth, eventBus });
- *
- * // Cleanup when done
- * stream.close();
- * ```
- */
-interface SSEStream {
-    /**
-     * Close the SSE stream and abort the connection
-     *
-     * Should be called to cleanup resources when stream is no longer needed.
-     * Safe to call multiple times.
-     *
-     * @example
-     * ```typescript
-     * // React cleanup
-     * useEffect(() => {
-     *   const stream = client.sse.markReferences(..., { auth, eventBus });
-     *   return () => stream.close();
-     * }, []);
-     * ```
-     */
-    close(): void;
-}
-
-/**
- * SSE meta event for stream connection lifecycle
- * Internal to SSE infrastructure, not part of core event protocol
- */
-declare const SSE_STREAM_CONNECTED: "stream-connected";
-type SSEStreamConnected = typeof SSE_STREAM_CONNECTED;
-/**
- * SSE Client configuration
- */
-interface SSEClientConfig {
-    baseUrl: BaseUrl;
-    logger?: Logger;
-}
-/**
- * Options for SSE requests
- */
-interface SSERequestOptions {
-    auth?: AccessToken;
-    /** EventBus for event-driven architecture (required) */
-    eventBus: _semiont_core.EventBus;
-}
-/**
- * SSE Client for long-lived streaming connections.
- *
- * This client has three methods — one per long-lived broadcast stream.
- * Per-operation SSE routes have been replaced by plain HTTP POSTs with
- * results delivered via the events-stream.
- *
- * Uses native fetch() instead of ky for SSE support.
- * Auth tokens are passed per-request via options.
- *
- * @example
- * ```typescript
- * const sseClient = new SSEClient({ baseUrl: 'http://localhost:4000' });
- *
- * // Open a long-lived resource events stream (auto-reconnects on disconnect)
- * const stream = sseClient.resourceEvents(resourceId, { auth, eventBus });
- *
- * // Events auto-route to EventBus typed channels
- * eventBus.get('mark:body-updated').subscribe((event) => { ... });
- *
- * // Close when done
- * stream.close();
- * ```
- */
-declare class SSEClient {
-    private baseUrl;
-    private logger?;
-    constructor(config: SSEClientConfig);
-    /**
-     * Get common headers for SSE requests
-     */
-    private getHeaders;
-    /**
-     * Subscribe to resource events (long-lived stream)
-     *
-     * Opens a long-lived SSE connection to receive real-time events for a resource.
-     * Used for collaborative editing - see events from other users as they happen.
-     *
-     * This stream does NOT have a complete event - it stays open until explicitly closed.
-     *
-     * @param resourceId - Resource URI or ID to subscribe to
-     * @param options - Request options (auth token)
-     * @returns SSE stream controller with event callback
-     *
-     * @example
-     * ```typescript
-     * const stream = sseClient.resourceEvents(
-     *   'http://localhost:4000/resources/doc-123',
-     *   { auth: 'your-token' }
-     * );
-     *
-     * stream.onProgress((event) => {
-     *   console.log(`Event: ${event.type}`);
-     *   console.log(`User: ${event.userId}`);
-     *   console.log(`Sequence: ${event.metadata.sequenceNumber}`);
-     *   console.log(`Payload:`, event.payload);
-     * });
-     *
-     * stream.onError((error) => {
-     *   console.error('Stream error:', error.message);
-     * });
-     *
-     * // Close when no longer needed (e.g., component unmount)
-     * stream.close();
-     * ```
-     */
-    resourceEvents(resourceId: ResourceId, options: SSERequestOptions & {
-        onConnected?: () => void;
-    }): SSEStream;
-    /**
-     * Subscribe to global system events (long-lived stream)
-     *
-     * Opens a long-lived SSE connection to receive system-level domain events
-     * (entity type additions, etc.) that are not scoped to a specific resource.
-     *
-     * @param options - Request options (auth token, eventBus)
-     * @returns SSE stream controller
-     *
-     * @example
-     * ```typescript
-     * const stream = sseClient.globalEvents({ auth: 'your-token', eventBus });
-     *
-     * // Events auto-emit to EventBus typed channels — subscribe there
-     * eventBus.get('mark:entity-type-added').subscribe((stored) => {
-     *   // Invalidate entity types query
-     * });
-     *
-     * // Close when no longer needed
-     * stream.close();
-     * ```
-     */
-    globalEvents(options: SSERequestOptions & {
-        onConnected?: () => void;
-    }): SSEStream;
-    /**
-     * Subscribe to participant attention stream (long-lived stream)
-     *
-     * Opens a participant-scoped SSE connection to receive cross-participant
-     * beckon signals. Signals are delivered as 'beckon:focus' events routed
-     * to the EventBus — the existing scroll/highlight machinery handles them.
-     *
-     * Signals are ephemeral — delivered if connected, dropped if not.
-     *
-     * @param options - Request options (auth token, eventBus)
-     * @returns SSE stream controller
-     */
-    attentionStream(options: SSERequestOptions & {
-        onConnected?: () => void;
-    }): SSEStream;
-}
-
-/**
- * Verb Namespace Interfaces
- *
- * These interfaces define the public API of the Semiont api-client,
- * organized by the 7 domain flows (Browse, Mark, Bind, Gather, Match,
- * Yield, Beckon) plus infrastructure namespaces (Job, Auth, Admin).
- *
- * Each namespace maps 1:1 to a flow. Each flow maps to a clear actor
- * on the backend. The frontend calls `client.mark.annotation()` and the
- * proxy handles HTTP, auth, SSE, and caching internally.
- *
- * Return type conventions:
- * - Browse live queries → Observable (events-stream driven, cached)
- * - Browse one-shot reads → Promise (fetch once, no cache)
- * - Commands (mark, bind, yield.resource) → Promise (fire-and-forget)
- * - Long-running ops (gather, match, yield.fromAnnotation, mark.assist) → Observable (progress + result)
- * - Ephemeral signals (beckon) → void
- */
-
-type Annotation$1 = components['schemas']['Annotation'];
-type ResourceDescriptor$2 = components['schemas']['ResourceDescriptor'];
-type StoredEventResponse$1 = components['schemas']['StoredEventResponse'];
-type GatherProgress = components['schemas']['GatherProgress'];
-type MatchSearchResult = components['schemas']['MatchSearchResult'];
-type MarkAssistFinished = components['schemas']['MarkAssistFinished'];
-type GatherAnnotationComplete = components['schemas']['GatherAnnotationComplete'];
-type JobStatusResponse$1 = components['schemas']['JobStatusResponse'];
-type AuthResponse$1 = components['schemas']['AuthResponse'];
-type OAuthConfigResponse$1 = components['schemas']['OAuthConfigResponse'];
-type AdminUserStatsResponse$1 = components['schemas']['AdminUserStatsResponse'];
-type ResponseContent$1<T> = T extends {
-    responses: {
-        200: {
-            content: {
-                'application/json': infer R;
-            };
-        };
-    };
-} ? R : T extends {
-    responses: {
-        201: {
-            content: {
-                'application/json': infer R;
-            };
-        };
-    };
-} ? R : never;
-type RequestContent$1<T> = T extends {
-    requestBody?: {
-        content: {
-            'application/json': infer R;
-        };
-    };
-} ? R : never;
-/** Input for creating an annotation via mark.annotation() */
-type CreateAnnotationInput = RequestContent$1<paths['/resources/{id}/annotations']['post']>;
-/** Input for creating a resource via yield.resource() */
-interface CreateResourceInput {
-    name: string;
-    file: File | Buffer;
-    format: string;
-    entityTypes?: string[];
-    language?: string;
-    creationMethod?: string;
-    sourceAnnotationId?: string;
-    sourceResourceId?: string;
-    storageUri: string;
-}
-/** Options for yield.fromAnnotation() */
-interface GenerationOptions {
-    title: string;
-    storageUri: string;
-    context: GatheredContext;
-    prompt?: string;
-    language?: string;
-    temperature?: number;
-    maxTokens?: number;
-}
-/** Options for mark.assist() */
-interface MarkAssistOptions {
-    entityTypes?: string[];
-    includeDescriptiveReferences?: boolean;
-    instructions?: string;
-    density?: number;
-    tone?: string;
-    language?: string;
-    schemaId?: string;
-    categories?: string[];
-}
-/** Options for yield.createFromToken() */
-type CreateFromTokenOptions = RequestContent$1<paths['/api/clone-tokens/create-resource']['post']>;
-/** Referenced-by entry from browse.referencedBy() */
-type ReferencedByEntry = ResponseContent$1<paths['/resources/{id}/referenced-by']['get']>['referencedBy'][number];
-/** Annotation history from browse.annotationHistory() */
-type AnnotationHistoryResponse = ResponseContent$1<paths['/resources/{resourceId}/annotations/{annotationId}/history']['get']>;
-/** User object from auth/admin responses */
-type User = AuthResponse$1['user'];
-/**
- * Progress emitted by gather.annotation() Observable.
- * Emits GatherProgress during assembly, then GatherAnnotationComplete on finish.
- */
-type GatherAnnotationProgress = GatherProgress | GatherAnnotationComplete;
-/**
- * Progress emitted by match.search() Observable.
- * Emits the final MatchSearchResult (no intermediate progress events currently).
- */
-type MatchSearchProgress = MatchSearchResult;
-/**
- * Progress emitted by mark.assist() Observable.
- * Emits MarkProgress during scanning, then MarkAssistFinished on completion.
- * On failure, the Observable errors with MarkAssistFailed.
- */
-type MarkAssistProgress = MarkProgress | MarkAssistFinished;
-/**
- * Browse — reads from materialized views
- *
- * Live queries return Observables that emit initial state and re-emit
- * on events-stream updates. One-shot reads return Promises.
- *
- * Backend actor: Browser (context classes)
- * Event prefix: browse:*
- */
-interface BrowseNamespace$1 {
-    resource(resourceId: ResourceId): Observable<ResourceDescriptor$2 | undefined>;
-    resources(filters?: {
-        limit?: number;
-        archived?: boolean;
-        search?: string;
-    }): Observable<ResourceDescriptor$2[] | undefined>;
-    annotations(resourceId: ResourceId): Observable<Annotation$1[] | undefined>;
-    annotation(resourceId: ResourceId, annotationId: AnnotationId): Observable<Annotation$1 | undefined>;
-    entityTypes(): Observable<string[] | undefined>;
-    referencedBy(resourceId: ResourceId): Observable<ReferencedByEntry[] | undefined>;
-    resourceContent(resourceId: ResourceId): Promise<string>;
-    resourceRepresentation(resourceId: ResourceId, options?: {
-        accept?: string;
-    }): Promise<{
-        data: ArrayBuffer;
-        contentType: string;
-    }>;
-    resourceRepresentationStream(resourceId: ResourceId, options?: {
-        accept?: string;
-    }): Promise<{
-        stream: ReadableStream<Uint8Array>;
-        contentType: string;
-    }>;
-    resourceEvents(resourceId: ResourceId): Promise<StoredEventResponse$1[]>;
-    annotationHistory(resourceId: ResourceId, annotationId: AnnotationId): Promise<AnnotationHistoryResponse>;
-    connections(resourceId: ResourceId): Promise<GraphConnection[]>;
-    backlinks(resourceId: ResourceId): Promise<Annotation$1[]>;
-    resourcesByName(query: string, limit?: number): Promise<ResourceDescriptor$2[]>;
-    files(dirPath?: string, sort?: 'name' | 'mtime' | 'annotationCount'): Promise<ResponseContent$1<paths['/api/browse/files']['get']>>;
-}
-/**
- * Mark — annotation CRUD, entity types, AI assist
- *
- * Commands return Promises that resolve on HTTP acceptance (202).
- * Results appear on browse Observables via events-stream.
- * assist() returns an Observable for long-running progress.
- *
- * Backend actor: Stower
- * Event prefix: mark:*
- */
-interface MarkNamespace$1 {
-    annotation(resourceId: ResourceId, input: CreateAnnotationInput): Promise<{
-        annotationId: string;
-    }>;
-    delete(resourceId: ResourceId, annotationId: AnnotationId): Promise<void>;
-    entityType(type: string): Promise<void>;
-    entityTypes(types: string[]): Promise<void>;
-    updateResource(resourceId: ResourceId, data: UpdateResourceInput): Promise<void>;
-    archive(resourceId: ResourceId): Promise<void>;
-    unarchive(resourceId: ResourceId): Promise<void>;
-    assist(resourceId: ResourceId, motivation: Motivation, options: MarkAssistOptions): Observable<MarkAssistProgress>;
-}
-/**
- * Bind — reference linking
- *
- * The simplest namespace. One method. The result (updated annotation
- * with resolved reference) arrives on browse.annotations() via the
- * enriched mark:body-updated event.
- *
- * Backend actor: Stower (via mark:update-body)
- * Event prefix: mark:body-updated (shares mark event pipeline)
- */
-interface BindNamespace$1 {
-    body(resourceId: ResourceId, annotationId: AnnotationId, operations: BodyOperation[]): Promise<void>;
-}
-/**
- * Gather — context assembly
- *
- * Long-running (LLM calls + graph traversal). Returns Observables
- * that emit progress then the gathered context.
- *
- * Backend actor: Gatherer
- * Event prefix: gather:*
- */
-interface GatherNamespace$1 {
-    annotation(annotationId: AnnotationId, resourceId: ResourceId, options?: {
-        contextWindow?: number;
-    }): Observable<GatherAnnotationProgress>;
-    resource(resourceId: ResourceId, options?: {
-        contextWindow?: number;
-    }): Observable<GatherAnnotationProgress>;
-}
-/**
- * Match — search and ranking
- *
- * Long-running (semantic search, optional LLM scoring). Returns
- * Observable with progress then results.
- *
- * Backend actor: Matcher
- * Event prefix: match:*
- */
-interface MatchNamespace$1 {
-    search(resourceId: ResourceId, referenceId: string, context: GatheredContext, options?: {
-        limit?: number;
-        useSemanticScoring?: boolean;
-    }): Observable<MatchSearchProgress>;
-}
-/**
- * Yield — resource creation
- *
- * resource() is synchronous file upload (Promise).
- * fromAnnotation() is long-running LLM generation (Observable).
- *
- * Backend actor: Stower + generation worker
- * Event prefix: yield:*
- */
-interface YieldNamespace$1 {
-    resource(data: CreateResourceInput): Promise<{
-        resourceId: string;
-    }>;
-    fromAnnotation(resourceId: ResourceId, annotationId: AnnotationId, options: GenerationOptions): Observable<YieldProgress$1>;
-    cloneToken(resourceId: ResourceId): Promise<{
-        token: string;
-        expiresAt: string;
-    }>;
-    fromToken(token: string): Promise<ResourceDescriptor$2>;
-    createFromToken(options: CreateFromTokenOptions): Promise<{
-        resourceId: string;
-    }>;
-}
-/**
- * Beckon — attention coordination
- *
- * Fire-and-forget. Ephemeral presence signal delivered via the
- * attention-stream to other participants.
- *
- * Backend actor: (frontend relay via attention-stream)
- * Event prefix: beckon:*
- */
-interface BeckonNamespace$1 {
-    attention(annotationId: AnnotationId, resourceId: ResourceId): void;
-}
-/**
- * Job — worker lifecycle
- */
-interface JobNamespace$1 {
-    status(jobId: JobId): Promise<JobStatusResponse$1>;
-    pollUntilComplete(jobId: JobId, options?: {
-        interval?: number;
-        timeout?: number;
-        onProgress?: (status: JobStatusResponse$1) => void;
-    }): Promise<JobStatusResponse$1>;
-    cancel(jobId: JobId, type: string): Promise<void>;
-}
-/**
- * Auth — authentication
- */
-interface AuthNamespace$1 {
-    password(email: string, password: string): Promise<AuthResponse$1>;
-    google(credential: string): Promise<AuthResponse$1>;
-    refresh(token: string): Promise<AuthResponse$1>;
-    logout(): Promise<void>;
-    me(): Promise<User>;
-    acceptTerms(): Promise<void>;
-    mcpToken(): Promise<{
-        token: string;
-    }>;
-    mediaToken(resourceId: ResourceId): Promise<{
-        token: string;
-    }>;
-}
-/**
- * Admin — administration
- */
-interface AdminNamespace$1 {
-    users(): Promise<User[]>;
-    userStats(): Promise<AdminUserStatsResponse$1>;
-    updateUser(userId: UserDID, data: RequestContent$1<paths['/api/admin/users/{id}']['patch']>): Promise<User>;
-    oauthConfig(): Promise<OAuthConfigResponse$1>;
-    healthCheck(): Promise<ResponseContent$1<paths['/api/health']['get']>>;
-    status(): Promise<ResponseContent$1<paths['/api/status']['get']>>;
-    backup(): Promise<Response>;
-    restore(file: File, onProgress?: (event: {
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }) => void): Promise<{
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }>;
-    exportKnowledgeBase(params?: {
-        includeArchived?: boolean;
-    }): Promise<Response>;
-    importKnowledgeBase(file: File, onProgress?: (event: {
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }) => void): Promise<{
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }>;
-}
-
-/**
- * BrowseNamespace — reads from materialized views
- *
- * Absorbs AnnotationStore and ResourceStore logic. Live queries return
- * Observables backed by BehaviorSubjects that update reactively when
- * EventBus events arrive. One-shot reads are Promise wrappers over HTTP.
- *
- * Backend actor: Browser (context classes)
- * Event prefix: browse:*
- */
-
-type Annotation = components['schemas']['Annotation'];
-type ResourceDescriptor$1 = components['schemas']['ResourceDescriptor'];
-type StoredEventResponse = components['schemas']['StoredEventResponse'];
-type TokenGetter$9 = () => AccessToken | undefined;
-declare class BrowseNamespace implements BrowseNamespace$1 {
-    private readonly http;
-    private readonly eventBus;
-    private readonly annotationList$;
-    private readonly fetchingAnnotationList;
-    private readonly annotationListObs$;
-    private readonly annotationDetail$;
-    private readonly fetchingAnnotationDetail;
-    private readonly annotationDetailObs$;
-    private readonly resourceDetail$;
-    private readonly fetchingResourceDetail;
-    private readonly resourceDetailObs$;
-    private readonly resourceList$;
-    private readonly fetchingResourceList;
-    private readonly resourceListObs$;
-    private readonly entityTypes$;
-    private fetchingEntityTypes;
-    private readonly referencedBy$;
-    private readonly fetchingReferencedBy;
-    private readonly referencedByObs$;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, eventBus: EventBus, getToken: TokenGetter$9);
-    resource(resourceId: ResourceId): Observable<ResourceDescriptor$1 | undefined>;
-    resources(filters?: {
-        limit?: number;
-        archived?: boolean;
-        search?: string;
-    }): Observable<ResourceDescriptor$1[] | undefined>;
-    annotations(resourceId: ResourceId): Observable<Annotation[] | undefined>;
-    annotation(resourceId: ResourceId, annotationId: AnnotationId): Observable<Annotation | undefined>;
-    entityTypes(): Observable<string[] | undefined>;
-    referencedBy(resourceId: ResourceId): Observable<ReferencedByEntry[] | undefined>;
-    resourceContent(resourceId: ResourceId): Promise<string>;
-    resourceRepresentation(resourceId: ResourceId, options?: {
-        accept?: string;
-    }): Promise<{
-        data: ArrayBuffer;
-        contentType: string;
-    }>;
-    resourceRepresentationStream(resourceId: ResourceId, options?: {
-        accept?: string;
-    }): Promise<{
-        stream: ReadableStream<Uint8Array>;
-        contentType: string;
-    }>;
-    resourceEvents(resourceId: ResourceId): Promise<StoredEventResponse[]>;
-    annotationHistory(resourceId: ResourceId, annotationId: AnnotationId): Promise<AnnotationHistoryResponse>;
-    connections(_resourceId: ResourceId): Promise<GraphConnection[]>;
-    backlinks(_resourceId: ResourceId): Promise<Annotation[]>;
-    resourcesByName(_query: string, _limit?: number): Promise<ResourceDescriptor$1[]>;
-    files(dirPath?: string, sort?: 'name' | 'mtime' | 'annotationCount'): Promise<ResponseContent$1<paths['/api/browse/files']['get']>>;
-    invalidateAnnotationList(resourceId: ResourceId): void;
-    invalidateAnnotationDetail(annotationId: AnnotationId): void;
-    invalidateResourceDetail(id: ResourceId): void;
-    invalidateResourceLists(): void;
-    invalidateEntityTypes(): void;
-    invalidateReferencedBy(resourceId: ResourceId): void;
-    updateAnnotationInPlace(resourceId: ResourceId, annotation: Annotation): void;
-    private subscribeToEvents;
-    private fetchAnnotationList;
-    private fetchAnnotationDetail;
-    private fetchResourceDetail;
-    private fetchResourceList;
-    private fetchEntityTypes;
-    private fetchReferencedBy;
-}
-
-/**
- * MarkNamespace — annotation CRUD, entity types, AI assist
- *
- * Commands return Promises that resolve on HTTP acceptance.
- * Results appear on browse Observables via events-stream.
- * assist() returns an Observable for long-running progress.
- *
- * Backend actor: Stower
- * Event prefix: mark:*
- */
-
-type TokenGetter$8 = () => AccessToken | undefined;
-declare class MarkNamespace implements MarkNamespace$1 {
-    private readonly http;
-    private readonly eventBus;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, eventBus: EventBus, getToken: TokenGetter$8);
-    annotation(resourceId: ResourceId, input: CreateAnnotationInput): Promise<{
-        annotationId: string;
-    }>;
-    delete(resourceId: ResourceId, annotationId: AnnotationId): Promise<void>;
-    entityType(type: string): Promise<void>;
-    entityTypes(types: string[]): Promise<void>;
-    updateResource(resourceId: ResourceId, data: UpdateResourceInput): Promise<void>;
-    archive(resourceId: ResourceId): Promise<void>;
-    unarchive(resourceId: ResourceId): Promise<void>;
-    assist(resourceId: ResourceId, motivation: Motivation, options: MarkAssistOptions): Observable<MarkAssistProgress>;
-    private dispatchAssist;
-}
-
-/**
- * BindNamespace — reference linking
- *
- * The simplest namespace. One method. The result (updated annotation
- * with resolved reference) arrives on browse.annotations() via the
- * enriched mark:body-updated event.
- *
- * Backend actor: Stower (via mark:update-body)
- * Event prefix: mark:body-updated (shares mark event pipeline)
- */
-
-type TokenGetter$7 = () => AccessToken | undefined;
-declare class BindNamespace implements BindNamespace$1 {
-    private readonly http;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, getToken: TokenGetter$7);
-    body(resourceId: ResourceId, annotationId: AnnotationId, operations: BodyOperation[]): Promise<void>;
+/** Minimal ViewModel surface — anything with a `dispose()` method. */
+interface ViewModel {
+    dispose(): void;
 }
 
-/**
- * GatherNamespace — context assembly
- *
- * Long-running (LLM calls + graph traversal). Returns Observables
- * that emit progress then the gathered context.
- *
- * Backend actor: Gatherer
- * Event prefix: gather:*
- */
-
-type TokenGetter$6 = () => AccessToken | undefined;
-declare class GatherNamespace implements GatherNamespace$1 {
-    private readonly http;
-    private readonly eventBus;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, eventBus: EventBus, getToken: TokenGetter$6);
-    annotation(annotationId: AnnotationId, resourceId: ResourceId, options?: {
-        contextWindow?: number;
-    }): Observable<GatherAnnotationProgress>;
-    resource(_resourceId: ResourceId, _options?: {
-        contextWindow?: number;
-    }): Observable<GatherAnnotationProgress>;
+interface BusEvent {
+    channel: string;
+    payload: Record<string, unknown>;
+    scope?: string;
 }
-
-/**
- * MatchNamespace — search and ranking
- *
- * Long-running (semantic search, optional LLM scoring). Returns
- * Observable with results.
- *
- * Backend actor: Matcher
- * Event prefix: match:*
- */
-
-type TokenGetter$5 = () => AccessToken | undefined;
-declare class MatchNamespace implements MatchNamespace$1 {
-    private readonly http;
-    private readonly eventBus;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, eventBus: EventBus, getToken: TokenGetter$5);
-    search(resourceId: ResourceId, referenceId: string, context: GatheredContext, options?: {
-        limit?: number;
-        useSemanticScoring?: boolean;
-    }): Observable<MatchSearchProgress>;
+interface ActorVMOptions {
+    baseUrl: string;
+    token: string | (() => string);
+    channels: string[];
+    scope?: string;
+    reconnectMs?: number;
 }
-
-/**
- * YieldNamespace — resource creation
- *
- * resource() is synchronous file upload (Promise).
- * fromAnnotation() is long-running LLM generation (Observable).
- *
- * Backend actor: Stower + generation worker
- * Event prefix: yield:*
- */
-
-type ResourceDescriptor = components['schemas']['ResourceDescriptor'];
-type TokenGetter$4 = () => AccessToken | undefined;
-declare class YieldNamespace implements YieldNamespace$1 {
-    private readonly http;
-    private readonly eventBus;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, eventBus: EventBus, getToken: TokenGetter$4);
-    resource(data: CreateResourceInput): Promise<{
-        resourceId: string;
-    }>;
-    fromAnnotation(resourceId: ResourceId, annotationId: AnnotationId, options: GenerationOptions): Observable<YieldProgress$1>;
-    cloneToken(resourceId: ResourceId): Promise<{
-        token: string;
-        expiresAt: string;
-    }>;
-    fromToken(token: string): Promise<ResourceDescriptor>;
-    createFromToken(options: CreateFromTokenOptions): Promise<{
-        resourceId: string;
-    }>;
+/** Time in the `reconnecting` state before transitioning to `degraded`. */
+declare const DEGRADED_THRESHOLD_MS = 3000;
+interface ActorVM extends ViewModel {
+    on$<T = Record<string, unknown>>(channel: string): Observable<T>;
+    emit(channel: string, payload: Record<string, unknown>, emitScope?: string): Promise<void>;
+    state$: Observable<ConnectionState>;
+    addChannels(channels: string[], scope?: string): void;
+    removeChannels(channels: string[]): void;
+    start(): void;
+    stop(): void;
 }
+declare function createActorVM(options: ActorVMOptions): ActorVM;
 
 /**
- * BeckonNamespace — attention coordination
+ * HttpTransport — the HTTP/SSE implementation of ITransport.
  *
- * Fire-and-forget. Ephemeral presence signal delivered via the
- * attention-stream to other participants.
+ * Phase 1 of TRANSPORT-ABSTRACTION. Owns everything that crosses the wire
+ * in remote mode: the bus actor (SSE + POST /bus/emit), auth/admin/exchange/
+ * system HTTP endpoints, and connection-state plumbing.
  *
- * Backend actor: (frontend relay via attention-stream)
- * Event prefix: beckon:*
- */
-
-type TokenGetter$3 = () => AccessToken | undefined;
-declare class BeckonNamespace implements BeckonNamespace$1 {
-    private readonly http;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, getToken: TokenGetter$3);
-    attention(annotationId: AnnotationId, resourceId: ResourceId): void;
-}
-
-/**
- * JobNamespace — worker lifecycle
- */
-
-type JobStatusResponse = components['schemas']['JobStatusResponse'];
-type TokenGetter$2 = () => AccessToken | undefined;
-declare class JobNamespace implements JobNamespace$1 {
-    private readonly http;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, getToken: TokenGetter$2);
-    status(jobId: JobId): Promise<JobStatusResponse>;
-    pollUntilComplete(jobId: JobId, options?: {
-        interval?: number;
-        timeout?: number;
-        onProgress?: (status: JobStatusResponse) => void;
-    }): Promise<JobStatusResponse>;
-    cancel(jobId: JobId, type: string): Promise<void>;
-}
-
-/**
- * AuthNamespace — authentication
+ * Does NOT own the local coordination bus — that lives on `SemiontClient`.
+ * `bridgeInto(bus)` wires SSE-received events into the caller-supplied bus
+ * once at construction.
  */
 
 type AuthResponse = components['schemas']['AuthResponse'];
-type TokenGetter$1 = () => AccessToken | undefined;
-declare class AuthNamespace implements AuthNamespace$1 {
-    private readonly http;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, getToken: TokenGetter$1);
-    password(emailStr: string, passwordStr: string): Promise<AuthResponse>;
-    google(credential: string): Promise<AuthResponse>;
-    refresh(token: string): Promise<AuthResponse>;
-    logout(): Promise<void>;
-    me(): Promise<User>;
-    acceptTerms(): Promise<void>;
-    mcpToken(): Promise<{
-        token: string;
-    }>;
-    mediaToken(resourceId: ResourceId): Promise<{
-        token: string;
-    }>;
-}
-
-/**
- * AdminNamespace — administration
- */
-
+type TokenRefreshResponse = components['schemas']['TokenRefreshResponse'];
 type AdminUserStatsResponse = components['schemas']['AdminUserStatsResponse'];
 type OAuthConfigResponse = components['schemas']['OAuthConfigResponse'];
-type TokenGetter = () => AccessToken | undefined;
-declare class AdminNamespace implements AdminNamespace$1 {
-    private readonly http;
-    private readonly getToken;
-    constructor(http: SemiontApiClient, getToken: TokenGetter);
-    users(): Promise<User[]>;
-    userStats(): Promise<AdminUserStatsResponse>;
-    updateUser(userId: UserDID, data: RequestContent$1<paths['/api/admin/users/{id}']['patch']>): Promise<User>;
-    oauthConfig(): Promise<OAuthConfigResponse>;
-    healthCheck(): Promise<ResponseContent$1<paths['/api/health']['get']>>;
-    status(): Promise<ResponseContent$1<paths['/api/status']['get']>>;
-    backup(): Promise<Response>;
-    restore(file: File, onProgress?: (event: {
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }) => void): Promise<{
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }>;
-    exportKnowledgeBase(params?: {
-        includeArchived?: boolean;
-    }): Promise<Response>;
-    importKnowledgeBase(file: File, onProgress?: (event: {
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }) => void): Promise<{
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }>;
-}
-
-/**
- * Common API client for Semiont backend
- *
- * This client can be used by:
- * - MCP server (Node.js)
- * - Demo scripts (Node.js)
- * - Frontend (Next.js/React - can wrap with hooks)
- *
- * Uses ky for HTTP requests with built-in retry, timeout, and error handling.
- */
-
-type ResponseContent<T> = T extends {
-    responses: {
-        200: {
-            content: {
-                'application/json': infer R;
-            };
-        };
-    };
-} ? R : T extends {
-    responses: {
-        201: {
-            content: {
-                'application/json': infer R;
-            };
-        };
-    };
-} ? R : never;
-type RequestContent<T> = T extends {
-    requestBody?: {
-        content: {
-            'application/json': infer R;
-        };
-    };
-} ? R : never;
 declare class APIError extends Error {
     status: number;
     statusText: string;
     details?: unknown | undefined;
     constructor(message: string, status: number, statusText: string, details?: unknown | undefined);
 }
-/**
- * Optional callback invoked when a request fails with HTTP 401. If it
- * resolves to a non-null token, the failed request is retried once with
- * the new Bearer token. If it resolves to null (or throws), the original
- * 401 propagates as an APIError.
- *
- * Implementations must dedupe concurrent calls so that simultaneous 401s
- * don't fire multiple parallel refresh requests. The frontend's
- * KnowledgeBaseSessionProvider provides this via an in-flight Promise map
- * keyed by KB id.
- */
 type TokenRefresher = () => Promise<string | null>;
-interface SemiontApiClientConfig {
+interface HttpTransportConfig {
     baseUrl: BaseUrl;
-    /** Per-workspace EventBus. Required — one bus per workspace, constructed externally. */
-    eventBus: EventBus;
+    /** Observable token source; headers read the current value. */
+    token$?: BehaviorSubject<AccessToken | null>;
     timeout?: number;
     retry?: number;
     logger?: Logger;
     /** Optional 401-recovery hook. See {@link TokenRefresher}. */
     tokenRefresher?: TokenRefresher;
-    /**
-     * Token getter for the verb-namespace API (client.browse, client.mark, etc.).
-     * When provided, auth is managed internally — no per-call auth needed.
-     * The getter is called on each request to get the current token.
-     * If not provided, namespace methods use undefined auth (public endpoints only).
-     */
-    getToken?: () => AccessToken | undefined;
 }
-/**
- * Options for individual API requests
- */
-interface RequestOptions {
-    /** Access token for this request */
-    auth?: AccessToken;
-}
-/**
- * Semiont API Client
- *
- * Provides type-safe methods for all Semiont backend API endpoints.
- * This client is fully stateless - authentication must be provided per request.
- */
-declare class SemiontApiClient {
-    private http;
+declare class HttpTransport implements ITransport {
     readonly baseUrl: BaseUrl;
-    /** The workspace-scoped EventBus this client was constructed with. */
-    readonly eventBus: EventBus;
-    private logger?;
-    /**
-     * Shared mutable token getter. All verb namespaces read from this.
-     * Updated via setTokenGetter() from the React auth layer.
-     */
-    private _getToken;
-    /**
-     * SSE streaming client for real-time operations
-     *
-     * Separate from the main HTTP client to clearly mark streaming endpoints.
-     * Uses native fetch() instead of ky for SSE support.
-     */
-    readonly sse: SSEClient;
-    readonly browse: BrowseNamespace;
-    readonly mark: MarkNamespace;
-    readonly bind: BindNamespace;
-    readonly gather: GatherNamespace;
-    readonly match: MatchNamespace;
-    readonly yield: YieldNamespace;
-    readonly beckon: BeckonNamespace;
-    readonly job: JobNamespace;
-    readonly auth: AuthNamespace;
-    readonly admin: AdminNamespace;
-    constructor(config: SemiontApiClientConfig);
-    /**
-     * Update the token getter for all verb namespaces.
-     * Called from the React auth layer when the token changes.
-     * All namespaces share this getter via closure — no per-namespace sync needed.
-     */
-    setTokenGetter(getter: () => AccessToken | undefined): void;
+    private readonly http;
+    private readonly token$;
+    private readonly logger?;
+    private _actor;
+    private _actorStarted;
+    private disposed;
+    private activeResource;
+    /** Buses we've been asked to bridge wire events into. */
+    private readonly bridges;
+    constructor(config: HttpTransportConfig);
+    get actor(): ActorVM;
+    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<void>;
+    on<K extends keyof EventMap>(channel: K, handler: (payload: EventMap[K]) => void): () => void;
+    stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
+    /**
+     * Wire this transport's SSE fan-in into the given bus. Every channel
+     * in `BRIDGED_CHANNELS` (and subsequently per-resource scoped channels
+     * opened by `subscribeToResource`) is published on the bus. Safe to
+     * call multiple times — each bus is added to the fan-out list.
+     */
+    bridgeInto(bus: EventBus): void;
+    subscribeToResource(resourceId: ResourceId): () => void;
+    private makeUnsubscriber;
+    get state$(): Observable<ConnectionState>;
+    dispose(): void;
     private authHeaders;
-    authenticatePassword(email: Email, password: string, options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/password']['post']>>;
-    refreshToken(token: RefreshToken, options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/refresh']['post']>>;
-    authenticateGoogle(credential: GoogleCredential, options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/google']['post']>>;
-    generateMCPToken(options?: RequestOptions): Promise<ResponseContent<paths['/api/tokens/mcp-generate']['post']>>;
-    getMediaToken(resourceId: ResourceId, options?: RequestOptions): Promise<{
+    authenticatePassword(email: Email, password: string): Promise<AuthResponse>;
+    authenticateGoogle(credential: GoogleCredential): Promise<AuthResponse>;
+    refreshAccessToken(token: RefreshToken): Promise<TokenRefreshResponse>;
+    logout(): Promise<void>;
+    acceptTerms(): Promise<void>;
+    getCurrentUser(): Promise<UserResponse>;
+    generateMcpToken(): Promise<{
         token: string;
     }>;
-    getMe(options?: RequestOptions): Promise<ResponseContent<paths['/api/users/me']['get']>>;
-    acceptTerms(options?: RequestOptions): Promise<ResponseContent<paths['/api/users/accept-terms']['post']>>;
-    logout(options?: RequestOptions): Promise<ResponseContent<paths['/api/users/logout']['post']>>;
+    getMediaToken(resourceId: ResourceId): Promise<{
+        token: string;
+    }>;
+    listUsers(): Promise<ListUsersResponse>;
+    getUserStats(): Promise<AdminUserStatsResponse>;
+    updateUser(id: UserDID, data: UpdateUserRequest): Promise<UpdateUserResponse>;
+    getOAuthConfig(): Promise<OAuthConfigResponse>;
+    backupKnowledgeBase(): Promise<Response>;
+    restoreKnowledgeBase(file: File, onProgress?: ProgressCallback): Promise<ProgressEvent>;
+    exportKnowledgeBase(params?: {
+        includeArchived?: boolean;
+    }): Promise<Response>;
+    importKnowledgeBase(file: File, onProgress?: ProgressCallback): Promise<ProgressEvent>;
+    private parseSSEStream;
+    healthCheck(): Promise<HealthCheckResponse>;
+    getStatus(): Promise<StatusResponse>;
     /**
-     * Create a new resource with binary content support
-     *
-     * @param data - Resource creation data
-     * @param data.name - Resource name
-     * @param data.file - File object or Buffer with binary content
-     * @param data.format - MIME type (e.g., 'text/markdown', 'image/png')
-     * @param data.entityTypes - Optional array of entity types
-     * @param data.language - Optional ISO 639-1 language code
-     * @param data.creationMethod - Optional creation method
-     * @param data.sourceAnnotationId - Optional source annotation ID
-     * @param data.sourceResourceId - Optional source resource ID
-     * @param options - Request options including auth
+     * Temporary escape hatch for the ongoing transport migration: namespaces
+     * that still need to issue ad-hoc HTTP calls (e.g. legacy browse/mark
+     * HTTP fallbacks) can borrow the configured `ky` instance here. Will be
+     * deleted once all namespaces route through bus channels or through
+     * typed methods on this transport.
      */
-    yieldResource(data: {
-        name: string;
-        file: File | Buffer;
-        format: string;
-        entityTypes?: string[];
-        language?: string;
-        creationMethod?: string;
-        sourceAnnotationId?: string;
-        sourceResourceId?: string;
-        storageUri: string;
-    }, options?: RequestOptions): Promise<{
-        resourceId: string;
-    }>;
-    browseResource(id: ResourceId, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}']['get']>>;
+    get rawHttp(): KyInstance;
     /**
-     * Get resource representation using W3C content negotiation
-     * Returns raw binary content (images, PDFs, text, etc.) with content type
-     *
-     * @param resourceUri - Full resource URI
-     * @param options - Options including Accept header for content negotiation and auth
-     * @returns Object with data (ArrayBuffer) and contentType (string)
-     *
-     * @example
-     * ```typescript
-     * // Get markdown representation
-     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'text/markdown', auth: token });
-     * const markdown = new TextDecoder().decode(data);
-     *
-     * // Get image representation
-     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'image/png', auth: token });
-     * const blob = new Blob([data], { type: contentType });
-     *
-     * // Get PDF representation
-     * const { data, contentType } = await client.getResourceRepresentation(rUri, { accept: 'application/pdf', auth: token });
-     * ```
+     * Current access token (synchronously read from the BehaviorSubject).
+     * Used by content-transport and legacy namespace HTTP fallbacks that
+     * need to pass `auth: token` through some code paths.
      */
-    getResourceRepresentation(id: ResourceId, options?: {
-        accept?: ContentFormat;
+    getToken(): AccessToken | undefined;
+}
+
+/**
+ * HttpContentTransport — binary I/O over HTTP.
+ *
+ * Phase 1 of TRANSPORT-ABSTRACTION. Narrow by design because binary has
+ * different backpressure and streaming characteristics than typed command
+ * payloads. Uses the HttpTransport's underlying ky instance + token, so
+ * retries, logging, and auth behave identically to the rest of the wire.
+ */
+
+declare class HttpContentTransport implements IContentTransport {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    putBinary(request: PutBinaryRequest, options?: {
+        auth?: AccessToken;
+    }): Promise<{
+        resourceId: ResourceId;
+    }>;
+    getBinary(resourceId: ResourceId, options?: {
+        accept?: ContentFormat | string;
         auth?: AccessToken;
     }): Promise<{
         data: ArrayBuffer;
         contentType: string;
     }>;
-    /**
-     * Get resource representation as a stream using W3C content negotiation
-     * Returns streaming binary content (for large files: videos, large PDFs, etc.)
-     *
-     * Use this for large files to avoid loading entire content into memory.
-     * The stream is consumed incrementally and the backend connection stays open
-     * until the stream is fully consumed or closed.
-     *
-     * @param resourceUri - Full resource URI
-     * @param options - Options including Accept header for content negotiation and auth
-     * @returns Object with stream (ReadableStream) and contentType (string)
-     *
-     * @example
-     * ```typescript
-     * // Stream large file
-     * const { stream, contentType } = await client.getResourceRepresentationStream(rUri, {
-     *   accept: 'video/mp4',
-     *   auth: token
-     * });
-     *
-     * // Consume stream chunk by chunk (never loads entire file into memory)
-     * for await (const chunk of stream) {
-     *   // Process chunk
-     *   console.log(`Received ${chunk.length} bytes`);
-     * }
-     *
-     * // Or pipe to a file in Node.js
-     * const fileStream = fs.createWriteStream('output.mp4');
-     * const reader = stream.getReader();
-     * while (true) {
-     *   const { done, value } = await reader.read();
-     *   if (done) break;
-     *   fileStream.write(value);
-     * }
-     * ```
-     */
-    getResourceRepresentationStream(id: ResourceId, options?: {
-        accept?: ContentFormat;
+    getBinaryStream(resourceId: ResourceId, options?: {
+        accept?: ContentFormat | string;
         auth?: AccessToken;
     }): Promise<{
         stream: ReadableStream<Uint8Array>;
         contentType: string;
     }>;
-    browseResources(limit?: number, archived?: boolean, query?: SearchQuery, options?: RequestOptions): Promise<ResponseContent<paths['/resources']['get']>>;
-    updateResource(id: ResourceId, data: RequestContent<paths['/resources/{id}']['patch']>, options?: RequestOptions): Promise<void>;
-    getResourceEvents(id: ResourceId, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/events']['get']>>;
-    browseReferences(id: ResourceId, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/referenced-by']['get']>>;
-    generateCloneToken(id: ResourceId, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/clone-with-token']['post']>>;
-    getResourceByToken(token: CloneToken, options?: RequestOptions): Promise<ResponseContent<paths['/api/clone-tokens/{token}']['get']>>;
-    createResourceFromToken(data: RequestContent<paths['/api/clone-tokens/create-resource']['post']>, options?: RequestOptions): Promise<{
-        resourceId: string;
-    }>;
-    markAnnotation(id: ResourceId, data: RequestContent<paths['/resources/{id}/annotations']['post']>, options?: RequestOptions): Promise<{
-        annotationId: string;
-    }>;
-    getAnnotation(id: AnnotationId, options?: RequestOptions): Promise<ResponseContent<paths['/annotations/{id}']['get']>>;
-    browseAnnotation(resourceId: ResourceId, annotationId: AnnotationId, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}']['get']>>;
-    browseAnnotations(id: ResourceId, motivation?: Motivation, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{id}/annotations']['get']>>;
-    deleteAnnotation(resourceId: ResourceId, annotationId: AnnotationId, options?: RequestOptions): Promise<void>;
-    bindAnnotation(resourceId: ResourceId, annotationId: AnnotationId, data: {
-        operations: BodyOperation[];
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-    }>;
-    getAnnotationHistory(resourceId: ResourceId, annotationId: AnnotationId, options?: RequestOptions): Promise<ResponseContent<paths['/resources/{resourceId}/annotations/{annotationId}/history']['get']>>;
-    annotateReferences(resourceId: ResourceId, data: {
-        entityTypes: string[];
-        includeDescriptiveReferences?: boolean;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-        jobId: string;
-    }>;
-    annotateHighlights(resourceId: ResourceId, data: {
-        instructions?: string;
-        density?: number;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-        jobId: string;
-    }>;
-    annotateAssessments(resourceId: ResourceId, data: {
-        instructions?: string;
-        tone?: string;
-        density?: number;
-        language?: string;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-        jobId: string;
-    }>;
-    annotateComments(resourceId: ResourceId, data: {
-        instructions?: string;
-        tone?: string;
-        density?: number;
-        language?: string;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-        jobId: string;
-    }>;
-    annotateTags(resourceId: ResourceId, data: {
-        schemaId: string;
-        categories: string[];
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-        jobId: string;
-    }>;
-    yieldResourceFromAnnotation(resourceId: ResourceId, annotationId: AnnotationId, data: {
-        title: string;
-        storageUri: string;
-        context: unknown;
-        prompt?: string;
-        language?: string;
-        temperature?: number;
-        maxTokens?: number;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-        jobId: string;
-    }>;
-    gatherAnnotationContext(resourceId: ResourceId, annotationId: AnnotationId, data: {
-        correlationId: string;
-        contextWindow?: number;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-    }>;
-    matchSearch(resourceId: ResourceId, data: {
-        correlationId: string;
-        referenceId: string;
-        context: unknown;
-        limit?: number;
-        useSemanticScoring?: boolean;
-    }, options?: RequestOptions): Promise<{
-        correlationId: string;
-    }>;
-    addEntityType(type: EntityType, options?: RequestOptions): Promise<void>;
-    addEntityTypesBulk(types: EntityType[], options?: RequestOptions): Promise<void>;
-    listEntityTypes(options?: RequestOptions): Promise<ResponseContent<paths['/api/entity-types']['get']>>;
-    beckonAttention(participantId: string, data: RequestContent<paths['/api/participants/{id}/attention']['post']>, options?: RequestOptions): Promise<ResponseContent<paths['/api/participants/{id}/attention']['post']>>;
-    listUsers(options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/users']['get']>>;
-    getUserStats(options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/users/stats']['get']>>;
-    /**
-     * Update a user by ID
-     * Note: Users use DID identifiers (did:web:domain:users:id), not HTTP URIs.
-     */
-    updateUser(id: UserDID, data: RequestContent<paths['/api/admin/users/{id}']['patch']>, options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/users/{id}']['patch']>>;
-    getOAuthConfig(options?: RequestOptions): Promise<ResponseContent<paths['/api/admin/oauth/config']['get']>>;
-    /**
-     * Create a backup of the knowledge base. Returns raw Response for streaming download.
-     * Caller should use response.blob() to trigger a file download.
-     */
-    backupKnowledgeBase(options?: RequestOptions): Promise<Response>;
-    /**
-     * Restore knowledge base from a backup file. Parses SSE progress events and calls onProgress.
-     * Returns the final SSE event (phase: 'complete' or 'error').
-     */
-    restoreKnowledgeBase(file: File, options?: RequestOptions & {
-        onProgress?: (event: {
-            phase: string;
-            message?: string;
-            result?: Record<string, unknown>;
-        }) => void;
-    }): Promise<{
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }>;
-    /**
-     * Export the knowledge base as a JSON-LD Linked Data archive. Returns raw Response for streaming download.
-     * Caller should use response.blob() to trigger a file download.
-     */
-    exportKnowledgeBase(params?: {
-        includeArchived?: boolean;
-    }, options?: RequestOptions): Promise<Response>;
-    /**
-     * Import a JSON-LD Linked Data archive into the knowledge base. Parses SSE progress events and calls onProgress.
-     * Returns the final SSE event (phase: 'complete' or 'error').
-     */
-    importKnowledgeBase(file: File, options?: RequestOptions & {
-        onProgress?: (event: {
-            phase: string;
-            message?: string;
-            result?: Record<string, unknown>;
-        }) => void;
-    }): Promise<{
-        phase: string;
-        message?: string;
-        result?: Record<string, unknown>;
-    }>;
-    private parseSSEStream;
-    getJobStatus(id: JobId, options?: RequestOptions): Promise<ResponseContent<paths['/api/jobs/{id}']['get']>>;
-    /**
-     * Poll a job until it completes or fails
-     * @param id - The job ID to poll
-     * @param options - Polling options
-     * @returns The final job status
-     */
-    pollJobUntilComplete(id: JobId, options?: {
-        interval?: number;
-        timeout?: number;
-        onProgress?: (status: ResponseContent<paths['/api/jobs/{id}']['get']>) => void;
-        auth?: AccessToken;
-    }): Promise<ResponseContent<paths['/api/jobs/{id}']['get']>>;
-    healthCheck(options?: RequestOptions): Promise<ResponseContent<paths['/api/health']['get']>>;
-    getStatus(options?: RequestOptions): Promise<ResponseContent<paths['/api/status']['get']>>;
-    browseFiles(dirPath?: string, sort?: 'name' | 'mtime' | 'annotationCount', options?: RequestOptions): Promise<ResponseContent<paths['/api/browse/files']['get']>>;
+    dispose(): void;
+    /** Auth header + W3C trace propagation for the active span. */
+    private requestHeaders;
 }
 
-/**
- * MIME type utilities for Semiont
- *
- * Initial support for:
- * - text/plain
- * - text/markdown
- * - image/png
- * - image/jpeg
- * - application/pdf
- */
-/**
- * Map MIME type to file extension
- */
-declare function getExtensionForMimeType(mimeType: string): string;
-/**
- * Detect if MIME type is an image (png or jpeg only for now)
- */
-declare function isImageMimeType(mimeType: string): boolean;
-/**
- * Detect if MIME type is text-based (plain or markdown only for now)
- */
-declare function isTextMimeType(mimeType: string): boolean;
-/**
- * Detect if MIME type is PDF
- */
-declare function isPdfMimeType(mimeType: string): boolean;
-/**
- * Get category for MIME type (for routing to appropriate viewer)
- *
- * Categories represent annotation models, not file formats:
- * - 'text': Text-based annotations (TextPositionSelector, TextQuoteSelector)
- * - 'image': Spatial coordinate annotations (SvgSelector, FragmentSelector)
- *
- * PDFs use spatial coordinates for annotations, so they belong to 'image' category.
- */
-type MimeCategory = 'text' | 'image' | 'unsupported';
-declare function getMimeCategory(mimeType: string): MimeCategory;
-
-export { APIError, AdminNamespace, type AnnotationHistoryResponse, AuthNamespace, BeckonNamespace, BindNamespace, BrowseNamespace, type CreateAnnotationInput, type CreateFromTokenOptions, type CreateResourceInput, type GatherAnnotationProgress, GatherNamespace, type GenerationOptions, JobNamespace, type MarkAssistOptions, type MarkAssistProgress, MarkNamespace, MatchNamespace, type MatchSearchProgress, type MimeCategory, type ReferenceDetectionProgress, type ReferencedByEntry, type RequestContent$1 as RequestContent, type RequestOptions, type ResponseContent$1 as ResponseContent, SSEClient, type SSEClientConfig, type SSEStream, type SSEStreamConnected, SSE_STREAM_CONNECTED, SemiontApiClient, type SemiontApiClientConfig, type TokenRefresher, type User, YieldNamespace, type YieldProgress, getExtensionForMimeType, getMimeCategory, isImageMimeType, isPdfMimeType, isTextMimeType };
+export { APIError, type ActorVM, type ActorVMOptions, type BusEvent, DEGRADED_THRESHOLD_MS, HttpContentTransport, HttpTransport, type HttpTransportConfig, type TokenRefresher, createActorVM };