@semiont/core 0.5.5 → 0.5.7

package/dist/index.d.ts

@@ -1545,8 +1545,8 @@ interface paths {
                         file: string;
                         /** @description Media type of the content (e.g. text/plain, text/markdown, image/png) */
                         format: string;
-                        /** @description Where the content has been / should be placed (file://... for local). If omitted, derived from name + format. */
-                        storageUri?: string;
+                        /** @description Where the content lives (file://... for local). Required — the client names the location; the server does not derive one. */
+                        storageUri: string;
                         /** @description ISO 639-1 language code */
                         language?: string;
                         /** @description JSON-stringified array of entity type names */
@@ -1574,7 +1574,7 @@ interface paths {
                         "application/json": components["schemas"]["CreateResourceResponse"];
                     };
                 };
-                /** @description Missing required fields (name, file, or format) */
+                /** @description Missing required fields (name, file, format, or storageUri), or the format's base MIME type is not a SupportedMediaType. The error message names the offending type. */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -1608,20 +1608,17 @@ interface paths {
             cookie?: never;
         };
         /**
-         * Get a resource (content-negotiated)
-         * @description Content negotiation via the Accept header:
-         *     - application/ld+json (default) — returns JSON-LD metadata including all annotations + inbound entity references
-         *     - text/* or image/* or application/pdf — returns the raw representation bytes
+         * Get a resource's stored representation (the pipe)
+         * @description Returns the stored representation's bytes, verbatim, with the stored media type in Content-Type (`application/octet-stream` when the stored metadata carries none). The Accept header is never read: there is no content negotiation and no transcoding, so the served bytes always hash to the representation's registered checksum.
          *
-         *     Binary payloads flow directly from the content store; metadata payloads go through the bus gateway.
+         *     The resource's JSON-LD description (descriptor + annotations + inbound entity references) lives at GET /resources/{id}/jsonld; every content response advertises it via a `Link: rel="describedby"` header.
+         *
+         *     Content is immutable (checksum-addressed), and this route is bearer-authenticated, so responses carry `Cache-Control: private, max-age=31536000, immutable`.
          */
         get: {
             parameters: {
                 query?: never;
-                header?: {
-                    /** @description application/ld+json for metadata, or a text/image/pdf media type for raw content */
-                    Accept?: string;
-                };
+                header?: never;
                 path: {
                     id: string;
                 };
@@ -1629,21 +1626,18 @@ interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Resource content or metadata, depending on Accept */
+                /** @description The stored representation's bytes, verbatim */
                 200: {
                     headers: {
+                        /** @description `</resources/{id}/jsonld>; rel="describedby"; type="application/ld+json"` — where to dereference the resource's JSON-LD description */
+                        Link?: string;
                         [name: string]: unknown;
                     };
                     content: {
-                        "application/ld+json": components["schemas"]["GetResourceResponse"];
-                        "text/plain": string;
-                        "text/markdown": string;
-                        "text/html": string;
-                        "image/*": string;
-                        "application/pdf": string;
+                        "*/*": string;
                     };
                 };
-                /** @description Resource not found */
+                /** @description Resource or representation not found */
                 404: {
                     headers: {
                         [name: string]: unknown;
@@ -1661,6 +1655,58 @@ interface paths {
                         "application/json": components["schemas"]["ErrorResponse"];
                     };
                 };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}/jsonld": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get a resource's JSON-LD description
+         * @description The dereferenceable linked-data description of the resource: its descriptor plus all annotations and inbound entity references, assembled via the bus gateway. This is the target of the `Link: rel="describedby"` header that GET /resources/{id} sends with every content response.
+         *
+         *     Live data — annotations and references change — so responses carry `Cache-Control: no-cache`, in contrast to the immutable content at GET /resources/{id}.
+         */
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: string;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description The resource's JSON-LD description */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/ld+json": components["schemas"]["GetResourceResponse"];
+                    };
+                };
+                /** @description Resource not found */
+                404: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["ErrorResponse"];
+                    };
+                };
                 /** @description Request timed out (bus gateway) */
                 504: {
                     headers: {
@@ -1688,10 +1734,10 @@ interface paths {
             cookie?: never;
         };
         /**
-         * Get raw resource content (browser-friendly alias)
-         * @description Browser-friendly alternative to GET /resources/{id} that always returns the raw representation, never JSON-LD. Used by `<img>` / PDF.js / `<video>` tags and anywhere an httpOnly cookie is the only feasible auth vector. Behaves like GET /resources/{id} with JSON-LD stripped from the Accept header before content negotiation.
+         * Get a resource's stored representation (browser-friendly alias)
+         * @description Identical pipe to GET /resources/{id} — verbatim bytes, stored media type in Content-Type, Accept never read. Exists only as the auth affordance for `<img>` / PDF.js / download links, which cannot carry Authorization headers: the `?token=` media token or the httpOnly semiont-token cookie ride along automatically.
          *
-         *     Sets long-lived immutable Cache-Control (content is addressed by checksum upstream, so bytes never change for a given resource id).
+         *     Responses carry `Cache-Control: public, max-age=31536000, immutable` — `public` is safe here, unlike the bearer-authenticated main route, because the `?token=` is part of the cache key.
          */
         get: {
             parameters: {
@@ -1704,17 +1750,15 @@ interface paths {
             };
             requestBody?: never;
             responses: {
-                /** @description Raw representation bytes with appropriate Content-Type */
+                /** @description The stored representation's bytes, verbatim */
                 200: {
                     headers: {
+                        /** @description `</resources/{id}/jsonld>; rel="describedby"; type="application/ld+json"` — where to dereference the resource's JSON-LD description */
+                        Link?: string;
                         [name: string]: unknown;
                     };
                     content: {
-                        "text/plain": string;
-                        "text/markdown": string;
-                        "text/html": string;
-                        "image/*": string;
-                        "application/pdf": string;
+                        "*/*": string;
                     };
                 };
                 /** @description Resource or representation not found */
@@ -1895,22 +1939,10 @@ interface components {
             targetResource?: components["schemas"]["ResourceDescriptor"] | null;
             /** @description Gathered context for this annotation */
             context?: components["schemas"]["GatheredContext"];
-            /** @description DEPRECATED: Use 'context' instead. Legacy source context format. */
-            sourceContext?: {
-                before: string;
-                selected: string;
-                after: string;
-            };
             targetContext?: {
                 content: string;
                 summary?: string;
             };
-            suggestedResolution?: {
-                resourceId: string;
-                resourceName: string;
-                confidence: number;
-                reasoning: string;
-            };
         };
         /** @description W3C Web Annotation target object - source is required, selector is optional */
         AnnotationTarget: {
@@ -2059,10 +2091,15 @@ interface components {
             details?: string;
         };
         /**
-         * @description Content format as MIME type, optionally with charset parameter. Values include: text/plain, text/plain; charset=utf-8, text/plain; charset=iso-8859-1, text/markdown, text/markdown; charset=windows-1252, image/png, image/jpeg, application/pdf
+         * @description Content format as a MIME type, optionally with parameters. The base type (everything before the first ';') MUST be a SupportedMediaType; parameters such as charset are preserved as metadata. Semantic validation happens in code at the create/yield boundary — there is deliberately no pattern here, the vocabulary lives in SupportedMediaType. Examples: text/plain, text/plain; charset=iso-8859-1, text/markdown; charset=windows-1252, image/png, application/pdf
          * @example text/plain; charset=utf-8
          */
         ContentFormat: string;
+        /**
+         * @description Base MIME types (no parameters) admitted by Semiont. Membership is the create/yield gate — every member is storable, nameable, and uploadable. What more the system can do with a type (render, annotate, extract text, author) is curated per type in @semiont/core's media-type registry, which is keyed by this enum.
+         * @enum {string}
+         */
+        SupportedMediaType: "text/plain" | "text/markdown" | "text/html" | "text/css" | "text/csv" | "text/xml" | "application/json" | "application/xml" | "application/yaml" | "application/x-yaml" | "application/pdf" | "application/msword" | "application/vnd.openxmlformats-officedocument.wordprocessingml.document" | "application/vnd.ms-excel" | "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" | "application/vnd.ms-powerpoint" | "application/vnd.openxmlformats-officedocument.presentationml.presentation" | "application/zip" | "application/gzip" | "application/x-tar" | "application/x-7z-compressed" | "application/octet-stream" | "application/wasm" | "image/png" | "image/jpeg" | "image/gif" | "image/webp" | "image/svg+xml" | "image/bmp" | "image/tiff" | "image/x-icon" | "video/mp4" | "video/mpeg" | "video/webm" | "video/ogg" | "video/quicktime" | "video/x-msvideo" | "audio/mpeg" | "audio/wav" | "audio/ogg" | "audio/webm" | "audio/aac" | "audio/flac" | "text/javascript" | "application/javascript" | "text/x-typescript" | "application/typescript" | "text/x-python" | "text/x-java" | "text/x-c" | "text/x-c++" | "text/x-csharp" | "text/x-go" | "text/x-rust" | "text/x-ruby" | "text/x-php" | "text/x-swift" | "text/x-kotlin" | "text/x-shell" | "font/woff" | "font/woff2" | "font/ttf" | "font/otf";
         ContextualSummaryResponse: {
             summary: string;
             relevantFields: {
@@ -2142,8 +2179,6 @@ interface components {
         EventMetadata: {
             /** @description Monotonic position in the event log (ordering authority) */
             sequenceNumber: number;
-            /** @description Byte offset in the JSONL file */
-            streamPosition: number;
             /** @description Optional correlation id propagated from a command. Lets clients match command-result events back to the POST that initiated them. Set by EventStore.appendEvent's options when a route handler passes one through. */
             correlationId?: string;
         };
@@ -3591,7 +3626,7 @@ declare function resourceAnnotationUri(uri: string): ResourceAnnotationUri;
  * These types prevent mixing up resource IDs, annotation IDs, and user IDs
  * at compile time while having zero runtime overhead.
  *
- * URI types (ResourceUri, AnnotationUri) are in @semiont/api-client
+ * URI types (ResourceUri, AnnotationUri) are in @semiont/http-transport
  * since they deal with HTTP URIs returned by the API.
  */
 type ResourceId = string & {
@@ -3619,7 +3654,7 @@ type RawAnnotation = components['schemas']['Annotation'];
  * `components['schemas']['Annotation']`, but with a branded `AnnotationId`
  * for the `id` field. Use this import everywhere the codebase refers to
  * "an annotation"; the raw OpenAPI type is only used inside
- * `@semiont/api-client` at the HTTP boundary.
+ * `@semiont/http-transport` at the HTTP boundary.
  *
  * Implemented by intersection (not `Omit`) to be robust against generator
  * drift — if the OpenAPI schema gets `additionalProperties: true` added,
@@ -3681,7 +3716,7 @@ interface EntityTypeStats {
 /**
  * Persisted Events
  *
- * The 18 event types that get appended to the JSONL event log.
+ * The event types that get appended to the JSONL event log.
  * Each maps a type string to its OpenAPI payload schema.
  * The PersistedEvent union derives from this catalog.
  */
@@ -3731,7 +3766,7 @@ type EventOfType<K extends keyof PersistedEventCatalog> = K extends SystemEventT
     resourceId: ResourceId;
     payload: PersistedEventCatalog[K];
 };
-/** The union of all 20 persisted event types. Discriminated on `type`. */
+/** The union of all persisted event types. Discriminated on `type`. */
 type PersistedEvent = {
     [K in keyof PersistedEventCatalog]: EventOfType<K>;
 }[keyof PersistedEventCatalog];
@@ -4123,23 +4158,13 @@ type EventName = keyof EventMap;
  * for one caller) does NOT belong here. Those are per-caller correlation-ID
  * responses and publish globally — the caller filters by `correlationId`.
  *
- * The frontend's `subscribeToResource(id)` wires these channels via
- * `scope=id&scoped=<channel>` so the SSE route delivers them to that
- * participant. WorkerStateUnit uses this list to decide which emitted events to
- * scope to their resource.
+ * The SDK's resource-scoped `browse.*` live queries wire these channels —
+ * subscribing acquires the scope via the transport's `subscribeToResource`
+ * (`scope=id&scoped=<channel>`) so the SSE route delivers them to that
+ * participant (freshness follows observation; #847). WorkerStateUnit uses this
+ * list to decide which emitted events to scope to their resource.
  */
-/**
- * Audit note (SIMPLE-BUS Phase 3 close): `yield:progress` was
- * considered for inclusion but has only one consumer — the
- * yield-initiator's Observable in `packages/api-client/src/namespaces/yield.ts`.
- * No viewer of the resource other than the initiator subscribes to
- * progress. Scoping therefore serves no fan-out-narrowing purpose for
- * that channel, so it stays global (as a correlation-ID-shaped
- * response, filtered by `referenceId`). Only `yield:finished` and
- * `yield:failed` have a genuine multi-participant consumer (the
- * ResourceViewerPage toast on the source resource).
- */
-declare const RESOURCE_BROADCAST_TYPES: readonly ["job:complete", "job:fail"];
+declare const RESOURCE_BROADCAST_TYPES: readonly [];
 type ResourceBroadcastType = typeof RESOURCE_BROADCAST_TYPES[number];
 /**
  * Authoritative map from bus channel to OpenAPI schema name.
@@ -4956,6 +4981,45 @@ declare function extractBoundingBox(svg: string): {
     height: number;
 } | null;
 
+/**
+ * PDF viewrect FragmentSelector codec.
+ *
+ * `PdfCoordinate` is a bounding rectangle in PDF point space: origin at the
+ * bottom-left of the page, Y increasing upward. The Y-flip to canvas pixels
+ * lives in the browser (`react-ui`); the server has no canvas.
+ *
+ * These functions are the viewrect peer of the W3C `FragmentSelector` wrapper in
+ * `web-annotation-utils`: they serialize/parse the RFC 3778
+ * `page=N&viewrect=left,top,width,height` value. `@semiont/content` (geometry
+ * from the text layer), `@semiont/jobs` (serialization at write time), and the
+ * browser canvas all import them from here — no package reaches into the UI.
+ *
+ * RFC 3778 PDF Fragment Identifiers: https://tools.ietf.org/html/rfc3778
+ */
+/**
+ * A bounding rectangle in PDF point coordinates.
+ * Origin at the bottom-left of the page; Y increases upward.
+ */
+interface PdfCoordinate {
+    page: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Serialize a PdfCoordinate to an RFC 3778 FragmentSelector value.
+ * Format: `page=N&viewrect=left,top,width,height` (all in PDF points).
+ */
+declare function createFragmentSelector(coord: PdfCoordinate): string;
+/**
+ * Parse an RFC 3778 FragmentSelector value into PDF coordinates.
+ * Returns null when the value is not a well-formed page + viewrect fragment.
+ */
+declare function parseFragmentSelector(fragment: string): PdfCoordinate | null;
+/** Extract the 1-indexed page number from a FragmentSelector value. */
+declare function getPageFromFragment(fragment: string): number | null;
+
 /**
  * Helper functions for working with W3C ResourceDescriptor
  */
@@ -5055,7 +5119,7 @@ declare function decodeRepresentation(buffer: Buffer, mediaType: string): string
  * Common error classes — the unified Semiont error hierarchy.
  *
  * `SemiontError` is the base every other Semiont error class extends:
- * `APIError` (api-client), `BusRequestError` and `SemiontSessionError` (sdk),
+ * `APIError` (http-transport), `BusRequestError` and `SemiontSessionError` (sdk),
  * `ValidationError`, `ScriptError`, `NotFoundError`, `UnauthorizedError`,
  * `ConflictError` (here), and `AWSError` (cli). Subclasses tighten the
  * `code` field to a literal-union for discriminated handling.
@@ -5103,7 +5167,7 @@ declare class ConflictError extends SemiontError {
  * Transport interfaces — the shared contract for any wire-or-local
  * communication path consumed by `SemiontClient`. Concrete implementations
  * live alongside the runtime they wrap (`HttpTransport` in
- * `@semiont/api-client`, in-process variants in `@semiont/make-meaning`,
+ * `@semiont/http-transport`, in-process variants in `@semiont/make-meaning`,
  * etc.).
  *
  * Three interfaces:
@@ -5124,6 +5188,7 @@ 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
  * (connecting spinners, reconnecting banners, etc.) and is observed via
@@ -5226,6 +5291,12 @@ interface ITransport {
      *
      * Returns a disposer that detaches the scope when the last subscriber
      * unsubscribes (ref-counted).
+     *
+     * SDK-internal: this is the scope primitive the SDK's resource-scoped
+     * `browse.*` live queries drive on subscribe/teardown (freshness follows
+     * observation; #847) — it is not part of the application-facing surface.
+     * Single-scope at a time; multi-scope is deferred
+     * (`.plans/MULTI-RESOURCE-SCOPE.md`).
      */
     subscribeToResource(resourceId: ResourceId): () => void;
     /**
@@ -5307,7 +5378,7 @@ interface IBackendOperations {
 interface PutBinaryRequest {
     name: string;
     file: File | Buffer;
-    format: ContentFormat | string;
+    format: ContentFormat;
     storageUri: string;
     entityTypes?: string[];
     language?: string;
@@ -5350,19 +5421,27 @@ interface IContentTransport {
         resourceId: ResourceId;
     }>;
     getBinary(resourceId: ResourceId, options?: {
-        accept?: ContentFormat | string;
         auth?: AccessToken;
     }): Promise<{
         data: ArrayBuffer;
         contentType: string;
     }>;
     getBinaryStream(resourceId: ResourceId, options?: {
-        accept?: ContentFormat | string;
         auth?: AccessToken;
     }): Promise<{
         stream: ReadableStream<Uint8Array>;
         contentType: string;
     }>;
+    /**
+     * Fetch the resource's JSON-LD metadata graph (descriptor + annotations +
+     * inbound entity references). The HTTP transport dereferences
+     * `GET /resources/:id/jsonld` (the LD face an external linked-data client
+     * sees); in-process transports assemble it from their `KnowledgeSystem`.
+     * See `.plans/SIMPLER-JSON-LD.md` §5 / decision 7.
+     */
+    getResourceGraph(resourceId: ResourceId, options?: {
+        auth?: AccessToken;
+    }): Promise<GetResourceResponse>;
     dispose(): void;
 }
 
@@ -5408,20 +5487,33 @@ declare function normalizeText(text: string): string;
  * Pre-computed content strings for batch fuzzy matching.
  * Avoids recomputing normalizeText(content) and content.toLowerCase()
  * for every annotation when processing many annotations against the same content.
+ *
+ * `normalizedMap[i]` is the original-content index that normalized
+ * character `i` came from. It has length `normalizedContent.length + 1`;
+ * the final entry is `content.length` so a match that ends at the end of
+ * the normalized string maps back to the end of the original. This map is
+ * how `findBestTextMatch` recovers the *original* offset of a normalized
+ * match — counting char-by-char with `normalizeText(singleChar)` is
+ * wrong, because a lone whitespace char trims to `''` (contributing 0)
+ * while in a full-string normalize it collapses to a single space
+ * (contributing 1). That discrepancy shifted recovered offsets by the
+ * number of whitespace runs before the match.
  */
 interface ContentCache {
     normalizedContent: string;
+    normalizedMap: number[];
     lowerContent: string;
 }
 /**
  * Build a ContentCache for a given content string.
- * Call once per content, pass to findBestTextMatch/findTextWithContext for all annotations.
+ * Call once per content, pass to findBestTextMatch/anchorAnnotation for all annotations.
  */
 declare function buildContentCache(content: string): ContentCache;
 /**
  * Find best match for text in content using multi-strategy search
  *
- * Shared core logic used by both findTextWithContext and validateAndCorrectOffsets.
+ * Shared core logic used by both anchorAnnotation (render-time) and
+ * reconcileSelector (write-time).
  *
  * @param content - Full text content to search within
  * @param searchText - The text to find
@@ -5434,37 +5526,91 @@ declare function findBestTextMatch(content: string, searchText: string, position
     end: number;
     matchQuality: MatchQuality;
 } | null;
-/**
- * Find text using exact match with optional prefix/suffix context
- *
- * When the exact text appears multiple times in the content, prefix and suffix
- * are used to disambiguate and find the correct occurrence.
- *
- * If exact text is not found, uses multi-strategy fuzzy matching (normalization,
- * case-insensitive, Levenshtein distance) to locate changed text.
- *
- * @param content - Full text content to search within
- * @param exact - The exact text to find
- * @param prefix - Optional text that should appear immediately before the match
- * @param suffix - Optional text that should appear immediately after the match
- * @param positionHint - Optional position hint (from TextPositionSelector) for fuzzy search
- * @returns Position of the matched text, or null if not found
- *
- * @example
- * ```typescript
- * const content = "The cat sat. The cat ran.";
- * // Find second "The cat" occurrence
- * const pos = findTextWithContext(content, "The cat", "sat. ", " ran");
- * // Returns { start: 13, end: 20 }
- * ```
- */
-declare function findTextWithContext(content: string, exact: string, prefix: string | undefined, suffix: string | undefined, positionHint: number | undefined, cache: ContentCache): TextPosition | null;
 /**
  * Verify that a position correctly points to the exact text
  * Useful for debugging and validation
  */
 declare function verifyPosition(content: string, position: TextPosition, expectedExact: string): boolean;
 
+/**
+ * Anchor a W3C Web Annotation to its rendered text.
+ *
+ * Render-time cleverness is deliberately limited to **verbatim** quote
+ * matching. The annotation's two selectors are written to agree (the
+ * write-side `reconcileSelector` + `buildTextAnnotation` invariant
+ * guarantee `content.substring(start, end) === exact`). At render time the
+ * only legitimate discrepancy is *positional drift*: the document grew or
+ * shrank above the span after the annotation was written, so the offset is
+ * stale but the exact text still exists, byte-identical, elsewhere. That is
+ * the W3C-intended role of `TextQuoteSelector`, and it is safe because it
+ * demands identical text — no normalization, no fuzzy matching, no
+ * judgment call.
+ *
+ * Anything that would require *fuzzy* recovery (smart-quote folding,
+ * whitespace collapse, Levenshtein) is out of scope here: a non-verbatim
+ * mismatch means the content representation diverged or the stored record
+ * is wrong, both of which are deterministic and belong upstream (canonical
+ * content, or a corrected annotation event). The renderer does not guess —
+ * it renders at the stored offset and flags the anchor low-confidence so
+ * the discrepancy surfaces for an upstream fix.
+ *
+ * Returns `null` only when nothing usable is present; otherwise always
+ * returns a position with a `strategy` and `confidence`.
+ */
+type AnchorStrategy = 
+/** Position hint pointed exactly at the exact text. Unambiguous. */
+'fast-path'
+/** Exact text appears once verbatim in the content. No tiebreak needed. */
+ | 'unique-occurrence'
+/** Multiple verbatim occurrences; prefix+suffix uniquely identified one. */
+ | 'context-disambiguated'
+/** Multiple verbatim candidates; position closest to hint chosen. */
+ | 'position-tiebreaker'
+/** Exact text not found verbatim (or no quote); raw stored offset used,
+ *  flagged for upstream correction. */
+ | 'position-fallback';
+type AnchorConfidence = 'high' | 'medium' | 'low';
+interface RenderedAnchor {
+    start: number;
+    end: number;
+    strategy: AnchorStrategy;
+    confidence: AnchorConfidence;
+}
+interface AnchorSelectors {
+    position?: {
+        start: number;
+        end: number;
+    };
+    quote?: {
+        exact: string;
+        prefix?: string;
+        suffix?: string;
+    };
+}
+/**
+ * Distance window for the position tiebreaker. Candidates closer than this
+ * to the hint receive a non-zero position score; further candidates fall
+ * back to zero. Tuned for typical document sizes; calibration tests pin
+ * the boundary behaviour rather than the exact value.
+ */
+declare const POSITION_WINDOW = 1024;
+/**
+ * Score weights — kept as named constants so the calibration tests can
+ * import them and pin the *relationships* rather than the magnitudes.
+ *
+ * Invariant: a full-context match always outranks any position score.
+ * (`CONTEXT_FULL_WEIGHT * 2 > POSITION_WEIGHT_MAX`, accounting for
+ * prefix+suffix each contributing the full weight.)
+ */
+declare const CONTEXT_FULL_WEIGHT = 10;
+declare const CONTEXT_PARTIAL_WEIGHT = 5;
+declare const POSITION_WEIGHT_MAX = 5;
+/**
+ * Locate the best-effort anchor for an annotation against the content the
+ * renderer is about to display. Verbatim-only — see the module doc.
+ */
+declare function anchorAnnotation(content: string, selectors: AnchorSelectors): RenderedAnchor | null;
+
 /**
  * Locale information
  * Copied from SDK for frontend use
@@ -5541,89 +5687,86 @@ declare function normalizeCoordinates(point: Point, displayWidth: number, displa
 declare function scaleSvgToNative(svg: string, displayWidth: number, displayHeight: number, imageWidth: number, imageHeight: number): string;
 
 /**
- * Text context extraction utilities for W3C Web Annotation TextQuoteSelector
+ * Selector reconciliation for write-time annotation construction.
  *
- * Provides robust prefix/suffix context extraction with word boundary detection
- * to ensure fuzzy anchoring works correctly when the same text appears multiple times.
+ * LLM-produced text offsets are guides, not authoritative anchors.
+ * `reconcileSelector` takes whatever the LLM emitted and produces a
+ * `TextQuoteSelector`-equivalent `start`/`end`/`exact`/`prefix`/`suffix`
+ * that is provably consistent with the source content:
  *
- * Also provides AI offset validation and correction for handling AI-generated annotations
- * where the model may return slightly incorrect character offsets.
+ *   - `content.substring(start, end) === exact`
+ *   - `content.substring(start - prefix.length, start) === prefix`
+ *   - `content.substring(end, end + suffix.length) === suffix`
  *
- * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
- */
-
-/**
- * Extract prefix and suffix context for TextQuoteSelector
- *
- * Extracts up to 64 characters before and after the selected text,
- * extending to word boundaries to avoid cutting words in half.
- * This ensures prefix/suffix are meaningful context for fuzzy anchoring.
+ * No caller spreads LLM-emitted prefix/suffix into the stored selector.
+ * The shared helper extracts both from source at the corrected position,
+ * so the no-overlap invariant holds by construction.
  *
- * @param content - Full text content
- * @param start - Start offset of selection
- * @param end - End offset of selection
- * @returns Object with prefix and suffix (undefined if at boundaries)
+ * Returns `null` when the LLM emitted text that doesn't appear in the
+ * source. Callers filter; the helper doesn't decide for them.
  *
- * @example
- * ```typescript
- * const content = "The United States Congress...";
- * const context = extractContext(content, 4, 17); // "United States"
- * // Returns: { prefix: "The ", suffix: " Congress..." }
- * // NOT: { prefix: "nited ", suffix: "gress..." }
- * ```
+ * @see https://www.w3.org/TR/annotation-model/#text-quote-selector
  */
-declare function extractContext(content: string, start: number, end: number): {
-    prefix?: string;
-    suffix?: string;
-};
+
 /**
- * Result of validating and correcting AI-provided annotation offsets
- */
-interface ValidatedAnnotation {
+ * How the reconciliation arrived at the chosen offset. Carried into the
+ * worker log so operators can audit ambiguous matches; the
+ * `first-of-many` flag, in particular, is the signal that an annotation
+ * *may* be anchored at the wrong occurrence and warrants review.
+ */
+type AnchorMethod = 
+/** Exact text appears once in the source — anchored unambiguously. */
+'unique-match'
+/** Multiple occurrences; LLM-emitted prefix/suffix picked one. */
+ | 'context-recovered'
+/** Exact text not found verbatim; fuzzy match recovered it. */
+ | 'fuzzy-match'
+/** Multiple occurrences, no context disambiguated — risky fallback. */
+ | 'first-of-many';
+interface ReconciledSelector {
     start: number;
     end: number;
+    /** Always a substring of the source content — never the LLM's emission. */
     exact: string;
+    /** Extracted from source via extractContext — never the LLM's emission. */
     prefix?: string;
+    /** Extracted from source via extractContext — never the LLM's emission. */
     suffix?: string;
-    corrected: boolean;
-    fuzzyMatched?: boolean;
+    anchorMethod: AnchorMethod;
+    /** Present when the fuzzy fallback recovered the match, naming how. */
     matchQuality?: MatchQuality;
 }
+interface LlmSelectorInput {
+    exact: string;
+    /** LLM-emitted context for disambiguation only — not for storage. */
+    prefix?: string;
+    /** LLM-emitted context for disambiguation only — not for storage. */
+    suffix?: string;
+}
 /**
- * Validate and correct AI-provided annotation offsets with fuzzy matching tolerance
- *
- * AI models sometimes return offsets that don't match the actual text position,
- * or provide text with minor variations (case differences, whitespace, typos).
- *
- * This function uses a multi-strategy approach:
- * 1. Check if AI's offsets are exactly correct
- * 2. Try exact case-sensitive search
- * 3. Try case-insensitive search
- * 4. Try fuzzy matching with Levenshtein distance (5% tolerance)
+ * Extract prefix and suffix context for a `TextQuoteSelector` from
+ * source content. Used internally by `reconcileSelector` after offsets
+ * are reconciled, and exported for callers (e.g. UI-side selection
+ * capture) that need the same extraction semantics.
  *
- * This ensures we're maximally tolerant of AI errors while still maintaining
- * annotation quality and logging what corrections were made.
- *
- * @param content - Full text content
- * @param aiStart - Start offset from AI
- * @param aiEnd - End offset from AI
- * @param exact - The exact text that should be at this position (from AI)
- * @returns Validated annotation with corrected offsets and context
- * @throws Error if no acceptable match can be found
+ * Extracts up to 64 characters before and after the selected text,
+ * extending up to 32 additional chars to reach a word boundary so the
+ * prefix/suffix is meaningful context rather than mid-word fragments.
+ */
+declare function extractContext(content: string, start: number, end: number): {
+    prefix?: string;
+    suffix?: string;
+};
+/**
+ * Reconcile LLM-emitted offsets against the source. Returns a selector
+ * whose `start`/`end` are verified to bracket `exact` in `content`, and
+ * whose `prefix`/`suffix` are extracted from source — never carried
+ * verbatim from the LLM.
  *
- * @example
- * ```typescript
- * // AI said start=1143, but actual text is at 1161
- * const result = validateAndCorrectOffsets(
- *   content,
- *   1143,
- *   1289,
- *   "the question \"whether..."
- * );
- * // Returns: { start: 1161, end: 1303, exact: "...", corrected: true, matchQuality: 'exact', ... }
- * ```
+ * Returns `null` if `exact` cannot be found anywhere in the content,
+ * even via fuzzy match. Callers filter null and log the drop.
  */
-declare function validateAndCorrectOffsets(content: string, aiStart: number, aiEnd: number, exact: string): ValidatedAnnotation;
+declare function reconcileSelector(content: string, llm: LlmSelectorInput): ReconciledSelector | null;
 
 /**
  * Text encoding utilities for consistent charset handling
@@ -5660,7 +5803,7 @@ declare function extractCharset(mediaType: string): string;
 declare function decodeWithCharset(buffer: ArrayBuffer, mediaType: string): string;
 
 /**
- * Generic validation utilities for @semiont/api-client
+ * Generic validation utilities for @semiont/http-transport
  *
  * Pure TypeScript validation with no external dependencies.
  * Safe to use in any JavaScript environment (Node.js, browser, Deno, etc.)
@@ -5717,42 +5860,215 @@ declare function validateData<T>(schema: {
 declare function isValidEmail(email: string): boolean;
 
 /**
- * MIME type utilities for Semiont
+ * Media-type registry for Semiont
+ *
+ * One supported-types list, capability-tiered, keyed by the spec's
+ * SupportedMediaType enum. Admission (registry membership) is the
+ * create/yield gate: every member is storable, nameable, and uploadable.
+ * The curated capabilities say what more the system can do with a type:
  *
- * Initial support for:
- * - text/plain
- * - text/markdown
- * - image/png
- * - image/jpeg
- * - application/pdf
+ * - `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)
+ * - `authorable`  — offered in the compose editor's format dropdown
+ * - `uploadable`  — big tent: true for every registry member
+ *
+ * Capabilities are orthogonal strategies, not a ladder: images render but
+ * yield no text; PDFs yield text but aren't authorable. A "tier" is a
+ * derived reading, not a stored fact.
+ *
+ * Import-leniency invariant: restore/import preserves archive mediaTypes
+ * verbatim, so "every stored mediaType is registry-valid" holds only for
+ * content that entered through the validated create/yield gate. No code
+ * reading a stored mediaType may assume `capabilitiesOf()` succeeds — the
+ * `undefined` branch is mandatory wherever stored types are read.
  */
+
+type SupportedMediaType = components['schemas']['SupportedMediaType'];
+type RenderMode = 'text' | 'image' | 'pdf' | 'none';
+type AnchoringModel = 'text-selector' | 'spatial' | 'none';
+type TextExtraction = 'decode' | 'pdf-text-layer' | 'none';
+interface MediaTypeCapabilities {
+    /** Canonical file extension, with leading dot. */
+    extension: `.${string}`;
+    /** UI display name. */
+    label: string;
+    render: RenderMode;
+    anchoring: AnchoringModel;
+    extractText: TextExtraction;
+    authorable: boolean;
+    uploadable: boolean;
+}
+/**
+ * The registry. `satisfies Record<SupportedMediaType, …>` is the
+ * drift-lock: adding a type to the spec enum without a capabilities row
+ * (or vice versa) is a compile error.
+ *
+ * Row order matters for `mediaTypeForExtension`: extension collisions
+ * (.xml, .yaml, .js, .ts, .webm) resolve to the first row declaring the
+ * extension.
+ */
+declare const MEDIA_TYPES: {
+    'text/markdown': {
+        extension: ".md";
+        label: string;
+        render: "text";
+        anchoring: "text-selector";
+        extractText: "decode";
+        authorable: true;
+        uploadable: true;
+    };
+    'text/plain': {
+        extension: ".txt";
+        label: string;
+        render: "text";
+        anchoring: "text-selector";
+        extractText: "decode";
+        authorable: true;
+        uploadable: true;
+    };
+    'text/html': {
+        extension: ".html";
+        label: string;
+        render: "text";
+        anchoring: "text-selector";
+        extractText: "decode";
+        authorable: true;
+        uploadable: true;
+    };
+    'application/json': {
+        extension: ".json";
+        label: string;
+        render: "text";
+        anchoring: "text-selector";
+        extractText: "decode";
+        authorable: false;
+        uploadable: true;
+    };
+    'image/png': {
+        extension: ".png";
+        label: string;
+        render: "image";
+        anchoring: "spatial";
+        extractText: "none";
+        authorable: false;
+        uploadable: true;
+    };
+    'image/jpeg': {
+        extension: ".jpg";
+        label: string;
+        render: "image";
+        anchoring: "spatial";
+        extractText: "none";
+        authorable: false;
+        uploadable: true;
+    };
+    'application/pdf': {
+        extension: ".pdf";
+        label: string;
+        render: "pdf";
+        anchoring: "spatial";
+        extractText: "pdf-text-layer";
+        authorable: false;
+        uploadable: true;
+    };
+    'text/css': MediaTypeCapabilities;
+    'text/csv': MediaTypeCapabilities;
+    'text/xml': MediaTypeCapabilities;
+    'application/xml': MediaTypeCapabilities;
+    'application/yaml': MediaTypeCapabilities;
+    'application/x-yaml': MediaTypeCapabilities;
+    'text/javascript': MediaTypeCapabilities;
+    'application/javascript': MediaTypeCapabilities;
+    'text/x-typescript': MediaTypeCapabilities;
+    'application/typescript': MediaTypeCapabilities;
+    'text/x-python': MediaTypeCapabilities;
+    'text/x-java': MediaTypeCapabilities;
+    'text/x-c': MediaTypeCapabilities;
+    'text/x-c++': MediaTypeCapabilities;
+    'text/x-csharp': MediaTypeCapabilities;
+    'text/x-go': MediaTypeCapabilities;
+    'text/x-rust': MediaTypeCapabilities;
+    'text/x-ruby': MediaTypeCapabilities;
+    'text/x-php': MediaTypeCapabilities;
+    'text/x-swift': MediaTypeCapabilities;
+    'text/x-kotlin': MediaTypeCapabilities;
+    'text/x-shell': MediaTypeCapabilities;
+    'application/msword': MediaTypeCapabilities;
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document': MediaTypeCapabilities;
+    'application/vnd.ms-excel': MediaTypeCapabilities;
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': MediaTypeCapabilities;
+    'application/vnd.ms-powerpoint': MediaTypeCapabilities;
+    'application/vnd.openxmlformats-officedocument.presentationml.presentation': MediaTypeCapabilities;
+    'application/zip': MediaTypeCapabilities;
+    'application/gzip': MediaTypeCapabilities;
+    'application/x-tar': MediaTypeCapabilities;
+    'application/x-7z-compressed': MediaTypeCapabilities;
+    'application/octet-stream': MediaTypeCapabilities;
+    'application/wasm': MediaTypeCapabilities;
+    'image/gif': MediaTypeCapabilities;
+    'image/webp': MediaTypeCapabilities;
+    'image/svg+xml': MediaTypeCapabilities;
+    'image/bmp': MediaTypeCapabilities;
+    'image/tiff': MediaTypeCapabilities;
+    'image/x-icon': MediaTypeCapabilities;
+    'video/mp4': MediaTypeCapabilities;
+    'video/mpeg': MediaTypeCapabilities;
+    'video/webm': MediaTypeCapabilities;
+    'video/ogg': MediaTypeCapabilities;
+    'video/quicktime': MediaTypeCapabilities;
+    'video/x-msvideo': MediaTypeCapabilities;
+    'audio/mpeg': MediaTypeCapabilities;
+    'audio/wav': MediaTypeCapabilities;
+    'audio/ogg': MediaTypeCapabilities;
+    'audio/webm': MediaTypeCapabilities;
+    'audio/aac': MediaTypeCapabilities;
+    'audio/flac': MediaTypeCapabilities;
+    'font/woff': MediaTypeCapabilities;
+    'font/woff2': MediaTypeCapabilities;
+    'font/ttf': MediaTypeCapabilities;
+    'font/otf': MediaTypeCapabilities;
+};
 /**
- * Map MIME type to file extension
+ * Strip parameters ("; charset=...") and normalize case.
+ * Replaces the inline `split(';')[0]` sites across the codebase.
  */
-declare function getExtensionForMimeType(mimeType: string): string;
+declare function baseMediaType(format: string): string;
 /**
- * Detect if MIME type is an image (png or jpeg only for now)
+ * Registry membership — the admission gate. Exact match: callers pass a
+ * base type (see `baseMediaType`); strings carrying parameters are not
+ * members.
  */
-declare function isImageMimeType(mimeType: string): boolean;
+declare function isSupportedMediaType(format: string): format is SupportedMediaType;
+/** Capabilities for a format (parameters tolerated), or undefined on registry miss. */
+declare function capabilitiesOf(format: string): MediaTypeCapabilities | undefined;
 /**
- * Detect if MIME type is text-based (plain or markdown only for now)
+ * Lenient extension lookup for naming foreign/imported content: '.dat' on
+ * registry miss. Exporters use this — a vocabulary change must never
+ * refuse to name restored data.
  */
-declare function isTextMimeType(mimeType: string): boolean;
+declare function extensionForMediaType(format: string): string;
 /**
- * Detect if MIME type is PDF
+ * Inverted registry: extension → media type, for the CLI and the upload
+ * detection chain. Accepts 'md' or '.md', any case, and common alternate
+ * spellings. Returns undefined for unknown extensions — detection chains
+ * fall back to 'application/octet-stream' themselves.
  */
-declare function isPdfMimeType(mimeType: string): boolean;
+declare function mediaTypeForExtension(ext: string): SupportedMediaType | undefined;
 /**
- * Get category for MIME type (for routing to appropriate viewer)
- *
- * Categories represent annotation models, not file formats:
- * - 'text': Text-based annotations (TextPositionSelector, TextQuoteSelector)
- * - 'image': Spatial coordinate annotations (SvgSelector, FragmentSelector)
- *
- * PDFs use spatial coordinates for annotations, so they belong to 'image' category.
+ * 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'.
  */
-type MimeCategory = 'text' | 'image' | 'unsupported';
-declare function getMimeCategory(mimeType: string): MimeCategory;
+declare function textExtractionOf(format: string): TextExtraction;
+/** 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. */
+declare const EMBEDDABLE_MEDIA_TYPES: readonly SupportedMediaType[];
 
 /**
  * Resource input/output types
@@ -6615,15 +6931,5 @@ declare function isValidPlatformType(value: string): value is PlatformType;
  */
 declare function getAllPlatformTypes(): PlatformType[];
 
-/**
- * @semiont/core
- *
- * Core domain logic and utilities for the Semiont semantic knowledge platform.
- * OpenAPI types are generated here and exported for use across the monorepo.
- */
-
-declare const CORE_TYPES_VERSION = "0.1.0";
-declare const SDK_VERSION = "0.1.0";
-
-export { BRIDGED_CHANNELS, CHANNEL_SCHEMAS, CORE_TYPES_VERSION, ConfigurationError, ConflictError, EventBus, JWTTokenSchema, LOCALES, NotFoundError, PERSISTED_EVENT_TYPES, RESOURCE_BROADCAST_TYPES, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, cloneToken, createCircleSvg, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, didToAgent, email, entityType, errField, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findTextWithContext, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getExtensionForMimeType, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getNodeEncoding, 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, isImageMimeType, isNull, isNullish, isNumber, isObject, isPdfMimeType, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isTag, isTextMimeType, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, normalizeCoordinates, normalizeText, parseEnvironment, parseSvgSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, userDID, userId, userToAgent, userToDid, validateAndCorrectOffsets, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, CloneToken, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, FragmentSelector, FrontendServiceConfig, GatheredContext, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, ListUsersResponse, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MimeCategory, Motivation, OllamaProviderConfig, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, RefreshToken, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StatusResponse, StoredEvent, StoredEventLike, SvgSelector, TagCategory, TagSchema, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidatedAnnotation, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, 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, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorSelectors, AnchorStrategy, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, CloneToken, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, FragmentSelector, FrontendServiceConfig, GatheredContext, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, 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, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, 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 };