@semiont/make-meaning 0.5.24 → 0.5.26

package/dist/smelter-main.js

@@ -1,8 +1,8 @@
-import { createTomlConfigLoader, accessToken, baseUrl as baseUrl$1, retryWithBackoff, isTransientFetchError, STARTUP_FETCH_RETRY, burstBuffer, errField, resourceId, textExtractionOf, decodeRepresentation, busRequest, getResourceEntityTypes, getTargetSelector, getExactText, annotationId, getPrimaryMediaType, getPrimaryRepresentation } from '@semiont/core';
-import { calculateChecksum } from '@semiont/content';
-import { createEmbeddingProvider, createVectorStore, chunkText } from '@semiont/vectors';
+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 { registerVectorIndexSizeProvider, withActorSpan } from '@semiont/observability';
 import { HttpTransport, HttpContentTransport } from '@semiont/http-transport';
+import { createEmbeddingProvider, createVectorStore } from '@semiont/vectors';
 import { createServer } from 'http';
 import { existsSync, readFileSync } from 'fs';
 import { homedir } from 'os';
@@ -9738,6 +9738,7 @@ var SMELTER_CHANNELS = [
   "mark:entity-tag-added",
   "mark:entity-tag-removed"
 ];
+var SMELTER_COMMAND_CHANNELS = ["smelt:rebuild-anchors"];
 function createSmelterActorStateUnit(options) {
   const { bus } = options;
   let started = false;
@@ -9752,12 +9753,14 @@ function createSmelterActorStateUnit(options) {
       )
     )
   );
+  const rebuildAnchors$ = bus.on$("smelt:rebuild-anchors");
   return {
     events$,
+    rebuildAnchors$,
     start: () => {
       if (started) return;
       started = true;
-      bus.addChannels?.([...SMELTER_CHANNELS]);
+      bus.addChannels?.([...SMELTER_CHANNELS, ...SMELTER_COMMAND_CHANNELS]);
     },
     dispose: () => {
       started = false;
@@ -9793,6 +9796,7 @@ function sameStringSet(a, b) {
 var WORK_ITEM_TYPES = /* @__PURE__ */ new Set([
   "smelt:embed",
   "smelt:restamp",
+  "smelt:reanchor",
   "smelt:purge",
   "smelt:embed-annotation",
   "smelt:purge-annotation"
@@ -9801,8 +9805,9 @@ function isWorkItem(input) {
   return WORK_ITEM_TYPES.has(input.type);
 }
 var Smelter = class _Smelter {
-  constructor(events$, vectorStore, embeddingProvider, content, bus, chunkingConfig2, timing, logger2) {
+  constructor(events$, rebuildAnchors$, vectorStore, embeddingProvider, content, bus, chunkingConfig2, timing, logger2) {
     this.events$ = events$;
+    this.rebuildAnchors$ = rebuildAnchors$;
     this.vectorStore = vectorStore;
     this.embeddingProvider = embeddingProvider;
     this.content = content;
@@ -9810,8 +9815,10 @@ var Smelter = class _Smelter {
     this.chunkingConfig = chunkingConfig2;
     this.timing = timing;
     this.logger = logger2;
+    this.anchoredStore = anchoredTextStoreOverTransport(content, logger2.child({ component: "anchored-text-cache" }));
   }
   events$;
+  rebuildAnchors$;
   vectorStore;
   embeddingProvider;
   content;
@@ -9824,11 +9831,21 @@ var Smelter = class _Smelter {
   static RECONCILE_WAVE = 8;
   eventSubject = new import_rxjs2.Subject();
   sourceSubscription = null;
+  commandSubscription = null;
   pipelineSubscription = null;
   _eventsProcessed = 0;
   _reconcileState = { phase: "pending" };
   workDone = 0;
+  workFailed = 0;
   workWaiter = null;
+  /**
+   * Serializes every planner drain (reconcile, anchored-text rebuilds):
+   * there is one waiter slot, and the weave:rebuild rule — rebuilds never
+   * interleave — applies to every unit here being a potential multi-second
+   * OCR pass.
+   */
+  drainChain = Promise.resolve();
+  anchoredStore;
   get eventsProcessed() {
     return this._eventsProcessed;
   }
@@ -9856,7 +9873,7 @@ var Smelter = class _Smelter {
             return (0, import_rxjs2.from)(
               withActorSpan("smelter", inputOrBatch.type, async () => {
                 const ok = await this.safeProcessEvent(inputOrBatch);
-                if (isWorkItem(inputOrBatch)) this.noteWorkDone(1);
+                if (isWorkItem(inputOrBatch)) this.noteWorkDone(1, ok ? 0 : 1);
                 else if (ok) this._eventsProcessed++;
               })
             );
@@ -9870,18 +9887,26 @@ var Smelter = class _Smelter {
       this.logger.debug("Bus event received", { type: event.type, resourceId: event.resourceId });
       this.eventSubject.next(event);
     });
+    this.commandSubscription = this.rebuildAnchors$.pipe(
+      (0, import_operators2.concatMap)((command) => (0, import_rxjs2.from)(this.rebuildAnchors(command)))
+    ).subscribe({
+      error: (err) => this.logger.error("Smelter command pipeline error", { error: errField(err) })
+    });
     this.logger.info("Smelter pipeline initialized");
   }
   stop() {
     this.sourceSubscription?.unsubscribe();
     this.sourceSubscription = null;
+    this.commandSubscription?.unsubscribe();
+    this.commandSubscription = null;
     this.pipelineSubscription?.unsubscribe();
     this.pipelineSubscription = null;
     this.eventSubject.complete();
     this.logger.info("Smelter stopped");
   }
-  noteWorkDone(count) {
+  noteWorkDone(count, failed) {
     this.workDone += count;
+    this.workFailed += failed;
     if (this.workWaiter && this.workDone >= this.workWaiter.target) {
       this.workWaiter.resolve();
       this.workWaiter = null;
@@ -9895,12 +9920,15 @@ var Smelter = class _Smelter {
     let wireProcessed = 0;
     for (const run of partitionByType(events)) {
       const workRun = isWorkItem(run[0]);
+      let succeeded = 0;
       try {
         if (run.length === 1) {
           const ok = await this.safeProcessEvent(run[0]);
+          if (ok) succeeded = 1;
           if (ok && !workRun) wireProcessed++;
         } else {
           const processed = await this.applyBatchByType(run);
+          succeeded = processed;
           if (!workRun) wireProcessed += processed;
         }
       } catch (error) {
@@ -9910,7 +9938,7 @@ var Smelter = class _Smelter {
           error: errField(error)
         });
       } finally {
-        if (workRun) this.noteWorkDone(run.length);
+        if (workRun) this.noteWorkDone(run.length, run.length - succeeded);
       }
     }
     return wireProcessed;
@@ -9982,6 +10010,9 @@ var Smelter = class _Smelter {
       case "smelt:restamp":
         await this.restampResource(event);
         break;
+      case "smelt:reanchor":
+        await this.reanchorResource(event);
+        break;
       case "smelt:purge":
         await this.handleResourcePurge(event);
         break;
@@ -10008,6 +10039,45 @@ var Smelter = class _Smelter {
     await this.vectorStore.updateResourceEntityTypes(resourceId(rid), entityTypes);
     this.logger.info("Restamped resource entity types", { resourceId: rid, entityTypes });
   }
+  /**
+   * Re-derive a lost anchored-text artifact from the resource's current
+   * bytes (PERSIST-ANCHORS P0, the third drift class). Extraction is the
+   * cost here — the vectors are already correct, so this NEVER calls the
+   * embedding provider, the vector store, or the settled signal: the index
+   * decision was already made and announced at its checksum; only the map
+   * is missing. Name the work for what it does (the S13 discipline).
+   *
+   * The publish is STRICT, unlike the embed path's best-effort side
+   * publish: here the artifact IS the job, so a store failure must throw —
+   * the pipeline logs and counts it, and the rebuild command's partial-
+   * failure accounting depends on that throw.
+   */
+  async reanchorResource(event) {
+    const rid = event.resourceId;
+    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) {
+      this.logger.info("Re-anchor found no geometry-capable extractor", { resourceId: rid, contentType });
+      return;
+    }
+    const checksum = calculateChecksum(bytes);
+    const extracted = await extractor.extract(bytes, contentType, {
+      key: checksum,
+      store: this.anchoredStore
+    });
+    if ("declined" in extracted || !extracted.items?.length) {
+      this.logger.info("Re-anchor extraction yielded no geometry", {
+        resourceId: rid,
+        contentType,
+        ..."declined" in extracted ? { declined: extracted.declined } : {}
+      });
+      return;
+    }
+    await this.content.putAnchoredText(checksum, { ...extracted, items: extracted.items });
+    this.logger.info("Re-anchored resource", { resourceId: rid, checksum, items: extracted.items.length });
+  }
   async handleResourcePurge(event) {
     const rid = event.resourceId;
     if (!rid) return;
@@ -10027,12 +10097,34 @@ var Smelter = class _Smelter {
       const { data, contentType } = await this.content.getBinary(resourceId(resourceId$1));
       const bytes = Buffer.from(data);
       const checksum = calculateChecksum(bytes);
-      if (textExtractionOf(contentType) !== "decode") {
-        this.logger.debug("Skipping resource that does not decode as text", { resourceId: resourceId$1, contentType });
-        return { kind: "skipped", checksum };
+      const extractor = EXTRACTORS[textExtractionOf(contentType)];
+      if (!extractor) {
+        this.logger.debug("Skipping resource with no extractor for its media type", { resourceId: resourceId$1, contentType });
+        return { kind: "skipped", checksum, reason: "no-extractor" };
+      }
+      const extracted = await extractor.extract(bytes, contentType, {
+        key: checksum,
+        store: this.anchoredStore
+      });
+      if ("declined" in extracted) {
+        this.logger.debug("Extractor declined", { resourceId: resourceId$1, 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,
+          contentType,
+          ...extracted.ocrConfidence
+        });
       }
-      const text = decodeRepresentation(bytes, contentType);
-      return text.trim() ? { kind: "text", text, checksum } : { kind: "skipped", checksum };
+      if (extracted.unreadPages?.length) {
+        this.logger.info("Partial extraction coverage", {
+          resourceId: resourceId$1,
+          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) });
       return { kind: "unavailable" };
@@ -10044,9 +10136,9 @@ 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) {
+  async emitSettled(resourceId, contentChecksum, outcome, reason) {
     try {
-      await this.bus.emit("smelt:settled", { resourceId, contentChecksum, outcome });
+      await this.bus.emit("smelt:settled", { resourceId, contentChecksum, outcome, ...reason ? { reason } : {} });
     } catch (error) {
       this.logger.warn("Failed to emit smelt:settled", { resourceId, outcome, error: errField(error) });
     }
@@ -10074,12 +10166,14 @@ var Smelter = class _Smelter {
     const fetched = await this.fetchEmbeddableText(rid);
     if (fetched.kind === "unavailable") return;
     if (fetched.kind === "skipped") {
-      await this.emitSettled(rid, fetched.checksum, "skipped");
+      await this.vectorStore.deleteResourceVectors(resourceId(rid));
+      await this.emitSettled(rid, fetched.checksum, "skipped", fetched.reason);
       return;
     }
     const chunks = chunkText(fetched.text, this.chunkingConfig);
     if (chunks.length === 0) {
-      await this.emitSettled(rid, fetched.checksum, "skipped");
+      await this.vectorStore.deleteResourceVectors(resourceId(rid));
+      await this.emitSettled(rid, fetched.checksum, "skipped", "empty");
       return;
     }
     const entityTypes = await this.resolveEntityTypes(rid);
@@ -10089,7 +10183,7 @@ var Smelter = class _Smelter {
       text: t,
       embedding: embeddings[i]
     }));
-    await this.vectorStore.upsertResourceVectors(resourceId(rid), embeddingChunks, fetched.checksum, entityTypes);
+    await this.vectorStore.upsertResourceVectors(resourceId(rid), embeddingChunks, fetched.checksum, entityTypes, fetched.machineRead);
     await this.emitSettled(rid, fetched.checksum, "indexed");
     this.logger.info(logMessage, { resourceId: rid, chunks: chunks.length });
   }
@@ -10133,12 +10227,14 @@ var Smelter = class _Smelter {
     if (!exactText?.trim()) return;
     const aid = annotationId(annotation.id);
     const embedding2 = await this.embeddingProvider.embed(exactText);
+    const stamp = await this.vectorStore.getResourceStamp(resourceId(rid));
     const payload = {
       annotationId: aid,
       resourceId: resourceId(rid),
       motivation: annotation.motivation ?? "",
       entityTypes: annotation.entityTypes ?? [],
-      exactText
+      exactText,
+      ...stamp?.machineRead ? { machineRead: true } : {}
     };
     await this.vectorStore.upsertAnnotationVector(aid, embedding2, payload);
     this.logger.info("Indexed annotation", { annotationId: String(aid) });
@@ -10163,28 +10259,30 @@ var Smelter = class _Smelter {
       const fetched = await this.fetchEmbeddableText(rid);
       if (fetched.kind === "unavailable") continue;
       if (fetched.kind === "skipped") {
-        await this.emitSettled(rid, fetched.checksum, "skipped");
+        await this.vectorStore.deleteResourceVectors(resourceId(rid));
+        await this.emitSettled(rid, fetched.checksum, "skipped", fetched.reason);
         continue;
       }
       const chunks = chunkText(fetched.text, this.chunkingConfig);
       if (chunks.length === 0) {
-        await this.emitSettled(rid, fetched.checksum, "skipped");
+        await this.vectorStore.deleteResourceVectors(resourceId(rid));
+        await this.emitSettled(rid, fetched.checksum, "skipped", "empty");
         continue;
       }
       const entityTypes = await this.resolveEntityTypes(rid);
-      resourceData.push({ rid: resourceId(rid), chunks, checksum: fetched.checksum, entityTypes });
+      resourceData.push({ rid: resourceId(rid), chunks, checksum: fetched.checksum, entityTypes, machineRead: fetched.machineRead });
       allChunks.push(...chunks);
     }
     if (allChunks.length === 0) return events.length;
     const allEmbeddings = await this.embeddingProvider.embedBatch(allChunks);
     let offset = 0;
-    for (const { rid, chunks, checksum, entityTypes } of resourceData) {
+    for (const { rid, chunks, checksum, entityTypes, machineRead } of resourceData) {
       const embeddingChunks = chunks.map((t, i) => ({
         chunkIndex: i,
         text: t,
         embedding: allEmbeddings[offset + i]
       }));
-      await this.vectorStore.upsertResourceVectors(rid, embeddingChunks, checksum, entityTypes);
+      await this.vectorStore.upsertResourceVectors(rid, embeddingChunks, checksum, entityTypes, machineRead);
       await this.emitSettled(String(rid), checksum, "indexed");
       this.logger.info("Batch-indexed resource", { resourceId: String(rid), chunks: chunks.length });
       offset += chunks.length;
@@ -10257,26 +10355,23 @@ var Smelter = class _Smelter {
     }
     this._reconcileState = { phase: "running" };
     try {
-      const [indexedResources, indexedAnnotations] = await Promise.all([
+      const [indexedResources, indexedAnnotations, anchoredKeys] = await Promise.all([
         this.vectorStore.listResourceStamps(),
-        this.vectorStore.listAnnotationIds()
+        this.vectorStore.listAnnotationIds(),
+        // The artifact store's would-hit keys — one bulk read, never a probe
+        // 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))
       ]);
       const resources = await this.listAllResources();
       this.logger.info("Reconcile started", {
         indexedResources: indexedResources.size,
         indexedAnnotations: indexedAnnotations.size,
+        anchoredArtifacts: anchoredKeys.size,
         liveResources: resources.length
       });
-      const embeddable = /* @__PURE__ */ new Map();
-      for (const resource of resources) {
-        const mediaType = getPrimaryMediaType(resource);
-        if (resource["@id"] && mediaType && textExtractionOf(mediaType) === "decode") {
-          embeddable.set(resource["@id"], {
-            checksum: getPrimaryRepresentation(resource)?.checksum,
-            entityTypes: getResourceEntityTypes(resource)
-          });
-        }
-      }
+      const embeddable = this.classifyEmbeddable(resources);
       const work = [];
       for (const rid of indexedResources.keys()) {
         if (!embeddable.has(rid)) work.push({ type: "smelt:purge", resourceId: rid, payload: {} });
@@ -10290,6 +10385,9 @@ var Smelter = class _Smelter {
         } else if (!sameStringSet(indexed.entityTypes, catalog.entityTypes)) {
           work.push({ type: "smelt:restamp", resourceId: rid, payload: {} });
         }
+        if (indexed && catalog.checksum !== void 0 && indexed.contentChecksum === catalog.checksum && catalog.yieldsGeometry && !anchoredKeys.has(catalog.checksum)) {
+          work.push({ type: "smelt:reanchor", resourceId: rid, payload: {} });
+        }
       }
       const liveAnnotationIds = /* @__PURE__ */ new Set();
       for (const resource of resources) {
@@ -10318,9 +10416,12 @@ var Smelter = class _Smelter {
       const summary = {
         resourcesEmbedded: work.filter((w) => w.type === "smelt:embed").length,
         resourcesRestamped: work.filter((w) => w.type === "smelt:restamp").length,
+        resourcesReanchored: work.filter((w) => w.type === "smelt:reanchor").length,
         resourceVectorsDeleted: work.filter((w) => w.type === "smelt:purge").length,
         annotationsEmbedded: work.filter((w) => w.type === "smelt:embed-annotation").length,
-        annotationVectorsDeleted: work.filter((w) => w.type === "smelt:purge-annotation").length
+        annotationVectorsDeleted: work.filter((w) => w.type === "smelt:purge-annotation").length,
+        resourcesEligible: embeddable.size,
+        resourcesIndexed: (await this.vectorStore.listResourceStamps()).size
       };
       this._reconcileState = { phase: "done", summary };
       this.logger.info("Reconcile complete", { ...summary });
@@ -10339,16 +10440,106 @@ var Smelter = class _Smelter {
    * completion. The pipeline ticks `noteWorkDone` for every consumed work
    * item (success or failure — failures are logged like any live event), so
    * each wave's waiter resolves exactly when its items have been processed.
+   *
+   * Serialized through `drainChain`: there is ONE waiter slot, and the
+   * planners that drain (reconcile, `smelt:rebuild-anchors`) must not
+   * interleave — a rebuild command arriving mid-reconcile waits its turn.
+   *
+   * @returns how many of THESE items failed — the rebuild command's
+   * partial-failure accounting (failure detail is in the logs).
    */
   async drain(work) {
-    for (let i = 0; i < work.length; i += _Smelter.RECONCILE_WAVE) {
-      const wave = work.slice(i, i + _Smelter.RECONCILE_WAVE);
-      const done = new Promise((resolve) => {
-        this.workWaiter = { target: this.workDone + wave.length, resolve };
-      });
-      for (const item of wave) this.eventSubject.next(item);
-      await done;
+    let failures = 0;
+    const run = this.drainChain.then(async () => {
+      const failedBefore = this.workFailed;
+      for (let i = 0; i < work.length; i += _Smelter.RECONCILE_WAVE) {
+        const wave = work.slice(i, i + _Smelter.RECONCILE_WAVE);
+        const done = new Promise((resolve) => {
+          this.workWaiter = { target: this.workDone + wave.length, resolve };
+        });
+        for (const item of wave) this.eventSubject.next(item);
+        await done;
+      }
+      failures = this.workFailed - failedBefore;
+    });
+    this.drainChain = run.then(() => void 0, () => void 0);
+    await run;
+    return failures;
+  }
+  /**
+   * `smelt:rebuild-anchors` — the operator's explicit re-derivation of
+   * anchored-text artifacts (PERSIST-ANCHORS P0), shaped after
+   * `weave:rebuild`: optionally scoped, strictly serialized (concatMap on
+   * the command stream + the drain chain), correlated ok/failed replies,
+   * and partial completion FAILS — a rebuild that quietly skipped resources
+   * would present exactly like a document with no text, which is the #845
+   * failure mode wearing different clothes.
+   *
+   * Never destructive: nothing is deleted first, stale entries are simply
+   * overwritten (the W5-frames lesson — a rebuild that clears before it
+   * re-derives turns a partial failure into a loss). Re-anchoring makes
+   * zero embedding calls; work items ride the normal per-resource lanes,
+   * so a rebuild can never interleave with live processing of the same
+   * resource (S1/S2).
+   */
+  async rebuildAnchors(command) {
+    const { correlationId, resourceId } = command;
+    try {
+      let work;
+      if (resourceId) {
+        work = [{ type: "smelt:reanchor", resourceId, 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 });
+      const failed = await this.drain(work);
+      if (failed > 0) {
+        await this.bus.emit("smelt:rebuild-anchors-failed", {
+          ...correlationId ? { correlationId } : {},
+          message: `${failed} of ${work.length} resources failed to re-anchor \u2014 see smelter logs`
+        });
+        return;
+      }
+      await this.bus.emit("smelt:rebuild-anchors-ok", correlationId ? { correlationId } : {});
+      this.logger.info("Anchored-text rebuild complete", { scoped: resourceId ?? null, resources: work.length });
+    } catch (error) {
+      this.logger.error("Anchored-text rebuild failed", { error: errField(error) });
+      try {
+        await this.bus.emit("smelt:rebuild-anchors-failed", {
+          ...correlationId ? { correlationId } : {},
+          message: error instanceof Error ? error.message : String(error)
+        });
+      } catch (emitError) {
+        this.logger.warn("Failed to emit smelt:rebuild-anchors-failed", { error: errField(emitError) });
+      }
+    }
+  }
+  /**
+   * Embeddable live resources, each with the catalog's claims: the primary
+   * 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.
+   * 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) {
+        embeddable.set(resource["@id"], {
+          checksum: getPrimaryRepresentation(resource)?.checksum,
+          entityTypes: getResourceEntityTypes(resource),
+          yieldsGeometry: extractor.yieldsGeometry
+        });
+      }
     }
+    return embeddable;
   }
   /** Page through `browse:resources-requested` until the catalog is exhausted. */
   async listAllResources() {
@@ -10480,6 +10671,7 @@ async function main() {
   logger.info("Content transport ready", { mode: "http" });
   const smelter = new Smelter(
     actorStateUnit.events$,
+    actorStateUnit.rebuildAnchors$,
     vectorStore,
     embeddingProvider,
     contentTransport,