@semiont/sdk 0.5.4 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@semiont/sdk",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "description": "Semiont SDK — SemiontClient, namespaces, session/browser, state units, and the bus-request/cache helpers. Transport-agnostic; pair with @semiont/api-client (HttpTransport) or @semiont/make-meaning (LocalTransport) for the wire.",
   "type": "module",
   "main": "dist/index.js",
@@ -31,9 +31,9 @@
   "scripts": {
     "pretypecheck": "npm run build --workspace=@semiont/core --if-present && npm run build --workspace=@semiont/api-client --if-present",
     "typecheck": "tsc --noEmit",
-    "build": "npm run typecheck && tsup && tsc -p tsconfig.build.json",
+    "build": "npm run typecheck && tsup && tsc -p tsconfig.build.json && rollup -c rollup.dts.config.mjs && rm -rf dist-types",
     "watch": "tsup --watch",
-    "clean": "rm -rf dist",
+    "clean": "rm -rf dist dist-types",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage"
@@ -45,6 +45,8 @@
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.1.0",
+    "rollup": "^4.60.3",
+    "rollup-plugin-dts": "^6.4.1",
     "tsup": "^8.5.1",
     "typescript": "^6.0.2"
   },

package/dist/awaitable.d.ts

@@ -1,103 +0,0 @@
-/**
- * Thenable Observable subclasses.
- *
- * Two thin Observable subclasses that also implement `PromiseLike<T>`. Used as
- * the public return type of namespace methods that emit streams (job
- * lifecycle, generation progress) and cache reads (Browse live queries).
- *
- * The point: scripts can `await` the call directly without `lastValueFrom` /
- * `firstValueFrom` wrappers; reactive consumers keep using `.subscribe(...)`
- * and `.pipe(...)` exactly as before.
- *
- * The asymmetric `.then()` semantics — last-value-on-completion for streams,
- * first-non-undefined-value for caches — is encoded by the subclass name. The
- * docstring on the namespace method tells the consumer which one applies.
- *
- * `.pipe(...)` returns a plain `Observable<T>` (RxJS doesn't propagate
- * subclasses through `pipe`). Once you compose, you've explicitly entered
- * RxJS land; `lastValueFrom` from `rxjs` is the right bridge there.
- */
-import { Observable } from 'rxjs';
-import type { ResourceId } from '@semiont/core';
-/**
- * Bounded Observable stream — emits zero-or-more progress values, then a
- * final value on completion. Used by job-lifecycle methods like
- * `mark.assist`, `gather.annotation`, `match.search`, `yield.fromAnnotation`.
- *
- * Awaiting resolves to the **last** emitted value (via `lastValueFrom`).
- * Subscribing yields every emission, ending in `complete`.
- */
-export declare class StreamObservable<T> extends Observable<T> implements PromiseLike<T> {
-    then<R1 = T, R2 = never>(onfulfilled?: ((v: T) => R1 | PromiseLike<R1>) | null, onrejected?: ((e: unknown) => R2 | PromiseLike<R2>) | null): PromiseLike<R1 | R2>;
-    /** Wrap an existing Observable's subscribe behavior in a StreamObservable. */
-    static from<T>(source: Observable<T>): StreamObservable<T>;
-}
-/**
- * Multicast cache observable — emits `undefined` while the underlying value
- * is loading, then the value, then re-emits when bus events invalidate the
- * cache entry. Used by Browse live-query methods (`browse.resource`,
- * `browse.annotations`, etc.).
- *
- * Awaiting resolves to the **first non-undefined** value (waits past the
- * loading state). Subscribing yields the full sequence including the
- * initial `undefined`, so reactive consumers can render a loading state.
- *
- * The class is parameterized as `CacheObservable<T>` even though the
- * stream's element type is `T | undefined` — `T` is what the consumer
- * gets from `await`, and that's the contract we want to advertise. The
- * `Observable<T | undefined>` shape leaks through `.subscribe` and
- * `.pipe` in the natural way.
- */
-export declare class CacheObservable<T> extends Observable<T | undefined> implements PromiseLike<T> {
-    then<R1 = T, R2 = never>(onfulfilled?: ((v: T) => R1 | PromiseLike<R1>) | null, onrejected?: ((e: unknown) => R2 | PromiseLike<R2>) | null): PromiseLike<R1 | R2>;
-    /**
-     * Wrap an existing Observable's subscribe behavior in a `CacheObservable`.
-     *
-     * Memoizes on source identity: passing the same `source` returns the same
-     * wrapper instance. The Browse cache primitive already returns a stable
-     * Observable per key (its B4 contract), so this preserves that contract
-     * through the awaitable wrapping. Without the memo, every public-method
-     * call would produce a fresh wrapper and break referential-equality
-     * guarantees that hook-style reactive consumers depend on.
-     *
-     * Backed by a `WeakMap`, so wrappers are GC'd when their source is.
-     */
-    static from<T>(source: Observable<T | undefined>): CacheObservable<T>;
-}
-/**
- * Discriminated phases of an upload's lifecycle.
- *
- * - `started` — emitted immediately on `yield.resource(...)` invocation, before any bytes flow.
- * - `progress` — emitted as bytes flow over the wire. Wired by `HttpContentTransport`'s XHR path when a caller passes `onProgress` (or, transitively, when `yield.resource` is the caller — it always wires the hook so subscribers see byte counts). `bytesUploaded` and `totalBytes` carry the running counts; `totalBytes` may be 0 when the transport can't determine the total (rare, e.g. chunked encoding) — UI consumers should render an indeterminate state in that case.
- * - `finished` — emitted on backend acknowledgement, carries the assigned `resourceId`.
- *
- * Failures surface as `Observable.error(...)` (typically an `APIError` from the transport's `errors$` Subject), not as a `phase: 'failed'` event — `subscribe`'s error callback handles them. Cancellation is honored: unsubscribing before `finished` aborts the in-flight HTTP request on the XHR path.
- */
-export type UploadProgress = {
-    phase: 'started';
-    totalBytes: number;
-} | {
-    phase: 'progress';
-    bytesUploaded: number;
-    totalBytes: number;
-} | {
-    phase: 'finished';
-    resourceId: ResourceId;
-};
-/**
- * Specialized `StreamObservable` for `yield.resource`. Subscribers see the
- * full `UploadProgress` event sequence (started → optional progress → finished).
- * Awaiting resolves specifically to `{ resourceId }` extracted from the
- * `'finished'` event — preserving the pre-Phase-18 awaited shape so existing
- * `await client.yield.resource(...)` callers don't need to narrow the union.
- */
-export declare class UploadObservable extends Observable<UploadProgress> implements PromiseLike<{
-    resourceId: ResourceId;
-}> {
-    then<R1 = {
-        resourceId: ResourceId;
-    }, R2 = never>(onfulfilled?: ((v: {
-        resourceId: ResourceId;
-    }) => R1 | PromiseLike<R1>) | null, onrejected?: ((e: unknown) => R2 | PromiseLike<R2>) | null): PromiseLike<R1 | R2>;
-}
-//# sourceMappingURL=awaitable.d.ts.map

package/dist/awaitable.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"awaitable.d.ts","sourceRoot":"","sources":["../src/awaitable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAAE,UAAU,EAAiC,MAAM,MAAM,CAAC;AAEjE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;;;;GAOG;AACH,qBAAa,gBAAgB,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAC9E,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EACrB,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EACrD,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,GACzD,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;IAIvB,8EAA8E;IAC9E,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC;CAG3D;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,eAAe,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,GAAG,SAAS,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IACzF,IAAI,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,KAAK,EACrB,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EACrD,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,GACzD,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;IAKvB;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,GAAG,eAAe,CAAC,CAAC,CAAC;CAQtE;AAID;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,KAAK,EAAE,SAAS,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAChE;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;AAElD;;;;;;GAMG;AACH,qBAAa,gBAAiB,SAAQ,UAAU,CAAC,cAAc,CAAE,YAAW,WAAW,CAAC;IAAE,UAAU,EAAE,UAAU,CAAA;CAAE,CAAC;IACjH,IAAI,CAAC,EAAE,GAAG;QAAE,UAAU,EAAE,UAAU,CAAA;KAAE,EAAE,EAAE,GAAG,KAAK,EAC9C,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE;QAAE,UAAU,EAAE,UAAU,CAAA;KAAE,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAC9E,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,EAAE,GAAG,WAAW,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,GACzD,WAAW,CAAC,EAAE,GAAG,EAAE,CAAC;CASxB"}

package/dist/bus-request.d.ts

@@ -1,18 +0,0 @@
-import { Observable } from 'rxjs';
-import { SemiontError, type EventMap } from '@semiont/core';
-export type BusRequestErrorCode = 'bus.timeout' | 'bus.rejected' | 'bus.bad-payload' | 'bus.unauthorized' | 'bus.forbidden' | 'bus.not-found';
-export declare class BusRequestError extends SemiontError {
-    code: BusRequestErrorCode;
-    constructor(message: string, code: BusRequestErrorCode, details?: Record<string, unknown>);
-}
-/**
- * Subset of ITransport that `busRequest` needs: a way to send a command and
- * a way to observe channels. Generic enough that an in-process transport
- * can satisfy it without round-tripping through HTTP.
- */
-export interface BusRequestPrimitive {
-    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K]): Promise<void>;
-    stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
-}
-export declare function busRequest<TResult>(bus: BusRequestPrimitive, emitChannel: string, payload: Record<string, unknown>, resultChannel: string, failureChannel: string, timeoutMs?: number): Promise<TResult>;
-//# sourceMappingURL=bus-request.d.ts.map

package/dist/bus-request.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bus-request.d.ts","sourceRoot":"","sources":["../src/bus-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAmD,MAAM,MAAM,CAAC;AAEnF,OAAO,EAAE,YAAY,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE5D,MAAM,MAAM,mBAAmB,GAC3B,aAAa,GACb,cAAc,GACd,iBAAiB,GACjB,kBAAkB,GAClB,eAAe,GACf,eAAe,CAAC;AAEpB,qBAAa,eAAgB,SAAQ,YAAY;IACvC,IAAI,EAAE,mBAAmB,CAAC;gBAEtB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAI1F;AAED;;;;GAIG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAChF,MAAM,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,OAAO,EAAE,CAAC,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;CACvE;AAED,wBAAsB,UAAU,CAAC,OAAO,EACtC,GAAG,EAAE,mBAAmB,EACxB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,EACtB,SAAS,SAAS,GACjB,OAAO,CAAC,OAAO,CAAC,CA+ClB"}

package/dist/cache.d.ts

@@ -1,57 +0,0 @@
-/**
- * RxJS-native read-through cache primitive.
- *
- * Behavioral contract: packages/sdk/docs/CACHE-SEMANTICS.md (B1–B13).
- *
- * Framework-agnostic: no React, no dependency on any namespace. Used by
- * `BrowseNamespace` to back its per-key stores, but equally usable from
- * CLI, MCP, or worker code.
- *
- * Shape:
- *   - `observe(key)`: returns an Observable<V | undefined> that triggers
- *     a fetch on first subscription for a missing key, dedup-joins any
- *     concurrent fetch, and emits the stored value thereafter.
- *   - `invalidate(key)`: stale-while-revalidate — keeps the current
- *     value visible to observers, clears the in-flight guard, starts a
- *     fresh fetch. If the previous fetch was orphaned (SSE torn down,
- *     response lost), this is how the cache recovers.
- *   - `remove(key)`: drops the cache entry entirely. Used for entity
- *     deletions (B13a). No refetch.
- *   - `set(key, value)`: writes through without a fetch. Used when a
- *     bus event carries the new value inline (B13b).
- *   - `invalidateAll()`: per-key SWR refetch of every currently-cached
- *     entry. Used by gap-detection paths.
- *   - `dispose()`: completes the store so observers unsubscribe.
- *
- * What's deliberately out:
- *   - No subscriber ref-counting / GC of unobserved keys. The per-key
- *     observable memo grows with the set of observed keys for the cache's
- *     lifetime (B11). Acceptable given cache lifetime == client lifetime.
- *   - No TTL / cacheTime. Entries are evicted only by explicit remove.
- *   - No retry / backoff. A failing fetch leaves the cache unchanged
- *     (B6); the caller drives retry via invalidate.
- */
-import { Observable } from 'rxjs';
-export interface Cache<K, V> {
-    /** Observable stream of the value at `key`. Triggers a fetch if not cached. */
-    observe(key: K): Observable<V | undefined>;
-    /** Synchronous snapshot of the current value, without triggering a fetch. */
-    get(key: K): V | undefined;
-    /** Iterator of currently-cached keys. For invalidateAll and diagnostics. */
-    keys(): K[];
-    /**
-     * Mark the entry stale and refetch. Keeps the previous value visible
-     * to observers during the refetch (stale-while-revalidate).
-     */
-    invalidate(key: K): void;
-    /** Drop the entry from the cache. No refetch. */
-    remove(key: K): void;
-    /** Write-through: set the value directly without a fetch. */
-    set(key: K, value: V): void;
-    /** Per-key SWR refetch of every currently-cached entry. */
-    invalidateAll(): void;
-    /** Release the underlying subject. Observers complete. */
-    dispose(): void;
-}
-export declare function createCache<K, V>(fetchFn: (key: K) => Promise<V>): Cache<K, V>;
-//# sourceMappingURL=cache.d.ts.map

package/dist/cache.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../src/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,OAAO,EAAmB,UAAU,EAA6B,MAAM,MAAM,CAAC;AAE9E,MAAM,WAAW,KAAK,CAAC,CAAC,EAAE,CAAC;IACzB,+EAA+E;IAC/E,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;IAE3C,6EAA6E;IAC7E,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;IAE3B,4EAA4E;IAC5E,IAAI,IAAI,CAAC,EAAE,CAAC;IAEZ;;;OAGG;IACH,UAAU,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;IAEzB,iDAAiD;IACjD,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;IAErB,6DAA6D;IAC7D,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAE5B,2DAA2D;IAC3D,aAAa,IAAI,IAAI,CAAC;IAEtB,0DAA0D;IAC1D,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CA0F9E"}

package/dist/client.d.ts

@@ -1,138 +0,0 @@
-/**
- * SemiontClient — the verb-oriented namespace surface.
- *
- * Thin coordinator over an injected transport pair. Owns a local
- * `EventBus` (`bus`) for UI-signal channels and bridges wire events into
- * it via `transport.bridgeInto(bus)`. Namespaces receive `(transport,
- * bus)` (and `content` for binary-I/O namespaces) and choose internally
- * whether each method goes over the wire or stays local.
- *
- * No public `emit`/`on`/`stream` shortcuts: consumers call typed
- * namespace methods. The single sanctioned channel-by-name escape hatch
- * is `SemiontSession.subscribe(channel, handler)`, which reads from
- * `client.bus`.
- */
-import type { ResourceId, BaseUrl, AccessToken } from '@semiont/core';
-import { EventBus } from '@semiont/core';
-import { BrowseNamespace } from './namespaces/browse';
-import { MarkNamespace } from './namespaces/mark';
-import { BindNamespace } from './namespaces/bind';
-import { GatherNamespace } from './namespaces/gather';
-import { MatchNamespace } from './namespaces/match';
-import { YieldNamespace } from './namespaces/yield';
-import { BeckonNamespace } from './namespaces/beckon';
-import { FrameNamespace } from './namespaces/frame';
-import { JobNamespace } from './namespaces/job';
-import { AuthNamespace } from './namespaces/auth';
-import { AdminNamespace } from './namespaces/admin';
-import type { IBackendOperations, IContentTransport, ITransport } from '@semiont/core';
-export { APIError, type TokenRefresher, HttpTransport, type HttpTransportConfig, HttpContentTransport, } from '@semiont/api-client';
-export declare class SemiontClient {
-    /**
-     * The wire-facing transport. Owns bus actor, HTTP, auth, admin, exchange,
-     * system. Exposed for advanced consumers (workers, custom job adapters)
-     * that need raw `transport.emit(channel, payload, scope)` access. Ordinary
-     * consumers go through typed namespace methods.
-     */
-    readonly transport: ITransport;
-    /** Binary I/O transport. */
-    private readonly content;
-    /**
-     * Per-client local EventBus. Wire events flow in via the transport
-     * bridge. Read-only public so `SemiontSession.subscribe(channel, …)`
-     * can wire arbitrary-channel subscriptions; everything else uses
-     * typed namespace methods.
-     */
-    readonly bus: EventBus;
-    readonly baseUrl: BaseUrl;
-    readonly frame: FrameNamespace;
-    readonly browse: BrowseNamespace;
-    readonly mark: MarkNamespace;
-    readonly bind: BindNamespace;
-    readonly gather: GatherNamespace;
-    readonly match: MatchNamespace;
-    readonly yield: YieldNamespace;
-    readonly beckon: BeckonNamespace;
-    readonly job: JobNamespace;
-    readonly auth: AuthNamespace | undefined;
-    readonly admin: AdminNamespace | undefined;
-    /**
-     * The client *owns* its bus. The constructor creates a fresh `EventBus`
-     * and hands it to the transport via `transport.bridgeInto(this.bus)`.
-     * The reference flows client → transport, never the other way:
-     * the transport stores the reference and publishes the events it
-     * receives onto that bus. `HttpTransport` does so for every channel
-     * delivered on its SSE wire; in-process transports adapt their
-     * internal source.
-     *
-     * Callers do not pass a bus in. If they need to interact with the bus
-     * (e.g. for tests or to subscribe to arbitrary channels), they read it
-     * back via `client.bus`.
-     *
-     * `backend` is optional. When provided, the `auth` and `admin`
-     * namespaces are constructed against it; when omitted, they're
-     * `undefined`. For HTTP setups this is conventionally the same
-     * `HttpTransport` instance that's also passed as `transport` (HTTP
-     * implements both `ITransport` and `IBackendOperations`).
-     */
-    constructor(transport: ITransport, content: IContentTransport, backend?: IBackendOperations);
-    /** Transport-level connection state. HTTP reflects SSE health; local is always 'connected'. */
-    get state$(): import("rxjs").Observable<import("@semiont/core").ConnectionState>;
-    subscribeToResource(resourceId: ResourceId): () => void;
-    dispose(): void;
-    /**
-     * Convenience factory for the default HTTP setup. Constructs a
-     * `BehaviorSubject<AccessToken | null>` internally, plus an
-     * `HttpTransport` and `HttpContentTransport`, and returns the wired
-     * `SemiontClient`.
-     *
-     * Use this for one-shot scripts, CLI commands, or any consumer that
-     * doesn't need to drive the token from outside (no manual refresh,
-     * no cross-tab sync). For long-running scripts that need refresh,
-     * use `SemiontSession.fromHttp(...)` (with a token already on hand)
-     * or `SemiontSession.signInHttp(...)` (credentials-first) instead —
-     * either owns the same transport/client wiring plus the
-     * proactive-refresh + storage machinery.
-     *
-     * Strings are accepted for `baseUrl` and `token`; they are branded
-     * via `baseUrl()` / `accessToken()` from `@semiont/core` automatically.
-     * Pass the already-branded values if you have them.
-     *
-     * Omit `token` for unauthenticated usage (public endpoints only).
-     */
-    static fromHttp(opts: {
-        baseUrl: BaseUrl | string;
-        token?: AccessToken | string | null;
-    }): SemiontClient;
-    /**
-     * Async factory for the credentials-first script case. Builds a
-     * transient HTTP transport, calls `auth.password(email, password)`
-     * to acquire an access token, and returns the wired client with
-     * the token populated.
-     *
-     * This is the right entry point for skills, CLI scripts, and any
-     * consumer that starts with email + password rather than a JWT
-     * already on hand. For consumers that already hold a token (CLI
-     * cached-token path, env-var token, embedded auth flow), use
-     * `fromHttp({ baseUrl, token })` instead.
-     *
-     * For long-running scripts that need refresh, use
-     * `SemiontSession.signInHttp(...)` — same credentials shape, plus
-     * the session machinery for proactive refresh and persistence.
-     *
-     * Named `signInHttp` because email+password authentication is
-     * inherently an HTTP-shaped operation in the current backend; an
-     * in-process `LocalTransport` doesn't have a credentials login
-     * path. Non-HTTP transports construct the client directly from
-     * their package's transport instance.
-     *
-     * Throws if authentication fails. The transient client is disposed
-     * before the throw, so no resources leak on failure.
-     */
-    static signInHttp(opts: {
-        baseUrl: BaseUrl | string;
-        email: string;
-        password: string;
-    }): Promise<SemiontClient>;
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAwB,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAevF,OAAO,EACL,QAAQ,EACR,KAAK,cAAc,EACnB,aAAa,EACb,KAAK,mBAAmB,EACxB,oBAAoB,GACrB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,aAAa;IACxB;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,UAAU,CAAC;IAC/B,4BAA4B;IAC5B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAW1B,SAAgB,KAAK,EAAE,cAAc,CAAC;IACtC,SAAgB,MAAM,EAAE,eAAe,CAAC;IACxC,SAAgB,IAAI,EAAE,aAAa,CAAC;IACpC,SAAgB,IAAI,EAAE,aAAa,CAAC;IACpC,SAAgB,MAAM,EAAE,eAAe,CAAC;IACxC,SAAgB,KAAK,EAAE,cAAc,CAAC;IACtC,SAAgB,KAAK,EAAE,cAAc,CAAC;IACtC,SAAgB,MAAM,EAAE,eAAe,CAAC;IACxC,SAAgB,GAAG,EAAE,YAAY,CAAC;IAClC,SAAgB,IAAI,EAAE,aAAa,GAAG,SAAS,CAAC;IAChD,SAAgB,KAAK,EAAE,cAAc,GAAG,SAAS,CAAC;IAElD;;;;;;;;;;;;;;;;;;OAkBG;gBACS,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,iBAAiB,EAAE,OAAO,CAAC,EAAE,kBAAkB;IAqB3F,+FAA+F;IAC/F,IAAI,MAAM,uEAET;IAED,mBAAmB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,IAAI;IAIvD,OAAO,IAAI,IAAI;IAKf;;;;;;;;;;;;;;;;;;;OAmBG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACpB,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;QAC1B,KAAK,CAAC,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAAC;KACrC,GAAG,aAAa;IAajB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACU,UAAU,CAAC,IAAI,EAAE;QAC5B,OAAO,EAAE,OAAO,GAAG,MAAM,CAAC;QAC1B,KAAK,EAAE,MAAM,CAAC;QACd,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,aAAa,CAAC;CAgB3B"}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAGH,cAAc,UAAU,CAAC;AAIzB,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAGvG,OAAO,EACL,UAAU,EACV,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,mBAAmB,oBAAoB,CAAC;AAMxC,YAAY,EACV,MAAM,EAEN,WAAW,EACX,YAAY,EACZ,OAAO,EACP,YAAY,EACZ,UAAU,EACV,MAAM,EAEN,UAAU,EACV,QAAQ,EACR,aAAa,EACb,UAAU,EACV,QAAQ,EACR,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,SAAS,EAET,eAAe,EACf,iBAAiB,EACjB,UAAU,GACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,WAAW,EACX,YAAY,EACZ,OAAO,EACP,UAAU,EACV,YAAY,EACZ,UAAU,EACV,MAAM,EAEN,YAAY,GACb,MAAM,eAAe,CAAC;AAIvB,OAAO,EAAE,cAAc,EAAE,KAAK,oBAAoB,EAAE,KAAK,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AACrG,OAAO,EAAE,cAAc,EAAE,KAAK,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACtF,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AACvF,OAAO,EAAE,wBAAwB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,KAAK,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AACxE,OAAO,EACL,KAAK,cAAc,EACnB,sBAAsB,GACvB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,UAAU,EACf,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,MAAM,GACP,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,EACL,eAAe,EACf,eAAe,EACf,YAAY,EACZ,gBAAgB,EAChB,KAAK,aAAa,GACnB,MAAM,mBAAmB,CAAC;AAK3B,cAAc,SAAS,CAAC;AAOxB,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC"}

package/dist/namespaces/admin.d.ts

@@ -1,27 +0,0 @@
-/**
- * AdminNamespace — administration. Backend ops only; no bus.
- */
-import type { UserDID, ProgressEvent, components, paths } from '@semiont/core';
-import type { BackendDownload, IBackendOperations } from '@semiont/core';
-import { StreamObservable } from '../awaitable';
-import type { AdminNamespace as IAdminNamespace, User, RequestContent, ResponseContent } from './types';
-type AdminUserStatsResponse = components['schemas']['AdminUserStatsResponse'];
-type OAuthConfigResponse = components['schemas']['OAuthConfigResponse'];
-export declare class AdminNamespace implements IAdminNamespace {
-    private readonly backend;
-    constructor(backend: IBackendOperations);
-    users(): Promise<User[]>;
-    userStats(): Promise<AdminUserStatsResponse>;
-    updateUser(userId: UserDID, data: RequestContent<paths['/api/admin/users/{id}']['patch']>): Promise<User>;
-    oauthConfig(): Promise<OAuthConfigResponse>;
-    healthCheck(): Promise<ResponseContent<paths['/api/health']['get']>>;
-    status(): Promise<ResponseContent<paths['/api/status']['get']>>;
-    backup(): Promise<BackendDownload>;
-    restore(file: File): StreamObservable<ProgressEvent>;
-    exportKnowledgeBase(params?: {
-        includeArchived?: boolean;
-    }): Promise<BackendDownload>;
-    importKnowledgeBase(file: File): StreamObservable<ProgressEvent>;
-}
-export {};
-//# sourceMappingURL=admin.d.ts.map

package/dist/namespaces/admin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"admin.d.ts","sourceRoot":"","sources":["../../src/namespaces/admin.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,KAAK,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACzE,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,cAAc,IAAI,eAAe,EAAE,IAAI,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAExG,KAAK,sBAAsB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,wBAAwB,CAAC,CAAC;AAC9E,KAAK,mBAAmB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,qBAAqB,CAAC,CAAC;AAExE,qBAAa,cAAe,YAAW,eAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,kBAAkB;IAElD,KAAK,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;IAKxB,SAAS,IAAI,OAAO,CAAC,sBAAsB,CAAC;IAI5C,UAAU,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,cAAc,CAAC,KAAK,CAAC,uBAAuB,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAKzG,WAAW,IAAI,OAAO,CAAC,mBAAmB,CAAC;IAI3C,WAAW,IAAI,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAIpE,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAI/D,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC;IAIxC,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAAC,aAAa,CAAC;IAI9C,mBAAmB,CAAC,MAAM,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,eAAe,CAAC;IAI3F,mBAAmB,CAAC,IAAI,EAAE,IAAI,GAAG,gBAAgB,CAAC,aAAa,CAAC;CAGjE"}

package/dist/namespaces/auth.d.ts

@@ -1,26 +0,0 @@
-/**
- * AuthNamespace — authentication. Backend ops only; no bus.
- */
-import type { ResourceId, components } from '@semiont/core';
-import type { IBackendOperations } from '@semiont/core';
-import type { AuthNamespace as IAuthNamespace, User } from './types';
-type AuthResponse = components['schemas']['AuthResponse'];
-type TokenRefreshResponse = components['schemas']['TokenRefreshResponse'];
-export declare class AuthNamespace implements IAuthNamespace {
-    private readonly backend;
-    constructor(backend: IBackendOperations);
-    password(emailStr: string, passwordStr: string): Promise<AuthResponse>;
-    google(credential: string): Promise<AuthResponse>;
-    refresh(token: string): Promise<TokenRefreshResponse>;
-    logout(): Promise<void>;
-    me(): Promise<User>;
-    acceptTerms(): Promise<void>;
-    mcpToken(): Promise<{
-        token: string;
-    }>;
-    mediaToken(resourceId: ResourceId): Promise<{
-        token: string;
-    }>;
-}
-export {};
-//# sourceMappingURL=auth.d.ts.map

package/dist/namespaces/auth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../src/namespaces/auth.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAE5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,KAAK,EAAE,aAAa,IAAI,cAAc,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAErE,KAAK,YAAY,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,cAAc,CAAC,CAAC;AAC1D,KAAK,oBAAoB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,sBAAsB,CAAC,CAAC;AAE1E,qBAAa,aAAc,YAAW,cAAc;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,kBAAkB;IAElD,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAItE,MAAM,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAIjD,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAIrD,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAIvB,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAInB,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,QAAQ,IAAI,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAItC,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;CAGrE"}

package/dist/namespaces/beckon.d.ts

@@ -1,12 +0,0 @@
-import type { AnnotationId, EventBus, ResourceId } from '@semiont/core';
-import type { ITransport } from '@semiont/core';
-import type { BeckonNamespace as IBeckonNamespace } from './types';
-export declare class BeckonNamespace implements IBeckonNamespace {
-    private readonly transport;
-    private readonly bus;
-    constructor(transport: ITransport, bus: EventBus);
-    attention(resourceId: ResourceId, annotationId: AnnotationId): void;
-    hover(annotationId: AnnotationId | null): void;
-    sparkle(annotationId: AnnotationId): void;
-}
-//# sourceMappingURL=beckon.d.ts.map

package/dist/namespaces/beckon.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"beckon.d.ts","sourceRoot":"","sources":["../../src/namespaces/beckon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEnE,qBAAa,eAAgB,YAAW,gBAAgB;IAEpD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;gBADH,SAAS,EAAE,UAAU,EACrB,GAAG,EAAE,QAAQ;IAGhC,SAAS,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI;IAInE,KAAK,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI;IAK9C,OAAO,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI;CAG1C"}

package/dist/namespaces/bind.d.ts

@@ -1,11 +0,0 @@
-import type { ResourceId, AnnotationId, BodyOperation, EventBus, EventMap } from '@semiont/core';
-import type { ITransport } from '@semiont/core';
-import type { BindNamespace as IBindNamespace } from './types';
-export declare class BindNamespace implements IBindNamespace {
-    private readonly transport;
-    private readonly bus;
-    constructor(transport: ITransport, bus: EventBus);
-    body(resourceId: ResourceId, annotationId: AnnotationId, operations: BodyOperation[]): Promise<void>;
-    initiate(input: EventMap['bind:initiate']): void;
-}
-//# sourceMappingURL=bind.d.ts.map

package/dist/namespaces/bind.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bind.d.ts","sourceRoot":"","sources":["../../src/namespaces/bind.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,aAAa,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACjG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,aAAa,IAAI,cAAc,EAAE,MAAM,SAAS,CAAC;AAE/D,qBAAa,aAAc,YAAW,cAAc;IAEhD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,GAAG;gBADH,SAAS,EAAE,UAAU,EACrB,GAAG,EAAE,QAAQ;IAG1B,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1G,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,IAAI;CAIjD"}

package/dist/namespaces/browse.d.ts

@@ -1,111 +0,0 @@
-import { CacheObservable } from '../awaitable';
-import type { Annotation, EventBus, ResourceDescriptor, ResourceId, AnnotationId, GraphConnection, Motivation, TagSchema, components } from '@semiont/core';
-import type { ITransport, IContentTransport } from '@semiont/core';
-import type { BrowseNamespace as IBrowseNamespace, ReferencedByEntry, AnnotationHistoryResponse } from './types';
-type StoredEventResponse = components['schemas']['StoredEventResponse'];
-type ResourceListFilters = {
-    limit?: number;
-    archived?: boolean;
-    search?: string;
-};
-export declare class BrowseNamespace implements IBrowseNamespace {
-    private readonly transport;
-    private readonly bus;
-    private readonly content;
-    private readonly resourceCache;
-    private readonly resourceListCache;
-    private readonly annotationListCache;
-    /**
-     * Annotation-detail cache keyed by `annotationId` only — the resourceId
-     * is a routing hint for the backend fetch, not an identity component.
-     * We track the most recent resourceId per annotationId in a side-map
-     * so `mark:delete-ok` (which carries only `annotationId`) can reach
-     * the right cache entry. Aligns with the pre-refactor semantics.
-     */
-    private readonly annotationDetailCache;
-    private readonly annotationResources;
-    private readonly entityTypesCache;
-    private readonly tagSchemasCache;
-    private readonly referencedByCache;
-    private readonly resourceEventsCache;
-    /** Filter-blob memory so `invalidateResourceLists` can replay per-key. */
-    private readonly resourceListFilters;
-    /**
-     * Per-key memo for `annotations()` observables. The cache stores the
-     * full `AnnotationsListResponse`; the public shape is just the inner
-     * `Annotation[]`. Without this memo, every call to `annotations(rId)`
-     * would produce a fresh `.pipe(map(...))` observable, violating B4
-     * (per-key observable stability). Consumers that compare observable
-     * identity — React hooks depending on the observable reference,
-     * `distinctUntilChanged` at a higher level — would misbehave.
-     */
-    private readonly annotationListObs;
-    constructor(transport: ITransport, bus: EventBus, content: IContentTransport);
-    resource(resourceId: ResourceId): CacheObservable<ResourceDescriptor>;
-    resources(filters?: ResourceListFilters): CacheObservable<ResourceDescriptor[]>;
-    annotations(resourceId: ResourceId): CacheObservable<Annotation[]>;
-    annotation(resourceId: ResourceId, annotationId: AnnotationId): CacheObservable<Annotation>;
-    entityTypes(): CacheObservable<string[]>;
-    tagSchemas(): CacheObservable<TagSchema[]>;
-    referencedBy(resourceId: ResourceId): CacheObservable<ReferencedByEntry[]>;
-    events(resourceId: ResourceId): CacheObservable<StoredEventResponse[]>;
-    resourceContent(resourceId: ResourceId): Promise<string>;
-    resourceRepresentation(resourceId: ResourceId, options?: {
-        accept?: string;
-    }): Promise<{
-        data: ArrayBuffer;
-        contentType: string;
-    }>;
-    resourceRepresentationStream(resourceId: ResourceId, options?: {
-        accept?: string;
-    }): Promise<{
-        stream: ReadableStream<Uint8Array>;
-        contentType: string;
-    }>;
-    resourceEvents(resourceId: ResourceId): Promise<StoredEventResponse[]>;
-    annotationHistory(resourceId: ResourceId, annotationId: AnnotationId): Promise<AnnotationHistoryResponse>;
-    connections(_resourceId: ResourceId): Promise<GraphConnection[]>;
-    backlinks(_resourceId: ResourceId): Promise<Annotation[]>;
-    resourcesByName(_query: string, _limit?: number): Promise<ResourceDescriptor[]>;
-    files(dirPath?: string, sort?: 'name' | 'mtime' | 'annotationCount'): Promise<components['schemas']['BrowseFilesResponse']>;
-    click(annotationId: AnnotationId, motivation: Motivation): void;
-    navigateReference(resourceId: ResourceId): void;
-    invalidateAnnotationList(resourceId: ResourceId): void;
-    removeAnnotationDetail(annotationId: AnnotationId): void;
-    invalidateResourceDetail(id: ResourceId): void;
-    invalidateResourceLists(): void;
-    invalidateEntityTypes(): void;
-    invalidateTagSchemas(): void;
-    invalidateReferencedBy(resourceId: ResourceId): void;
-    invalidateResourceEvents(resourceId: ResourceId): void;
-    updateAnnotationInPlace(resourceId: ResourceId, annotation: Annotation): void;
-    /**
-     * Typed shorthand for `eventBus.get(channel).subscribe(handler)`.
-     * Preserves per-channel payload typing so handlers read
-     * `EventMap[K]` without any casts.
-     */
-    private on;
-    /**
-     * Handler shared by `mark:entity-tag-added` and `mark:entity-tag-removed`.
-     * Both events carry the same effect: the annotation list, the
-     * resource descriptor, and the event log for that resource all may
-     * now reflect different entity tagging, so invalidate all three.
-     */
-    private onEntityTagChanged;
-    /**
-     * Handler shared by `mark:archived` and `mark:unarchived`. Both
-     * change a resource's archived flag, which is stored on the resource
-     * descriptor and affects the resource-list filter.
-     */
-    private onArchiveToggled;
-    /**
-     * Handler shared by `yield:create-ok` and `yield:update-ok`. Both
-     * report a resource mutation with the resourceId as a string (not
-     * yet branded), so we brand and apply the same effect as
-     * `onArchiveToggled`.
-     */
-    private onYieldResourceMutated;
-    private subscribeToEvents;
-}
-export {};
-//# sourceMappingURL=browse.d.ts.map

package/dist/namespaces/browse.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"browse.d.ts","sourceRoot":"","sources":["../../src/namespaces/browse.ts"],"names":[],"mappings":"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"}

package/dist/namespaces/frame.d.ts

@@ -1,29 +0,0 @@
-/**
- * FrameNamespace — the eighth flow's surface.
- *
- * Frame operates on the KB's **schema layer** — the conceptual vocabulary
- * the other seven flows are expressed in. Where yield/mark/match/bind/
- * gather/browse/beckon act on content (resources, annotations, references,
- * attention), Frame acts on what *kinds* of things exist: entity types,
- * eventually tag schemas, relation/predicate types, ontology imports.
- *
- * The MVP owns a single primitive — entity-type vocabulary writes on the
- * `frame:add-entity-type` channel. See `docs/protocol/flows/FRAME.md`
- * for the per-flow contract.
- *
- * Live reads of the entity-type vocabulary stay on Browse
- * (`browse.entityTypes()` is a `CacheObservable<string[]>`). Frame owns
- * writes; Browse owns reads. The asymmetry is intentional — re-implementing
- * Browse's cache primitives on Frame for a single read would duplicate
- * machinery without benefit.
- */
-import type { ITransport, TagSchema } from '@semiont/core';
-import type { FrameNamespace as IFrameNamespace } from './types';
-export declare class FrameNamespace implements IFrameNamespace {
-    private readonly transport;
-    constructor(transport: ITransport);
-    addEntityType(type: string): Promise<void>;
-    addEntityTypes(types: string[]): Promise<void>;
-    addTagSchema(schema: TagSchema): Promise<void>;
-}
-//# sourceMappingURL=frame.d.ts.map

package/dist/namespaces/frame.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../src/namespaces/frame.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC3D,OAAO,KAAK,EAAE,cAAc,IAAI,eAAe,EAAE,MAAM,SAAS,CAAC;AAEjE,qBAAa,cAAe,YAAW,eAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS;gBAAT,SAAS,EAAE,UAAU;IAE5C,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1C,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAM9C,YAAY,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;CAGrD"}