@semiont/make-meaning 0.5.28 → 0.5.30

package/dist/index.js

@@ -1,17 +1,16 @@
 import { STALL_THRESHOLD_MS, FsJobQueue } from '@semiont/jobs';
 import { FilesystemViewStorage, resolveStorageUri, EventQuery, createEventStore } from '@semiont/event-sourcing';
-import { getResourceEntityTypes, getResourceId, getTargetSource, resourceId, getPrimaryRepresentation, decodeRepresentation, getBodySource, getTargetSelector, deriveViews, getTextPositionSelector, annotationId, errField, userId, generateUuid, getExactText, busRequest, cloneToken, baseMediaType, isSupportedMediaType, capabilitiesOf, didToAgent, assembleAnnotation, isGenerationJobParams, jobId, entityType, baseUrl, busLog, BRIDGED_CHANNELS, burstBuffer, textExtractionOf, chunkText, getPrimaryMediaType, extensionForMediaType, applyBodyOperations, softwareToAgent } from '@semiont/core';
+import { getResourceEntityTypes, getResourceId, getTargetSource, resourceId, decodeRepresentation, getBodySource, getStorageUri, getPrimaryRepresentation, getTargetSelector, deriveViews, getTextPositionSelector, annotationId, errField, userId, generateUuid, getExactText, busRequest, cloneToken, assembleAnnotation, applyBodyOperations, didToAgent, isGenerationJobParams, jobId, entityType, baseUrl, busLog, BRIDGED_CHANNELS, burstBuffer, textExtractionOf, chunkText, getPrimaryMediaType, isAnnotatable, softwareToAgent } from '@semiont/core';
 import { recordGatherDegrade, withActorSpan, recordBusEmit, withSpan, SpanKind, registerJobQueueProvider, registerVectorIndexSizeProvider } from '@semiont/observability';
 import { createInferenceClient } from '@semiont/inference';
 import { compareByRecencyThenId, getGraphDatabase } from '@semiont/graph';
-import { WorkingTreeStore, createAnchoredTextStore, deriveStorageUri, anchoredTextStoreOverTransport, EXTRACTORS, calculateChecksum } from '@semiont/content';
+import { WorkingTreeStore, createAnchoredTextStore, RepresentationMissing, ChecksumMismatchError, EXTRACTORS, calculateChecksum } from '@semiont/content';
 import { getEntityTypes, DEFAULT_ENTITY_TYPES } from '@semiont/ontology';
 import { mergeByResource } from '@semiont/vectors';
 import { promises } from 'fs';
 import * as path3 from 'path';
-import { createGzip, createGunzip } from 'zlib';
-import { pipeline, Readable } from 'stream';
-import { promisify } from 'util';
+import { createServer } from 'http';
+import { pipeline } from 'stream/promises';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -3568,7 +3567,7 @@ var require_firstValueFrom = __commonJS({
     exports.firstValueFrom = void 0;
     var EmptyError_1 = require_EmptyError();
     var Subscriber_1 = require_Subscriber();
-    function firstValueFrom2(source, config) {
+    function firstValueFrom(source, config) {
       var hasConfig = typeof config === "object";
       return new Promise(function(resolve2, reject) {
         var subscriber = new Subscriber_1.SafeSubscriber({
@@ -3588,7 +3587,7 @@ var require_firstValueFrom = __commonJS({
         source.subscribe(subscriber);
       });
     }
-    exports.firstValueFrom = firstValueFrom2;
+    exports.firstValueFrom = firstValueFrom;
   }
 });
 
@@ -3727,7 +3726,7 @@ var require_map = __commonJS({
     exports.map = void 0;
     var lift_1 = require_lift();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function map3(project, thisArg) {
+    function map2(project, thisArg) {
       return lift_1.operate(function(source, subscriber) {
         var index = 0;
         source.subscribe(OperatorSubscriber_1.createOperatorSubscriber(subscriber, function(value) {
@@ -3735,7 +3734,7 @@ var require_map = __commonJS({
         }));
       });
     }
-    exports.map = map3;
+    exports.map = map2;
   }
 });
 
@@ -4565,7 +4564,7 @@ var require_timer = __commonJS({
     var async_1 = require_async();
     var isScheduler_1 = require_isScheduler();
     var isDate_1 = require_isDate();
-    function timer2(dueTime, intervalOrScheduler, scheduler) {
+    function timer(dueTime, intervalOrScheduler, scheduler) {
       if (dueTime === void 0) {
         dueTime = 0;
       }
@@ -4598,7 +4597,7 @@ var require_timer = __commonJS({
         }, due);
       });
     }
-    exports.timer = timer2;
+    exports.timer = timer;
   }
 });
 
@@ -4788,7 +4787,7 @@ var require_race = __commonJS({
     var innerFrom_1 = require_innerFrom();
     var argsOrArgArray_1 = require_argsOrArgArray();
     var OperatorSubscriber_1 = require_OperatorSubscriber();
-    function race2() {
+    function race() {
       var sources = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         sources[_i] = arguments[_i];
@@ -4796,7 +4795,7 @@ var require_race = __commonJS({
       sources = argsOrArgArray_1.argsOrArgArray(sources);
       return sources.length === 1 ? innerFrom_1.innerFrom(sources[0]) : new Observable_1.Observable(raceInit(sources));
     }
-    exports.race = race2;
+    exports.race = race;
     function raceInit(sources) {
       return function(subscriber) {
         var subscriptions = [];
@@ -9252,14 +9251,14 @@ var require_race2 = __commonJS({
     exports.race = void 0;
     var argsOrArgArray_1 = require_argsOrArgArray();
     var raceWith_1 = require_raceWith();
-    function race2() {
+    function race() {
       var args = [];
       for (var _i = 0; _i < arguments.length; _i++) {
         args[_i] = arguments[_i];
       }
       return raceWith_1.raceWith.apply(void 0, __spreadArray([], __read(argsOrArgArray_1.argsOrArgArray(args))));
     }
-    exports.race = race2;
+    exports.race = race;
   }
 });
 
@@ -9726,6 +9725,45 @@ var require_operators = __commonJS({
 });
 
 // src/config.ts
+function requireKBName(config) {
+  const name = config.kb?.name;
+  if (!name) {
+    throw new Error(
+      "[kb] name is missing from the environment config. The launcher stages the KB's committed identity into each service's config (SINGLE-KB-MOUNT D4); without it this service cannot locate the state tree."
+    );
+  }
+  return name;
+}
+function makeMeaningConfigFrom(config) {
+  const meta = config._metadata;
+  const gather = meta?.gather;
+  if (!gather) {
+    throw new Error("make-meaning gather config missing \u2014 load config via loadEnvironmentConfig (the TOML loader owns the settleTimeoutMs default)");
+  }
+  const search = meta?.search;
+  if (!search) {
+    throw new Error("make-meaning search config missing \u2014 load config via loadEnvironmentConfig (the TOML loader owns the semanticFloor default)");
+  }
+  return {
+    gather,
+    search,
+    services: {
+      // vectors/embedding are required on both sides (MANDATORY-EMBEDDING P3):
+      // core's ServicesConfig requires the pair, so a config missing either
+      // already refused at the TOML loader — nothing to re-check here.
+      graph: config.services.graph,
+      vectors: config.services.vectors,
+      embedding: config.services.embedding,
+      archivist: config.services.archivist
+    },
+    // The KB's canonical identity — the agent roster mints DIDs from this,
+    // the SAME value /api/tokens/agent uses (agent-did-host-skew fix). The
+    // value, not JWTService, so make-meaning stays gateway-agnostic.
+    ...config.site?.domain ? { site: { domain: config.site.domain } } : {},
+    actors: meta?.actors,
+    workers: meta?.workers
+  };
+}
 function resolveActorInference(config, actor) {
   const specific = config.actors?.[actor];
   if (specific) return specific;
@@ -9746,6 +9784,21 @@ function resolveWorkerInference(config, workerType) {
 // src/service.ts
 var import_rxjs7 = __toESM(require_cjs());
 var import_operators6 = __toESM(require_operators());
+function representationSource(resource) {
+  const primary = getPrimaryRepresentation(resource);
+  if (!primary?.storageUri) return null;
+  return {
+    storageUri: primary.storageUri,
+    mediaType: primary.mediaType
+  };
+}
+async function resolveRepresentation(deps, resourceId10) {
+  const view = await deps.views.get(resourceId10);
+  if (!view?.resource) throw new RepresentationMissing(String(resourceId10), "resource");
+  const source = representationSource(view.resource);
+  if (!source) throw new RepresentationMissing(String(resourceId10), "representation");
+  return { stream: deps.content.retrieveStream(source.storageUri), mediaType: source.mediaType };
+}
 
 // src/weave-progress.ts
 var WeaveProgressTimeout = class extends Error {
@@ -9883,6 +9936,19 @@ function createSmeltProgress(eventBus) {
 }
 
 // src/knowledge-base.ts
+function workingTreeContentReads(views, content) {
+  return {
+    getBinary: async (resourceId10) => {
+      const { stream, mediaType } = await resolveRepresentation({ views, content }, resourceId10);
+      const chunks = [];
+      for await (const chunk of stream) chunks.push(chunk);
+      const buf = Buffer.concat(chunks);
+      const data = new ArrayBuffer(buf.byteLength);
+      new Uint8Array(data).set(buf);
+      return { data, contentType: mediaType };
+    }
+  };
+}
 async function createKnowledgeBase(eventStore, project, graphDb, eventBus, logger, options) {
   const views = new FilesystemViewStorage(project, logger.child({ component: "view-storage" }));
   const content = new WorkingTreeStore(
@@ -9915,27 +9981,6 @@ var PROJECTION_LAG_BACKOFF_MS = [25, 50, 100, 200];
 var PROJECTION_BARRIER_TIMEOUT_MS = 500;
 var GRAPH_BARRIER_BUDGET_MS = PROJECTION_BARRIER_TIMEOUT_MS + PROJECTION_LAG_BACKOFF_MS.reduce((a, b) => a + b, 0);
 var GraphContext = class {
-  /**
-   * Get all resources referencing this resource (backlinks)
-   * Requires graph traversal - must use graph database
-   */
-  static async getBacklinks(resourceId10, kb) {
-    return kb.graph.getResourceReferencedBy(resourceId10);
-  }
-  /**
-   * Find shortest path between two resources
-   * Requires graph traversal - must use graph database
-   */
-  static async findPath(fromResourceId, toResourceId, kb, maxDepth) {
-    return kb.graph.findPath(fromResourceId, toResourceId, maxDepth);
-  }
-  /**
-   * Get resource connections (graph edges)
-   * Requires graph traversal - must use graph database
-   */
-  static async getResourceConnections(resourceId10, kb) {
-    return kb.graph.getResourceConnections(resourceId10);
-  }
   /**
    * Build the unified knowledge graph for a resource's neighborhood:
    * resources AND annotations as typed nodes, typed/directional edges.
@@ -10168,10 +10213,10 @@ var ResourceContext = class _ResourceContext {
     return Promise.all(
       resources.map(async (doc) => {
         try {
-          if (doc.storageUri) {
-            const contentBuffer = await kb.content.retrieve(doc.storageUri);
-            const primaryRep = getPrimaryRepresentation(doc);
-            const contentPreview = decodeRepresentation(contentBuffer, primaryRep?.mediaType ?? "text/plain").slice(0, 200);
+          const source = representationSource(doc);
+          if (source) {
+            const contentBuffer = await kb.content.retrieve(source.storageUri);
+            const contentPreview = decodeRepresentation(contentBuffer, source.mediaType).slice(0, 200);
             return { ...doc, content: contentPreview };
           }
           return { ...doc, content: "" };
@@ -10183,13 +10228,17 @@ var ResourceContext = class _ResourceContext {
   }
   /**
    * Get full content for a resource
-   * Retrieves and decodes the primary representation
+   * Retrieves and decodes the primary representation. ResourceId-keyed
+   * (EXTRACT-LIBRARIAN P3, D-CONTENT b): the descriptor's `storageUri` is the
+   * has-content signal; the fetch itself goes by id, so the standalone
+   * Librarian serves it over the transport.
    */
   static async getResourceContent(resource, kb) {
-    if (resource.storageUri) {
-      const contentBuffer = await kb.content.retrieve(resource.storageUri);
-      const primaryRep = getPrimaryRepresentation(resource);
-      return decodeRepresentation(contentBuffer, primaryRep?.mediaType ?? "text/plain");
+    const id = getResourceId(resource);
+    const source = representationSource(resource);
+    if (source && id) {
+      const { data, contentType } = await kb.content.getBinary(resourceId(id));
+      return decodeRepresentation(Buffer.from(data), contentType);
     }
     return void 0;
   }
@@ -10256,12 +10305,12 @@ var AnnotationContext = class {
     }
     let sourceContext;
     if (includeSourceContext) {
-      if (!sourceDoc.storageUri) {
+      if (!getStorageUri(sourceDoc)) {
         throw new Error("Source content not found: no storageUri");
       }
       const primaryRep = getPrimaryRepresentation(sourceDoc);
-      const sourceContent = await kb.content.retrieve(sourceDoc.storageUri);
-      const contentStr = decodeRepresentation(sourceContent, primaryRep?.mediaType ?? "text/plain");
+      const { data: sourceContent } = await kb.content.getBinary(resourceId10);
+      const contentStr = decodeRepresentation(Buffer.from(sourceContent), primaryRep?.mediaType ?? "text/plain");
       const targetSelectorRaw = getTargetSelector(annotation.target);
       const targetSelector = Array.isArray(targetSelectorRaw) ? targetSelectorRaw[0] : targetSelectorRaw;
       logger?.debug("Target selector", { type: targetSelector?.type });
@@ -10297,10 +10346,10 @@ var AnnotationContext = class {
     }
     let targetContext;
     if (includeTargetContext && targetDoc) {
-      if (targetDoc.storageUri) {
+      if (getStorageUri(targetDoc) && bodySource) {
         const targetRep = getPrimaryRepresentation(targetDoc);
-        const targetContent = await kb.content.retrieve(targetDoc.storageUri);
-        const contentStr = decodeRepresentation(targetContent, targetRep?.mediaType ?? "text/plain");
+        const { data: targetContent } = await kb.content.getBinary(resourceId(bodySource));
+        const contentStr = decodeRepresentation(Buffer.from(targetContent), targetRep?.mediaType ?? "text/plain");
         targetContext = {
           content: contentStr.slice(0, contextWindow * 2),
           summary: inferenceClient ? await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), inferenceClient) : void 0
@@ -10582,15 +10631,18 @@ Summary:`;
     };
   }
   /**
-   * Get resource content as string
+   * Get resource content as string. ResourceId-keyed (D-CONTENT b): the
+   * primary representation's `storageUri` stays the has-content signal, the
+   * fetch goes by id.
    */
   static async getResourceContent(resource, content) {
-    if (!resource.storageUri) {
+    const id = getResourceId(resource);
+    if (!getStorageUri(resource) || !id) {
       throw new Error("Resource content not found: no storageUri");
     }
     const primaryRep = getPrimaryRepresentation(resource);
-    const buf = await content.retrieve(resource.storageUri);
-    return decodeRepresentation(buf, primaryRep?.mediaType ?? "text/plain");
+    const { data } = await content.getBinary(resourceId(id));
+    return decodeRepresentation(Buffer.from(data), primaryRep?.mediaType ?? "text/plain");
   }
   /**
    * Extract annotation context from resource content
@@ -10745,15 +10797,15 @@ var LLMContext = class {
 
 // src/gatherer.ts
 var Gatherer = class {
-  constructor(kb, eventBus, inferenceClient, settleTimeoutMs, logger, embeddingProvider) {
-    this.kb = kb;
+  constructor(stores, eventBus, inferenceClient, settleTimeoutMs, logger, embeddingProvider) {
+    this.stores = stores;
     this.eventBus = eventBus;
     this.inferenceClient = inferenceClient;
     this.settleTimeoutMs = settleTimeoutMs;
     this.embeddingProvider = embeddingProvider;
     this.logger = logger;
   }
-  kb;
+  stores;
   eventBus;
   inferenceClient;
   settleTimeoutMs;
@@ -10800,7 +10852,7 @@ var Gatherer = class {
       const response = await AnnotationContext.buildLLMContext(
         annotationId(event.annotationId),
         resourceId(event.resourceId),
-        this.kb,
+        this.stores,
         this.embeddingProvider,
         event.options ?? {},
         this.inferenceClient,
@@ -10831,7 +10883,7 @@ var Gatherer = class {
       const result = await LLMContext.getResourceContext(
         resourceId(event.resourceId),
         event.options,
-        this.kb,
+        this.stores,
         this.inferenceClient,
         this.settleTimeoutMs,
         this.logger
@@ -10857,7 +10909,7 @@ var Gatherer = class {
     return AnnotationContext.generateAnnotationSummary(
       annotationId5,
       resourceId10,
-      this.kb,
+      this.stores,
       this.inferenceClient
     );
   }
@@ -10874,14 +10926,14 @@ var Gatherer = class {
 var import_rxjs2 = __toESM(require_cjs());
 var import_operators2 = __toESM(require_operators());
 var Matcher = class {
-  constructor(kb, eventBus, logger, inferenceClient, embeddingProvider) {
-    this.kb = kb;
+  constructor(stores, eventBus, logger, inferenceClient, embeddingProvider) {
+    this.stores = stores;
     this.eventBus = eventBus;
     this.inferenceClient = inferenceClient;
     this.embeddingProvider = embeddingProvider;
     this.logger = logger;
   }
-  kb;
+  stores;
   eventBus;
   inferenceClient;
   embeddingProvider;
@@ -10961,13 +11013,13 @@ var Matcher = class {
     const views = deriveViews(context.graph, mainResourceId);
     const connections = views.connections;
     const [nameMatches, entityTypeMatches, semanticMatches] = await Promise.all([
-      this.kb.graph.listResources({ search: searchTerm, limit: 20 }).then((r) => r.resources),
-      annotationEntityTypes.length > 0 ? this.kb.graph.listResources({ entityTypes: annotationEntityTypes, limit: 50 }).then((r) => r.resources) : Promise.resolve([]),
+      this.stores.graph.listResources({ search: searchTerm, limit: 20 }).then((r) => r.resources),
+      annotationEntityTypes.length > 0 ? this.stores.graph.listResources({ entityTypes: annotationEntityTypes, limit: 50 }).then((r) => r.resources) : Promise.resolve([]),
       // 4. Semantic match — vector similarity search (if vectors configured)
       this.searchVectors(searchTerm)
     ]);
     const neighborResolved = await Promise.all(
-      connections.map((conn) => resourceWithViewGrace(this.kb, resourceId(conn.resourceId)))
+      connections.map((conn) => resourceWithViewGrace(this.stores, resourceId(conn.resourceId)))
     );
     const laggedNeighbors = neighborResolved.filter((r) => r.laggedBehindView).length;
     if (laggedNeighbors > 0) {
@@ -10994,7 +11046,7 @@ var Matcher = class {
     let laggedSemantic = 0;
     for (const sm of semanticMatches) {
       semanticScores.set(sm.resourceId, sm.score);
-      const { resource, laggedBehindView } = await resourceWithViewGrace(this.kb, resourceId(sm.resourceId));
+      const { resource, laggedBehindView } = await resourceWithViewGrace(this.stores, resourceId(sm.resourceId));
       if (laggedBehindView) laggedSemantic++;
       if (resource) addCandidate(resource, "semantic");
     }
@@ -11190,7 +11242,7 @@ For each candidate, output a line with the number and score, like:
     if (!searchTerm.trim()) return [];
     try {
       const embedding = await this.embeddingProvider.embed(searchTerm);
-      const results = await this.kb.vectors.searchResources(embedding, {
+      const results = await this.stores.vectors.searchResources(embedding, {
         limit: 40,
         scoreThreshold: 0.4
       });
@@ -11215,9 +11267,9 @@ For each candidate, output a line with the number and score, like:
 // src/stower.ts
 var import_rxjs3 = __toESM(require_cjs());
 var import_operators3 = __toESM(require_operators());
-async function readEntityTypesProjection(project) {
+async function readEntityTypesProjection(state) {
   const entityTypesPath = path3.join(
-    project.stateDir,
+    state.stateDir,
     "projections",
     "__system__",
     "entitytypes.json"
@@ -11259,13 +11311,13 @@ function entityTypesNotRegisteredMessage(unknown) {
 
 // src/stower.ts
 var Stower = class {
-  constructor(kb, eventBus, project, logger) {
-    this.kb = kb;
+  constructor(stores, eventBus, project, logger) {
+    this.stores = stores;
     this.eventBus = eventBus;
     this.project = project;
     this.logger = logger;
   }
-  kb;
+  stores;
   eventBus;
   project;
   subscription = null;
@@ -11279,9 +11331,11 @@ var Stower = class {
     );
     this.subscription = (0, import_rxjs3.merge)(
       pipe("yield:create", (e) => this.handleYieldCreate(e)),
+      pipe("yield:clone-persist", (e) => this.handleYieldClonePersist(e)),
       pipe("yield:update", (e) => this.handleYieldUpdate(e)),
       pipe("yield:mv", (e) => this.handleYieldMv(e)),
       pipe("mark:create", (e) => this.handleMarkCreate(e)),
+      pipe("mark:commit", (e) => this.handleMarkCommit(e)),
       pipe("mark:delete", (e) => this.handleMarkDelete(e)),
       pipe("mark:update-body", (e) => this.handleMarkUpdateBody(e)),
       pipe("frame:add-entity-type", (e) => this.handleAddEntityType(e)),
@@ -11306,14 +11360,14 @@ var Stower = class {
     const uid = userId(event._userId);
     try {
       const rId = resourceId(generateUuid());
-      const stored = await this.kb.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
+      const stored = await this.stores.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
       const checksum = stored.checksum;
       const byteSize = event.byteSize;
       const generatedFrom = event.generatedFrom?.resourceId && event.generatedFrom?.annotationId ? {
         resourceId: resourceId(event.generatedFrom.resourceId),
         annotationId: annotationId(event.generatedFrom.annotationId)
       } : void 0;
-      await this.kb.eventStore.appendEvent({
+      await this.stores.eventStore.appendEvent({
         type: "yield:created",
         resourceId: rId,
         userId: uid,
@@ -11366,13 +11420,66 @@ var Stower = class {
       });
     }
   }
+  /**
+   * Persist a clone (the CloneTokenManager's second half).
+   *
+   * A clone is its own domain fact, not a creation with an extra field: it
+   * NAMES the resource it came from, and `ResourceClonedPayload` requires
+   * that name. So it gets its own command and appends its own event, rather
+   * than an optional parent turning `yield:created` into something else at
+   * runtime.
+   *
+   * The token was already validated and the source's entity types already
+   * read by the CloneTokenManager — the one party that can do either. What
+   * happens here is what only the Stower may do: register the bytes and
+   * append the event (single-writer, GATEWAY.md D4b).
+   *
+   * Generated resources do NOT come through here. Their provenance is
+   * `generatedFrom` on `yield:created`, which is a different relation: a
+   * generated resource is derived from a source, a clone IS a copy of one.
+   */
+  async handleYieldClonePersist(event) {
+    if (!event._userId) {
+      throw new Error("yield:clone-persist missing _userId (gateway injection)");
+    }
+    try {
+      const rId = resourceId(generateUuid());
+      const stored = await this.stores.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
+      await this.stores.eventStore.appendEvent({
+        type: "yield:cloned",
+        resourceId: rId,
+        userId: userId(event._userId),
+        version: 1,
+        payload: {
+          name: event.name,
+          format: event.format,
+          contentChecksum: stored.checksum,
+          contentByteSize: event.byteSize,
+          storageUri: event.storageUri,
+          parentResourceId: event.parentResourceId,
+          entityTypes: event.entityTypes || [],
+          language: event.language || void 0
+        }
+      });
+      this.eventBus.get("yield:clone-persist-ok").next({
+        correlationId: event.correlationId,
+        response: { resourceId: rId }
+      });
+    } catch (error) {
+      this.logger.error("Failed to persist clone", { error: errField(error) });
+      this.eventBus.get("yield:clone-persist-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   async handleYieldUpdate(event) {
     if (!event._userId) {
       throw new Error("yield:update missing _userId (gateway injection)");
     }
     try {
-      await this.kb.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
-      await this.kb.eventStore.appendEvent({
+      await this.stores.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
+      await this.stores.eventStore.appendEvent({
         type: "yield:updated",
         resourceId: resourceId(event.resourceId),
         userId: userId(event._userId),
@@ -11397,7 +11504,7 @@ var Stower = class {
   async handleYieldMv(event) {
     let rId;
     try {
-      const resolved = await resolveStorageUri(this.kb.projectionsDir, event.fromUri);
+      const resolved = await resolveStorageUri(this.project.projectionsDir, event.fromUri);
       rId = resolved;
     } catch (error) {
       this.logger.error("Failed to resolve resource for move", { fromUri: event.fromUri, error });
@@ -11411,8 +11518,8 @@ var Stower = class {
       throw new Error("yield:mv missing _userId (gateway injection)");
     }
     try {
-      await this.kb.content.move(event.fromUri, event.toUri, { noGit: event.noGit });
-      await this.kb.eventStore.appendEvent({
+      await this.stores.content.move(event.fromUri, event.toUri, { noGit: event.noGit });
+      await this.stores.eventStore.appendEvent({
         type: "yield:moved",
         resourceId: rId,
         userId: userId(event._userId),
@@ -11436,7 +11543,7 @@ var Stower = class {
     }
     try {
       this.logger.debug("Stowing annotation", { annotationId: event.annotation.id });
-      await this.kb.eventStore.appendEvent(
+      await this.stores.eventStore.appendEvent(
         {
           type: "mark:added",
           resourceId: resourceId(event.resourceId),
@@ -11454,6 +11561,61 @@ var Stower = class {
       });
     }
   }
+  /**
+   * Persist a detection unit's annotations as ONE acknowledged batch, then
+   * answer (JOB-RESTART-SAFETY P6).
+   *
+   * The difference from `mark:create` is the reply, and it is the whole point.
+   * `mark:create` is fire-and-forget: the worker's emit resolves when the bus
+   * accepts it, which says nothing about the event log, so a down Stower loses
+   * a unit silently and a flapping one hangs the worker forever. This answers
+   * only after every append has returned, so the worker can gate unit
+   * completion — and its checkpoint — on durability.
+   *
+   * Appends are sequential, not concurrent: the event log is the system of
+   * record and a batch that half-lands under concurrency is harder to reason
+   * about than one that stops at the first failure. A partial batch is
+   * reported as a failure and the worker retries the WHOLE unit, which is safe
+   * because ids are deterministic (P3) and the annotation fold is idempotent
+   * by id — re-appending what already landed changes nothing.
+   */
+  async handleMarkCommit(event) {
+    if (!event._userId) {
+      throw new Error("mark:commit missing _userId (gateway injection)");
+    }
+    const annotations = event.annotations ?? [];
+    try {
+      let persisted = 0;
+      for (const annotation of annotations) {
+        await this.stores.eventStore.appendEvent({
+          type: "mark:added",
+          resourceId: resourceId(event.resourceId),
+          userId: userId(event._userId),
+          version: 1,
+          payload: { annotation }
+        });
+        persisted++;
+      }
+      this.logger.debug("Committed annotation batch", {
+        correlationId: event.correlationId,
+        resourceId: event.resourceId,
+        persisted
+      });
+      this.eventBus.get("mark:commit-ok").next({
+        correlationId: event.correlationId,
+        response: { persisted, annotationIds: annotations.map((a) => String(a.id)) }
+      });
+    } catch (error) {
+      this.logger.error("Failed to commit annotation batch", {
+        correlationId: event.correlationId,
+        error: errField(error)
+      });
+      this.eventBus.get("mark:commit-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   async handleMarkDelete(event) {
     if (!event._userId) {
       throw new Error("mark:delete missing _userId (gateway injection)");
@@ -11462,7 +11624,7 @@ var Stower = class {
       throw new Error("mark:delete missing resourceId");
     }
     try {
-      await this.kb.eventStore.appendEvent({
+      await this.stores.eventStore.appendEvent({
         type: "mark:removed",
         resourceId: resourceId(event.resourceId),
         userId: userId(event._userId),
@@ -11483,7 +11645,7 @@ var Stower = class {
       throw new Error("mark:update-body missing _userId (gateway injection)");
     }
     try {
-      await this.kb.eventStore.appendEvent(
+      await this.stores.eventStore.appendEvent(
         {
           type: "mark:body-updated",
           resourceId: resourceId(event.resourceId),
@@ -11509,9 +11671,9 @@ var Stower = class {
     }
     try {
       if (event.storageUri) {
-        await this.kb.content.remove(event.storageUri, { keepFile: event.keepFile, noGit: event.noGit });
+        await this.stores.content.remove(event.storageUri, { keepFile: event.keepFile, noGit: event.noGit });
       }
-      await this.kb.eventStore.appendEvent({
+      await this.stores.eventStore.appendEvent({
         type: "mark:archived",
         resourceId: resourceId(event.resourceId),
         userId: userId(event._userId),
@@ -11533,14 +11695,14 @@ var Stower = class {
     }
     try {
       if (event.storageUri) {
-        const absPath = this.kb.content.resolveUri(event.storageUri);
+        const absPath = this.stores.content.resolveUri(event.storageUri);
         try {
           await promises.access(absPath);
         } catch {
           throw new Error(`Cannot unarchive: file not found at ${event.storageUri}`);
         }
       }
-      await this.kb.eventStore.appendEvent({
+      await this.stores.eventStore.appendEvent({
         type: "mark:unarchived",
         resourceId: resourceId(event.resourceId),
         userId: userId(event._userId),
@@ -11561,7 +11723,7 @@ var Stower = class {
       throw new Error("frame:add-entity-type missing _userId (gateway injection)");
     }
     try {
-      await this.kb.eventStore.appendEvent({
+      await this.stores.eventStore.appendEvent({
         type: "frame:entity-type-added",
         userId: userId(event._userId),
         version: 1,
@@ -11581,7 +11743,7 @@ var Stower = class {
       throw new Error("frame:add-tag-schema missing _userId (gateway injection)");
     }
     try {
-      await this.kb.eventStore.appendEvent({
+      await this.stores.eventStore.appendEvent({
         type: "frame:tag-schema-added",
         userId: userId(event._userId),
         version: 1,
@@ -11612,7 +11774,7 @@ var Stower = class {
         }
       }
       for (const entityType2 of added) {
-        await this.kb.eventStore.appendEvent({
+        await this.stores.eventStore.appendEvent({
           type: "mark:entity-tag-added",
           resourceId: resourceId(event.resourceId),
           userId: uid,
@@ -11621,7 +11783,7 @@ var Stower = class {
         });
       }
       for (const entityType2 of removed) {
-        await this.kb.eventStore.appendEvent({
+        await this.stores.eventStore.appendEvent({
           type: "mark:entity-tag-removed",
           resourceId: resourceId(event.resourceId),
           userId: uid,
@@ -11642,7 +11804,7 @@ var Stower = class {
     if (!event._userId) {
       throw new Error("job:start missing _userId (gateway injection)");
     }
-    await this.kb.eventStore.appendEvent({
+    await this.stores.eventStore.appendEvent({
       type: "job:started",
       resourceId: resourceId(event.resourceId),
       userId: userId(event._userId),
@@ -11658,7 +11820,7 @@ var Stower = class {
     if (!event._userId) {
       throw new Error("job:complete missing _userId (gateway injection)");
     }
-    await this.kb.eventStore.appendEvent({
+    await this.stores.eventStore.appendEvent({
       type: "job:completed",
       resourceId: resourceId(event.resourceId),
       userId: userId(event._userId),
@@ -11675,7 +11837,7 @@ var Stower = class {
     if (!event._userId) {
       throw new Error("job:fail missing _userId (gateway injection)");
     }
-    await this.kb.eventStore.appendEvent({
+    await this.stores.eventStore.appendEvent({
       type: "job:failed",
       resourceId: resourceId(event.resourceId),
       userId: userId(event._userId),
@@ -11713,9 +11875,9 @@ async function readAnchoredText(kb, resourceId10) {
     throw error;
   }
 }
-async function readTagSchemasProjection(project) {
+async function readTagSchemasProjection(state) {
   const tagSchemasPath = path3.join(
-    project.stateDir,
+    state.stateDir,
     "projections",
     "__system__",
     "tagschemas.json"
@@ -11801,8 +11963,7 @@ function deriveAgentRoster(config) {
 
 // src/browser.ts
 var Browser = class {
-  constructor(views, kb, eventBus, project, config, limitsDiscovery, embeddingProvider, logger) {
-    this.views = views;
+  constructor(kb, eventBus, project, config, limitsDiscovery, embeddingProvider, logger) {
     this.kb = kb;
     this.eventBus = eventBus;
     this.project = project;
@@ -11811,7 +11972,6 @@ var Browser = class {
     this.embeddingProvider = embeddingProvider;
     this.logger = logger;
   }
-  views;
   kb;
   eventBus;
   project;
@@ -11843,6 +12003,7 @@ var Browser = class {
     this.subscriptions.push(
       pipe("browse:resource-requested", (e) => this.handleBrowseResource(e)).subscribe({ error: errorHandler }),
       pipe("browse:anchored-text-requested", (e) => this.handleAnchoredText(e)).subscribe({ error: errorHandler }),
+      pipe("browse:anchored-text-by-checksum-requested", (e) => this.handleAnchoredTextByChecksum(e)).subscribe({ error: errorHandler }),
       pipe("browse:resources-requested", (e) => this.handleBrowseResources(e)).subscribe({ error: errorHandler }),
       pipe("browse:annotations-requested", (e) => this.handleBrowseAnnotations(e)).subscribe({ error: errorHandler }),
       pipe("browse:annotation-requested", (e) => this.handleBrowseAnnotation(e)).subscribe({ error: errorHandler }),
@@ -11886,6 +12047,30 @@ var Browser = class {
       });
     }
   }
+  /**
+   * Serve the checksum-addressed consult (ANCHORED-TEXT-TO-SMELTER P2, D2) —
+   * the detection workers' read-through cache. The caller computed the key
+   * from bytes it already holds, so unlike the resource-addressed read there
+   * is nothing to resolve and no settle barrier: with no resourceId there is
+   * no content generation to wait on, and a miss means "extract it yourself".
+   * A hit — success or decline — is served whole, so the caller runs neither
+   * parser nor engine. Read-only over the wire: the Smelter is the sole
+   * writer and never answers here.
+   */
+  async handleAnchoredTextByChecksum(event) {
+    try {
+      this.eventBus.get("browse:anchored-text-by-checksum-result").next({
+        correlationId: event.correlationId,
+        response: await this.kb.anchoredText.read(event.checksum)
+      });
+    } catch (error) {
+      this.logger.error("Browse anchored text by checksum failed", { checksum: event.checksum, error: errField(error) });
+      this.eventBus.get("browse:anchored-text-by-checksum-failed").next({
+        correlationId: event.correlationId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   async handleBrowseResource(event) {
     try {
       const response = await assembleResourceGraph(this.kb, resourceId(event.resourceId));
@@ -12183,10 +12368,13 @@ var Browser = class {
       return;
     }
     const visible = dirents.filter((d) => d.name !== ".semiont" && !d.name.startsWith("."));
-    const allViews = await this.views.getAll();
+    const allViews = await this.kb.views.getAll();
     const prefix = `file://${resolved}`;
     const viewsByUri = new Map(
-      allViews.filter((v) => v.resource.storageUri?.startsWith(prefix + "/") || v.resource.storageUri?.startsWith(prefix + path3.sep)).map((v) => [v.resource.storageUri, v])
+      allViews.filter((v) => {
+        const uri = getStorageUri(v.resource);
+        return uri?.startsWith(prefix + "/") || uri?.startsWith(prefix + path3.sep);
+      }).map((v) => [getStorageUri(v.resource), v])
     );
     const entries = [];
     for (const dirent of visible) {
@@ -12275,13 +12463,13 @@ function createLimitsDiscovery(config, logger, options) {
     }
   }
   const consult = async (pair, client) => {
-    let timer2;
+    let timer;
     try {
       const discovery = client.limits();
       const raced = await Promise.race([
         discovery,
         new Promise((resolve2) => {
-          timer2 = setTimeout(() => resolve2(void 0), budgetMs);
+          timer = setTimeout(() => resolve2(void 0), budgetMs);
         })
       ]);
       if (raced === void 0) {
@@ -12298,7 +12486,7 @@ function createLimitsDiscovery(config, logger, options) {
       });
       return void 0;
     } finally {
-      clearTimeout(timer2);
+      clearTimeout(timer);
     }
   };
   return {
@@ -12334,6 +12522,15 @@ async function readAnnotationFromView(kb, resourceId10, annotationId5) {
   const allAnnotations = await AnnotationContext.getAllAnnotations(resourceId10, kb);
   return allAnnotations.find((a) => a.id === annotationId5) ?? null;
 }
+function wireEnrichment(eventStore, kb) {
+  eventStore.setEnrichEvent(async (event, resourceId10) => {
+    const annId = eventAnnotationId(event);
+    if (annId === null) return event;
+    const annotation = await readAnnotationFromView(kb, resourceId10, annId);
+    if (annotation === null) return event;
+    return { ...event, annotation };
+  });
+}
 
 // src/clone-token-manager.ts
 var import_rxjs6 = __toESM(require_cjs());
@@ -12385,16 +12582,67 @@ var ResourceOperations = class {
     );
     return resourceId(rId);
   }
+  /**
+   * Persist a CLONE via EventBus → Stower.
+   *
+   * Separate from `createResource` because a clone is a separate fact: it
+   * names its parent, and `yield:cloned` requires that name. Callers reach
+   * this only after the CloneTokenManager has validated the token — it is the
+   * inner half of the flow, not a public entry point.
+   */
+  static async persistClone(input, userId3, eventBus) {
+    const { resourceId: rId } = await busRequest(
+      asBusRequestPrimitive(eventBus),
+      "yield:clone-persist",
+      {
+        name: input.name,
+        storageUri: input.storageUri,
+        contentChecksum: input.contentChecksum,
+        byteSize: input.byteSize,
+        format: input.format,
+        parentResourceId: input.parentResourceId,
+        entityTypes: input.entityTypes,
+        language: input.language,
+        _userId: userId3
+      },
+      3e4
+    );
+    return resourceId(rId);
+  }
+  /**
+   * Create a resource from a clone token via EventBus → CloneTokenManager.
+   * The bytes are already stored (the gateway's upload path, `noGit` — the
+   * Archivist's register does the one `git add`, D4b); the command carries
+   * storage coordinates only (EXTRACT-ARCHIVIST P3, D4a).
+   */
+  static async createFromCloneToken(input, userId3, eventBus) {
+    const { resourceId: rId } = await busRequest(
+      asBusRequestPrimitive(eventBus),
+      "yield:clone-create",
+      {
+        token: input.token,
+        name: input.name,
+        storageUri: input.storageUri,
+        contentChecksum: input.contentChecksum,
+        byteSize: input.byteSize,
+        format: input.format,
+        archiveOriginal: input.archiveOriginal,
+        _userId: userId3
+      },
+      3e4
+    );
+    return resourceId(rId);
+  }
 };
 
 // src/clone-token-manager.ts
 var CloneTokenManager = class {
-  constructor(kb, eventBus, logger) {
-    this.kb = kb;
+  constructor(stores, eventBus, logger) {
+    this.stores = stores;
     this.eventBus = eventBus;
     this.logger = logger;
   }
-  kb;
+  stores;
   eventBus;
   subscriptions = [];
   logger;
@@ -12419,7 +12667,7 @@ var CloneTokenManager = class {
   }
   async handleGenerateToken(event) {
     try {
-      const resource = await ResourceContext.getResourceMetadata(resourceId(event.resourceId), this.kb);
+      const resource = await ResourceContext.getResourceMetadata(resourceId(event.resourceId), this.stores);
       if (!resource) {
         this.eventBus.get("yield:clone-token-failed").next({
           correlationId: event.correlationId,
@@ -12427,7 +12675,8 @@ var CloneTokenManager = class {
         });
         return;
       }
-      if (!resource.storageUri) {
+      const storageUri = getStorageUri(resource);
+      if (!storageUri) {
         this.eventBus.get("yield:clone-token-failed").next({
           correlationId: event.correlationId,
           message: "Resource content not found"
@@ -12435,7 +12684,7 @@ var CloneTokenManager = class {
         return;
       }
       try {
-        await this.kb.content.retrieve(resource.storageUri);
+        await promises.access(this.stores.content.resolveUri(storageUri));
       } catch {
         this.eventBus.get("yield:clone-token-failed").next({
           correlationId: event.correlationId,
@@ -12482,7 +12731,7 @@ var CloneTokenManager = class {
         });
         return;
       }
-      const sourceResource = await ResourceContext.getResourceMetadata(tokenData.resourceId, this.kb);
+      const sourceResource = await ResourceContext.getResourceMetadata(tokenData.resourceId, this.stores);
       if (!sourceResource) {
         this.eventBus.get("yield:clone-resource-failed").next({
           correlationId: event.correlationId,
@@ -12531,7 +12780,7 @@ var CloneTokenManager = class {
         });
         return;
       }
-      const sourceDoc = await ResourceContext.getResourceMetadata(tokenData.resourceId, this.kb);
+      const sourceDoc = await ResourceContext.getResourceMetadata(tokenData.resourceId, this.stores);
       if (!sourceDoc) {
         this.eventBus.get("yield:clone-create-failed").next({
           correlationId: event.correlationId,
@@ -12539,17 +12788,14 @@ var CloneTokenManager = class {
         });
         return;
       }
-      const base = baseMediaType(getPrimaryRepresentation(sourceDoc)?.mediaType ?? "text/plain");
-      const format = isSupportedMediaType(base) && capabilitiesOf(base)?.authorable ? base : "text/plain";
-      const resolvedUri = deriveStorageUri(event.name, format);
-      const stored = await this.kb.content.store(Buffer.from(event.content), resolvedUri);
-      const newResourceId = await ResourceOperations.createResource(
+      const newResourceId = await ResourceOperations.persistClone(
         {
           name: event.name,
-          storageUri: resolvedUri,
-          contentChecksum: stored.checksum,
-          byteSize: stored.byteSize,
-          format,
+          storageUri: event.storageUri,
+          contentChecksum: event.contentChecksum,
+          byteSize: event.byteSize,
+          format: event.format,
+          parentResourceId: String(tokenData.resourceId),
           entityTypes: getResourceEntityTypes(sourceDoc)
         },
         userId(event._userId),
@@ -12617,42 +12863,115 @@ async function stopKnowledgeSystem(ks) {
   ks.kb.weaveProgress.dispose();
   await ks.kb.graph.disconnect();
 }
-function registerAnnotationAssemblyHandler(eventBus, parentLogger) {
+async function assertAnnotatableTarget(kb, target) {
+  const view = await kb.views.get(resourceId(target));
+  const mediaType = getPrimaryRepresentation(view?.resource)?.mediaType;
+  if (!mediaType || !isAnnotatable(mediaType)) {
+    throw new Error(`"${mediaType ?? "unknown"}" cannot be annotated`);
+  }
+}
+var AnnotationOperations = class {
+  /**
+   * Create a new annotation via EventBus → Stower
+   */
+  static async createAnnotation(request, userId3, creator, eventBus, kb) {
+    await assertAnnotatableTarget(kb, request.target.source);
+    const { annotation } = assembleAnnotation(request, creator);
+    const resId = resourceId(request.target.source);
+    eventBus.get("mark:create").next({
+      annotation,
+      _userId: userId3,
+      resourceId: resId
+    });
+    return { annotation };
+  }
+  /**
+   * Update annotation body via EventBus → Stower
+   */
+  static async updateAnnotationBody(id, request, userId3, eventBus, kb) {
+    const resId = resourceId(request.resourceId);
+    const annotation = await AnnotationContext.getAnnotation(
+      annotationId(id),
+      resId,
+      kb
+    );
+    if (!annotation) {
+      throw new Error("Annotation not found");
+    }
+    eventBus.get("mark:update-body").next({
+      annotationId: annotationId(id),
+      _userId: userId3,
+      resourceId: resId,
+      operations: request.operations
+    });
+    const updatedBody = applyBodyOperations(annotation.body, request.operations);
+    return {
+      annotation: {
+        ...annotation,
+        body: updatedBody
+      }
+    };
+  }
+  /**
+   * Delete an annotation via EventBus → Stower
+   */
+  static async deleteAnnotation(id, resourceIdStr, userId3, eventBus, kb, logger) {
+    const resId = resourceId(resourceIdStr);
+    const projection = await AnnotationContext.getResourceAnnotations(resId, kb);
+    const annotation = projection.annotations.find((a) => a.id === id);
+    if (!annotation) {
+      throw new Error("Annotation not found in resource");
+    }
+    logger?.debug("Removing annotation via EventBus", { annotationId: id });
+    eventBus.get("mark:delete").next({
+      annotationId: annotationId(id),
+      _userId: userId3,
+      resourceId: resId
+    });
+    logger?.debug("Annotation delete event emitted");
+  }
+};
+
+// src/handlers/annotation-assembly.ts
+function registerAnnotationAssemblyHandler(eventBus, kb, parentLogger) {
   const logger = parentLogger.child({ component: "annotation-assembly" });
   const inflight = /* @__PURE__ */ new Map();
   eventBus.get("mark:create-request").subscribe((command) => {
-    const { correlationId, resourceId: resId, request, _userId } = command;
-    const cid = correlationId;
-    try {
-      if (!_userId || typeof _userId !== "string") {
-        throw new Error("_userId is required (injected by bus gateway)");
-      }
-      if (!cid) {
-        throw new Error("correlationId is required on mark:create-request");
+    void (async () => {
+      const { correlationId, resourceId: resId, request, _userId } = command;
+      const cid = correlationId;
+      try {
+        if (!_userId || typeof _userId !== "string") {
+          throw new Error("_userId is required (injected by bus gateway)");
+        }
+        if (!cid) {
+          throw new Error("correlationId is required on mark:create-request");
+        }
+        await assertAnnotatableTarget(kb, resId);
+        const agent = didToAgent(_userId);
+        const { annotation } = assembleAnnotation(request, agent);
+        inflight.set(cid, { annotationId: annotation.id });
+        eventBus.get("mark:create").next({
+          correlationId: cid,
+          annotation,
+          _userId,
+          resourceId: resourceId(resId)
+        });
+        logger.info("Annotation assembled, awaiting persistence", {
+          annotationId: annotation.id,
+          correlationId: cid
+        });
+      } catch (error) {
+        logger.warn("mark:create-request failed during assembly", {
+          correlationId: cid,
+          error: error.message
+        });
+        eventBus.get("mark:create-failed").next({
+          correlationId: cid,
+          message: error.message
+        });
       }
-      const agent = didToAgent(_userId);
-      const { annotation } = assembleAnnotation(request, agent);
-      inflight.set(cid, { annotationId: annotation.id });
-      eventBus.get("mark:create").next({
-        correlationId: cid,
-        annotation,
-        _userId,
-        resourceId: resourceId(resId)
-      });
-      logger.info("Annotation assembled, awaiting persistence", {
-        annotationId: annotation.id,
-        correlationId: cid
-      });
-    } catch (error) {
-      logger.warn("mark:create-request failed during assembly", {
-        correlationId: cid,
-        error: error.message
-      });
-      eventBus.get("mark:create-failed").next({
-        correlationId: cid,
-        message: error.message
-      });
-    }
+    })();
   });
   eventBus.get("mark:added").subscribe((event) => {
     const cid = event.metadata?.correlationId;
@@ -12672,7 +12991,7 @@ function registerAnnotationAssemblyHandler(eventBus, parentLogger) {
     inflight.delete(cid);
   });
 }
-function registerAnnotationLookupHandlers(eventBus, kb, gatherer, parentLogger) {
+function registerAnnotationContextHandler(eventBus, kb, parentLogger) {
   const logger = parentLogger.child({ component: "annotation-lookups" });
   eventBus.get("browse:annotation-context-requested").subscribe(async (command) => {
     const { correlationId } = command;
@@ -12700,6 +13019,9 @@ function registerAnnotationLookupHandlers(eventBus, kb, gatherer, parentLogger)
       });
     }
   });
+}
+function registerGatherSummaryHandler(eventBus, gatherer, parentLogger) {
+  const logger = parentLogger.child({ component: "annotation-lookups" });
   eventBus.get("gather:summary-requested").subscribe(async (command) => {
     const { correlationId } = command;
     const annId = command.annotationId;
@@ -12785,7 +13107,7 @@ function parseDidUser(did) {
   const email = decodeURIComponent(parts.slice(usersIdx + 1).join(":"));
   return { userId: did, email, domain };
 }
-function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
+function registerJobCommandHandlers(eventBus, jobQueue, state, parentLogger) {
   const logger = parentLogger.child({ component: "job-commands" });
   eventBus.get("job:create").subscribe(async (command) => {
     const { correlationId, jobType, resourceId: resId, params, _userId } = command;
@@ -12850,7 +13172,7 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
       };
       const jobParams = job.params;
       if ((jobType === "reference-annotation" || jobType === "generation") && Array.isArray(jobParams.entityTypes) && jobParams.entityTypes.length > 0) {
-        const registered = await readEntityTypesProjection(project);
+        const registered = await readEntityTypesProjection(state);
         const result = validateEntityTypes(registered, jobParams.entityTypes);
         if (!result.ok) {
           throw new Error(entityTypesNotRegisteredMessage(result.unknown));
@@ -12860,7 +13182,7 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
         jobParams.entityTypes = jobParams.entityTypes.map((et) => entityType(et));
       }
       if (jobType === "tag-annotation") {
-        const schemas = await readTagSchemasProjection(project);
+        const schemas = await readTagSchemasProjection(state);
         const result = resolveTagSchema(schemas, jobParams.schemaId);
         if (result.error !== void 0) {
           throw new Error(result.error);
@@ -12928,7 +13250,7 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
   });
   eventBus.get("job:fail").subscribe(async (event) => {
     try {
-      const outcome = await jobQueue.failJob(jobId(event.jobId), event.error);
+      const outcome = await jobQueue.failJob(jobId(event.jobId), event.error, event.completedUnits, event.failureClass);
       if (outcome === "retried") {
         logger.info("Job re-queued for retry", { jobId: event.jobId });
       } else if (outcome === null) {
@@ -12954,16 +13276,45 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
       });
     }
   });
+  eventBus.get("job:checkpoint").subscribe(async (event) => {
+    try {
+      await jobQueue.checkpointUnits(jobId(event.jobId), event.completedUnits);
+    } catch (error) {
+      logger.error("Failed to checkpoint job units", {
+        jobId: event.jobId,
+        error: error.message
+      });
+    }
+  });
   eventBus.get("job:cancel-requested").subscribe(async (event) => {
     try {
-      const cancelled = await jobQueue.cancelPendingJobs(event.jobType);
-      logger.info("Cancel requested", { jobType: event.jobType, cancelled });
+      let cancelled;
+      if (event.jobId) {
+        const target = await jobQueue.getJob(jobId(event.jobId));
+        if (!target) {
+          cancelled = 0;
+        } else if (target.status === "pending") {
+          cancelled = await jobQueue.cancelJob(jobId(event.jobId)) ? 1 : 0;
+        } else if (target.status === "running") {
+          logger.info("Cancel of running job delegated to its worker", { jobId: event.jobId });
+          cancelled = 1;
+        } else {
+          cancelled = 0;
+        }
+        logger.info("Cancel requested", { jobId: event.jobId, cancelled });
+      } else if (event.jobType) {
+        cancelled = await jobQueue.cancelPendingJobs(event.jobType);
+        logger.info("Cancel requested", { jobType: event.jobType, cancelled });
+      } else {
+        cancelled = 0;
+      }
       eventBus.get("job:cancel-ok").next({
         correlationId: event.correlationId,
         response: { cancelled }
       });
     } catch (error) {
-      logger.error("Failed to cancel pending jobs", {
+      logger.error("Failed to cancel jobs", {
+        jobId: event.jobId,
         jobType: event.jobType,
         error: error.message
       });
@@ -12973,20 +13324,41 @@ function registerJobCommandHandlers(eventBus, jobQueue, project, parentLogger) {
       });
     }
   });
+  eventBus.get("job:cancel").subscribe(async (event) => {
+    try {
+      await jobQueue.cancelJob(jobId(event.jobId));
+      logger.info("Job cancelled by its worker", { jobId: event.jobId });
+    } catch (error) {
+      logger.error("Failed to cancel job", {
+        jobId: event.jobId,
+        error: error.message
+      });
+    }
+  });
+}
+
+// src/handlers/index.ts
+function registerBusHandlers(eventBus, knowledgeSystem, jobQueue, state, logger) {
+  const { kb } = knowledgeSystem;
+  registerAnnotationAssemblyHandler(eventBus, kb, logger);
+  registerAnnotationContextHandler(
+    eventBus,
+    { views: kb.views, content: workingTreeContentReads(kb.views, kb.content) },
+    logger
+  );
+  registerGatherSummaryHandler(eventBus, knowledgeSystem.gatherer, logger);
+  registerBindUpdateBodyHandler(eventBus, logger);
+  registerJobCommandHandlers(eventBus, jobQueue, state, logger);
+}
+function registerGatewayBusHandlers(eventBus, jobQueue, state, logger) {
+  registerBindUpdateBodyHandler(eventBus, logger);
+  registerJobCommandHandlers(eventBus, jobQueue, state, logger);
 }
-
-// src/handlers/index.ts
-function registerBusHandlers(eventBus, knowledgeSystem, jobQueue, project, logger) {
-  registerAnnotationAssemblyHandler(eventBus, logger);
-  registerAnnotationLookupHandlers(eventBus, knowledgeSystem.kb, knowledgeSystem.gatherer, logger);
-  registerBindUpdateBodyHandler(eventBus, logger);
-  registerJobCommandHandlers(eventBus, jobQueue, project, logger);
-}
 
 // src/service.ts
-async function createJobQueue(project, eventBus, logger) {
+async function createJobQueue(state, eventBus, logger) {
   const jobQueueLogger = logger.child({ component: "job-queue" });
-  const jobQueue = new FsJobQueue(project, jobQueueLogger, eventBus);
+  const jobQueue = new FsJobQueue(state, jobQueueLogger, eventBus);
   await jobQueue.initialize();
   registerJobQueueProvider(() => jobQueue.getStats());
   const jobStatusSubscription = eventBus.get("job:status-requested").pipe(
@@ -13026,12 +13398,12 @@ async function createJobQueue(project, eventBus, logger) {
 }
 var STARTUP_CONNECT_TIMEOUT_MS = 6e4;
 async function withStartupTimeout(what, work) {
-  let timer2;
+  let timer;
   try {
     return await Promise.race([
       work,
       new Promise((_resolve, reject) => {
-        timer2 = setTimeout(
+        timer = setTimeout(
           () => reject(
             new Error(
               `${what} did not become available within ${STARTUP_CONNECT_TIMEOUT_MS / 1e3}s. Exiting so the container restart policy can retry \u2014 it is normal for a dependency to be slow when every service restarts at once.`
@@ -13042,10 +13414,10 @@ async function withStartupTimeout(what, work) {
       })
     ]);
   } finally {
-    if (timer2 !== void 0) clearTimeout(timer2);
+    if (timer !== void 0) clearTimeout(timer);
   }
 }
-async function createKnowledgeSystemFromConfig(project, config, eventBus, logger, skipRebuild) {
+async function connectStores(project, config, eventBus, logger, skipRebuild) {
   const graphConfig = config.services.graph;
   logger.info("Connecting to graph database", { type: graphConfig.type });
   const graphDb = await withStartupTimeout("Graph database", getGraphDatabase(graphConfig));
@@ -13088,18 +13460,18 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
     vectorStore,
     skipRebuild
   });
-  eventStore.setEnrichEvent(async (event, resourceId10) => {
-    const annId = eventAnnotationId(event);
-    if (annId === null) return event;
-    const annotation = await readAnnotationFromView(kb, resourceId10, annId);
-    if (annotation === null) return event;
-    return { ...event, annotation };
-  });
+  return { kb, eventStore, embeddingProvider };
+}
+async function createKnowledgeSystemFromConfig(project, config, eventBus, logger, skipRebuild) {
+  const { kb, eventStore, embeddingProvider } = await connectStores(project, config, eventBus, logger, skipRebuild ?? false);
+  wireEnrichment(eventStore, kb);
   const stower = new Stower(kb, eventBus, project, logger.child({ component: "stower" }));
   await stower.initialize();
   await bootstrapEntityTypes(eventBus, eventStore, logger.child({ component: "entity-types-bootstrap" }));
   const gatherer = new Gatherer(
-    kb,
+    // The content capability is ResourceId-keyed (D-CONTENT b); in-process
+    // it wraps this root's own working tree behind the transport shape.
+    { ...kb, content: workingTreeContentReads(kb.views, kb.content) },
     eventBus,
     createInferenceClient(resolveActorInference(config, "gatherer"), logger.child({ component: "inference-client-gatherer" })),
     config.gather.settleTimeoutMs,
@@ -13116,14 +13488,14 @@ async function createKnowledgeSystemFromConfig(project, config, eventBus, logger
   );
   await matcher.initialize();
   const limitsDiscovery = createLimitsDiscovery(config, logger.child({ component: "limits-discovery" }));
-  const browser = new Browser(kb.views, kb, eventBus, project, config, limitsDiscovery, embeddingProvider, logger.child({ component: "browser" }));
+  const browser = new Browser(kb, eventBus, project, config, limitsDiscovery, embeddingProvider, logger.child({ component: "browser" }));
   await browser.initialize();
   const cloneTokenManager = new CloneTokenManager(kb, eventBus, logger.child({ component: "clone-token-manager" }));
   await cloneTokenManager.initialize();
   const ks = { kb, stower, gatherer, matcher, browser, cloneTokenManager, stop: () => stopKnowledgeSystem(ks) };
   return ks;
 }
-async function startMakeMeaning(project, config, eventBus, logger, options) {
+function assertMakeMeaningConfig(config) {
   if (!config.services?.graph) {
     throw new Error("services.graph is required for make-meaning service");
   }
@@ -13135,6 +13507,9 @@ async function startMakeMeaning(project, config, eventBus, logger, options) {
       `gather.settleTimeoutMs (${config.gather.settleTimeoutMs}ms) plus the graph barrier budget (${GRAPH_BARRIER_BUDGET_MS}ms) must nest inside the job-worker stall watchdog (${STALL_THRESHOLD_MS}ms) \u2014 lower settleTimeoutMs (A4)`
     );
   }
+}
+async function startMakeMeaning(project, config, eventBus, logger, options) {
+  assertMakeMeaningConfig(config);
   const skipRebuild = options?.skipRebuild ?? process.env.SEMIONT_SKIP_REBUILD === "true";
   const { jobQueue, jobStatusSubscription } = await createJobQueue(project, eventBus, logger);
   const knowledgeSystem = await createKnowledgeSystemFromConfig(project, config, eventBus, logger, skipRebuild);
@@ -13151,6 +13526,106 @@ async function startMakeMeaning(project, config, eventBus, logger, options) {
     }
   };
 }
+async function startMakeMeaningGateway(state, config, eventBus, logger) {
+  assertMakeMeaningConfig(config);
+  const { jobQueue, jobStatusSubscription } = await createJobQueue(state, eventBus, logger);
+  registerGatewayBusHandlers(eventBus, jobQueue, state, logger);
+  return {
+    jobQueue,
+    state,
+    stop: async () => {
+      logger.info("Stopping gateway make-meaning");
+      jobStatusSubscription.unsubscribe();
+      logger.info("Gateway make-meaning stopped");
+    }
+  };
+}
+var json = (res, status, body) => {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(body));
+};
+function createArchivistServer(deps) {
+  const { events, content, views, workerSecret, health, branch, logger } = deps;
+  const authorized = (req, res) => {
+    if (!workerSecret) {
+      json(res, 503, { error: "disabled: no SEMIONT_WORKER_SECRET configured" });
+      return false;
+    }
+    if (req.headers.authorization !== `Bearer ${workerSecret}`) {
+      json(res, 401, { error: "unauthorized" });
+      return false;
+    }
+    return true;
+  };
+  return createServer((req, res) => {
+    const url = new URL(req.url ?? "/", "http://archivist");
+    if (req.method === "GET" && url.pathname === "/health") {
+      json(res, 200, health());
+      return;
+    }
+    if (req.method === "GET" && url.pathname === "/kb/branch") {
+      if (!authorized(req, res)) return;
+      json(res, 200, { branch: branch() });
+      return;
+    }
+    if (req.method === "GET" && url.pathname.startsWith("/events/")) {
+      if (!authorized(req, res)) return;
+      const rawId = decodeURIComponent(url.pathname.slice("/events/".length));
+      const rawFrom = url.searchParams.get("fromSequence");
+      const fromSequence = rawFrom === null ? NaN : Number(rawFrom);
+      if (!rawId || !Number.isInteger(fromSequence) || fromSequence < 1) {
+        json(res, 400, { error: "resourceId path segment and integer fromSequence >= 1 are required" });
+        return;
+      }
+      events.queryEvents(resourceId(rawId), { fromSequence }).then((replay) => json(res, 200, { events: replay })).catch((error) => {
+        logger.error("D1 read path failed", { resourceId: rawId, fromSequence, error: errField(error) });
+        json(res, 500, { error: "event read failed" });
+      });
+      return;
+    }
+    const contentMatch = req.method === "GET" && /^\/resources\/(.+)\/content$/.exec(url.pathname);
+    if (contentMatch) {
+      if (!authorized(req, res)) return;
+      const rid = decodeURIComponent(contentMatch[1]);
+      resolveRepresentation({ views, content }, resourceId(rid)).then(async ({ stream, mediaType }) => {
+        res.writeHead(200, { "Content-Type": mediaType });
+        await pipeline(stream, res);
+      }).catch((error) => {
+        if (error instanceof RepresentationMissing) {
+          json(res, 404, { error: error.message, reason: error.reason });
+          return;
+        }
+        logger.error("Content read failed", { resourceId: rid, error: errField(error) });
+        if (res.headersSent) res.destroy();
+        else json(res, 500, { error: "content read failed" });
+      });
+      return;
+    }
+    if (req.method === "PUT" && url.pathname.startsWith("/content/")) {
+      if (!authorized(req, res)) return;
+      const storageUri = decodeURIComponent(url.pathname.slice("/content/".length));
+      if (!storageUri) {
+        json(res, 400, { error: "storageUri path segment is required" });
+        return;
+      }
+      const expectedChecksum = url.searchParams.get("checksum");
+      content.store(req, storageUri, {
+        noGit: true,
+        ...expectedChecksum !== null ? { expectedChecksum } : {}
+      }).then((stored) => json(res, 200, stored)).catch((error) => {
+        if (error instanceof ChecksumMismatchError) {
+          json(res, 409, { error: "checksum mismatch: body does not match the checksum the caller supplied" });
+          return;
+        }
+        logger.error("Content write failed", { storageUri, error: errField(error) });
+        json(res, 500, { error: "content write failed" });
+      });
+      return;
+    }
+    res.writeHead(404);
+    res.end();
+  });
+}
 
 // src/local-transport.ts
 var import_rxjs8 = __toESM(require_cjs());
@@ -13232,7 +13707,7 @@ var LocalTransport = class {
     }
   }
   // LocalTransport implements `ITransport` only. It does not implement
-  // `IBackendOperations` — a SemiontClient built over LocalTransport has
+  // `IGatewayOperations` — a SemiontClient built over LocalTransport has
   // no `client.auth` / `client.admin` namespaces by design (no
   // credentials, no admin routes, no exchange machinery in-process).
   // ── Lifecycle ───────────────────────────────────────────────────────────
@@ -13248,10 +13723,10 @@ var LocalTransport = class {
   }
 };
 var LocalContentTransport = class {
-  constructor(ks) {
-    this.ks = ks;
+  constructor(kb) {
+    this.kb = kb;
   }
-  ks;
+  kb;
   async putBinary(_request, _options) {
     throw new Error(
       "LocalContentTransport does not support putBinary() \u2014 create resources via bus emits (mark/yield namespaces) in local mode"
@@ -13266,12 +13741,12 @@ var LocalContentTransport = class {
    */
   async putAnchoredText(checksum, outcome, _options) {
     busLog("PUT", "anchored-text", { checksum });
-    await this.ks.kb.anchoredText.write(checksum, outcome);
+    await this.kb.anchoredText.write(checksum, outcome);
   }
   /** The stored outcome, or null when nothing has derived one — the common case. */
   async getAnchoredText(resourceId10, _options) {
     busLog("GET", "anchored-text", { resourceId: resourceId10 });
-    return readAnchoredText(this.ks.kb, resourceId10);
+    return readAnchoredText(this.kb, resourceId10);
   }
   /**
    * The cache-consult read (PERSIST-ANCHORS P2c), straight from the store —
@@ -13280,7 +13755,7 @@ var LocalContentTransport = class {
    */
   async getAnchoredTextByChecksum(checksum, _options) {
     busLog("GET", "anchored-text-by-checksum", { checksum });
-    return this.ks.kb.anchoredText.read(checksum);
+    return this.kb.anchoredText.read(checksum);
   }
   /**
    * The store's would-hit keys, straight from the store — planning data for
@@ -13289,7 +13764,7 @@ var LocalContentTransport = class {
    */
   async listAnchoredTextKeys(_options) {
     busLog("GET", "anchored-text-keys", {});
-    return this.ks.kb.anchoredText.list();
+    return this.kb.anchoredText.list();
   }
   async getBinary(resourceId10, _options) {
     busLog("GET", "content", { resourceId: resourceId10 });
@@ -13320,16 +13795,14 @@ var LocalContentTransport = class {
       }
     );
   }
-  async loadBinary(resourceId10) {
-    const view = await this.ks.kb.views.get(resourceId10);
-    if (!view) throw new Error(`Resource not found: ${resourceId10}`);
-    const rep = getPrimaryRepresentation(view.resource);
-    if (!rep?.storageUri) {
-      throw new Error(`Resource ${resourceId10} has no representation with a storageUri`);
-    }
-    const buf = await this.ks.kb.content.retrieve(rep.storageUri);
-    const data = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-    return { data, contentType: rep.mediaType };
+  /**
+   * The same resolution the wire path serves, buffered — local and hosted
+   * modes must answer identically, which they did not before
+   * SINGLE-KB-MOUNT P3: this resolved through `representations[].storageUri`,
+   * a field `ViewMaterializer` never writes, so every binary read here threw.
+   */
+  loadBinary(resourceId10) {
+    return workingTreeContentReads(this.kb.views, this.kb.content).getBinary(resourceId10);
   }
   /**
    * Assemble the resource's JSON-LD graph in-process from the KB — the local
@@ -13337,7 +13810,7 @@ var LocalContentTransport = class {
    * getBinary; SIMPLER-JSON-LD.md decision 7). Local mode has no auth.
    */
   async getResourceGraph(resourceId10, _options) {
-    const graph = await assembleResourceGraph(this.ks.kb, resourceId10);
+    const graph = await assembleResourceGraph(this.kb, resourceId10);
     if (!graph) throw new Error(`Resource not found: ${resourceId10}`);
     return graph;
   }
@@ -13382,23 +13855,24 @@ function isWorkItem(input) {
   return WORK_ITEM_TYPES.has(input.type);
 }
 var Smelter = class _Smelter {
-  constructor(events$, rebuildAnchors$, vectorStore, embeddingProvider, content, bus, chunkingConfig, timing, logger) {
+  constructor(events$, rebuildAnchors$, vectorStore, embeddingProvider, content, anchoredStore, bus, chunkingConfig, timing, logger) {
     this.events$ = events$;
     this.rebuildAnchors$ = rebuildAnchors$;
     this.vectorStore = vectorStore;
     this.embeddingProvider = embeddingProvider;
     this.content = content;
+    this.anchoredStore = anchoredStore;
     this.bus = bus;
     this.chunkingConfig = chunkingConfig;
     this.timing = timing;
     this.logger = logger;
-    this.anchoredStore = anchoredTextStoreOverTransport(content, logger.child({ component: "anchored-text-cache" }));
   }
   events$;
   rebuildAnchors$;
   vectorStore;
   embeddingProvider;
   content;
+  anchoredStore;
   bus;
   chunkingConfig;
   timing;
@@ -13422,7 +13896,6 @@ var Smelter = class _Smelter {
    * OCR pass.
    */
   drainChain = Promise.resolve();
-  anchoredStore;
   get eventsProcessed() {
     return this._eventsProcessed;
   }
@@ -13652,7 +14125,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) {
@@ -13939,7 +14412,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", {
@@ -14176,864 +14649,7 @@ function createSmelterActorStateUnit(options) {
     }
   };
 }
-var pipelineAsync = promisify(pipeline);
-var BLOCK_SIZE = 512;
-function createTarHeader(name, size) {
-  const header = Buffer.alloc(BLOCK_SIZE, 0);
-  header.write(name.slice(0, 100), 0, 100, "utf8");
-  header.write("0000644\0", 100, 8, "utf8");
-  header.write("0000000\0", 108, 8, "utf8");
-  header.write("0000000\0", 116, 8, "utf8");
-  header.write(size.toString(8).padStart(11, "0") + "\0", 124, 12, "utf8");
-  const mtime = Math.floor(Date.now() / 1e3);
-  header.write(mtime.toString(8).padStart(11, "0") + "\0", 136, 12, "utf8");
-  header.write("        ", 148, 8, "utf8");
-  header.write("0", 156, 1, "utf8");
-  header.write("ustar\0", 257, 6, "utf8");
-  header.write("00", 263, 2, "utf8");
-  let checksum = 0;
-  for (let i = 0; i < BLOCK_SIZE; i++) {
-    checksum += header[i];
-  }
-  header.write(checksum.toString(8).padStart(6, "0") + "\0 ", 148, 8, "utf8");
-  return header;
-}
-function paddingBytes(size) {
-  const remainder = size % BLOCK_SIZE;
-  return remainder === 0 ? 0 : BLOCK_SIZE - remainder;
-}
-async function writeTarGz(entries, output) {
-  const gzip = createGzip();
-  const tarStream = new Readable({ read() {
-  } });
-  const pipePromise = pipelineAsync(tarStream, gzip, output);
-  for await (const entry of entries) {
-    const header = createTarHeader(entry.name, entry.data.length);
-    tarStream.push(header);
-    tarStream.push(entry.data);
-    const pad = paddingBytes(entry.data.length);
-    if (pad > 0) {
-      tarStream.push(Buffer.alloc(pad, 0));
-    }
-  }
-  tarStream.push(Buffer.alloc(BLOCK_SIZE * 2, 0));
-  tarStream.push(null);
-  await pipePromise;
-}
-async function decompressStream(input) {
-  const gunzip = createGunzip();
-  const chunks = [];
-  return new Promise((resolve2, reject) => {
-    gunzip.on("data", (chunk) => chunks.push(chunk));
-    gunzip.on("end", () => resolve2(Buffer.concat(chunks)));
-    gunzip.on("error", reject);
-    input.on("error", reject);
-    input.pipe(gunzip);
-  });
-}
-function* parseTarEntries(decompressed) {
-  let offset = 0;
-  while (offset + BLOCK_SIZE <= decompressed.length) {
-    const header = decompressed.subarray(offset, offset + BLOCK_SIZE);
-    if (header.every((b) => b === 0)) break;
-    const nameEnd = header.indexOf(0, 0);
-    const name = header.subarray(0, Math.min(nameEnd, 100)).toString("utf8");
-    const sizeStr = header.subarray(124, 135).toString("utf8").trim();
-    const size = parseInt(sizeStr, 8);
-    offset += BLOCK_SIZE;
-    const data = decompressed.subarray(offset, offset + size);
-    offset += size;
-    offset += paddingBytes(size);
-    yield { name, size, data };
-  }
-}
-async function* readTarGz(input) {
-  const decompressed = await decompressStream(input);
-  yield* parseTarEntries(decompressed);
-}
-
-// src/exchange/manifest.ts
-var BACKUP_FORMAT = "semiont-backup";
-var FORMAT_VERSION = 1;
-var LINKED_DATA_FORMAT = "semiont-linked-data";
-function isLinkedDataManifest(obj) {
-  return typeof obj === "object" && obj !== null && obj["semiont:format"] === LINKED_DATA_FORMAT;
-}
-function isBackupManifest(obj) {
-  return typeof obj === "object" && obj !== null && obj.format === BACKUP_FORMAT;
-}
-function validateManifestVersion(version) {
-  if (version > FORMAT_VERSION) {
-    throw new Error(
-      `Unsupported format version ${version}. This tool supports version ${FORMAT_VERSION}.`
-    );
-  }
-}
-
-// src/exchange/backup-exporter.ts
-var SYSTEM_STREAM = "__system__";
-async function exportBackup(options, output) {
-  const { eventStore, content, sourceUrl, logger } = options;
-  const resourceIds = await eventStore.log.storage.getAllResourceIds();
-  logger?.info("Backup export: enumerating streams", { resourceCount: resourceIds.length });
-  const allStreamIds = [SYSTEM_STREAM, ...resourceIds];
-  const streamData = /* @__PURE__ */ new Map();
-  let totalEvents = 0;
-  for (const id of allStreamIds) {
-    const events = await eventStore.log.getEvents(id);
-    if (events.length > 0) {
-      streamData.set(id, events);
-      totalEvents += events.length;
-    }
-  }
-  const contentRefs = collectContentRefs(streamData);
-  logger?.info("Backup export: collected content refs", {
-    streams: streamData.size,
-    events: totalEvents,
-    blobs: contentRefs.size
-  });
-  const contentBlobs = /* @__PURE__ */ new Map();
-  let totalContentBytes = 0;
-  for (const [storageUri, mediaType] of contentRefs) {
-    const data = await content.retrieve(storageUri);
-    const ext = extensionForMediaType(mediaType);
-    contentBlobs.set(storageUri, { data, ext });
-    totalContentBytes += data.length;
-  }
-  const streamSummaries = [];
-  for (const [streamId, events] of streamData) {
-    streamSummaries.push({
-      stream: streamId,
-      eventCount: events.length
-    });
-  }
-  const manifestHeader = {
-    format: BACKUP_FORMAT,
-    version: FORMAT_VERSION,
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    sourceUrl,
-    stats: {
-      streams: streamData.size,
-      events: totalEvents,
-      blobs: contentBlobs.size,
-      contentBytes: totalContentBytes
-    }
-  };
-  async function* generateEntries() {
-    const manifestLines = [
-      JSON.stringify(manifestHeader),
-      ...streamSummaries.map((s) => JSON.stringify(s))
-    ].join("\n") + "\n";
-    yield { name: ".semiont/manifest.jsonl", data: Buffer.from(manifestLines, "utf8") };
-    for (const [streamId, events] of streamData) {
-      const fileName = streamId === SYSTEM_STREAM ? ".semiont/events/__system__.jsonl" : `.semiont/events/${streamId}.jsonl`;
-      const jsonl = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-      yield { name: fileName, data: Buffer.from(jsonl, "utf8") };
-    }
-    for (const [storageUri, { data, ext }] of contentBlobs) {
-      const blobPath = storageUri.startsWith("file://") ? storageUri.slice(7) : storageUri;
-      yield { name: `${blobPath}${ext}`, data };
-    }
-  }
-  await writeTarGz(generateEntries(), output);
-  logger?.info("Backup export complete", {
-    streams: streamData.size,
-    events: totalEvents,
-    blobs: contentBlobs.size,
-    contentBytes: totalContentBytes
-  });
-  return manifestHeader;
-}
-function collectContentRefs(streamData) {
-  const refs = /* @__PURE__ */ new Map();
-  for (const [, events] of streamData) {
-    for (const stored of events) {
-      if (stored.type === "yield:created") {
-        const payload = stored.payload;
-        if (payload.storageUri && payload.format) {
-          refs.set(payload.storageUri, payload.format);
-        }
-      }
-    }
-  }
-  return refs;
-}
-
-// src/exchange/await-reply.ts
-var import_rxjs11 = __toESM(require_cjs());
-var import_operators9 = __toESM(require_operators());
-function awaitReply(eventBus, command, payload, okChannel, failedChannel, timeoutMs) {
-  const result$ = (0, import_rxjs11.race)(
-    eventBus.get(okChannel).pipe((0, import_operators9.map)(() => void 0)),
-    eventBus.get(failedChannel).pipe(
-      (0, import_operators9.map)((e) => {
-        throw new Error(e.message ?? `${command} failed`);
-      })
-    ),
-    (0, import_rxjs11.timer)(timeoutMs).pipe(
-      (0, import_operators9.map)(() => {
-        throw new Error(`Timeout waiting for ${okChannel}`);
-      })
-    )
-  );
-  eventBus.get(command).next(payload);
-  return (0, import_rxjs11.firstValueFrom)(result$);
-}
-var REPLAY_TIMEOUT_MS = 3e4;
-async function replayEventStream(jsonl, eventBus, eventStore, resolveBlob, contentStore, logger) {
-  const lines = jsonl.trim().split("\n").filter((l) => l.length > 0);
-  const storedEvents = lines.map((line) => JSON.parse(line));
-  const stats = {
-    eventsReplayed: 0,
-    resourcesCreated: 0,
-    annotationsCreated: 0,
-    entityTypesAdded: 0
-  };
-  for (const stored of storedEvents) {
-    await replayEvent(stored, eventBus, eventStore, resolveBlob, contentStore, stats, logger);
-    stats.eventsReplayed++;
-  }
-  return { stats };
-}
-async function replayEvent(event, eventBus, eventStore, resolveBlob, contentStore, stats, logger) {
-  switch (event.type) {
-    case "frame:entity-type-added":
-      await replayEntityTypeAdded(event, eventBus, logger);
-      stats.entityTypesAdded++;
-      break;
-    case "yield:created":
-      await replayResourceCreated(event, eventBus, resolveBlob, contentStore, logger);
-      stats.resourcesCreated++;
-      break;
-    case "mark:added":
-      await replayAnnotationAdded(event, eventBus, logger);
-      stats.annotationsCreated++;
-      break;
-    case "mark:body-updated":
-      await replayAnnotationBodyUpdated(event, eventBus, logger);
-      break;
-    case "mark:removed":
-      await replayAnnotationRemoved(event, eventBus, logger);
-      break;
-    case "mark:archived":
-      await replayResourceArchived(event, eventBus, logger);
-      break;
-    case "mark:unarchived":
-      await replayResourceUnarchived(event, eventBus, logger);
-      break;
-    case "mark:entity-tag-added":
-    case "mark:entity-tag-removed":
-      await replayEntityTagChange(event, eventStore, logger);
-      break;
-    // Job events are transient — skip during replay
-    case "job:started":
-    case "job:completed":
-    case "job:failed":
-      logger?.debug("Skipping job event during replay", { type: event.type });
-      break;
-    // Representation events — content is already stored via yield:created replay
-    case "yield:representation-added":
-    case "yield:representation-removed":
-      logger?.debug("Skipping representation event during replay", { type: event.type });
-      break;
-    default:
-      logger?.warn("Unknown event type during replay", { type: event.type });
-  }
-}
-async function replayEntityTypeAdded(event, eventBus, logger) {
-  await busRequest(
-    asBusRequestPrimitive(eventBus),
-    "frame:add-entity-type",
-    { tag: event.payload.entityType, _userId: event.userId },
-    REPLAY_TIMEOUT_MS
-  );
-  logger?.debug("Replayed entitytype.added", { entityType: event.payload.entityType });
-}
-async function replayResourceCreated(event, eventBus, resolveBlob, contentStore, logger) {
-  const { payload } = event;
-  const blob = resolveBlob(payload.contentChecksum);
-  if (!blob) {
-    throw new Error(`Missing content blob for checksum ${payload.contentChecksum}`);
-  }
-  const base = baseMediaType(payload.format);
-  const resolvedUri = payload.storageUri || deriveStorageUri(payload.name, isSupportedMediaType(base) ? base : "application/octet-stream");
-  const stored = await contentStore.store(blob, resolvedUri);
-  await busRequest(
-    asBusRequestPrimitive(eventBus),
-    "yield:create",
-    {
-      name: payload.name,
-      storageUri: resolvedUri,
-      contentChecksum: stored.checksum,
-      byteSize: stored.byteSize,
-      format: payload.format,
-      _userId: event.userId,
-      language: payload.language,
-      entityTypes: payload.entityTypes,
-      isDraft: payload.isDraft,
-      generatedFrom: payload.generatedFrom,
-      generationPrompt: payload.generationPrompt
-    },
-    REPLAY_TIMEOUT_MS
-  );
-  logger?.debug("Replayed resource.created", { name: payload.name });
-}
-async function replayAnnotationAdded(event, eventBus, logger) {
-  await awaitReply(
-    eventBus,
-    "mark:create",
-    {
-      annotation: event.payload.annotation,
-      _userId: event.userId,
-      resourceId: event.resourceId
-    },
-    "mark:create-ok",
-    "mark:create-failed",
-    REPLAY_TIMEOUT_MS
-  );
-  logger?.debug("Replayed annotation.added", { annotationId: event.payload.annotation.id });
-}
-async function replayAnnotationBodyUpdated(event, eventBus, logger) {
-  await awaitReply(
-    eventBus,
-    "mark:update-body",
-    {
-      annotationId: event.payload.annotationId,
-      _userId: event.userId,
-      resourceId: event.resourceId,
-      operations: event.payload.operations
-    },
-    "mark:body-updated",
-    "mark:body-update-failed",
-    REPLAY_TIMEOUT_MS
-  );
-  logger?.debug("Replayed annotation.body.updated", { annotationId: event.payload.annotationId });
-}
-async function replayAnnotationRemoved(event, eventBus, logger) {
-  await awaitReply(
-    eventBus,
-    "mark:delete",
-    {
-      annotationId: event.payload.annotationId,
-      _userId: event.userId,
-      resourceId: event.resourceId
-    },
-    "mark:delete-ok",
-    "mark:delete-failed",
-    REPLAY_TIMEOUT_MS
-  );
-  logger?.debug("Replayed annotation.removed", { annotationId: event.payload.annotationId });
-}
-async function replayResourceArchived(event, eventBus, logger) {
-  eventBus.get("mark:archive").next({
-    _userId: event.userId,
-    resourceId: event.resourceId
-  });
-  logger?.debug("Replayed resource.archived", { resourceId: event.resourceId });
-}
-async function replayResourceUnarchived(event, eventBus, logger) {
-  eventBus.get("mark:unarchive").next({
-    _userId: event.userId,
-    resourceId: event.resourceId
-  });
-  logger?.debug("Replayed resource.unarchived", { resourceId: event.resourceId });
-}
-async function replayEntityTagChange(event, eventStore, logger) {
-  const base = {
-    resourceId: event.resourceId,
-    userId: event.userId,
-    version: event.version
-  };
-  if (event.type === "mark:entity-tag-added") {
-    await eventStore.appendEvent({ ...base, type: "mark:entity-tag-added", payload: event.payload });
-  } else {
-    await eventStore.appendEvent({ ...base, type: "mark:entity-tag-removed", payload: event.payload });
-  }
-  logger?.debug("Replayed entity tag change", { type: event.type, entityType: event.payload.entityType });
-}
-
-// src/exchange/backup-importer.ts
-function buildBlobResolver(entries) {
-  const checksumIndex = /* @__PURE__ */ new Map();
-  for (const name of entries.keys()) {
-    if (!name.startsWith(".semiont/")) {
-      const dotIndex = name.lastIndexOf(".");
-      const checksum = dotIndex >= 0 ? name.slice(0, dotIndex) : name;
-      checksumIndex.set(checksum, name);
-    }
-  }
-  return (checksum) => {
-    const entryName = checksumIndex.get(checksum);
-    return entryName ? entries.get(entryName) : void 0;
-  };
-}
-async function importBackup(archive, options) {
-  const { eventBus, eventStore, contentStore, logger } = options;
-  const entries = /* @__PURE__ */ new Map();
-  for await (const entry of readTarGz(archive)) {
-    entries.set(entry.name, entry.data);
-  }
-  const manifestData = entries.get(".semiont/manifest.jsonl");
-  if (!manifestData) {
-    throw new Error("Invalid backup: missing .semiont/manifest.jsonl");
-  }
-  const manifestLines = manifestData.toString("utf8").trim().split("\n");
-  const header = JSON.parse(manifestLines[0]);
-  if (!isBackupManifest(header)) {
-    throw new Error(`Invalid backup: expected format "${BACKUP_FORMAT}", got "${header.format}"`);
-  }
-  validateManifestVersion(header.version);
-  const streamSummaries = manifestLines.slice(1).map((line) => JSON.parse(line));
-  logger?.info("Backup import: parsed manifest", {
-    streams: header.stats.streams,
-    events: header.stats.events,
-    blobs: header.stats.blobs
-  });
-  const resolveBlob = buildBlobResolver(entries);
-  const systemData = entries.get(".semiont/events/__system__.jsonl");
-  let stats = { eventsReplayed: 0, resourcesCreated: 0, annotationsCreated: 0, entityTypesAdded: 0 };
-  if (systemData) {
-    const result = await replayEventStream(
-      systemData.toString("utf8"),
-      eventBus,
-      eventStore,
-      resolveBlob,
-      contentStore,
-      logger
-    );
-    stats = mergeStats(stats, result.stats);
-  }
-  for (const summary of streamSummaries) {
-    if (summary.stream === "__system__") continue;
-    const eventData = entries.get(`.semiont/events/${summary.stream}.jsonl`);
-    if (!eventData) {
-      logger?.warn("Backup import: missing event stream", { stream: summary.stream });
-      continue;
-    }
-    const result = await replayEventStream(
-      eventData.toString("utf8"),
-      eventBus,
-      eventStore,
-      resolveBlob,
-      contentStore,
-      logger
-    );
-    stats = mergeStats(stats, result.stats);
-  }
-  logger?.info("Backup import complete", { ...stats });
-  return { manifest: header, stats };
-}
-function mergeStats(a, b) {
-  return {
-    eventsReplayed: a.eventsReplayed + b.eventsReplayed,
-    resourcesCreated: a.resourcesCreated + b.resourcesCreated,
-    annotationsCreated: a.annotationsCreated + b.annotationsCreated,
-    entityTypesAdded: a.entityTypesAdded + b.entityTypesAdded
-  };
-}
-var SEMIONT_CONTEXT = [
-  "https://schema.org/",
-  "http://www.w3.org/ns/anno.jsonld",
-  {
-    "semiont": "https://semiont.org/vocab/",
-    "entityTypes": "semiont:entityTypes",
-    "archived": "semiont:archived",
-    "representations": { "@id": "semiont:representations", "@container": "@set" },
-    "annotations": { "@id": "semiont:annotations", "@container": "@set" }
-  }
-];
-var MANIFEST_CONTEXT = {
-  "semiont": "https://semiont.org/vocab/",
-  "schema": "https://schema.org/",
-  "dct": "http://purl.org/dc/terms/",
-  "prov": "http://www.w3.org/ns/prov#",
-  "void": "http://rdfs.org/ns/void#"
-};
-function hydrateAnnotation(annotation, baseUrl) {
-  const hydrated = { ...annotation };
-  if (hydrated.id && !hydrated.id.startsWith("http")) {
-    hydrated.id = `${baseUrl}/annotations/${hydrated.id}`;
-  }
-  if (typeof hydrated.target === "string") {
-    if (!hydrated.target.startsWith("http")) {
-      hydrated.target = `${baseUrl}/resources/${hydrated.target}`;
-    }
-  } else if (hydrated.target && typeof hydrated.target === "object") {
-    const target = { ...hydrated.target };
-    if (target.source && !target.source.startsWith("http")) {
-      target.source = `${baseUrl}/resources/${target.source}`;
-    }
-    hydrated.target = target;
-  }
-  hydrated.body = hydrateBody(hydrated.body, baseUrl);
-  return hydrated;
-}
-function hydrateBody(body, baseUrl) {
-  if (Array.isArray(body)) {
-    return body.map((b) => hydrateBodyItem(b, baseUrl));
-  }
-  return hydrateBodyItem(body, baseUrl);
-}
-function hydrateBodyItem(item, baseUrl) {
-  if (item && typeof item === "object" && "source" in item) {
-    const source = item.source;
-    if (typeof source === "string" && !source.startsWith("http")) {
-      return { ...item, source: `${baseUrl}/resources/${source}` };
-    }
-  }
-  return item;
-}
-async function exportLinkedData(options, output) {
-  const { views, content, sourceUrl, entityTypes, includeArchived, logger } = options;
-  const allViews = await views.getAll();
-  const resourceViews = includeArchived ? allViews : allViews.filter((v) => !v.resource.archived);
-  logger?.info("Linked data export: enumerating resources", { count: resourceViews.length });
-  const contentRefs = /* @__PURE__ */ new Map();
-  for (const view of resourceViews) {
-    collectContentRefsFromResource(view.resource, contentRefs);
-  }
-  const contentBlobs = /* @__PURE__ */ new Map();
-  for (const [storageUri, mediaType] of contentRefs) {
-    try {
-      const data = await content.retrieve(storageUri);
-      const ext = extensionForMediaType(mediaType);
-      contentBlobs.set(storageUri, { data, ext });
-    } catch (err) {
-      logger?.warn("Failed to retrieve content blob", { storageUri, error: String(err) });
-    }
-  }
-  const manifest = {
-    "@context": MANIFEST_CONTEXT,
-    "@type": "void:Dataset",
-    "semiont:format": LINKED_DATA_FORMAT,
-    "semiont:version": FORMAT_VERSION,
-    "dct:created": (/* @__PURE__ */ new Date()).toISOString(),
-    "prov:wasGeneratedBy": {
-      "@type": "prov:Activity",
-      "prov:used": sourceUrl
-    },
-    "semiont:entityTypes": entityTypes,
-    "void:entities": resourceViews.length
-  };
-  async function* generateEntries() {
-    yield {
-      name: ".semiont/manifest.jsonld",
-      data: Buffer.from(JSON.stringify(manifest, null, 2), "utf8")
-    };
-    for (const view of resourceViews) {
-      const resourceId10 = view.resource["@id"];
-      const jsonld = buildResourceJsonLd(view.resource, view.annotations.annotations, sourceUrl);
-      yield {
-        name: `.semiont/resources/${resourceId10}.jsonld`,
-        data: Buffer.from(JSON.stringify(jsonld, null, 2), "utf8")
-      };
-    }
-    for (const [storageUri, { data, ext }] of contentBlobs) {
-      const blobPath = storageUri.startsWith("file://") ? storageUri.slice(7) : storageUri;
-      yield { name: `${blobPath}${ext}`, data };
-    }
-  }
-  await writeTarGz(generateEntries(), output);
-  logger?.info("Linked data export complete", {
-    resources: resourceViews.length,
-    blobs: contentBlobs.size
-  });
-  return manifest;
-}
-function buildResourceJsonLd(resource, annotations, sourceUrl) {
-  const resourceId10 = resource["@id"];
-  const resourceUri = resourceId10.startsWith("http") ? resourceId10 : `${sourceUrl}/resources/${resourceId10}`;
-  const doc = {
-    "@context": SEMIONT_CONTEXT,
-    "@id": resourceUri,
-    "@type": resource["@type"] ?? "DigitalDocument",
-    "name": resource.name
-  };
-  if (resource.dateCreated) doc["dateCreated"] = resource.dateCreated;
-  if (resource.dateModified) doc["dateModified"] = resource.dateModified;
-  if (resource.description) doc["description"] = resource.description;
-  const reps = normalizeRepresentations(resource.representations);
-  if (reps.length > 0) {
-    const primary = reps[0];
-    if (primary.language) doc["inLanguage"] = primary.language;
-    if (primary.mediaType) doc["encodingFormat"] = primary.mediaType;
-  }
-  if (resource.entityTypes && resource.entityTypes.length > 0) doc["entityTypes"] = resource.entityTypes;
-  if (resource.archived) doc["archived"] = resource.archived;
-  if (resource.wasDerivedFrom) doc["wasDerivedFrom"] = resource.wasDerivedFrom;
-  if (resource.wasAttributedTo) doc["wasAttributedTo"] = resource.wasAttributedTo;
-  if (resource.sameAs && resource.sameAs.length > 0) doc["sameAs"] = resource.sameAs;
-  if (resource.isPartOf && resource.isPartOf.length > 0) doc["isPartOf"] = resource.isPartOf;
-  if (resource.hasPart && resource.hasPart.length > 0) doc["hasPart"] = resource.hasPart;
-  if (reps.length > 0) {
-    doc["representations"] = reps.map((rep) => {
-      const mediaObj = {
-        "@type": "schema:MediaObject",
-        "encodingFormat": rep.mediaType
-      };
-      if (rep.byteSize !== void 0) mediaObj["contentSize"] = rep.byteSize;
-      if (rep.checksum) {
-        const rawChecksum = rep.checksum.startsWith("sha256:") ? rep.checksum.slice(7) : rep.checksum;
-        mediaObj["sha256"] = rawChecksum;
-        const ext = extensionForMediaType(rep.mediaType);
-        mediaObj["name"] = `${rawChecksum}${ext}`;
-      }
-      if (rep.language) mediaObj["inLanguage"] = rep.language;
-      return mediaObj;
-    });
-  }
-  if (annotations.length > 0) {
-    doc["annotations"] = annotations.map((ann) => hydrateAnnotation(ann, sourceUrl));
-  }
-  return doc;
-}
-function normalizeRepresentations(reps) {
-  if (!reps) return [];
-  if (Array.isArray(reps)) return reps;
-  return [reps];
-}
-function collectContentRefsFromResource(resource, refs) {
-  if (resource.storageUri) {
-    const reps = normalizeRepresentations(resource.representations);
-    const mediaType = reps[0]?.mediaType ?? "application/octet-stream";
-    refs.set(resource.storageUri, mediaType);
-  }
-}
-var IMPORT_TIMEOUT_MS = 3e4;
-function stripUriToId(uri) {
-  if (!uri.includes("/")) return uri;
-  const lastSlash = uri.lastIndexOf("/");
-  return uri.slice(lastSlash + 1);
-}
-function dehydrateAnnotation(annotation) {
-  const dehydrated = { ...annotation };
-  if (dehydrated.id) {
-    dehydrated.id = annotationId(stripUriToId(dehydrated.id));
-  }
-  if (typeof dehydrated.target === "string") {
-    dehydrated.target = stripUriToId(dehydrated.target);
-  } else if (dehydrated.target && typeof dehydrated.target === "object") {
-    const target = { ...dehydrated.target };
-    if (target.source) {
-      target.source = stripUriToId(target.source);
-    }
-    dehydrated.target = target;
-  }
-  dehydrated.body = dehydrateBody(dehydrated.body);
-  return dehydrated;
-}
-function dehydrateBody(body) {
-  if (Array.isArray(body)) {
-    return body.map((b) => dehydrateBodyItem(b));
-  }
-  return dehydrateBodyItem(body);
-}
-function dehydrateBodyItem(item) {
-  if (item && typeof item === "object" && "source" in item) {
-    const source = item.source;
-    if (typeof source === "string" && source.includes("/")) {
-      return { ...item, source: stripUriToId(source) };
-    }
-  }
-  return item;
-}
-function buildBlobResolver2(entries) {
-  const checksumIndex = /* @__PURE__ */ new Map();
-  for (const name of entries.keys()) {
-    if (!name.startsWith(".semiont/")) {
-      const dotIndex = name.lastIndexOf(".");
-      const checksum = dotIndex >= 0 ? name.slice(0, dotIndex) : name;
-      checksumIndex.set(checksum, name);
-    }
-  }
-  return (checksum) => {
-    const entryName = checksumIndex.get(checksum);
-    return entryName ? entries.get(entryName) : void 0;
-  };
-}
-async function importLinkedData(archive, options) {
-  const { eventBus, contentStore, userId: userId3, logger } = options;
-  const entries = /* @__PURE__ */ new Map();
-  for await (const entry of readTarGz(archive)) {
-    entries.set(entry.name, entry.data);
-  }
-  const manifestData = entries.get(".semiont/manifest.jsonld");
-  if (!manifestData) {
-    throw new Error("Invalid linked data archive: missing .semiont/manifest.jsonld");
-  }
-  const manifest = JSON.parse(manifestData.toString("utf8"));
-  if (!isLinkedDataManifest(manifest)) {
-    throw new Error(
-      `Invalid linked data archive: expected format "${LINKED_DATA_FORMAT}", got "${manifest["semiont:format"]}"`
-    );
-  }
-  validateManifestVersion(manifest["semiont:version"]);
-  logger?.info("Linked data import: parsed manifest", {
-    entityTypes: manifest["semiont:entityTypes"].length,
-    resources: manifest["void:entities"]
-  });
-  const resolveBlob = buildBlobResolver2(entries);
-  let entityTypesAdded = 0;
-  for (const entityType2 of manifest["semiont:entityTypes"]) {
-    await addEntityType(entityType2, userId3, eventBus, logger);
-    entityTypesAdded++;
-  }
-  const resourceEntries = [...entries.keys()].filter((name) => name.startsWith(".semiont/resources/") && name.endsWith(".jsonld")).sort();
-  let resourcesCreated = 0;
-  let annotationsCreated = 0;
-  for (const entryName of resourceEntries) {
-    const resourceDoc = JSON.parse(entries.get(entryName).toString("utf8"));
-    const result = await importResource(resourceDoc, userId3, eventBus, contentStore, resolveBlob, logger);
-    resourcesCreated++;
-    annotationsCreated += result.annotationsCreated;
-  }
-  logger?.info("Linked data import complete", {
-    resourcesCreated,
-    annotationsCreated,
-    entityTypesAdded
-  });
-  return {
-    manifest,
-    resourcesCreated,
-    annotationsCreated,
-    entityTypesAdded
-  };
-}
-async function addEntityType(entityType2, userId3, eventBus, logger) {
-  await busRequest(
-    asBusRequestPrimitive(eventBus),
-    "frame:add-entity-type",
-    { tag: entityType2, _userId: userId3 },
-    IMPORT_TIMEOUT_MS
-  );
-  logger?.debug("Added entity type", { entityType: entityType2 });
-}
-async function importResource(doc, userId3, eventBus, contentStore, resolveBlob, logger) {
-  const name = doc["name"];
-  const representations = doc["representations"];
-  const annotations = doc["annotations"];
-  const entityTypes = doc["entityTypes"];
-  let format = "text/markdown";
-  let language;
-  let contentChecksum;
-  if (representations && representations.length > 0) {
-    const primary = representations[0];
-    if (primary["encodingFormat"]) format = primary["encodingFormat"];
-    if (primary["inLanguage"]) language = primary["inLanguage"];
-    if (primary["sha256"]) contentChecksum = primary["sha256"];
-  }
-  if (!contentChecksum) {
-    throw new Error(`Resource "${name}" has no content checksum in representations`);
-  }
-  const blob = resolveBlob(contentChecksum);
-  if (!blob) {
-    throw new Error(`Missing content blob for checksum ${contentChecksum} (resource "${name}")`);
-  }
-  const base = baseMediaType(format);
-  const resolvedUri = deriveStorageUri(name, isSupportedMediaType(base) ? base : "application/octet-stream");
-  const stored = await contentStore.store(blob, resolvedUri);
-  const { resourceId: createdId } = await busRequest(
-    asBusRequestPrimitive(eventBus),
-    "yield:create",
-    {
-      name,
-      storageUri: resolvedUri,
-      contentChecksum: stored.checksum,
-      byteSize: stored.byteSize,
-      format,
-      _userId: userId3,
-      language,
-      entityTypes: entityTypes ?? []
-    },
-    IMPORT_TIMEOUT_MS
-  );
-  const resourceId10 = resourceId(createdId);
-  logger?.debug("Created resource from JSON-LD", { name, resourceId: resourceId10 });
-  let annotationsCreated = 0;
-  if (annotations && annotations.length > 0) {
-    for (const annotation of annotations) {
-      await createAnnotation(annotation, resourceId10, userId3, eventBus, logger);
-      annotationsCreated++;
-    }
-  }
-  return { annotationsCreated };
-}
-async function createAnnotation(annotation, resourceId10, userId3, eventBus, logger) {
-  await awaitReply(
-    eventBus,
-    "mark:create",
-    {
-      annotation: dehydrateAnnotation(annotation),
-      _userId: userId3,
-      resourceId: resourceId10
-    },
-    "mark:create-ok",
-    "mark:create-failed",
-    IMPORT_TIMEOUT_MS
-  );
-  logger?.debug("Created annotation", { annotationId: annotation.id });
-}
-var AnnotationOperations = class {
-  /**
-   * Create a new annotation via EventBus → Stower
-   */
-  static async createAnnotation(request, userId3, creator, eventBus) {
-    const { annotation } = assembleAnnotation(request, creator);
-    const resId = resourceId(request.target.source);
-    eventBus.get("mark:create").next({
-      annotation,
-      _userId: userId3,
-      resourceId: resId
-    });
-    return { annotation };
-  }
-  /**
-   * Update annotation body via EventBus → Stower
-   */
-  static async updateAnnotationBody(id, request, userId3, eventBus, kb) {
-    const resId = resourceId(request.resourceId);
-    const annotation = await AnnotationContext.getAnnotation(
-      annotationId(id),
-      resId,
-      kb
-    );
-    if (!annotation) {
-      throw new Error("Annotation not found");
-    }
-    eventBus.get("mark:update-body").next({
-      annotationId: annotationId(id),
-      _userId: userId3,
-      resourceId: resId,
-      operations: request.operations
-    });
-    const updatedBody = applyBodyOperations(annotation.body, request.operations);
-    return {
-      annotation: {
-        ...annotation,
-        body: updatedBody
-      }
-    };
-  }
-  /**
-   * Delete an annotation via EventBus → Stower
-   */
-  static async deleteAnnotation(id, resourceIdStr, userId3, eventBus, kb, logger) {
-    const resId = resourceId(resourceIdStr);
-    const projection = await AnnotationContext.getResourceAnnotations(resId, kb);
-    const annotation = projection.annotations.find((a) => a.id === id);
-    if (!annotation) {
-      throw new Error("Annotation not found in resource");
-    }
-    logger?.debug("Removing annotation via EventBus", { annotationId: id });
-    eventBus.get("mark:delete").next({
-      annotationId: annotationId(id),
-      _userId: userId3,
-      resourceId: resId
-    });
-    logger?.debug("Annotation delete event emitted");
-  }
-};
 
-export { AnnotationContext, AnnotationOperations, BACKUP_FORMAT, Browser, CloneTokenManager, FORMAT_VERSION, Gatherer, GraphContext, LLMContext, LocalContentTransport, LocalTransport, Matcher, ResourceContext, ResourceOperations, Smelter, Stower, asBusRequestPrimitive, bootstrapEntityTypes, createKnowledgeBase, createSmelterActorStateUnit, exportBackup, exportLinkedData, generateReferenceSuggestions, generateResourceSummary, importBackup, importLinkedData, isBackupManifest, readEntityTypesProjection, registerAnnotationAssemblyHandler, registerAnnotationLookupHandlers, registerBindUpdateBodyHandler, registerBusHandlers, registerJobCommandHandlers, startMakeMeaning, stopKnowledgeSystem, validateManifestVersion };
+export { AnnotationContext, AnnotationOperations, Browser, CloneTokenManager, Gatherer, GraphContext, LLMContext, LocalContentTransport, LocalTransport, Matcher, ResourceContext, ResourceOperations, Smelter, Stower, asBusRequestPrimitive, bootstrapEntityTypes, createArchivistServer, createKnowledgeBase, createSmelterActorStateUnit, generateReferenceSuggestions, generateResourceSummary, makeMeaningConfigFrom, readEntityTypesProjection, registerAnnotationAssemblyHandler, registerAnnotationContextHandler, registerBindUpdateBodyHandler, registerBusHandlers, registerGatherSummaryHandler, registerJobCommandHandlers, requireKBName, startMakeMeaning, startMakeMeaningGateway, stopKnowledgeSystem };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map