@semiont/make-meaning 0.5.3 → 0.5.4

package/dist/annotation-assembly.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Annotation Assembly — re-exported from @semiont/core
+ *
+ * The canonical implementation lives in @semiont/core.
+ * This re-export maintains the public API of @semiont/make-meaning.
+ */
+export { assembleAnnotation, applyBodyOperations, type AssembledAnnotation, } from '@semiont/core';
+//# sourceMappingURL=annotation-assembly.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-assembly.d.ts","sourceRoot":"","sources":["../src/annotation-assembly.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,KAAK,mBAAmB,GACzB,MAAM,eAAe,CAAC"}

package/dist/annotation-context.d.ts

@@ -0,0 +1,104 @@
+/**
+ * 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
+ */
+import type { InferenceClient } from '@semiont/inference';
+import type { EmbeddingProvider } from '@semiont/vectors';
+import type { components } from '@semiont/core';
+import type { ResourceId, ResourceAnnotations, AnnotationId, AnnotationCategory, Logger } from '@semiont/core';
+import type { KnowledgeBase } from './knowledge-base';
+type AnnotationLLMContextResponse = components['schemas']['AnnotationLLMContextResponse'];
+import type { Annotation } from '@semiont/core';
+type AnnotationContextResponse = components['schemas']['AnnotationContextResponse'];
+type ContextualSummaryResponse = components['schemas']['ContextualSummaryResponse'];
+export interface BuildContextOptions {
+    includeSourceContext?: boolean;
+    includeTargetContext?: boolean;
+    contextWindow?: number;
+}
+export 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;
+}
+export {};
+//# sourceMappingURL=annotation-context.d.ts.map

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

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

package/dist/annotation-operations.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+import type { components } from '@semiont/core';
+import type { UserId, Logger } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+import type { KnowledgeBase } from './knowledge-base';
+type Agent = components['schemas']['Agent'];
+import type { Annotation } from '@semiont/core';
+type CreateAnnotationRequest = components['schemas']['CreateAnnotationRequest'];
+type UpdateAnnotationBodyRequest = components['schemas']['UpdateAnnotationBodyRequest'];
+export interface CreateAnnotationResult {
+    annotation: Annotation;
+}
+export interface UpdateAnnotationBodyResult {
+    annotation: Annotation;
+}
+export 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>;
+}
+export {};
+//# sourceMappingURL=annotation-operations.d.ts.map

package/dist/annotation-operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotation-operations.d.ts","sourceRoot":"","sources":["../src/annotation-operations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAEV,MAAM,EACN,MAAM,EACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,QAAQ,EAAuF,MAAM,eAAe,CAAC;AAE9H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,KAAK,KAAK,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,KAAK,uBAAuB,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,yBAAyB,CAAC,CAAC;AAChF,KAAK,2BAA2B,GAAG,UAAU,CAAC,SAAS,CAAC,CAAC,6BAA6B,CAAC,CAAC;AAExF,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,MAAM,WAAW,0BAA0B;IACzC,UAAU,EAAE,UAAU,CAAC;CACxB;AAED,qBAAa,oBAAoB;IAC/B;;OAEG;WACU,gBAAgB,CAC3B,OAAO,EAAE,uBAAuB,EAChC,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,KAAK,EACd,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,sBAAsB,CAAC;IAclC;;OAEG;WACU,oBAAoB,CAC/B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,2BAA2B,EACpC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,aAAa,GAChB,OAAO,CAAC,0BAA0B,CAAC;IA8BtC;;OAEG;WACU,gBAAgB,CAC3B,EAAE,EAAE,MAAM,EACV,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,EAClB,EAAE,EAAE,aAAa,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,IAAI,CAAC;CAqBjB"}

package/dist/batch-utils.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared batch utilities for event-processing actors (GraphDBConsumer, Smelter).
+ *
+ * Both actors use the same pattern: burst-buffered events arrive as a batch,
+ * get partitioned into consecutive same-type runs, and each run is processed
+ * with a type-specific batch handler.
+ */
+import type { StoredEvent } from '@semiont/core';
+/**
+ * Partition a batch of events into runs of consecutive same-type events.
+ * e.g. [A, A, B, B, B, A] → [[A, A], [B, B, B], [A]]
+ */
+export declare function partitionByType(events: StoredEvent[]): StoredEvent[][];
+//# sourceMappingURL=batch-utils.d.ts.map

package/dist/batch-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-utils.d.ts","sourceRoot":"","sources":["../src/batch-utils.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,EAAE,CActE"}

package/dist/bootstrap/entity-types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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.
+ */
+import { EventBus, type Logger } from '@semiont/core';
+import type { EventStore } from '@semiont/event-sourcing';
+/**
+ * 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.
+ */
+export declare function bootstrapEntityTypes(eventBus: EventBus, eventStore: EventStore, logger?: Logger): Promise<void>;
+//# sourceMappingURL=entity-types.d.ts.map

package/dist/bootstrap/entity-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-types.d.ts","sourceRoot":"","sources":["../../src/bootstrap/entity-types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAGH,OAAO,EAAE,QAAQ,EAAsB,KAAK,MAAM,EAAE,MAAM,eAAe,CAAC;AAC1E,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAI1D;;;;GAIG;AACH,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAsCrH"}

package/dist/browser.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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:tag-schemas-requested — list tag schemas from the project projection
+ * - browse:directory-requested — list a project directory, merging fs + ViewStorage
+ */
+import type { SemiontProject } from '@semiont/core/node';
+import type { Logger } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+import type { ViewStorage } from '@semiont/event-sourcing';
+import type { KnowledgeBase } from './knowledge-base';
+export 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 handleTagSchemas;
+    private handleBrowseDirectory;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAMH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,KAAK,EAAY,MAAM,EAAc,MAAM,eAAe,CAAC;AAClE,OAAO,EAAE,QAAQ,EAAsC,MAAM,eAAe,CAAC;AAI7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAWtD,qBAAa,OAAO;IAKhB,OAAO,CAAC,KAAK;IACb,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,OAAO;IAPjB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;gBAGtB,KAAK,EAAE,WAAW,EAClB,EAAE,EAAE,aAAa,EACjB,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,cAAc,EAC/B,MAAM,EAAE,MAAM;IAKV,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAiCnB,oBAAoB;YAsCpB,qBAAqB;YAwCrB,uBAAuB;YAoBvB,sBAAsB;YAsCtB,kBAAkB;YAoClB,6BAA6B;YA4C7B,kBAAkB;YAkDlB,iBAAiB;YAgBjB,gBAAgB;YAoBhB,qBAAqB;IAiH7B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAO5B"}

package/dist/clone-token-manager.d.ts

@@ -0,0 +1,31 @@
+/**
+ * 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."
+ */
+import type { Logger } from '@semiont/core';
+import { type EventBus } from '@semiont/core';
+import type { KnowledgeBase } from './knowledge-base';
+export 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>;
+}
+//# sourceMappingURL=clone-token-manager.d.ts.map

package/dist/clone-token-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-token-manager.d.ts","sourceRoot":"","sources":["../src/clone-token-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH,OAAO,KAAK,EAAY,MAAM,EAAc,MAAM,eAAe,CAAC;AAClE,OAAO,EAAE,KAAK,QAAQ,EAAmF,MAAM,eAAe,CAAC;AAK/H,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,qBAAa,iBAAiB;IAM1B,OAAO,CAAC,EAAE;IACV,OAAO,CAAC,QAAQ;IANlB,OAAO,CAAC,aAAa,CAAsB;IAC3C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsE;gBAGnF,EAAE,EAAE,aAAa,EACjB,QAAQ,EAAE,QAAQ,EAC1B,MAAM,EAAE,MAAM;IAKV,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAwBnB,mBAAmB;YAsDnB,iBAAiB;YA+CjB,oBAAoB;IAwF5B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAQ5B"}

package/dist/config.d.ts

@@ -0,0 +1,55 @@
+import type { GraphServiceConfig, VectorsServiceConfig, EmbeddingServiceConfig } from '@semiont/core';
+/**
+ * Inference configuration for a single actor or worker.
+ */
+export 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.
+ */
+export interface ActorInferenceConfig {
+    gatherer?: InferenceConfig;
+    matcher?: InferenceConfig;
+}
+/**
+ * Per-worker-type inference overrides.
+ * Falls back to `workers.default` if a specific worker is not listed.
+ */
+export 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 */
+export interface MakeMeaningConfig {
+    services: {
+        graph?: GraphServiceConfig;
+        vectors?: VectorsServiceConfig;
+        embedding?: EmbeddingServiceConfig;
+    };
+    /** Per-actor inference config */
+    actors?: ActorInferenceConfig;
+    /** Per-worker-type inference config */
+    workers?: WorkerInferenceConfig;
+}
+/**
+ * Resolve inference config for a named actor.
+ */
+export declare function resolveActorInference(config: MakeMeaningConfig, actor: 'gatherer' | 'matcher'): InferenceConfig;
+/**
+ * Resolve inference config for a named worker type.
+ * Falls back to workers.default if a specific worker is not listed.
+ */
+export declare function resolveWorkerInference(config: MakeMeaningConfig, workerType: keyof Omit<WorkerInferenceConfig, 'default'>): InferenceConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAEtG;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,WAAW,GAAG,QAAQ,CAAC;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,sBAAsB,CAAC,EAAE,eAAe,CAAC;IACzC,sBAAsB,CAAC,EAAE,eAAe,CAAC;IACzC,uBAAuB,CAAC,EAAE,eAAe,CAAC;IAC1C,oBAAoB,CAAC,EAAE,eAAe,CAAC;IACvC,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,YAAY,CAAC,EAAE,eAAe,CAAC;CAChC;AAED,uEAAuE;AACvE,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE;QACR,KAAK,CAAC,EAAE,kBAAkB,CAAC;QAC3B,OAAO,CAAC,EAAE,oBAAoB,CAAC;QAC/B,SAAS,CAAC,EAAE,sBAAsB,CAAC;KACpC,CAAC;IACF,iCAAiC;IACjC,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,uCAAuC;IACvC,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,iBAAiB,EACzB,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,eAAe,CAQjB;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,iBAAiB,EACzB,UAAU,EAAE,MAAM,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,GACvD,eAAe,CAWjB"}

package/dist/embedding-store.d.ts

@@ -0,0 +1,63 @@
+/**
+ * EmbeddingStore
+ *
+ * Durable file-based cache for pre-computed embedding vectors.
+ * Stored under .semiont/embeddings/ — committed to git alongside events,
+ * but overwritten in place rather than appended.
+ *
+ * File layout (same 4-hex Jump Consistent Hash sharding as events):
+ *
+ *   .semiont/embeddings/{ab}/{cd}/{resourceId}.jsonl
+ *     Line 0: { model, dimensions }                  ← model header
+ *     Line N: { chunkIndex, text, embedding[] }       ← one chunk per line
+ *
+ *   .semiont/embeddings/{ab}/{cd}/{annotationId}.json
+ *     { model, dimensions, resourceId, text, embedding[], motivation, entityTypes }
+ *
+ * rebuildAll() in Smelter reads these files and upserts into Qdrant without
+ * calling the embedding provider — unless the stored model doesn't match the
+ * configured provider, in which case the file is re-embedded and overwritten.
+ */
+import type { ResourceId, AnnotationId } from '@semiont/core';
+import type { SemiontProject } from '@semiont/core/node';
+export interface StoredChunk {
+    chunkIndex: number;
+    text: string;
+    embedding: number[];
+}
+export interface ResourceEmbeddingFile {
+    model: string;
+    dimensions: number;
+    chunks: StoredChunk[];
+}
+export interface AnnotationEmbeddingFile {
+    model: string;
+    dimensions: number;
+    resourceId: string;
+    text: string;
+    embedding: number[];
+    motivation: string;
+    entityTypes: string[];
+}
+export declare class EmbeddingStore {
+    private readonly project;
+    constructor(project: SemiontProject);
+    private resourceFilePath;
+    private annotationFilePath;
+    writeResourceChunks(resourceId: ResourceId, model: string, dimensions: number, chunks: StoredChunk[]): Promise<void>;
+    readResourceEmbeddings(resourceId: ResourceId): Promise<ResourceEmbeddingFile | null>;
+    deleteResourceEmbeddings(resourceId: ResourceId): Promise<void>;
+    writeAnnotationEmbedding(annotationId: AnnotationId, resourceId: ResourceId, model: string, dimensions: number, text: string, embedding: number[], motivation: string, entityTypes: string[]): Promise<void>;
+    readAnnotationEmbedding(annotationId: AnnotationId): Promise<AnnotationEmbeddingFile | null>;
+    deleteAnnotationEmbedding(annotationId: AnnotationId): Promise<void>;
+    /**
+     * Scan embeddings directory and return all resource IDs (from *.jsonl files).
+     */
+    getAllResourceIds(): Promise<string[]>;
+    /**
+     * Scan embeddings directory and return all annotation IDs (from *.json files).
+     */
+    getAllAnnotationIds(): Promise<string[]>;
+    private scanIds;
+}
+//# sourceMappingURL=embedding-store.d.ts.map

package/dist/embedding-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embedding-store.d.ts","sourceRoot":"","sources":["../src/embedding-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,WAAW,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,uBAAuB;IACtC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,qBAAa,cAAc;IACb,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAP,OAAO,EAAE,cAAc;IAIpD,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,kBAAkB;IAOpB,mBAAmB,CACvB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,WAAW,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC;IAUV,sBAAsB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,qBAAqB,GAAG,IAAI,CAAC;IAerF,wBAAwB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/D,wBAAwB,CAC5B,YAAY,EAAE,YAAY,EAC1B,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EAAE,GACpB,OAAO,CAAC,IAAI,CAAC;IAWV,uBAAuB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;IAW5F,yBAAyB,CAAC,YAAY,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAW1E;;OAEG;IACG,iBAAiB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAI5C;;OAEG;IACG,mBAAmB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;YAIhC,OAAO;CAgCtB"}

package/dist/event-enrichment.d.ts

@@ -0,0 +1,5 @@
+import type { KnowledgeBase } from './knowledge-base';
+import type { Annotation, ResourceId, StoredEvent } from '@semiont/core';
+export declare function eventAnnotationId(event: StoredEvent): string | null;
+export declare function readAnnotationFromView(kb: KnowledgeBase, resourceId: ResourceId, annotationId: string): Promise<Annotation | null>;
+//# sourceMappingURL=event-enrichment.d.ts.map

package/dist/event-enrichment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-enrichment.d.ts","sourceRoot":"","sources":["../src/event-enrichment.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEzE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,GAAG,IAAI,CAWnE;AAED,wBAAsB,sBAAsB,CAC1C,EAAE,EAAE,aAAa,EACjB,UAAU,EAAE,UAAU,EACtB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAG5B"}

package/dist/exchange/backup-exporter.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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.
+ */
+import type { Writable } from 'node:stream';
+import type { ResourceId, StoredEvent, Logger } from '@semiont/core';
+import { type BackupManifestHeader } from './manifest';
+/** Subset of EventStore used by the backup exporter. */
+export interface BackupEventStoreReader {
+    log: {
+        storage: {
+            getAllResourceIds(): Promise<ResourceId[]>;
+        };
+        getEvents(resourceId: ResourceId): Promise<StoredEvent[]>;
+    };
+}
+/** Subset of WorkingTreeStore used by the backup exporter. */
+export interface BackupContentReader {
+    retrieve(storageUri: string): Promise<Buffer>;
+}
+export 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)
+ */
+export declare function exportBackup(options: BackupExporterOptions, output: Writable): Promise<BackupManifestHeader>;
+//# sourceMappingURL=backup-exporter.d.ts.map

package/dist/exchange/backup-exporter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup-exporter.d.ts","sourceRoot":"","sources":["../../src/exchange/backup-exporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGrE,OAAO,EAGL,KAAK,oBAAoB,EAE1B,MAAM,YAAY,CAAC;AAEpB,wDAAwD;AACxD,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE;QACH,OAAO,EAAE;YACP,iBAAiB,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;SAC5C,CAAC;QACF,SAAS,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;KAC3D,CAAC;CACH;AAED,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,sBAAsB,CAAC;IACnC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,qBAAqB,EAC9B,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,oBAAoB,CAAC,CAgG/B"}

package/dist/exchange/backup-importer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * 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.
+ */
+import type { Readable } from 'node:stream';
+import type { Logger } from '@semiont/core';
+import { EventBus } from '@semiont/core';
+import type { WorkingTreeStore } from '@semiont/content';
+import { type BackupManifestHeader } from './manifest';
+import { type ReplayStats } from './replay';
+export interface BackupImporterOptions {
+    eventBus: EventBus;
+    contentStore: WorkingTreeStore;
+    logger?: Logger;
+}
+export 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
+ */
+export declare function importBackup(archive: Readable, options: BackupImporterOptions): Promise<BackupImportResult>;
+//# sourceMappingURL=backup-importer.d.ts.map

package/dist/exchange/backup-importer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backup-importer.d.ts","sourceRoot":"","sources":["../../src/exchange/backup-importer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAEL,KAAK,oBAAoB,EAI1B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAqB,KAAK,WAAW,EAA4B,MAAM,UAAU,CAAC;AAEzF,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,QAAQ,CAAC;IACnB,YAAY,EAAE,gBAAgB,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,KAAK,EAAE,WAAW,CAAC;CACpB;AAyBD;;;;;;;;;;;GAWG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,QAAQ,EACjB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CA0E7B"}

package/dist/exchange/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Exchange Module — Knowledge Base Backup/Restore + Linked Data Export/Import
+ */
+export { exportBackup, type BackupExporterOptions, type BackupEventStoreReader, type BackupContentReader } from './backup-exporter';
+export { importBackup, type BackupImporterOptions, type BackupImportResult } from './backup-importer';
+export { type ReplayStats, type ContentBlobResolver } from './replay';
+export { BACKUP_FORMAT, FORMAT_VERSION, type BackupManifestHeader, type BackupStreamSummary, isBackupManifest, validateManifestVersion, } from './manifest';
+export { exportLinkedData, type LinkedDataExporterOptions, type LinkedDataViewReader, type LinkedDataContentReader } from './linked-data-exporter';
+export { importLinkedData, type LinkedDataImporterOptions, type LinkedDataImportResult } from './linked-data-importer';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/exchange/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,YAAY,EAAE,KAAK,qBAAqB,EAAE,KAAK,sBAAsB,EAAE,KAAK,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACpI,OAAO,EAAE,YAAY,EAAE,KAAK,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACtG,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACtE,OAAO,EACL,aAAa,EACb,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,mBAAmB,EACxB,gBAAgB,EAChB,uBAAuB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,KAAK,oBAAoB,EAAE,KAAK,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACnJ,OAAO,EAAE,gBAAgB,EAAE,KAAK,yBAAyB,EAAE,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAC"}

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

@@ -0,0 +1,42 @@
+/**
+ * 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)
+ */
+import type { Writable } from 'node:stream';
+import type { Logger } from '@semiont/core';
+import { type LinkedDataManifest } from './manifest';
+import type { ResourceDescriptor } from '@semiont/core';
+import type { Annotation } from '@semiont/core';
+/** Subset of ViewStorage used by the linked-data exporter. */
+export interface LinkedDataViewReader {
+    getAll(): Promise<Array<{
+        resource: ResourceDescriptor;
+        annotations: {
+            annotations: Annotation[];
+        };
+    }>>;
+}
+/** Subset of WorkingTreeStore used by the linked-data exporter. */
+export interface LinkedDataContentReader {
+    retrieve(storageUri: string): Promise<Buffer>;
+}
+export 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.
+ */
+export declare function exportLinkedData(options: LinkedDataExporterOptions, output: Writable): Promise<LinkedDataManifest>;
+//# sourceMappingURL=linked-data-exporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"linked-data-exporter.d.ts","sourceRoot":"","sources":["../../src/exchange/linked-data-exporter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAI5C,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD,8DAA8D;AAC9D,MAAM,WAAW,oBAAoB;IACnC,MAAM,IAAI,OAAO,CAAC,KAAK,CAAC;QACtB,QAAQ,EAAE,kBAAkB,CAAC;QAC7B,WAAW,EAAE;YAAE,WAAW,EAAE,UAAU,EAAE,CAAA;SAAE,CAAC;KAC5C,CAAC,CAAC,CAAC;CACL;AAaD,mEAAmE;AACnE,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,oBAAoB,CAAC;IAC5B,OAAO,EAAE,uBAAuB,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAwED;;GAEG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,yBAAyB,EAClC,MAAM,EAAE,QAAQ,GACf,OAAO,CAAC,kBAAkB,CAAC,CA4E7B"}