@semiont/jobs 0.4.19 → 0.4.20

package/dist/index.js

@@ -2,7 +2,7 @@ import { promises, watch } from 'fs';
 import * as path from 'path';
 import { validateAndCorrectOffsets, getTargetSelector, getExactText, getLocaleEnglishName } from '@semiont/api-client';
 import { generateAnnotationId } from '@semiont/event-sourcing';
-import { userToAgent, userId, jobId, CREATION_METHODS, resourceId, annotationId } from '@semiont/core';
+import { userToAgent, userId, jobId, CREATION_METHODS, resourceId, annotationId, errField } from '@semiont/core';
 import { deriveStorageUri } from '@semiont/content';
 
 var __create = Object.create;
@@ -10944,75 +10944,92 @@ Example output:
         offsetsFromAI: `[${startOffset}:${endOffset}]`
       });
       const extractedText = exact.substring(startOffset, endOffset);
-      if (extractedText !== entity.exact) {
-        logger?.warn("Offset mismatch detected", {
-          expected: entity.exact,
-          foundAtOffsets: `[${startOffset}:${endOffset}]`,
-          foundText: extractedText
+      let anchorMethod;
+      if (extractedText === entity.exact) {
+        anchorMethod = "llm-exact";
+        logger?.debug("Entity anchored", {
+          text: entity.exact,
+          entityType: entity.entityType,
+          anchorMethod
         });
-        const contextStart = Math.max(0, startOffset - 50);
-        const contextEnd = Math.min(exact.length, endOffset + 50);
-        const contextBefore = exact.substring(contextStart, startOffset);
-        const contextAfter = exact.substring(endOffset, contextEnd);
-        logger?.debug("Context around AI offset", {
-          before: contextBefore,
-          extracted: extractedText,
-          after: contextAfter
+      } else {
+        logger?.debug("LLM offsets mismatch \u2014 attempting re-anchor", {
+          expected: entity.exact,
+          llmOffsets: `[${startOffset}:${endOffset}]`,
+          foundAtLlmOffsets: extractedText
         });
-        logger?.debug("Searching for exact match in resource");
-        let found = false;
-        if (entity.prefix || entity.suffix) {
-          logger?.debug("Using LLM-provided context for disambiguation", {
-            prefix: entity.prefix,
-            suffix: entity.suffix
+        let occurrenceCount = 0;
+        let firstOccurrence = -1;
+        let searchPos = 0;
+        while ((searchPos = exact.indexOf(entity.exact, searchPos)) !== -1) {
+          if (firstOccurrence === -1) firstOccurrence = searchPos;
+          occurrenceCount++;
+          searchPos++;
+        }
+        if (occurrenceCount === 0) {
+          anchorMethod = "dropped";
+          logger?.error("Entity text not found in resource \u2014 dropping", {
+            text: entity.exact,
+            entityType: entity.entityType,
+            llmOffsets: `[${startOffset}:${endOffset}]`,
+            anchorMethod,
+            resourceStart: exact.substring(0, 200)
           });
-          let searchPos = 0;
-          while ((searchPos = exact.indexOf(entity.exact, searchPos)) !== -1) {
-            const candidatePrefix = exact.substring(Math.max(0, searchPos - 32), searchPos);
+          return null;
+        }
+        let recoveredOffset = -1;
+        if (entity.prefix || entity.suffix) {
+          let p = 0;
+          while ((p = exact.indexOf(entity.exact, p)) !== -1) {
+            const candidatePrefix = exact.substring(Math.max(0, p - 32), p);
             const candidateSuffix = exact.substring(
-              searchPos + entity.exact.length,
-              Math.min(exact.length, searchPos + entity.exact.length + 32)
+              p + entity.exact.length,
+              Math.min(exact.length, p + entity.exact.length + 32)
             );
             const prefixMatch = !entity.prefix || candidatePrefix.endsWith(entity.prefix);
             const suffixMatch = !entity.suffix || candidateSuffix.startsWith(entity.suffix);
             if (prefixMatch && suffixMatch) {
-              logger?.debug("Found match using context", {
-                offset: searchPos,
-                offsetDiff: searchPos - startOffset,
-                candidatePrefix,
-                candidateSuffix
-              });
-              startOffset = searchPos;
-              endOffset = searchPos + entity.exact.length;
-              found = true;
+              recoveredOffset = p;
               break;
             }
-            searchPos++;
-          }
-          if (!found) {
-            logger?.warn("No occurrence found with matching context", { text: entity.exact });
+            p++;
           }
         }
-        if (!found) {
-          const index = exact.indexOf(entity.exact);
-          if (index !== -1) {
-            logger?.warn("Using first occurrence", {
-              text: entity.exact,
-              offset: index,
-              offsetDiff: index - startOffset
-            });
-            startOffset = index;
-            endOffset = index + entity.exact.length;
-          } else {
-            logger?.error("Cannot find entity anywhere in resource", {
-              text: entity.exact,
-              resourceStart: exact.substring(0, 200)
-            });
-            return null;
-          }
+        if (recoveredOffset !== -1) {
+          anchorMethod = "context-recovered";
+          startOffset = recoveredOffset;
+          endOffset = recoveredOffset + entity.exact.length;
+          logger?.debug("Entity anchored", {
+            text: entity.exact,
+            entityType: entity.entityType,
+            anchorMethod,
+            offsetDiff: recoveredOffset - entity.startOffset
+          });
+        } else if (occurrenceCount === 1) {
+          anchorMethod = "unique-match";
+          startOffset = firstOccurrence;
+          endOffset = firstOccurrence + entity.exact.length;
+          logger?.debug("Entity anchored", {
+            text: entity.exact,
+            entityType: entity.entityType,
+            anchorMethod,
+            offsetDiff: firstOccurrence - entity.startOffset
+          });
+        } else {
+          anchorMethod = "first-of-many";
+          startOffset = firstOccurrence;
+          endOffset = firstOccurrence + entity.exact.length;
+          logger?.warn("Entity anchored at first of multiple occurrences \u2014 may be wrong", {
+            text: entity.exact,
+            entityType: entity.entityType,
+            anchorMethod,
+            occurrenceCount,
+            chosenOffset: firstOccurrence,
+            llmOffsets: `[${entity.startOffset}:${entity.endOffset}]`,
+            hasPrefix: !!entity.prefix,
+            hasSuffix: !!entity.suffix
+          });
         }
-      } else {
-        logger?.debug("Offsets correct", { text: entity.exact });
       }
       return {
         exact: entity.exact,
@@ -11904,7 +11921,7 @@ var HighlightAnnotationWorker = class extends JobWorker {
         await this.createHighlightAnnotation(job.params.resourceId, job.metadata, highlight);
         created++;
       } catch (error) {
-        this.logger?.error("Failed to create highlight", { error });
+        this.logger?.error("Failed to create highlight", { error: errField(error) });
       }
     }
     updatedJob = {
@@ -12113,7 +12130,7 @@ var AssessmentAnnotationWorker = class extends JobWorker {
         await this.createAssessmentAnnotation(job.params.resourceId, job.metadata, assessment, job.params.language);
         created++;
       } catch (error) {
-        this.logger?.error("Failed to create assessment", { error });
+        this.logger?.error("Failed to create assessment", { error: errField(error) });
       }
     }
     updatedJob = {
@@ -12326,7 +12343,7 @@ var CommentAnnotationWorker = class extends JobWorker {
         await this.createCommentAnnotation(job.params.resourceId, job.metadata, comment, job.params.language);
         created++;
       } catch (error) {
-        this.logger?.error("Failed to create comment", { error });
+        this.logger?.error("Failed to create comment", { error: errField(error) });
       }
     }
     updatedJob = {
@@ -12571,7 +12588,7 @@ var TagAnnotationWorker = class extends JobWorker {
         await this.createTagAnnotation(job.params.resourceId, job.metadata, job.params.schemaId, tag);
         created++;
       } catch (error) {
-        this.logger?.error("Failed to create tag", { error });
+        this.logger?.error("Failed to create tag", { error: errField(error) });
       }
     }
     updatedJob = {