@semiont/core 0.5.29 → 0.5.31

package/dist/index.d.ts

@@ -1538,7 +1538,12 @@ interface components {
             body?: components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
             /** @description Web Annotation creator — the entity that initiated the annotation. For human-driven work this is a Person; for autonomous-agent work this is a Software peer. */
             creator?: components["schemas"]["Agent"];
-            created?: string;
+            /**
+             * Format: date-time
+             * @description When the annotation was MADE — the authoring moment, carried from the event that created it. Not when a projection happened to write it: a store that rebuilds from the log must preserve this value, never restamp it.
+             */
+            created: string;
+            /** Format: date-time */
             modified?: string;
             /** @description Web Annotation generator — the SoftwareAgent that produced the annotation, when software was involved. Absent for purely manual annotations. Single object is the common case; array supports pipelines that combine multiple software peers. */
             generator?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
@@ -1588,7 +1593,7 @@ interface components {
                 domain: string;
                 isAdmin: boolean;
             };
-            /** @description Short-lived access token (1 hour). Use as Authorization: Bearer header on API calls. */
+            /** @description Short-lived access token. Use as Authorization: Bearer header on API calls. The TTL is deliberately NOT restated here — docs/system/administration/AUTHENTICATION.md holds the one table of token lifetimes, and a second copy is how this description came to claim an hour for a ten-minute token. A client must refresh from the refresh token rather than assume any particular window. */
             token: string;
             /** @description Long-lived refresh token (30 days). Exchange via POST /api/tokens/refresh for a fresh access token. */
             refreshToken: string;
@@ -1846,15 +1851,36 @@ interface components {
             correlationId: string;
             resourceId: string;
         };
-        /** @description A resource's stored extraction outcome — the coordinate map with its provenance, or a named decline — or null when none has been derived. Null is the common case and not an error: a native text layer is read in the browser, and a media type with no extractor never produces one. */
+        /** @description A resource's coordinate map, a stored decline, or a named reason there is none (SMELTER-OWNS-OCR P1). Never null: absence used to be a bare null covering four different facts — barrier expired, settled-skipped, no content identity, fold disposed — two of which a caller should retry and two of which it should not. */
         BrowseAnchoredTextResult: {
             correlationId: string;
-            response: Omit<components["schemas"]["ExtractionOutcome"], "kind"> | null;
+            response: components["schemas"]["AnchoredTextAnswer"];
         };
-        /** @description Request the stored extraction outcome for a content identity the caller already holds — the detection workers' read-through cache consult (ANCHORED-TEXT-TO-SMELTER P2). A hit — success or decline — is served whole and the caller skips extraction; null is a miss and the caller extracts locally. Read-only: the Smelter is the sole writer and never answers over this channel. */
-        BrowseAnchoredTextByChecksumRequest: {
-            correlationId: string;
-            checksum: string;
+        /**
+         * @description What a reader gets when it asks for a resource's coordinate map: the map, a stored decline, or a named absence.
+         *
+         *     Distinct from `ExtractionOutcome` on purpose. That type is what the STORE holds and what an extractor RETURNS — neither of which can ever be 'not yet'. This is the read answer, which can, so widening ExtractionOutcome itself would have put an impossible state into the store's own type.
+         *
+         *     Flat, one discriminant: every member carries `kind`, rather than nesting an outcome inside a status envelope and giving the wire two `kind` fields at different depths.
+         */
+        AnchoredTextAnswer: components["schemas"]["ExtractedText"] | components["schemas"]["ExtractionDeclined"] | components["schemas"]["AnchoredTextAbsent"];
+        /**
+         * @description There is no coordinate map to serve, and WHY — the distinction a bare null could not carry (SMELTER-OWNS-OCR P1).
+         *
+         *     One member covers all three absences because none carries a payload; `kind` alone is the fact. Retryability is legible from the name, deliberately: a caller must not need a lookup table to decide whether to come back.
+         */
+        AnchoredTextAbsent: {
+            /**
+             * @description Discriminant, sharing the `kind` field with the ExtractedText/ExtractionDeclined members so the whole answer is one flat union (D6).
+             *
+             *     `not-yet` — the Smelter has not settled this content generation: the settle barrier expired, the progress fold was disposed, or it settled indexed and the artifact is missing (the reconcile planner's third drift class, which heals). RETRY.
+             *
+             *     `no-map` — the Smelter settled this resource as skipped: its media type derives no geometry, so a map will never exist. TERMINAL.
+             *
+             *     `unknown` — no content identity to look up: the resource is not in the view store, or its primary representation carries no checksum. TERMINAL. (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "not-yet" | "no-map" | "unknown";
         };
         /** @description Request to browse a single resource */
         BrowseResourceRequest: {
@@ -1909,6 +1935,8 @@ interface components {
             };
             /** @description Optional resource scope for broadcast channels (e.g. resourceId). Publishers only — clients must never set this. */
             scope?: string;
+            /** @description Routing address for this request's reply (CORRELATED-REPLY-ROUTING D1/D2): the emit doubles as a claim on the correlationId, and delivery matches BOTH this and the emitting principal. Top-level, not inside `payload` — a wire concern like `scope`, so it never enters a channel's domain type. Optional in the schema because a plain broadcast needs no return address; the route requires it when the channel is a registered request channel and the payload carries a correlationId. */
+            clientId?: string;
         };
         /** @description Subscription matrix for the bus SSE stream (MULTI-RESOURCE-SCOPE). `global` channels are delivered unscoped; each `scoped` entry subscribes the connection to one resource scope's channels, optionally resuming replay from that scope's last-seen persisted event id. At least one global channel or one scoped entry is required. */
         BusSubscribeRequest: {
@@ -1925,6 +1953,8 @@ interface components {
                 /** @description This scope's last-seen persisted event id (`p-<scope>-<seq>`). The server replays this scope's persisted events after it before joining the live tail, and emits a scoped `bus:resume-gap` when it cannot cover the gap (unparseable or mismatched id, retention exceeded, or query error). */
                 lastEventId?: string;
             }[];
+            /** @description Routing address for correlated replies (CORRELATED-REPLY-ROUTING D1): a UUID minted once per bus-client lifetime — per actor, NOT per connection, so it survives a make-before-break reconnect and both overlap connections share it. Required: a subscriber without one could never receive a correlated frame, and that must fail loudly here rather than silently at delivery. Not authentication — the JWT stays that; this is an unguessable routing address, never echoed into any payload or broadcast frame. */
+            clientId: string;
         };
         CloneResourceWithTokenResponse: {
             /** @description Generated clone token */
@@ -2239,6 +2269,8 @@ interface components {
         };
         /** @description Progress payload emitted on the gather:annotation-progress SSE channel during LLM context gathering. */
         GatherProgress: {
+            /** @description The request this progress belongs to (CORRELATED-REPLY-ROUTING D3). Required: `CORRELATED_CHANNELS` derives every operation's progress channel into the delivery filter, so a frame without it cannot be matched to a claim and is silently dropped. */
+            correlationId: string;
             message?: string;
             percentage?: number;
         };
@@ -2497,12 +2529,29 @@ interface components {
             assessmentsFound: number;
             assessmentsCreated: number;
         };
-        /** @description Request to cancel a job */
+        /** @description Request to cancel a job. Target one running or pending job by `jobId` (JOB-RESTART-SAFETY P4), or a whole category of pending jobs by `jobType`. A `jobId`-targeted request that names a RUNNING job is honoured cooperatively by the owning worker, which stops at its next unit boundary and emits JobCancelCommand — the queue is never made to yank a running job out from under a live worker. */
         JobCancelRequest: {
             /** @description Correlation id for request/reply matching, set by the SDK's busRequest so the confirmed-write ack/failure routes back. Absent for the local cancelRequest UI signal. */
             correlationId?: string;
-            /** @enum {string} */
-            jobType: "annotation" | "generation";
+            /** @description Cancel this one job. A pending job is cancelled immediately by the gateway; a running job is cancelled cooperatively by its worker. Takes precedence over jobType. */
+            jobId?: string;
+            /**
+             * @description Cancel all PENDING jobs in this category — the bulk UI signal. Ignored when jobId is present.
+             * @enum {string}
+             */
+            jobType?: "annotation" | "generation";
+        };
+        /** @description A worker's confirmation that it has cooperatively stopped a running job at a unit boundary (JOB-RESTART-SAFETY P4) — the queue moves the job to cancelled/. Distinct from JobCancelRequest (the client→worker REQUEST to stop): this is the worker announcing it did, so the running job is never yanked to cancelled/ out from under a live worker (the roach-motel race). */
+        JobCancelCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            resourceId: string;
+            jobId: string;
+            jobType: components["schemas"]["JobType"];
+            /** @description Annotation this job is attached to, when applicable. Lets the UI route cancellation feedback to a specific annotation. */
+            annotationId?: string;
+            /** @description Entity-type units whose annotations were fully emitted before cancellation. Recorded on the cancelled job's metadata so the work already done stays visible. */
+            completedUnits?: string[];
         };
         /** @description Command to claim a pending job (atomic CAS: pending → running) */
         JobClaimCommand: {
@@ -2577,6 +2626,23 @@ interface components {
             /** @description Annotation this job is attached to, when applicable. Lets the UI route failure feedback (error toast, revert state) to a specific annotation. */
             annotationId?: string;
             error: string;
+            /** @description Entity-type units whose annotations were fully emitted before this failure (checkpointed resume). The queue records them on the retried job's metadata; a retried claim skips them so completed work is neither redone nor duplicated. */
+            completedUnits?: string[];
+            /**
+             * @description Worker-side classification of the failure, made where the error is still typed. 'deterministic' — the same request cannot succeed on a second attempt — skips the retry budget; absent or 'transient' retries as before. Only KNOWN-deterministic failures carry the class.
+             * @enum {string}
+             */
+            failureClass?: "transient" | "deterministic";
+            /** @description Whether the queue will re-queue this job for another attempt. Computed by the worker from the SAME predicate the queue applies at failJob (one decision site, `willRetryAfter` in @semiont/jobs) using the retry budget carried on the claimed record. FALSE (or absent) means this failure is TERMINAL: a client's job-watch stream ends here. TRUE means the work continues on a fresh attempt — the failure is an event, not the end, and a stream that terminated on it would report a recovering run as a failed one (JOB-RESTART-SAFETY P5). */
+            willRetry?: boolean;
+        };
+        /** @description Command to persist a running job's completed-unit checkpoint AT unit completion (JOB-RESTART-SAFETY P2). Distinct from JobFailCommand's checkpoint, which lands only on a clean failure: a worker that dies (crash/OOM/kill) never emits job:fail, so this durable, unthrottled write is what lets the janitor's stale-running recovery resume a dead worker's job rather than redo its finished units. */
+        JobCheckpointCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            jobId: string;
+            /** @description Entity-type units whose annotations have been fully emitted so far. Unioned into the running job's metadata checkpoint; a retry after recovery skips them. */
+            completedUnits: string[];
         };
         /** @description Result of a job that completed without doing its work because the resource could not be read. Distinct from a failure: nothing went wrong, there was simply no text to work with — an encrypted or damaged PDF, a scan whose text could not be recognized, or a document that yielded nothing. The reasons are the extraction vocabulary the Smelter reports on `smelt:settled`, MINUS `no-extractor`: a media type that can never yield text (a zip, an image) is a bad request rather than a decline, so a worker asked to detect over one throws and the job reports `job:fail`. Everything here is a resource-specific outcome — the same media type would have succeeded on a different document. */
         JobDeclinedResult: {
@@ -2661,6 +2727,8 @@ interface components {
                 value: string;
                 /** @description Annotations found for it. */
                 foundCount: number;
+                /** @description Annotations actually persisted for it — post-dedupe and post-durability-acknowledgement, so it counts what the event log holds, not what the model proposed. Beside foundCount this is the per-unit yield the sizing work is judged by. Present on flows whose units persist as they complete (reference-annotation); the tagging flow reports the same fact as byCategory on its result, because its annotations are built after the per-category loop. */
+                persistedCount?: number;
             }[];
             /** @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?: {
@@ -2939,6 +3007,29 @@ interface components {
                 annotationId: string;
             };
         };
+        /** @description Bus command to persist a detection unit's annotations as one acknowledged batch (JOB-RESTART-SAFETY P6). Unlike mark:create, which is fire-and-forget and resolves when the bus accepts it, this command is answered only after every annotation is in the event log — so a worker can gate unit completion on durability rather than on emission. The batch is the unit: a partial commit is reported as a failure, and the worker retries the whole unit, which is safe because annotation ids are deterministic (P3). */
+        MarkCommitCommand: {
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+            /** @description Correlation id set by busRequest so the mark:commit-ok / mark:commit-failed reply routes back to the awaiting worker. */
+            correlationId: string;
+            /** @description Resource every annotation in this batch targets. */
+            resourceId: string;
+            /** @description The unit's annotations, already built with deterministic ids. Re-committing an identical batch is a no-op rather than a duplicate. */
+            annotations: components["schemas"]["Annotation"][];
+        };
+        /** @description Durability acknowledgement for a mark:commit batch: every annotation named by the command is in the event log at the moment this is emitted. */
+        MarkCommitOk: {
+            /** @description Correlation id echoed from the mark:commit command so busRequest can match the reply. */
+            correlationId: string;
+            /** @description What the commit persisted. */
+            response: {
+                /** @description Annotations this commit appended to the event log. Equals the batch size on success — a retry re-appends what already landed rather than counting it out, because the annotation fold is idempotent by id and the log is append-only. Not a dedupe count. */
+                persisted: number;
+                /** @description Ids the batch covers, whether appended now or already present. */
+                annotationIds: string[];
+            };
+        };
         /** @description Raw annotation creation intent — bus handler assembles the W3C annotation */
         MarkCreateRequest: {
             correlationId: string;
@@ -3747,6 +3838,7 @@ interface CreateAnnotationInternal {
     target: Annotation['target'];
     body?: Annotation['body'];
     creator: components['schemas']['Agent'];
+    created: Annotation['created'];
 }
 
 /**
@@ -4049,6 +4141,16 @@ type EventMap = {
     'mark:update-entity-types': components['schemas']['MarkUpdateEntityTypesCommand'];
     'mark:create-ok': components['schemas']['MarkCreateOk'];
     'mark:create-failed': components['schemas']['CommandError'];
+    /**
+     * Persist a detection unit's annotations as ONE acknowledged batch
+     * (JOB-RESTART-SAFETY P6). Answered only after every annotation is in
+     * the event log, so a worker can gate unit completion on durability
+     * instead of on emission — which is what makes an Archivist outage a
+     * delay rather than silent data loss.
+     */
+    'mark:commit': components['schemas']['MarkCommitCommand'];
+    'mark:commit-ok': components['schemas']['MarkCommitOk'];
+    'mark:commit-failed': components['schemas']['CommandError'];
     'mark:delete-ok': components['schemas']['MarkDeleteOk'];
     'mark:delete-failed': components['schemas']['CommandError'];
     'mark:archive-ok': {
@@ -4142,21 +4244,10 @@ type EventMap = {
         correlationId: string;
     } & components['schemas']['CommandError'];
     'browse:anchored-text-requested': components['schemas']['BrowseAnchoredTextRequest'];
-    'browse:anchored-text-result': {
-        correlationId: string;
-        response: components['schemas']['ExtractionOutcome'] | null;
-    };
+    'browse:anchored-text-result': components['schemas']['BrowseAnchoredTextResult'];
     'browse:anchored-text-failed': {
         correlationId: string;
     } & components['schemas']['CommandError'];
-    'browse:anchored-text-by-checksum-requested': components['schemas']['BrowseAnchoredTextByChecksumRequest'];
-    'browse:anchored-text-by-checksum-result': {
-        correlationId: string;
-        response: components['schemas']['ExtractionOutcome'] | null;
-    };
-    'browse:anchored-text-by-checksum-failed': {
-        correlationId: string;
-    } & components['schemas']['CommandError'];
     'browse:resources-requested': components['schemas']['BrowseResourcesRequest'];
     'browse:resources-result': {
         correlationId: string;
@@ -4262,8 +4353,10 @@ type EventMap = {
     'job:report-progress': components['schemas']['JobReportProgressCommand'];
     'job:complete': components['schemas']['JobCompleteCommand'];
     'job:fail': components['schemas']['JobFailCommand'];
+    'job:checkpoint': components['schemas']['JobCheckpointCommand'];
     'job:queued': components['schemas']['JobQueuedEvent'];
     'job:cancel-requested': components['schemas']['JobCancelRequest'];
+    'job:cancel': components['schemas']['JobCancelCommand'];
     'job:status-requested': components['schemas']['JobStatusRequest'];
     'job:create': components['schemas']['JobCreateCommand'];
     'job:claim': components['schemas']['JobClaimCommand'];
@@ -4463,6 +4556,9 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'frame:add-tag-schema': "FrameAddTagSchemaCommand";
     readonly 'mark:create-ok': "MarkCreateOk";
     readonly 'mark:create-failed': "CommandError";
+    readonly 'mark:commit': "MarkCommitCommand";
+    readonly 'mark:commit-ok': "MarkCommitOk";
+    readonly 'mark:commit-failed': "CommandError";
     readonly 'mark:delete-ok': "MarkDeleteOk";
     readonly 'mark:delete-failed': "CommandError";
     readonly 'mark:archive-ok': null;
@@ -4512,9 +4608,6 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'browse:anchored-text-requested': "BrowseAnchoredTextRequest";
     readonly 'browse:anchored-text-result': "BrowseAnchoredTextResult";
     readonly 'browse:anchored-text-failed': null;
-    readonly 'browse:anchored-text-by-checksum-requested': "BrowseAnchoredTextByChecksumRequest";
-    readonly 'browse:anchored-text-by-checksum-result': "BrowseAnchoredTextResult";
-    readonly 'browse:anchored-text-by-checksum-failed': null;
     readonly 'browse:resources-requested': "BrowseResourcesRequest";
     readonly 'browse:resources-result': "BrowseResourcesResult";
     readonly 'browse:resources-failed': null;
@@ -4571,8 +4664,10 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'job:report-progress': "JobReportProgressCommand";
     readonly 'job:complete': "JobCompleteCommand";
     readonly 'job:fail': "JobFailCommand";
+    readonly 'job:checkpoint': "JobCheckpointCommand";
     readonly 'job:queued': "JobQueuedEvent";
     readonly 'job:cancel-requested': "JobCancelRequest";
+    readonly 'job:cancel': "JobCancelCommand";
     readonly 'job:status-requested': "JobStatusRequest";
     readonly 'job:create': "JobCreateCommand";
     readonly 'job:claim': "JobClaimCommand";
@@ -5363,6 +5458,15 @@ interface AnchoredText {
  * the generated spec type so the wire shape has exactly one authority.
  */
 type ExtractionOutcome = components['schemas']['ExtractionOutcome'];
+/**
+ * What a READER gets when it asks for a resource's map: the map, a stored
+ * decline, or a named absence (SMELTER-OWNS-OCR P1).
+ *
+ * Deliberately wider than `ExtractionOutcome`, which is what the store HOLDS and
+ * what an extractor RETURNS — neither of which can ever be "not yet". Widening
+ * that type instead would have put an impossible state into the store's own.
+ */
+type AnchoredTextAnswer = components['schemas']['AnchoredTextAnswer'];
 /**
  * One text run as pdf.js reports it, narrowed to the fields anchoring reads.
  * Structural on purpose: core takes no dependency on pdfjs-dist, so each
@@ -5639,21 +5743,28 @@ declare class ConflictError extends SemiontError {
 type Agent$1 = components['schemas']['Agent'];
 type GetResourceResponse = components['schemas']['GetResourceResponse'];
 /**
- * Six-state lifecycle for a transport's connection. Drives UI affordances
+ * Seven-state lifecycle for a transport's connection. Drives UI affordances
  * (connecting spinners, reconnecting banners, etc.) and is observed via
  * `ITransport.state$`.
  *
- *   initial      ─ pre-`start()`; never enters subscribers' streams
- *                  except as the first replayed value
- *   connecting   ─ in-flight initial open
- *   open         ─ healthy, delivering events
- *   reconnecting ─ open → dropped, retrying; may be transient
- *   degraded     ─ has been reconnecting for > DEGRADED_THRESHOLD_MS;
- *                  UI banner threshold; distinguishes brief mount-
- *                  churn cycles from sustained disconnection
- *   closed       ─ stop()/dispose() called; terminal
- */
-type ConnectionState = 'initial' | 'connecting' | 'open' | 'reconnecting' | 'degraded' | 'closed';
+ *   initial         ─ pre-`start()`; never enters subscribers' streams
+ *                     except as the first replayed value
+ *   connecting      ─ in-flight initial open
+ *   open            ─ healthy, delivering events
+ *   reconnecting    ─ open → dropped, retrying; may be transient
+ *   degraded        ─ has been reconnecting for > DEGRADED_THRESHOLD_MS;
+ *                     UI banner threshold; distinguishes brief mount-
+ *                     churn cycles from sustained disconnection
+ *   unauthenticated ─ not attempting: the credential is absent, or was
+ *                     refused (401) and only a DIFFERENT one is worth
+ *                     trying. No network activity; recovers on its own
+ *                     when a usable credential appears (a re-login, a
+ *                     session refresh). The refusal itself surfaces on
+ *                     the transport's error stream (SSE-AUTH-RESILIENCE
+ *                     D3/D6a — one state for both answers)
+ *   closed          ─ stop()/dispose() called; terminal
+ */
+type ConnectionState = 'initial' | 'connecting' | 'open' | 'reconnecting' | 'degraded' | 'unauthenticated' | 'closed';
 type AuthResponse = components['schemas']['AuthResponse'];
 type TokenRefreshResponse = components['schemas']['TokenRefreshResponse'];
 type AdminUserStatsResponse = components['schemas']['AdminUserStatsResponse'];
@@ -5927,10 +6038,6 @@ declare const BUS_OPERATIONS: {
         readonly result: "browse:anchored-text-result";
         readonly failure: "browse:anchored-text-failed";
     };
-    readonly 'browse:anchored-text-by-checksum-requested': {
-        readonly result: "browse:anchored-text-by-checksum-result";
-        readonly failure: "browse:anchored-text-by-checksum-failed";
-    };
     readonly 'browse:resources-requested': {
         readonly result: "browse:resources-result";
         readonly failure: "browse:resources-failed";
@@ -6016,6 +6123,10 @@ declare const BUS_OPERATIONS: {
         readonly result: "mark:create-ok";
         readonly failure: "mark:create-failed";
     };
+    readonly 'mark:commit': {
+        readonly result: "mark:commit-ok";
+        readonly failure: "mark:commit-failed";
+    };
     readonly 'mark:delete': {
         readonly result: "mark:delete-ok";
         readonly failure: "mark:delete-failed";
@@ -6100,7 +6211,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", "browse:resource-open", "browse:resource-viewed", "session:joined", "session:left", "browse:click"];
+declare const BRIDGED_BROADCASTS: readonly ["job:report-progress", "job:complete", "job:fail", "frame:entity-type-added", "frame:tag-schema-added", "yield:created", "yield:updated", "yield:cloned", "yield:moved", "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;
@@ -6125,11 +6236,24 @@ type BridgedChannel = RegistryReply | (typeof BRIDGED_BROADCASTS)[number];
 type BusReply<Op extends BusOperationKey> = EventMap[(typeof BUS_OPERATIONS)[Op]['result'] & EventName] extends {
     response: infer R;
 } ? R : void;
-type BusRequestErrorCode = 'bus.timeout' | 'bus.rejected' | 'bus.closed' | 'bus.bad-payload' | 'bus.unauthorized' | 'bus.forbidden' | 'bus.not-found';
+type BusRequestErrorCode = 'bus.timeout' | 'bus.rejected' | 'bus.closed' | 'bus.bad-payload' | 'bus.unauthorized' | 'bus.forbidden' | 'bus.not-found' | 'bus.unsubscribed';
 declare class BusRequestError extends SemiontError {
     code: BusRequestErrorCode;
     constructor(message: string, code: BusRequestErrorCode, details?: Record<string, unknown>);
 }
+/**
+ * The reply channels — result, failure, and (for streaming operations)
+ * progress — of every operation in `channels`, deduplicated. Entries that
+ * are not operation request channels (broadcast signals, domain events)
+ * contribute nothing.
+ *
+ * This is THE derivation for a narrowed-subscription transport profile
+ * (`HttpTransportConfig.channels`: subscribe exactly the reply channels of
+ * the operations a process awaits) and for a service's outbound reply pump
+ * (forward exactly the replies of the operations it answers). Restating a
+ * reply channel by hand was the recurring unbridged-reply bug class.
+ */
+declare function replyChannelsFor(channels: readonly string[]): EventName[];
 /**
  * Subset of ITransport that `busRequest` needs: a way to send a command and
  * a way to observe channels. Generic enough that an in-process transport
@@ -6163,6 +6287,16 @@ interface BusRequestPrimitive {
      * lose replies omits the surface and `busRequest` behaves as before.
      */
     trackReply?(correlationId: string): () => void;
+    /**
+     * Whether this transport's receive path delivers `channel` — i.e. a reply
+     * published there can actually reach this process. Wire transports whose
+     * subscription set is configurable (a worker subscribing only the reply
+     * channels it awaits) implement this so `busRequest` on a channel outside
+     * the set fails fast with `bus.unsubscribed` instead of burning its
+     * timeout on a reply that could never arrive. OPTIONAL: an in-process
+     * transport delivers every channel and omits it.
+     */
+    isSubscribed?(channel: string): boolean;
 }
 /**
  * Request/reply over the bus, keyed by the operation's request channel.
@@ -6590,8 +6724,11 @@ declare function isValidEmail(email: string): boolean;
  * - `render`      — which viewer the UI mounts ('none' → metadata + download)
  * - `anchoring`   — which annotation model applies: character-offset text
  *                   selectors vs spatial geometry (PDFs are spatial)
- * - `extractText` — how the Smelter gets embeddable text ('none' → skip
- *                   embedding, never mojibake)
+ * - `textSource`  — WHERE a type's text comes from: decoded from its own bytes,
+ *                   or derived by reading them ('none' → skip embedding, never
+ *                   mojibake). Named `extractText` until READ-VS-EXTRACT P3,
+ *                   which called decoding an extraction — the conflation that
+ *                   let a worker OCR PDFs for four months (#739)
  * - `authorable`  — offered in the compose editor's format dropdown
  * - `uploadable`  — big tent: true for every registry member
  * - `generatable` — the generation worker can produce it as a yield artifact
@@ -6614,7 +6751,7 @@ declare function isValidEmail(email: string): boolean;
 type SupportedMediaType = components['schemas']['SupportedMediaType'];
 type RenderMode = 'text' | 'image' | 'pdf' | 'none';
 type AnchoringModel = 'text-selector' | 'spatial' | 'none';
-type TextExtraction = 'decode' | 'pdf-text-layer' | 'none';
+type TextSource = 'decode' | 'pdf-text-layer' | 'none';
 interface MediaTypeCapabilities {
     /** Canonical file extension, with leading dot. */
     extension: `.${string}`;
@@ -6622,7 +6759,7 @@ interface MediaTypeCapabilities {
     label: string;
     render: RenderMode;
     anchoring: AnchoringModel;
-    extractText: TextExtraction;
+    textSource: TextSource;
     authorable: boolean;
     uploadable: boolean;
     /** Whether the generation worker can produce this type as a yield artifact.
@@ -6645,7 +6782,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "text";
         anchoring: "text-selector";
-        extractText: "decode";
+        textSource: "decode";
         authorable: true;
         uploadable: true;
         generatable: true;
@@ -6655,7 +6792,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "text";
         anchoring: "text-selector";
-        extractText: "decode";
+        textSource: "decode";
         authorable: true;
         uploadable: true;
         generatable: true;
@@ -6665,7 +6802,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "text";
         anchoring: "text-selector";
-        extractText: "decode";
+        textSource: "decode";
         authorable: true;
         uploadable: true;
         generatable: false;
@@ -6675,7 +6812,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "text";
         anchoring: "text-selector";
-        extractText: "decode";
+        textSource: "decode";
         authorable: false;
         uploadable: true;
         generatable: false;
@@ -6685,7 +6822,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "image";
         anchoring: "spatial";
-        extractText: "none";
+        textSource: "none";
         authorable: false;
         uploadable: true;
         generatable: false;
@@ -6695,7 +6832,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "image";
         anchoring: "spatial";
-        extractText: "none";
+        textSource: "none";
         authorable: false;
         uploadable: true;
         generatable: false;
@@ -6705,7 +6842,7 @@ declare const MEDIA_TYPES: {
         label: string;
         render: "pdf";
         anchoring: "spatial";
-        extractText: "pdf-text-layer";
+        textSource: "pdf-text-layer";
         authorable: false;
         uploadable: true;
         generatable: true;
@@ -6803,29 +6940,56 @@ declare function extensionForMediaType(format: string): string;
  */
 declare function mediaTypeForExtension(ext: string): SupportedMediaType | undefined;
 /**
- * The Smelter's gate: how to get embeddable text from a format. Registry
- * rows answer directly; on a registry miss, base types under text/* decode
- * (RFC 2046 guarantees the text top-level type is textual — imported
- * unregistered text subtypes embed too), everything else is 'none'.
+ * WHERE a format's text comes from. Registry rows answer directly; on a registry
+ * miss, base types under text/* decode (RFC 2046 guarantees the text top-level
+ * type is textual — imported unregistered text subtypes embed too), everything
+ * else is 'none'.
+ *
+ * The three answers are different operations, not degrees of one: `decode` is a
+ * pure charset-aware `Buffer → string` anyone holding bytes may run;
+ * `pdf-text-layer` parses and, failing that, OCRs — expensive, not deterministic
+ * across engine versions, and runnable only by the process that persists its
+ * output. Calling both "extraction" is what this accessor was named for until
+ * READ-VS-EXTRACT P3.
+ */
+declare function textSourceOf(format: string): TextSource;
+/**
+ * WHETHER a type's extracted text carries geometry — page-positioned runs
+ * rather than a bare string. Answers "should an anchored-text artifact exist
+ * for this resource?" (PERSIST-ANCHORS P0, the third drift class) and "does
+ * this type anchor spatially or by character offset?".
+ *
+ * Derived from `textSource`, not stored: until READ-VS-EXTRACT P1 this was a
+ * `yieldsGeometry` boolean declared on each `TextExtractor` in
+ * `@semiont/content` — a property of the STRATEGY, declared per-implementation,
+ * in a different package from the strategy vocabulary. Two facts that must
+ * agree, gated by nothing, and consumers asking about a media type had to
+ * resolve an implementation to get an answer.
+ *
+ * Lenient like `textSourceOf`, not strict like `isAnnotatable`. An
+ * unregistered `text/*` type decodes, and decoding yields no geometry — so
+ * `false` here is a real answer rather than a refusal. Nothing downstream is a
+ * durable write against a coordinate model, which is what makes `isAnnotatable`
+ * strict.
  */
-declare function textExtractionOf(format: string): TextExtraction;
+declare function yieldsGeometryOf(format: string): boolean;
 /**
  * WHETHER a type can carry annotations — `anchoring` remains the authority on
  * HOW. Derived rather than stored: a parallel `annotatable` row field would be
  * two facts that can disagree, with nothing to adjudicate
  * `{ annotatable: true, anchoring: 'none' }`.
  *
- * Strict on a registry miss, where `textExtractionOf` above is lenient. The
- * asymmetry is deliberate. Extracting the wrong bytes costs one bad vector,
- * and refusing to extract costs a resource nobody can find, so extraction
+ * Strict on a registry miss, where `textSourceOf` above is lenient. The
+ * asymmetry is deliberate. Reading the wrong bytes costs one bad vector, and
+ * refusing to read costs a resource nobody can find, so the text source
  * guesses; an annotation is a durable write against a coordinate model the
  * system does not have for an unknown type, so it refuses.
  */
 declare function isAnnotatable(format: string): boolean;
 /** Types offered in the compose editor's format dropdown. */
 declare const AUTHORABLE_MEDIA_TYPES: readonly SupportedMediaType[];
-/** Registry rows whose text the Smelter can extract. Rows only — the
- *  text/* fallback in `textExtractionOf` isn't enumerable. */
+/** Registry rows whose text the Smelter can get at, by either route. Rows only —
+ *  the text/* fallback in `textSourceOf` isn't enumerable. */
 declare const EMBEDDABLE_MEDIA_TYPES: readonly SupportedMediaType[];
 /** Types the generation worker can produce as a yield artifact — the
  *  `outputMediaType` gate reads this, not a local table. */
@@ -6834,6 +6998,12 @@ declare const GENERATABLE_MEDIA_TYPES: readonly SupportedMediaType[];
 /**
  * Resource input/output types
  */
+
+/**
+ * What the byte door reports about bytes it just stored. A projection of the
+ * specced Representation — drop a field there and this stops compiling.
+ */
+type StoredResource = Required<Pick<components['schemas']['Representation'], 'storageUri' | 'checksum' | 'byteSize' | 'created'>>;
 interface UpdateResourceInput {
     name?: string;
     entityTypes?: string[];
@@ -7893,7 +8063,7 @@ declare function deriveViews(graph: KnowledgeGraph, mainResourceId: string, foca
 interface RetryPolicy {
     /** Total attempts, including the first one. */
     attempts: number;
-    /** Delay before the second attempt; doubles each retry. */
+    /** Ceiling on the delay before the second attempt; doubles each retry. */
     initialDelayMs: number;
     /** Ceiling for the doubled delay. */
     maxDelayMs: number;
@@ -7908,8 +8078,10 @@ interface RetryAttemptInfo {
     error: unknown;
 }
 /**
- * Default policy for startup connections to the gateway: 8 attempts with
- * delays 1s, 2s, 4s, then capped at 8s — ~39s of patience before giving up.
+ * Default policy for startup connections to the gateway: 8 attempts with delay
+ * ceilings 1s, 2s, 4s, then capped at 8s — up to ~39s of patience before giving
+ * up. "Up to", because the backoff is equal-jittered: each wait lands in
+ * [cap/2, cap), so the worst case is that sum and the expected case is ~75% of it.
  */
 declare const STARTUP_FETCH_RETRY: RetryPolicy;
 /**
@@ -7921,10 +8093,43 @@ declare const STARTUP_FETCH_RETRY: RetryPolicy;
  */
 declare function isTransientFetchError(error: unknown): boolean;
 /**
- * Run `fn`, retrying on errors `isRetryable` accepts, with exponential
- * backoff per `policy`. `onRetry` fires before each wait — the caller's
- * hook for logging the attempt. The final error (retryable budget
- * exhausted, or the first non-retryable one) is rethrown verbatim.
+ * An error that knows the HTTP status the server answered with.
+ *
+ * Structural rather than a class, because the class already exists:
+ * http-transport's `APIError` carries `status` and cannot be named from here
+ * without inverting the package dependency. This interface is the contract
+ * between the thrower and `isRetryableRequestError`, stated once — a predicate
+ * that recovered the status by parsing it back out of an error MESSAGE would be
+ * a second statement of the same fact, in the fragile direction.
+ */
+interface HttpStatusError extends Error {
+    readonly status: number;
+}
+/**
+ * True for failures worth another attempt: the connection never landed
+ * (`isTransientFetchError`), the server answered "not now"
+ * (`RETRYABLE_STATUSES`), or our own deadline expired.
+ *
+ * The timeout case is the one that is easy to get wrong. `AbortSignal.timeout()`
+ * rejects with a **DOMException named `TimeoutError`**, not a `TypeError` —
+ * measured, not assumed — so `isTransientFetchError` cannot see it, and a
+ * request that bounded itself was unretryable precisely when the bound fired.
+ * Matched by `name` rather than `instanceof DOMException` because the constructor
+ * is not guaranteed present in every runtime this package builds for, while the
+ * name is part of the DOM spec.
+ *
+ * Auth and validation failures stay excluded, preserving `isTransientFetchError`'s
+ * reasoning verbatim: a 401 means the gateway is UP and rejected us, and retrying
+ * will not change its mind. A 429 differs — the gateway is up and *asking* us to
+ * wait, so the same "it answered" fact points the other way.
+ */
+declare function isRetryableRequestError(error: unknown): boolean;
+/**
+ * Run `fn`, retrying on errors `isRetryable` accepts, with equal-jitter
+ * exponential backoff per `policy`. `onRetry` fires before each wait — the
+ * caller's hook for logging the attempt, and it reports the actual jittered
+ * delay. The final error (retryable budget exhausted, or the first
+ * non-retryable one) is rethrown verbatim.
  */
 declare function retryWithBackoff<T>(fn: () => Promise<T>, isRetryable: (error: unknown) => boolean, policy: RetryPolicy, onRetry?: (info: RetryAttemptInfo) => void): Promise<T>;
 
@@ -7994,5 +8199,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, cloneFormat, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveStorageUri, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, folderOf, 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, isAnnotatable, 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, proposeStoragePath, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, storageFileName, 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, ArchivistServiceConfig, AssembledAnnotation, AuthCode, 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, GatewayServiceConfig, GatheredContext, GenerationJobParams, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IContentTransport, IGatewayOperations, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, 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, cloneFormat, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveStorageUri, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, folderOf, 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, isAnnotatable, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isGatheredContext, isGenerationJobParams, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isRetryableRequestError, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, proposeStoragePath, reconcileSelector, refreshToken, replyChannelsFor, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, storageFileName, textSourceOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition, yieldsGeometryOf };
+export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoredTextAnswer, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, ArchivistServiceConfig, AssembledAnnotation, AuthCode, 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, GatewayServiceConfig, GatheredContext, GenerationJobParams, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, HttpStatusError, IContentTransport, IGatewayOperations, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, 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, StoredResource, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextPosition, TextPositionSelector, TextQuoteSelector, TextSource, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };