@semiont/core 0.5.6 → 0.5.8

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];
@@ -5084,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.
@@ -5132,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:
@@ -5153,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
@@ -5342,7 +5378,7 @@ interface IBackendOperations {
 interface PutBinaryRequest {
     name: string;
     file: File | Buffer;
-    format: ContentFormat | string;
+    format: ContentFormat;
     storageUri: string;
     entityTypes?: string[];
     language?: string;
@@ -5385,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;
 }
 
@@ -5759,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.)
@@ -5816,42 +5860,215 @@ declare function validateData<T>(schema: {
 declare function isValidEmail(email: string): boolean;
 
 /**
- * MIME type utilities for Semiont
+ * Media-type registry for Semiont
  *
- * Initial support for:
- * - text/plain
- * - text/markdown
- * - image/png
- * - image/jpeg
- * - application/pdf
+ * 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:
+ *
+ * - `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;
+}
 /**
- * Map MIME type to file extension
+ * 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;
+};
+/**
+ * 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
@@ -6714,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, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, CORE_TYPES_VERSION, ConfigurationError, ConflictError, EventBus, JWTTokenSchema, LOCALES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, didToAgent, email, entityType, errField, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getExtensionForMimeType, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, 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, isImageMimeType, isNull, isNullish, isNumber, isObject, isPdfMimeType, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isTag, isTextMimeType, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorSelectors, AnchorStrategy, 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, MimeCategory, Motivation, OllamaProviderConfig, PdfCoordinate, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderedAnchor, 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, 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 };