@semiont/make-meaning 0.5.2 → 0.5.4

package/dist/index.d.ts

@@ -1,1240 +1,37 @@
-import { JobQueue } from '@semiont/jobs';
-import { SemiontProject } from '@semiont/core/node';
-import { GraphServiceConfig, VectorsServiceConfig, EmbeddingServiceConfig, EventBus, Logger, StoredEvent, ResourceId, ResourceDescriptor, AnnotationId, components, ITransport, BaseUrl, ConnectionState, SemiontError, UserDID, EventMap, IContentTransport, PutBinaryRequest, PutBinaryOptions, ContentFormat as ContentFormat$1, AccessToken, Annotation, UserId, CreationMethod, ResourceAnnotations, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
-export { AssembledAnnotation, applyBodyOperations, assembleAnnotation } from '@semiont/core';
-import { EventStore, ViewStorage } from '@semiont/event-sourcing';
-import { WorkingTreeStore } from '@semiont/content';
-import { GraphDatabase } from '@semiont/graph';
-import { VectorStore, EmbeddingProvider } from '@semiont/vectors';
-import { InferenceClient } from '@semiont/inference';
-import { BehaviorSubject, Observable } from 'rxjs';
-import { StateUnit, WorkerBus } from '@semiont/sdk';
-import { Writable, Readable } from 'node:stream';
-
-/**
- * Inference configuration for a single actor or worker.
- */
-interface InferenceConfig {
-    type: 'anthropic' | 'ollama';
-    model: string;
-    maxTokens?: number;
-    apiKey?: string;
-    endpoint?: string;
-    baseURL?: string;
-}
-/**
- * Per-actor inference overrides.
- * Stower never calls an LLM, so it has no entry here.
- */
-interface ActorInferenceConfig {
-    gatherer?: InferenceConfig;
-    matcher?: InferenceConfig;
-}
-/**
- * Per-worker-type inference overrides.
- * Falls back to `workers.default` if a specific worker is not listed.
- */
-interface WorkerInferenceConfig {
-    default?: InferenceConfig;
-    'reference-annotation'?: InferenceConfig;
-    'highlight-annotation'?: InferenceConfig;
-    'assessment-annotation'?: InferenceConfig;
-    'comment-annotation'?: InferenceConfig;
-    'tag-annotation'?: InferenceConfig;
-    'generation'?: InferenceConfig;
-}
-/** Narrow config type — only the fields make-meaning actually reads */
-interface MakeMeaningConfig {
-    services: {
-        graph?: GraphServiceConfig;
-        vectors?: VectorsServiceConfig;
-        embedding?: EmbeddingServiceConfig;
-    };
-    /** Per-actor inference config */
-    actors?: ActorInferenceConfig;
-    /** Per-worker-type inference config */
-    workers?: WorkerInferenceConfig;
-}
-
-/**
- * GraphDB Consumer
- *
- * Subscribes to resource events and updates GraphDB accordingly.
- * Makes GraphDB a projection of Event Store events (single source of truth).
- *
- * Uses an RxJS pipeline with adaptive burst buffering:
- *   - First event after idle passes through immediately (zero latency)
- *   - Subsequent events in a burst are batched and flushed together
- *   - After idle, returns to passthrough mode
- *
- * Per-resource ordering is preserved via groupBy(resourceId) + concatMap.
- * Cross-resource parallelism is provided via mergeMap over groups.
- *
- * Burst buffer thresholds (see BATCH-GRAPH-CONSUMER-RX.md for tuning guidance):
- *   BURST_WINDOW_MS  = 50   — debounce window before flushing a batch
- *   MAX_BATCH_SIZE   = 500  — force flush to bound memory
- *   IDLE_TIMEOUT_MS  = 200  — silence before returning to passthrough
- *
- * ## Per-resource serialization
- *
- * `groupBy(resourceId) + concatMap(...)` is the stream-consumer flavor of
- * per-resource serialization — the same invariant enforced by `Smelter`,
- * `Gatherer`, and (in a different shape) `ViewManager`. See
- * `packages/core/src/serialize-per-key.ts` for the shared primitive used
- * by RPC-style services.
- */
-
-declare class GraphDBConsumer {
-    private eventStore;
-    private graphDb;
-    private coreEventBus;
-    private static readonly GRAPH_RELEVANT_EVENTS;
-    private static readonly BURST_WINDOW_MS;
-    private static readonly MAX_BATCH_SIZE;
-    private static readonly IDLE_TIMEOUT_MS;
-    private _globalSubscriptions;
-    private eventSubject;
-    private pipelineSubscription;
-    private lastProcessed;
-    private readonly logger;
-    constructor(eventStore: EventStore, graphDb: GraphDatabase, coreEventBus: EventBus, logger: Logger);
-    initialize(): Promise<void>;
-    /**
-     * Subscribe globally to ALL events, pre-filter to graph-relevant types,
-     * and wire through the RxJS burst-buffered pipeline.
-     */
-    private subscribeToGlobalEvents;
-    /**
-     * Wrap applyEventToGraph in try/catch so one failed event doesn't kill the pipeline.
-     */
-    private safeApplyEvent;
-    private ensureInitialized;
-    /**
-     * Stop the consumer, flush remaining buffered events, and unsubscribe.
-     */
-    stop(): Promise<void>;
-    /**
-     * Process a batch of events for the same resource.
-     * Partitions into consecutive same-type runs for batch optimization.
-     */
-    private processBatch;
-    /**
-     * Batch-optimized processing for consecutive events of the same type.
-     * Uses batch graph methods where available, falls back to sequential.
-     */
-    private applyBatchByType;
-    /**
-     * Build a ResourceDescriptor from a resource.created event.
-     * Extracted for reuse by both applyEventToGraph and applyBatchByType.
-     */
-    private buildResourceDescriptor;
-    /**
-     * Apply a single event to GraphDB.
-     */
-    protected applyEventToGraph(storedEvent: StoredEvent): Promise<void>;
-    /**
-     * Rebuild entire resource from events.
-     * Bypasses the live pipeline — reads directly from event store.
-     */
-    rebuildResource(resourceId: ResourceId): Promise<void>;
-    /**
-     * Rebuild entire GraphDB from all events.
-     * Uses two-pass approach to ensure all resources exist before creating REFERENCES edges.
-     * Bypasses the live pipeline — reads directly from event store.
-     */
-    rebuildAll(): Promise<void>;
-    /**
-     * Get consumer health metrics.
-     */
-    getHealthMetrics(): {
-        subscriptions: number;
-        lastProcessed: Record<string, number>;
-        pipelineActive: boolean;
-    };
-    /**
-     * Shutdown consumer.
-     */
-    shutdown(): Promise<void>;
-}
-
-/**
- * Knowledge Base
- *
- * The durable store that records what intelligent actors decide.
- * Groups the KB subsystems from ARCHITECTURE.md:
- *
- * - Event Log (immutable append-only) — via EventStore
- * - Materialized Views (fast single-doc queries) — via ViewStorage
- * - Content Store (working-tree files, URI-addressed) — via WorkingTreeStore
- * - Graph (eventually consistent relationship projection) — via GraphDatabase
- * - Graph Consumer (event-to-graph projection) — via GraphDBConsumer
- * - Vectors (semantic search) — via VectorStore (optional, read-only)
- *
- * The Smelter (event-to-vector projection) runs as an external actor
- * via @semiont/make-meaning/smelter-main. It subscribes to domain events
- * via the EventBus gateway, embeds content, and writes to Qdrant directly.
- */
-
-interface KnowledgeBase {
-    eventStore: EventStore;
-    views: ViewStorage;
-    content: WorkingTreeStore;
-    graph: GraphDatabase;
-    graphConsumer: GraphDBConsumer;
-    vectors?: VectorStore;
-    projectionsDir: string;
-}
-interface CreateKnowledgeBaseOptions {
-    vectorStore?: VectorStore;
-    skipRebuild?: boolean;
-}
-declare function createKnowledgeBase(eventStore: EventStore, project: SemiontProject, graphDb: GraphDatabase, eventBus: EventBus, logger: Logger, options?: CreateKnowledgeBaseOptions): Promise<KnowledgeBase>;
-
-/**
- * Stower Actor
- *
- * The single write gateway to the Knowledge Base. Subscribes to command
- * events on the EventBus and translates them into domain events on the
- * EventStore + content writes to the RepresentationStore.
- *
- * From ARCHITECTURE.md:
- * The Knowledge Base has exactly three actor interfaces:
- * - Stower (write) — this actor
- * - Gatherer (read context)
- * - Matcher (read search)
- *
- * No other code should call eventStore.appendEvent() or repStore.store().
- *
- * Subscriptions:
- * - yield:create       → resource.created (+ content store)   → yield:created / yield:create-failed
- * - yield:update       → resource.updated (+ content store)   → yield:updated / yield:update-failed
- * - yield:mv           → resource.moved (+ working tree move) → yield:moved / yield:move-failed
- * - mark:create        → annotation.added                     → mark:created / mark:create-failed
- * - mark:delete        → annotation.removed                   → mark:deleted / mark:delete-failed
- * - mark:update-body   → annotation.body.updated              → (no result event yet)
- * - mark:archive       → resource.archived (+ file removal)   (resource-scoped, no result event)
- * - mark:unarchive     → resource.unarchived                  (resource-scoped, no result event)
- * - frame:add-entity-type → entitytype.added                   → frame:entity-type-added / frame:entity-type-add-failed
- * - mark:update-entity-types → entitytag.added / entitytag.removed
- * - job:start          → job.started
- * - job:complete       → job.completed
- * - job:fail           → job.failed
- *
- * Note: `job:report-progress` is intentionally NOT persisted. Progress
- * events are ephemeral UI feedback and would clutter the event log
- * (historical logs show ~3× as many progress entries as start+complete
- * combined). UI consumers subscribe to the bus directly for live
- * progress; the event log keeps only the durable lifecycle boundaries.
- */
-
-interface CreateResourceResult {
-    resourceId: ResourceId;
-    resource: ResourceDescriptor;
-}
-declare class Stower {
-    private kb;
-    private eventBus;
-    private subscription;
-    private readonly logger;
-    constructor(kb: KnowledgeBase, eventBus: EventBus, logger: Logger);
-    initialize(): Promise<void>;
-    private handleYieldCreate;
-    private handleYieldUpdate;
-    private handleYieldMv;
-    private handleMarkCreate;
-    private handleMarkDelete;
-    private handleMarkUpdateBody;
-    private handleMarkArchive;
-    private handleMarkUnarchive;
-    private handleAddEntityType;
-    private handleUpdateEntityTypes;
-    private handleJobStart;
-    private handleJobComplete;
-    private handleJobFail;
-    stop(): Promise<void>;
-}
-
-/**
- * Gatherer Actor
- *
- * LLM context assembly for the Knowledge System. Subscribes to gather events,
- * queries KB stores via context modules, and emits results back to the bus.
- *
- * From ARCHITECTURE.md:
- * "When a Generator Agent or Linker Agent emits a gather event, the Gatherer
- * receives it from the bus, queries the relevant KB stores, and assembles
- * the context needed for downstream work."
- *
- * Handles:
- * - gather:requested — annotation-level LLM context assembly
- * - gather:resource-requested — resource-level LLM context assembly
- *
- * RxJS pipeline uses groupBy(resourceId) + concatMap for per-resource isolation.
- *
- * ## Per-resource serialization
- *
- * `groupBy(resourceId) + concatMap(...)` is the stream-consumer flavor of
- * per-resource serialization — the same invariant enforced by `Smelter`,
- * `GraphDBConsumer`, and (in a different shape) `ViewManager`. See
- * `packages/core/src/serialize-per-key.ts` for the shared primitive used
- * by RPC-style services.
- */
-
-declare class Gatherer$1 {
-    private kb;
-    private eventBus;
-    private inferenceClient;
-    private embeddingProvider?;
-    private subscriptions;
-    private readonly logger;
-    constructor(kb: KnowledgeBase, eventBus: EventBus, inferenceClient: InferenceClient, logger: Logger, embeddingProvider?: EmbeddingProvider | undefined);
-    initialize(): Promise<void>;
-    private handleAnnotationGather;
-    private handleResourceGather;
-    generateAnnotationSummary(annotationId: AnnotationId, resourceId: ResourceId): Promise<components['schemas']['ContextualSummaryResponse']>;
-    stop(): Promise<void>;
-}
-
-/**
- * Matcher Actor
- *
- * Candidate search for the bind flow. Subscribes to match:search-requested,
- * queries the KB graph for matching resources, scores them, and emits results.
- *
- * Handles:
- * - match:search-requested — multi-source retrieval + composite scoring
- *
- * The write side (annotation.body.updated) stays in the route where userId
- * is available from auth context.
- */
-
-declare class Matcher {
-    private kb;
-    private eventBus;
-    private inferenceClient;
-    private embeddingProvider?;
-    private subscriptions;
-    private readonly logger;
-    constructor(kb: KnowledgeBase, eventBus: EventBus, logger: Logger, inferenceClient: InferenceClient, embeddingProvider?: EmbeddingProvider | undefined);
-    initialize(): Promise<void>;
-    private handleSearch;
-    /**
-     * Context-driven search: multi-source retrieval + composite scoring
-     *
-     * Retrieval sources:
-     * 1. Name match — graph.searchResources(searchTerm)
-     * 2. Entity type match — graph.listResources({ entityTypes })
-     * 3. Graph neighborhood — connections from GatheredContext
-     *
-     * Ranking signals:
-     * - Entity type overlap (Jaccard similarity)
-     * - Bidirectionality (already connected both ways)
-     * - Citation weight (well-connected = important)
-     * - Name match quality (exact > prefix > contains)
-     * - Recency (newer resources scored higher)
-     */
-    private contextDrivenSearch;
-    /**
-     * LLM-based semantic relevance scoring (GraphRAG-style)
-     *
-     * Batches candidates into a single prompt asking the LLM to score
-     * each candidate's semantic relevance given the passage and graph context.
-     *
-     * @returns Map of resourceId → score (0-1)
-     */
-    private inferenceSemanticScore;
-    /**
-     * Search vectors for semantically similar resources.
-     * Returns empty array if vectors or embedding provider are not configured.
-     */
-    private searchVectors;
-    stop(): Promise<void>;
-}
-
-/**
- * Browser Actor
- *
- * Filesystem-shaped reads and KB graph reads for the Knowledge System.
- * Merges live filesystem state with KB metadata for tracked resources.
- *
- * Handles:
- * - browse:resource-requested — single resource metadata (materialized from events)
- * - browse:resources-requested — list resources
- * - browse:annotations-requested — all annotations for a resource
- * - browse:annotation-requested — single annotation with resolved resource
- * - browse:events-requested — resource event history
- * - browse:annotation-history-requested — annotation event history
- * - browse:referenced-by-requested — find annotations in the KB graph that reference a resource
- * - browse:entity-types-requested — list entity types from the project projection
- * - browse:directory-requested — list a project directory, merging fs + ViewStorage
- */
-
-declare class Browser {
-    private views;
-    private kb;
-    private eventBus;
-    private project;
-    private subscriptions;
-    private readonly logger;
-    constructor(views: ViewStorage, kb: KnowledgeBase, eventBus: EventBus, project: SemiontProject, logger: Logger);
-    initialize(): Promise<void>;
-    private handleBrowseResource;
-    private handleBrowseResources;
-    private handleBrowseAnnotations;
-    private handleBrowseAnnotation;
-    private handleBrowseEvents;
-    private handleBrowseAnnotationHistory;
-    private handleReferencedBy;
-    private handleEntityTypes;
-    private handleBrowseDirectory;
-    stop(): Promise<void>;
-}
-
-/**
- * Clone Token Manager
- *
- * Reactive actor that handles clone token operations via the EventBus.
- * Manages an in-memory token store for resource cloning workflows.
- *
- * Handles:
- * - yield:clone-token-requested — generate a clone token for a resource
- * - yield:clone-resource-requested — look up a resource by clone token
- * - yield:clone-create — create a new resource from a clone token
- *
- * From COMPLETE-EVENT-PROTOCOL.md:
- * "Clone tokens produce new resources — that's yield."
- */
-
-declare class CloneTokenManager {
-    private kb;
-    private eventBus;
-    private subscriptions;
-    private readonly logger;
-    private readonly tokens;
-    constructor(kb: KnowledgeBase, eventBus: EventBus, logger: Logger);
-    initialize(): Promise<void>;
-    private handleGenerateToken;
-    private handleGetResource;
-    private handleCreateResource;
-    stop(): Promise<void>;
-}
-
-/**
- * Knowledge System
- *
- * Binds the KnowledgeBase to the actors that provide disciplined access to it.
- * Nothing outside the KnowledgeSystem reads or writes the KnowledgeBase directly.
- *
- * - kb:                the durable store (event log, views, content, graph)
- * - stower:            write actor — weaves new knowledge in
- * - gatherer:          read actor — traces threads to build context
- * - matcher:           search actor — finds related threads
- * - browser:           filesystem actor — lists project directories
- * - cloneTokenManager: token actor — manages resource clone tokens
- *
- * EventBus, JobQueue, and workers are peers to KnowledgeSystem, not members.
- */
-
-interface KnowledgeSystem {
-    kb: KnowledgeBase;
-    stower: Stower;
-    gatherer: Gatherer$1;
-    matcher: Matcher;
-    browser: Browser;
-    cloneTokenManager: CloneTokenManager;
-    stop: () => Promise<void>;
-}
-declare function stopKnowledgeSystem(ks: KnowledgeSystem): Promise<void>;
-
-/**
- * Make-Meaning Service
- *
- * Provides a clean interface:
- *   const makeMeaning = await startMakeMeaning(project, config, eventBus, logger);
- */
-
-interface MakeMeaningService {
-    knowledgeSystem: KnowledgeSystem;
-    jobQueue: JobQueue;
-    stop: () => Promise<void>;
-}
-declare function startMakeMeaning(project: SemiontProject, config: MakeMeaningConfig, eventBus: EventBus, logger: Logger, options?: {
-    skipRebuild?: boolean;
-}): Promise<MakeMeaningService>;
-
-/**
- * LocalTransport — `ITransport` for an in-process `KnowledgeSystem`.
- *
- * Bus-ownership pattern (see `docs/protocol/TRANSPORT-CONTRACT.md`):
- *   - The caller owns a make-meaning `EventBus` and passes it to both
- *     `startMakeMeaning` and `LocalTransport` so the transport can publish
- *     directly onto the bus the `KnowledgeSystem` actors are listening on.
- *   - `SemiontClient` constructs its own `clientBus` and calls
- *     `bridgeInto(clientBus)` during construction. `LocalTransport`
- *     subscribes to every `BRIDGED_CHANNELS` entry on the make-meaning bus
- *     and forwards each onto `clientBus`.
- *   - The bus reference flows client → transport, never the other way.
- *
- * LocalTransport implements `ITransport` only. Auth, admin, and exchange
- * (`IBackendOperations`) are HTTP-shaped concepts that don't apply
- * in-process — local mode runs as a single host-process identity supplied
- * at construction, with no token/credential lifecycle. A `SemiontClient`
- * built over this transport has no `.auth` / `.admin` namespaces.
- */
-
-interface LocalTransportConfig {
-    /**
-     * The in-process knowledge system. Lifetime is owned by the caller —
-     * `dispose()` on this transport does not stop the KnowledgeSystem.
-     */
-    knowledgeSystem: KnowledgeSystem;
-    /**
-     * The make-meaning `EventBus`. Must be the same instance passed to
-     * `startMakeMeaning` so that emits land on the bus KnowledgeSystem
-     * actors are subscribed to.
-     */
-    eventBus: EventBus;
-    /**
-     * Host-process identity. Stamped onto every emit as `_userId`, mirroring
-     * the gateway-injection convention used by `HttpTransport` (where the
-     * `/bus/emit` gateway reads the JWT subject and injects `_userId`).
-     * Handlers downstream trust nothing else.
-     */
-    userId: UserDID;
-    /**
-     * Cosmetic base URL for diagnostics and URL composition. Defaults to
-     * `local://in-process`. Local code never makes outgoing HTTP requests
-     * with it.
-     */
-    baseUrl?: BaseUrl;
-}
-declare class LocalTransport implements ITransport {
-    readonly baseUrl: BaseUrl;
-    readonly state$: BehaviorSubject<ConnectionState>;
-    private readonly errorsSubject;
-    /**
-     * Stream of `SemiontError` instances surfaced from transport-mediated
-     * round-trips (typed-wire methods on this transport that fail). The
-     * in-process implementation does not currently surface errors through
-     * this stream — most failures here originate inside the make-meaning
-     * actors and surface through bus channels (correlation-ID failures via
-     * `busRequest`). The Subject exists to satisfy the `ITransport`
-     * contract; future expansion (e.g. transport-level guard failures)
-     * can publish into it.
-     */
-    readonly errors$: Observable<SemiontError>;
-    private readonly bus;
-    private readonly userId;
-    private readonly bridges;
-    private readonly bridgeSubs;
-    private disposed;
-    constructor(cfg: LocalTransportConfig);
-    emit<K extends keyof EventMap>(channel: K, payload: EventMap[K], resourceScope?: ResourceId): Promise<void>;
-    on<K extends keyof EventMap>(channel: K, handler: (payload: EventMap[K]) => void): () => void;
-    stream<K extends keyof EventMap>(channel: K): Observable<EventMap[K]>;
-    subscribeToResource(_resourceId: ResourceId): () => void;
-    bridgeInto(bus: EventBus): void;
-    dispose(): void;
-}
-
-/**
- * LocalContentTransport — `IContentTransport` for an in-process
- * `KnowledgeSystem`.
- *
- * Reads go straight to `kb.views` (resource lookup) + `kb.content`
- * (byte retrieval). No network, no auth — local mode runs as a single
- * host-process identity.
- *
- * `putBinary` is intentionally not implemented in Phase 2: in-process
- * resource creation is exercised through bus emits (mark/yield
- * namespaces), not multipart upload. If a future caller needs raw
- * binary upload from a local context, wire it through the same
- * resource-creation pipeline the HTTP `/resources` handler uses.
- */
-
-declare class LocalContentTransport implements IContentTransport {
-    private readonly ks;
-    constructor(ks: KnowledgeSystem);
-    putBinary(_request: PutBinaryRequest, _options?: PutBinaryOptions): Promise<{
-        resourceId: ResourceId;
-    }>;
-    getBinary(resourceId: ResourceId, options?: {
-        accept?: ContentFormat$1 | string;
-        auth?: AccessToken;
-    }): Promise<{
-        data: ArrayBuffer;
-        contentType: string;
-    }>;
-    getBinaryStream(resourceId: ResourceId, options?: {
-        accept?: ContentFormat$1 | string;
-        auth?: AccessToken;
-    }): Promise<{
-        stream: ReadableStream<Uint8Array>;
-        contentType: string;
-    }>;
-    private loadBinary;
-    dispose(): void;
-}
-
-/**
- * Handles `mark:create-request` — the bus command for creating an annotation.
- *
- * Flow:
- *   1. Assemble the W3C annotation from the request using the injected user DID.
- *   2. Emit `mark:create` with the correlationId threaded through.
- *   3. Stower picks up `mark:create`, appends to the event store (threading
- *      correlationId into event metadata), and publishes `mark:added` on the
- *      core EventBus.
- *   4. This handler subscribes to `mark:added` and `mark:create-failed`,
- *      matches by correlationId, and emits `mark:create-ok` / `mark:create-failed`
- *      to the caller only after persistence has actually completed.
- *
- * This is a deferred-ack pattern: the result event attests that Stower has
- * persisted the annotation, not merely that the command was well-formed.
- */
-declare function registerAnnotationAssemblyHandler(eventBus: EventBus, parentLogger: Logger): void;
-
-interface Gatherer {
-    generateAnnotationSummary(annId: AnnotationId, resId: ResourceId): Promise<Record<string, unknown>>;
-}
-declare function registerAnnotationLookupHandlers(eventBus: EventBus, kb: KnowledgeBase, gatherer: Gatherer, parentLogger: Logger): void;
-
-/**
- * Handles `bind:update-body` — the Bind flow's authoritative "apply body
- * operations to an annotation" command. Bind remains a first-class flow
- * despite delegating persistence to Mark — the semantic distinction (Bind =
- * reference linking, Mark = annotation CRUD) is meaningful at the UX and
- * agent-reasoning layers even when the downstream storage event is shared.
- *
- * Flow:
- *   1. Receive bind:update-body with correlationId.
- *   2. Forward to mark:update-body with correlationId threaded through.
- *   3. Stower persists (via EventStore.appendEvent) and publishes mark:body-updated
- *      with correlationId in metadata.
- *   4. This handler subscribes to mark:body-updated and mark:body-update-failed,
- *      matches by correlationId, and emits bind:body-updated / bind:body-update-failed
- *      so the caller learns the real outcome — not an optimistic ack.
- */
-declare function registerBindUpdateBodyHandler(eventBus: EventBus, parentLogger: Logger): void;
-
-declare function registerJobCommandHandlers(eventBus: EventBus, jobQueue: JobQueue, parentLogger: Logger): void;
-
-/**
- * Bus command handlers — pure bus-event translators that bridge the
- * "request" channels callers emit (`mark:create-request`, `bind:update-body`,
- * `job:create`, `browse:annotation-context-requested`,
- * `gather:summary-requested`) to the underlying make-meaning pipeline
- * (Stower, Browser, Gatherer, JobQueue).
- *
- * These ran in `apps/backend` historically because the HTTP gateway was
- * the only consumer that needed them. They are not HTTP-specific — moving
- * them here means `LocalTransport` consumers (and any future transport)
- * get the same contract automatically.
- */
-
-/**
- * Register all bus command handlers on the make-meaning EventBus. Called
- * during `startMakeMeaning` after the JobQueue and KnowledgeSystem exist.
- */
-declare function registerBusHandlers(eventBus: EventBus, knowledgeSystem: KnowledgeSystem, jobQueue: JobQueue, logger: Logger): void;
-
-/**
- * Entity Types Bootstrap
- *
- * On startup, seeds the KB with DEFAULT_ENTITY_TYPES by emitting
- * frame:add-entity-type for each missing type. Reads the __system__ event
- * stream (the durable source of truth in .semiont/events/) to determine
- * which types already exist.
- *
- * Idempotent: safe to call on every startup. Only emits events for types
- * not already in the log.
- *
- * Future: evolve toward a migration-based model where a `system:bootstrapped`
- * sentinel event records that first-time init completed, and `system:migrated`
- * events record schema version upgrades (e.g., adding new default entity types
- * in a future release). For now, scanning the small __system__ stream is simple
- * and correct.
- */
-
-/**
- * Bootstrap entity types if any are missing from the event log.
- * Reads the __system__ stream to find existing frame:entity-type-added events,
- * then emits only the missing ones.
- */
-declare function bootstrapEntityTypes(eventBus: EventBus, eventStore: EventStore, logger?: Logger): Promise<void>;
-
-/**
- * Entity Types Projection Reader
- *
- * Reads entity types from the view storage projection file.
- * This file is maintained by ViewMaterializer in response to entitytype.added events.
- */
-
-/**
- * Read entity types from view storage projection
- */
-declare function readEntityTypesProjection(project: SemiontProject): Promise<string[]>;
-
-/**
- * SmelterActorStateUnit — domain-event fan-in for the Smelter worker.
- *
- * Subscribes to the six smelter-relevant channels on a shared bus and
- * exposes them as a single typed `events$` stream. Transport-neutral —
- * the caller passes a `WorkerBus` (HTTP `ActorStateUnit` today, an in-process
- * bus shim if/when one exists). The state unit does not own the bus and does
- * not dispose it.
- *
- * `start()` widens the bus's channel-subscription set to include the
- * smelter channels. On HTTP this extends the SSE subscription URL;
- * on an in-process bus this is a no-op (the underlying `EventBus`
- * already delivers every emit).
- */
-
-interface SmelterEvent {
-    type: string;
-    resourceId?: string;
-    payload: Record<string, unknown>;
-}
-interface SmelterActorStateUnitOptions {
-    bus: WorkerBus;
-}
-interface SmelterActorStateUnit extends StateUnit {
-    events$: Observable<SmelterEvent>;
-    emit(channel: string, payload: Record<string, unknown>): Promise<void>;
-    start(): void;
-}
-declare function createSmelterActorStateUnit(options: SmelterActorStateUnitOptions): SmelterActorStateUnit;
-
-/**
- * Exchange Format Manifest Types
- *
- * Defines the metadata structures for backup archives.
- * The manifest is the first entry in an archive and describes its contents.
- */
-declare const BACKUP_FORMAT: "semiont-backup";
-declare const FORMAT_VERSION = 1;
-interface BackupManifestHeader {
-    format: typeof BACKUP_FORMAT;
-    version: number;
-    exportedAt: string;
-    sourceUrl: string;
-    stats: {
-        streams: number;
-        events: number;
-        blobs: number;
-        contentBytes: number;
-    };
-}
-interface BackupStreamSummary {
-    stream: string;
-    eventCount: number;
-}
-declare const LINKED_DATA_FORMAT: "semiont-linked-data";
-interface LinkedDataManifest {
-    '@context': Record<string, string>;
-    '@type': string;
-    'semiont:format': typeof LINKED_DATA_FORMAT;
-    'semiont:version': number;
-    'dct:created': string;
-    'prov:wasGeneratedBy': {
-        '@type': string;
-        'prov:used': string;
-    };
-    'semiont:entityTypes': string[];
-    'void:entities': number;
-}
-declare function isBackupManifest(obj: unknown): obj is BackupManifestHeader;
-declare function validateManifestVersion(version: number): void;
-
-/**
- * Backup Exporter
- *
- * Produces a lossless tar.gz archive of the system of record:
- * - Event log (all streams, JSONL format)
- * - Content store (content-addressed blobs)
- *
- * Reads events via EventStore and content via RepresentationStore.
- * The archive can restore a complete knowledge base.
- */
-
-/** Subset of EventStore used by the backup exporter. */
-interface BackupEventStoreReader {
-    log: {
-        storage: {
-            getAllResourceIds(): Promise<ResourceId[]>;
-        };
-        getEvents(resourceId: ResourceId): Promise<StoredEvent[]>;
-    };
-}
-/** Subset of WorkingTreeStore used by the backup exporter. */
-interface BackupContentReader {
-    retrieve(storageUri: string): Promise<Buffer>;
-}
-interface BackupExporterOptions {
-    eventStore: BackupEventStoreReader;
-    content: BackupContentReader;
-    sourceUrl: string;
-    logger?: Logger;
-}
-/**
- * Export a full backup of the knowledge base to a tar.gz stream.
- *
- * Archive structure:
- *   .semiont/manifest.jsonl              - Format metadata + per-stream checksums
- *   .semiont/events/__system__.jsonl     - System events
- *   .semiont/events/{resourceId}.jsonl   - Per-resource events
- *   {checksum}.{ext}                     - Content blobs (root level)
- */
-declare function exportBackup(options: BackupExporterOptions, output: Writable): Promise<BackupManifestHeader>;
-
-/**
- * Event Replay
- *
- * Replays parsed JSONL event streams through the EventBus.
- * Each domain event is translated to the corresponding command event
- * (e.g. yield:created → yield:create), emitted, and the result
- * event is awaited before proceeding (backpressure).
- *
- * Content blobs are resolved lazily via a lookup function so that
- * the caller controls memory strategy (streaming, on-disk, etc.).
- */
-
-/**
- * Resolves a content blob by its checksum.
- * Returned by the caller so replay doesn't dictate memory strategy.
- */
-type ContentBlobResolver = (checksum: string) => Buffer | undefined;
-interface ReplayStats {
-    eventsReplayed: number;
-    resourcesCreated: number;
-    annotationsCreated: number;
-    entityTypesAdded: number;
-}
-
-/**
- * Backup Importer
- *
- * Restores a knowledge base from a backup tar.gz archive.
- * Replays events through the EventBus → Stower pipeline so all
- * derived state (materialized views, graph) rebuilds naturally.
- *
- * Accepts a Readable stream so callers can pipe directly from disk
- * or network without buffering the entire archive first.
- * Content blobs are resolved lazily via a closure over the parsed
- * tar entries, avoiding a separate copy of all blob data in memory.
- */
-
-interface BackupImporterOptions {
-    eventBus: EventBus;
-    contentStore: WorkingTreeStore;
-    logger?: Logger;
-}
-interface BackupImportResult {
-    manifest: BackupManifestHeader;
-    stats: ReplayStats;
-}
-/**
- * Import a backup archive by replaying events through the EventBus.
- *
- * Flow:
- *   1. Stream and decompress tar.gz entries
- *   2. Parse .semiont/manifest.jsonl → validate format
- *   3. Build blob resolver over root-level content entries
- *   4. Replay .semiont/events/__system__.jsonl (entity types)
- *   5. Replay each .semiont/events/{resourceId}.jsonl (resources, annotations)
- *
- * Events flow: importer → EventBus → Stower → EventStore + Views
- */
-declare function importBackup(archive: Readable, options: BackupImporterOptions): Promise<BackupImportResult>;
-
-/**
- * Linked Data Exporter
- *
- * Produces a JSON-LD tar.gz archive from the current state of the knowledge base.
- * Reads materialized views (not the event log) for a fast, current-state export.
- *
- * Archive structure:
- *   .semiont/manifest.jsonld                - JSON-LD manifest with format metadata
- *   .semiont/resources/{resourceId}.jsonld   - One JSON-LD document per resource
- *   {checksum}.{ext}                        - Content blobs (root level)
- */
-
-/** Subset of ViewStorage used by the linked-data exporter. */
-interface LinkedDataViewReader {
-    getAll(): Promise<Array<{
-        resource: ResourceDescriptor;
-        annotations: {
-            annotations: Annotation[];
-        };
-    }>>;
-}
-/** Subset of WorkingTreeStore used by the linked-data exporter. */
-interface LinkedDataContentReader {
-    retrieve(storageUri: string): Promise<Buffer>;
-}
-interface LinkedDataExporterOptions {
-    views: LinkedDataViewReader;
-    content: LinkedDataContentReader;
-    sourceUrl: string;
-    entityTypes: string[];
-    includeArchived?: boolean;
-    logger?: Logger;
-}
-/**
- * Export the knowledge base as a JSON-LD tar.gz archive.
- */
-declare function exportLinkedData(options: LinkedDataExporterOptions, output: Writable): Promise<LinkedDataManifest>;
-
-/**
- * Linked Data Importer
- *
- * Creates resources from a JSON-LD tar.gz archive exported by the linked-data exporter.
- * Unlike the backup importer, this is lossy — new resources are created (new IDs),
- * no event history is preserved. Entity types are restored from the manifest.
- *
- * Parses .semiont/manifest.jsonld for format validation and entity types,
- * then processes each .semiont/resources/{resourceId}.jsonld to create
- * resources and annotations via the EventBus → Stower pipeline.
- */
-
-interface LinkedDataImporterOptions {
-    eventBus: EventBus;
-    contentStore: WorkingTreeStore;
-    userId: UserId;
-    logger?: Logger;
-}
-interface LinkedDataImportResult {
-    manifest: LinkedDataManifest;
-    resourcesCreated: number;
-    annotationsCreated: number;
-    entityTypesAdded: number;
-}
-/**
- * Import a JSON-LD archive by creating resources through the EventBus.
- *
- * Flow:
- *   1. Stream and decompress tar.gz entries
- *   2. Parse .semiont/manifest.jsonld → validate format
- *   3. Build blob resolver over root-level content entries
- *   4. Add entity types from manifest via frame:add-entity-type
- *   5. For each .semiont/resources/{id}.jsonld:
- *      a. Parse JSON-LD document
- *      b. Resolve content blob by checksum from representations
- *      c. Emit yield:create → await yield:created
- *      d. For each annotation: emit mark:create → await mark:created
- */
-declare function importLinkedData(archive: Readable, options: LinkedDataImporterOptions): Promise<LinkedDataImportResult>;
-
-/**
- * Resource Operations
- *
- * Business logic for resource operations. All writes go through the EventBus
- * — the Stower actor subscribes and handles persistence.
- *
- * For create: emits yield:create, awaits yield:created / yield:create-failed.
- */
-
-type ContentFormat = components['schemas']['ContentFormat'];
-type Agent$1 = components['schemas']['Agent'];
-interface CreateResourceInput {
-    name: string;
-    storageUri: string;
-    contentChecksum: string;
-    byteSize: number;
-    format: ContentFormat;
-    language?: string;
-    entityTypes?: string[];
-    creationMethod?: CreationMethod;
-    /** Provenance for AI-generated resources: source resource + annotation. */
-    generatedFrom?: {
-        resourceId?: string;
-        annotationId?: string;
-    };
-    generationPrompt?: string;
-    generator?: Agent$1 | Agent$1[];
-    isDraft?: boolean;
-}
-declare class ResourceOperations {
-    /**
-     * Create a new resource via EventBus → Stower
-     */
-    static createResource(input: CreateResourceInput, userId: UserId, eventBus: EventBus): Promise<ResourceId>;
-}
-
-/**
- * Annotation Operations
- *
- * Business logic for annotation CRUD operations. All writes go through the
- * EventBus — the Stower actor subscribes and handles persistence.
- *
- * In-process callers pass a `UserId` to these operations; the
- * EventBus emits stamp it onto the gateway-injection field `_userId`,
- * matching the wire-side convention so Stower handlers see one shape
- * regardless of where the command originated.
- */
-
-type Agent = components['schemas']['Agent'];
-
-type CreateAnnotationRequest = components['schemas']['CreateAnnotationRequest'];
-type UpdateAnnotationBodyRequest = components['schemas']['UpdateAnnotationBodyRequest'];
-interface CreateAnnotationResult {
-    annotation: Annotation;
-}
-interface UpdateAnnotationBodyResult {
-    annotation: Annotation;
-}
-declare class AnnotationOperations {
-    /**
-     * Create a new annotation via EventBus → Stower
-     */
-    static createAnnotation(request: CreateAnnotationRequest, userId: UserId, creator: Agent, eventBus: EventBus): Promise<CreateAnnotationResult>;
-    /**
-     * Update annotation body via EventBus → Stower
-     */
-    static updateAnnotationBody(id: string, request: UpdateAnnotationBodyRequest, userId: UserId, eventBus: EventBus, kb: KnowledgeBase): Promise<UpdateAnnotationBodyResult>;
-    /**
-     * Delete an annotation via EventBus → Stower
-     */
-    static deleteAnnotation(id: string, resourceIdStr: string, userId: UserId, eventBus: EventBus, kb: KnowledgeBase, logger?: Logger): Promise<void>;
-}
-
-/**
- * Resource Context
- *
- * Assembles resource context from view storage and content store
- * Does NOT touch the graph - graph queries go through GraphContext
- */
-
-interface ListResourcesFilters {
-    search?: string;
-    archived?: boolean;
-}
-declare class ResourceContext {
-    /**
-     * Get resource metadata from view storage
-     */
-    static getResourceMetadata(resourceId: ResourceId, kb: KnowledgeBase): Promise<ResourceDescriptor | null>;
-    /**
-     * List resources, optionally filtered.
-     *
-     * When `search` is set, delegates to `kb.graph.searchResources`, which runs
-     * the name match in the graph engine instead of scanning every view in JS.
-     * The graph result is then narrowed by `archived` if requested.
-     *
-     * When `search` is unset, falls back to scanning all materialized views.
-     * (TODO: also push the listing path through the graph for large KBs.)
-     */
-    static listResources(filters: ListResourcesFilters | undefined, kb: KnowledgeBase): Promise<ResourceDescriptor[]>;
-    private static sortByDateDesc;
-    /**
-     * Add content previews to resources (for search results)
-     * Retrieves and decodes the first 200 characters of each resource's primary representation
-     */
-    static addContentPreviews(resources: ResourceDescriptor[], kb: KnowledgeBase): Promise<Array<ResourceDescriptor & {
-        content: string;
-    }>>;
-    /**
-     * Get full content for a resource
-     * Retrieves and decodes the primary representation
-     */
-    static getResourceContent(resource: ResourceDescriptor, kb: KnowledgeBase): Promise<string | undefined>;
-}
-
-/**
- * Annotation Context
- *
- * Assembles annotation context from view storage and content store.
- * Provides methods for:
- * - Getting resource annotations
- * - Building LLM context for annotations
- * - Extracting annotation text context
- * - Generating AI summaries
- */
-
-type AnnotationLLMContextResponse = components['schemas']['AnnotationLLMContextResponse'];
-
-type AnnotationContextResponse = components['schemas']['AnnotationContextResponse'];
-type ContextualSummaryResponse = components['schemas']['ContextualSummaryResponse'];
-interface BuildContextOptions {
-    includeSourceContext?: boolean;
-    includeTargetContext?: boolean;
-    contextWindow?: number;
-}
-declare class AnnotationContext {
-    /**
-     * Build LLM context for an annotation
-     *
-     * @param annotationId - Bare annotation ID
-     * @param resourceId - Source resource ID
-     * @param kb - Knowledge base stores
-     * @param options - Context building options
-     * @param inferenceClient - Optional inference client for target context summary
-     * @returns Rich context for LLM processing
-     * @throws Error if annotation or resource not found
-     */
-    static buildLLMContext(annotationId: AnnotationId, resourceId: ResourceId, kb: KnowledgeBase, options?: BuildContextOptions, inferenceClient?: InferenceClient, logger?: Logger, embeddingProvider?: EmbeddingProvider): Promise<AnnotationLLMContextResponse>;
-    /**
-     * Get resource annotations from view storage (fast path)
-     * Throws if view missing
-     */
-    static getResourceAnnotations(resourceId: ResourceId, kb: KnowledgeBase): Promise<ResourceAnnotations>;
-    /**
-     * Get all annotations
-     * @returns Array of all annotation objects
-     */
-    static getAllAnnotations(resourceId: ResourceId, kb: KnowledgeBase): Promise<Annotation[]>;
-    /**
-     * Enrich reference annotations with resolved document names
-     * Adds _resolvedDocumentName property to annotations that link to documents
-     * @private
-     */
-    private static enrichResolvedReferences;
-    /**
-     * Get resource stats (version info)
-     * @returns Version and timestamp info for the annotations
-     */
-    static getResourceStats(resourceId: ResourceId, kb: KnowledgeBase): Promise<{
-        resourceId: ResourceId;
-        version: number;
-        updatedAt: string;
-    }>;
-    /**
-     * Check if resource exists in view storage
-     */
-    static resourceExists(resourceId: ResourceId, kb: KnowledgeBase): Promise<boolean>;
-    /**
-     * Get a single annotation by ID
-     * O(1) lookup using resource ID to access view storage
-     */
-    static getAnnotation(annotationId: AnnotationId, resourceId: ResourceId, kb: KnowledgeBase): Promise<Annotation | null>;
-    /**
-     * List annotations with optional filtering
-     * @param filters - Optional filters like resourceId and type
-     * @throws Error if resourceId not provided (cross-resource queries not supported in view storage)
-     */
-    static listAnnotations(filters: {
-        resourceId?: ResourceId;
-        type?: AnnotationCategory;
-    } | undefined, kb: KnowledgeBase): Promise<Annotation[]>;
-    /**
-     * Get annotation context (selected text with surrounding context)
-     */
-    static getAnnotationContext(annotationId: AnnotationId, resourceId: ResourceId, contextBefore: number, contextAfter: number, kb: KnowledgeBase): Promise<AnnotationContextResponse>;
-    /**
-     * Generate AI summary of annotation in context
-     */
-    static generateAnnotationSummary(annotationId: AnnotationId, resourceId: ResourceId, kb: KnowledgeBase, inferenceClient: InferenceClient): Promise<ContextualSummaryResponse>;
-    /**
-     * Get resource content as string
-     */
-    private static getResourceContent;
-    /**
-     * Extract annotation context from resource content
-     */
-    private static extractAnnotationContext;
-    /**
-     * Generate LLM summary of annotation in context
-     * Creates inference client per-request (HTTP handler context)
-     */
-    private static generateSummary;
-}
-
-/**
- * Graph Context
- *
- * Provides graph database operations for resources and annotations.
- * All methods require graph traversal - must use graph database.
- */
-
-interface GraphNode {
-    id: string;
-    type: string;
-    label: string;
-    metadata: {
-        entityTypes: string[];
-    };
-}
-interface GraphEdge {
-    source: string;
-    target: string;
-    type: string;
-    metadata: Record<string, unknown>;
-}
-interface GraphRepresentation {
-    nodes: GraphNode[];
-    edges: GraphEdge[];
-}
-declare class GraphContext {
-    /**
-     * Get all resources referencing this resource (backlinks)
-     * Requires graph traversal - must use graph database
-     */
-    static getBacklinks(resourceId: ResourceId, kb: KnowledgeBase): Promise<Annotation[]>;
-    /**
-     * Find shortest path between two resources
-     * Requires graph traversal - must use graph database
-     */
-    static findPath(fromResourceId: ResourceId, toResourceId: ResourceId, kb: KnowledgeBase, maxDepth?: number): Promise<GraphPath[]>;
-    /**
-     * Get resource connections (graph edges)
-     * Requires graph traversal - must use graph database
-     */
-    static getResourceConnections(resourceId: ResourceId, kb: KnowledgeBase): Promise<GraphConnection[]>;
-    /**
-     * Search resources by name (cross-resource query)
-     * Requires full-text search - must use graph database
-     */
-    static searchResources(query: string, kb: KnowledgeBase, limit?: number): Promise<ResourceDescriptor[]>;
-    /**
-     * Build graph representation with nodes and edges for a resource and its connections
-     * Retrieves connections from graph and builds visualization-ready structure
-     */
-    static buildGraphRepresentation(resourceId: ResourceId, maxRelated: number, kb: KnowledgeBase): Promise<GraphRepresentation>;
-}
-
-/**
- * LLM Context
- *
- * Builds comprehensive context for LLM processing of resources
- * Orchestrates: ResourceContext, GraphContext, AnnotationContext, and generation functions
- */
-
-type ResourceLLMContextResponse = components['schemas']['ResourceLLMContextResponse'];
-interface LLMContextOptions {
-    depth: number;
-    maxResources: number;
-    includeContent: boolean;
-    includeSummary: boolean;
-}
-declare class LLMContext {
-    /**
-     * Get comprehensive LLM context for a resource
-     * Includes: main resource, related resources, annotations, graph, content, summary, references
-     */
-    static getResourceContext(resourceId: ResourceId, options: LLMContextOptions, kb: KnowledgeBase, inferenceClient: InferenceClient): Promise<ResourceLLMContextResponse>;
-}
-
-/**
- * Resource Generation Functions
- *
- * Application-specific resource generation logic:
- * - Resource summary generation
- * - Reference suggestion generation
- *
- * NOTE: generateResourceFromTopic lives in @semiont/jobs (canonical location)
- * because make-meaning depends on jobs, not vice versa.
- */
-
-/**
- * Generate an intelligent summary for a resource
- */
-declare function generateResourceSummary(resourceName: string, content: string, entityTypes: string[], client: InferenceClient): Promise<string>;
-/**
- * Generate smart suggestions for a reference
- */
-declare function generateReferenceSuggestions(referenceTitle: string, client: InferenceClient, entityType?: string, currentContent?: string): Promise<string[] | null>;
-
-declare const PACKAGE_NAME = "@semiont/make-meaning";
-declare const VERSION = "0.1.0";
-
-export { AnnotationContext, AnnotationOperations, BACKUP_FORMAT, type BackupContentReader, type BackupEventStoreReader, type BackupExporterOptions, type BackupImportResult, type BackupImporterOptions, type BackupManifestHeader, type BackupStreamSummary, Browser, type BuildContextOptions, CloneTokenManager, type ContentBlobResolver, type CreateAnnotationResult, type CreateResourceInput, type CreateResourceResult, FORMAT_VERSION, Gatherer$1 as Gatherer, GraphContext, type GraphEdge, type GraphNode, type GraphRepresentation, type KnowledgeBase, type KnowledgeSystem, LLMContext, type LLMContextOptions, type LinkedDataContentReader, type LinkedDataExporterOptions, type LinkedDataImportResult, type LinkedDataImporterOptions, type LinkedDataViewReader, type ListResourcesFilters, LocalContentTransport, LocalTransport, type LocalTransportConfig, type MakeMeaningConfig, type MakeMeaningService, Matcher, PACKAGE_NAME, type ReplayStats, ResourceContext, ResourceOperations, type SmelterActorStateUnit, type SmelterActorStateUnitOptions, type SmelterEvent, Stower, type UpdateAnnotationBodyResult, VERSION, bootstrapEntityTypes, createKnowledgeBase, createSmelterActorStateUnit, exportBackup, exportLinkedData, generateReferenceSuggestions, generateResourceSummary, importBackup, importLinkedData, isBackupManifest, readEntityTypesProjection, registerAnnotationAssemblyHandler, registerAnnotationLookupHandlers, registerBindUpdateBodyHandler, registerBusHandlers, registerJobCommandHandlers, startMakeMeaning, stopKnowledgeSystem, validateManifestVersion };
+export { startMakeMeaning } from './service';
+export type { MakeMeaningService, MakeMeaningConfig } from './service';
+export type { KnowledgeSystem } from './knowledge-system';
+export { stopKnowledgeSystem } from './knowledge-system';
+export { LocalTransport, type LocalTransportConfig } from './local-transport';
+export { LocalContentTransport } from './local-content-transport';
+export { registerBusHandlers, registerAnnotationAssemblyHandler, registerAnnotationLookupHandlers, registerBindUpdateBodyHandler, registerJobCommandHandlers, } from './handlers';
+export { bootstrapEntityTypes } from './bootstrap/entity-types';
+export { readEntityTypesProjection } from './views/entity-types-reader';
+export { createKnowledgeBase } from './knowledge-base';
+export type { KnowledgeBase } from './knowledge-base';
+export { Gatherer } from './gatherer';
+export { Matcher } from './matcher';
+export { Stower } from './stower';
+export type { CreateResourceResult } from './stower';
+export { Browser } from './browser';
+export { CloneTokenManager } from './clone-token-manager';
+export { createSmelterActorStateUnit, type SmelterActorStateUnit, type SmelterActorStateUnitOptions, type SmelterEvent, } from './smelter-actor-state-unit';
+export * from './exchange';
+export { ResourceOperations } from './resource-operations';
+export type { CreateResourceInput } from './resource-operations';
+export { assembleAnnotation, applyBodyOperations } from './annotation-assembly';
+export type { AssembledAnnotation } from './annotation-assembly';
+export { AnnotationOperations } from './annotation-operations';
+export type { CreateAnnotationResult, UpdateAnnotationBodyResult } from './annotation-operations';
+export { ResourceContext } from './resource-context';
+export type { ListResourcesFilters } from './resource-context';
+export { AnnotationContext } from './annotation-context';
+export type { BuildContextOptions } from './annotation-context';
+export { GraphContext } from './graph-context';
+export type { GraphNode, GraphEdge, GraphRepresentation } from './graph-context';
+export { LLMContext } from './llm-context';
+export type { LLMContextOptions } from './llm-context';
+export { generateResourceSummary, generateReferenceSuggestions, } from './generation/resource-generation';
+export declare const PACKAGE_NAME = "@semiont/make-meaning";
+export declare const VERSION = "0.1.0";
+//# sourceMappingURL=index.d.ts.map