@semiont/make-meaning 0.5.29 → 0.5.31

package/dist/smelter-main.js

@@ -1,8 +1,11 @@
-import { archivistContentReads, createAnchoredTextStore, EXTRACTORS, calculateChecksum } from '@semiont/content';
-import { createTomlConfigLoader, accessToken, baseUrl as baseUrl$1, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, burstBuffer, errField, resourceId, textExtractionOf, busRequest, getResourceEntityTypes, chunkText, getTargetSelector, getExactText, annotationId, getPrimaryMediaType, getPrimaryRepresentation } from '@semiont/core';
+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 { registerVectorIndexSizeProvider, withActorSpan } from '@semiont/observability';
-import { HttpTransport } from '@semiont/http-transport';
+import '@semiont/ontology';
+import '@semiont/graph';
 import { createEmbeddingProvider, createVectorStore } from '@semiont/vectors';
+import '@semiont/event-sourcing';
+import { HttpTransport } from '@semiont/http-transport';
 import { createServer } from 'http';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
@@ -10057,8 +10060,8 @@ var Smelter = class _Smelter {
     if (!rid) return;
     const { data, contentType } = await this.content.getBinary(resourceId(rid));
     const bytes = Buffer.from(data);
-    const extractor = EXTRACTORS[textExtractionOf(contentType)];
-    if (!extractor?.yieldsGeometry) {
+    const extractor = derivingExtractorFor(contentType);
+    if (!extractor) {
       this.logger.info("Re-anchor found no geometry-capable extractor", { resourceId: rid, contentType });
       return;
     }
@@ -10092,41 +10095,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(resourceId$1) {
+  async fetchEmbeddableText(resourceId6) {
     try {
-      const { data, contentType } = await this.content.getBinary(resourceId(resourceId$1));
+      const { data, contentType } = await this.content.getBinary(resourceId(resourceId6));
       const bytes = Buffer.from(data);
       const checksum = calculateChecksum(bytes);
-      const extractor = EXTRACTORS[textExtractionOf(contentType)];
-      if (!extractor) {
-        this.logger.debug("Skipping resource with no extractor for its media type", { resourceId: resourceId$1, contentType });
+      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 });
         return { kind: "skipped", checksum, reason: "no-extractor" };
       }
-      const extracted = await extractor.extract(bytes, contentType, {
-        key: checksum,
-        store: this.anchoredStore
-      });
+      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: resourceId$1, contentType, reason: extracted.declined });
+        this.logger.debug("Extractor declined", { resourceId: resourceId6, 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: resourceId$1,
+          resourceId: resourceId6,
           contentType,
           ...extracted.ocrConfidence
         });
       }
       if (extracted.unreadPages?.length) {
         this.logger.info("Partial extraction coverage", {
-          resourceId: resourceId$1,
+          resourceId: resourceId6,
           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: resourceId$1, error: errField(error) });
+      this.logger.warn("Content unavailable for embedding", { resourceId: resourceId6, error: errField(error) });
       return { kind: "unavailable" };
     }
   }
@@ -10136,11 +10136,11 @@ var Smelter = class _Smelter {
    * fold. Best-effort — waiters degrade to their bounded timeout; a signal
    * failure must never fail the embed.
    */
-  async emitSettled(resourceId, contentChecksum, outcome, reason) {
+  async emitSettled(resourceId6, contentChecksum, outcome, reason) {
     try {
-      await this.bus.emit("smelt:settled", { resourceId, contentChecksum, outcome, ...reason ? { reason } : {} });
+      await this.bus.emit("smelt:settled", { resourceId: resourceId6, contentChecksum, outcome, ...reason ? { reason } : {} });
     } catch (error) {
-      this.logger.warn("Failed to emit smelt:settled", { resourceId, outcome, error: errField(error) });
+      this.logger.warn("Failed to emit smelt:settled", { resourceId: resourceId6, outcome, error: errField(error) });
     }
   }
   /**
@@ -10152,11 +10152,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(resourceId) {
+  async resolveEntityTypes(resourceId6) {
     const { resource } = await busRequest(
       this.bus,
       "browse:resource-requested",
-      { resourceId }
+      { resourceId: resourceId6 }
     );
     return getResourceEntityTypes(resource);
   }
@@ -10240,11 +10240,11 @@ var Smelter = class _Smelter {
     this.logger.info("Indexed annotation", { annotationId: String(aid) });
   }
   async handleAnnotationRemoved(event) {
-    const annotationId$1 = event.payload.annotationId;
-    if (!annotationId$1) return;
-    const aid = annotationId(annotationId$1);
+    const annotationId3 = event.payload.annotationId;
+    if (!annotationId3) return;
+    const aid = annotationId(annotationId3);
     await this.vectorStore.deleteAnnotationVector(aid);
-    this.logger.info("Deleted annotation vector", { annotationId: annotationId$1 });
+    this.logger.info("Deleted annotation vector", { annotationId: annotationId3 });
   }
   /**
    * Batch-embed chunks from multiple yield:created events in a single
@@ -10483,16 +10483,16 @@ var Smelter = class _Smelter {
    * resource (S1/S2).
    */
   async rebuildAnchors(command) {
-    const { correlationId, resourceId } = command;
+    const { correlationId, resourceId: resourceId6 } = command;
     try {
       let work;
-      if (resourceId) {
-        work = [{ type: "smelt:reanchor", resourceId, payload: {} }];
+      if (resourceId6) {
+        work = [{ type: "smelt:reanchor", resourceId: resourceId6, 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: resourceId ?? null, resources: work.length });
+      this.logger.info("Anchored-text rebuild started", { scoped: resourceId6 ?? null, resources: work.length });
       const failed = await this.drain(work);
       if (failed > 0) {
         await this.bus.emit("smelt:rebuild-anchors-failed", {
@@ -10502,7 +10502,7 @@ var Smelter = class _Smelter {
         return;
       }
       await this.bus.emit("smelt:rebuild-anchors-ok", correlationId ? { correlationId } : {});
-      this.logger.info("Anchored-text rebuild complete", { scoped: resourceId ?? null, resources: work.length });
+      this.logger.info("Anchored-text rebuild complete", { scoped: resourceId6 ?? null, resources: work.length });
     } catch (error) {
       this.logger.error("Anchored-text rebuild failed", { error: errField(error) });
       try {
@@ -10520,22 +10520,24 @@ var Smelter = class _Smelter {
    * representation's checksum (the bytes the smelter would read), the
    * current entity-type set (the discriminator the stamps must carry), and
    * whether the media type's extractor derives geometry (whether an
-   * anchored-text artifact should exist). Embeddable ⇔ an extractor exists
-   * for the media type's strategy — the same registry the live fetch
-   * resolves, and `yieldsGeometry` is declared on the extractor itself, so
-   * every gate here and the live fetch's behavior are twins by construction.
+   * anchored-text artifact should exist). Both answers are core's, keyed by the
+   * media type's strategy: embeddable ⇔ the type has any text-reading strategy
+   * at all, and geometry ⇔ that strategy derives it. Until READ-VS-EXTRACT P2
+   * embeddability was asked as `EXTRACTORS[strategy] !== null` — true, but a
+   * second statement of `strategy !== 'none'`, answered by resolving an
+   * implementation to learn a fact about a media type.
    * Shared by `reconcile()` and the `smelt:rebuild-anchors` planner.
    */
   classifyEmbeddable(resources) {
     const embeddable = /* @__PURE__ */ new Map();
     for (const resource of resources) {
       const mediaType = getPrimaryMediaType(resource);
-      const extractor = mediaType ? EXTRACTORS[textExtractionOf(mediaType)] : null;
-      if (resource["@id"] && extractor) {
+      const readable = mediaType !== void 0 && textSourceOf(mediaType) !== "none";
+      if (resource["@id"] && mediaType && readable) {
         embeddable.set(resource["@id"], {
           checksum: getPrimaryRepresentation(resource)?.checksum,
           entityTypes: getResourceEntityTypes(resource),
-          yieldsGeometry: extractor.yieldsGeometry
+          yieldsGeometry: yieldsGeometryOf(mediaType)
         });
       }
     }
@@ -10555,6 +10557,108 @@ var Smelter = class _Smelter {
     }
   }
 };
+var MATCHER_CHANNELS = [
+  "match:search-requested"
+];
+
+// src/gatherer.ts
+var GATHERER_CHANNELS = [
+  "gather:requested",
+  "gather:resource-requested"
+];
+var STOWER_CHANNELS = [
+  "yield:create",
+  "yield:clone-persist",
+  "yield:update",
+  "yield:mv",
+  "mark:create",
+  "mark:commit",
+  "mark:delete",
+  "mark:update-body",
+  "frame:add-entity-type",
+  "frame:add-tag-schema",
+  "mark:archive",
+  "mark:unarchive",
+  "mark:update-entity-types",
+  "job:start",
+  "job:complete",
+  "job:fail"
+];
+
+// src/browser.ts
+var BROWSER_CHANNELS = [
+  "browse:resource-requested",
+  "browse:anchored-text-requested",
+  "browse:resources-requested",
+  "browse:annotations-requested",
+  "browse:annotation-requested",
+  "browse:events-requested",
+  "browse:annotation-history-requested",
+  "browse:referenced-by-requested",
+  "browse:entity-types-requested",
+  "browse:tag-schemas-requested",
+  "browse:agents-requested",
+  "browse:directory-requested"
+];
+
+// src/clone-token-manager.ts
+var CLONE_TOKEN_CHANNELS = [
+  "yield:clone-token-requested",
+  "yield:clone-resource-requested",
+  "yield:clone-create"
+];
+
+// src/service-channels.ts
+var SMELTER_AWAITED_OPERATIONS = [
+  "browse:resource-requested",
+  "browse:annotations-requested",
+  "browse:resources-requested"
+];
+var SMELTER_REPLY_CHANNELS = replyChannelsFor(SMELTER_AWAITED_OPERATIONS);
+var WEAVER_AWAITED_OPERATIONS = [
+  "browse:resources-requested",
+  "browse:events-requested",
+  "browse:annotations-requested"
+];
+replyChannelsFor(WEAVER_AWAITED_OPERATIONS);
+var LIBRARIAN_INBOUND_CHANNELS = [
+  ...MATCHER_CHANNELS,
+  ...GATHERER_CHANNELS,
+  "gather:summary-requested",
+  "weave:applied",
+  "smelt:settled"
+];
+replyChannelsFor(LIBRARIAN_INBOUND_CHANNELS);
+var ARCHIVIST_INBOUND_CHANNELS = [
+  ...STOWER_CHANNELS,
+  ...BROWSER_CHANNELS,
+  ...CLONE_TOKEN_CHANNELS,
+  "mark:create-request",
+  "smelt:settled",
+  // The annotation-context read moved here with the bytes (SINGLE-KB-MOUNT D5).
+  "browse:annotation-context-requested"
+];
+var ARCHIVIST_OUTBOUND_STRAYS = [
+  "mark:body-update-failed",
+  // op keyed 'bind:update-body' (gateway handler re-emits mark:update-body)
+  "yield:move-failed"
+  // yield:mv has no registered operation; failure is direct-subscribed
+];
+[
+  ...ARCHIVIST_OUTBOUND_STRAYS,
+  ...replyChannelsFor(ARCHIVIST_INBOUND_CHANNELS)
+];
+async function runBootPass(pass, run, logger2, onState) {
+  try {
+    const summary = await run();
+    onState?.({ phase: "done", summary });
+  } catch (error) {
+    logger2.error(`Boot pass '${pass}' failed \u2014 continuing with a store that may be behind`, {
+      pass,
+      error: errField(error)
+    });
+  }
+}
 var configPath = join(homedir(), ".semiontconfig");
 var tomlReader = {
   readIfExists: (p) => existsSync(p) ? readFileSync(p, "utf-8") : null
@@ -10590,7 +10694,7 @@ var chunkingConfig = {
   overlap: embedding.chunking?.overlap ?? 64
 };
 var workerSecret = process.env.SEMIONT_WORKER_SECRET ?? "";
-var healthPort = 9091;
+var healthPort = 24101;
 var logger = createProcessLogger("smelter");
 async function authenticate() {
   if (!workerSecret) {
@@ -10661,7 +10765,12 @@ async function main() {
   const httpTransport = new HttpTransport({
     baseUrl: baseUrl$1(baseUrl),
     token$: tokenSubject,
-    tokenRefresher: refreshToken
+    tokenRefresher: refreshToken,
+    // Only the reply channels this process awaits — not the full bridged
+    // set, whose global reply fan-out is the worker-OOM failure mode. See
+    // SMELTER_AWAITED_OPERATIONS. The domain-event channels are added by
+    // the actor state unit's start() below.
+    channels: SMELTER_REPLY_CHANNELS
   });
   const actorStateUnit = createSmelterActorStateUnit({
     bus: httpTransport.actor
@@ -10715,7 +10824,7 @@ async function main() {
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  await smelter.reconcile();
+  await runBootPass("reconcile", () => smelter.reconcile(), logger);
 }
 main().catch((error) => {
   logger.error("Fatal", { error: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : void 0 });