@semiont/make-meaning 0.5.32 → 0.5.34

package/dist/smelter-main.js

@@ -1,5 +1,5 @@
 import { archivistContentReads, createAnchoredTextStore, derivingExtractorFor, calculateChecksum } from '@semiont/content';
-import { replyChannelsFor, createTomlConfigLoader, accessToken, baseUrl as baseUrl$1, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, burstBuffer, errField, resourceId, textSourceOf, decodeRepresentation, busRequest, getResourceEntityTypes, chunkText, getTargetSelector, getExactText, annotationId, getPrimaryMediaType, yieldsGeometryOf, getPrimaryRepresentation } from '@semiont/core';
+import { replyChannelsFor, createTomlConfigLoader, accessToken, withDeadline, baseUrl as baseUrl$1, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, burstBuffer, errField, resourceId, textSourceOf, decodeRepresentation, busRequest, getResourceEntityTypes, chunkText, getTargetSelector, getExactText, annotationId, getPrimaryMediaType, yieldsGeometryOf, getPrimaryRepresentation, isPeerUnavailable } from '@semiont/core';
 import { registerVectorIndexSizeProvider, withActorSpan } from '@semiont/observability';
 import '@semiont/ontology';
 import '@semiont/graph';
@@ -11,6 +11,8 @@ import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
 import { join } from 'path';
 import { createProcessLogger } from '@semiont/observability/process-logger';
+import '@semiont/jobs';
+import '@semiont/inference';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -9789,6 +9791,28 @@ function partitionByType(events) {
   if (currentRun.length > 0) runs.push(currentRun);
   return runs;
 }
+var RESOURCE_LISTING_RETRY = {
+  attempts: 17,
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4
+};
+var RESOURCES_CHANNEL = "browse:resources-requested";
+async function browseAllResources(bus, options) {
+  const all = [];
+  for (; ; ) {
+    const page = await retryWithBackoff(
+      () => busRequest(bus, RESOURCES_CHANNEL, {
+        ...options.archived !== void 0 ? { archived: options.archived } : {},
+        offset: all.length,
+        limit: options.limit
+      }),
+      isPeerUnavailable,
+      RESOURCE_LISTING_RETRY
+    );
+    all.push(...page.resources);
+    if (page.resources.length === 0 || all.length >= page.total) return all;
+  }
+}
 
 // src/smelter.ts
 function sameStringSet(a, b) {
@@ -10095,38 +10119,38 @@ var Smelter = class _Smelter {
    * null (logged) when the resource doesn't decode as text, is unavailable,
    * or is empty — callers skip it.
    */
-  async fetchEmbeddableText(resourceId6) {
+  async fetchEmbeddableText(resourceId10) {
     try {
-      const { data, contentType } = await this.content.getBinary(resourceId(resourceId6));
+      const { data, contentType } = await this.content.getBinary(resourceId(resourceId10));
       const bytes = Buffer.from(data);
       const checksum = calculateChecksum(bytes);
       const extractor = derivingExtractorFor(contentType);
       if (!extractor && textSourceOf(contentType) === "none") {
-        this.logger.debug("Skipping resource with no way to read its media type", { resourceId: resourceId6, contentType });
+        this.logger.debug("Skipping resource with no way to read its media type", { resourceId: resourceId10, contentType });
         return { kind: "skipped", checksum, reason: "no-extractor" };
       }
       const extracted = extractor ? await extractor.extract(bytes, contentType, { key: checksum, store: this.anchoredStore }) : { kind: "extracted", text: decodeRepresentation(bytes, contentType), method: "text-passthrough" };
       if (extracted.kind === "declined") {
-        this.logger.debug("Extractor declined", { resourceId: resourceId6, contentType, reason: extracted.declined });
+        this.logger.debug("Extractor declined", { resourceId: resourceId10, contentType, reason: extracted.declined });
         return { kind: "skipped", checksum, reason: extracted.declined };
       }
       if (extracted.ocrConfidence && extracted.ocrConfidence.lowConfidenceWords > 0) {
         this.logger.info("OCR read words it was unsure of", {
-          resourceId: resourceId6,
+          resourceId: resourceId10,
           contentType,
           ...extracted.ocrConfidence
         });
       }
       if (extracted.unreadPages?.length) {
         this.logger.info("Partial extraction coverage", {
-          resourceId: resourceId6,
+          resourceId: resourceId10,
           contentType,
           unreadPages: extracted.unreadPages
         });
       }
       return extracted.text.trim() ? { kind: "text", text: extracted.text, checksum, machineRead: extracted.method === "ocr" } : { kind: "skipped", checksum, reason: "empty" };
     } catch (error) {
-      this.logger.warn("Content unavailable for embedding", { resourceId: resourceId6, error: errField(error) });
+      this.logger.warn("Content unavailable for embedding", { resourceId: resourceId10, error: errField(error) });
       return { kind: "unavailable" };
     }
   }
@@ -10136,11 +10160,11 @@ var Smelter = class _Smelter {
    * fold. Best-effort — waiters degrade to their bounded timeout; a signal
    * failure must never fail the embed.
    */
-  async emitSettled(resourceId6, contentChecksum, outcome, reason) {
+  async emitSettled(resourceId10, contentChecksum, outcome, reason) {
     try {
-      await this.bus.emit("smelt:settled", { resourceId: resourceId6, contentChecksum, outcome, ...reason ? { reason } : {} });
+      await this.bus.emit("smelt:settled", { resourceId: resourceId10, contentChecksum, outcome, ...reason ? { reason } : {} });
     } catch (error) {
-      this.logger.warn("Failed to emit smelt:settled", { resourceId: resourceId6, outcome, error: errField(error) });
+      this.logger.warn("Failed to emit smelt:settled", { resourceId: resourceId10, outcome, error: errField(error) });
     }
   }
   /**
@@ -10152,11 +10176,11 @@ var Smelter = class _Smelter {
    * propagates to the pipeline's per-resource error handler (reconcile heals),
    * rather than silently stamping `[]` and letting the resource leak into recall.
    */
-  async resolveEntityTypes(resourceId6) {
+  async resolveEntityTypes(resourceId10) {
     const { resource } = await busRequest(
       this.bus,
       "browse:resource-requested",
-      { resourceId: resourceId6 }
+      { resourceId: resourceId10 }
     );
     return getResourceEntityTypes(resource);
   }
@@ -10240,11 +10264,11 @@ var Smelter = class _Smelter {
     this.logger.info("Indexed annotation", { annotationId: String(aid) });
   }
   async handleAnnotationRemoved(event) {
-    const annotationId3 = event.payload.annotationId;
-    if (!annotationId3) return;
-    const aid = annotationId(annotationId3);
+    const annotationId5 = event.payload.annotationId;
+    if (!annotationId5) return;
+    const aid = annotationId(annotationId5);
     await this.vectorStore.deleteAnnotationVector(aid);
-    this.logger.info("Deleted annotation vector", { annotationId: annotationId3 });
+    this.logger.info("Deleted annotation vector", { annotationId: annotationId5 });
   }
   /**
    * Batch-embed chunks from multiple yield:created events in a single
@@ -10483,16 +10507,16 @@ var Smelter = class _Smelter {
    * resource (S1/S2).
    */
   async rebuildAnchors(command) {
-    const { correlationId, resourceId: resourceId6 } = command;
+    const { correlationId, resourceId: resourceId10 } = command;
     try {
       let work;
-      if (resourceId6) {
-        work = [{ type: "smelt:reanchor", resourceId: resourceId6, payload: {} }];
+      if (resourceId10) {
+        work = [{ type: "smelt:reanchor", resourceId: resourceId10, payload: {} }];
       } else {
         const resources = await this.listAllResources();
         work = [...this.classifyEmbeddable(resources)].filter(([, catalog]) => catalog.yieldsGeometry).map(([rid]) => ({ type: "smelt:reanchor", resourceId: rid, payload: {} }));
       }
-      this.logger.info("Anchored-text rebuild started", { scoped: resourceId6 ?? null, resources: work.length });
+      this.logger.info("Anchored-text rebuild started", { scoped: resourceId10 ?? null, resources: work.length });
       const failed = await this.drain(work);
       if (failed > 0) {
         await this.bus.emit("smelt:rebuild-anchors-failed", {
@@ -10502,7 +10526,7 @@ var Smelter = class _Smelter {
         return;
       }
       await this.bus.emit("smelt:rebuild-anchors-ok", correlationId ? { correlationId } : {});
-      this.logger.info("Anchored-text rebuild complete", { scoped: resourceId6 ?? null, resources: work.length });
+      this.logger.info("Anchored-text rebuild complete", { scoped: resourceId10 ?? null, resources: work.length });
     } catch (error) {
       this.logger.error("Anchored-text rebuild failed", { error: errField(error) });
       try {
@@ -10544,17 +10568,11 @@ var Smelter = class _Smelter {
     return embeddable;
   }
   /** Page through `browse:resources-requested` until the catalog is exhausted. */
-  async listAllResources() {
-    const all = [];
-    for (; ; ) {
-      const page = await busRequest(
-        this.bus,
-        "browse:resources-requested",
-        { archived: false, offset: all.length, limit: _Smelter.RECONCILE_PAGE_SIZE }
-      );
-      all.push(...page.resources);
-      if (page.resources.length === 0 || all.length >= page.total) return all;
-    }
+  /** Shared with the weaver since 2026-09-09 — see `browse-resources.ts` for why the
+   *  retry lives at the page rather than around the pass. `archived: false` is
+   *  the smelter's own filter and the one difference between the two loops. */
+  listAllResources() {
+    return browseAllResources(this.bus, { limit: _Smelter.RECONCILE_PAGE_SIZE, archived: false });
   }
 };
 var MATCHER_CHANNELS = [
@@ -10659,6 +10677,12 @@ async function runBootPass(pass, run, logger2, onState) {
     });
   }
 }
+
+// src/service.ts
+var STARTUP_CONNECT_TIMEOUT_MS = 6e4;
+var RESTART_HINT = "Exiting so the container restart policy can retry \u2014 it is normal for a dependency to be slow when every service restarts at once.";
+
+// src/smelter-main.ts
 var configPath = join(homedir(), ".semiontconfig");
 var tomlReader = {
   readIfExists: (p) => existsSync(p) ? readFileSync(p, "utf-8") : null
@@ -10731,8 +10755,9 @@ async function authenticate() {
   );
 }
 async function main() {
-  const { initObservabilityNode } = await import('@semiont/observability/node');
+  const { initObservabilityNode, registerSupervisorRestartCount } = await import('@semiont/observability/node');
   initObservabilityNode({ serviceName: "semiont-smelter" });
+  registerSupervisorRestartCount();
   logger.info("Authenticating", { baseUrl });
   const tokenSubject = new import_rxjs3.BehaviorSubject(accessToken(await authenticate()));
   logger.info("Authenticated");
@@ -10748,18 +10773,29 @@ async function main() {
       });
     });
   }, 12 * 60 * 60 * 1e3);
-  const embeddingProvider = await createEmbeddingProvider({
-    type: embeddingType,
-    model: embeddingModel,
-    baseURL: embeddingBaseURL
-  });
+  const embeddingProvider = await withDeadline(
+    "Embedding provider",
+    STARTUP_CONNECT_TIMEOUT_MS,
+    () => createEmbeddingProvider({
+      type: embeddingType,
+      model: embeddingModel,
+      baseURL: embeddingBaseURL
+    }),
+    RESTART_HINT
+  );
   logger.info("Embedding provider ready", { type: embeddingType, model: embeddingModel });
-  const vectorStore = await createVectorStore({
-    type: "qdrant",
-    host: qdrantHost,
-    port: qdrantPort,
-    dimensions: () => embeddingProvider.dimensions()
-  });
+  const vectorStore = await withDeadline(
+    "Vector store",
+    STARTUP_CONNECT_TIMEOUT_MS,
+    (signal) => createVectorStore({
+      signal,
+      type: "qdrant",
+      host: qdrantHost,
+      port: qdrantPort,
+      dimensions: () => embeddingProvider.dimensions()
+    }),
+    RESTART_HINT
+  );
   logger.info("Vector store ready", { host: qdrantHost, port: qdrantPort });
   registerVectorIndexSizeProvider(() => vectorStore.count());
   const httpTransport = new HttpTransport({