@semiont/core 0.5.23 → 0.5.25

package/dist/index.js

@@ -1,65 +1,8 @@
-import { Subject, Observable, merge, TimeoutError, throwError, firstValueFrom } from 'rxjs';
+export { createTomlConfigLoader, loadTomlConfig } from './chunk-XQTWEBJ5.js';
+import { BUS_OPERATIONS } from './chunk-FMFOBVTE.js';
+export { BRIDGED_CHANNELS, BUS_OPERATIONS, EventBus, ScopedEventBus, accessToken, annotationUri, authCode, baseUrl, busLog, busLogEnabled, cloneToken, email, entityType, googleCredential, jobId, mcpToken, refreshToken, resourceAnnotationUri, resourceUri, searchQuery, setBusLogTraceIdProvider, userDID } from './chunk-FMFOBVTE.js';
+import { Observable, merge, TimeoutError, throwError, firstValueFrom } from 'rxjs';
 import { filter, map, take, timeout, catchError, defaultIfEmpty } from 'rxjs/operators';
-import { parse } from 'smol-toml';
-
-// src/branded-types.ts
-function email(value) {
-  return value;
-}
-function authCode(value) {
-  return value;
-}
-function googleCredential(value) {
-  return value;
-}
-function accessToken(value) {
-  return value;
-}
-function refreshToken(value) {
-  return value;
-}
-function mcpToken(value) {
-  return value;
-}
-function cloneToken(value) {
-  return value;
-}
-function jobId(value) {
-  return value;
-}
-function userDID(value) {
-  return value;
-}
-function entityType(value) {
-  return value;
-}
-function searchQuery(value) {
-  return value;
-}
-function baseUrl(value) {
-  return value;
-}
-function resourceUri(uri) {
-  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-    throw new TypeError(`Expected ResourceUri, got: ${uri}`);
-  }
-  return uri;
-}
-function annotationUri(uri) {
-  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-    throw new TypeError(`Expected AnnotationUri, got: ${uri}`);
-  }
-  return uri;
-}
-function resourceAnnotationUri(uri) {
-  if (!uri.startsWith("http://") && !uri.startsWith("https://")) {
-    throw new TypeError(`Expected ResourceAnnotationUri, got: ${uri}`);
-  }
-  if (!uri.includes("/resources/") || !uri.includes("/annotations/")) {
-    throw new TypeError(`Expected nested ResourceAnnotationUri format, got: ${uri}`);
-  }
-  return uri;
-}
 
 // src/identifiers.ts
 function isResourceId(value) {
@@ -236,6 +179,10 @@ var CHANNEL_SCHEMAS = {
   "browse:resource-result": "BrowseResourceResult",
   "browse:resource-failed": null,
   // { correlationId } & CommandError
+  "browse:anchored-text-requested": "BrowseAnchoredTextRequest",
+  "browse:anchored-text-result": "BrowseAnchoredTextResult",
+  "browse:anchored-text-failed": null,
+  // { correlationId } & CommandError
   "browse:resources-requested": "BrowseResourcesRequest",
   "browse:resources-result": "BrowseResourcesResult",
   "browse:resources-failed": null,
@@ -328,12 +275,17 @@ var CHANNEL_SCHEMAS = {
   "weave:applied": null,
   // { resourceId; sequenceNumber }
   "smelt:settled": null,
-  // { resourceId; contentChecksum; outcome }
+  // { resourceId; contentChecksum; outcome; reason? }
   "weave:rebuild": "WeaveRebuildCommand",
   "weave:rebuild-ok": null,
   // { correlationId }
   "weave:rebuild-failed": null,
   // { correlationId; message }
+  "smelt:rebuild-anchors": "SmeltRebuildAnchorsCommand",
+  "smelt:rebuild-anchors-ok": null,
+  // { correlationId }
+  "smelt:rebuild-anchors-failed": null,
+  // { correlationId; message }
   // ── SSE infrastructure ──────────────────────────────────────────
   "stream-connected": null,
   // Record<string, never>
@@ -369,274 +321,6 @@ function isEventRelatedToAnnotation(event, annotationUri2) {
 function isStoredEvent(event) {
   return event && typeof event.id === "string" && typeof event.timestamp === "string" && typeof event.type === "string" && typeof event.metadata === "object" && typeof event.metadata.sequenceNumber === "number";
 }
-
-// src/bus-operations.ts
-var BUS_OPERATIONS = {
-  // ── BIND ────────────────────────────────────────────────────────
-  "bind:update-body": { result: "bind:body-updated", failure: "bind:body-update-failed" },
-  // ── BROWSE (reads) ──────────────────────────────────────────────
-  "browse:resource-requested": { result: "browse:resource-result", failure: "browse:resource-failed" },
-  "browse:resources-requested": { result: "browse:resources-result", failure: "browse:resources-failed" },
-  "browse:annotation-requested": { result: "browse:annotation-result", failure: "browse:annotation-failed" },
-  "browse:annotations-requested": { result: "browse:annotations-result", failure: "browse:annotations-failed" },
-  "browse:annotation-history-requested": { result: "browse:annotation-history-result", failure: "browse:annotation-history-failed" },
-  "browse:events-requested": { result: "browse:events-result", failure: "browse:events-failed" },
-  "browse:referenced-by-requested": { result: "browse:referenced-by-result", failure: "browse:referenced-by-failed" },
-  "browse:entity-types-requested": { result: "browse:entity-types-result", failure: "browse:entity-types-failed" },
-  "browse:tag-schemas-requested": { result: "browse:tag-schemas-result", failure: "browse:tag-schemas-failed" },
-  "browse:agents-requested": { result: "browse:agents-result", failure: "browse:agents-failed" },
-  "browse:directory-requested": { result: "browse:directory-result", failure: "browse:directory-failed" },
-  // dormant — backend handler complete, no client caller yet (annotation-detail capability)
-  "browse:annotation-context-requested": { result: "browse:annotation-context-result", failure: "browse:annotation-context-failed" },
-  // ── FRAME (KB schema writes) ────────────────────────────────────
-  "frame:add-entity-type": { result: "frame:entity-type-add-ok", failure: "frame:entity-type-add-failed" },
-  "frame:add-tag-schema": { result: "frame:tag-schema-add-ok", failure: "frame:tag-schema-add-failed" },
-  // ── GATHER ──────────────────────────────────────────────────────
-  // streaming: take-1 result + failure plus an intermediate progress channel
-  "gather:requested": { result: "gather:complete", failure: "gather:failed", progress: "gather:annotation-progress" },
-  "gather:resource-requested": { result: "gather:resource-complete", failure: "gather:resource-failed" },
-  // dormant — backend handler complete, no client caller yet (annotation summary)
-  "gather:summary-requested": { result: "gather:summary-result", failure: "gather:summary-failed" },
-  // ── JOB ─────────────────────────────────────────────────────────
-  "job:create": { result: "job:created", failure: "job:create-failed" },
-  "job:status-requested": { result: "job:status-result", failure: "job:status-failed" },
-  "job:cancel-requested": { result: "job:cancel-ok", failure: "job:cancel-failed" },
-  // worker-side: the worker claims a queued job (not an SDK call)
-  "job:claim": { result: "job:claimed", failure: "job:claim-failed" },
-  // ── MARK ────────────────────────────────────────────────────────
-  "mark:create-request": { result: "mark:create-ok", failure: "mark:create-failed" },
-  "mark:delete": { result: "mark:delete-ok", failure: "mark:delete-failed" },
-  "mark:archive": { result: "mark:archive-ok", failure: "mark:archive-failed" },
-  "mark:unarchive": { result: "mark:unarchive-ok", failure: "mark:unarchive-failed" },
-  "mark:update-entity-types": { result: "mark:update-entity-types-ok", failure: "mark:update-entity-types-failed" },
-  // ── MATCH ───────────────────────────────────────────────────────
-  // take-1 dressed as an Observable in the SDK; no progress channel
-  "match:search-requested": { result: "match:search-results", failure: "match:search-failed" },
-  // ── WEAVE ───────────────────────────────────────────────────────
-  // Graph-projection rebuild, served by the Weaver (WEAVER-ISOLATION D3)
-  "weave:rebuild": { result: "weave:rebuild-ok", failure: "weave:rebuild-failed" },
-  // ── YIELD ───────────────────────────────────────────────────────
-  // live in-process (resource-operations.ts emits + awaits via race()); the
-  // client also .on()-subscribes -ok for cache invalidation
-  "yield:create": { result: "yield:create-ok", failure: "yield:create-failed" },
-  // dormant — handler in stower exists, no request emitter; client pre-subscribes -ok
-  "yield:update": { result: "yield:update-ok", failure: "yield:update-failed" },
-  "yield:clone-create": { result: "yield:clone-created", failure: "yield:clone-create-failed" },
-  "yield:clone-resource-requested": { result: "yield:clone-resource-result", failure: "yield:clone-resource-failed" },
-  "yield:clone-token-requested": { result: "yield:clone-token-generated", failure: "yield:clone-token-failed" }
-};
-
-// src/bridged-channels.ts
-var BRIDGED_BROADCASTS = [
-  "job:report-progress",
-  "job:complete",
-  "job:fail",
-  "frame:entity-type-added",
-  "frame:tag-schema-added",
-  "beckon:focus",
-  "beckon:sparkle",
-  "bus:resume-gap"
-];
-var REGISTRY_REPLIES = Object.keys(BUS_OPERATIONS).flatMap(
-  (key) => {
-    const op = BUS_OPERATIONS[key];
-    return "progress" in op ? [op.result, op.failure, op.progress] : [op.result, op.failure];
-  }
-);
-var BRIDGED_CHANNELS = [
-  ...REGISTRY_REPLIES,
-  ...BRIDGED_BROADCASTS
-];
-
-// src/bus-log.ts
-var NODE_BUS_LOG = typeof process !== "undefined" && !!process.env?.SEMIONT_BUS_LOG;
-var IS_NODE = typeof process !== "undefined" && !!process.versions?.node;
-function busLogEnabled() {
-  const g = globalThis;
-  if (g.__SEMIONT_BUS_LOG__) return true;
-  return NODE_BUS_LOG;
-}
-var traceIdProvider;
-function setBusLogTraceIdProvider(fn) {
-  traceIdProvider = fn;
-}
-function busLog(op, channel, payload, scope) {
-  if (!busLogEnabled()) return;
-  const cidRaw = payload?.correlationId;
-  const cid = typeof cidRaw === "string" ? cidRaw.slice(0, 8) : void 0;
-  let traceId;
-  if (traceIdProvider) {
-    try {
-      traceId = traceIdProvider();
-    } catch {
-    }
-  }
-  const tag = `[bus ${op}] ${channel}` + (scope ? ` scope=${scope}` : "") + (cid ? ` cid=${cid}` : "") + (traceId ? ` trace=${traceId.slice(0, 8)}` : "");
-  console.debug(tag, payload);
-}
-function warnUnobservedRepliesEnabled() {
-  return IS_NODE;
-}
-var unobservedReplyWarned = /* @__PURE__ */ new Set();
-function warnIfUnobservedReply(channel, payload, observerCount) {
-  if (observerCount > 0) return;
-  const cidRaw = payload?.correlationId;
-  if (typeof cidRaw !== "string" || cidRaw.length === 0) return;
-  if (BRIDGED_CHANNELS.includes(channel)) return;
-  if (unobservedReplyWarned.has(channel)) return;
-  unobservedReplyWarned.add(channel);
-  console.warn(
-    `[bus DROP] ${channel} cid=${cidRaw.slice(0, 8)} emitted with 0 subscribers and not in BRIDGED_CHANNELS \u2014 a correlation reply with no forwarder is dropped, so the awaiting client times out (no error). Bridge it by declaring its operation in BUS_OPERATIONS (packages/core/src/bus-operations.ts) \u2014 or, if it is a non-reply broadcast, add it to BRIDGED_BROADCASTS (packages/core/src/bridged-channels.ts) \u2014 so transports subscribe to it.`
-  );
-}
-
-// src/event-bus.ts
-var EventBus = class {
-  subjects;
-  isDestroyed;
-  constructor() {
-    this.subjects = /* @__PURE__ */ new Map();
-    this.isDestroyed = false;
-  }
-  /**
-   * Get the RxJS Subject for an event
-   *
-   * Returns a typed Subject that can be used with all RxJS operators.
-   * Subjects are created lazily on first access.
-   *
-   * @param eventName - The event name
-   * @returns The RxJS Subject for this event
-   *
-   * @example
-   * ```typescript
-   * // Emit
-   * eventBus.get('beckon:hover').next({ annotationId: 'ann-1' });
-   *
-   * // Subscribe
-   * const sub = eventBus.get('beckon:hover').subscribe(handleHover);
-   *
-   * // With operators
-   * eventBus.get('beckon:hover')
-   *   .pipe(debounceTime(100), distinctUntilChanged())
-   *   .subscribe(handleHover);
-   * ```
-   */
-  get(eventName) {
-    if (this.isDestroyed) {
-      throw new Error(`Cannot access event '${String(eventName)}' on destroyed bus`);
-    }
-    if (!this.subjects.has(eventName)) {
-      const subject = new Subject();
-      const wantBusLog = busLogEnabled();
-      const wantDropCheck = warnUnobservedRepliesEnabled();
-      if (wantBusLog || wantDropCheck) {
-        const wrapped = subject;
-        const originalNext = subject.next.bind(subject);
-        subject.next = (value) => {
-          if (wantBusLog) busLog("EMIT", String(eventName), value);
-          if (wantDropCheck) warnIfUnobservedReply(String(eventName), value, wrapped.observers.length);
-          originalNext(value);
-        };
-      }
-      this.subjects.set(eventName, subject);
-    }
-    return this.subjects.get(eventName);
-  }
-  /**
-   * Get the RxJS Subject for a domain event type (PersistedEventType).
-   *
-   * Domain event channels carry `StoredEvent`. This method avoids the need
-   * for `as keyof EventMap` casts when subscribing to domain event channels
-   * using runtime `PersistedEventType` strings.
-   */
-  getDomainEvent(eventType) {
-    return this.get(eventType);
-  }
-  /**
-   * Destroy the event bus and complete all subjects
-   *
-   * After calling destroy(), no new events can be emitted or subscribed to.
-   * All active subscriptions will be completed.
-   */
-  destroy() {
-    if (this.isDestroyed) {
-      return;
-    }
-    for (const subject of this.subjects.values()) {
-      subject.complete();
-    }
-    this.subjects.clear();
-    this.isDestroyed = true;
-  }
-  /**
-   * Check if the event bus has been destroyed
-   */
-  get destroyed() {
-    return this.isDestroyed;
-  }
-  /**
-   * Create a resource-scoped event bus
-   *
-   * Events emitted or subscribed through the scoped bus are isolated to that resource.
-   * Internally, events are namespaced but the API remains identical to the parent bus.
-   *
-   * @param resourceId - Resource identifier to scope events to
-   * @returns A scoped event bus for this resource
-   *
-   * @example
-   * ```typescript
-   * const eventBus = new EventBus();
-   * const resource1 = eventBus.scope('resource-1');
-   * const resource2 = eventBus.scope('resource-2');
-   *
-   * // These are isolated - only resource1 subscribers will fire
-   * resource1.get('detection:progress').next({ status: 'started' });
-   * ```
-   */
-  scope(resourceId2) {
-    return new ScopedEventBus(this, resourceId2);
-  }
-};
-var ScopedEventBus = class _ScopedEventBus {
-  constructor(parent, scopePrefix) {
-    this.parent = parent;
-    this.scopePrefix = scopePrefix;
-  }
-  parent;
-  scopePrefix;
-  /**
-   * Get the RxJS Subject for a scoped event
-   *
-   * Returns the same type as the parent bus, but events are isolated to this scope.
-   * Internally uses namespaced keys but preserves type safety.
-   *
-   * @param event - The event name
-   * @returns The RxJS Subject for this scoped event
-   */
-  get(event) {
-    const scopedKey = `${this.scopePrefix}:${event}`;
-    const parentSubjects = this.parent.subjects;
-    if (!parentSubjects.has(scopedKey)) {
-      parentSubjects.set(scopedKey, new Subject());
-    }
-    return parentSubjects.get(scopedKey);
-  }
-  /** Get the RxJS Subject for a domain event type on this scoped bus. */
-  getDomainEvent(eventType) {
-    return this.get(eventType);
-  }
-  /**
-   * Create a nested scope
-   *
-   * Allows hierarchical scoping like `resource-1:subsystem-a`
-   *
-   * @param subScope - Additional scope level
-   * @returns A nested scoped event bus
-   */
-  scope(subScope) {
-    return new _ScopedEventBus(this.parent, `${this.scopePrefix}:${subScope}`);
-  }
-};
 function burstBuffer(options) {
   const { burstWindowMs, maxBatchSize, idleTimeoutMs } = options;
   return (source) => new Observable((subscriber) => {
@@ -781,8 +465,21 @@ function findBodyItem(body, identity) {
 }
 
 // src/id-generation.ts
+function v4Bytes() {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  return bytes;
+}
+function hex(bytes) {
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
 function generateUuid() {
-  return crypto.randomUUID().replace(/-/g, "");
+  return hex(v4Bytes());
+}
+function uuidV4() {
+  const h = hex(v4Bytes());
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
 }
 
 // src/annotation-assembly.ts
@@ -1057,6 +754,136 @@ function getPageFromFragment(fragment) {
   return match ? parseInt(match[1], 10) : null;
 }
 
+// src/pdf-anchoring.ts
+function isTextRun(item) {
+  return typeof item === "object" && item !== null && "str" in item;
+}
+function anchorRuns(runs, page) {
+  const items = [];
+  let text = "";
+  for (const run of runs) {
+    if (run.str.trim()) {
+      const start = text.length;
+      text += run.str;
+      const end = text.length;
+      const [, , , , x, y] = run.transform;
+      items.push({ start, end, page, x, y, width: run.width, height: run.height });
+      text += run.hasEOL ? "\n" : " ";
+    } else if (run.hasEOL) {
+      text += "\n";
+    }
+  }
+  return { text, items };
+}
+var SAME_LINE_THRESHOLD_PT = 2;
+function locate(anchored, start, end) {
+  const overlap = anchored.items.filter(
+    (item) => item.start < end && item.end > start
+  );
+  if (overlap.length === 0) return { rects: [], overlap };
+  const pages = groupItemsByPage(overlap);
+  const rects = [];
+  for (const [page, pageItems] of pages) {
+    const lines = groupItemsByLine(pageItems, SAME_LINE_THRESHOLD_PT);
+    for (const lineItems of lines) {
+      const edges = lineItems.map((i) => {
+        const chars = i.end - i.start;
+        const left = i.start < start && chars > 0 ? i.x + i.width * ((start - i.start) / chars) : i.x;
+        const right2 = i.end > end && chars > 0 ? i.x + i.width * ((end - i.start) / chars) : i.x + i.width;
+        return { left, right: right2 };
+      });
+      const x = Math.min(...edges.map((e) => e.left));
+      const right = Math.max(...edges.map((e) => e.right));
+      const y = Math.min(...lineItems.map((i) => i.y));
+      const top = Math.max(...lineItems.map((i) => i.y + i.height));
+      rects.push({ page, x, y, width: right - x, height: top - y });
+    }
+  }
+  return { rects, overlap };
+}
+function textUnder(anchored, rect) {
+  const covered = anchored.items.filter((item) => item.page === rect.page && covers(item, rect)).sort((a, b) => a.start - b.start);
+  if (covered.length === 0) return "";
+  let quoted = slice(anchored, covered[0]);
+  for (let i = 1; i < covered.length; i++) {
+    const gap = anchored.text.slice(covered[i - 1].end, covered[i].start);
+    quoted += (gap.trim() === "" ? gap : " ") + slice(anchored, covered[i]);
+  }
+  return quoted.trim();
+}
+var slice = (anchored, item) => anchored.text.slice(item.start, item.end);
+var RUN_COVERAGE_THRESHOLD = 0.5;
+function covers(item, rect) {
+  const overlapX = Math.min(item.x + item.width, rect.x + rect.width) - Math.max(item.x, rect.x);
+  const overlapY = Math.min(item.y + item.height, rect.y + rect.height) - Math.max(item.y, rect.y);
+  if (overlapX <= 0 || overlapY <= 0) return false;
+  return overlapX * overlapY >= RUN_COVERAGE_THRESHOLD * item.width * item.height;
+}
+function groupItemsByPage(items) {
+  const map2 = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const existing = map2.get(item.page);
+    if (existing) {
+      existing.push(item);
+    } else {
+      map2.set(item.page, [item]);
+    }
+  }
+  return map2;
+}
+function groupItemsByLine(items, sameLineThreshold) {
+  const sorted = [...items].sort((a, b) => b.y - a.y || a.x - b.x);
+  const lines = [];
+  let currentLine = [];
+  for (const item of sorted) {
+    if (currentLine.length === 0 || Math.abs(item.y - currentLine[0].y) <= sameLineThreshold) {
+      currentLine.push(item);
+    } else {
+      lines.push(currentLine);
+      currentLine = [item];
+    }
+  }
+  if (currentLine.length > 0) lines.push(currentLine);
+  return lines;
+}
+
+// src/pdf-citation-search.ts
+var BREAK_MARKER = "
";
+var BREAK_GAP = `(?: ?${BREAK_MARKER} ?)?`;
+var escapeRegExp = (ch) => ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function findClaimSpan(anchored, exact) {
+  const needle = exact.replace(/\s+/g, " ").trim();
+  if (needle.length === 0) return null;
+  let norm = "";
+  const map2 = [];
+  let pendingWsAt = -1;
+  for (let i = 0; i < anchored.text.length; i++) {
+    const ch = anchored.text[i];
+    if (/\s/.test(ch)) {
+      if (norm.length > 0 && pendingWsAt < 0) pendingWsAt = i;
+      continue;
+    }
+    if (pendingWsAt >= 0) {
+      norm += " ";
+      map2.push(pendingWsAt);
+      pendingWsAt = -1;
+    }
+    norm += ch;
+    map2.push(i);
+  }
+  const idx = norm.indexOf(needle);
+  if (idx >= 0) {
+    return { start: map2[idx], end: map2[idx + needle.length - 1] + 1 };
+  }
+  const marker = anchored.text.replace(/\n/g, BREAK_MARKER);
+  const pattern = [...needle].map(escapeRegExp).join(BREAK_GAP);
+  const match = new RegExp(pattern).exec(marker);
+  if (match) {
+    return { start: match.index, end: match.index + match[0].length };
+  }
+  return null;
+}
+
 // src/resource-utils.ts
 function getResourceId(resource) {
   if (!resource) return void 0;
@@ -1172,7 +999,7 @@ var BusRequestError = class extends SemiontError {
   }
 };
 async function busRequest(bus, operation, payload, timeoutMs = 3e4) {
-  const correlationId = crypto.randomUUID();
+  const correlationId = uuidV4();
   const fullPayload = { ...payload, correlationId };
   const { result: resultChannel, failure: failureChannel } = BUS_OPERATIONS[operation];
   const result$ = merge(
@@ -1891,7 +1718,8 @@ var storedBinary = (extension, label) => ({
   anchoring: "none",
   extractText: "none",
   authorable: false,
-  uploadable: true
+  uploadable: true,
+  generatable: false
 });
 var storedText = (extension, label) => ({
   ...storedBinary(extension, label),
@@ -1899,13 +1727,15 @@ var storedText = (extension, label) => ({
 });
 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 },
+  // `generatable: application/pdf` — the Typst renderer (PDF-GENERATION P3):
+  // the model writes Typst, the worker's pinned binary compiles it.
+  "text/markdown": { extension: ".md", label: "Markdown", render: "text", anchoring: "text-selector", extractText: "decode", authorable: true, uploadable: true, generatable: true },
+  "text/plain": { extension: ".txt", label: "Plain Text", render: "text", anchoring: "text-selector", extractText: "decode", authorable: true, uploadable: true, generatable: true },
+  "text/html": { extension: ".html", label: "HTML", render: "text", anchoring: "text-selector", extractText: "decode", authorable: true, uploadable: true, generatable: false },
+  "application/json": { extension: ".json", label: "JSON", render: "text", anchoring: "text-selector", extractText: "decode", authorable: false, uploadable: true, generatable: false },
+  "image/png": { extension: ".png", label: "PNG image", render: "image", anchoring: "spatial", extractText: "none", authorable: false, uploadable: true, generatable: false },
+  "image/jpeg": { extension: ".jpg", label: "JPEG image", render: "image", anchoring: "spatial", extractText: "none", authorable: false, uploadable: true, generatable: false },
+  "application/pdf": { extension: ".pdf", label: "PDF", render: "pdf", anchoring: "spatial", extractText: "pdf-text-layer", authorable: false, uploadable: true, generatable: true },
   // Storage tier — the big tent. Every row is a deliberate admission,
   // promotable by editing its row. Text-flavored rows embed (decode).
   // Text
@@ -2019,6 +1849,53 @@ var AUTHORABLE_MEDIA_TYPES = REGISTRY_KEYS.filter(
 var EMBEDDABLE_MEDIA_TYPES = REGISTRY_KEYS.filter(
   (type) => MEDIA_TYPES[type].extractText !== "none"
 );
+var GENERATABLE_MEDIA_TYPES = REGISTRY_KEYS.filter(
+  (type) => MEDIA_TYPES[type].generatable
+);
+
+// src/chunking.ts
+var DEFAULT_CHUNKING_CONFIG = {
+  chunkSize: 512,
+  overlap: 64
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function chunkText(text, config = DEFAULT_CHUNKING_CONFIG) {
+  if (text.length === 0) return [];
+  const totalTokens = estimateTokens(text);
+  if (totalTokens <= config.chunkSize) {
+    return [text];
+  }
+  const chunkChars = config.chunkSize * 4;
+  const overlapChars = config.overlap * 4;
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    let end = Math.min(start + chunkChars, text.length);
+    if (end < text.length) {
+      const paraBreak = text.lastIndexOf("\n\n", end);
+      if (paraBreak > start + chunkChars / 2) {
+        end = paraBreak;
+      } else {
+        const sentenceBreak = text.lastIndexOf(". ", end);
+        if (sentenceBreak > start + chunkChars / 2) {
+          end = sentenceBreak + 1;
+        } else {
+          const wordBreak = text.lastIndexOf(" ", end);
+          if (wordBreak > start + chunkChars / 2) {
+            end = wordBreak;
+          }
+        }
+      }
+    }
+    chunks.push(text.slice(start, end).trim());
+    const nextStart = end - overlapChars;
+    start = nextStart > start ? nextStart : end;
+    if (start >= text.length) break;
+  }
+  return chunks.filter((c) => c.length > 0);
+}
 
 // src/type-guards.ts
 function isString(value) {
@@ -2112,292 +1989,6 @@ function didToAgent(did) {
     name: decodeURIComponent(encoded)
   };
 }
-function deepMerge(base, override) {
-  const result = { ...base };
-  for (const key of Object.keys(override)) {
-    const b = base[key];
-    const o = override[key];
-    if (o !== void 0 && o !== null && typeof o === "object" && !Array.isArray(o) && b !== void 0 && b !== null && typeof b === "object" && !Array.isArray(b)) {
-      result[key] = deepMerge(b, o);
-    } else if (o !== void 0) {
-      result[key] = o;
-    }
-  }
-  return result;
-}
-function resolveEnvVars(obj, env) {
-  if (typeof obj === "string") {
-    return obj.replace(/\$\{([^}]+)\}/g, (match, expr) => {
-      const sepIdx = expr.indexOf(":-");
-      const varName = sepIdx >= 0 ? expr.slice(0, sepIdx) : expr;
-      const defaultValue = sepIdx >= 0 ? expr.slice(sepIdx + 2) : void 0;
-      const value = env[varName];
-      if (value !== void 0) return value;
-      if (defaultValue !== void 0) return defaultValue;
-      throw new Error(`Environment variable ${varName} is not set (referenced in config as ${match})`);
-    });
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => resolveEnvVars(item, env));
-  }
-  if (obj !== null && typeof obj === "object") {
-    const resolved = {};
-    for (const key in obj) {
-      resolved[key] = resolveEnvVars(obj[key], env);
-    }
-    return resolved;
-  }
-  return obj;
-}
-function requirePlatform(value, serviceName) {
-  if (!value) {
-    throw new Error(`platform is required for service '${serviceName}' \u2014 add 'platform = "posix"|"container"|"external"' to its config section`);
-  }
-  return value;
-}
-function loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env) {
-  const projectConfigContent = projectRoot ? reader.readIfExists(`${projectRoot}/.semiont/config`) : null;
-  const projectConfig = projectConfigContent ? parse(projectConfigContent) : void 0;
-  const projectName = projectConfig?.project?.name ?? "semiont-project";
-  const projectVersion = projectConfig?.project?.version;
-  const projectSite = projectConfig?.site;
-  const globalContent = reader.readIfExists(globalConfigPath);
-  const raw = globalContent ? parse(globalContent) : {};
-  const resolvedEnvironment = environment ?? env.SEMIONT_ENV ?? raw.defaults?.environment;
-  if (!resolvedEnvironment) {
-    throw new Error(
-      "No environment selected: pass one explicitly, set SEMIONT_ENV, or declare `[defaults] environment` in ~/.semiontconfig."
-    );
-  }
-  const projectHasSection = projectConfig?.environments != null && resolvedEnvironment in projectConfig.environments;
-  const globalHasSection = raw.environments != null && resolvedEnvironment in raw.environments;
-  if (!projectHasSection && !globalHasSection) {
-    throw new Error(
-      `Environment "${resolvedEnvironment}" is selected but no [environments.${resolvedEnvironment}] section exists in the project (.semiont/config) or global (~/.semiontconfig) config. Declare the section, or select an environment that exists.`
-    );
-  }
-  const projectEnvSection = projectConfig?.environments?.[resolvedEnvironment] ?? {};
-  const userEnvSection = raw.environments?.[resolvedEnvironment] ?? {};
-  const envSection = deepMerge(
-    projectEnvSection,
-    userEnvSection
-  );
-  const resolved = resolveEnvVars(envSection, env);
-  const flatInference = resolved.inference;
-  const makeMeaningSection = resolved["make-meaning"];
-  const workersSection = resolved.workers ?? {};
-  const actorsSection = resolved.actors ?? {};
-  const defaultWorkerInference = workersSection["default"]?.inference;
-  const defaultMakeMeaningInference = makeMeaningSection?.default?.inference;
-  function mergeWithFlatInference(specific) {
-    if (!flatInference) return specific;
-    const providerDefaults = {};
-    if (specific.type === "anthropic") {
-      const a = flatInference.anthropic;
-      if (a) {
-        providerDefaults.apiKey = a.apiKey;
-        providerDefaults.endpoint = a.endpoint;
-      } else {
-        if (!flatInference.type) {
-          throw new Error(
-            `[environments.${resolvedEnvironment}.inference] is missing 'type'. Add type = "anthropic" or use [inference.anthropic] sub-section.`
-          );
-        }
-        providerDefaults.apiKey = flatInference.apiKey;
-        providerDefaults.endpoint = flatInference.endpoint;
-      }
-    } else if (specific.type === "ollama") {
-      const o = flatInference.ollama;
-      if (o) {
-        providerDefaults.baseURL = o.baseURL;
-      } else {
-        if (!flatInference.type) {
-          throw new Error(
-            `[environments.${resolvedEnvironment}.inference] is missing 'type'. Add type = "ollama" or use [inference.ollama] sub-section.`
-          );
-        }
-        providerDefaults.baseURL = flatInference.baseURL;
-      }
-    }
-    return {
-      maxTokens: flatInference.maxTokens,
-      ...providerDefaults,
-      ...specific
-    };
-  }
-  function resolveActorInference(fromMakeMeaning, fromActors) {
-    const base = fromMakeMeaning ?? fromActors ?? defaultMakeMeaningInference;
-    if (!base) return void 0;
-    return mergeWithFlatInference(base);
-  }
-  const actors = {};
-  const gathererInference = resolveActorInference(
-    makeMeaningSection?.actors?.gatherer?.inference,
-    actorsSection["gatherer"]?.inference
-  );
-  if (gathererInference) actors.gatherer = gathererInference;
-  const matcherInference = resolveActorInference(
-    makeMeaningSection?.actors?.matcher?.inference,
-    actorsSection["matcher"]?.inference
-  );
-  if (matcherInference) actors.matcher = matcherInference;
-  const workers = {};
-  const workerTypes = ["reference-annotation", "highlight-annotation", "assessment-annotation", "comment-annotation", "tag-annotation", "generation"];
-  if (defaultWorkerInference) {
-    workers.default = mergeWithFlatInference(defaultWorkerInference);
-  }
-  for (const wt of workerTypes) {
-    const specific = workersSection[wt]?.inference;
-    if (specific) {
-      workers[wt] = mergeWithFlatInference(specific);
-    }
-  }
-  const backend = resolved.backend;
-  const site = resolved.site ?? projectSite;
-  const inferenceSection = resolved.inference;
-  let inferenceProviders;
-  if (inferenceSection) {
-    inferenceProviders = {};
-    if (inferenceSection.anthropic) {
-      const a = inferenceSection.anthropic;
-      inferenceProviders.anthropic = {
-        platform: requirePlatform(a.platform, "inference.anthropic"),
-        endpoint: a.endpoint ?? "https://api.anthropic.com",
-        apiKey: a.apiKey ?? ""
-      };
-    } else if (inferenceSection.type === "anthropic") {
-      inferenceProviders.anthropic = {
-        platform: requirePlatform(inferenceSection.platform, "inference"),
-        endpoint: inferenceSection.endpoint ?? "https://api.anthropic.com",
-        apiKey: inferenceSection.apiKey ?? ""
-      };
-    }
-    if (inferenceSection.ollama) {
-      const o = inferenceSection.ollama;
-      inferenceProviders.ollama = {
-        platform: { type: requirePlatform(o.platform, "inference.ollama") },
-        baseURL: o.baseURL,
-        port: o.baseURL ? void 0 : o.port ?? 11434
-      };
-    } else if (inferenceSection.type === "ollama") {
-      inferenceProviders.ollama = {
-        platform: { type: requirePlatform(inferenceSection.platform, "inference") },
-        baseURL: inferenceSection.baseURL,
-        port: inferenceSection.baseURL ? void 0 : 11434
-      };
-    }
-  }
-  const topLevelWorkers = {};
-  for (const [name, w] of Object.entries(workersSection)) {
-    if (w.inference) {
-      topLevelWorkers[name] = { inference: { type: w.inference.type, model: w.inference.model } };
-    }
-  }
-  const topLevelActors = {};
-  for (const [name, a] of Object.entries(actorsSection)) {
-    if (a.inference) {
-      topLevelActors[name] = { inference: { type: a.inference.type, model: a.inference.model } };
-    }
-  }
-  if (makeMeaningSection?.actors?.gatherer?.inference) {
-    topLevelActors["gatherer"] = { inference: { type: makeMeaningSection.actors.gatherer.inference.type, model: makeMeaningSection.actors.gatherer.inference.model } };
-  }
-  if (makeMeaningSection?.actors?.matcher?.inference) {
-    topLevelActors["matcher"] = { inference: { type: makeMeaningSection.actors.matcher.inference.type, model: makeMeaningSection.actors.matcher.inference.model } };
-  }
-  const frontend = resolved.frontend;
-  const services = {};
-  if (backend) {
-    services.backend = {
-      platform: { type: requirePlatform(backend.platform, "backend") },
-      port: backend.port ?? 4e3,
-      publicURL: backend.publicURL ?? `http://localhost:${backend.port ?? 4e3}`
-    };
-  }
-  if (frontend) {
-    services.frontend = {
-      platform: { type: requirePlatform(frontend.platform, "frontend") },
-      port: frontend.port ?? 3e3,
-      siteName: site?.siteName ?? "Semiont",
-      publicURL: frontend.publicURL
-    };
-  }
-  if (resolved.graph) {
-    services.graph = {
-      ...resolved.graph,
-      platform: { type: requirePlatform(resolved.graph.platform, "graph") },
-      type: resolved.graph.type ?? "neo4j"
-    };
-  } else if (makeMeaningSection?.graph) {
-    services.graph = makeMeaningSection.graph;
-  }
-  if (resolved.database) {
-    services.database = {
-      platform: { type: requirePlatform(resolved.database.platform, "database") },
-      type: "postgres",
-      image: resolved.database.image,
-      host: resolved.database.host ?? "localhost",
-      port: resolved.database.port ?? 5432,
-      name: resolved.database.name,
-      user: resolved.database.user,
-      password: resolved.database.password
-    };
-  }
-  if (resolved.vectors) {
-    services.vectors = {
-      platform: { type: "external" },
-      type: resolved.vectors.type ?? "qdrant",
-      host: resolved.vectors.host,
-      port: resolved.vectors.port ?? 6333
-    };
-  }
-  const embeddingSource = resolved.embedding ?? resolved.vectors?.embedding;
-  if (embeddingSource) {
-    services.embedding = {
-      platform: { type: "external" },
-      type: embeddingSource.type,
-      model: embeddingSource.model,
-      apiKey: embeddingSource.apiKey,
-      baseURL: embeddingSource.baseURL,
-      endpoint: embeddingSource.endpoint,
-      chunking: resolved.embedding?.chunking ?? resolved.vectors?.chunking ? {
-        chunkSize: (resolved.embedding?.chunking ?? resolved.vectors?.chunking)?.chunkSize ?? 512,
-        overlap: (resolved.embedding?.chunking ?? resolved.vectors?.chunking)?.overlap ?? 64
-      } : void 0
-    };
-  }
-  const config = {
-    services,
-    ...inferenceProviders ? { inference: inferenceProviders } : {},
-    ...Object.keys(topLevelWorkers).length > 0 ? { workers: topLevelWorkers } : {},
-    ...Object.keys(topLevelActors).length > 0 ? { actors: topLevelActors } : {},
-    site: site ? {
-      domain: site.domain ?? "localhost",
-      siteName: site.siteName,
-      adminEmail: site.adminEmail,
-      oauthAllowedDomains: site.oauthAllowedDomains
-    } : void 0,
-    logLevel: resolved.logLevel,
-    _metadata: {
-      environment: resolvedEnvironment,
-      projectRoot,
-      projectName,
-      projectVersion,
-      ...Object.keys(actors).length > 0 ? { actors } : {},
-      ...Object.keys(workers).length > 0 ? { workers } : {},
-      // Always set — the loader is the ONE home of this default (D5).
-      // Consuming code (make-meaning's gather path) receives a required
-      // value and defaults nothing.
-      gather: { settleTimeoutMs: makeMeaningSection?.gather?.settleTimeoutMs ?? 15e3 }
-    }
-  };
-  return config;
-}
-function createTomlConfigLoader(reader, globalConfigPath, env) {
-  return (projectRoot, environment) => {
-    return loadTomlConfig(projectRoot, environment, globalConfigPath, reader, env);
-  };
-}
 
 // src/config/environment-validator.ts
 function isValidEnvironment(value, availableEnvironments) {
@@ -2520,9 +2111,36 @@ async function retryWithBackoff(fn, isRetryable, policy, onRetry) {
   }
 }
 
+// src/shard-utils.ts
+function jumpConsistentHash(key, numBuckets = 65536) {
+  const hash = hashToUint32(key);
+  return hash % numBuckets;
+}
+function hashToUint32(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    hash = (hash << 5) - hash + str.charCodeAt(i);
+    hash = hash & 4294967295;
+  }
+  return Math.abs(hash);
+}
+function shardIdToPath(shardId) {
+  if (shardId < 0 || shardId >= 65536) {
+    throw new Error(`Invalid shard ID: ${shardId}. Must be 0-65535 for 4-hex sharding.`);
+  }
+  const shardHex = shardId.toString(16).padStart(4, "0");
+  const ab = shardHex.substring(0, 2);
+  const cd = shardHex.substring(2, 4);
+  return [ab, cd];
+}
+function getShardPath(key, numBuckets = 65536) {
+  const shardId = jumpConsistentHash(key, numBuckets);
+  return shardIdToPath(shardId);
+}
+
 // src/discovery.ts
 var DISCOVERY_URL_PATH = "/discovery/kbs.json";
 
-export { AUTHORABLE_MEDIA_TYPES, BRIDGED_CHANNELS, BUS_OPERATIONS, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, EventBus, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScopedEventBus, ScriptError, SemiontError, UnauthorizedError, ValidationError, accessToken, agentToDid, anchorAnnotation, annotationId, annotationUri, applyBodyOperations, assembleAnnotation, authCode, baseMediaType, baseUrl, buildContentCache, burstBuffer, busLog, busLogEnabled, busRequest, capabilitiesOf, cloneToken, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, createTomlConfigLoader, decodeRepresentation, decodeWithCharset, deriveViews, 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, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jobId, kbDid, loadTomlConfig, mcpToken, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, refreshToken, resourceAnnotationUri, resourceId, resourceUri, retryWithBackoff, scaleSvgToNative, searchQuery, serializePerKey, setBusLogTraceIdProvider, softwareToAgent, textExtractionOf, userDID, userId, userToAgent, userToDid, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
+export { AUTHORABLE_MEDIA_TYPES, BusRequestError, CHANNEL_SCHEMAS, CONTEXT_FULL_WEIGHT, CONTEXT_PARTIAL_WEIGHT, ConfigurationError, ConflictError, DEFAULT_CHUNKING_CONFIG, DISCOVERY_URL_PATH, EMBEDDABLE_MEDIA_TYPES, GENERATABLE_MEDIA_TYPES, JWTTokenSchema, LOCALES, MEDIA_TYPES, NotFoundError, PERSISTED_EVENT_TYPES, POSITION_WEIGHT_MAX, POSITION_WINDOW, RESOURCE_BROADCAST_TYPES, STARTUP_FETCH_RETRY, ScriptError, SemiontError, UnauthorizedError, ValidationError, agentToDid, anchorAnnotation, anchorRuns, annotationId, applyBodyOperations, assembleAnnotation, baseMediaType, buildContentCache, burstBuffer, busRequest, capabilitiesOf, chunkText, createCircleSvg, createFragmentSelector, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, deriveViews, didToAgent, errField, estimateTokens, extensionForMediaType, extractBoundingBox, extractCharset, extractContext, findBestTextMatch, findBodyItem, findClaimSpan, 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, getShardPath, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, 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, isTextRun, isTransientFetchError, isUndefined, isValidEmail, isValidPlatformType, jumpConsistentHash, kbDid, locate, mediaTypeForExtension, normalizeCoordinates, normalizeText, parseEnvironment, parseFragmentSelector, parseSvgSelector, reconcileSelector, resourceId, retryWithBackoff, scaleSvgToNative, serializePerKey, softwareToAgent, textExtractionOf, textUnder, userId, userToAgent, userToDid, uuidV4, validateData, validateEnvironment, validateSvgMarkup, verifyPosition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map