@semiont/make-meaning 0.5.28 → 0.5.30

package/dist/smelter-main.js

@@ -1,8 +1,11 @@
-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 { anchoredTextStoreOverTransport, EXTRACTORS, calculateChecksum } from '@semiont/content';
+import { archivistContentReads, createAnchoredTextStore, EXTRACTORS, calculateChecksum } from '@semiont/content';
+import { replyChannelsFor, 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 { registerVectorIndexSizeProvider, withActorSpan } from '@semiont/observability';
-import { HttpTransport, HttpContentTransport } 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';
@@ -9805,23 +9808,24 @@ function isWorkItem(input) {
   return WORK_ITEM_TYPES.has(input.type);
 }
 var Smelter = class _Smelter {
-  constructor(events$, rebuildAnchors$, vectorStore, embeddingProvider, content, bus, chunkingConfig2, timing, logger2) {
+  constructor(events$, rebuildAnchors$, vectorStore, embeddingProvider, content, anchoredStore, bus, chunkingConfig2, timing, logger2) {
     this.events$ = events$;
     this.rebuildAnchors$ = rebuildAnchors$;
     this.vectorStore = vectorStore;
     this.embeddingProvider = embeddingProvider;
     this.content = content;
+    this.anchoredStore = anchoredStore;
     this.bus = bus;
     this.chunkingConfig = chunkingConfig2;
     this.timing = timing;
     this.logger = logger2;
-    this.anchoredStore = anchoredTextStoreOverTransport(content, logger2.child({ component: "anchored-text-cache" }));
   }
   events$;
   rebuildAnchors$;
   vectorStore;
   embeddingProvider;
   content;
+  anchoredStore;
   bus;
   chunkingConfig;
   timing;
@@ -9845,7 +9849,6 @@ var Smelter = class _Smelter {
    * OCR pass.
    */
   drainChain = Promise.resolve();
-  anchoredStore;
   get eventsProcessed() {
     return this._eventsProcessed;
   }
@@ -10075,7 +10078,7 @@ var Smelter = class _Smelter {
       });
       return;
     }
-    await this.content.putAnchoredText(checksum, { ...extracted, items: extracted.items });
+    await this.anchoredStore.write(checksum, { ...extracted, items: extracted.items });
     this.logger.info("Re-anchored resource", { resourceId: rid, checksum, items: extracted.items.length });
   }
   async handleResourcePurge(event) {
@@ -10092,14 +10095,14 @@ 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 });
+        this.logger.debug("Skipping resource with no extractor for its media type", { resourceId: resourceId6, contentType });
         return { kind: "skipped", checksum, reason: "no-extractor" };
       }
       const extracted = await extractor.extract(bytes, contentType, {
@@ -10107,26 +10110,26 @@ var Smelter = class _Smelter {
         store: this.anchoredStore
       });
       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 +10139,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 +10155,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 +10243,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
@@ -10362,7 +10365,7 @@ var Smelter = class _Smelter {
         // per resource (PERSIST-ANCHORS P0). Keys are resource ids today;
         // P1 rekeys the store by content checksum and this lookup moves
         // with it.
-        this.content.listAnchoredTextKeys().then((keys) => new Set(keys))
+        this.anchoredStore.list().then((keys) => new Set(keys))
       ]);
       const resources = await this.listAllResources();
       this.logger.info("Reconcile started", {
@@ -10483,16 +10486,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 +10505,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 {
@@ -10555,6 +10558,98 @@ 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:anchored-text-by-checksum-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)
+];
 var configPath = join(homedir(), ".semiontconfig");
 var tomlReader = {
   readIfExists: (p) => existsSync(p) ? readFileSync(p, "utf-8") : null
@@ -10564,11 +10659,11 @@ var envConfig = createTomlConfigLoader(
   configPath,
   process.env
 )(null);
-var backendPublicURL = envConfig.services?.backend?.publicURL;
-if (!backendPublicURL) {
-  throw new Error("services.backend.publicURL is required in ~/.semiontconfig");
+var gatewayPublicURL = envConfig.services?.gateway?.publicURL;
+if (!gatewayPublicURL) {
+  throw new Error("services.gateway.publicURL is required in ~/.semiontconfig");
 }
-var baseUrl = backendPublicURL;
+var baseUrl = gatewayPublicURL;
 var embedding = envConfig.services?.embedding;
 if (!embedding?.type || !embedding?.model) {
   throw new Error("services.embedding.{type,model} are required in ~/.semiontconfig");
@@ -10590,7 +10685,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) {
@@ -10617,7 +10712,7 @@ async function authenticate() {
     isTransientFetchError,
     STARTUP_FETCH_RETRY,
     ({ attempt, attempts, delayMs, error }) => {
-      logger.warn("Backend unreachable, retrying authentication", {
+      logger.warn("Gateway unreachable, retrying authentication", {
         attempt,
         attempts,
         retryInMs: delayMs,
@@ -10661,19 +10756,30 @@ 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
   });
-  const contentTransport = new HttpContentTransport(httpTransport);
-  logger.info("Content transport ready", { mode: "http" });
+  const contentReads = archivistContentReads(envConfig);
+  logger.info("Content reads ready", { via: "archivist" });
+  const anchoredTextDir = process.env.SEMIONT_ANCHORED_TEXT_DIR;
+  if (!anchoredTextDir) {
+    throw new Error("SEMIONT_ANCHORED_TEXT_DIR is required \u2014 the Smelter owns the anchored-text store and has no default for where it lives");
+  }
+  const anchoredStore = createAnchoredTextStore(anchoredTextDir, logger.child({ component: "anchored-text-store" }));
   const smelter = new Smelter(
     actorStateUnit.events$,
     actorStateUnit.rebuildAnchors$,
     vectorStore,
     embeddingProvider,
-    contentTransport,
+    contentReads,
+    anchoredStore,
     httpTransport,
     chunkingConfig,
     { burstWindowMs: 50, maxBatchSize: 100, idleTimeoutMs: 200 },