@semiont/make-meaning 0.2.30-build.61 → 0.2.30-build.63

package/dist/index.d.ts

@@ -1,9 +1,285 @@
-import { components, AnnotationUri } from '@semiont/api-client';
-import { ResourceId, EnvironmentConfig, ResourceAnnotations, AnnotationId, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
-import { CommentMatch, HighlightMatch, AssessmentMatch, TagMatch } from '@semiont/inference';
-export { AssessmentMatch, CommentMatch, HighlightMatch, TagMatch } from '@semiont/inference';
-import { JobWorker, JobQueue, Job } from '@semiont/jobs';
+import { JobWorker, JobQueue, AnyJob } from '@semiont/jobs';
 import { EventStore } from '@semiont/event-sourcing';
+import { RepresentationStore } from '@semiont/content';
+import { EnvironmentConfig, ResourceId, StoredEvent, ResourceAnnotations, AnnotationId, AnnotationCategory, GraphPath, GraphConnection } from '@semiont/core';
+import { InferenceClient } from '@semiont/inference';
+import { GraphDatabase } from '@semiont/graph';
+import { components, AnnotationUri, GenerationContext } from '@semiont/api-client';
+
+/**
+ * Reference Detection Worker
+ *
+ * Processes detection jobs: runs AI inference to find entities in resources
+ * and emits reference.created events for each detected entity.
+ *
+ * This worker is INDEPENDENT of HTTP clients - it just processes jobs and emits events.
+ */
+
+type ResourceDescriptor$2 = components['schemas']['ResourceDescriptor'];
+interface DetectedAnnotation {
+    annotation: {
+        selector: {
+            start: number;
+            end: number;
+            exact: string;
+            prefix?: string;
+            suffix?: string;
+        };
+        entityTypes: string[];
+    };
+}
+declare class ReferenceDetectionWorker extends JobWorker {
+    private config;
+    private eventStore;
+    private inferenceClient;
+    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore, inferenceClient: InferenceClient);
+    protected getWorkerName(): string;
+    protected canProcessJob(job: AnyJob): boolean;
+    protected executeJob(job: AnyJob): Promise<void>;
+    /**
+     * Detect entity references in resource using AI
+     * Self-contained implementation for reference detection
+     *
+     * Public for testing charset handling - see entity-detection-charset.test.ts
+     */
+    detectReferences(resource: ResourceDescriptor$2, entityTypes: string[], includeDescriptiveReferences?: boolean): Promise<DetectedAnnotation[]>;
+    private processDetectionJob;
+    protected handleJobFailure(job: AnyJob, error: any): Promise<void>;
+    /**
+     * Update job progress and emit events to Event Store
+     * Overrides base class to also emit job progress events
+     */
+    protected updateJobProgress(job: AnyJob): Promise<void>;
+}
+
+/**
+ * Generation Worker
+ *
+ * Processes generation jobs: runs AI inference to generate new resources
+ * and emits resource.created and annotation.body.updated events.
+ *
+ * This worker is INDEPENDENT of HTTP clients - it just processes jobs and emits events.
+ */
+
+declare class GenerationWorker extends JobWorker {
+    private config;
+    private eventStore;
+    private inferenceClient;
+    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore, inferenceClient: InferenceClient);
+    protected getWorkerName(): string;
+    protected canProcessJob(job: AnyJob): boolean;
+    protected executeJob(job: AnyJob): Promise<void>;
+    private processGenerationJob;
+    /**
+     * Update job progress and emit events to Event Store
+     * Overrides base class to also emit job progress events
+     */
+    protected updateJobProgress(job: AnyJob): Promise<void>;
+}
+
+/**
+ * Highlight Detection Worker
+ *
+ * Processes highlight-detection jobs: runs AI inference to find passages
+ * that should be highlighted and creates highlight annotations.
+ */
+
+declare class HighlightDetectionWorker extends JobWorker {
+    private config;
+    private eventStore;
+    private inferenceClient;
+    private isFirstProgress;
+    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore, inferenceClient: InferenceClient);
+    protected getWorkerName(): string;
+    protected canProcessJob(job: AnyJob): boolean;
+    protected executeJob(job: AnyJob): Promise<void>;
+    /**
+     * Override updateJobProgress to emit events to Event Store
+     */
+    protected updateJobProgress(job: AnyJob): Promise<void>;
+    protected handleJobFailure(job: AnyJob, error: any): Promise<void>;
+    private processHighlightDetectionJob;
+    private createHighlightAnnotation;
+}
+
+/**
+ * Assessment Detection Worker
+ *
+ * Processes assessment-detection jobs: runs AI inference to assess/evaluate
+ * passages in the text and creates assessment annotations.
+ */
+
+declare class AssessmentDetectionWorker extends JobWorker {
+    private config;
+    private eventStore;
+    private inferenceClient;
+    private isFirstProgress;
+    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore, inferenceClient: InferenceClient);
+    protected getWorkerName(): string;
+    protected canProcessJob(job: AnyJob): boolean;
+    protected executeJob(job: AnyJob): Promise<void>;
+    /**
+     * Override updateJobProgress to emit events to Event Store
+     */
+    protected updateJobProgress(job: AnyJob): Promise<void>;
+    protected handleJobFailure(job: AnyJob, error: any): Promise<void>;
+    private processAssessmentDetectionJob;
+    private createAssessmentAnnotation;
+}
+
+/**
+ * Comment Detection Worker
+ *
+ * Processes comment-detection jobs: runs AI inference to identify passages
+ * that would benefit from explanatory comments and creates comment annotations.
+ */
+
+declare class CommentDetectionWorker extends JobWorker {
+    private config;
+    private eventStore;
+    private inferenceClient;
+    private isFirstProgress;
+    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore, inferenceClient: InferenceClient);
+    protected getWorkerName(): string;
+    protected canProcessJob(job: AnyJob): boolean;
+    protected executeJob(job: AnyJob): Promise<void>;
+    /**
+     * Override updateJobProgress to emit events to Event Store
+     */
+    protected updateJobProgress(job: AnyJob): Promise<void>;
+    protected handleJobFailure(job: AnyJob, error: any): Promise<void>;
+    private processCommentDetectionJob;
+    private createCommentAnnotation;
+}
+
+/**
+ * Tag Detection Worker
+ *
+ * Processes tag-detection jobs: runs AI inference to identify passages
+ * serving specific structural roles (IRAC, IMRAD, Toulmin, etc.) and
+ * creates tag annotations with dual-body structure.
+ */
+
+declare class TagDetectionWorker extends JobWorker {
+    private config;
+    private eventStore;
+    private inferenceClient;
+    private isFirstProgress;
+    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore, inferenceClient: InferenceClient);
+    protected getWorkerName(): string;
+    protected canProcessJob(job: AnyJob): boolean;
+    protected executeJob(job: AnyJob): Promise<void>;
+    /**
+     * Override updateJobProgress to emit events to Event Store
+     */
+    protected updateJobProgress(job: AnyJob): Promise<void>;
+    protected handleJobFailure(job: AnyJob, error: any): Promise<void>;
+    private processTagDetectionJob;
+    private createTagAnnotation;
+}
+
+/**
+ * GraphDB Consumer
+ * Subscribes to resource events and updates GraphDB accordingly
+ *
+ * Makes GraphDB a projection of Event Store events (single source of truth)
+ */
+
+declare class GraphDBConsumer {
+    private config;
+    private eventStore;
+    private graphDb;
+    private subscriptions;
+    private _globalSubscription;
+    private processing;
+    private lastProcessed;
+    constructor(config: EnvironmentConfig, eventStore: EventStore, graphDb: GraphDatabase);
+    initialize(): Promise<void>;
+    /**
+     * Subscribe to global system-level events (no resourceId)
+     * This allows the consumer to react to events like entitytype.added
+     */
+    private subscribeToGlobalEvents;
+    private ensureInitialized;
+    /**
+     * Subscribe to events for a resource
+     * Apply each event to GraphDB
+     */
+    subscribeToResource(resourceId: ResourceId): Promise<void>;
+    /**
+     * Stop the consumer and unsubscribe from all events
+     */
+    stop(): Promise<void>;
+    /**
+     * Process event with ordering guarantee (sequential per resource)
+     */
+    protected processEvent(storedEvent: StoredEvent): Promise<void>;
+    /**
+     * Apply event to GraphDB
+     */
+    protected applyEventToGraph(storedEvent: StoredEvent): Promise<void>;
+    /**
+     * Rebuild entire resource from events
+     * Useful for recovery or initial sync
+     */
+    rebuildResource(resourceId: ResourceId): Promise<void>;
+    /**
+     * Rebuild entire GraphDB from all events
+     * Uses two-pass approach to ensure all resources exist before creating REFERENCES edges
+     */
+    rebuildAll(): Promise<void>;
+    /**
+     * Get consumer health metrics
+     */
+    getHealthMetrics(): {
+        subscriptions: number;
+        lastProcessed: Record<string, number>;
+        processing: string[];
+    };
+    /**
+     * Unsubscribe from resource
+     */
+    unsubscribeFromResource(resourceId: ResourceId): Promise<void>;
+    /**
+     * Unsubscribe from all resources
+     */
+    unsubscribeAll(): Promise<void>;
+    /**
+     * Shutdown consumer
+     */
+    shutdown(): Promise<void>;
+}
+
+/**
+ * Make-Meaning Service
+ *
+ * Consolidates all meaning-making infrastructure:
+ * - Job queue initialization
+ * - Worker instantiation and startup
+ * - Graph consumer (event-to-graph synchronization)
+ *
+ * Provides a clean interface similar to createEventStore():
+ *   const makeMeaning = await startMakeMeaning(config);
+ */
+
+interface MakeMeaningService {
+    jobQueue: JobQueue;
+    eventStore: EventStore;
+    repStore: RepresentationStore;
+    inferenceClient: InferenceClient;
+    graphDb: GraphDatabase;
+    workers: {
+        detection: ReferenceDetectionWorker;
+        generation: GenerationWorker;
+        highlight: HighlightDetectionWorker;
+        assessment: AssessmentDetectionWorker;
+        comment: CommentDetectionWorker;
+        tag: TagDetectionWorker;
+    };
+    graphConsumer: GraphDBConsumer;
+    stop: () => Promise<void>;
+}
+declare function startMakeMeaning(config: EnvironmentConfig): Promise<MakeMeaningService>;
 
 /**
  * Resource Context
@@ -12,7 +288,7 @@ import { EventStore } from '@semiont/event-sourcing';
  * Does NOT touch the graph - graph queries go through GraphContext
  */
 
-type ResourceDescriptor$2 = components['schemas']['ResourceDescriptor'];
+type ResourceDescriptor$1 = components['schemas']['ResourceDescriptor'];
 interface ListResourcesFilters {
     search?: string;
     archived?: boolean;
@@ -21,16 +297,16 @@ declare class ResourceContext {
     /**
      * Get resource metadata from view storage
      */
-    static getResourceMetadata(resourceId: ResourceId, config: EnvironmentConfig): Promise<ResourceDescriptor$2 | null>;
+    static getResourceMetadata(resourceId: ResourceId, config: EnvironmentConfig): Promise<ResourceDescriptor$1 | null>;
     /**
      * List all resources by scanning view storage
      */
-    static listResources(filters: ListResourcesFilters | undefined, config: EnvironmentConfig): Promise<ResourceDescriptor$2[]>;
+    static listResources(filters: ListResourcesFilters | undefined, config: EnvironmentConfig): Promise<ResourceDescriptor$1[]>;
     /**
      * 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$2[], config: EnvironmentConfig): Promise<Array<ResourceDescriptor$2 & {
+    static addContentPreviews(resources: ResourceDescriptor$1[], config: EnvironmentConfig): Promise<Array<ResourceDescriptor$1 & {
         content: string;
     }>>;
 }
@@ -128,6 +404,7 @@ declare class AnnotationContext {
     private static extractAnnotationContext;
     /**
      * Generate LLM summary of annotation in context
+     * Creates inference client per-request (HTTP handler context)
      */
     private static generateSummary;
 }
@@ -140,7 +417,7 @@ declare class AnnotationContext {
  */
 
 type Annotation = components['schemas']['Annotation'];
-type ResourceDescriptor$1 = components['schemas']['ResourceDescriptor'];
+type ResourceDescriptor = components['schemas']['ResourceDescriptor'];
 declare class GraphContext {
     /**
      * Get all resources referencing this resource (backlinks)
@@ -161,7 +438,102 @@ declare class GraphContext {
      * Search resources by name (cross-resource query)
      * Requires full-text search - must use graph database
      */
-    static searchResources(query: string, config: EnvironmentConfig, limit?: number): Promise<ResourceDescriptor$1[]>;
+    static searchResources(query: string, config: EnvironmentConfig, limit?: number): Promise<ResourceDescriptor[]>;
+}
+
+/**
+ * Response parsers for annotation detection motivations
+ *
+ * Provides static methods to parse and validate AI responses for each motivation type.
+ * Includes offset validation and correction logic.
+ * Extracted from worker implementations to centralize parsing logic.
+ */
+/**
+ * Represents a detected comment with validated position
+ */
+interface CommentMatch {
+    exact: string;
+    start: number;
+    end: number;
+    prefix?: string;
+    suffix?: string;
+    comment: string;
+}
+/**
+ * Represents a detected highlight with validated position
+ */
+interface HighlightMatch {
+    exact: string;
+    start: number;
+    end: number;
+    prefix?: string;
+    suffix?: string;
+}
+/**
+ * Represents a detected assessment with validated position
+ */
+interface AssessmentMatch {
+    exact: string;
+    start: number;
+    end: number;
+    prefix?: string;
+    suffix?: string;
+    assessment: string;
+}
+/**
+ * Represents a detected tag with validated position
+ */
+interface TagMatch {
+    exact: string;
+    start: number;
+    end: number;
+    prefix?: string;
+    suffix?: string;
+    category: string;
+}
+declare class MotivationParsers {
+    /**
+     * Parse and validate AI response for comment detection
+     *
+     * @param response - Raw AI response string (may include markdown code fences)
+     * @param content - Original content to validate offsets against
+     * @returns Array of validated comment matches
+     */
+    static parseComments(response: string, content: string): CommentMatch[];
+    /**
+     * Parse and validate AI response for highlight detection
+     *
+     * @param response - Raw AI response string (may include markdown code fences)
+     * @param content - Original content to validate offsets against
+     * @returns Array of validated highlight matches
+     */
+    static parseHighlights(response: string, content: string): HighlightMatch[];
+    /**
+     * Parse and validate AI response for assessment detection
+     *
+     * @param response - Raw AI response string (may include markdown code fences)
+     * @param content - Original content to validate offsets against
+     * @returns Array of validated assessment matches
+     */
+    static parseAssessments(response: string, content: string): AssessmentMatch[];
+    /**
+     * Parse and validate AI response for tag detection
+     * Note: Does NOT validate offsets - caller must do that with content
+     *
+     * @param response - Raw AI response string (may include markdown code fences)
+     * @returns Array of tag matches (offsets not yet validated)
+     */
+    static parseTags(response: string): Omit<TagMatch, 'category'>[];
+    /**
+     * Validate tag offsets against content and add category
+     * Helper for tag detection after initial parsing
+     *
+     * @param tags - Parsed tags without validated offsets
+     * @param content - Original content to validate against
+     * @param category - Category to assign to validated tags
+     * @returns Array of validated tag matches
+     */
+    static validateTagOffsets(tags: Omit<TagMatch, 'category'>[], content: string, category: string): TagMatch[];
 }
 
 /**
@@ -184,43 +556,47 @@ declare class AnnotationDetection {
      *
      * @param resourceId - The resource to analyze
      * @param config - Environment configuration
+     * @param client - Inference client for AI operations
      * @param instructions - Optional user instructions for comment generation
      * @param tone - Optional tone guidance (e.g., "academic", "conversational")
      * @param density - Optional target number of comments per 2000 words
      * @returns Array of validated comment matches
      */
-    static detectComments(resourceId: ResourceId, config: EnvironmentConfig, instructions?: string, tone?: string, density?: number): Promise<CommentMatch[]>;
+    static detectComments(resourceId: ResourceId, config: EnvironmentConfig, client: InferenceClient, instructions?: string, tone?: string, density?: number): Promise<CommentMatch[]>;
     /**
      * Detect highlights in a resource
      *
      * @param resourceId - The resource to analyze
      * @param config - Environment configuration
+     * @param client - Inference client for AI operations
      * @param instructions - Optional user instructions for highlight selection
      * @param density - Optional target number of highlights per 2000 words
      * @returns Array of validated highlight matches
      */
-    static detectHighlights(resourceId: ResourceId, config: EnvironmentConfig, instructions?: string, density?: number): Promise<HighlightMatch[]>;
+    static detectHighlights(resourceId: ResourceId, config: EnvironmentConfig, client: InferenceClient, instructions?: string, density?: number): Promise<HighlightMatch[]>;
     /**
      * Detect assessments in a resource
      *
      * @param resourceId - The resource to analyze
      * @param config - Environment configuration
+     * @param client - Inference client for AI operations
      * @param instructions - Optional user instructions for assessment generation
      * @param tone - Optional tone guidance (e.g., "critical", "supportive")
      * @param density - Optional target number of assessments per 2000 words
      * @returns Array of validated assessment matches
      */
-    static detectAssessments(resourceId: ResourceId, config: EnvironmentConfig, instructions?: string, tone?: string, density?: number): Promise<AssessmentMatch[]>;
+    static detectAssessments(resourceId: ResourceId, config: EnvironmentConfig, client: InferenceClient, instructions?: string, tone?: string, density?: number): Promise<AssessmentMatch[]>;
     /**
      * Detect tags in a resource for a specific category
      *
      * @param resourceId - The resource to analyze
      * @param config - Environment configuration
+     * @param client - Inference client for AI operations
      * @param schemaId - The tag schema identifier (e.g., "irac", "imrad")
      * @param category - The specific category to detect
      * @returns Array of validated tag matches
      */
-    static detectTags(resourceId: ResourceId, config: EnvironmentConfig, schemaId: string, category: string): Promise<TagMatch[]>;
+    static detectTags(resourceId: ResourceId, config: EnvironmentConfig, client: InferenceClient, schemaId: string, category: string): Promise<TagMatch[]>;
     /**
      * Load resource content from representation store
      * Helper method used by all detection methods
@@ -233,172 +609,108 @@ declare class AnnotationDetection {
 }
 
 /**
- * Comment Detection Worker
+ * Prompt builders for annotation detection motivations
  *
- * Processes comment-detection jobs: runs AI inference to identify passages
- * that would benefit from explanatory comments and creates comment annotations.
+ * Provides static methods to build AI prompts for each Web Annotation motivation type.
+ * Extracted from worker implementations to centralize prompt logic.
  */
-
-declare class CommentDetectionWorker extends JobWorker {
-    private config;
-    private eventStore;
-    private isFirstProgress;
-    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore);
-    protected getWorkerName(): string;
-    protected canProcessJob(job: Job): boolean;
-    protected executeJob(job: Job): Promise<void>;
+declare class MotivationPrompts {
     /**
-     * Override updateJobProgress to emit events to Event Store
+     * Build a prompt for detecting comment-worthy passages
+     *
+     * @param content - The text content to analyze (will be truncated to 8000 chars)
+     * @param instructions - Optional user-provided instructions
+     * @param tone - Optional tone guidance (e.g., "academic", "conversational")
+     * @param density - Optional target number of comments per 2000 words
+     * @returns Formatted prompt string
      */
-    protected updateJobProgress(job: Job): Promise<void>;
-    protected handleJobFailure(job: Job, error: any): Promise<void>;
-    private processCommentDetectionJob;
-    private createCommentAnnotation;
-}
-
-/**
- * Highlight Detection Worker
- *
- * Processes highlight-detection jobs: runs AI inference to find passages
- * that should be highlighted and creates highlight annotations.
- */
-
-declare class HighlightDetectionWorker extends JobWorker {
-    private config;
-    private eventStore;
-    private isFirstProgress;
-    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore);
-    protected getWorkerName(): string;
-    protected canProcessJob(job: Job): boolean;
-    protected executeJob(job: Job): Promise<void>;
+    static buildCommentPrompt(content: string, instructions?: string, tone?: string, density?: number): string;
     /**
-     * Override updateJobProgress to emit events to Event Store
+     * Build a prompt for detecting highlight-worthy passages
+     *
+     * @param content - The text content to analyze (will be truncated to 8000 chars)
+     * @param instructions - Optional user-provided instructions
+     * @param density - Optional target number of highlights per 2000 words
+     * @returns Formatted prompt string
      */
-    protected updateJobProgress(job: Job): Promise<void>;
-    protected handleJobFailure(job: Job, error: any): Promise<void>;
-    private processHighlightDetectionJob;
-    private createHighlightAnnotation;
-}
-
-/**
- * Assessment Detection Worker
- *
- * Processes assessment-detection jobs: runs AI inference to assess/evaluate
- * passages in the text and creates assessment annotations.
- */
-
-declare class AssessmentDetectionWorker extends JobWorker {
-    private config;
-    private eventStore;
-    private isFirstProgress;
-    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore);
-    protected getWorkerName(): string;
-    protected canProcessJob(job: Job): boolean;
-    protected executeJob(job: Job): Promise<void>;
+    static buildHighlightPrompt(content: string, instructions?: string, density?: number): string;
     /**
-     * Override updateJobProgress to emit events to Event Store
+     * Build a prompt for detecting assessment-worthy passages
+     *
+     * @param content - The text content to analyze (will be truncated to 8000 chars)
+     * @param instructions - Optional user-provided instructions
+     * @param tone - Optional tone guidance (e.g., "critical", "supportive")
+     * @param density - Optional target number of assessments per 2000 words
+     * @returns Formatted prompt string
      */
-    protected updateJobProgress(job: Job): Promise<void>;
-    protected handleJobFailure(job: Job, error: any): Promise<void>;
-    private processAssessmentDetectionJob;
-    private createAssessmentAnnotation;
+    static buildAssessmentPrompt(content: string, instructions?: string, tone?: string, density?: number): string;
+    /**
+     * Build a prompt for detecting structural tags
+     *
+     * @param content - The full text content to analyze (NOT truncated for structural analysis)
+     * @param category - The specific category to detect
+     * @param schemaName - Human-readable schema name
+     * @param schemaDescription - Schema description
+     * @param schemaDomain - Schema domain
+     * @param categoryDescription - Category description
+     * @param categoryExamples - Example questions/guidance for this category
+     * @returns Formatted prompt string
+     */
+    static buildTagPrompt(content: string, category: string, schemaName: string, schemaDescription: string, schemaDomain: string, categoryDescription: string, categoryExamples: string[]): string;
 }
 
 /**
- * Tag Detection Worker
- *
- * Processes tag-detection jobs: runs AI inference to identify passages
- * serving specific structural roles (IRAC, IMRAD, Toulmin, etc.) and
- * creates tag annotations with dual-body structure.
+ * Entity reference extracted from text
  */
-
-declare class TagDetectionWorker extends JobWorker {
-    private config;
-    private eventStore;
-    private isFirstProgress;
-    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore);
-    protected getWorkerName(): string;
-    protected canProcessJob(job: Job): boolean;
-    protected executeJob(job: Job): Promise<void>;
-    /**
-     * Override updateJobProgress to emit events to Event Store
-     */
-    protected updateJobProgress(job: Job): Promise<void>;
-    protected handleJobFailure(job: Job, error: any): Promise<void>;
-    private processTagDetectionJob;
-    private createTagAnnotation;
+interface ExtractedEntity {
+    exact: string;
+    entityType: string;
+    startOffset: number;
+    endOffset: number;
+    prefix?: string;
+    suffix?: string;
 }
-
 /**
- * Reference Detection Worker
+ * Extract entity references from text using AI
  *
- * Processes detection jobs: runs AI inference to find entities in resources
- * and emits reference.created events for each detected entity.
- *
- * This worker is INDEPENDENT of HTTP clients - it just processes jobs and emits events.
+ * @param text - The text to analyze
+ * @param entityTypes - Array of entity types to detect (optionally with examples)
+ * @param client - Inference client for AI operations
+ * @param includeDescriptiveReferences - Include anaphoric/cataphoric references (default: false)
+ * @returns Array of extracted entities with their character offsets
  */
-
-type ResourceDescriptor = components['schemas']['ResourceDescriptor'];
-interface DetectedAnnotation {
-    annotation: {
-        selector: {
-            start: number;
-            end: number;
-            exact: string;
-            prefix?: string;
-            suffix?: string;
-        };
-        entityTypes: string[];
-    };
-}
-declare class ReferenceDetectionWorker extends JobWorker {
-    private config;
-    private eventStore;
-    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore);
-    protected getWorkerName(): string;
-    protected canProcessJob(job: Job): boolean;
-    protected executeJob(job: Job): Promise<void>;
-    /**
-     * Detect entity references in resource using AI
-     * Self-contained implementation for reference detection
-     *
-     * Public for testing charset handling - see entity-detection-charset.test.ts
-     */
-    detectReferences(resource: ResourceDescriptor, entityTypes: string[], includeDescriptiveReferences?: boolean): Promise<DetectedAnnotation[]>;
-    private processDetectionJob;
-    protected handleJobFailure(job: Job, error: any): Promise<void>;
-    /**
-     * Update job progress and emit events to Event Store
-     * Overrides base class to also emit job progress events
-     */
-    protected updateJobProgress(job: Job): Promise<void>;
-}
+declare function extractEntities(exact: string, entityTypes: string[] | {
+    type: string;
+    examples?: string[];
+}[], client: InferenceClient, includeDescriptiveReferences?: boolean): Promise<ExtractedEntity[]>;
 
 /**
- * Generation Worker
- *
- * Processes generation jobs: runs AI inference to generate new resources
- * and emits resource.created and annotation.body.updated events.
+ * Resource Generation Functions
  *
- * This worker is INDEPENDENT of HTTP clients - it just processes jobs and emits events.
+ * Application-specific resource generation logic including:
+ * - Markdown resource generation from topics
+ * - Resource summary generation
+ * - Reference suggestion generation
+ * - Language handling and template processing
  */
 
-declare class GenerationWorker extends JobWorker {
-    private config;
-    private eventStore;
-    constructor(jobQueue: JobQueue, config: EnvironmentConfig, eventStore: EventStore);
-    protected getWorkerName(): string;
-    protected canProcessJob(job: Job): boolean;
-    protected executeJob(job: Job): Promise<void>;
-    private processGenerationJob;
-    /**
-     * Update job progress and emit events to Event Store
-     * Overrides base class to also emit job progress events
-     */
-    protected updateJobProgress(job: Job): Promise<void>;
-}
+/**
+ * Generate resource content using inference
+ */
+declare function generateResourceFromTopic(topic: string, entityTypes: string[], client: InferenceClient, userPrompt?: string, locale?: string, context?: GenerationContext, temperature?: number, maxTokens?: number): Promise<{
+    title: string;
+    content: string;
+}>;
+/**
+ * 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, AnnotationDetection, AssessmentDetectionWorker, type BuildContextOptions, CommentDetectionWorker, GenerationWorker, GraphContext, HighlightDetectionWorker, type ListResourcesFilters, PACKAGE_NAME, ReferenceDetectionWorker, ResourceContext, TagDetectionWorker, VERSION };
+export { AnnotationContext, AnnotationDetection, AssessmentDetectionWorker, type AssessmentMatch, type BuildContextOptions, CommentDetectionWorker, type CommentMatch, type ExtractedEntity, GenerationWorker, GraphContext, GraphDBConsumer, HighlightDetectionWorker, type HighlightMatch, type ListResourcesFilters, type MakeMeaningService, MotivationParsers, MotivationPrompts, PACKAGE_NAME, ReferenceDetectionWorker, ResourceContext, TagDetectionWorker, type TagMatch, VERSION, extractEntities, generateReferenceSuggestions, generateResourceFromTopic, generateResourceSummary, startMakeMeaning };