@semiont/core 0.5.23 → 0.5.25

package/dist/index.d.ts

@@ -1540,6 +1540,242 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/resources/{id}/anchored-text": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a resource's anchored text
+         * @description The coordinate map derived from a resource's bytes: its recovered text plus the positioned runs that index it. Assembled via the bus gateway.
+         *
+         *     Whole-resource, not paginated — a producer iterates page by page, but every consumer wants one map: a browser quoting the text under a hand-drawn rectangle, a headless client analysing a document.
+         *
+         *     This endpoint never runs recognition. The Smelter is the sole producer and publishes at ingest; a read that finds nothing waits for that resource's content generation to settle and then answers 204. A 204 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 a map at all. Callers degrade: for a PDF annotation that means geometry with no quoted text.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The stored extraction outcome: the coordinate map with its provenance (method, PDF class, OCR confidence, unread pages), or a named decline. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ExtractionOutcome"];
+                    };
+                };
+                /** @description No map has been derived for this resource. The ordinary answer for a native text layer or a media type with no extractor — not an error, and distinct from 404, which means the resource itself is absent. Carried as an empty body rather than a JSON `null` body so that a generated client's typed 200 field stays absent: unmarshalling `null` into a struct is a no-op in several languages, which would make "no map" indistinguishable from an empty one. */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Request timed out (bus gateway) */
+                504: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/anchored-text/keys": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List the keys under which anchored text is currently stored
+         * @description The anchored-text store's would-hit keys — the reconcile planner's bulk existence read (PERSIST-ANCHORS P0). The Smelter diffs this against the catalog to find resources whose derived coordinate map was lost (a transient store, a failed publish) and plans re-derivation; one request per reconcile, keys only, because each map is ~32 KB per scanned page and only presence is being asked.
+         *
+         *     Keys are resource ids today; after PERSIST-ANCHORS P1 they are content checksums. Only entries a read would actually serve are listed — stale-stamped or unreadable entries are excluded, exactly as a read would exclude them.
+         *
+         *     Agents only: this is projection-maintenance planning data, same trust boundary as publishing a map.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description Every key under which anchored text would currently be served. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": {
+                            keys: string[];
+                        };
+                    };
+                };
+                /** @description Caller is not an agent */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/anchored-text/{checksum}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Read a representation's stored extraction outcome by content checksum
+         * @description The cache-consult read (PERSIST-ANCHORS P2c): the extraction seam asks "has this exact byte content already been extracted?" — and every cache consumer runs out of process (the smelter worker, the detection workers), so the consult must cross the wire or the cache is write-only from exactly the processes it exists to serve.
+         *
+         *     Checksum-addressed and barrier-free, deliberately: presence at this instant is the question, the same semantics as the keys listing. The read-your-writes settle barrier belongs to the resource-addressed reader (GET /resources/{id}/anchored-text), which resolves a mutable resource id through the view index; a caller holding the checksum already holds the content identity and needs no resolution and no wait.
+         *
+         *     Agents only — projection-maintenance traffic, the same trust boundary as the PUT beside it.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Hex SHA-256 checksum of the representation bytes. */
+                    checksum: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The stored extraction outcome — a success with provenance, or a cached decline. */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ExtractionOutcome"];
+                    };
+                };
+                /** @description No entry under this checksum. The ordinary cache miss — carried as an empty body rather than a JSON null for the same generated-client reason as the resource-addressed GET. */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Caller is not an agent */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        /**
+         * Publish anchored text for a representation, keyed by its content checksum
+         * @description Store the coordinate map derived from a representation's bytes, under the SHA-256 checksum of those bytes (PERSIST-ANCHORS decision A: one artifact per representation, and a representation is its bytes). The producer supplies the checksum because it alone knows which bytes it actually read — deriving the key server-side from the resource's current representation would file old geometry under a new checksum when a byte change races the publish, and that entry would read as present to the reconcile planner forever. Reads remain resource-addressed (GET /resources/{id}/anchored-text); the server resolves the resource to its current representation's checksum.
+         *
+         *     The Smelter is the sole producer: it is the only process that reads those bytes at ingest, so it is the only one positioned to derive a map cheaply, and it runs separately from the backend.
+         *
+         *     Agents only. A map is derived data every consumer trusts to place annotation geometry, so a browser session must not be able to write one.
+         */
+        put: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    /** @description Hex SHA-256 checksum of the representation bytes the map was derived from. */
+                    checksum: string;
+                };
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["ExtractionOutcome"];
+                };
+            };
+            responses: {
+                /** @description Stored */
+                204: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content?: never;
+                };
+                /** @description Body is not a valid ExtractionOutcome */
+                400: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+                /** @description Caller is not an agent */
+                403: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
+            };
+        };
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/resources/{id}/jsonld": {
         parameters: {
             query?: never;
@@ -2069,6 +2305,36 @@ interface components {
             oldIndex: number;
             newIndex: number;
         };
+        /** @description Text paired with the geometry that indexes it — the minimum needed to turn a character range into a selection, or a rectangle into a quote. Whole-resource: a producer iterates page by page, but every consumer wants one map. */
+        AnchoredText: {
+            /** @description Reading-order text of the whole resource. */
+            text: string;
+            /** @description Positioned runs indexing `text`, roughly one per word. */
+            items: components["schemas"]["PdfTextItem"][];
+        };
+        /** @description One positioned text run. Coordinates are PDF points with the origin at the bottom-left of the page, Y increasing upward; the flip to canvas pixels happens in the browser. */
+        PdfTextItem: {
+            /** @description Char offset into AnchoredText.text, inclusive. */
+            start: number;
+            /** @description Char offset into AnchoredText.text, exclusive. */
+            end: number;
+            /** @description 1-indexed page number. */
+            page: number;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        /** @description Request a resource's derived coordinate map — the text recovered from its bytes plus the geometry indexing it. Read-only: the Smelter is the sole producer and publishes through the content transport, never over this channel. */
+        BrowseAnchoredTextRequest: {
+            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. */
+        BrowseAnchoredTextResult: {
+            correlationId: string;
+            response: components["schemas"]["ExtractionOutcome"] | null;
+        };
         /** @description Request to browse a single resource */
         BrowseResourceRequest: {
             correlationId: string;
@@ -2303,6 +2569,35 @@ interface components {
             data: string;
             id?: string;
         };
+        /** @description The full outcome of text extraction for one representation — the record the anchored-text store holds and the wire serves (PERSIST-ANCHORS decision D1). Either a success (the anchored text plus its provenance: how it was extracted, what class of PDF it came from, how confident OCR was, which pages could not be read) or a named decline. A decline is a first-class, cacheable outcome: 'we ran and there was nothing' costs a full recognition pass to discover. ocrConfidence is extraction quality for operators, deliberately not anchor confidence. */
+        ExtractionOutcome: (components["schemas"]["AnchoredText"] & {
+            /**
+             * @description How the text was extracted.
+             * @enum {string}
+             */
+            method: "text-passthrough" | "pdf-text-layer" | "table" | "form" | "ocr";
+            /**
+             * @description PDF classification, when the source was a PDF.
+             * @enum {string}
+             */
+            pdfClass?: "A" | "B" | "C" | "D" | "E" | "F" | "G";
+            /** @description How well the engine read the pixels, when any of this text came from OCR. */
+            ocrConfidence?: {
+                /** @description Mean per-word confidence, 0-100. */
+                mean: number;
+                /** @description Words the engine was unsure of. */
+                lowConfidenceWords: number;
+                totalWords: number;
+            };
+            /** @description 1-indexed pages this extraction could not read — present only for partially covered documents (class C). */
+            unreadPages?: number[];
+        }) | {
+            /**
+             * @description Why extraction yielded nothing, by class.
+             * @enum {string}
+             */
+            declined: "no-text-layer" | "encrypted" | "corrupt" | "too-large";
+        };
         FileEntry: {
             /** @enum {string} */
             type: "file";
@@ -2647,6 +2942,21 @@ interface components {
             annotationId?: string;
             error: 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: {
+            /**
+             * @description Discriminant. Always true — a job that did its work reports one of the other result shapes.
+             * @enum {boolean}
+             */
+            declined: true;
+            /**
+             * @description Why the resource could not be read.
+             * @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: {
             jobId: string;
@@ -2752,7 +3062,7 @@ interface components {
             progress?: components["schemas"]["JobProgress"];
         };
         /** @description Discriminated union of all job result types. */
-        JobResult: components["schemas"]["JobGenerationResult"] | components["schemas"]["JobReferenceAnnotationResult"] | components["schemas"]["JobHighlightAnnotationResult"] | components["schemas"]["JobAssessmentAnnotationResult"] | components["schemas"]["JobCommentAnnotationResult"] | components["schemas"]["JobTagAnnotationResult"];
+        JobResult: components["schemas"]["JobGenerationResult"] | components["schemas"]["JobReferenceAnnotationResult"] | components["schemas"]["JobHighlightAnnotationResult"] | components["schemas"]["JobAssessmentAnnotationResult"] | components["schemas"]["JobCommentAnnotationResult"] | components["schemas"]["JobTagAnnotationResult"] | components["schemas"]["JobDeclinedResult"];
         /** @description Command to start a job */
         JobStartCommand: {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
@@ -3225,6 +3535,8 @@ interface components {
             score: number;
             /** @description Entity types on the matched passage */
             entityTypes?: string[];
+            /** @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 Emitted when the hover delay setting changes */
         SettingsHoverDelayChangedEvent: {
@@ -3397,6 +3709,15 @@ interface components {
             /** @description The validated JWT token string for the current session */
             token: string;
         };
+        /** @description Bus command to rebuild anchored-text artifacts by re-running extraction — every geometry-capable resource when resourceId is absent, one resource when present. Served by the Smelter, serialized (each unit can be a multi-second OCR pass), and never destructive: nothing is deleted first, stale entries are simply overwritten. Re-anchoring makes zero embedding calls — the vectors are already correct; only the derived map is re-made. Partial completion replies failed, with counts: a rebuild that quietly skipped resources would present exactly like a document with no text. */
+        SmeltRebuildAnchorsCommand: {
+            /** @description Correlation id for request/reply matching, set by busRequest so the ok/failed reply routes back. */
+            correlationId?: string;
+            /** @description When present, re-anchor only this resource; otherwise every geometry-capable resource in the catalog. */
+            resourceId?: string;
+            /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
+            _userId?: string;
+        };
         /** @description Bus command to rebuild the graph projection from the event log — the whole graph when resourceId is absent, one resource when present. Served by the Weaver; replaces direct rebuild access, which does not survive the Weaver's container split. */
         WeaveRebuildCommand: {
             /** @description Correlation id for request/reply matching, set by busRequest so the ok/failed reply routes back. */
@@ -4012,6 +4333,14 @@ type EventMap = {
     'browse:resource-failed': {
         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-failed': {
+        correlationId: string;
+    } & components['schemas']['CommandError'];
     'browse:resources-requested': components['schemas']['BrowseResourcesRequest'];
     'browse:resources-result': {
         correlationId: string;
@@ -4160,6 +4489,7 @@ type EventMap = {
         resourceId: string;
         contentChecksum: string;
         outcome: 'indexed' | 'skipped';
+        reason?: 'no-extractor' | 'empty' | 'no-text-layer' | 'encrypted' | 'corrupt' | 'too-large';
     };
     'weave:rebuild': components['schemas']['WeaveRebuildCommand'];
     'weave:rebuild-ok': {
@@ -4169,6 +4499,14 @@ type EventMap = {
         correlationId?: string;
         message: string;
     };
+    'smelt:rebuild-anchors': components['schemas']['SmeltRebuildAnchorsCommand'];
+    'smelt:rebuild-anchors-ok': {
+        correlationId?: string;
+    };
+    'smelt:rebuild-anchors-failed': {
+        correlationId?: string;
+        message: string;
+    };
     'settings:theme-changed': components['schemas']['SettingsThemeChangedEvent'];
     'settings:line-numbers-toggled': void;
     'settings:locale-changed': components['schemas']['SettingsLocaleChangedEvent'];
@@ -4350,6 +4688,9 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'browse:resource-requested': "BrowseResourceRequest";
     readonly 'browse:resource-result': "BrowseResourceResult";
     readonly 'browse:resource-failed': null;
+    readonly 'browse:anchored-text-requested': "BrowseAnchoredTextRequest";
+    readonly 'browse:anchored-text-result': "BrowseAnchoredTextResult";
+    readonly 'browse:anchored-text-failed': null;
     readonly 'browse:resources-requested': "BrowseResourcesRequest";
     readonly 'browse:resources-result': "BrowseResourcesResult";
     readonly 'browse:resources-failed': null;
@@ -4428,6 +4769,9 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'weave:rebuild': "WeaveRebuildCommand";
     readonly 'weave:rebuild-ok': null;
     readonly 'weave:rebuild-failed': null;
+    readonly 'smelt:rebuild-anchors': "SmeltRebuildAnchorsCommand";
+    readonly 'smelt:rebuild-anchors-ok': null;
+    readonly 'smelt:rebuild-anchors-failed': null;
     readonly 'stream-connected': null;
     readonly 'replay-window-exceeded': null;
     readonly 'bus:resume-gap': null;
@@ -5124,6 +5468,163 @@ declare function parseFragmentSelector(fragment: string): PdfCoordinate | null;
 /** Extract the 1-indexed page number from a FragmentSelector value. */
 declare function getPageFromFragment(fragment: string): number | null;
 
+/**
+ * Text ↔ geometry anchoring for PDFs.
+ *
+ * Two directions over the same pairing of text and the runs that index it:
+ * `locate` turns a character span into rectangles (an annotation the model
+ * produced by quoting text), `textUnder` turns a rectangle into characters (an
+ * annotation a person produced by dragging a box). They are inverses and live
+ * together deliberately.
+ *
+ * This is pure arithmetic over plain data, so it sits here beside
+ * `PdfCoordinate` and the viewrect codec rather than in `@semiont/content`:
+ * the browser canvas needs `textUnder` at drag time and cannot import
+ * `@semiont/content`, which carries pdf.js, Tesseract and `node:fs`.
+ * *Producing* an `AnchoredText` — from a text layer or from OCR — stays there.
+ *
+ * Coordinates are PDF points with the origin at the bottom-left of the page,
+ * Y increasing upward. The Y-flip to canvas pixels lives in the browser.
+ */
+
+/**
+ * A single text item (one text run, roughly a word) from a PDF.
+ * Character offsets refer to positions in the paired `AnchoredText.text`.
+ */
+interface PdfTextItem {
+    start: number;
+    end: number;
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Text paired with the geometry that indexes it — the minimum needed to turn a
+ * character range into a Selection, or a rectangle into a quote.
+ *
+ * This is the contract `locate`, `textUnder` and the annotation builders
+ * actually require; they do not need pages, form fields, or anything else a
+ * full `PdfTextLayer` carries. Naming it separately lets OCR'd content
+ * (recovered from pixels, so not a "text layer" in the PDF sense) satisfy the
+ * same anchoring path.
+ */
+interface AnchoredText {
+    text: string;
+    items: PdfTextItem[];
+}
+/**
+ * The full outcome of text extraction for one representation — the record
+ * the anchored-text store holds and the wire serves (PERSIST-ANCHORS
+ * decision D1): an `AnchoredText` plus its provenance (`method`, `pdfClass`,
+ * `ocrConfidence`, `unreadPages`), or a named decline. `AnchoredText` stays
+ * the anchoring vocabulary; this is the stored/served record. Aliased from
+ * the generated spec type so the wire shape has exactly one authority.
+ */
+type ExtractionOutcome = components['schemas']['ExtractionOutcome'];
+/**
+ * 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
+ * producer filters marked-content items at its own boundary and passes the
+ * text runs through.
+ */
+interface PdfTextRun {
+    str: string;
+    /** pdf.js text matrix `[a, b, c, d, x, y]`; only x/y are read. */
+    transform: number[];
+    width: number;
+    height: number;
+    hasEOL?: boolean;
+}
+/**
+ * pdf.js interleaves marked-content items with text runs in `getTextContent()`;
+ * only the latter carry `str`. Both producers filter with this before calling
+ * `anchorRuns`, so the boundary rule is stated once.
+ */
+declare function isTextRun<T>(item: T): item is T & PdfTextRun;
+/**
+ * Turns one page's pdf.js text runs into `AnchoredText`.
+ *
+ * This is the offset and separator convention — what `text` says, and where
+ * each item points into it. Both producers share it: the server extractor
+ * reading a whole document, and the browser canvas reading the page under a
+ * drag. Divergence would mean the same rectangle quoting differently depending
+ * on which side captured it.
+ *
+ * Offsets are page-local. A caller assembling a multi-page document shifts them
+ * by the length of the text already accumulated.
+ */
+declare function anchorRuns(runs: PdfTextRun[], page: number): AnchoredText;
+/**
+ * Locates bounding rectangles for a span of text in an AnchoredText
+ * (single-line or multi-line).
+ *
+ * Finds all overlapping items [start, end), groups them by page and line, and
+ * records one bounding rectangle per line as a PdfCoordinate.
+ *
+ * Returns both the per-line `rects` and the `overlap` items they were computed
+ * from — so a caller that also needs the covered text (e.g. buildPdfAnnotation's
+ * geometry↔text containment invariant) reuses this single `items` scan
+ * instead of re-filtering. Both arrays are empty if no item overlaps the span.
+ */
+declare function locate(anchored: AnchoredText, start: number, end: number): {
+    rects: PdfCoordinate[];
+    overlap: PdfTextItem[];
+};
+/**
+ * The inverse of `locate`: given a rectangle, returns the text under it.
+ *
+ * A hand-drawn PDF rectangle otherwise carries no quoted text at all, so every
+ * panel that quotes an annotation shows it blank
+ * (.plans/PDF-MANUAL-ANNOTATION-TEXT.md).
+ *
+ * `rect` is in the same PDF-point, bottom-left-origin space as `PdfTextItem`,
+ * so a canvas drag rectangle passes straight in. A run counts as covered when
+ * the rectangle overlaps `RUN_COVERAGE_THRESHOLD` of its area — see there for
+ * why any-intersection is not survivable for a hand-drawn box.
+ *
+ * Covered runs are emitted in reading order (`text` offset order), which
+ * inherits the extractor's known column-major ordering on multi-column pages
+ * rather than answering it a second, different way.
+ *
+ * Returns `''` when nothing is covered — over an image, over whitespace, or
+ * over a scanned page with no text layer. Callers must then emit no
+ * `TextQuoteSelector` at all: an empty quote would assert the box was drawn
+ * around nothing.
+ */
+declare function textUnder(anchored: AnchoredText, rect: PdfCoordinate): string;
+
+/**
+ * Two-stage citation search over an extracted PDF text layer
+ * (PDF-GENERATION P4).
+ *
+ * A citation's `exact` claim text comes from the authored source; the rendered
+ * text layer diverges from it in exactly two measured ways (the P0 spike):
+ * line breaks (`anchorRuns` joins runs with " \n") and hyphenation (soft
+ * hyphens are DROPPED — a hyphenated word yields its two halves with no hyphen
+ * character anywhere).
+ *
+ * Two stages, in this order, never collapsed to one matcher:
+ *
+ *   1. STRICT — search a whitespace-normalized copy, offsets mapped back.
+ *      Bridges plain line breaks (" \n" collapses to " ").
+ *   2. BREAK-AWARE — only on a strict miss. The line break becomes a distinct
+ *      marker character that may be absorbed in any inter-character gap, with
+ *      an optional space on either side (anchorRuns emits a space *then* the
+ *      newline). Ordinary spaces are NEVER wildcards, so "abc" cannot match
+ *      "a b c" — only a real break is absorbable.
+ *
+ * The ordering is the safety property: the permissive matcher runs only where
+ * the strict one already failed, so it can never turn a working citation into
+ * a wrong one — only a failure into an unlikely mismatch.
+ */
+
+declare function findClaimSpan(anchored: AnchoredText, exact: string): {
+    start: number;
+    end: number;
+} | null;
+
 /**
  * Helper functions for working with W3C ResourceDescriptor
  */
@@ -5560,6 +6061,85 @@ interface IContentTransport {
     getResourceGraph(resourceId: ResourceId, options?: {
         auth?: AccessToken;
     }): Promise<GetResourceResponse>;
+    /**
+     * Store anchored text — the coordinate map a producer derived from a
+     * representation's bytes (OCR, a native text layer, a table or form
+     * reader) — under **the content checksum of those bytes** (PERSIST-ANCHORS
+     * decision A: one artifact per representation, and a representation IS its
+     * bytes).
+     *
+     * The producer supplies the checksum because it alone knows which bytes it
+     * actually read. That is a correctness rule, not a convenience: if the
+     * store derived the key from the resource's CURRENT representation at
+     * write time, a byte change racing the publish would file old geometry
+     * under the new checksum — wrong quotes served, and the reconcile diff
+     * sees "artifact present" so it never heals. Producer-supplied, the same
+     * race files the map under the OLD checksum: an unreachable orphan, and
+     * the new checksum's missing artifact is exactly what the third drift
+     * class re-derives (SMELTER-AXIOMS S15).
+     *
+     * Its own method rather than a `putBinary` of some derived media type: a
+     * coordinate map is not a *representation* of the resource, and dressing it
+     * as one would make a derived artifact indistinguishable from content a user
+     * uploaded.
+     *
+     * Whole-representation, like `getResourceGraph` is whole-resource. The
+     * producer iterates page by page; every consumer wants one map.
+     */
+    putAnchoredText(checksum: string, outcome: ExtractionOutcome, options?: {
+        auth?: AccessToken;
+    }): Promise<void>;
+    /**
+     * The resource's anchored text, or `null` when none has been derived.
+     *
+     * Deliberately resource-addressed while `putAnchoredText` is
+     * checksum-addressed: readers hold a resource id, and the server resolves
+     * it to the current representation's checksum through the view — the
+     * `resourceId → checksum` index of PERSIST-ANCHORS decision A. A reader
+     * therefore can never receive geometry for bytes the resource no longer
+     * has: the pointer moves, the artifacts stay, the index always follows
+     * the pointer.
+     *
+     * `null` is not an error and is the common case: a native text layer is read
+     * in the browser, and a resource whose media type has no extractor never
+     * produces a map at all. Callers degrade — for a PDF annotation that means
+     * geometry with no quoted text, which is the behaviour that shipped before
+     * any of this existed.
+     */
+    getAnchoredText(resourceId: ResourceId, options?: {
+        auth?: AccessToken;
+    }): Promise<ExtractionOutcome | null>;
+    /**
+     * The stored extraction outcome for exactly this byte content, or `null`
+     * for a miss — the cache-consult read (PERSIST-ANCHORS P2c). Every cache
+     * consumer runs out of process (the smelter worker, the detection
+     * workers), so the `extract()` seam's consult crosses the wire through
+     * this method; without it the cache would be write-only from exactly the
+     * processes it exists to serve.
+     *
+     * Checksum-addressed and barrier-free, unlike `getAnchoredText`:
+     * presence at this instant is the question (the keys listing's
+     * semantics), and a caller holding the checksum already holds the
+     * content identity — nothing to resolve, nothing to wait for.
+     */
+    getAnchoredTextByChecksum(checksum: string, options?: {
+        auth?: AccessToken;
+    }): Promise<ExtractionOutcome | null>;
+    /**
+     * Every key under which anchored text would currently be served — the
+     * reconcile planner's bulk existence read (PERSIST-ANCHORS P0). The
+     * Smelter diffs this against the catalog to find resources whose artifact
+     * was lost (a transient store, a failed publish) and plans re-derivation;
+     * one call per reconcile, never a `getAnchoredText` probe per resource,
+     * because each map is ~32 KB per scanned page and only presence is asked.
+     *
+     * Keys are resource ids today; after PERSIST-ANCHORS P1 they are content
+     * checksums. Callers compare against whichever handle the store is keyed
+     * by — the diff moves with the rekey, this contract does not.
+     */
+    listAnchoredTextKeys(options?: {
+        auth?: AccessToken;
+    }): Promise<string[]>;
     dispose(): void;
 }
 
@@ -5599,6 +6179,10 @@ declare const BUS_OPERATIONS: {
         readonly result: "browse:resource-result";
         readonly failure: "browse:resource-failed";
     };
+    readonly 'browse:anchored-text-requested': {
+        readonly result: "browse:anchored-text-result";
+        readonly failure: "browse:anchored-text-failed";
+    };
     readonly 'browse:resources-requested': {
         readonly result: "browse:resources-result";
         readonly failure: "browse:resources-failed";
@@ -5708,6 +6292,10 @@ declare const BUS_OPERATIONS: {
         readonly result: "weave:rebuild-ok";
         readonly failure: "weave:rebuild-failed";
     };
+    readonly 'smelt:rebuild-anchors': {
+        readonly result: "smelt:rebuild-anchors-ok";
+        readonly failure: "smelt:rebuild-anchors-failed";
+    };
     readonly 'yield:create': {
         readonly result: "yield:create-ok";
         readonly failure: "yield:create-failed";
@@ -6275,6 +6863,10 @@ interface MediaTypeCapabilities {
     extractText: TextExtraction;
     authorable: boolean;
     uploadable: boolean;
+    /** Whether the generation worker can produce this type as a yield artifact.
+     *  Gate for `outputMediaType` — unsupported requests fail loudly, never
+     *  fall back to markdown under a mislabeled format. */
+    generatable: boolean;
 }
 /**
  * The registry. `satisfies Record<SupportedMediaType, …>` is the
@@ -6294,6 +6886,7 @@ declare const MEDIA_TYPES: {
         extractText: "decode";
         authorable: true;
         uploadable: true;
+        generatable: true;
     };
     'text/plain': {
         extension: ".txt";
@@ -6303,6 +6896,7 @@ declare const MEDIA_TYPES: {
         extractText: "decode";
         authorable: true;
         uploadable: true;
+        generatable: true;
     };
     'text/html': {
         extension: ".html";
@@ -6312,6 +6906,7 @@ declare const MEDIA_TYPES: {
         extractText: "decode";
         authorable: true;
         uploadable: true;
+        generatable: false;
     };
     'application/json': {
         extension: ".json";
@@ -6321,6 +6916,7 @@ declare const MEDIA_TYPES: {
         extractText: "decode";
         authorable: false;
         uploadable: true;
+        generatable: false;
     };
     'image/png': {
         extension: ".png";
@@ -6330,6 +6926,7 @@ declare const MEDIA_TYPES: {
         extractText: "none";
         authorable: false;
         uploadable: true;
+        generatable: false;
     };
     'image/jpeg': {
         extension: ".jpg";
@@ -6339,6 +6936,7 @@ declare const MEDIA_TYPES: {
         extractText: "none";
         authorable: false;
         uploadable: true;
+        generatable: false;
     };
     'application/pdf': {
         extension: ".pdf";
@@ -6348,6 +6946,7 @@ declare const MEDIA_TYPES: {
         extractText: "pdf-text-layer";
         authorable: false;
         uploadable: true;
+        generatable: true;
     };
     'text/css': MediaTypeCapabilities;
     'text/csv': MediaTypeCapabilities;
@@ -6444,6 +7043,9 @@ 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. */
 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. */
+declare const GENERATABLE_MEDIA_TYPES: readonly SupportedMediaType[];
 
 /**
  * Resource input/output types
@@ -6496,12 +7098,58 @@ interface GoogleAuthRequest {
 }
 
 /**
- * ID generation utilities
+ * ID generation utilities.
+ *
+ * Built on `crypto.getRandomValues()`, NOT `crypto.randomUUID()`: browsers
+ * expose `randomUUID` only in secure contexts (https, `http://localhost`,
+ * `http://127.0.0.1`), so a page served over plain http from any other host
+ * has no `randomUUID` and calling it throws — which broke the frontend from
+ * the host-gateway IP (.plans/bugs/crypto-randomuuid-insecure-context.md).
+ * `getRandomValues` is cryptographically sound and available in ALL contexts,
+ * Node and browser, secure or not.
  */
 /**
- * Generate a UUID v4 string (without dashes)
+ * Generate a UUID v4 string WITHOUT dashes (32 hex chars).
+ *
+ * The dashless form is data shape: persisted annotation/resource/job ids are
+ * built from it and land in URIs. Do not change the format.
  */
 declare function generateUuid(): string;
+/**
+ * Generate a canonical dashed UUID v4 (36 chars, 8-4-4-4-12) — the format
+ * `crypto.randomUUID()` produces, without its secure-context requirement.
+ *
+ * Use for ephemeral wire ids (`correlationId`s and the like).
+ */
+declare function uuidV4(): string;
+
+/**
+ * Text Chunking Utilities
+ *
+ * Splits long text into overlapping chunks for embedding.
+ * Each chunk is a passage that fits within the embedding model's context window.
+ */
+interface ChunkingConfig {
+    chunkSize: number;
+    overlap: number;
+}
+declare const DEFAULT_CHUNKING_CONFIG: ChunkingConfig;
+/**
+ * Rough token count estimate: ~4 characters per token for English text.
+ *
+ * Exported as the single token-estimation heuristic: `chunkText` sizes chunks
+ * with it, and inference/detection budget arithmetic must use the same
+ * heuristic so estimates and chunk sizes agree.
+ */
+declare function estimateTokens(text: string): number;
+/**
+ * Split text into overlapping chunks.
+ *
+ * Splits on paragraph boundaries when possible, falling back to sentence
+ * boundaries, then word boundaries. Each chunk overlaps with the previous
+ * by `overlap` tokens worth of text.
+ */
+declare function chunkText(text: string, config?: ChunkingConfig): string[];
 
 /**
  * Marker for the state-unit pattern: a stateful, lifecycled object with an
@@ -7276,7 +7924,7 @@ type TomlFileReader = {
  *
  * @param projectRoot - Path to the project root (contains .semiont/config)
  * @param environment - Environment name (e.g. 'local', 'production'); when
- *   undefined, resolved from SEMIONT_ENV, then `[defaults] environment`
+ *   undefined, resolved from `[defaults] environment`
  * @param globalConfigPath - Path to ~/.semiontconfig (caller resolves ~ expansion)
  * @param reader - File reader abstraction
  * @param env - Environment variables for ${VAR} resolution
@@ -7434,6 +8082,59 @@ declare function isTransientFetchError(error: unknown): boolean;
  */
 declare function retryWithBackoff<T>(fn: () => Promise<T>, isRetryable: (error: unknown) => boolean, policy: RetryPolicy, onRetry?: (info: RetryAttemptInfo) => void): Promise<T>;
 
+/**
+ * Sharding Utilities
+ *
+ * Shared utilities for consistent sharding across all storage layers —
+ * the event log and view storage (@semiont/event-sourcing) and the
+ * anchored-text store (@semiont/content) all lay files out as
+ * `{ab}/{cd}/<key>` through `getShardPath`. Hoisted here (PERSIST-ANCHORS
+ * P1a) so both importers share one implementation: a second sharding
+ * implementation is how two trees end up disagreeing about where
+ * something lives.
+ *
+ * Pure string/number math — no node dependencies — so it is safe on
+ * core's browser-facing root export.
+ */
+/**
+ * TEMPORARY: Simple modulo-based hash sharding
+ *
+ * ⚠️ TODO: Replace with proper Jump Consistent Hash implementation
+ *
+ * This is a TEMPORARY implementation using simple modulo. It works and provides
+ * good distribution, but does NOT provide the minimal reshuffling property of
+ * Jump Consistent Hash when changing bucket counts.
+ *
+ * The proper implementation should use Google's Jump Consistent Hash algorithm:
+ * Reference: "A Fast, Minimal Memory, Consistent Hash Algorithm" by Lamping & Veach (2014)
+ * https://arxiv.org/abs/1406.2294
+ *
+ * Working implementations exist in npm packages like:
+ * - jumphash (https://www.npmjs.com/package/jumphash)
+ * - jump-gouache (https://github.com/bhoudu/jump-gouache)
+ *
+ * The algorithm requires proper 64-bit integer handling with BigInt to avoid
+ * precision loss in JavaScript. The previous attempt failed due to incorrect
+ * BigInt arithmetic in the while loop condition.
+ *
+ * Until replaced, this modulo approach will cause ALL data to be reshuffled
+ * if bucket count changes, rather than the optimal O(n/k) reshuffling that
+ * Jump Consistent Hash provides.
+ *
+ * @param key - The key to hash (a resource id or content checksum)
+ * @param numBuckets - Number of shards/buckets (default: 65536 for 4-hex sharding)
+ * @returns Shard number (0 to numBuckets-1)
+ */
+declare function jumpConsistentHash(key: string, numBuckets?: number): number;
+/**
+ * Get 4-hex shard path for a key
+ *
+ * @param key - The key to hash (a resource id or content checksum)
+ * @param numBuckets - Number of shards (default: 65536)
+ * @returns Path segments like ['ab', 'cd']
+ */
+declare function getShardPath(key: string, numBuckets?: number): [string, string];
+
 /**
  * Browser ↔ launcher KB discovery (BROWSER-KB-DISCOVERY).
  *
@@ -7447,5 +8148,5 @@ declare function retryWithBackoff<T>(fn: () => Promise<T>, isRetryable: (error:
  */
 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, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, 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, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, 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, 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, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, kbDid, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, 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, 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, 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 };