@semiont/core 0.5.21 → 0.5.23

package/dist/index.d.ts

@@ -1265,32 +1265,28 @@ interface paths {
             path?: never;
             cookie?: never;
         };
+        get?: never;
+        put?: never;
         /**
          * Subscribe to the Semiont event bus (SSE)
-         * @description Opens a long-lived Server-Sent Events stream over which the bus delivers events matching the requested channels and scopes.
+         * @description Opens a long-lived Server-Sent Events stream over which the bus delivers events matching the requested subscription matrix. The JSON body names unscoped `global` channels plus any number of `scoped` entries — one per resource scope — so a single connection can hold live subscriptions to many resources at once (MULTI-RESOURCE-SCOPE).
          *
-         *     Each SSE frame has `event: bus-event`, a JSON-encoded `data` of the form `{ channel, payload, scope? }`, and an `id` (either a persisted event id, `scope:seq`, for domain events; or an ephemeral id for job-lifecycle / result channels).
+         *     Each SSE frame has `event: bus-event`, a JSON-encoded `data` of the form `{ channel, payload, scope? }` (scoped events carry their originating scope), and an `id` (a persisted event id `p-<scope>-<seq>` for domain events; an ephemeral `e-*` id for job-lifecycle / correlated-reply channels).
          *
-         *     Pass the last-received id as `Last-Event-ID` to resume — the server replays missed persisted events and emits a `bus:resume-gap` synthetic event when the gap exceeds the replay window.
+         *     Resumption is per scope: pass each scope's last-received persisted id as `lastEventId` on its scoped entry — the server replays that scope's missed persisted events and emits a scoped `bus:resume-gap` synthetic event when the gap cannot be covered.
          */
-        get: {
+        post: {
             parameters: {
-                query?: {
-                    /** @description Unscoped channels to subscribe to. Repeat the parameter for multiple channels. At least one of `channel` or `scoped` is required. */
-                    channel?: string[];
-                    /** @description Resource-scoped channels to subscribe to (requires `scope`). Repeat for multiple. */
-                    scoped?: string[];
-                    /** @description Resource scope for scoped channels (typically a resourceId). */
-                    scope?: string;
-                };
-                header?: {
-                    /** @description Id of the last event the client received. On reconnect, the server replays persisted events after this id and emits `bus:resume-gap` if the gap exceeds the replay cap. */
-                    "Last-Event-ID"?: string;
-                };
+                query?: never;
+                header?: never;
                 path?: never;
                 cookie?: never;
             };
-            requestBody?: never;
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["BusSubscribeRequest"];
+                };
+            };
             responses: {
                 /** @description SSE stream opened */
                 200: {
@@ -1301,7 +1297,7 @@ interface paths {
                         "text/event-stream": components["schemas"]["EventStreamResponse"];
                     };
                 };
-                /** @description No channels requested (at least one `channel` or `scoped` parameter required) */
+                /** @description Malformed body, no channels requested, duplicate scopes, malformed scoped entry, or scope count above the per-connection cap */
                 400: {
                     headers: {
                         [name: string]: unknown;
@@ -1321,8 +1317,6 @@ interface paths {
                 };
             };
         };
-        put?: never;
-        post?: never;
         delete?: never;
         options?: never;
         head?: never;
@@ -2124,6 +2118,22 @@ interface components {
             /** @description Optional resource scope for broadcast channels (e.g. resourceId). Publishers only — frontends 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. */
+        BusSubscribeRequest: {
+            /** @description Unscoped channels to subscribe to. */
+            global?: string[];
+            /** @description Correlation ids of busRequest replies this client still awaits (BUS-RESUMPTION Phase 2). The server replays any matching replies from its bounded retention buffer (TTL 60s) as normal frames with their deterministic `e-<channel>:<cid>` ids, so a reply that ALSO arrived live dedups client-side. At most 256 entries. */
+            pendingReplies?: string[];
+            /** @description Per-resource-scope subscriptions. Scopes must be unique across entries. */
+            scoped?: {
+                /** @description Resource scope (a resourceId). */
+                scope: string;
+                /** @description Channels to subscribe within this scope. */
+                channels: string[];
+                /** @description This scope's last-seen persisted event id (`p-<scope>-<seq>`). The server replays this scope's persisted events after it before joining the live tail, and emits a scoped `bus:resume-gap` when it cannot cover the gap (unparseable or mismatched id, retention exceeded, or query error). */
+                lastEventId?: string;
+            }[];
+        };
         CloneResourceWithTokenResponse: {
             /** @description Generated clone token */
             token: string;
@@ -2243,8 +2253,8 @@ interface components {
             placement: "local" | "codespace";
             /** @description owner/name GitHub slug — present for codespace placements, where the repo is the stack's identity */
             repo?: string;
-            /** @description The KB's did:web identifier as recorded from its committed .semiont/config — the permanent identity stamped into its event log. Prefer this as a merge key: ports are reallocated across restarts; the did follows the KB. */
-            did?: string;
+            /** @description The KB's did:web identifier, from its committed .semiont/config — "did:web:" + the [site] domain, verbatim. REQUIRED: a KB that declares no domain has no identity to publish, and the launcher refuses to start it rather than inventing or defaulting one. NOT unique within a document: a did names the knowledge base, not a running copy of it, so a local clone and a codespace of the same repo legitimately share one and both are published. host:port is the unique field (at most one entry per address), so consumers look up by ADDRESS and use the did to VERIFY that the copy they reached is the KB they meant — an address alone cannot say which KB is which, and an identity alone cannot say which copy. */
+            did: string;
             /** @description Human-readable site name from the KB's .semiont/config, for display */
             siteName?: string;
             /** @description The agent that owns this entry's lifecycle (the launcher writes "semiont-launcher"). Consumers treat managed entries as authoritative for themselves — upsert on appearance, remove on disappearance — and never touch entries they did not write. */
@@ -3251,6 +3261,8 @@ 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. */
+            did: string;
         };
         /** @description A persisted domain event with metadata. Flat shape — event fields and metadata are peers. */
         StoredEventResponse: {
@@ -5387,8 +5399,9 @@ interface ITransport {
      * SDK-internal: this is the scope primitive the SDK's resource-scoped
      * `browse.*` live queries drive on subscribe/teardown (freshness follows
      * observation; #847) — it is not part of the application-facing surface.
-     * Single-scope at a time; multi-scope is deferred
-     * (`.plans/MULTI-RESOURCE-SCOPE.md`).
+     * Distinct resources COMPOSE (`.plans/MULTI-RESOURCE-SCOPE.md`): each
+     * resource's subscriptions are ref-counted independently, and one client
+     * may hold many resource scopes at once on its single connection.
      */
     subscribeToResource(resourceId: ResourceId): () => void;
     /**
@@ -5404,8 +5417,24 @@ interface ITransport {
      * Transport-level connection state. For HTTP, reflects the SSE
      * connection's health; for in-process transports, typically `'open'`
      * from construction onward (no connection to lose).
+     *
+     * Load-bearing beyond UI: `busRequest` gates its emit on this
+     * (`BusRequestPrimitive.state$`, .plans/BUS-ATTACH-GATE.md) — no
+     * correlated emit before the reply path exists. Implementers back it
+     * with a `BehaviorSubject` so the current state arrives synchronously
+     * on subscribe.
      */
     readonly state$: Observable<ConnectionState>;
+    /**
+     * Correlated-reply retention, client side (BUS-RESUMPTION Phase 2 /
+     * SDK-DEBT S1). `busRequest` registers its correlationId here before
+     * emitting and releases on settle; a wire transport includes the
+     * tracked set as `pendingReplies` on each subscribe body so a reply
+     * published while the connection was down replays from the server's
+     * retention buffer. OPTIONAL: in-process transports that cannot lose
+     * replies omit it.
+     */
+    trackReply?(correlationId: string): () => void;
     /**
      * Stream of transport-level errors surfaced from typed-wire methods or
      * other transport-mediated round-trips, just before they're thrown to
@@ -5534,6 +5563,33 @@ interface IContentTransport {
     dispose(): void;
 }
 
+/**
+ * BUS_OPERATIONS — the request/reply operations registry (Tier 1).
+ *
+ * Each entry declares ONE operation as the triple that was previously three
+ * loose, independently-maintained facts spread across call sites:
+ *   - the request channel (the key — an `EmittableChannel`),
+ *   - the `result` channel (success reply),
+ *   - the `failure` channel,
+ *   - and, for a streaming op, an optional `progress` channel.
+ *
+ * `BridgedChannel` / `BRIDGED_CHANNELS` are DERIVED from this map
+ * (bridged-channels.ts): every reply lands in the bridged fan-in set by
+ * construction, so "a reply channel forgotten from BRIDGED_CHANNELS" — the
+ * recurring bug class (gather:resource-complete, frame:*-add-failed) — is no
+ * longer representable. See .plans/BUS-OPERATIONS-REGISTRY.md.
+ *
+ * `Partial<Record<EmittableChannel, …>>` enforces that every key is a real
+ * emittable request. `result`/`failure`/`progress` stay `EventName` rather than
+ * `BridgedChannel` to avoid a circular reference (BridgedChannel derives from
+ * this map); the derivation closes the loop instead.
+ */
+interface BusOperationSpec {
+    result: EventName;
+    failure: EventName;
+    /** Streaming ops only: an intermediate channel that also bridges. */
+    progress?: EventName;
+}
 declare const BUS_OPERATIONS: {
     readonly 'bind:update-body': {
         readonly result: "bind:body-updated";
@@ -5742,6 +5798,26 @@ declare class BusRequestError extends SemiontError {
 interface BusRequestPrimitive {
     emit<K extends keyof EventMap>(channel: K, payload: EventMap[K]): Promise<void>;
     stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
+    /**
+     * Connection state of the stream that carries replies. Required, not
+     * optional (.plans/BUS-ATTACH-GATE.md D2): `busRequest` gates its emit on
+     * this — no correlated emit before the reply path exists. Implementers back
+     * it with a `BehaviorSubject`, so the current state arrives synchronously
+     * on subscribe; a transport that cannot lose replies (in-process) reports
+     * `'open'` until disposal.
+     */
+    state$: Observable<ConnectionState>;
+    /**
+     * Correlated-reply retention, client side (.plans/BUS-RESUMPTION.md
+     * Phase 2 / SDK-DEBT S1). `busRequest` registers its correlationId here
+     * BEFORE emitting and calls the returned disposer on every settle path;
+     * a wire transport includes the currently-tracked ids as
+     * `pendingReplies` in each subscribe body, so a reply published while
+     * the connection was down is replayed from the server's retention
+     * buffer on reconnect. OPTIONAL: an in-process transport that cannot
+     * lose replies omits the surface and `busRequest` behaves as before.
+     */
+    trackReply?(correlationId: string): () => void;
 }
 /**
  * Request/reply over the bus, keyed by the operation's request channel.
@@ -6503,8 +6579,12 @@ declare function isDefined<T>(value: T | null | undefined): value is T;
  *
  * DID:WEB shapes used in Semiont:
  *
- *   Person:   did:web:<host>:users:<email%40host>
- *   Software: did:web:<host>:agents:<provider>:<model>
+ *   Knowledge base: did:web:<domain>
+ *   Person:         did:web:<domain>:users:<email%40host>
+ *   Software:       did:web:<domain>:agents:<provider>:<model>
+ *
+ * `<domain>` is the KB's committed `[site] domain` — one identity, with its
+ * people and software peers named beneath it.
  *
  * `didToAgent` is the inverse: parse the DID, recognize whether the
  * subject is a person or a software peer, and return a typed Agent.
@@ -6516,6 +6596,23 @@ declare function isDefined<T>(value: T | null | undefined): value is T;
  */
 
 type Agent = components['schemas']['Agent'];
+/**
+ * The knowledge base's own did:web identity, from its committed
+ * `[site] domain` (`SemiontProject.siteDomain()`).
+ *
+ * Format: `did:web:<domain>` — the domain **verbatim, never encoded**. The
+ * config already stores it in did:web colon-path form
+ * (`the-ai-alliance.github.io:semiont-caselaw-kb`), so encoding those colons
+ * would mint a string nothing else in the system produces. The launcher
+ * mints the identical string in Go (`kbconfig.go` `didWeb()`), and the two
+ * MUST agree byte-for-byte: the Browser joins discovered KBs to connected
+ * ones on this value, and a mismatch fails silently — looking implemented
+ * while never matching (.plans/KB-IDENTITY-VS-ADDRESS.md).
+ *
+ * A KB has no did when it declares no domain; identity is declared, never
+ * defaulted or inferred from an address.
+ */
+declare function kbDid(domain: string): string;
 /**
  * Convert a user object to a DID:WEB identifier.
  *
@@ -7178,18 +7275,19 @@ type TomlFileReader = {
  * Parse ~/.semiontconfig and .semiont/config and return EnvironmentConfig.
  *
  * @param projectRoot - Path to the project root (contains .semiont/config)
- * @param environment - Environment name (e.g. 'local', 'production')
+ * @param environment - Environment name (e.g. 'local', 'production'); when
+ *   undefined, resolved from SEMIONT_ENV, then `[defaults] environment`
  * @param globalConfigPath - Path to ~/.semiontconfig (caller resolves ~ expansion)
  * @param reader - File reader abstraction
  * @param env - Environment variables for ${VAR} resolution
  */
-declare function loadTomlConfig(projectRoot: string | null, environment: string, globalConfigPath: string, reader: TomlFileReader, env: Record<string, string | undefined>): EnvironmentConfig;
+declare function loadTomlConfig(projectRoot: string | null, environment: string | undefined, globalConfigPath: string, reader: TomlFileReader, env: Record<string, string | undefined>): EnvironmentConfig;
 /**
  * Create a TOML config loader backed by a file reader.
  * Drop-in replacement for createConfigLoader that reads TOML instead of JSON.
  * The caller must resolve globalConfigPath (e.g. expand '~' using process.env.HOME).
  */
-declare function createTomlConfigLoader(reader: TomlFileReader, globalConfigPath: string, env: Record<string, string | undefined>): (projectRoot: string | null, environment: string) => EnvironmentConfig;
+declare function createTomlConfigLoader(reader: TomlFileReader, globalConfigPath: string, env: Record<string, string | undefined>): (projectRoot: string | null, environment?: string) => EnvironmentConfig;
 
 /**
  * Environment validation utilities
@@ -7349,5 +7447,5 @@ declare function retryWithBackoff<T>(fn: () => Promise<T>, isRetryable: (error:
  */
 declare const DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
-export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusRequestErrorCode, BusRequestPrimitive, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, FragmentSelector, FrontendServiceConfig, GatheredContext, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, kbDid, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export type { AccessToken, AnchorConfidence, AnchorMethod, AnchorRect, AnchorSelectors, AnchorStrategy, AnchoringModel, Annotation, AnnotationCategory, AnnotationId, AnnotationUri, AnthropicProviderConfig, AppConfig, AssembledAnnotation, AuthCode, BackendDownload, BackendServiceConfig, BaseUrl, BodyItem, BodyItemIdentity, BodyOperation, BoundingBox, Brand, BridgedChannel, BurstBufferOptions, BusOp, BusOperationKey, BusOperationSpec, BusRequestErrorCode, BusRequestPrimitive, CloneToken, CollaboratorEntry, ConnectionState, ContentCache, ContentFormat, CreateAnnotationInternal, DatabaseServiceConfig, DiscoveredKB, DiscoveryDocument, Email, EmbeddingServiceConfig, EmittableChannel, EntityType, EntityTypeStats, Environment, EnvironmentConfig, EventBase, EventInput, EventMap, EventMetadata, EventName, EventOfType, EventQuery, EventSignature, FragmentSelector, FrontendServiceConfig, GatheredContext, GoogleAuthRequest, GoogleCredential, GraphConnection, GraphDatabaseType, GraphPath, GraphServiceConfig, GraphViews, HealthCheckResponse, IBackendOperations, IContentTransport, ITransport, InferenceProvidersConfig, JobId, JobType, ListUsersResponse, LlmSelectorInput, LocaleInfo, Logger, MCPToken, MatchQuality, McpServiceConfig, MediaTypeCapabilities, Motivation, OllamaProviderConfig, PdfCoordinate, PersistedEvent, PersistedEventType, PlatformType, Point, ProgressCallback, ProgressEvent, PutBinaryOptions, PutBinaryProgress, PutBinaryRequest, ReconciledSelector, RefreshToken, RenderMode, RenderedAnchor, ResourceAnnotationUri, ResourceAnnotations, ResourceBroadcastType, ResourceDescriptor, ResourceFilter, ResourceId, ResourceUri, RetryAttemptInfo, RetryPolicy, SearchQuery, SelectionData, Selector, SemiontConfig, ServicePlatformConfig, ServicesConfig, SiteConfig, StateUnit, StatusResponse, StoredEvent, StoredEventLike, SupportedMediaType, SvgSelector, TagCategory, TagSchema, TextExtraction, TextPosition, TextPositionSelector, TextQuoteSelector, ActorInferenceConfig as TomlActorInferenceConfig, TomlFileReader, InferenceConfig as TomlInferenceConfig, WorkerInferenceConfig as TomlWorkerInferenceConfig, TransportErrorCode, UpdateResourceInput, UpdateUserRequest, UpdateUserResponse, UserDID, UserId, UserResponse, ValidationFailure, ValidationResult, ValidationSuccess, VectorsServiceConfig, components, operations, paths };

package/dist/index.js

@@ -1223,18 +1223,69 @@ async function busRequest(bus, operation, payload, timeoutMs = 3e4) {
     })
   );
   const resultPromise = firstValueFrom(result$);
-  try {
-    await bus.emit(operation, fullPayload);
-  } catch (emitError) {
+  const closedBeforeEmit = () => {
     resultPromise.catch(() => {
     });
-    throw emitError;
+    return new BusRequestError(`Bus closed before emit on ${operation}`, "bus.closed", {
+      channel: operation,
+      correlationId
+    });
+  };
+  let currentState;
+  bus.state$.subscribe((s) => {
+    currentState = s;
+  }).unsubscribe();
+  if (currentState === "closed") {
+    throw closedBeforeEmit();
+  }
+  let emitAllowed = currentState === "open";
+  if (!emitAllowed) {
+    const gate = firstValueFrom(
+      bus.state$.pipe(
+        filter((s) => s === "open" || s === "closed"),
+        take(1),
+        // `state$` completed without ever attaching: treat as closed.
+        defaultIfEmpty("closed")
+      )
+    );
+    const outcome = await Promise.race([
+      gate,
+      // Either settlement of the reply machinery means "stop waiting, never
+      // emit": its timeout rejecting `bus.timeout` at `timeoutMs` (the same
+      // moment it would fire today — D4), or its streams completing into the
+      // `bus.closed` default above. The shared tail below carries it.
+      resultPromise.then(
+        () => "settled",
+        () => "settled"
+      )
+    ]);
+    if (outcome === "closed") {
+      throw closedBeforeEmit();
+    }
+    emitAllowed = outcome === "open";
   }
-  const result = await resultPromise;
-  if (!result.ok) {
-    throw result.error;
+  let releaseTracking;
+  if (emitAllowed) {
+    releaseTracking = bus.trackReply?.(correlationId);
+    try {
+      await bus.emit(operation, fullPayload);
+    } catch (emitError) {
+      releaseTracking?.();
+      releaseTracking = void 0;
+      resultPromise.catch(() => {
+      });
+      throw emitError;
+    }
+  }
+  try {
+    const result = await resultPromise;
+    if (!result.ok) {
+      throw result.error;
+    }
+    return result.response;
+  } finally {
+    releaseTracking?.();
   }
-  return result.response;
 }
 
 // src/fuzzy-anchor.ts
@@ -2002,6 +2053,9 @@ function isDefined(value) {
 }
 
 // src/did-utils.ts
+function kbDid(domain) {
+  return `did:web:${domain}`;
+}
 function userToDid(user) {
   return `did:web:${user.domain}:users:${encodeURIComponent(user.email)}`;
 }
@@ -2103,20 +2157,27 @@ function requirePlatform(value, serviceName) {
 }
 function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env) {
   const projectConfigContent = projectRoot ? reader.readIfExists(`${projectRoot}/.semiont/config`) : null;
-  let projectName = "semiont-project";
-  let projectVersion;
-  let projectSite;
-  let projectEnvSection = {};
-  if (projectConfigContent) {
-    const projectConfig = parse(projectConfigContent);
-    projectName = projectConfig.project?.name ?? projectName;
-    projectVersion = projectConfig.project?.version;
-    projectSite = projectConfig.site;
-    projectEnvSection = projectConfig.environments?.[environment] ?? {};
-  }
+  const projectConfig = projectConfigContent ? parse(projectConfigContent) : void 0;
+  const projectName = projectConfig?.project?.name ?? "semiont-project";
+  const projectVersion = projectConfig?.project?.version;
+  const projectSite = projectConfig?.site;
   const globalContent = reader.readIfExists(globalConfigPath);
   const raw = globalContent ? parse(globalContent) : {};
-  const userEnvSection = raw.environments?.[environment] ?? {};
+  const resolvedEnvironment = environment ?? env.SEMIONT_ENV ?? raw.defaults?.environment;
+  if (!resolvedEnvironment) {
+    throw new Error(
+      "No environment selected: pass one explicitly, set SEMIONT_ENV, or declare `[defaults] environment` in ~/.semiontconfig."
+    );
+  }
+  const projectHasSection = projectConfig?.environments != null && resolvedEnvironment in projectConfig.environments;
+  const globalHasSection = raw.environments != null && resolvedEnvironment in raw.environments;
+  if (!projectHasSection && !globalHasSection) {
+    throw new Error(
+      `Environment "${resolvedEnvironment}" is selected but no [environments.${resolvedEnvironment}] section exists in the project (.semiont/config) or global (~/.semiontconfig) config. Declare the section, or select an environment that exists.`
+    );
+  }
+  const projectEnvSection = projectConfig?.environments?.[resolvedEnvironment] ?? {};
+  const userEnvSection = raw.environments?.[resolvedEnvironment] ?? {};
   const envSection = deepMerge(
     projectEnvSection,
     userEnvSection
@@ -2139,7 +2200,7 @@ function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env)
       } else {
         if (!flatInference.type) {
           throw new Error(
-            `[environments.${environment}.inference] is missing 'type'. Add type = "anthropic" or use [inference.anthropic] sub-section.`
+            `[environments.${resolvedEnvironment}.inference] is missing 'type'. Add type = "anthropic" or use [inference.anthropic] sub-section.`
           );
         }
         providerDefaults.apiKey = flatInference.apiKey;
@@ -2152,7 +2213,7 @@ function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env)
       } else {
         if (!flatInference.type) {
           throw new Error(
-            `[environments.${environment}.inference] is missing 'type'. Add type = "ollama" or use [inference.ollama] sub-section.`
+            `[environments.${resolvedEnvironment}.inference] is missing 'type'. Add type = "ollama" or use [inference.ollama] sub-section.`
           );
         }
         providerDefaults.baseURL = flatInference.baseURL;
@@ -2318,7 +2379,7 @@ function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env)
     } : void 0,
     logLevel: resolved.logLevel,
     _metadata: {
-      environment,
+      environment: resolvedEnvironment,
       projectRoot,
       projectName,
       projectVersion,
@@ -2462,6 +2523,6 @@ async function retryWithBackoff(fn, isRetryable, policy, onRetry) {
 // src/discovery.ts
 var DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, email, entityType, errField, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, kbDid, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map