@semiont/core 0.5.5 → 0.5.7

package/dist/index.js

@@ -108,12 +108,14 @@ var PERSISTED_EVENT_TYPES = [
 
 // src/bus-protocol.ts
 var RESOURCE_BROADCAST_TYPES = [
-  // Post-unification: job:complete / job:fail carry the "job ended on
-  // this resource" signal that yield:finished / yield:failed used to.
-  // Scope them by resource so every viewer of the affected resource
-  // — not just the initiator — can react (toast, refresh, etc.).
-  "job:complete",
-  "job:fail"
+  // Currently empty. `job:complete` / `job:fail` were moved to GLOBAL,
+  // `jobId`-keyed correlation delivery (#847): the dispatching caller
+  // filters by `jobId`, and resource viewers filter the same global stream
+  // by `resourceId` — no resource-scoped copy, so a client that is both
+  // dispatcher and viewer no longer receives it twice. This set remains as
+  // the extension point for *genuine* resource-bound broadcasts — events
+  // every viewer of a resource should see and no single caller owns (e.g.
+  // resource-generation progress for multiple viewers).
 ];
 var CHANNEL_SCHEMAS = {
   // ── YIELD FLOW ──────────────────────────────────────────────────
@@ -479,6 +481,8 @@ var ScopedEventBus = class _ScopedEventBus {
     this.parent = parent;
     this.scopePrefix = scopePrefix;
   }
+  parent;
+  scopePrefix;
   /**
    * Get the RxJS Subject for a scoped event
    *
@@ -913,6 +917,30 @@ function extractBoundingBox(svg) {
   return null;
 }
 
+// src/pdf-coordinates.ts
+function createFragmentSelector(coord) {
+  return `page=${coord.page}&viewrect=${coord.x},${coord.y},${coord.width},${coord.height}`;
+}
+function parseFragmentSelector(fragment) {
+  const pageMatch = fragment.match(/page=(\d+)/);
+  if (!pageMatch) return null;
+  const viewrectMatch = fragment.match(
+    /viewrect=(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?),(-?\d+(?:\.\d+)?)/
+  );
+  if (!viewrectMatch) return null;
+  return {
+    page: parseInt(pageMatch[1], 10),
+    x: parseFloat(viewrectMatch[1]),
+    y: parseFloat(viewrectMatch[2]),
+    width: parseFloat(viewrectMatch[3]),
+    height: parseFloat(viewrectMatch[4])
+  };
+}
+function getPageFromFragment(fragment) {
+  const match = fragment.match(/page=(\d+)/);
+  return match ? parseInt(match[1], 10) : null;
+}
+
 // src/resource-utils.ts
 function getResourceId(resource) {
   if (!resource) return void 0;
@@ -1065,9 +1093,52 @@ function levenshteinDistance(str1, str2) {
   }
   return matrix[len1][len2];
 }
+function normalizeTextWithMap(input) {
+  let normalized = "";
+  const map = [];
+  let pendingWhitespaceStart = -1;
+  const flushWhitespace = () => {
+    if (pendingWhitespaceStart !== -1) {
+      if (normalized.length > 0) {
+        normalized += " ";
+        map.push(pendingWhitespaceStart);
+      }
+      pendingWhitespaceStart = -1;
+    }
+  };
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (/\s/.test(ch)) {
+      if (pendingWhitespaceStart === -1) pendingWhitespaceStart = i;
+      continue;
+    }
+    flushWhitespace();
+    if (ch === "\u2018" || ch === "\u2019") {
+      normalized += "'";
+      map.push(i);
+    } else if (ch === "\u201C" || ch === "\u201D") {
+      normalized += '"';
+      map.push(i);
+    } else if (ch === "\u2014") {
+      normalized += "--";
+      map.push(i);
+      map.push(i);
+    } else if (ch === "\u2013") {
+      normalized += "-";
+      map.push(i);
+    } else {
+      normalized += ch;
+      map.push(i);
+    }
+  }
+  map.push(input.length);
+  return { normalized, map };
+}
 function buildContentCache(content) {
+  const { normalized, map } = normalizeTextWithMap(content);
   return {
-    normalizedContent: normalizeText(content),
+    normalizedContent: normalized,
+    normalizedMap: map,
     lowerContent: content.toLowerCase()
   };
 }
@@ -1084,19 +1155,11 @@ function findBestTextMatch(content, searchText, positionHint, cache) {
   const normalizedSearch = normalizeText(searchText);
   const normalizedIndex = cache.normalizedContent.indexOf(normalizedSearch);
   if (normalizedIndex !== -1) {
-    let actualPos = 0;
-    let normalizedPos = 0;
-    while (normalizedPos < normalizedIndex && actualPos < content.length) {
-      const char = content[actualPos];
-      const normalizedChar = normalizeText(char);
-      if (normalizedChar) {
-        normalizedPos += normalizedChar.length;
-      }
-      actualPos++;
-    }
+    const start = cache.normalizedMap[normalizedIndex] ?? 0;
+    const end = cache.normalizedMap[normalizedIndex + normalizedSearch.length] ?? content.length;
     return {
-      start: actualPos,
-      end: actualPos + searchText.length,
+      start,
+      end,
       matchQuality: "normalized"
     };
   }
@@ -1132,58 +1195,154 @@ function findBestTextMatch(content, searchText, positionHint, cache) {
   }
   return null;
 }
-function findTextWithContext(content, exact, prefix, suffix, positionHint, cache) {
-  if (!exact) return null;
-  if (positionHint !== void 0 && positionHint >= 0 && positionHint + exact.length <= content.length) {
-    if (content.substring(positionHint, positionHint + exact.length) === exact) {
-      return { start: positionHint, end: positionHint + exact.length };
+function verifyPosition(content, position, expectedExact) {
+  const actualText = content.substring(position.start, position.end);
+  return actualText === expectedExact;
+}
+
+// src/anchor-annotation.ts
+var POSITION_WINDOW = 1024;
+var CONTEXT_FULL_WEIGHT = 10;
+var CONTEXT_PARTIAL_WEIGHT = 5;
+var POSITION_WEIGHT_MAX = 5;
+function anchorAnnotation(content, selectors) {
+  const { position, quote } = selectors;
+  if (!quote || !quote.exact) {
+    if (!position) return null;
+    if (position.start < 0 || position.end > content.length || position.start >= position.end) {
+      return null;
     }
+    return {
+      start: position.start,
+      end: position.end,
+      strategy: "position-fallback",
+      confidence: "low"
+    };
   }
-  const occurrences = [];
-  let index = content.indexOf(exact);
-  while (index !== -1) {
-    occurrences.push(index);
-    index = content.indexOf(exact, index + 1);
-  }
-  if (occurrences.length === 0) {
-    const fuzzyMatch = findBestTextMatch(content, exact, positionHint, cache);
-    if (fuzzyMatch) {
-      return { start: fuzzyMatch.start, end: fuzzyMatch.end };
+  const { exact, prefix, suffix } = quote;
+  if (position) {
+    const probeEnd = position.start + exact.length;
+    if (position.start >= 0 && probeEnd <= content.length && content.substring(position.start, probeEnd) === exact) {
+      return {
+        start: position.start,
+        end: probeEnd,
+        strategy: "fast-path",
+        confidence: "high"
+      };
     }
-    return null;
   }
+  const occurrences = findAllOccurrences(content, exact);
   if (occurrences.length === 1) {
-    const pos2 = occurrences[0];
-    return { start: pos2, end: pos2 + exact.length };
-  }
-  if (prefix || suffix) {
-    for (const pos2 of occurrences) {
-      const actualPrefixStart = Math.max(0, pos2 - (prefix?.length || 0));
-      const actualPrefix = content.substring(actualPrefixStart, pos2);
-      const actualSuffixEnd = Math.min(content.length, pos2 + exact.length + (suffix?.length || 0));
-      const actualSuffix = content.substring(pos2 + exact.length, actualSuffixEnd);
-      const prefixMatch = !prefix || actualPrefix.endsWith(prefix);
-      const suffixMatch = !suffix || actualSuffix.startsWith(suffix);
-      if (prefixMatch && suffixMatch) {
-        return { start: pos2, end: pos2 + exact.length };
-      }
+    const start = occurrences[0];
+    return {
+      start,
+      end: start + exact.length,
+      strategy: "unique-occurrence",
+      confidence: "high"
+    };
+  }
+  if (occurrences.length > 1) {
+    const winner = pickByScore(content, occurrences, exact, prefix, suffix, position?.start);
+    return winner;
+  }
+  if (position && position.start >= 0 && position.end <= content.length && position.start < position.end) {
+    return {
+      start: position.start,
+      end: position.end,
+      strategy: "position-fallback",
+      confidence: "low"
+    };
+  }
+  return null;
+}
+function findAllOccurrences(content, exact) {
+  const out = [];
+  let i = content.indexOf(exact);
+  while (i !== -1) {
+    out.push(i);
+    i = content.indexOf(exact, i + 1);
+  }
+  return out;
+}
+function contextScoreAt(content, pos, exact, prefix, suffix) {
+  let score = 0;
+  let prefixFull = true;
+  let suffixFull = true;
+  if (prefix) {
+    const adj = content.substring(Math.max(0, pos - prefix.length), pos);
+    if (adj.endsWith(prefix)) {
+      score += CONTEXT_FULL_WEIGHT;
+      prefixFull = true;
+    } else if (adj.includes(prefix.trim()) && prefix.trim().length > 0) {
+      score += CONTEXT_PARTIAL_WEIGHT;
+      prefixFull = false;
+    } else {
+      prefixFull = false;
     }
-    for (const pos2 of occurrences) {
-      const actualPrefix = content.substring(Math.max(0, pos2 - (prefix?.length || 0)), pos2);
-      const actualSuffix = content.substring(pos2 + exact.length, pos2 + exact.length + (suffix?.length || 0));
-      const fuzzyPrefixMatch = !prefix || actualPrefix.includes(prefix.trim());
-      const fuzzySuffixMatch = !suffix || actualSuffix.includes(suffix.trim());
-      if (fuzzyPrefixMatch && fuzzySuffixMatch) {
-        return { start: pos2, end: pos2 + exact.length };
-      }
+  }
+  if (suffix) {
+    const adj = content.substring(pos + exact.length, Math.min(content.length, pos + exact.length + suffix.length));
+    if (adj.startsWith(suffix)) {
+      score += CONTEXT_FULL_WEIGHT;
+      suffixFull = true;
+    } else if (adj.includes(suffix.trim()) && suffix.trim().length > 0) {
+      score += CONTEXT_PARTIAL_WEIGHT;
+      suffixFull = false;
+    } else {
+      suffixFull = false;
     }
   }
-  const pos = occurrences[0];
-  return { start: pos, end: pos + exact.length };
-}
-function verifyPosition(content, position, expectedExact) {
-  const actualText = content.substring(position.start, position.end);
-  return actualText === expectedExact;
+  const full = (prefix === void 0 || prefixFull) && (suffix === void 0 || suffixFull) && (prefix !== void 0 || suffix !== void 0);
+  return { score, full };
+}
+function positionScoreAt(pos, hint) {
+  if (hint === void 0) return 0;
+  const distance = Math.abs(pos - hint);
+  if (distance >= POSITION_WINDOW) return 0;
+  return POSITION_WEIGHT_MAX * (1 - distance / POSITION_WINDOW);
+}
+function pickByScore(content, occurrences, exact, prefix, suffix, hint) {
+  let bestPos = occurrences[0];
+  let bestScore = -1;
+  let bestContextFull = false;
+  let bestHasAnyContextSignal = false;
+  let bestHasAnyPositionSignal = false;
+  for (const pos of occurrences) {
+    const ctx = contextScoreAt(content, pos, exact, prefix, suffix);
+    const positionScore = positionScoreAt(pos, hint);
+    const total = ctx.score + positionScore;
+    if (total > bestScore) {
+      bestScore = total;
+      bestPos = pos;
+      bestContextFull = ctx.full;
+      bestHasAnyContextSignal = ctx.score > 0;
+      bestHasAnyPositionSignal = positionScore > 0;
+    }
+  }
+  let strategy;
+  let confidence;
+  if (bestContextFull) {
+    strategy = "context-disambiguated";
+    confidence = "high";
+  } else if (bestHasAnyContextSignal && !bestHasAnyPositionSignal) {
+    strategy = "context-disambiguated";
+    confidence = "medium";
+  } else if (bestHasAnyContextSignal && bestHasAnyPositionSignal) {
+    strategy = "position-tiebreaker";
+    confidence = "medium";
+  } else if (bestHasAnyPositionSignal) {
+    strategy = "position-tiebreaker";
+    confidence = "medium";
+  } else {
+    strategy = "position-tiebreaker";
+    confidence = "low";
+  }
+  return {
+    start: bestPos,
+    end: bestPos + exact.length,
+    strategy,
+    confidence
+  };
 }
 
 // src/locales.ts
@@ -1338,72 +1497,112 @@ function scaleSvgToNative(svg, displayWidth, displayHeight, imageWidth, imageHei
 }
 
 // src/text-context.ts
+var CONTEXT_LENGTH = 64;
+var MAX_EXTENSION = 32;
+var DISAMBIGUATION_MIN_WINDOW = 32;
 function extractContext(content, start, end) {
-  const CONTEXT_LENGTH = 64;
-  const MAX_EXTENSION = 32;
-  let prefix;
+  const result = {};
   if (start > 0) {
     let prefixStart = Math.max(0, start - CONTEXT_LENGTH);
     let extensionCount = 0;
     while (prefixStart > 0 && extensionCount < MAX_EXTENSION) {
       const char = content[prefixStart - 1];
-      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) {
-        break;
-      }
+      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) break;
       prefixStart--;
       extensionCount++;
     }
-    prefix = content.substring(prefixStart, start);
+    result.prefix = content.substring(prefixStart, start);
   }
-  let suffix;
   if (end < content.length) {
     let suffixEnd = Math.min(content.length, end + CONTEXT_LENGTH);
     let extensionCount = 0;
     while (suffixEnd < content.length && extensionCount < MAX_EXTENSION) {
       const char = content[suffixEnd];
-      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) {
-        break;
-      }
+      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) break;
       suffixEnd++;
       extensionCount++;
     }
-    suffix = content.substring(end, suffixEnd);
+    result.suffix = content.substring(end, suffixEnd);
   }
-  return { prefix, suffix };
+  return result;
 }
-function validateAndCorrectOffsets(content, aiStart, aiEnd, exact) {
-  const textAtOffset = content.substring(aiStart, aiEnd);
-  if (textAtOffset === exact) {
-    const context2 = extractContext(content, aiStart, aiEnd);
+function reconcileSelector(content, llm) {
+  const { exact, prefix: llmPrefix, suffix: llmSuffix } = llm;
+  if (!exact) return null;
+  const occurrences = [];
+  let i = content.indexOf(exact);
+  while (i !== -1) {
+    occurrences.push(i);
+    i = content.indexOf(exact, i + 1);
+  }
+  if (occurrences.length === 1) {
+    const start = occurrences[0];
+    const end = start + exact.length;
+    const ctx2 = extractContext(content, start, end);
     return {
-      start: aiStart,
-      end: aiEnd,
+      start,
+      end,
       exact,
-      prefix: context2.prefix,
-      suffix: context2.suffix,
-      corrected: false,
-      matchQuality: "exact"
+      ...ctx2.prefix !== void 0 ? { prefix: ctx2.prefix } : {},
+      ...ctx2.suffix !== void 0 ? { suffix: ctx2.suffix } : {},
+      anchorMethod: "unique-match"
+    };
+  }
+  if (occurrences.length > 1) {
+    if (llmPrefix || llmSuffix) {
+      const prefixWindow = Math.max(DISAMBIGUATION_MIN_WINDOW, llmPrefix?.length ?? 0);
+      const suffixWindow = Math.max(DISAMBIGUATION_MIN_WINDOW, llmSuffix?.length ?? 0);
+      for (const pos of occurrences) {
+        const candPrefix = content.substring(Math.max(0, pos - prefixWindow), pos);
+        const candSuffix = content.substring(
+          pos + exact.length,
+          Math.min(content.length, pos + exact.length + suffixWindow)
+        );
+        const prefixOk = !llmPrefix || candPrefix.endsWith(llmPrefix) || candPrefix.includes(llmPrefix.trim());
+        const suffixOk = !llmSuffix || candSuffix.startsWith(llmSuffix) || candSuffix.includes(llmSuffix.trim());
+        if (prefixOk && suffixOk) {
+          const start2 = pos;
+          const end2 = start2 + exact.length;
+          const ctx3 = extractContext(content, start2, end2);
+          return {
+            start: start2,
+            end: end2,
+            exact,
+            ...ctx3.prefix !== void 0 ? { prefix: ctx3.prefix } : {},
+            ...ctx3.suffix !== void 0 ? { suffix: ctx3.suffix } : {},
+            anchorMethod: "context-recovered"
+          };
+        }
+      }
+    }
+    const start = occurrences[0];
+    const end = start + exact.length;
+    const ctx2 = extractContext(content, start, end);
+    return {
+      start,
+      end,
+      exact,
+      ...ctx2.prefix !== void 0 ? { prefix: ctx2.prefix } : {},
+      ...ctx2.suffix !== void 0 ? { suffix: ctx2.suffix } : {},
+      anchorMethod: "first-of-many"
     };
   }
   const cache = buildContentCache(content);
-  const match = findBestTextMatch(content, exact, aiStart, cache);
-  if (!match) {
-    throw new Error(
-      "Cannot find acceptable match for text in content. All search strategies failed. Text may be hallucinated."
-    );
-  }
-  const actualText = content.substring(match.start, match.end);
-  const context = extractContext(content, match.start, match.end);
+  const fuzzy = findBestTextMatch(content, exact, void 0, cache);
+  if (!fuzzy) return null;
+  const actual = content.substring(fuzzy.start, fuzzy.end);
+  const ctx = extractContext(content, fuzzy.start, fuzzy.end);
   return {
-    start: match.start,
-    end: match.end,
-    exact: actualText,
-    // Use actual text from document, not AI's version
-    prefix: context.prefix,
-    suffix: context.suffix,
-    corrected: true,
-    fuzzyMatched: match.matchQuality !== "exact",
-    matchQuality: match.matchQuality
+    start: fuzzy.start,
+    end: fuzzy.end,
+    // Use the actual source text, not the LLM's version — the LLM may
+    // have emitted slightly different characters (smart vs straight
+    // quotes, etc.) and we store what's verifiable.
+    exact: actual,
+    ...ctx.prefix !== void 0 ? { prefix: ctx.prefix } : {},
+    ...ctx.suffix !== void 0 ? { suffix: ctx.suffix } : {},
+    anchorMethod: "fuzzy-match",
+    matchQuality: fuzzy.matchQuality
   };
 }
 
@@ -1464,35 +1663,142 @@ function isValidEmail(email2) {
   return emailRegex.test(email2);
 }
 
-// src/mime-utils.ts
-function getExtensionForMimeType(mimeType) {
-  const map = {
-    "text/plain": "txt",
-    "text/markdown": "md",
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "application/pdf": "pdf"
-  };
-  return map[mimeType] || "dat";
-}
-function isImageMimeType(mimeType) {
-  return mimeType === "image/png" || mimeType === "image/jpeg";
-}
-function isTextMimeType(mimeType) {
-  return mimeType === "text/plain" || mimeType === "text/markdown";
-}
-function isPdfMimeType(mimeType) {
-  return mimeType === "application/pdf";
-}
-function getMimeCategory(mimeType) {
-  if (isTextMimeType(mimeType)) {
-    return "text";
-  }
-  if (isImageMimeType(mimeType) || isPdfMimeType(mimeType)) {
-    return "image";
-  }
-  return "unsupported";
-}
+// src/media-types.ts
+var storedBinary = (extension, label) => ({
+  extension,
+  label,
+  render: "none",
+  anchoring: "none",
+  extractText: "none",
+  authorable: false,
+  uploadable: true
+});
+var storedText = (extension, label) => ({
+  ...storedBinary(extension, label),
+  extractText: "decode"
+});
+var MEDIA_TYPES = {
+  // Full-capability tier
+  "text/markdown": { extension: ".md", label: "Markdown", render: "text", anchoring: "text-selector", extractText: "decode", authorable: true, uploadable: true },
+  "text/plain": { extension: ".txt", label: "Plain Text", render: "text", anchoring: "text-selector", extractText: "decode", authorable: true, uploadable: true },
+  "text/html": { extension: ".html", label: "HTML", render: "text", anchoring: "text-selector", extractText: "decode", authorable: true, uploadable: true },
+  "application/json": { extension: ".json", label: "JSON", render: "text", anchoring: "text-selector", extractText: "decode", authorable: false, uploadable: true },
+  "image/png": { extension: ".png", label: "PNG image", render: "image", anchoring: "spatial", extractText: "none", authorable: false, uploadable: true },
+  "image/jpeg": { extension: ".jpg", label: "JPEG image", render: "image", anchoring: "spatial", extractText: "none", authorable: false, uploadable: true },
+  "application/pdf": { extension: ".pdf", label: "PDF", render: "pdf", anchoring: "spatial", extractText: "pdf-text-layer", authorable: false, uploadable: true },
+  // Storage tier — the big tent. Every row is a deliberate admission,
+  // promotable by editing its row. Text-flavored rows embed (decode).
+  // Text
+  "text/css": storedText(".css", "CSS"),
+  "text/csv": storedText(".csv", "CSV"),
+  "text/xml": storedText(".xml", "XML"),
+  // Structured-text application formats
+  "application/xml": storedText(".xml", "XML"),
+  "application/yaml": storedText(".yaml", "YAML"),
+  "application/x-yaml": storedText(".yaml", "YAML"),
+  // Programming languages
+  "text/javascript": storedText(".js", "JavaScript"),
+  "application/javascript": storedText(".js", "JavaScript"),
+  "text/x-typescript": storedText(".ts", "TypeScript"),
+  "application/typescript": storedText(".ts", "TypeScript"),
+  "text/x-python": storedText(".py", "Python source"),
+  "text/x-java": storedText(".java", "Java source"),
+  "text/x-c": storedText(".c", "C source"),
+  "text/x-c++": storedText(".cpp", "C++ source"),
+  "text/x-csharp": storedText(".cs", "C# source"),
+  "text/x-go": storedText(".go", "Go source"),
+  "text/x-rust": storedText(".rs", "Rust source"),
+  "text/x-ruby": storedText(".rb", "Ruby source"),
+  "text/x-php": storedText(".php", "PHP source"),
+  "text/x-swift": storedText(".swift", "Swift source"),
+  "text/x-kotlin": storedText(".kt", "Kotlin source"),
+  "text/x-shell": storedText(".sh", "Shell script"),
+  // Documents
+  "application/msword": storedBinary(".doc", "Word document (legacy)"),
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": storedBinary(".docx", "Word document"),
+  "application/vnd.ms-excel": storedBinary(".xls", "Excel spreadsheet (legacy)"),
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": storedBinary(".xlsx", "Excel spreadsheet"),
+  "application/vnd.ms-powerpoint": storedBinary(".ppt", "PowerPoint presentation (legacy)"),
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": storedBinary(".pptx", "PowerPoint presentation"),
+  // Archives
+  "application/zip": storedBinary(".zip", "ZIP archive"),
+  "application/gzip": storedBinary(".gz", "Gzip archive"),
+  "application/x-tar": storedBinary(".tar", "TAR archive"),
+  "application/x-7z-compressed": storedBinary(".7z", "7z archive"),
+  // Binaries
+  "application/octet-stream": storedBinary(".bin", "Binary"),
+  "application/wasm": storedBinary(".wasm", "WebAssembly module"),
+  // Images beyond the rendered pair
+  "image/gif": storedBinary(".gif", "GIF image"),
+  "image/webp": storedBinary(".webp", "WebP image"),
+  "image/svg+xml": storedBinary(".svg", "SVG image"),
+  "image/bmp": storedBinary(".bmp", "BMP image"),
+  "image/tiff": storedBinary(".tiff", "TIFF image"),
+  "image/x-icon": storedBinary(".ico", "Icon"),
+  // Video (before audio so .webm resolves to video)
+  "video/mp4": storedBinary(".mp4", "MP4 video"),
+  "video/mpeg": storedBinary(".mpeg", "MPEG video"),
+  "video/webm": storedBinary(".webm", "WebM video"),
+  "video/ogg": storedBinary(".ogv", "Ogg video"),
+  "video/quicktime": storedBinary(".mov", "QuickTime video"),
+  "video/x-msvideo": storedBinary(".avi", "AVI video"),
+  // Audio
+  "audio/mpeg": storedBinary(".mp3", "MP3 audio"),
+  "audio/wav": storedBinary(".wav", "WAV audio"),
+  "audio/ogg": storedBinary(".ogg", "Ogg audio"),
+  "audio/webm": storedBinary(".webm", "WebM audio"),
+  "audio/aac": storedBinary(".aac", "AAC audio"),
+  "audio/flac": storedBinary(".flac", "FLAC audio"),
+  // Fonts
+  "font/woff": storedBinary(".woff", "WOFF font"),
+  "font/woff2": storedBinary(".woff2", "WOFF2 font"),
+  "font/ttf": storedBinary(".ttf", "TrueType font"),
+  "font/otf": storedBinary(".otf", "OpenType font")
+};
+var REGISTRY = MEDIA_TYPES;
+function baseMediaType(format) {
+  return format.split(";")[0].trim().toLowerCase();
+}
+function isSupportedMediaType(format) {
+  return Object.hasOwn(MEDIA_TYPES, format);
+}
+function capabilitiesOf(format) {
+  return REGISTRY[baseMediaType(format)];
+}
+function extensionForMediaType(format) {
+  return capabilitiesOf(format)?.extension ?? ".dat";
+}
+var EXTENSION_TO_MEDIA_TYPE = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const type of Object.keys(MEDIA_TYPES)) {
+    const ext = MEDIA_TYPES[type].extension;
+    if (!map.has(ext)) map.set(ext, type);
+  }
+  return map;
+})();
+var EXTENSION_ALIASES = {
+  ".markdown": ".md",
+  ".htm": ".html",
+  ".jpeg": ".jpg",
+  ".yml": ".yaml"
+};
+function mediaTypeForExtension(ext) {
+  const lower = ext.trim().toLowerCase();
+  const dotted = lower.startsWith(".") ? lower : `.${lower}`;
+  return EXTENSION_TO_MEDIA_TYPE.get(EXTENSION_ALIASES[dotted] ?? dotted);
+}
+function textExtractionOf(format) {
+  const caps = capabilitiesOf(format);
+  if (caps) return caps.extractText;
+  return baseMediaType(format).startsWith("text/") ? "decode" : "none";
+}
+var REGISTRY_KEYS = Object.keys(MEDIA_TYPES);
+var AUTHORABLE_MEDIA_TYPES = REGISTRY_KEYS.filter(
+  (type) => MEDIA_TYPES[type].authorable
+);
+var EMBEDDABLE_MEDIA_TYPES = REGISTRY_KEYS.filter(
+  (type) => MEDIA_TYPES[type].extractText !== "none"
+);
 
 // src/type-guards.ts
 function isString(value) {
@@ -1535,6 +1841,8 @@ var SemiontError = class extends Error {
     this.name = "SemiontError";
     Error.captureStackTrace(this, this.constructor);
   }
+  code;
+  details;
 };
 var ValidationError = class extends SemiontError {
   constructor(message, details) {
@@ -1935,6 +2243,8 @@ var ConfigurationError = class extends Error {
     this.name = "ConfigurationError";
     this.cause = cause;
   }
+  environment;
+  suggestion;
   cause;
   /**
    * Format the error nicely for CLI output
@@ -1961,10 +2271,6 @@ function getAllPlatformTypes() {
   return ["aws", "container", "posix", "external"];
 }
 
-// src/index.ts
-var CORE_TYPES_VERSION = "0.1.0";
-var SDK_VERSION = "0.1.0";
-
-export { BRIDGED_CHANNELS, CHANNEL_SCHEMAS, CORE_TYPES_VERSION, ConfigurationError, ConflictError, EventBus, JWTTokenSchema, LOCALES, NotFoundError, PERSISTED_EVENT_TYPES, RESOURCE_BROADCAST_TYPES, SDK_VERSION, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, cloneToken, createCircleSvg, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, didToAgent, email, entityType, errField, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findTextWithContext, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getExtensionForMimeType, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isImageMimeType, isNull, isNullish, isNumber, isObject, isPdfMimeType, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isTag, isTextMimeType, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, normalizeCoordinates, normalizeText, parseEnvironment, parseSvgSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, userDID, userId, userToAgent, userToDid, validateAndCorrectOffsets, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, didToAgent, email, entityType, errField, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, formatLocaleDisplay, generateUuid, getAllLocaleCodes, getAllPlatformTypes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getExactText, getFragmentSelector, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getNodeEncoding, getPageFromFragment, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAnnotationId, isArchived, isArray, isAssessment, isBodyResolved, isBoolean, isComment, isDefined, isDraft, isEventRelatedToAnnotation, isFunction, isHighlight, isNull, isNullish, isNumber, isObject, isReference, isResolvedReference, isResourceId, isStoredEvent, isString, isStubReference, isSupportedMediaType, isTag, isUndefined, isValidEmail, isValidPlatformType, jobId, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map