@semiont/make-meaning 0.5.3 → 0.5.4

package/dist/exchange/linked-data-importer.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 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.
+ */
+import type { Readable } from 'node:stream';
+import type { Logger, UserId } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+import type { WorkingTreeStore } from '@semiont/content';
+import { type LinkedDataManifest } from './manifest';
+export interface LinkedDataImporterOptions {
+    eventBus: EventBus;
+    contentStore: WorkingTreeStore;
+    userId: UserId;
+    logger?: Logger;
+}
+export 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
+ */
+export declare function importLinkedData(archive: Readable, options: LinkedDataImporterOptions): Promise<LinkedDataImportResult>;
+//# sourceMappingURL=linked-data-importer.d.ts.map

package/dist/exchange/linked-data-importer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linked-data-importer.d.ts","sourceRoot":"","sources":["../../src/exchange/linked-data-importer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAG5C,OAAO,KAAK,EAAE,MAAM,EAAc,MAAM,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,QAAQ,EAAqE,MAAM,eAAe,CAAC;AAE5G,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGzD,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,YAAY,CAAC;AAKpB,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAmFD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,yBAAyB,GACjC,OAAO,CAAC,sBAAsB,CAAC,CAoEjC"}

package/dist/exchange/manifest.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Exchange Format Manifest Types
+ *
+ * Defines the metadata structures for backup archives.
+ * The manifest is the first entry in an archive and describes its contents.
+ */
+export declare const BACKUP_FORMAT: "semiont-backup";
+export declare const FORMAT_VERSION = 1;
+export interface BackupManifestHeader {
+    format: typeof BACKUP_FORMAT;
+    version: number;
+    exportedAt: string;
+    sourceUrl: string;
+    stats: {
+        streams: number;
+        events: number;
+        blobs: number;
+        contentBytes: number;
+    };
+}
+export interface BackupStreamSummary {
+    stream: string;
+    eventCount: number;
+}
+export declare const LINKED_DATA_FORMAT: "semiont-linked-data";
+export 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;
+}
+export declare function isLinkedDataManifest(obj: unknown): obj is LinkedDataManifest;
+export declare function isBackupManifest(obj: unknown): obj is BackupManifestHeader;
+export declare function validateManifestVersion(version: number): void;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/exchange/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/exchange/manifest.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,eAAO,MAAM,aAAa,EAAG,gBAAyB,CAAC;AAEvD,eAAO,MAAM,cAAc,IAAI,CAAC;AAIhC,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,OAAO,aAAa,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE;QACL,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,KAAK,EAAE,MAAM,CAAC;QACd,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;CACH;AAED,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB;AAID,eAAO,MAAM,kBAAkB,EAAG,qBAA8B,CAAC;AAEjE,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,EAAE,OAAO,kBAAkB,CAAC;IAC5C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,qBAAqB,EAAE;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,kBAAkB,CAM5E;AAID,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,oBAAoB,CAM1E;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAM7D"}

package/dist/exchange/replay.d.ts

@@ -0,0 +1,37 @@
+/**
+ * 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.).
+ */
+import type { Logger } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+import type { WorkingTreeStore } from '@semiont/content';
+/**
+ * Resolves a content blob by its checksum.
+ * Returned by the caller so replay doesn't dictate memory strategy.
+ */
+export type ContentBlobResolver = (checksum: string) => Buffer | undefined;
+export interface ReplayStats {
+    eventsReplayed: number;
+    resourcesCreated: number;
+    annotationsCreated: number;
+    entityTypesAdded: number;
+}
+export interface ReplayResult {
+    stats: ReplayStats;
+}
+/**
+ * Replay a JSONL event stream through the EventBus.
+ *
+ * Events are emitted sequentially — each command event waits for
+ * its result before the next is emitted. This matches the Stower's
+ * concatMap processing guarantee.
+ */
+export declare function replayEventStream(jsonl: string, eventBus: EventBus, resolveBlob: ContentBlobResolver, contentStore: WorkingTreeStore, logger?: Logger): Promise<ReplayResult>;
+//# sourceMappingURL=replay.d.ts.map

package/dist/exchange/replay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/exchange/replay.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,MAAM,EAAyD,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAMzD;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAE3E,MAAM,WAAW,WAAW;IAC1B,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,WAAW,CAAC;CACpB;AAID;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,mBAAmB,EAChC,YAAY,EAAE,gBAAgB,EAC9B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,YAAY,CAAC,CAkBvB"}

package/dist/exchange/tar.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Minimal Streaming Tar Writer/Reader
+ *
+ * Creates and reads POSIX tar archives without external dependencies.
+ * Tar format: 512-byte header blocks followed by data padded to 512 bytes.
+ *
+ * The reader accepts a Readable stream so callers can pipe from disk
+ * or network without buffering the entire archive in memory first.
+ */
+import { Readable, Writable } from 'node:stream';
+export interface TarEntry {
+    name: string;
+    data: Buffer;
+}
+/**
+ * Write tar entries to a gzipped stream.
+ * Entries are written sequentially as they're yielded.
+ */
+export declare function writeTarGz(entries: AsyncIterable<TarEntry>, output: Writable): Promise<void>;
+export interface TarReadEntry {
+    name: string;
+    size: number;
+    data: Buffer;
+}
+/**
+ * Read tar entries from a gzipped Readable stream.
+ * Yields entries one at a time.
+ *
+ * The stream is decompressed incrementally via pipe, then tar entries
+ * are parsed from the decompressed result. This avoids requiring the
+ * caller to buffer the entire gzipped archive before calling.
+ */
+export declare function readTarGz(input: Readable): AsyncIterable<TarReadEntry>;
+//# sourceMappingURL=tar.d.ts.map

package/dist/exchange/tar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tar.d.ts","sourceRoot":"","sources":["../../src/exchange/tar.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAY,MAAM,aAAa,CAAC;AAiD3D,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,aAAa,CAAC,QAAQ,CAAC,EAChC,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,IAAI,CAAC,CAsBf;AAID,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAoDD;;;;;;;GAOG;AACH,wBAAuB,SAAS,CAAC,KAAK,EAAE,QAAQ,GAAG,aAAa,CAAC,YAAY,CAAC,CAG7E"}

package/dist/gatherer.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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.
+ */
+import type { Logger, components, AnnotationId, ResourceId } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+import type { InferenceClient } from '@semiont/inference';
+import type { EmbeddingProvider } from '@semiont/vectors';
+import type { KnowledgeBase } from './knowledge-base';
+export declare class Gatherer {
+    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>;
+}
+//# sourceMappingURL=gatherer.d.ts.map

package/dist/gatherer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gatherer.d.ts","sourceRoot":"","sources":["../src/gatherer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAIH,OAAO,KAAK,EAAY,MAAM,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAE,QAAQ,EAA0D,MAAM,eAAe,CAAC;AAEjG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAItD,qBAAa,QAAQ;IAKjB,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,eAAe;IAEvB,OAAO,CAAC,iBAAiB,CAAC;IAR5B,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAGtB,EAAE,EAAE,aAAa,EACjB,QAAQ,EAAE,QAAQ,EAClB,eAAe,EAAE,eAAe,EACxC,MAAM,EAAE,MAAM,EACN,iBAAiB,CAAC,EAAE,iBAAiB,YAAA;IAKzC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAuCnB,sBAAsB;YAmCtB,oBAAoB;IA+B5B,yBAAyB,CAC7B,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,2BAA2B,CAAC,CAAC;IASxD,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}

package/dist/generation/resource-generation.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+import type { InferenceClient } from '@semiont/inference';
+/**
+ * Generate an intelligent summary for a resource
+ */
+export declare function generateResourceSummary(resourceName: string, content: string, entityTypes: string[], client: InferenceClient): Promise<string>;
+/**
+ * Generate smart suggestions for a reference
+ */
+export declare function generateReferenceSuggestions(referenceTitle: string, client: InferenceClient, entityType?: string, currentContent?: string): Promise<string[] | null>;
+//# sourceMappingURL=resource-generation.d.ts.map

package/dist/generation/resource-generation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-generation.d.ts","sourceRoot":"","sources":["../../src/generation/resource-generation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EAAE,EACrB,MAAM,EAAE,eAAe,GACtB,OAAO,CAAC,MAAM,CAAC,CAejB;AAED;;GAEG;AACH,wBAAsB,4BAA4B,CAChD,cAAc,EAAE,MAAM,EACtB,MAAM,EAAE,eAAe,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC,CAgB1B"}

package/dist/graph/consumer.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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.
+ */
+import { type EventStore } from '@semiont/event-sourcing';
+import { EventBus } from '@semiont/core';
+import type { GraphDatabase } from '@semiont/graph';
+import type { StoredEvent, ResourceId, Logger } from '@semiont/core';
+export 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>;
+}
+//# sourceMappingURL=consumer.d.ts.map

package/dist/graph/consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer.d.ts","sourceRoot":"","sources":["../../src/graph/consumer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAIH,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,EAA2B,QAAQ,EAAY,MAAM,eAAe,CAAC;AAC5E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AACpD,OAAO,KAAK,EAAkB,WAAW,EAAe,UAAU,EAAE,MAAM,EAAC,MAAM,eAAe,CAAC;AAOjG,qBAAa,eAAe;IAoBxB,OAAO,CAAC,UAAU;IAClB,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,YAAY;IApBtB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,qBAAqB,CAI1C;IAGH,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAM;IAC7C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAO;IAC7C,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAO;IAE9C,OAAO,CAAC,oBAAoB,CAAsB;IAClD,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,oBAAoB,CAA6B;IACzD,OAAO,CAAC,aAAa,CAAkC;IACvD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAGtB,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,QAAQ,EAC9B,MAAM,EAAE,MAAM;IAKV,UAAU;IAKhB;;;OAGG;YACW,uBAAuB;IAoDrC;;OAEG;YACW,cAAc;IAc5B,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACG,IAAI;IAsBV;;;OAGG;YACW,YAAY;IA6B1B;;;OAGG;YACW,gBAAgB;IA+B9B;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IA0B/B;;OAEG;cACa,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAwI1E;;;OAGG;IACG,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAoB5D;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IA0CjC;;OAEG;IACH,gBAAgB,IAAI;QAClB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACtC,cAAc,EAAE,OAAO,CAAC;KACzB;IAQD;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAIhC"}

package/dist/graph-context.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Graph Context
+ *
+ * Provides graph database operations for resources and annotations.
+ * All methods require graph traversal - must use graph database.
+ */
+import type { ResourceId, GraphConnection, GraphPath } from '@semiont/core';
+import type { KnowledgeBase } from './knowledge-base';
+import type { Annotation } from '@semiont/core';
+import type { ResourceDescriptor } from '@semiont/core';
+export interface GraphNode {
+    id: string;
+    type: string;
+    label: string;
+    metadata: {
+        entityTypes: string[];
+    };
+}
+export interface GraphEdge {
+    source: string;
+    target: string;
+    type: string;
+    metadata: Record<string, unknown>;
+}
+export interface GraphRepresentation {
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+}
+export 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>;
+}
+//# sourceMappingURL=graph-context.d.ts.map

package/dist/graph-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-context.d.ts","sourceRoot":"","sources":["../src/graph-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,eAAe,EACf,SAAS,EACV,MAAM,eAAe,CAAC;AAEvB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE;QAAE,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACrC;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,SAAS,EAAE,CAAC;CACpB;AAED,qBAAa,YAAY;IACvB;;;OAGG;WACU,YAAY,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAI3F;;;OAGG;WACU,QAAQ,CACnB,cAAc,EAAE,UAAU,EAC1B,YAAY,EAAE,UAAU,EACxB,EAAE,EAAE,aAAa,EACjB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,SAAS,EAAE,CAAC;IAIvB;;;OAGG;WACU,sBAAsB,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC;IAI1G;;;OAGG;WACU,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,aAAa,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC;IAI7G;;;OAGG;WACU,wBAAwB,CACnC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,aAAa,GAChB,OAAO,CAAC,mBAAmB,CAAC;CAwChC"}

package/dist/handlers/annotation-assembly.d.ts

@@ -0,0 +1,19 @@
+import type { EventBus, Logger } from '@semiont/core';
+/**
+ * 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.
+ */
+export declare function registerAnnotationAssemblyHandler(eventBus: EventBus, parentLogger: Logger): void;
+//# sourceMappingURL=annotation-assembly.d.ts.map

package/dist/handlers/annotation-assembly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-assembly.d.ts","sourceRoot":"","sources":["../../src/handlers/annotation-assembly.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAc,MAAM,eAAe,CAAC;AAIlE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,iCAAiC,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CA8DhG"}

package/dist/handlers/annotation-lookups.d.ts

@@ -0,0 +1,8 @@
+import type { AnnotationId, ResourceId, EventBus, Logger } from '@semiont/core';
+import type { KnowledgeBase } from '../knowledge-base.js';
+interface Gatherer {
+    generateAnnotationSummary(annId: AnnotationId, resId: ResourceId): Promise<Record<string, unknown>>;
+}
+export declare function registerAnnotationLookupHandlers(eventBus: EventBus, kb: KnowledgeBase, gatherer: Gatherer, parentLogger: Logger): void;
+export {};
+//# sourceMappingURL=annotation-lookups.d.ts.map

package/dist/handlers/annotation-lookups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-lookups.d.ts","sourceRoot":"","sources":["../../src/handlers/annotation-lookups.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGhF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,UAAU,QAAQ;IAChB,yBAAyB,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CACrG;AAED,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,aAAa,EACjB,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,MAAM,GACnB,IAAI,CAuDN"}

package/dist/handlers/bind-update-body.d.ts

@@ -0,0 +1,19 @@
+import type { EventBus, Logger } from '@semiont/core';
+/**
+ * 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.
+ */
+export declare function registerBindUpdateBodyHandler(eventBus: EventBus, parentLogger: Logger): void;
+//# sourceMappingURL=bind-update-body.d.ts.map

package/dist/handlers/bind-update-body.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bind-update-body.d.ts","sourceRoot":"","sources":["../../src/handlers/bind-update-body.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAiB,MAAM,eAAe,CAAC;AAErE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAkE5F"}

package/dist/handlers/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+import type { EventBus, Logger } from '@semiont/core';
+import type { SemiontProject } from '@semiont/core/node';
+import type { JobQueue } from '@semiont/jobs';
+import type { KnowledgeSystem } from '../knowledge-system.js';
+import { registerAnnotationAssemblyHandler } from './annotation-assembly.js';
+import { registerAnnotationLookupHandlers } from './annotation-lookups.js';
+import { registerBindUpdateBodyHandler } from './bind-update-body.js';
+import { registerJobCommandHandlers } from './job-commands.js';
+export { registerAnnotationAssemblyHandler, registerAnnotationLookupHandlers, registerBindUpdateBodyHandler, registerJobCommandHandlers, };
+/**
+ * Register all bus command handlers on the make-meaning EventBus. Called
+ * during `startMakeMeaning` after the JobQueue and KnowledgeSystem exist.
+ */
+export declare function registerBusHandlers(eventBus: EventBus, knowledgeSystem: KnowledgeSystem, jobQueue: JobQueue, project: SemiontProject, logger: Logger): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/handlers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/handlers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,iCAAiC,EAAE,MAAM,0BAA0B,CAAC;AAC7E,OAAO,EAAE,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAC3E,OAAO,EAAE,6BAA6B,EAAE,MAAM,uBAAuB,CAAC;AACtE,OAAO,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAC;AAE/D,OAAO,EACL,iCAAiC,EACjC,gCAAgC,EAChC,6BAA6B,EAC7B,0BAA0B,GAC3B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,QAAQ,EAClB,eAAe,EAAE,eAAe,EAChC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,MAAM,GACb,IAAI,CAKN"}

package/dist/handlers/job-commands.d.ts

@@ -0,0 +1,5 @@
+import type { EventBus, Logger } from '@semiont/core';
+import type { SemiontProject } from '@semiont/core/node';
+import type { JobQueue } from '@semiont/jobs';
+export declare function registerJobCommandHandlers(eventBus: EventBus, jobQueue: JobQueue, project: SemiontProject, parentLogger: Logger): void;
+//# sourceMappingURL=job-commands.d.ts.map

package/dist/handlers/job-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-commands.d.ts","sourceRoot":"","sources":["../../src/handlers/job-commands.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAiB9C,wBAAgB,0BAA0B,CACxC,QAAQ,EAAE,QAAQ,EAClB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,GACnB,IAAI,CAgIN"}