@semiont/core 0.5.26 → 0.5.27

package/dist/index.d.ts

@@ -1353,12 +1353,14 @@ interface paths {
                 };
             };
             responses: {
-                /** @description Event accepted and published to subscribers */
+                /** @description Event accepted and published. The body reports how many subscribers the target subject had at dispatch; zero means the signal reached nobody. */
                 202: {
                     headers: {
                         [name: string]: unknown;
                     };
-                    content?: never;
+                    content: {
+                        "application/json": components["schemas"]["BusEmitAccepted"];
+                    };
                 };
                 /** @description Missing/invalid channel, payload, or scope; or payload failed schema validation for the channel */
                 400: {
@@ -2082,9 +2084,10 @@ interface components {
             refreshToken: string;
             isNewUser: boolean;
         };
-        /** @description Emitted when an annotation receives focus for beckoning */
+        /** @description Emitted when an annotation receives focus for beckoning. resourceId is a guard, not navigation: it names the resource this focus applies to, and a viewer currently showing a different resource ignores the event — a deliberate ignore rather than a silent no-op. Focus never moves the viewer; driving the Browser to a resource is browse:resource-open's job. */
         BeckonFocusEvent: {
             annotationId?: string;
+            /** @description Guard: the resource this focus applies to. A viewer showing a different resource ignores the event. Never causes navigation. */
             resourceId?: string;
         };
         /** @description Emitted when an annotation is hovered over for beckoning */
@@ -2210,10 +2213,9 @@ interface components {
             correlationId: string;
             response: components["schemas"]["GetAnnotationsResponse"];
         };
-        /** @description Emitted when an annotation is clicked in the browse panel */
+        /** @description An annotation was clicked — open it: the viewer selects its entry in the annotations panel and relays a focus signal to scroll to it. The annotation id is the whole address; it identifies exactly one annotation on exactly one resource, so no resource field is carried and none is needed to scope the event. Motivation is NOT on the wire either: the viewer derives it from the annotation the id names, so the wire states the fact once. A viewer that has not loaded that annotation finds nothing and does nothing. Emitted locally by every clickable annotation surface, and over the wire by a driver opening an annotation on another participant's screen. */
         BrowseClickEvent: {
             annotationId: string;
-            motivation: components["schemas"]["Motivation"];
         };
         /** @description Request to browse a directory listing */
         BrowseDirectoryRequest: {
@@ -2281,8 +2283,12 @@ interface components {
         BrowsePanelToggleEvent: {
             panel: string;
         };
-        /** @description Emitted when navigation to a reference resource is requested */
-        BrowseReferenceNavigateEvent: {
+        /** @description Domain intent to open a resource in the viewer (GUIDED-TOUR D1/D2): emitted locally by in-app link handlers and remotely by the launcher's tour verbs; the viewer translates it to host routing (nav:push). Deliberately not named 'navigate' — that word and the nav:* prefix belong to the host-local framework layer. */
+        BrowseResourceOpenEvent: {
+            resourceId: string;
+        };
+        /** @description REPORT that a resource has loaded in a viewer — emitted on arrival by ANY means: a followed cue, an in-app link, the back button, a typed URL (GUIDED-TOUR D6). Deliberately distinct from the imperative browse:resource-open: drive and report never share a channel, or the driver hears its own commands and one viewer's arrival steers another's page. */
+        BrowseResourceViewedEvent: {
             resourceId: string;
         };
         /** @description Request to browse annotations that reference a resource */
@@ -2373,6 +2379,11 @@ interface components {
             correlationId: string;
             response: components["schemas"]["GetTagSchemasResponse"];
         };
+        /** @description Result of publishing one event. `subscribers` is the number of observers attached to the target subject at dispatch — the GLOBAL subject for an unscoped emit, the scoped one when `scope` is set. Zero means the signal reached nobody: /bus/subscribe enforces no channel allowlist and the emit handler publishes unconditionally, so a client can emit a channel no participant subscribes to and otherwise receive a clean 202 with no way to tell. Deliberately NOT named `delivered`: this is the count at dispatch, and a subscriber may still drop the frame downstream, so the field is named after what the server can actually observe. */
+        BusEmitAccepted: {
+            /** @description Observers on the target subject when the event was dispatched. */
+            subscribers: number;
+        };
         /** @description Emit an event on the Semiont bus. Channel names come from bus-protocol.ts; payload shape is validated against the channel's registered schema (CHANNEL_SCHEMAS). An optional scope routes resource-scoped broadcasts (e.g. mark:added, job:complete) to per-resource subscribers via eventBus.scope(scope); leave it unset for unscoped/global events. */
         BusEmitRequest: {
             /** @description Channel name from bus-protocol.ts EventMap */
@@ -2412,6 +2423,8 @@ interface components {
             agent: components["schemas"]["Agent"];
             /** @description Job types this agent is declared to serve (from the KB's workers.* config sections). Absent for Persons and for agents declared only under actor roles. */
             servesJobTypes?: components["schemas"]["JobType"][];
+            /** @description Discovered context/output ceilings for this agent's model; absent when discovery is currently unavailable. */
+            limits?: components["schemas"]["InferenceLimits"];
         };
         /** @description Error response for failed bus commands. Replaces native Error objects on the EventBus so payloads are serializable and OpenAPI-typed. */
         CommandError: {
@@ -2792,6 +2805,35 @@ interface components {
             /** @description LLM-generated summary of the focal anchor's relationships in the knowledge graph */
             inferredRelationshipSummary?: string;
         };
+        /** @description Params bag for `job:create` with `jobType: 'generation'` — exactly the shape yield.fromContext(context, options) takes: options + the gathered context. The job's ids are DERIVED from context.focus at the dispatcher (resource focus → focus.resource; annotation focus → focus.sourceResource, with the worker auto-binding to focus.annotation); a caller-supplied referenceId is rejected. Carried inside JobCreateCommand.params; this schema is the generation shape's contract, including its requiredness. */
+        GenerationJobParams: {
+            /** @description Title of the generated resource. */
+            title: string;
+            /** @description Storage URI for the generated resource's content. */
+            storageUri: string;
+            /** @description The gathered context that grounds the generation. Its `focus` names the anchor (the sdk derives the job's resourceId — and referenceId, for annotation focus — from it); under `cite`, the ids its embedding carries are the only valid citation targets. */
+            context: components["schemas"]["GatheredContext"];
+            /** @description Refining instruction, composed with `task` (task = what, prompt = how). */
+            prompt?: string;
+            /** @description Entity-type tags to stamp on the synthesized resource. Used both as a prompt bias for the generation worker and as the `entityTypes` set on the resulting resource. */
+            entityTypes?: string[];
+            /** @description Annotation/resource body locale — language the generated resource is written in (typically the user's UI locale). BCP-47. */
+            language?: string;
+            /** @description Source-resource locale — language of the resource being referenced, used in the prompt so the LLM understands embedded source-context snippets when source ≠ target language. BCP-47. */
+            sourceLanguage?: string;
+            /** @description Sampling temperature forwarded to the model. */
+            temperature?: number;
+            /** @description Output token budget forwarded to the model. Length never determines structure. */
+            maxTokens?: number;
+            /** @description Requested media type of the generated resource's content. Default `text/markdown` at the worker, which validates it against its supported output set and FAILS the job for anything it can't write — not a silent fallback. */
+            outputMediaType?: components["schemas"]["SupportedMediaType"];
+            /** @description What the model is asked to produce — the prompt's framing verb. Canonical values ('resource', 'answer', 'summary') map to the worker's tested framings; any other string is used VERBATIM as the framing instruction (loud degrade: the worker warns, never silently falls back). Unset ⇒ 'resource' (article framing). */
+            task?: string;
+            /** @description How the output is internally segmented — shape for text-bearing media, subordinate to `outputMediaType` (never its peer). Canonical values: 'prose' (flowing paragraphs), 'sections' (titled sections + title), 'chat' (speaker-labeled turns); any other string becomes a freeform "organize as: …" directive (loud degrade). Unset ⇒ NO structure directive at all — the task framing and the model determine shape. */
+            structure?: string;
+            /** @description Ask the model to cite: emit [[<id>]] transport tokens after each claim, using the ids the context embedding provides. The worker validates each id against the embedded context (unknown ids are dropped loudly), strips the tokens from the stored content, and mints W3C linking annotations on the derived resource. */
+            cite?: boolean;
+        };
         GetAnnotationHistoryResponse: {
             events: components["schemas"]["StoredEventResponse"][];
             total: number;
@@ -2861,6 +2903,13 @@ interface components {
             database: "connected" | "disconnected" | "unknown";
             environment: string;
         };
+        /** @description A provider's actual ceilings for a model, discovered from the provider itself (Anthropic Models API; Ollama /api/show) — never hand-maintained constants. Semantics differ by provider shape: Anthropic reports maximum input tokens in contextTokens with a separate output ceiling in maxOutputTokens; Ollama reports the shared input+output window and mirrors it into both fields (there is no separate output ceiling), so maxOutputTokens === contextTokens signals a shared window. */
+        InferenceLimits: {
+            /** @description The context window in tokens. Anthropic: maximum input tokens (output has its own ceiling). Ollama: the shared input+output window. */
+            contextTokens: number;
+            /** @description Maximum output tokens per generation. Equal to contextTokens when the provider has a single shared window. */
+            maxOutputTokens: number;
+        };
         /** @description Result of a completed assessment-annotation job. */
         JobAssessmentAnnotationResult: {
             assessmentsFound: number;
@@ -2907,7 +2956,6 @@ interface components {
             resultResourceId?: string;
             /** @description For generation: URI of annotation that triggered generation */
             annotationUri?: string;
-            message?: string;
             /** @description Full result object for extensibility */
             result?: {
                 [key: string]: unknown;
@@ -2919,7 +2967,8 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             jobType: components["schemas"]["JobType"];
-            resourceId: string;
+            /** @description Resource the job operates on. REQUIRED for every jobType EXCEPT 'generation', where it must be ABSENT: the dispatcher derives it from params.context.focus (the context is authoritative) and REJECTS a supplied value via job:create-failed. Both directions are enforced at the dispatcher — this schema cannot express the per-jobType conditionality. */
+            resourceId?: string;
             params: {
                 [key: string]: unknown;
             };
@@ -2950,12 +2999,10 @@ interface components {
              */
             declined: true;
             /**
-             * @description Why the resource could not be read.
+             * @description Why the resource could not be read. A CODE, not a sentence: the client owns the wording, so a browser renders it in the user's language and the CLI renders English terminal copy from the same value. The prose `message` this schema used to carry was composed backend-side and was therefore English everywhere (ASSIST-PROGRESS-CONSOLIDATION P5).
              * @enum {string}
              */
             reason: "no-text-layer" | "encrypted" | "corrupt" | "too-large" | "empty";
-            /** @description Human-readable explanation, suitable for showing to the user. */
-            message: string;
         };
         /** @description Payload for job:failed domain event */
         JobFailedPayload: {
@@ -2978,59 +3025,74 @@ interface components {
             highlightsFound: number;
             highlightsCreated: number;
         };
-        /** @description Progress report from a running job. Common fields are stage/percentage/message; job-type-specific fields may also be present. This is the single progress shape for every job type — annotation workers and generation alike. */
+        /** @description Progress report from a running job. The required field is `percentage`; `message` carries the coded phase and the rest are optional job-shape fields. This is the single progress shape for every job type — annotation workers and generation alike. `stage` and `currentEntityType` were REMOVED (ASSIST-PROGRESS-CONSOLIDATION P5): both were redundant denormalization of `message`. Terminality is signalled on `job:complete` / `job:fail`, not here. The per-flow progress vocabularies (`processedEntityTypes`/`totalEntityTypes` for references, `processedCategories`/`totalCategories`/`currentCategory` for tags) were replaced by one `current`/`processed`/`total` triple (CLEAN-PROGRESS D2): both flows iterate a user-chosen list, so they report the same shape and the client stops guessing which flow it is drawing. */
         JobProgress: {
-            /** @description Current processing stage (e.g. 'analyzing', 'creating', 'complete', 'error') */
-            stage: string;
             /** @description Completion percentage (0-100) */
             percentage: number;
-            /** @description Human-readable progress message */
-            message: string;
-            /** @description Annotation this job is attached to, when applicable. Echoed inside JobProgress (in addition to the outer command envelope) so consumers that only see the inner progress object (e.g. client.yield.fromAnnotation's Observable) can still route visual feedback to a specific annotation. */
+            /** @description What the job is doing right now, as a code plus typed params; the client renders the sentence. Optional: pure percentage heartbeats carry none, and consumers render nothing message-shaped when it is absent (this is also the whole tolerance story for pre-2026-08 persisted events that carried prose here). */
+            message?: components["schemas"]["JobProgressMessage"];
+            /** @description Annotation this job is attached to, when applicable. Echoed inside JobProgress (in addition to the outer command envelope) so consumers that only see the inner progress object (e.g. client.yield.fromContext's Observable) can still route visual feedback to a specific annotation. */
             annotationId?: string;
-            /** @description Total entity types to process (reference-annotation) */
-            totalEntityTypes?: number;
-            /** @description Entity types processed so far (reference-annotation) */
-            processedEntityTypes?: number;
+            /** @description What the run is working on right now. `kind` is a CODE the client renders a localized name for; `value` is KB data (an entity type, a tag category) shown verbatim — the same split as `requestParams`. Absent on flows that iterate nothing, such as generation. */
+            current?: {
+                /**
+                 * @description What sort of thing `value` is. Adding a variant means adding client copy for it in every locale.
+                 * @enum {string}
+                 */
+                kind: "entity-type" | "category";
+                /** @description The item itself, shown verbatim and never translated. */
+                value: string;
+            };
+            /** @description Items completed so far, zero-based — the item in `current` is the one after these. Paired with `total`. */
+            processed?: number;
+            /** @description Items this run will process in all. */
+            total?: number;
             /** @description Entities found so far (reference-annotation) */
             entitiesFound?: number;
             /** @description Annotations emitted so far (reference-annotation) */
             entitiesEmitted?: number;
-            /** @description Entity type currently being processed */
-            currentEntityType?: string;
-            /** @description Reference annotation: completed entity types with per-type counts, for UI progress display */
-            completedEntityTypes?: {
-                entityType: string;
+            /** @description Per-item results for the items already finished, for the UI's completed log. Generic across flows for the same reason `current` is. */
+            completedItems?: {
+                /** @description The item, shown verbatim. */
+                value: string;
+                /** @description Annotations found for it. */
                 foundCount: number;
             }[];
-            /** @description Categories processed (tag-annotation) */
-            processedCategories?: number;
-            /** @description Total categories (tag-annotation) */
-            totalCategories?: number;
-            /** @description Category currently being processed (tag-annotation) */
-            currentCategory?: string;
-            /** @description Echoed job parameters for display in the progress UI (e.g. entity types or categories the user asked to detect) */
+            /** @description Echoed job parameters for display in the progress UI. `label` is a CODE, not a sentence — the client owns the wording, same rule as the progress message. `value` is the user's own input (an entity-type list, their instructions) and is deliberately NOT translated: it is their words, not ours. */
             requestParams?: {
-                label: string;
+                /**
+                 * @description Which parameter this is. The client renders a localized name for it.
+                 * @enum {string}
+                 */
+                label: "entity-types" | "instructions" | "tone" | "density";
+                /** @description The user's own input, shown verbatim. */
                 value: string;
             }[];
         };
-        /** @description Payload for job:progress domain event */
-        JobProgressPayload: {
-            jobId: string;
-            jobType: components["schemas"]["JobType"];
-            percentage: number;
-            /** @description Human-readable current step */
-            currentStep?: string;
-            processedSteps?: number;
-            totalSteps?: number;
-            /** @description For detection: entities found so far */
-            foundCount?: number;
-            message?: string;
-            /** @description Full progress object for extensibility */
-            progress?: {
-                [key: string]: unknown;
-            };
+        /** @description What a running job is doing right now, as a code plus typed params — never a prose sentence. The producer reports what happened; each client renders it in the user's language (react-ui from its translations, the Go launcher from its English map). The vocabulary is the census of every onProgress call site in @semiont/jobs (.plans/ASSIST-PROGRESS-CONSOLIDATION.md P1, 2026-08-12); extending it means adding a variant here and copy in every client, gated by the locale-completeness check. */
+        JobProgressMessage: {
+            /** @enum {string} */
+            code: "loading" | "analyzing" | "analyzing-tags" | "generating-resource" | "creating-resource";
+        } | {
+            /** @enum {string} */
+            code: "detecting-entities";
+            /** @description Entity type currently being detected */
+            entityType: string;
+        } | {
+            /** @enum {string} */
+            code: "creating-annotations" | "creating-tag-annotations";
+            /** @description How many annotations are being created */
+            count: number;
+        } | {
+            /** @enum {string} */
+            code: "complete-created";
+            /** @description How many annotations were created */
+            count: number;
+            /**
+             * @description What kind of annotation was created; clients pluralize/translate
+             * @enum {string}
+             */
+            kind: "highlight" | "comment" | "assessment" | "reference" | "tag";
         };
         /** @description Event indicating a job has been queued */
         JobQueuedEvent: {
@@ -3152,6 +3214,11 @@ interface components {
             total: number;
             offset: number;
             limit: number;
+            /**
+             * @description What kind of answer this is: 'lexical' — the resources matched the query text; 'semantic' — no lexical match existed, and these resources discuss the query per the vector index (SEMANTIC-FALLBACK). Required so every producer labels its answer; a UI can render semantic results as a different kind of page ('no title matches, but these documents discuss it').
+             * @enum {string}
+             */
+            matchKind: "lexical" | "semantic";
         };
         /** @description Bus command to archive a resource and optionally remove its file. */
         MarkArchiveCommand: {
@@ -3538,6 +3605,20 @@ interface components {
             /** @description True when this passage's text was recognized from pixels (OCR of a scanned page) rather than read from the document. Absent means read directly — the common case — so the flag is only present where it changes how the text should be trusted. It travels with the passage because a consumer receives the chunk with no document attached and cannot recompute how the text was obtained. */
             machineRead?: boolean;
         };
+        /** @description A participant opened a live connection to this KB — an SSE stream on /bus/subscribe. Presence is CONNECTION lifecycle, not login: a token can be minted and sit unused, so what this reports is that someone is WATCHING. One person with two tabs produces two of these, which is why connectionId is required — the DID alone cannot tell two connections apart, and a consumer that counts DIDs will undercount viewers. */
+        SessionJoinedEvent: {
+            /** @description DID of the authenticated principal on that connection. A person or a software agent — the bus does not distinguish. */
+            participant: string;
+            /** @description Identifies this connection for its lifetime. The matching session:left carries the same value. */
+            connectionId: string;
+        };
+        /** @description A participant's live connection to this KB ended — the SSE stream aborted. Carries the same connectionId as the session:joined that opened it, so a consumer tracking who is present can retire the right connection rather than assuming one per participant. */
+        SessionLeftEvent: {
+            /** @description DID of the authenticated principal on that connection. */
+            participant: string;
+            /** @description The connectionId announced by the matching session:joined. */
+            connectionId: string;
+        };
         /** @description Emitted when the hover delay setting changes */
         SettingsHoverDelayChangedEvent: {
             hoverDelayMs: number;
@@ -4024,7 +4105,6 @@ type PersistedEventCatalog = {
     'frame:entity-type-added': components['schemas']['EntityTypeAddedPayload'];
     'frame:tag-schema-added': components['schemas']['TagSchemaAddedPayload'];
     'job:started': components['schemas']['JobStartedPayload'];
-    'job:progress': components['schemas']['JobProgressPayload'];
     'job:completed': components['schemas']['JobCompletedPayload'];
     'job:failed': components['schemas']['JobFailedPayload'];
 };
@@ -4054,7 +4134,7 @@ type PersistedEventType = PersistedEvent['type'];
  * also adding it here: forgetting fails to typecheck rather than silently
  * dropping the event from the events-stream.
  */
-declare const PERSISTED_EVENT_TYPES: readonly ["yield:created", "yield:cloned", "yield:updated", "yield:moved", "yield:representation-added", "yield:representation-removed", "mark:added", "mark:removed", "mark:body-updated", "mark:archived", "mark:unarchived", "mark:entity-tag-added", "mark:entity-tag-removed", "frame:entity-type-added", "frame:tag-schema-added", "job:started", "job:progress", "job:completed", "job:failed"];
+declare const PERSISTED_EVENT_TYPES: readonly ["yield:created", "yield:cloned", "yield:updated", "yield:moved", "yield:representation-added", "yield:representation-removed", "mark:added", "mark:removed", "mark:body-updated", "mark:archived", "mark:unarchived", "mark:entity-tag-added", "mark:entity-tag-removed", "frame:entity-type-added", "frame:tag-schema-added", "job:started", "job:completed", "job:failed"];
 /** Input type for appendEvent — PersistedEvent without id/timestamp (assigned at persistence time). */
 type EventInput = Omit<PersistedEvent, 'id' | 'timestamp'>;
 
@@ -4420,7 +4500,8 @@ type EventMap = {
     'browse:click': components['schemas']['BrowseClickEvent'] & {
         anchorRect?: AnchorRect;
     };
-    'browse:reference-navigate': components['schemas']['BrowseReferenceNavigateEvent'];
+    'browse:resource-open': components['schemas']['BrowseResourceOpenEvent'];
+    'browse:resource-viewed': components['schemas']['BrowseResourceViewedEvent'];
     'browse:entity-type-clicked': components['schemas']['BrowseEntityTypeClickedEvent'];
     'panel:toggle': components['schemas']['BrowsePanelToggleEvent'];
     'panel:open': components['schemas']['BrowsePanelOpenEvent'] & {
@@ -4439,7 +4520,6 @@ type EventMap = {
     'beckon:focus': components['schemas']['BeckonFocusEvent'];
     'beckon:sparkle': components['schemas']['BeckonSparkleEvent'];
     'job:started': StoredEvent<EventOfType<'job:started'>>;
-    'job:progress': StoredEvent<EventOfType<'job:progress'>>;
     'job:completed': StoredEvent<EventOfType<'job:completed'>>;
     'job:failed': StoredEvent<EventOfType<'job:failed'>>;
     'job:start': components['schemas']['JobStartCommand'];
@@ -4539,6 +4619,8 @@ type EventMap = {
         lastSeenId?: string;
         reason: string;
     };
+    'session:joined': components['schemas']['SessionJoinedEvent'];
+    'session:left': components['schemas']['SessionLeftEvent'];
 };
 
 /**
@@ -4724,8 +4806,9 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'browse:directory-requested': "BrowseDirectoryRequest";
     readonly 'browse:directory-result': "BrowseDirectoryResult";
     readonly 'browse:directory-failed': null;
-    readonly 'browse:click': null;
-    readonly 'browse:reference-navigate': "BrowseReferenceNavigateEvent";
+    readonly 'browse:click': "BrowseClickEvent";
+    readonly 'browse:resource-open': "BrowseResourceOpenEvent";
+    readonly 'browse:resource-viewed': "BrowseResourceViewedEvent";
     readonly 'browse:entity-type-clicked': "BrowseEntityTypeClickedEvent";
     readonly 'panel:toggle': "BrowsePanelToggleEvent";
     readonly 'panel:open': null;
@@ -4740,7 +4823,6 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'beckon:focus': "BeckonFocusEvent";
     readonly 'beckon:sparkle': "BeckonSparkleEvent";
     readonly 'job:started': null;
-    readonly 'job:progress': null;
     readonly 'job:completed': null;
     readonly 'job:failed': null;
     readonly 'job:start': "JobStartCommand";
@@ -4775,6 +4857,8 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'stream-connected': null;
     readonly 'replay-window-exceeded': null;
     readonly 'bus:resume-gap': null;
+    readonly 'session:joined': "SessionJoinedEvent";
+    readonly 'session:left': "SessionLeftEvent";
 };
 /** Channels where `/bus/emit` validates the payload (non-null schema). */
 type EmittableChannel = {
@@ -4795,6 +4879,13 @@ type EmittableChannel = {
 
 type Selector = components['schemas']['TextPositionSelector'] | components['schemas']['TextQuoteSelector'] | components['schemas']['SvgSelector'] | components['schemas']['FragmentSelector'];
 type GatheredContext = components['schemas']['GatheredContext'];
+/**
+ * The `job:create` params shape for `jobType: 'generation'` — one type shared
+ * by the write side (sdk `yield.fromContext` → `runGeneration`) and the read
+ * side (the generation worker's `isGenerationJobParams` narrowing), so the two
+ * ends of the wire cannot drift a field apart silently.
+ */
+type GenerationJobParams = components['schemas']['GenerationJobParams'];
 type SelectionData = components['schemas']['SelectionData'];
 type JobType = components['schemas']['JobType'];
 /**
@@ -5885,8 +5976,15 @@ interface ITransport {
      * `resourceScope`, when set, marks the emit as a resource-scoped
      * broadcast — only delivered to subscribers attached to that
      * resource's scope.
+     *
+     * Resolves with the number of subscribers the emit reached
+     * (`/bus/emit` responds `{subscribers: n}`; GUIDED-TOUR P1), or `-1`
+     * when the count is unknown — an older backend, an unreadable body, or
+     * an in-process transport where the question does not apply. `-1` is
+     * the same sentinel the Go client uses: a parse failure must stay
+     * distinguishable from a genuine empty room.
      */
-    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<void>;
+    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<number>;
     on<K extends keyof EventMap>(channel: K, handler: (payload: EventMap[K]) => void): () => void;
     stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
     /**
@@ -6348,7 +6446,7 @@ type BusOperationKey = keyof typeof BUS_OPERATIONS;
  * and SSE infrastructure. A reply channel must NOT go here — declare its
  * operation in `BUS_OPERATIONS` instead.
  */
-declare const BRIDGED_BROADCASTS: readonly ["job:report-progress", "job:complete", "job:fail", "frame:entity-type-added", "frame:tag-schema-added", "beckon:focus", "beckon:sparkle", "bus:resume-gap"];
+declare const BRIDGED_BROADCASTS: readonly ["job:report-progress", "job:complete", "job:fail", "frame:entity-type-added", "frame:tag-schema-added", "beckon:focus", "beckon:sparkle", "bus:resume-gap", "browse:resource-open", "browse:resource-viewed", "session:joined", "session:left", "browse:click"];
 type OpSpecs = (typeof BUS_OPERATIONS)[keyof typeof BUS_OPERATIONS];
 type ProgressChannel<O> = O extends {
     progress: infer P extends EventName;
@@ -6384,7 +6482,12 @@ declare class BusRequestError extends SemiontError {
  * can satisfy it without round-tripping through HTTP.
  */
 interface BusRequestPrimitive {
-    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K]): Promise<void>;
+    /**
+     * Matches `ITransport.emit`'s return: the subscriber count (`-1` =
+     * unknown). `busRequest` itself ignores it — the reply channel is its
+     * ack — but the primitive must stay assignable from every ITransport.
+     */
+    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K]): Promise<number>;
     stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
     /**
      * Connection state of the stream that carries replies. Required, not
@@ -7222,6 +7325,35 @@ declare function isNullish(value: unknown): value is null | undefined;
  * Check if value is defined (not null or undefined)
  */
 declare function isDefined<T>(value: T | null | undefined): value is T;
+/**
+ * Boundary guard for `job:create` generation params (YIELD-FROM-CONTEXT P1).
+ *
+ * Checks the REQUIRED trio the schema declares (`title`, `storageUri`,
+ * `context`) plus basic shape — deliberately NOT a full schema validation
+ * (that depth belongs to the spec and its generated types); this is the
+ * runtime half of the contract for values whose type history was severed:
+ * wire JSON, storage, casts. For well-typed callers it is dead code, and
+ * that is the correct price for a trust-boundary check.
+ */
+declare function isGenerationJobParams(value: unknown): value is GenerationJobParams;
+/**
+ * Boundary guard for a `GatheredContext` whose type history was severed —
+ * today that is exactly one place: the wizard stashes the context in
+ * `sessionStorage` on the way to the compose page, which reads it back and
+ * `JSON.parse`s it.
+ *
+ * Checks what consumers actually dereference rather than the whole schema:
+ * `focus` (every view branches on `focus.kind`) and `graph.nodes` / `graph.edges`,
+ * which `deriveViews` maps over without a guard. Both are `required` in
+ * `GatheredContext.json` / `KnowledgeGraph.json`, so this is dead code for every
+ * well-typed caller — the price of a trust boundary, same as
+ * `isGenerationJobParams` above.
+ *
+ * The failure it prevents is not cosmetic: `deriveViews` runs during render, so a
+ * stale stash (a tab held open across a deploy) throws inside React rather than
+ * degrading, unmounting the flow to the nearest error boundary.
+ */
+declare function isGatheredContext(value: unknown): value is GatheredContext;
 
 /**
  * DID (Decentralized Identifier) and W3C Agent utilities
@@ -7727,8 +7859,8 @@ interface ServicesConfig {
     database?: DatabaseServiceConfig;
     graph?: GraphServiceConfig;
     mcp?: McpServiceConfig;
-    vectors?: VectorsServiceConfig;
-    embedding?: EmbeddingServiceConfig;
+    vectors: VectorsServiceConfig;
+    embedding: EmbeddingServiceConfig;
     [k: string]: unknown;
 }
 /**
@@ -8149,5 +8281,5 @@ declare function getShardPath(key: string, numBuckets?: number): [string, string
  */
 declare const DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, anchorRuns, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, chunkText, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, ChunkingConfig, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, ExtractionOutcome, FragmentSelector, FrontendServiceConfig, GatheredContext, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, anchorRuns, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, chunkText, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isGatheredContext, isGenerationJobParams, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, ChunkingConfig, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, ExtractionOutcome, FragmentSelector, FrontendServiceConfig, GatheredContext, GenerationJobParams, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };

package/dist/index.js

@@ -1,6 +1,6 @@
-export { createTomlConfigLoader, loadTomlConfig } from './chunk-XQTWEBJ5.js';
-import { BUS_OPERATIONS } from './chunk-FMFOBVTE.js';
-export { BRIDGED_CHANNELS, BUS_OPERATIONS, EventBus, ScopedEventBus, accessToken, annotationUri, authCode, baseUrl, busLog, busLogEnabled, cloneToken, email, entityType, googleCredential, jobId, mcpToken, refreshToken, resourceAnnotationUri, resourceUri, searchQuery, setBusLogTraceIdProvider, userDID } from './chunk-FMFOBVTE.js';
+export { createTomlConfigLoader, loadTomlConfig } from './chunk-JWTQJVKM.js';
+import { BUS_OPERATIONS } from './chunk-CUPZGI7I.js';
+export { BRIDGED_CHANNELS, BUS_OPERATIONS, EventBus, ScopedEventBus, accessToken, annotationUri, authCode, baseUrl, busLog, busLogEnabled, cloneToken, email, entityType, googleCredential, jobId, mcpToken, refreshToken, resourceAnnotationUri, resourceUri, searchQuery, setBusLogTraceIdProvider, userDID } from './chunk-CUPZGI7I.js';
 import { Observable, merge, TimeoutError, throwError, firstValueFrom } from 'rxjs';
 import { filter, map, take, timeout, catchError, defaultIfEmpty } from 'rxjs/operators';
 
@@ -45,7 +45,6 @@ var PERSISTED_EVENT_TYPES = [
   "frame:entity-type-added",
   "frame:tag-schema-added",
   "job:started",
-  "job:progress",
   "job:completed",
   "job:failed"
 ];
@@ -218,9 +217,10 @@ var CHANNEL_SCHEMAS = {
   "browse:directory-result": "BrowseDirectoryResult",
   "browse:directory-failed": null,
   // { correlationId; path } & CommandError
-  "browse:click": null,
+  "browse:click": "BrowseClickEvent",
   // includes runtime `anchorRect?: AnchorRect`
-  "browse:reference-navigate": "BrowseReferenceNavigateEvent",
+  "browse:resource-open": "BrowseResourceOpenEvent",
+  "browse:resource-viewed": "BrowseResourceViewedEvent",
   "browse:entity-type-clicked": "BrowseEntityTypeClickedEvent",
   // ── SHELL (app-scoped UI events, fire on SemiontBrowser bus) ────
   "panel:toggle": "BrowsePanelToggleEvent",
@@ -243,7 +243,6 @@ var CHANNEL_SCHEMAS = {
   // ── JOB FLOW ────────────────────────────────────────────────────
   "job:started": null,
   // StoredEvent
-  "job:progress": null,
   "job:completed": null,
   "job:failed": null,
   "job:start": "JobStartCommand",
@@ -291,8 +290,10 @@ var CHANNEL_SCHEMAS = {
   // Record<string, never>
   "replay-window-exceeded": null,
   // inline payload
-  "bus:resume-gap": null
+  "bus:resume-gap": null,
   // inline payload
+  "session:joined": "SessionJoinedEvent",
+  "session:left": "SessionLeftEvent"
 };
 
 // src/event-utils.ts
@@ -1928,6 +1929,16 @@ function isNullish(value) {
 function isDefined(value) {
   return value !== null && value !== void 0;
 }
+function isGenerationJobParams(value) {
+  if (!isObject(value)) return false;
+  return typeof value.title === "string" && typeof value.storageUri === "string" && isObject(value.context);
+}
+function isGatheredContext(value) {
+  if (!isObject(value)) return false;
+  if (!isObject(value.focus)) return false;
+  if (!isObject(value.graph)) return false;
+  return isArray(value.graph.nodes) && isArray(value.graph.edges);
+}
 
 // src/did-utils.ts
 function kbDid(domain) {
@@ -2141,6 +2152,6 @@ function getShardPath(key, numBuckets = 65536) {
 // src/discovery.ts
 var DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScriptError, SemiontError, UnauthorizedError, ValidationError, agentToDid, anchorAnnotation, anchorRuns, annotationId, applyBodyOperations, assembleAnnotation, baseMediaType, buildContentCache, burstBuffer, busRequest, capabilitiesOf, chunkText, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jumpConsistentHash, kbDid, locate, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, resourceId, retryWithBackoff, scaleSvgToNative, serializePerKey, softwareToAgent, textExtractionOf, textUnder, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export { AUTHORABLE_MEDIA_TYPES, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScriptError, SemiontError, UnauthorizedError, ValidationError, agentToDid, anchorAnnotation, anchorRuns, annotationId, applyBodyOperations, assembleAnnotation, baseMediaType, buildContentCache, burstBuffer, busRequest, capabilitiesOf, chunkText, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isGatheredContext, isGenerationJobParams, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jumpConsistentHash, kbDid, locate, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, resourceId, retryWithBackoff, scaleSvgToNative, serializePerKey, softwareToAgent, textExtractionOf, textUnder, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map