@semiont/make-meaning 0.5.29 → 0.5.31

package/dist/weaver-main.js

@@ -1,9 +1,14 @@
-import { createTomlConfigLoader, accessToken, baseUrl as baseUrl$1, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, errField, burstBuffer, busRequest, resourceId, didToAgent, annotationId, findBodyItem } from '@semiont/core';
+import { replyChannelsFor, createTomlConfigLoader, accessToken, baseUrl as baseUrl$1, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, errField, burstBuffer, busRequest, resourceId, didToAgent, annotationId, findBodyItem } from '@semiont/core';
+import { getGraphDatabase, intendedGraphAnnotation } from '@semiont/graph';
 import { existsSync, readFileSync, promises } from 'fs';
 import * as path from 'path';
 import { join } from 'path';
+import '@semiont/observability';
+import '@semiont/ontology';
+import '@semiont/content';
+import '@semiont/vectors';
+import '@semiont/event-sourcing';
 import { HttpTransport } from '@semiont/http-transport';
-import { getGraphDatabase } from '@semiont/graph';
 import { createServer } from 'http';
 import { homedir } from 'os';
 import { createProcessLogger } from '@semiont/observability/process-logger';
@@ -9910,18 +9915,18 @@ var Weaver = class _Weaver {
       set.add(seq);
     }
   }
-  noteApplied(resourceId, sequenceNumber) {
-    const failed = this.failedSeqs.get(resourceId);
+  noteApplied(resourceId6, sequenceNumber) {
+    const failed = this.failedSeqs.get(resourceId6);
     let capped = sequenceNumber;
     if (failed && failed.size > 0) {
       capped = Math.min(capped, Math.min(...failed) - 1);
     }
-    const current = this.lastProcessed.get(resourceId);
+    const current = this.lastProcessed.get(resourceId6);
     if (current !== void 0 && current >= capped) return;
-    this.lastProcessed.set(resourceId, capped);
+    this.lastProcessed.set(resourceId6, capped);
     this.checkpointDirty = true;
-    this.bus.emit("weave:applied", { resourceId, sequenceNumber: capped }).catch((err) => {
-      this.logger.warn("weave:applied emit failed", { resourceId, sequenceNumber: capped, error: errField(err) });
+    this.bus.emit("weave:applied", { resourceId: resourceId6, sequenceNumber: capped }).catch((err) => {
+      this.logger.warn("weave:applied emit failed", { resourceId: resourceId6, sequenceNumber: capped, error: errField(err) });
     });
   }
   async flushCheckpoint() {
@@ -9967,8 +9972,8 @@ var Weaver = class _Weaver {
     return resources;
   }
   /** A resource's full event history over the bus, sorted by sequence. */
-  async fetchResourceEvents(resourceId) {
-    const reply = await busRequest(this.bus, "browse:events-requested", { resourceId });
+  async fetchResourceEvents(resourceId6) {
+    const reply = await busRequest(this.bus, "browse:events-requested", { resourceId: resourceId6 });
     return [...reply.events].sort((a, b) => a.metadata.sequenceNumber - b.metadata.sequenceNumber);
   }
   async catchUp() {
@@ -10076,6 +10081,7 @@ var Weaver = class _Weaver {
     let divergent = 0;
     let healed = 0;
     let healFailures = 0;
+    let orphaned = 0;
     for (const resource of resources) {
       const rid = resource["@id"];
       if (!rid) continue;
@@ -10084,11 +10090,17 @@ var Weaver = class _Weaver {
       divergent++;
       this.logger.warn("Reconcile divergence \u2014 healing from the log", { resourceId: String(rid), reason });
       const result = await this.rebuildResource(resourceId(String(rid)));
-      if (result.eventsFailed === 0) healed++;
+      if (result.eventCount === 0) {
+        orphaned++;
+        this.logger.warn(
+          "Reconcile found an orphaned view \u2014 the log has no events for this resource, so healing wrote nothing",
+          { resourceId: String(rid), reason, remedy: "semiont stop && semiont clean --store state && semiont start" }
+        );
+      } else if (result.eventsFailed === 0) healed++;
       else healFailures++;
     }
-    const summary = { resourcesChecked: resources.length, divergent, healed, healFailures };
-    if (divergent > 0 || healFailures > 0) {
+    const summary = { resourcesChecked: resources.length, divergent, healed, healFailures, orphaned };
+    if (divergent > 0 || healFailures > 0 || orphaned > 0) {
       this.logger.warn("Weaver reconcile found divergence", summary);
     } else {
       this.logger.info("Weaver reconcile complete \u2014 projection matches the catalog", summary);
@@ -10130,13 +10142,13 @@ var Weaver = class _Weaver {
     for (const id of viewIds) {
       if (!graphIds.has(id)) return "annotation-set-mismatch";
     }
-    const bodyKey = (a) => _Weaver.canonicalJson(a.body ?? []);
     const viewById = new Map(annotations.map((a) => [String(a.id), a]));
     for (const graphAnnotation of graphAnnotations) {
       const viewAnnotation = viewById.get(String(graphAnnotation.id));
       if (!viewAnnotation) continue;
-      if (bodyKey(graphAnnotation) !== bodyKey(viewAnnotation)) {
-        return "annotation-body-mismatch";
+      const intended = intendedGraphAnnotation({ ...viewAnnotation, creator: graphAnnotation.creator });
+      if (_Weaver.canonicalJson(graphAnnotation) !== _Weaver.canonicalJson(intended)) {
+        return "annotation-content-mismatch";
       }
     }
     return null;
@@ -10466,30 +10478,30 @@ var Weaver = class _Weaver {
    * Rebuild entire resource from events.
    * Bypasses the live pipeline — reads directly from event store.
    */
-  async rebuildResource(resourceId) {
+  async rebuildResource(resourceId6) {
     const graphDb = this.ensureInitialized();
-    this.logger.info("Rebuilding resource from events", { resourceId });
+    this.logger.info("Rebuilding resource from events", { resourceId: resourceId6 });
     try {
-      await graphDb.deleteResource(resourceId);
+      await graphDb.deleteResource(resourceId6);
     } catch (error) {
-      this.logger.debug("No existing resource to delete", { resourceId });
+      this.logger.debug("No existing resource to delete", { resourceId: resourceId6 });
     }
-    const events = await this.fetchResourceEvents(String(resourceId));
+    const events = await this.fetchResourceEvents(String(resourceId6));
     let eventsFailed = 0;
     for (const storedEvent of events) {
       if (!await this.safeApplyEvent(storedEvent)) eventsFailed++;
     }
     if (events.length > 0 && eventsFailed === 0) {
-      this.noteApplied(String(resourceId), Math.max(...events.map((e) => e.metadata.sequenceNumber)));
+      this.noteApplied(String(resourceId6), Math.max(...events.map((e) => e.metadata.sequenceNumber)));
     }
     if (eventsFailed > 0) {
       this.logger.error("Resource rebuild dropped events \u2014 graph incomplete for this resource", {
-        resourceId,
+        resourceId: resourceId6,
         eventsFailed
       });
     }
-    this.logger.info("Resource rebuild complete", { resourceId, eventCount: events.length, eventsFailed });
-    return { eventsApplied: events.length - eventsFailed, eventsFailed };
+    this.logger.info("Resource rebuild complete", { resourceId: resourceId6, eventCount: events.length, eventsFailed });
+    return { eventCount: events.length, eventsApplied: events.length - eventsFailed, eventsFailed };
   }
   /**
    * Rebuild entire GraphDB from all events.
@@ -10510,15 +10522,15 @@ var Weaver = class _Weaver {
     this.logger.info("Found resources to rebuild", { count: allResourceIds.length });
     const ledger = /* @__PURE__ */ new Map();
     this.logger.info("PASS 1: Creating all nodes (resources + annotations)");
-    for (const resourceId of allResourceIds) {
-      const events = await this.fetchResourceEvents(String(resourceId));
+    for (const resourceId6 of allResourceIds) {
+      const events = await this.fetchResourceEvents(String(resourceId6));
       if (events.length === 0) continue;
       const entry = {
         maxSeq: Math.max(...events.map((e) => e.metadata.sequenceNumber)),
         attempted: 0,
         failed: 0
       };
-      ledger.set(String(resourceId), entry);
+      ledger.set(String(resourceId6), entry);
       for (const storedEvent of events) {
         if (storedEvent.type === "mark:body-updated") {
           continue;
@@ -10529,11 +10541,11 @@ var Weaver = class _Weaver {
     }
     this.logger.info("Pass 1 complete - all nodes created");
     this.logger.info("PASS 2: Creating all REFERENCES edges");
-    for (const resourceId of allResourceIds) {
-      const events = await this.fetchResourceEvents(String(resourceId));
+    for (const resourceId6 of allResourceIds) {
+      const events = await this.fetchResourceEvents(String(resourceId6));
       for (const storedEvent of events) {
         if (storedEvent.type === "mark:body-updated") {
-          const entry = ledger.get(String(resourceId));
+          const entry = ledger.get(String(resourceId6));
           if (entry) entry.attempted++;
           if (!await this.safeApplyEvent(storedEvent)) {
             if (entry) entry.failed++;
@@ -10561,8 +10573,8 @@ var Weaver = class _Weaver {
    * Get consumer health metrics.
    */
   /** Highest applied sequence for a resource, if any — diagnostics/tests. */
-  appliedUpTo(resourceId) {
-    return this.lastProcessed.get(resourceId);
+  appliedUpTo(resourceId6) {
+    return this.lastProcessed.get(resourceId6);
   }
   getHealthMetrics() {
     return {
@@ -10614,6 +10626,110 @@ var FileWeaverCheckpoint = class {
     await promises.rename(tmp, this.filePath);
   }
 };
+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"
+];
+replyChannelsFor(SMELTER_AWAITED_OPERATIONS);
+var WEAVER_AWAITED_OPERATIONS = [
+  "browse:resources-requested",
+  "browse:events-requested",
+  "browse:annotations-requested"
+];
+var WEAVER_REPLY_CHANNELS = 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) {
+  onState?.({ phase: "running" });
+  try {
+    const summary = await run();
+    onState?.({ phase: "done", summary });
+  } catch (error) {
+    onState?.({ phase: "failed", error: error instanceof Error ? error.message : String(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
@@ -10637,7 +10753,7 @@ if (maybeGraphConfig.type === "memory") {
 }
 var graphConfig = maybeGraphConfig;
 var workerSecret = process.env.SEMIONT_WORKER_SECRET ?? "";
-var healthPort = 9092;
+var healthPort = 24102;
 var stateHome = process.env.XDG_STATE_HOME ?? join(homedir(), ".local", "state");
 var checkpointPath = join(stateHome, "semiont", "weaver-checkpoint.json");
 var logger = createProcessLogger("weaver");
@@ -10698,7 +10814,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
+    // WEAVER_AWAITED_OPERATIONS. The domain-event channels are added by
+    // the actor state unit's start() below.
+    channels: WEAVER_REPLY_CHANNELS
   });
   const actorStateUnit = createWeaverActorStateUnit({
     bus: httpTransport.actor
@@ -10755,22 +10876,12 @@ async function main() {
   };
   process.on("SIGTERM", shutdown);
   process.on("SIGINT", shutdown);
-  catchUpState = { phase: "running" };
-  try {
-    const summary = await weaver.catchUp();
-    catchUpState = { phase: "done", summary };
-  } catch (error) {
-    catchUpState = { phase: "failed", error: error instanceof Error ? error.message : String(error) };
-    throw error;
-  }
-  reconcileState = { phase: "running" };
-  try {
-    const summary = await weaver.reconcile();
-    reconcileState = { phase: "done", summary };
-  } catch (error) {
-    reconcileState = { phase: "failed", error: error instanceof Error ? error.message : String(error) };
-    throw error;
-  }
+  await runBootPass("catch-up", () => weaver.catchUp(), logger, (s) => {
+    catchUpState = s;
+  });
+  await runBootPass("reconcile", () => weaver.reconcile(), logger, (s) => {
+    reconcileState = s;
+  });
 }
 main().catch((error) => {
   logger.error("Fatal", { error: error instanceof Error ? error.message : String(error), stack: error instanceof Error ? error.stack : void 0 });