@semiont/make-meaning 0.5.28 → 0.5.30

package/dist/weaver-main.d.ts

@@ -0,0 +1,2 @@
+
+export { };

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 { existsSync, readFileSync, promises } from 'fs';
 import * as path from 'path';
 import { join } from 'path';
-import { HttpTransport } from '@semiont/http-transport';
+import '@semiont/observability';
+import '@semiont/ontology';
+import '@semiont/content';
 import { getGraphDatabase } from '@semiont/graph';
+import '@semiont/vectors';
+import '@semiont/event-sourcing';
+import { HttpTransport } from '@semiont/http-transport';
 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() {
@@ -10323,12 +10328,17 @@ var Weaver = class _Weaver {
       representations: [{
         mediaType: event.payload.format,
         checksum: event.payload.contentChecksum,
-        rel: "original"
+        rel: "original",
+        // The URI lives on the REPRESENTATION (STORAGE-URI-ONE-HOME D1).
+        // `ResourceDescriptor` is `additionalProperties: true`, so writing it
+        // at the top level typechecks and then reads back as undefined
+        // through `getStorageUri` — which is how the graph projection silently
+        // lost all 57 of its URIs until the P2 live gate caught it.
+        ...event.payload.storageUri ? { storageUri: event.payload.storageUri } : {}
       }],
       archived: false,
       dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
-      wasAttributedTo: didToAgent(event.userId),
-      ...event.payload.storageUri ? { storageUri: event.payload.storageUri } : {}
+      wasAttributedTo: didToAgent(event.userId)
     };
   }
   /**
@@ -10461,29 +10471,29 @@ 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 });
+    this.logger.info("Resource rebuild complete", { resourceId: resourceId6, eventCount: events.length, eventsFailed });
     return { eventsApplied: events.length - eventsFailed, eventsFailed };
   }
   /**
@@ -10505,15 +10515,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;
@@ -10524,11 +10534,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++;
@@ -10556,8 +10566,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 {
@@ -10609,6 +10619,98 @@ 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: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"
+];
+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)
+];
 var configPath = join(homedir(), ".semiontconfig");
 var tomlReader = {
   readIfExists: (p) => existsSync(p) ? readFileSync(p, "utf-8") : null
@@ -10618,11 +10720,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 maybeGraphConfig = envConfig.services?.graph;
 if (!maybeGraphConfig?.type) {
   throw new Error("services.graph.type is required in ~/.semiontconfig");
@@ -10632,7 +10734,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");
@@ -10661,7 +10763,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,
@@ -10693,7 +10795,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