@semiont/core 0.5.27 → 0.5.29

package/dist/index.d.ts

@@ -848,275 +848,6 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/api/admin/exchange/backup": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Backup Knowledge Base
-         * @description Create a lossless backup of the knowledge base as a streaming tar.gz archive
-         */
-        post: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Streaming backup archive */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/gzip": string;
-                    };
-                };
-                /** @description Unauthorized */
-                401: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Forbidden - Admin access required */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/admin/exchange/restore": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Restore Knowledge Base
-         * @description Restore knowledge base from a backup archive. Returns SSE progress events.
-         */
-        post: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody: {
-                content: {
-                    "multipart/form-data": {
-                        /**
-                         * Format: binary
-                         * @description Backup archive (.tar.gz)
-                         */
-                        file: string;
-                    };
-                };
-            };
-            responses: {
-                /** @description SSE stream of restore progress events */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "text/event-stream": string;
-                    };
-                };
-                /** @description Invalid file format */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Unauthorized */
-                401: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Forbidden - Admin access required */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/moderate/exchange/export": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Export Knowledge Base as JSON-LD
-         * @description Export the knowledge base as a JSON-LD Linked Data tar.gz archive
-         */
-        post: {
-            parameters: {
-                query?: {
-                    /** @description Include archived resources in export */
-                    includeArchived?: boolean;
-                };
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Streaming JSON-LD archive */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/gzip": string;
-                    };
-                };
-                /** @description Unauthorized */
-                401: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Forbidden - moderator or admin role required */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/moderate/exchange/import": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        get?: never;
-        put?: never;
-        /**
-         * Import Knowledge Base from JSON-LD
-         * @description Import resources from a JSON-LD Linked Data archive. Returns SSE progress events.
-         */
-        post: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody: {
-                content: {
-                    "multipart/form-data": {
-                        /**
-                         * Format: binary
-                         * @description JSON-LD archive (.tar.gz)
-                         */
-                        file: string;
-                    };
-                };
-            };
-            responses: {
-                /** @description SSE stream of import progress events */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "text/event-stream": string;
-                    };
-                };
-                /** @description Invalid file format */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Unauthorized */
-                401: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Forbidden - moderator or admin role required */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/api/cookies/consent": {
         parameters: {
             query?: never;
@@ -1399,7 +1130,7 @@ interface paths {
         put?: never;
         /**
          * Create a resource
-         * @description Upload binary content + metadata as multipart/form-data. The backend writes content to disk, then emits yield:create on the bus; Stower persists it and returns a 202 with the new resourceId. Full reconciliation happens via SSE domain events (yield:created).
+         * @description Upload binary content + metadata as multipart/form-data. The gateway writes content to disk, then emits yield:create on the bus; Stower persists it and returns a 202 with the new resourceId. Full reconciliation happens via SSE domain events (yield:created).
          *
          *     Generation workers and the /know/compose page both hit this route — bytes always travel on the HTTP wire, never on the bus.
          */
@@ -1542,242 +1273,6 @@ interface paths {
         patch?: never;
         trace?: never;
     };
-    "/resources/{id}/anchored-text": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * Get a resource's anchored text
-         * @description The coordinate map derived from a resource's bytes: its recovered text plus the positioned runs that index it. Assembled via the bus gateway.
-         *
-         *     Whole-resource, not paginated — a producer iterates page by page, but every consumer wants one map: a browser quoting the text under a hand-drawn rectangle, a headless client analysing a document.
-         *
-         *     This endpoint never runs recognition. The Smelter is the sole producer and publishes at ingest; a read that finds nothing waits for that resource's content generation to settle and then answers 204. A 204 is the common case and not an error — a native text layer is read in the browser, and a media type with no extractor never produces a map at all. Callers degrade: for a PDF annotation that means geometry with no quoted text.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path: {
-                    id: string;
-                };
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description The stored extraction outcome: the coordinate map with its provenance (method, PDF class, OCR confidence, unread pages), or a named decline. */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ExtractionOutcome"];
-                    };
-                };
-                /** @description No map has been derived for this resource. The ordinary answer for a native text layer or a media type with no extractor — not an error, and distinct from 404, which means the resource itself is absent. Carried as an empty body rather than a JSON `null` body so that a generated client's typed 200 field stays absent: unmarshalling `null` into a struct is a no-op in several languages, which would make "no map" indistinguishable from an empty one. */
-                204: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content?: never;
-                };
-                /** @description Resource not found */
-                404: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Request timed out (bus gateway) */
-                504: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/anchored-text/keys": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * List the keys under which anchored text is currently stored
-         * @description The anchored-text store's would-hit keys — the reconcile planner's bulk existence read (PERSIST-ANCHORS P0). The Smelter diffs this against the catalog to find resources whose derived coordinate map was lost (a transient store, a failed publish) and plans re-derivation; one request per reconcile, keys only, because each map is ~32 KB per scanned page and only presence is being asked.
-         *
-         *     Keys are resource ids today; after PERSIST-ANCHORS P1 they are content checksums. Only entries a read would actually serve are listed — stale-stamped or unreadable entries are excluded, exactly as a read would exclude them.
-         *
-         *     Agents only: this is projection-maintenance planning data, same trust boundary as publishing a map.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path?: never;
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description Every key under which anchored text would currently be served. */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": {
-                            keys: string[];
-                        };
-                    };
-                };
-                /** @description Caller is not an agent */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/anchored-text/{checksum}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /**
-         * Read a representation's stored extraction outcome by content checksum
-         * @description The cache-consult read (PERSIST-ANCHORS P2c): the extraction seam asks "has this exact byte content already been extracted?" — and every cache consumer runs out of process (the smelter worker, the detection workers), so the consult must cross the wire or the cache is write-only from exactly the processes it exists to serve.
-         *
-         *     Checksum-addressed and barrier-free, deliberately: presence at this instant is the question, the same semantics as the keys listing. The read-your-writes settle barrier belongs to the resource-addressed reader (GET /resources/{id}/anchored-text), which resolves a mutable resource id through the view index; a caller holding the checksum already holds the content identity and needs no resolution and no wait.
-         *
-         *     Agents only — projection-maintenance traffic, the same trust boundary as the PUT beside it.
-         */
-        get: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path: {
-                    /** @description Hex SHA-256 checksum of the representation bytes. */
-                    checksum: string;
-                };
-                cookie?: never;
-            };
-            requestBody?: never;
-            responses: {
-                /** @description The stored extraction outcome — a success with provenance, or a cached decline. */
-                200: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ExtractionOutcome"];
-                    };
-                };
-                /** @description No entry under this checksum. The ordinary cache miss — carried as an empty body rather than a JSON null for the same generated-client reason as the resource-addressed GET. */
-                204: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content?: never;
-                };
-                /** @description Caller is not an agent */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        /**
-         * Publish anchored text for a representation, keyed by its content checksum
-         * @description Store the coordinate map derived from a representation's bytes, under the SHA-256 checksum of those bytes (PERSIST-ANCHORS decision A: one artifact per representation, and a representation is its bytes). The producer supplies the checksum because it alone knows which bytes it actually read — deriving the key server-side from the resource's current representation would file old geometry under a new checksum when a byte change races the publish, and that entry would read as present to the reconcile planner forever. Reads remain resource-addressed (GET /resources/{id}/anchored-text); the server resolves the resource to its current representation's checksum.
-         *
-         *     The Smelter is the sole producer: it is the only process that reads those bytes at ingest, so it is the only one positioned to derive a map cheaply, and it runs separately from the backend.
-         *
-         *     Agents only. A map is derived data every consumer trusts to place annotation geometry, so a browser session must not be able to write one.
-         */
-        put: {
-            parameters: {
-                query?: never;
-                header?: never;
-                path: {
-                    /** @description Hex SHA-256 checksum of the representation bytes the map was derived from. */
-                    checksum: string;
-                };
-                cookie?: never;
-            };
-            requestBody: {
-                content: {
-                    "application/json": components["schemas"]["ExtractionOutcome"];
-                };
-            };
-            responses: {
-                /** @description Stored */
-                204: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content?: never;
-                };
-                /** @description Body is not a valid ExtractionOutcome */
-                400: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-                /** @description Caller is not an agent */
-                403: {
-                    headers: {
-                        [name: string]: unknown;
-                    };
-                    content: {
-                        "application/json": components["schemas"]["ErrorResponse"];
-                    };
-                };
-            };
-        };
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
     "/resources/{id}/jsonld": {
         parameters: {
             query?: never;
@@ -1960,9 +1455,28 @@ interface components {
                 updatedAt: string;
             }[];
         };
-        /** @description Web Annotation / W3C PROV Agent. Discriminated by @type — Person, Organization, or Software. Each branch carries fields appropriate to its kind. Software peers are first-class participants, not a sub-class of Person. */
-        Agent: ({
-            /** @constant */
+        /** @description Web Annotation / W3C PROV Agent. Discriminated by @type — Person, Organization, or Software (named member schemas: AgentPerson, AgentOrganization, AgentSoftware). Software peers are first-class participants, not a sub-class of Person. */
+        Agent: components["schemas"]["AgentPerson"] | components["schemas"]["AgentOrganization"] | components["schemas"]["AgentSoftware"];
+        /** @description An organization — the Organization branch of Agent. */
+        AgentOrganization: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            "@type": "Organization";
+            /** Format: uri */
+            "@id"?: string;
+            name: string;
+            homepage?: string;
+        } & {
+            [key: string]: unknown;
+        };
+        /** @description A human participant — the Person branch of Agent. */
+        AgentPerson: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             "@type": "Person";
             /**
              * Format: uri
@@ -1977,17 +1491,13 @@ interface components {
             homepage?: string;
         } & {
             [key: string]: unknown;
-        }) | ({
-            /** @constant */
-            "@type": "Organization";
-            /** Format: uri */
-            "@id"?: string;
-            name: string;
-            homepage?: string;
-        } & {
-            [key: string]: unknown;
-        }) | ({
-            /** @constant */
+        };
+        /** @description A software peer (an inference model acting as a first-class participant) — the Software branch of Agent. Carries structured provider + model. */
+        AgentSoftware: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             "@type": "Software";
             /**
              * Format: uri
@@ -2006,7 +1516,7 @@ interface components {
             };
         } & {
             [key: string]: unknown;
-        });
+        };
         Annotation: {
             /**
              * @description W3C Web Annotation JSON-LD context
@@ -2041,7 +1551,7 @@ interface components {
             /** @description SHA-256 of resource content at annotation time */
             contentChecksum?: string;
         };
-        /** @description Phase 2: Body can be TextualBody (for entity tags, descriptions) or SpecificResource (for links) */
+        /** @description An annotation's body: a TextualBody carries text the annotation states (entity tags, descriptions, comments), a SpecificResource points at what it links to. Tell them apart by `type`, which is required on both and single-valued — a consumer never has to probe for which fields happen to be present. */
         AnnotationBody: components["schemas"]["TextualBody"] | components["schemas"]["SpecificResource"];
         /** @description Payload for mark:body-updated domain event */
         AnnotationBodyUpdatedPayload: {
@@ -2339,7 +1849,12 @@ interface components {
         /** @description A resource's stored extraction outcome — the coordinate map with its provenance, or a named decline — or null when none has been derived. Null is the common case and not an error: a native text layer is read in the browser, and a media type with no extractor never produces one. */
         BrowseAnchoredTextResult: {
             correlationId: string;
-            response: components["schemas"]["ExtractionOutcome"] | null;
+            response: Omit<components["schemas"]["ExtractionOutcome"], "kind"> | null;
+        };
+        /** @description Request the stored extraction outcome for a content identity the caller already holds — the detection workers' read-through cache consult (ANCHORED-TEXT-TO-SMELTER P2). A hit — success or decline — is served whole and the caller skips extraction; null is a miss and the caller extracts locally. Read-only: the Smelter is the sole writer and never answers over this channel. */
+        BrowseAnchoredTextByChecksumRequest: {
+            correlationId: string;
+            checksum: string;
         };
         /** @description Request to browse a single resource */
         BrowseResourceRequest: {
@@ -2392,7 +1907,7 @@ interface components {
             payload: {
                 [key: string]: unknown;
             };
-            /** @description Optional resource scope for broadcast channels (e.g. resourceId). Publishers only — frontends must never set this. */
+            /** @description Optional resource scope for broadcast channels (e.g. resourceId). Publishers only — clients must never set this. */
             scope?: string;
         };
         /** @description Subscription matrix for the bus SSE stream (MULTI-RESOURCE-SCOPE). `global` channels are delivered unscoped; each `scoped` entry subscribes the connection to one resource scope's channels, optionally resuming replay from that scope's last-seen persisted event id. At least one global channel or one scoped entry is required. */
@@ -2493,7 +2008,7 @@ interface components {
             /** @description Optional body. Omit for annotations whose motivation alone is meaningful (highlighting) or whose user-supplied content is empty. Shape matches Annotation.body. */
             body?: components["schemas"]["AnnotationBody"] | components["schemas"]["AnnotationBody"][];
         };
-        /** @description Response body for POST /resources (202 Accepted). Resource creation is asynchronous — the backend writes content to disk, emits yield:create on the bus, and returns the newly-minted resourceId immediately. Consumers watch SSE domain events (yield:created) to observe the fully-persisted state. */
+        /** @description Response body for POST /resources (202 Accepted). The route writes content to disk, emits yield:create, and AWAITS the confirmed-write reply — so the returned resourceId is the one Stower minted, and the resource's event is persisted before this response is sent. What remains asynchronous is downstream projection: graph, views and vectors settle after the 202. */
         CreateResourceResponse: {
             /** @description The id of the newly-created resource. Assigned by Stower when it persists yield:create. */
             resourceId: string;
@@ -2503,7 +2018,10 @@ interface components {
             message: string;
         };
         DirEntry: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "dir";
             /** @description Entry name (basename) */
             name: string;
@@ -2515,6 +2033,7 @@ interface components {
              */
             mtime: string;
         };
+        /** @description One entry in a directory listing: a file, which may carry the resource it was ingested as, or a subdirectory. Tell them apart by `type`, which is required on both and single-valued. */
         DirectoryEntry: components["schemas"]["FileEntry"] | components["schemas"]["DirEntry"];
         /**
          * DiscoveredKB
@@ -2523,7 +2042,7 @@ interface components {
         DiscoveredKB: {
             /** @description Hostname the KB is reachable on from this machine (today always "localhost" — local stacks bind locally and codespace KBs arrive through a local port forward) */
             host: string;
-            /** @description Local TCP port of the KB's API (the backend port for a local stack; the allocated forward port for a codespace stack) */
+            /** @description Local TCP port of the KB's API (the gateway port for a local stack; the allocated forward port for a codespace stack) */
             port: number;
             /**
              * @description Where the stack actually runs. "local": containers on this machine. "codespace": a GitHub-hosted VM whose KB is port-forwarded here.
@@ -2541,7 +2060,7 @@ interface components {
         };
         /**
          * DiscoveryDocument
-         * @description The launcher's KB discovery document — the schema authority for <stateDir>/discovery/kbs.json, which the semiont launcher (Go, apps/launcher) regenerates on every stack mutation and the frontend container mounts read-only at /discovery. NOT an API endpoint: a static document fetched same-origin by browsers (via the frontend's static server) or read from disk by local Node consumers. An empty kbs list is meaningful ("the launcher manages nothing right now") and distinct from an absent file. Design record: .plans/BROWSER-KB-DISCOVERY.md.
+         * @description The launcher's KB discovery document — the schema authority for <stateDir>/discovery/kbs.json, which the semiont launcher (Go, apps/launcher) regenerates on every stack mutation and the Browser container mounts read-only at /discovery. NOT an API endpoint: a static document fetched same-origin by browsers (via the Browser's static server) or read from disk by local Node consumers. An empty kbs list is meaningful ("the launcher manages nothing right now") and distinct from an absent file. Design record: .plans/BROWSER-KB-DISCOVERY.md.
          */
         DiscoveryDocument: {
             /**
@@ -2552,7 +2071,7 @@ interface components {
             /** @description Every KB the launcher currently manages, local and forwarded */
             kbs: components["schemas"]["DiscoveredKB"][];
         };
-        /** @description Wire format emitted by GET /resources/:id/events/stream. Extends StoredEventResponse with optional enrichment fields populated from the materialized view at SSE-write time. Subscribers can read the enrichment fields directly to update local caches without an additional fetch. */
+        /** @description Wire format for persisted events delivered over the bus SSE stream (GET /bus/subscribe). Extends StoredEventResponse with optional enrichment fields the EventStore populates from the materialized view at publish time (persistence → view → enrich → notification). Subscribers read the enrichment fields directly to update local caches without an additional fetch. */
         EnrichedResourceEvent: components["schemas"]["StoredEventResponse"] & {
             /** @description Populated for events that mutate an annotation (mark:added, mark:body-updated, mark:removed). Carries the post-materialization annotation as it exists in the view, so subscribers can update local caches in-place without refetching. Absent for events that don't touch annotations. */
             annotation?: components["schemas"]["Annotation"];
@@ -2582,8 +2101,13 @@ interface components {
             data: string;
             id?: string;
         };
-        /** @description The full outcome of text extraction for one representation — the record the anchored-text store holds and the wire serves (PERSIST-ANCHORS decision D1). Either a success (the anchored text plus its provenance: how it was extracted, what class of PDF it came from, how confident OCR was, which pages could not be read) or a named decline. A decline is a first-class, cacheable outcome: 'we ran and there was nothing' costs a full recognition pass to discover. ocrConfidence is extraction quality for operators, deliberately not anchor confidence. */
-        ExtractionOutcome: (components["schemas"]["AnchoredText"] & {
+        /** @description A successful extraction: the anchored text plus its provenance (WIRE-UNION-DISCRIMINANTS P5c named this member; PERSIST-ANCHORS D1 made it the stored record). */
+        ExtractedText: components["schemas"]["AnchoredText"] & {
+            /**
+             * @description Discriminant — both ExtractionOutcome members carry `kind`, single-valued (D6: category here, detail in `method`).
+             * @enum {string}
+             */
+            kind: "extracted";
             /**
              * @description How the text was extracted.
              * @enum {string}
@@ -2604,15 +2128,33 @@ interface components {
             };
             /** @description 1-indexed pages this extraction could not read — present only for partially covered documents (class C). */
             unreadPages?: number[];
-        }) | {
+        } & {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            kind: "extracted";
+        };
+        /** @description A named decline: extraction ran and yielded nothing, by class. A first-class, cacheable outcome — 'we ran and there was nothing' costs a full recognition pass to discover. */
+        ExtractionDeclined: {
+            /**
+             * @description Discriminant — both ExtractionOutcome members carry `kind`, single-valued (D6: category here, detail in `declined`). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "declined";
             /**
              * @description Why extraction yielded nothing, by class.
              * @enum {string}
              */
             declined: "no-text-layer" | "encrypted" | "corrupt" | "too-large";
         };
+        /** @description The full outcome of text extraction for one representation — the record the anchored-text store holds and the wire serves (PERSIST-ANCHORS decision D1). Discriminated on `kind` (WIRE-UNION-DISCRIMINANTS P5c/D6): 'extracted' — the anchored text with its provenance; 'declined' — a named decline. ocrConfidence is extraction quality for operators, deliberately not anchor confidence. */
+        ExtractionOutcome: components["schemas"]["ExtractedText"] | components["schemas"]["ExtractionDeclined"];
         FileEntry: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "file";
             /** @description Entry name (basename) */
             name: string;
@@ -2807,11 +2349,11 @@ interface components {
         };
         /** @description Params bag for `job:create` with `jobType: 'generation'` — exactly the shape yield.fromContext(context, options) takes: options + the gathered context. The job's ids are DERIVED from context.focus at the dispatcher (resource focus → focus.resource; annotation focus → focus.sourceResource, with the worker auto-binding to focus.annotation); a caller-supplied referenceId is rejected. Carried inside JobCreateCommand.params; this schema is the generation shape's contract, including its requiredness. */
         GenerationJobParams: {
-            /** @description Title of the generated resource. */
+            /** @description Title of the generated resource. Non-empty: the dispatcher and worker both reject an empty title via isGenerationJobParams. NOTE minLength is documentation here — JobCreateCommand.params is additionalProperties:true, so /bus/emit's generated validator never sees this field (GENERATION-OUTPUT-FORMAT D9b). */
             title: string;
-            /** @description Storage URI for the generated resource's content. */
+            /** @description Storage URI for the generated resource's content — AUTHORITATIVE: the worker writes exactly here and never derives a location from the title. Non-empty, and there is no fallback; the dispatcher and worker both reject an empty value via isGenerationJobParams. NOTE minLength is documentation here — JobCreateCommand.params is additionalProperties:true, so /bus/emit's generated validator never sees this field (GENERATION-OUTPUT-FORMAT D6/D9). */
             storageUri: string;
-            /** @description The gathered context that grounds the generation. Its `focus` names the anchor (the sdk derives the job's resourceId — and referenceId, for annotation focus — from it); under `cite`, the ids its embedding carries are the only valid citation targets. */
+            /** @description The gathered context that grounds the generation. Its `focus` names the anchor: the DISPATCHER derives the job's resourceId from it (resource focus → focus.resource; annotation focus → focus.sourceResource, with the worker auto-binding to focus.annotation) and REJECTS a caller-supplied id — the context is authoritative. Under `cite`, the ids its embedding carries are the only valid citation targets. */
             context: components["schemas"]["GatheredContext"];
             /** @description Refining instruction, composed with `task` (task = what, prompt = how). */
             prompt?: string;
@@ -2910,8 +2452,48 @@ interface components {
             /** @description Maximum output tokens per generation. Equal to contextTokens when the provider has a single shared window. */
             maxOutputTokens: number;
         };
+        /** @description An annotation's graph presence. The node IS the annotation, so the full W3C object is required — selectors and body included, which is what lets a client place context annotations without a second fetch. Citations ride here too: an inbound reference is its linking annotation, anchored by an `annotation-of` edge to the resource it lives on and a `cites` edge to the focal resource. */
+        GraphAnnotationNode: {
+            /** @description The AnnotationId — the same value as annotation.id */
+            id: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "annotation";
+            /** @description The annotation's motivation, as a display label */
+            label: string;
+            /** @description Entity types carried by the annotation */
+            entityTypes?: string[];
+            annotation: components["schemas"]["Annotation"];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
+        /** @description A resource's presence in the gathered knowledge graph. */
+        GraphResourceNode: {
+            /** @description The resource's ResourceId */
+            id: string;
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "resource";
+            /** @description The resource's display name — its raw id when the resource's view was missing at build time */
+            label: string;
+            /** @description Entity types on the resource */
+            entityTypes?: string[];
+            metadata?: {
+                [key: string]: unknown;
+            };
+        };
         /** @description Result of a completed assessment-annotation job. */
         JobAssessmentAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "assessment-annotation";
             assessmentsFound: number;
             assessmentsCreated: number;
         };
@@ -2929,6 +2511,11 @@ interface components {
         };
         /** @description Result of a completed comment-annotation job. */
         JobCommentAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "comment-annotation";
             commentsFound: number;
             commentsCreated: number;
         };
@@ -2993,13 +2580,18 @@ interface components {
         };
         /** @description Result of a job that completed without doing its work because the resource could not be read. Distinct from a failure: nothing went wrong, there was simply no text to work with — an encrypted or damaged PDF, a scan whose text could not be recognized, or a document that yielded nothing. The reasons are the extraction vocabulary the Smelter reports on `smelt:settled`, MINUS `no-extractor`: a media type that can never yield text (a zip, an image) is a bad request rather than a decline, so a worker asked to detect over one throws and the job reports `job:fail`. Everything here is a resource-specific outcome — the same media type would have succeeded on a different document. */
         JobDeclinedResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "declined";
             /**
              * @description Discriminant. Always true — a job that did its work reports one of the other result shapes.
              * @enum {boolean}
              */
             declined: true;
             /**
-             * @description Why the resource could not be read. A CODE, not a sentence: the client owns the wording, so a browser renders it in the user's language and the CLI renders English terminal copy from the same value. The prose `message` this schema used to carry was composed backend-side and was therefore English everywhere (ASSIST-PROGRESS-CONSOLIDATION P5).
+             * @description Why the resource could not be read. A CODE, not a sentence: the client owns the wording, so a browser renders it in the user's language and the CLI renders English terminal copy from the same value. The prose `message` this schema used to carry was composed gateway-side and was therefore English everywhere (ASSIST-PROGRESS-CONSOLIDATION P5).
              * @enum {string}
              */
             reason: "no-text-layer" | "encrypted" | "corrupt" | "too-large" | "empty";
@@ -3013,15 +2605,27 @@ interface components {
             error: string;
             details?: string;
         };
-        /** @description Result of a completed generation job. resourceId is assigned by Stower when yield:create is processed; the worker emits job:complete with only resourceName, and Stower populates resourceId on the persisted payload. */
+        /** @description Result of a completed generation job. The worker creates the resource first (the yield:create round-trip returns the id), then emits job:complete carrying it — so resourceId is always present on the wire. */
         JobGenerationResult: {
-            /** @description ID of the generated resource (populated by Stower, not by the worker) */
-            resourceId?: string;
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "generation";
+            /** @description ID of the generated resource, obtained by the worker from the create round-trip before job:complete is emitted */
+            resourceId: string;
             /** @description Name of the generated resource */
             resourceName: string;
+            /** @description True when the model stopped at the maxTokens ceiling — the artifact is cut off, not complete. Derived at the producer from the provider's stopReason ('max_tokens' → true); required because the worker always knows (GENERATE-FROM-RESOURCE D6/P3a). */
+            truncated: boolean;
         };
         /** @description Result of a completed highlight-annotation job. */
         JobHighlightAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "highlight-annotation";
             highlightsFound: number;
             highlightsCreated: number;
         };
@@ -3069,22 +2673,30 @@ interface components {
                 value: string;
             }[];
         };
-        /** @description What a running job is doing right now, as a code plus typed params — never a prose sentence. The producer reports what happened; each client renders it in the user's language (react-ui from its translations, the Go launcher from its English map). The vocabulary is the census of every onProgress call site in @semiont/jobs (.plans/ASSIST-PROGRESS-CONSOLIDATION.md P1, 2026-08-12); extending it means adding a variant here and copy in every client, gated by the locale-completeness check. */
-        JobProgressMessage: {
-            /** @enum {string} */
-            code: "loading" | "analyzing" | "analyzing-tags" | "generating-resource" | "creating-resource";
-        } | {
-            /** @enum {string} */
-            code: "detecting-entities";
-            /** @description Entity type currently being detected */
-            entityType: string;
-        } | {
-            /** @enum {string} */
-            code: "creating-annotations" | "creating-tag-annotations";
-            /** @description How many annotations are being created */
-            count: number;
-        } | {
-            /** @enum {string} */
+        /** @description What a running job is doing right now, as a code plus typed params — never a prose sentence. The producer reports what happened; each client renders it in the user's language (react-ui from its translations, the Go launcher from its English map). One named schema per code, discriminated on `code` (WIRE-UNION-DISCRIMINANTS P5b), so generated clients get typed variants and copy-map completeness is statically checkable. The vocabulary is the census of every onProgress call site in @semiont/jobs (.plans/ASSIST-PROGRESS-CONSOLIDATION.md P1); extending it means adding a named variant here and copy in every client, gated by the locale-completeness check. */
+        JobProgressMessage: components["schemas"]["JobProgressLoading"] | components["schemas"]["JobProgressAnalyzing"] | components["schemas"]["JobProgressAnalyzingTags"] | components["schemas"]["JobProgressGeneratingResource"] | components["schemas"]["JobProgressCreatingResource"] | components["schemas"]["JobProgressCompleteGenerated"] | components["schemas"]["JobProgressDetectingEntities"] | components["schemas"]["JobProgressCreatingAnnotations"] | components["schemas"]["JobProgressCreatingTagAnnotations"] | components["schemas"]["JobProgressCompleteCreated"];
+        /** @description Analyzing the content. */
+        JobProgressAnalyzing: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "analyzing";
+        };
+        /** @description Analyzing the content against the tag schema. */
+        JobProgressAnalyzingTags: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "analyzing-tags";
+        };
+        /** @description Terminal success summary. */
+        JobProgressCompleteCreated: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             code: "complete-created";
             /** @description How many annotations were created */
             count: number;
@@ -3094,6 +2706,70 @@ interface components {
              */
             kind: "highlight" | "comment" | "assessment" | "reference" | "tag";
         };
+        /** @description Generation's terminal success. Deliberately generic — the client already holds the title it typed, and the outcome (name + resource link) travels on job:complete, not on progress (GENERATE-FROM-RESOURCE D7/D8). `truncated` qualifies the completion (D6): the same bit `JobGenerationResult.truncated` carries, so the two surfaces cannot drift. */
+        JobProgressCompleteGenerated: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "complete-generated";
+            /** @description True when the model stopped at the maxTokens ceiling — the artifact is cut off, not complete. */
+            truncated: boolean;
+        };
+        /** @description Writing detected annotations back to the resource. */
+        JobProgressCreatingAnnotations: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "creating-annotations";
+            /** @description How many annotations are being created */
+            count: number;
+        };
+        /** @description Writing the generated resource. */
+        JobProgressCreatingResource: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "creating-resource";
+        };
+        /** @description Writing detected tag annotations back to the resource. */
+        JobProgressCreatingTagAnnotations: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "creating-tag-annotations";
+            /** @description How many annotations are being created */
+            count: number;
+        };
+        /** @description Entity detection, one entity type at a time. */
+        JobProgressDetectingEntities: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "detecting-entities";
+            /** @description Entity type currently being detected */
+            entityType: string;
+        };
+        /** @description The model is generating the resource. */
+        JobProgressGeneratingResource: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "generating-resource";
+        };
+        /** @description Loading the resource content. */
+        JobProgressLoading: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            code: "loading";
+        };
         /** @description Event indicating a job has been queued */
         JobQueuedEvent: {
             jobId: string;
@@ -3104,6 +2780,11 @@ interface components {
         };
         /** @description Result of a completed reference-annotation job. */
         JobReferenceAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "reference-annotation";
             /** @description Total entities found */
             totalFound: number;
             /** @description Total annotations emitted */
@@ -3123,7 +2804,7 @@ interface components {
             percentage: number;
             progress?: components["schemas"]["JobProgress"];
         };
-        /** @description Discriminated union of all job result types. */
+        /** @description Discriminated union of all job result types — every member carries a single-valued `kind` (WIRE-UNION-DISCRIMINANTS D1/D2). Consumers switch on `kind`; generated clients get typed variants. */
         JobResult: components["schemas"]["JobGenerationResult"] | components["schemas"]["JobReferenceAnnotationResult"] | components["schemas"]["JobHighlightAnnotationResult"] | components["schemas"]["JobAssessmentAnnotationResult"] | components["schemas"]["JobCommentAnnotationResult"] | components["schemas"]["JobTagAnnotationResult"] | components["schemas"]["JobDeclinedResult"];
         /** @description Command to start a job */
         JobStartCommand: {
@@ -3159,7 +2840,7 @@ interface components {
             completedAt?: string;
             error?: string;
             progress?: unknown;
-            result?: unknown;
+            result?: components["schemas"]["JobResult"];
         };
         /** @description Result of a job status request */
         JobStatusResult: {
@@ -3168,6 +2849,11 @@ interface components {
         };
         /** @description Result of a completed tag-annotation job. */
         JobTagAnnotationResult: {
+            /**
+             * @description Discriminant — every JobResult member carries `kind`, single-valued, so a consumer holding only the result can tell what it is (WIRE-UNION-DISCRIMINANTS D1). (enum property replaced by openapi-typescript)
+             * @enum {string}
+             */
+            kind: "tag-annotation";
             tagsFound: number;
             tagsCreated: number;
             /** @description Count of tags created per category */
@@ -3182,25 +2868,11 @@ interface components {
         JobType: "reference-annotation" | "generation" | "highlight-annotation" | "assessment-annotation" | "comment-annotation" | "tag-annotation";
         /** @description Knowledge graph gathered for an LLM context — a shared backbone in which resources AND annotations are typed nodes, connected by typed (optionally bidirectional) edges. Flattened views the matcher/generation read (connections, citedBy, siblings) are derived from these nodes/edges. */
         KnowledgeGraph: {
-            nodes: {
-                /** @description Node identifier — a ResourceId or AnnotationId */
-                id: string;
-                /**
-                 * @description Whether this node is a resource or an annotation
-                 * @enum {string}
-                 */
-                type: "resource" | "annotation";
-                label: string;
-                /** @description Entity types on the node (resources) or carried by the annotation */
-                entityTypes?: string[];
-                metadata?: {
-                    [key: string]: unknown;
-                };
-            }[];
+            nodes: (components["schemas"]["GraphResourceNode"] | components["schemas"]["GraphAnnotationNode"])[];
             edges: {
                 source: string;
                 target: string;
-                /** @description Edge kind (e.g. citation, annotation-of, sibling) */
+                /** @description Edge kind: `annotation-of` (an annotation → the resource it lives on), `cites` (a citing linking annotation → the focal resource), or a peer connection's own relationshipType (free-form; `link` when unnamed) */
                 type: string;
                 /** @description Whether the connection goes both ways */
                 bidirectional?: boolean;
@@ -3227,6 +2899,7 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             resourceId: string;
+            /** @description Optional: where the resource's bytes live, so the archive can act on the file. An instruction to this handler, not a copy of the stored fact (that lives on the primary Representation). Working-tree URI, only file:// is supported. */
             storageUri?: string;
             keepFile?: boolean;
             noGit?: boolean;
@@ -3315,6 +2988,7 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             resourceId: string;
+            /** @description Optional: where the resource's bytes are expected to be. When present the handler VERIFIES the file exists and fails loudly if it does not, rather than succeeding as a no-op. An instruction, not a copy of the stored fact (that lives on the primary Representation). Working-tree URI, only file:// is supported. */
             storageUri?: string;
         };
         /** @description Bus command to update an annotation's body with patch operations. */
@@ -3406,7 +3080,7 @@ interface components {
             "@type"?: string | string[];
             /** @description MIME/media type (e.g., text/markdown, image/png). */
             mediaType: string;
-            /** @description Working-tree URI identifying where the bytes live. Only file:// is supported (e.g. file://docs/overview.md). */
+            /** @description Working-tree URI identifying where this rendition's bytes live. Only file:// is supported (e.g. file://docs/overview.md). The single home of the storage location: maintained across moves (yield:moved relocates it), absent when the resource has no stored bytes. */
             storageUri?: string;
             filename?: string;
             /** @description Size of the payload in bytes. */
@@ -3457,6 +3131,8 @@ interface components {
             format: components["schemas"]["ContentFormat"];
             contentChecksum: string;
             contentByteSize?: number;
+            /** @description Where the clone's bytes are, on the resource's primary Representation — the same single home `yield:created` writes to (STORAGE-URI-ONE-HOME). */
+            storageUri?: string;
             parentResourceId: string;
             entityTypes?: string[];
             language?: string;
@@ -3469,7 +3145,7 @@ interface components {
             contentChecksum: string;
             contentByteSize?: number;
             entityTypes?: string[];
-            /** @description Working-tree URI (e.g. file://docs/overview.md) */
+            /** @description The creating instruction's URI, recorded on the event. Append-only, so this value never changes — the LOCATION the projection serves is maintained across moves and lives on the resource's primary Representation, relocated by yield:moved. Optional: a resource may have no bytes. Working-tree URI, only file:// is supported (e.g. file://docs/overview.md). */
             storageUri?: string;
             language?: string;
             isDraft?: boolean;
@@ -3543,10 +3219,6 @@ interface components {
              * @description Original URI from a source knowledge base when this resource was imported
              */
             originatedFrom?: string;
-            /** @description Working-tree URI for this resource (e.g. file://docs/overview.md). Stable across updates and moves. */
-            storageUri?: string;
-            /** @description SHA-256 hex hash of the current content. Updated on resource.created, resource.updated, resource.cloned events. */
-            currentChecksum?: string;
         } & {
             [key: string]: unknown;
         };
@@ -3596,6 +3268,8 @@ interface components {
             text: string;
             /** @description Source resource ID */
             resourceId: string;
+            /** @description The source resource's display name, resolved from its view at gather time. Required: a match card must name its source, and corpus matches routinely come from outside the graph neighborhood, so there is no node to borrow a name from. A match whose source no longer resolves to a view is dropped by the producer rather than served nameless. */
+            resourceName: string;
             /** @description Source annotation ID, if the match is from an annotation */
             annotationId?: string;
             /** @description Cosine similarity score (0-1) */
@@ -3633,7 +3307,10 @@ interface components {
             theme: "light" | "dark" | "system";
         };
         SpecificResource: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "SpecificResource";
             /** @description IRI of the target resource */
             source: string;
@@ -3654,7 +3331,7 @@ interface components {
             projectName?: string;
             /** @description Current git branch of the knowledge base repository */
             gitBranch?: string;
-            /** @description The knowledge base's did:web identity — 'did:web:' + the committed [site] domain, byte-identical to the string the launcher publishes in its discovery document. REQUIRED: a KB that declares no domain does not run (the launcher refuses to start it, and the backend refuses to boot), so a response without this field means the caller reached something that bypassed both. Identifies WHICH knowledge base this is; it does NOT identify which running copy — one KB reachable at two addresses (a local clone and a codespace of one repo) reports the same did at both. Use it to verify what you connected to, not to select among discovered entries. */
+            /** @description The knowledge base's did:web identity — 'did:web:' + the committed [site] domain, byte-identical to the string the launcher publishes in its discovery document. REQUIRED: a KB that declares no domain does not run (the launcher refuses to start it, and the gateway refuses to boot), so a response without this field means the caller reached something that bypassed both. Identifies WHICH knowledge base this is; it does NOT identify which running copy — one KB reachable at two addresses (a local clone and a codespace of one repo) reports the same did at both. Use it to verify what you connected to, not to select among discovered entries. */
             did: string;
         };
         /** @description A persisted domain event with metadata. Flat shape — event fields and metadata are peers. */
@@ -3726,7 +3403,10 @@ interface components {
             suffix?: string;
         };
         TextualBody: {
-            /** @enum {string} */
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
             type: "TextualBody";
             /** @description The text content (e.g., entity type name) */
             value: string;
@@ -3808,14 +3488,18 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
         };
-        /** @description Bus command to create a cloned resource from a clone token. */
+        /** @description Bus command to create a cloned resource from a clone token. Bytes are stored gateway-side BEFORE this command is emitted (GATEWAY.md D4a: the Archivist serves no bytes) — the command carries the storage coordinates, never content. */
         YieldCloneCreateCommand: {
             correlationId: string;
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             token: string;
             name: string;
-            content: string;
+            /** @description Where the caller already wrote the clone's bytes — an instruction, not a copy of the stored fact (that lives on the primary Representation). Bytes are stored through the byte door BEFORE this command is sent, so this names an existing file. Working-tree URI, only file:// is supported. */
+            storageUri: string;
+            contentChecksum: string;
+            byteSize: number;
+            format: components["schemas"]["ContentFormat"];
             archiveOriginal?: boolean;
         };
         /** @description Success response after creating a cloned resource. */
@@ -3842,6 +3526,7 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             name: string;
+            /** @description The caller's instruction for WHERE the bytes are — not a copy of the stored fact. The stored location lives on the resource's primary Representation (`Representation.storageUri`), which is its single home; this field is the message that puts it there. Working-tree URI, only file:// is supported (e.g. file://docs/overview.md). */
             storageUri: string;
             contentChecksum: string;
             byteSize: number;
@@ -3857,6 +3542,34 @@ interface components {
             generator?: components["schemas"]["Agent"] | components["schemas"]["Agent"][];
             noGit?: boolean;
         };
+        /**
+         * @description Command: stow an already-uploaded clone's bytes and append `yield:cloned`.
+         *
+         *     The INNER half of the clone flow. `yield:clone-create` reaches the CloneTokenManager, which alone can validate the token and read the source's entity types; it then emits this so the Stower — the only appendEvent caller — writes the domain event.
+         *
+         *     Distinct from `yield:create` because a clone is a distinct operation, not a creation with an extra field. It REQUIRES a parent, and that requirement is what a separate command expresses: an optional `parentResourceId` on the create command could not say that a clone without a parent is not a clone. `ResourceClonedPayload` requires it for the same reason.
+         *
+         *     Generated resources are NOT clones: they carry provenance in `generatedFrom` and stay on `yield:create`.
+         */
+        YieldClonePersistCommand: {
+            /** @description Correlation id so busRequest can match the reply. */
+            correlationId: string;
+            /** @description Injected by the gateway from the authenticated principal; never supplied by a wire caller. */
+            _userId?: string;
+            name: string;
+            /** @description The caller's instruction for WHERE the bytes are — the uploader wrote them before emitting this. The stored location lives on the clone's primary Representation (STORAGE-URI-ONE-HOME). */
+            storageUri: string;
+            contentChecksum: string;
+            byteSize: number;
+            format: components["schemas"]["ContentFormat"];
+            language?: string;
+            /** @description Inherited from the source resource by the CloneTokenManager, which is the only party that knows the token is valid. */
+            entityTypes?: string[];
+            /** @description The resource this one is cloned FROM. Required: it is what makes this a clone rather than a creation. */
+            parentResourceId: string;
+            /** @description The bytes were already written by the uploader; the Stower's register does the one `git add` on apply (GATEWAY.md D4b). */
+            noGit?: boolean;
+        };
         /** @description Success reply after creating a yielded resource, matched to the originating command by correlationId. */
         YieldCreateOk: {
             /** @description Correlation id echoed from the yield:create command so busRequest can match the reply. */
@@ -3866,6 +3579,15 @@ interface components {
                 resourceId: string;
             };
         };
+        /** @description Success reply after cloning a resource, matched to the originating command by correlationId. */
+        YieldClonePersistOk: {
+            /** @description Correlation id echoed from the yield:clone-persist command so busRequest can match the reply. */
+            correlationId?: string;
+            /** @description The clone's identity — a new resource, distinct from its parent. */
+            response: {
+                resourceId: string;
+            };
+        };
         /** @description Bus command to move (rename) a yielded resource. */
         YieldMvCommand: {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
@@ -3881,6 +3603,7 @@ interface components {
             /** @description Authenticated user's DID, injected by the /bus/emit gateway. Clients do not set this. */
             _userId?: string;
             resourceId: string;
+            /** @description The caller's instruction for WHERE the bytes are — not a copy of the stored fact. The stored location lives on the resource's primary Representation (`Representation.storageUri`), which is its single home; this field is the message that puts it there. Working-tree URI, only file:// is supported (e.g. file://docs/overview.md). */
             storageUri: string;
             contentChecksum: string;
             byteSize: number;
@@ -4228,7 +3951,7 @@ interface AnchorRect {
  *
  * The complete EventMap for the RxJS EventBus. Every channel name and
  * its payload type is defined here — domain events, commands, reads,
- * results, SSE stream payloads, and frontend UI events.
+ * results, SSE stream payloads, and Browser UI events.
  *
  * Identifier discipline: where a payload carries an annotation or
  * resource id, the TypeScript layer narrows the OpenAPI `string` to the
@@ -4274,6 +3997,7 @@ type EventMap = {
     'yield:representation-added': StoredEvent<EventOfType<'yield:representation-added'>>;
     'yield:representation-removed': StoredEvent<EventOfType<'yield:representation-removed'>>;
     'yield:create': components['schemas']['YieldCreateCommand'];
+    'yield:clone-persist': components['schemas']['YieldClonePersistCommand'];
     'yield:update': components['schemas']['YieldUpdateCommand'];
     'yield:mv': components['schemas']['YieldMvCommand'];
     'yield:clone': void;
@@ -4282,6 +4006,10 @@ type EventMap = {
     'yield:clone-create': components['schemas']['YieldCloneCreateCommand'];
     'yield:create-ok': components['schemas']['YieldCreateOk'];
     'yield:create-failed': components['schemas']['CommandError'];
+    'yield:clone-persist-ok': components['schemas']['YieldClonePersistOk'];
+    'yield:clone-persist-failed': {
+        correlationId: string;
+    } & components['schemas']['CommandError'];
     'yield:update-ok': components['schemas']['YieldUpdateOk'];
     'yield:update-failed': components['schemas']['CommandError'];
     'yield:move-failed': {
@@ -4421,6 +4149,14 @@ type EventMap = {
     'browse:anchored-text-failed': {
         correlationId: string;
     } & components['schemas']['CommandError'];
+    'browse:anchored-text-by-checksum-requested': components['schemas']['BrowseAnchoredTextByChecksumRequest'];
+    'browse:anchored-text-by-checksum-result': {
+        correlationId: string;
+        response: components['schemas']['ExtractionOutcome'] | null;
+    };
+    'browse:anchored-text-by-checksum-failed': {
+        correlationId: string;
+    } & components['schemas']['CommandError'];
     'browse:resources-requested': components['schemas']['BrowseResourcesRequest'];
     'browse:resources-result': {
         correlationId: string;
@@ -4557,7 +4293,7 @@ type EventMap = {
      * Emitted by the Weaver after applying an event (or a batch's last event)
      * for a resource to the graph. `sequenceNumber` is the resource-stream
      * sequence of the last applied event. Folded by `WeaveProgress`
-     * (make-meaning) into the backend-local applied map that the
+     * (make-meaning) into the gateway-local applied map that the
      * `whenApplied` barrier awaits. In-process signal today; crosses the
      * bus gateway after WEAVER-ISOLATION.
      */
@@ -4687,6 +4423,7 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'yield:representation-added': null;
     readonly 'yield:representation-removed': null;
     readonly 'yield:create': "YieldCreateCommand";
+    readonly 'yield:clone-persist': "YieldClonePersistCommand";
     readonly 'yield:update': "YieldUpdateCommand";
     readonly 'yield:mv': "YieldMvCommand";
     readonly 'yield:clone': null;
@@ -4695,6 +4432,8 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'yield:clone-create': "YieldCloneCreateCommand";
     readonly 'yield:create-ok': "YieldCreateOk";
     readonly 'yield:create-failed': "CommandError";
+    readonly 'yield:clone-persist-ok': "YieldClonePersistOk";
+    readonly 'yield:clone-persist-failed': null;
     readonly 'yield:update-ok': "YieldUpdateOk";
     readonly 'yield:update-failed': null;
     readonly 'yield:move-failed': null;
@@ -4773,6 +4512,9 @@ declare const CHANNEL_SCHEMAS: {
     readonly 'browse:anchored-text-requested': "BrowseAnchoredTextRequest";
     readonly 'browse:anchored-text-result': "BrowseAnchoredTextResult";
     readonly 'browse:anchored-text-failed': null;
+    readonly 'browse:anchored-text-by-checksum-requested': "BrowseAnchoredTextByChecksumRequest";
+    readonly 'browse:anchored-text-by-checksum-result': "BrowseAnchoredTextResult";
+    readonly 'browse:anchored-text-by-checksum-failed': null;
     readonly 'browse:resources-requested': "BrowseResourcesRequest";
     readonly 'browse:resources-result': "BrowseResourcesResult";
     readonly 'browse:resources-failed': null;
@@ -5018,6 +4760,13 @@ declare class EventBus {
      * using runtime `PersistedEventType` strings.
      */
     getDomainEvent(eventType: PersistedEventType): Subject<StoredEvent>;
+    /**
+     * Channel names with at least one live observer right now. Introspection
+     * for composition-parity gates: `get()` creates subjects lazily, so mere
+     * access does not count — only real subscriptions do. Scoped channels
+     * appear under their namespaced key (`<scope>:<channel>`).
+     */
+    observedChannels(): string[];
     /**
      * Destroy the event bus and complete all subjects
      *
@@ -5254,7 +5003,7 @@ declare function errField(error: unknown): unknown;
  * Bus logging — runtime-toggleable cross-wire visibility.
  *
  * One line per event that crosses a process boundary, in a grep-able
- * format that's symmetric across frontend and backend:
+ * format that's symmetric across frontend and gateway:
  *
  *   [bus EMIT] <channel> [scope=X] [cid=<first8>] <payload>
  *   [bus RECV] <channel> [scope=X] [cid=<first8>] <payload>
@@ -5744,7 +5493,11 @@ declare function getChecksum(resource: ResourceDescriptor | undefined): string |
  */
 declare function getLanguage(resource: ResourceDescriptor | undefined): string | undefined;
 /**
- * Get storage URI from primary representation
+ * Get the storage URI from the primary representation — the field's ONE home
+ * (STORAGE-URI-ONE-HOME): bytes are a fact about a rendition, so their
+ * location lives on the Representation, never on the descriptor. This is the
+ * accessor every descriptor-holding read goes through; `undefined` means the
+ * resource has no stored bytes.
  *
  * @param resource - ResourceDescriptor
  * @returns Storage URI or undefined
@@ -5834,7 +5587,7 @@ declare function decodeRepresentation(buffer: Buffer, mediaType: string): string
  *  - `not-found`    — resource missing (HTTP 404)
  *  - `conflict`     — concurrent modification, duplicate, etc. (HTTP 409)
  *  - `bad-request`  — request malformed (HTTP 400)
- *  - `unavailable`  — backend unreachable, network error, 5xx
+ *  - `unavailable`  — gateway unreachable, network error, 5xx
  *  - `error`        — unclassified fallback
  */
 type TransportErrorCode = 'unauthorized' | 'forbidden' | 'not-found' | 'conflict' | 'bad-request' | 'unavailable' | 'error';
@@ -5870,11 +5623,11 @@ declare class ConflictError extends SemiontError {
  *
  *   ITransport          — bus primitives + lifecycle. Universal: every
  *                         concrete transport implements this.
- *   IBackendOperations  — auth, admin, exchange, system endpoints.
+ *   IGatewayOperations  — auth, admin, and system endpoints.
  *                         HTTP-shaped today; an in-process transport may
  *                         implement none, some, or a different set.
  *                         Optional on `SemiontClient` — passed only when
- *                         the host has a backend that supports them.
+ *                         the host has a gateway that supports them.
  *   IContentTransport   — binary I/O (putBinary / getBinary). Narrow by
  *                         design because binary has different backpressure
  *                         and streaming characteristics.
@@ -5943,27 +5696,6 @@ type UserResponse = ResponseContent<paths['/api/users/me']['get']>;
 type UpdateUserRequest = RequestContent<paths['/api/admin/users/{id}']['patch']>;
 type UpdateUserResponse = ResponseContent<paths['/api/admin/users/{id}']['patch']>;
 type ListUsersResponse = ResponseContent<paths['/api/admin/users']['get']>;
-type ProgressEvent = {
-    phase: string;
-    message?: string;
-    result?: Record<string, unknown>;
-};
-type ProgressCallback = (event: ProgressEvent) => void;
-/**
- * Stream-shaped return type for backend download operations
- * (`backupKnowledgeBase`, `exportKnowledgeBase`). Transport-neutral —
- * any implementation can produce a `ReadableStream<Uint8Array>` without
- * fabricating a fetch `Response`. HTTP wraps `response.body` and
- * `response.headers`; in-process implementations return their own stream.
- *
- * The same shape `IContentTransport.getBinaryStream` already uses for
- * binary downloads.
- */
-interface BackendDownload {
-    stream: ReadableStream<Uint8Array>;
-    contentType: string;
-    filename?: string;
-}
 interface ITransport {
     /**
      * Base URL the transport speaks to. For HTTP this is `https://host[:port]`;
@@ -5979,7 +5711,7 @@ interface ITransport {
      *
      * Resolves with the number of subscribers the emit reached
      * (`/bus/emit` responds `{subscribers: n}`; GUIDED-TOUR P1), or `-1`
-     * when the count is unknown — an older backend, an unreadable body, or
+     * when the count is unknown — an older gateway, an unreadable body, or
      * an in-process transport where the question does not apply. `-1` is
      * the same sentinel the Go client uses: a parse failure must stay
      * distinguishable from a genuine empty room.
@@ -6048,9 +5780,9 @@ interface ITransport {
     dispose(): void;
 }
 /**
- * Auth, admin, exchange, and system endpoints. HTTP-shaped today —
+ * Auth, admin, and system endpoints. HTTP-shaped today —
  * `HttpTransport` implements both this and `ITransport`; the
- * `SemiontClient` constructor takes a `IBackendOperations` argument
+ * `SemiontClient` constructor takes a `IGatewayOperations` argument
  * separately from the bus transport so non-HTTP transports
  * (`LocalTransport`) can implement just the bus surface and the
  * SemiontClient cleanly omits `client.auth` / `client.admin`.
@@ -6059,7 +5791,7 @@ interface ITransport {
  * `TransportErrorCode` (see `errors.ts`) so the routing layer
  * (`SemiontBrowser`) stays transport-neutral.
  */
-interface IBackendOperations {
+interface IGatewayOperations {
     authenticatePassword(email: Email, password: string): Promise<AuthResponse>;
     authenticateGoogle(credential: GoogleCredential): Promise<AuthResponse>;
     refreshAccessToken(token: RefreshToken): Promise<TokenRefreshResponse>;
@@ -6073,22 +5805,6 @@ interface IBackendOperations {
     getUserStats(): Promise<AdminUserStatsResponse>;
     updateUser(id: UserDID, data: UpdateUserRequest): Promise<UpdateUserResponse>;
     getOAuthConfig(): Promise<OAuthConfigResponse>;
-    backupKnowledgeBase(): Promise<BackendDownload>;
-    /**
-     * Stream of `ProgressEvent`s for a restore/import operation. The
-     * Observable emits each progress event in order and completes when
-     * the operation is done; the final event carries `phase: 'complete'`
-     * (or `'error'` / `'failed'` followed by an Observable error).
-     *
-     * The SDK wraps the contract's `Observable<ProgressEvent>` as a
-     * `StreamObservable<ProgressEvent>` so consumers can `await` for the
-     * final event or `.subscribe(...)` to render every step.
-     */
-    restoreKnowledgeBase(file: File): Observable<ProgressEvent>;
-    exportKnowledgeBase(params?: {
-        includeArchived?: boolean;
-    }): Promise<BackendDownload>;
-    importKnowledgeBase(file: File): Observable<ProgressEvent>;
     healthCheck(): Promise<HealthCheckResponse>;
     getStatus(): Promise<StatusResponse>;
 }
@@ -6104,6 +5820,15 @@ interface PutBinaryRequest {
     generationPrompt?: string;
     generator?: Agent$1 | Agent$1[];
     isDraft?: boolean;
+    /**
+     * Clone provenance (EXTRACT-ARCHIVIST P3): when set, the gateway stores
+     * the bytes and routes creation through `yield:clone-create` — the
+     * CloneTokenManager validates the token and inherits source metadata.
+     * Bytes never ride the bus (D4a).
+     */
+    cloneToken?: string;
+    /** Clone-only: archive the source resource after a successful clone. */
+    archiveOriginal?: boolean;
 }
 /**
  * Optional byte-progress hook for `putBinary`. Receives raw byte counts;
@@ -6159,85 +5884,6 @@ interface IContentTransport {
     getResourceGraph(resourceId: ResourceId, options?: {
         auth?: AccessToken;
     }): Promise<GetResourceResponse>;
-    /**
-     * Store anchored text — the coordinate map a producer derived from a
-     * representation's bytes (OCR, a native text layer, a table or form
-     * reader) — under **the content checksum of those bytes** (PERSIST-ANCHORS
-     * decision A: one artifact per representation, and a representation IS its
-     * bytes).
-     *
-     * The producer supplies the checksum because it alone knows which bytes it
-     * actually read. That is a correctness rule, not a convenience: if the
-     * store derived the key from the resource's CURRENT representation at
-     * write time, a byte change racing the publish would file old geometry
-     * under the new checksum — wrong quotes served, and the reconcile diff
-     * sees "artifact present" so it never heals. Producer-supplied, the same
-     * race files the map under the OLD checksum: an unreachable orphan, and
-     * the new checksum's missing artifact is exactly what the third drift
-     * class re-derives (SMELTER-AXIOMS S15).
-     *
-     * Its own method rather than a `putBinary` of some derived media type: a
-     * coordinate map is not a *representation* of the resource, and dressing it
-     * as one would make a derived artifact indistinguishable from content a user
-     * uploaded.
-     *
-     * Whole-representation, like `getResourceGraph` is whole-resource. The
-     * producer iterates page by page; every consumer wants one map.
-     */
-    putAnchoredText(checksum: string, outcome: ExtractionOutcome, options?: {
-        auth?: AccessToken;
-    }): Promise<void>;
-    /**
-     * The resource's anchored text, or `null` when none has been derived.
-     *
-     * Deliberately resource-addressed while `putAnchoredText` is
-     * checksum-addressed: readers hold a resource id, and the server resolves
-     * it to the current representation's checksum through the view — the
-     * `resourceId → checksum` index of PERSIST-ANCHORS decision A. A reader
-     * therefore can never receive geometry for bytes the resource no longer
-     * has: the pointer moves, the artifacts stay, the index always follows
-     * the pointer.
-     *
-     * `null` is not an error and is the common case: a native text layer is read
-     * in the browser, and a resource whose media type has no extractor never
-     * produces a map at all. Callers degrade — for a PDF annotation that means
-     * geometry with no quoted text, which is the behaviour that shipped before
-     * any of this existed.
-     */
-    getAnchoredText(resourceId: ResourceId, options?: {
-        auth?: AccessToken;
-    }): Promise<ExtractionOutcome | null>;
-    /**
-     * The stored extraction outcome for exactly this byte content, or `null`
-     * for a miss — the cache-consult read (PERSIST-ANCHORS P2c). Every cache
-     * consumer runs out of process (the smelter worker, the detection
-     * workers), so the `extract()` seam's consult crosses the wire through
-     * this method; without it the cache would be write-only from exactly the
-     * processes it exists to serve.
-     *
-     * Checksum-addressed and barrier-free, unlike `getAnchoredText`:
-     * presence at this instant is the question (the keys listing's
-     * semantics), and a caller holding the checksum already holds the
-     * content identity — nothing to resolve, nothing to wait for.
-     */
-    getAnchoredTextByChecksum(checksum: string, options?: {
-        auth?: AccessToken;
-    }): Promise<ExtractionOutcome | null>;
-    /**
-     * Every key under which anchored text would currently be served — the
-     * reconcile planner's bulk existence read (PERSIST-ANCHORS P0). The
-     * Smelter diffs this against the catalog to find resources whose artifact
-     * was lost (a transient store, a failed publish) and plans re-derivation;
-     * one call per reconcile, never a `getAnchoredText` probe per resource,
-     * because each map is ~32 KB per scanned page and only presence is asked.
-     *
-     * Keys are resource ids today; after PERSIST-ANCHORS P1 they are content
-     * checksums. Callers compare against whichever handle the store is keyed
-     * by — the diff moves with the rekey, this contract does not.
-     */
-    listAnchoredTextKeys(options?: {
-        auth?: AccessToken;
-    }): Promise<string[]>;
     dispose(): void;
 }
 
@@ -6281,6 +5927,10 @@ declare const BUS_OPERATIONS: {
         readonly result: "browse:anchored-text-result";
         readonly failure: "browse:anchored-text-failed";
     };
+    readonly 'browse:anchored-text-by-checksum-requested': {
+        readonly result: "browse:anchored-text-by-checksum-result";
+        readonly failure: "browse:anchored-text-by-checksum-failed";
+    };
     readonly 'browse:resources-requested': {
         readonly result: "browse:resources-result";
         readonly failure: "browse:resources-failed";
@@ -6398,6 +6048,10 @@ declare const BUS_OPERATIONS: {
         readonly result: "yield:create-ok";
         readonly failure: "yield:create-failed";
     };
+    readonly 'yield:clone-persist': {
+        readonly result: "yield:clone-persist-ok";
+        readonly failure: "yield:clone-persist-failed";
+    };
     readonly 'yield:update': {
         readonly result: "yield:update-ok";
         readonly failure: "yield:update-failed";
@@ -6837,7 +6491,7 @@ declare function reconcileSelector(content: string, llm: LlmSelectorInput): Reco
 /**
  * Text encoding utilities for consistent charset handling
  *
- * Ensures frontend decoding matches backend decoding by respecting
+ * Ensures frontend decoding matches gateway decoding by respecting
  * charset parameters in mediaType (e.g., "text/plain; charset=iso-8859-1")
  */
 /**
@@ -6856,7 +6510,7 @@ declare function extractCharset(mediaType: string): string;
  *
  * Uses TextDecoder with the charset extracted from mediaType parameter.
  * This ensures the same character space is used for both annotation creation
- * (backend) and rendering (frontend).
+ * (gateway) and rendering (frontend).
  *
  * @param buffer - Binary data to decode
  * @param mediaType - Media type with optional charset parameter
@@ -6940,11 +6594,16 @@ declare function isValidEmail(email: string): boolean;
  *                   embedding, never mojibake)
  * - `authorable`  — offered in the compose editor's format dropdown
  * - `uploadable`  — big tent: true for every registry member
+ * - `generatable` — the generation worker can produce it as a yield artifact
  *
  * 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.
  *
+ * Questions ANSWERABLE from those rows get a helper, never a row of their own —
+ * `isAnnotatable` reads `anchoring`, and a second stored field would be a fact
+ * that can contradict the one it was derived from.
+ *
  * 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
@@ -7121,6 +6780,15 @@ declare function baseMediaType(format: string): string;
 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;
+/**
+ * The clone-format gate (MEDIA-TYPES.md Phase 5, moved here for
+ * EXTRACT-ARCHIVIST's clone wire-shape change): a clone opens in the
+ * compose editor, so authorable sources keep their base media type and
+ * everything else falls back to text/plain. Lives beside the registry it
+ * reads; the SDK applies it when deriving a clone upload's format and the
+ * CloneTokenManager's tests pin it.
+ */
+declare function cloneFormat(sourceMediaType: string | undefined): SupportedMediaType;
 /**
  * Lenient extension lookup for naming foreign/imported content: '.dat' on
  * registry miss. Exporters use this — a vocabulary change must never
@@ -7141,6 +6809,19 @@ declare function mediaTypeForExtension(ext: string): SupportedMediaType | undefi
  * unregistered text subtypes embed too), everything else is 'none'.
  */
 declare function textExtractionOf(format: string): TextExtraction;
+/**
+ * WHETHER a type can carry annotations — `anchoring` remains the authority on
+ * HOW. Derived rather than stored: a parallel `annotatable` row field would be
+ * two facts that can disagree, with nothing to adjudicate
+ * `{ annotatable: true, anchoring: 'none' }`.
+ *
+ * Strict on a registry miss, where `textExtractionOf` above is lenient. The
+ * asymmetry is deliberate. Extracting the wrong bytes costs one bad vector,
+ * and refusing to extract costs a resource nobody can find, so extraction
+ * guesses; an annotation is a durable write against a coordinate model the
+ * system does not have for an unknown type, so it refuses.
+ */
+declare function isAnnotatable(format: string): boolean;
 /** Types offered in the compose editor's format dropdown. */
 declare const AUTHORABLE_MEDIA_TYPES: readonly SupportedMediaType[];
 /** Registry rows whose text the Smelter can extract. Rows only — the
@@ -7282,6 +6963,61 @@ interface StateUnit {
     dispose(): void;
 }
 
+/**
+ * Storage URI Derivation
+ *
+ * Builds the name a resource's content lives under in the working tree, from
+ * its title and validated media type. Extensions come from the media-type
+ * registry; formats are validated upstream at the create/yield boundary, so
+ * the lookup is strict — no fallback.
+ *
+ * Lives in `@semiont/core` rather than `@semiont/content` (moved
+ * 2026-08-24, GENERATION-OUTPUT-FORMAT D10) because the generation form
+ * proposes a default path and react-ui cannot depend on the node-flavoured
+ * content package. This module imports only the registry, so it is
+ * browser-safe.
+ */
+
+/**
+ * The FILENAME a resource's content takes: slug + the registry's extension.
+ *
+ * The name is lowercased, runs of non-alphanumeric characters collapse to
+ * single hyphens, and leading/trailing hyphens are stripped.
+ *
+ * This is the fragment form, for callers composing a path themselves — the
+ * generation form's input sits beside a `file://` prefix chip, so it must not
+ * strip a prefix this helper just added.
+ *
+ * @example
+ * storageFileName("My Document", "text/markdown") // => "my-document.md"
+ */
+declare function storageFileName(name: string, format: SupportedMediaType): string;
+/**
+ * Derive a full `file://` storage URI from a resource name and media type.
+ *
+ * @example
+ * deriveStorageUri("My Document", "text/markdown") // => "file://my-document.md"
+ */
+declare function deriveStorageUri(name: string, format: SupportedMediaType): string;
+/**
+ * The folder a resource lives in, WITHOUT a trailing slash — `''` when it sits
+ * at the tree root. Accepts a `file://` URI or a bare path.
+ */
+declare function folderOf(storageUri: string | undefined): string;
+/**
+ * The Save location a form PROPOSES: beside the source resource, named for the
+ * title, extended for the chosen format (GENERATION-OUTPUT-FORMAT D11).
+ *
+ * Deriving the whole filename — extension included — has a happy consequence:
+ * while untouched, switching format rewrites the extension too, so D7's
+ * mismatch refusal becomes unreachable except on hand-edited paths. It guards
+ * deliberate edits rather than trapping ordinary use.
+ *
+ * Returns `''` for an empty title: a bare extension (".md") reads as a hidden
+ * file and is nobody's intent.
+ */
+declare function proposeStoragePath(folder: string, title: string, format: SupportedMediaType): string;
+
 /**
  * Common type guard utilities
  */
@@ -7581,9 +7317,9 @@ interface BuildRequirements {
 }
 /**
  * This interface was referenced by `HttpsSemiontOrgSchemasConfigJson`'s JSON-Schema
- * via the `definition` "BackendServiceConfig".
+ * via the `definition` "GatewayServiceConfig".
  */
-interface BackendServiceConfig {
+interface GatewayServiceConfig {
     platform: ServicePlatformConfig;
     devMode?: boolean;
     command?: string;
@@ -7632,58 +7368,6 @@ interface BackendServiceConfig {
         [k: string]: string;
     };
 }
-/**
- * This interface was referenced by `HttpsSemiontOrgSchemasConfigJson`'s JSON-Schema
- * via the `definition` "FrontendServiceConfig".
- */
-interface FrontendServiceConfig {
-    platform: ServicePlatformConfig;
-    devMode?: boolean;
-    command?: string;
-    port: number;
-    siteName: string;
-    image?: string;
-    projectRoot?: string;
-    databaseUrl?: string;
-    timeout?: number;
-    wait?: number;
-    logsEndpoint?: string;
-    tag?: string;
-    resources?: ResourceRequirements;
-    security?: SecurityRequirements;
-    build?: boolean | BuildRequirements;
-    dockerfile?: string;
-    buildContext?: string;
-    buildArgs?: {
-        [k: string]: string;
-    };
-    buildTarget?: string;
-    prebuilt?: boolean;
-    noCache?: boolean;
-    secrets?: string[];
-    labels?: {
-        [k: string]: string;
-    };
-    annotations?: {
-        [k: string]: string;
-    };
-    dependencies?: string[];
-    externalDependencies?: (string | {
-        name?: string;
-        url?: string;
-        required?: boolean;
-        healthCheck?: string;
-        [k: string]: unknown;
-    })[];
-    environment?: {
-        [k: string]: string;
-    };
-    env?: {
-        [k: string]: string;
-    };
-    publicURL?: string;
-    allowedOrigins?: string[];
-}
 /**
  * This interface was referenced by `HttpsSemiontOrgSchemasConfigJson`'s JSON-Schema
  * via the `definition` "VectorsServiceConfig".
@@ -7854,13 +7538,26 @@ interface McpServiceConfig {
  * via the `definition` "ServicesConfig".
  */
 interface ServicesConfig {
-    backend?: BackendServiceConfig;
-    frontend?: FrontendServiceConfig;
+    gateway?: GatewayServiceConfig;
     database?: DatabaseServiceConfig;
     graph?: GraphServiceConfig;
     mcp?: McpServiceConfig;
     vectors: VectorsServiceConfig;
     embedding: EmbeddingServiceConfig;
+    archivist?: ArchivistServiceConfig;
+    [k: string]: unknown;
+}
+/**
+ * The Archivist service — the out-of-process keeper of the record (EXTRACT-ARCHIVIST). Internal-only: the gateway dials host:port for the D1 sequence-ranged event read path; nothing public.
+ *
+ * This interface was referenced by `HttpsSemiontOrgSchemasConfigJson`'s JSON-Schema
+ * via the `definition` "ArchivistServiceConfig".
+ */
+interface ArchivistServiceConfig {
+    platform?: ServicePlatformConfig;
+    host?: string;
+    port?: number;
+    image?: string;
     [k: string]: unknown;
 }
 /**
@@ -7875,7 +7572,7 @@ interface SiteConfig {
     /**
      * Primary domain for the site
      */
-    domain: string;
+    domain?: string;
     /**
      * Administrator email address
      */
@@ -7950,6 +7647,17 @@ interface EnvironmentConfig {
      * Environment name
      */
     name?: string;
+    /**
+     * The KB's committed identity, staged by the launcher (SINGLE-KB-MOUNT D4). Top-level in the staged file, out of any environment section's reach; never overridable.
+     */
+    kb?: {
+        name: string;
+        domain?: string;
+        /**
+         * Sign-in policy committed in the KB's .semiont/config, staged alongside the identity because the gateway no longer mounts the tree that holds it.
+         */
+        oauthAllowedDomains?: string[];
+    };
     platform?: {
         default?: PlatformType$1;
         [k: string]: unknown;
@@ -8142,11 +7850,16 @@ declare function getAllPlatformTypes(): PlatformType[];
  * and `@semiont/jobs` (the generation prompt builder) can share one derivation. `buildKnowledgeGraph`
  * — which queries the graph DB — stays in make-meaning; this only transforms an already-built graph.
  *
- * Reports the graph as-is (Option A): missing-view citers are kept (the citation edge reflects a real
- * reference event); the only filter is excluding the focal annotation from siblings (an annotation
- * isn't its own sibling). Peer connections are edges out of `mainResourceId`; citations and
- * `annotation-of` edges point INTO it. The graph is a projection of the event log (the system of
- * record), read here because it is the queryable projection at gather time.
+ * Reports the graph as-is (Option A): missing-view citers are kept (the citing annotation reflects a
+ * real reference event; its resource label falls back to the raw id). A citation is its linking
+ * ANNOTATION: an annotation node with `annotation-of` → the citing resource and `cites` → the focal
+ * resource — so citedBy resolves through that pair, deduped per citing resource (several citations
+ * from one document are one citer). Siblings are annotations ON the focal resource
+ * (`annotation-of` → main), excluding the focal annotation — an annotation isn't its own sibling,
+ * and a CITING annotation lives on another resource, so it never was one. Peer connections are
+ * edges out of `mainResourceId`; derivation is structural (endpoints), never a match on the
+ * free-form relationshipType. The graph is a projection of the event log (the system of record),
+ * read here because it is the queryable projection at gather time.
  */
 
 type KnowledgeGraph = components['schemas']['KnowledgeGraph'];
@@ -8171,8 +7884,8 @@ declare function deriveViews(graph: KnowledgeGraph, mainResourceId: string, foca
  *
  * Exists for startup-critical network calls in long-running peers (worker,
  * smelter, weaver): each authenticates against the KS the moment its
- * container starts, and the backend may not be reachable for a few seconds
- * (backend restart, container-network warm-up). Orchestration runs these
+ * container starts, and the gateway may not be reachable for a few seconds
+ * (gateway restart, container-network warm-up). Orchestration runs these
  * processes with `--rm` and no restart policy, so a process that dies on
  * the first `TypeError: fetch failed` is dead for good — the retry window
  * here is the only recovery it gets.
@@ -8195,7 +7908,7 @@ interface RetryAttemptInfo {
     error: unknown;
 }
 /**
- * Default policy for startup connections to the backend: 8 attempts with
+ * Default policy for startup connections to the gateway: 8 attempts with
  * delays 1s, 2s, 4s, then capped at 8s — ~39s of patience before giving up.
  */
 declare const STARTUP_FETCH_RETRY: RetryPolicy;
@@ -8203,7 +7916,7 @@ declare const STARTUP_FETCH_RETRY: RetryPolicy;
  * True for the errors `fetch` throws when the connection itself fails —
  * undici's `TypeError: fetch failed` (ECONNREFUSED, ENOTFOUND, reset,
  * timeout — the socket error rides in `cause`). Deliberately false for
- * HTTP-level failures (a 401 means the backend is UP and rejected us;
+ * HTTP-level failures (a 401 means the gateway is UP and rejected us;
  * retrying won't change its mind) and for programming errors.
  */
 declare function isTransientFetchError(error: unknown): boolean;
@@ -8281,5 +7994,5 @@ declare function getShardPath(key: string, numBuckets?: number): [string, string
  */
 declare const DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, anchorRuns, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, chunkText, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isGatheredContext, isGenerationJobParams, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, ChunkingConfig, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, ExtractionOutcome, FragmentSelector, FrontendServiceConfig, GatheredContext, GenerationJobParams, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, anchorRuns, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, chunkText, cloneFormat, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveStorageUri, deriveViews, didToAgent, email, entityType, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, folderOf, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotatable, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isGatheredContext, isGenerationJobParams, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, jumpConsistentHash, kbDid, loadTomlConfig, locate, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, proposeStoragePath, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, storageFileName, textExtractionOf, textUnder, userDID, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoredText, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, ArchivistServiceConfig, AssembledAnnotation, AuthCode, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, ChunkingConfig, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, ExtractionOutcome, FragmentSelector, GatewayServiceConfig, GatheredContext, GenerationJobParams, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IContentTransport, IGatewayOperations, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PdfTextItem, PdfTextRun, PersistedEvent, PersistedEventType, PlatformType, Point, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };