@semiont/make-meaning 0.3.8 → 0.4.0

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { GraphServiceConfig, Logger, StoredEvent, ResourceId, EventBus, componen
 export { AssembledAnnotation, applyBodyOperations, assembleAnnotation } from '@semiont/core';
 import { InferenceClient } from '@semiont/inference';
 import { GraphDatabase } from '@semiont/graph';
-import { RepresentationStore } from '@semiont/content';
+import { WorkingTreeStore } from '@semiont/content';
 import { Writable, Readable } from 'node:stream';
 
 /**
@@ -151,7 +151,7 @@ declare class GraphDBConsumer {
  *
  * - Event Log (immutable append-only) — via EventStore
  * - Materialized Views (fast single-doc queries) — via ViewStorage
- * - Content Store (SHA-256 addressed, deduplicated) — via RepresentationStore
+ * - Content Store (working-tree files, URI-addressed) — via WorkingTreeStore
  * - Graph (eventually consistent relationship projection) — via GraphDatabase
  *
  * The Gatherer and Matcher are the only actors that read from these stores directly.
@@ -160,8 +160,9 @@ declare class GraphDBConsumer {
 interface KnowledgeBase {
     eventStore: EventStore;
     views: ViewStorage;
-    content: RepresentationStore;
+    content: WorkingTreeStore;
     graph: GraphDatabase;
+    projectionsDir: string;
 }
 declare function createKnowledgeBase(eventStore: EventStore, project: SemiontProject, graphDb: GraphDatabase, logger: Logger): KnowledgeBase;
 
@@ -289,10 +290,12 @@ declare class Matcher {
  *
  * Subscriptions:
  * - yield:create       → resource.created (+ content store)   → yield:created / yield:create-failed
+ * - yield:update       → resource.updated (+ content store)   → yield:updated / yield:update-failed
+ * - yield:mv           → resource.moved (+ working tree move) → yield:moved / yield:move-failed
  * - mark:create        → annotation.added                     → mark:created / mark:create-failed
  * - mark:delete        → annotation.removed                   → mark:deleted / mark:delete-failed
  * - mark:update-body   → annotation.body.updated              → (no result event yet)
- * - mark:archive       → resource.archived                    (resource-scoped, no result event)
+ * - mark:archive       → resource.archived (+ file removal)   (resource-scoped, no result event)
  * - mark:unarchive     → resource.unarchived                  (resource-scoped, no result event)
  * - mark:add-entity-type → entitytype.added                   → mark:entity-type-added / mark:entity-type-add-failed
  * - mark:update-entity-types → entitytag.added / entitytag.removed
@@ -315,6 +318,8 @@ declare class Stower {
     constructor(kb: KnowledgeBase, eventBus: EventBus, logger: Logger);
     initialize(): Promise<void>;
     private handleYieldCreate;
+    private handleYieldUpdate;
+    private handleYieldMv;
     private handleMarkCreate;
     private handleMarkDelete;
     private handleMarkUpdateBody;
@@ -487,9 +492,9 @@ interface BackupEventStoreReader {
         getEvents(resourceId: ResourceId): Promise<StoredEvent[]>;
     };
 }
-/** Subset of RepresentationStore used by the backup exporter. */
+/** Subset of WorkingTreeStore used by the backup exporter. */
 interface BackupContentReader {
-    retrieve(checksum: string, mediaType: string): Promise<Buffer>;
+    retrieve(storageUri: string): Promise<Buffer>;
 }
 interface BackupExporterOptions {
     eventStore: BackupEventStoreReader;
@@ -591,9 +596,9 @@ interface LinkedDataViewReader {
         };
     }>>;
 }
-/** Subset of RepresentationStore used by the linked-data exporter. */
+/** Subset of WorkingTreeStore used by the linked-data exporter. */
 interface LinkedDataContentReader {
-    retrieve(checksum: string, mediaType: string): Promise<Buffer>;
+    retrieve(storageUri: string): Promise<Buffer>;
 }
 interface LinkedDataExporterOptions {
     views: LinkedDataViewReader;
@@ -674,6 +679,7 @@ interface CreateResourceInput {
     language?: string;
     entityTypes?: string[];
     creationMethod?: CreationMethod;
+    storageUri?: string;
 }
 declare class ResourceOperations {
     /**

package/dist/index.js

@@ -9945,7 +9945,6 @@ var require_operators = __commonJS({
 // src/service.ts
 import { JobQueue } from "@semiont/jobs";
 import { createEventStore as createEventStoreCore } from "@semiont/event-sourcing";
-import { getPrimaryRepresentation as getPrimaryRepresentation4 } from "@semiont/api-client";
 
 // src/config.ts
 function resolveActorInference(config, actor) {
@@ -10454,14 +10453,14 @@ function resetBootstrap() {
 
 // src/knowledge-base.ts
 import { FilesystemViewStorage } from "@semiont/event-sourcing";
-import { FilesystemRepresentationStore } from "@semiont/content";
+import { WorkingTreeStore } from "@semiont/content";
 function createKnowledgeBase(eventStore, project, graphDb, logger) {
   const views = new FilesystemViewStorage(project);
-  const content = new FilesystemRepresentationStore(
+  const content = new WorkingTreeStore(
     project,
-    logger.child({ component: "representation-store" })
+    logger.child({ component: "working-tree-store" })
   );
-  return { eventStore, views, content, graph: graphDb };
+  return { eventStore, views, content, graph: graphDb, projectionsDir: project.projectionsDir };
 }
 
 // src/gatherer.ts
@@ -10556,10 +10555,10 @@ var ResourceContext = class {
     return await Promise.all(
       resources.map(async (doc) => {
         try {
-          const primaryRep = getPrimaryRepresentation(doc);
-          if (primaryRep?.checksum && primaryRep?.mediaType) {
-            const contentBuffer = await kb.content.retrieve(primaryRep.checksum, primaryRep.mediaType);
-            const contentPreview = decodeRepresentation(contentBuffer, primaryRep.mediaType).slice(0, 200);
+          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);
             return { ...doc, content: contentPreview };
           }
           return { ...doc, content: "" };
@@ -10574,10 +10573,10 @@ var ResourceContext = class {
    * Retrieves and decodes the primary representation
    */
   static async getResourceContent(resource, kb) {
-    const primaryRep = getPrimaryRepresentation(resource);
-    if (primaryRep?.checksum && primaryRep?.mediaType) {
-      const contentBuffer = await kb.content.retrieve(primaryRep.checksum, primaryRep.mediaType);
-      return decodeRepresentation(contentBuffer, primaryRep.mediaType);
+    if (resource.storageUri) {
+      const contentBuffer = await kb.content.retrieve(resource.storageUri);
+      const primaryRep = getPrimaryRepresentation(resource);
+      return decodeRepresentation(contentBuffer, primaryRep?.mediaType ?? "text/plain");
     }
     return void 0;
   }
@@ -10644,12 +10643,12 @@ var AnnotationContext = class {
     }
     let sourceContext;
     if (includeSourceContext) {
-      const primaryRep = getPrimaryRepresentation2(sourceDoc);
-      if (!primaryRep?.checksum || !primaryRep?.mediaType) {
-        throw new Error("Source content not found");
+      if (!sourceDoc.storageUri) {
+        throw new Error("Source content not found: no storageUri");
       }
-      const sourceContent = await kb.content.retrieve(primaryRep.checksum, primaryRep.mediaType);
-      const contentStr = decodeRepresentation2(sourceContent, primaryRep.mediaType);
+      const primaryRep = getPrimaryRepresentation2(sourceDoc);
+      const sourceContent = await kb.content.retrieve(sourceDoc.storageUri);
+      const contentStr = decodeRepresentation2(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 });
@@ -10685,10 +10684,10 @@ var AnnotationContext = class {
     }
     let targetContext;
     if (includeTargetContext && targetDoc) {
-      const targetRep = getPrimaryRepresentation2(targetDoc);
-      if (targetRep?.checksum && targetRep?.mediaType) {
-        const targetContent = await kb.content.retrieve(targetRep.checksum, targetRep.mediaType);
-        const contentStr = decodeRepresentation2(targetContent, targetRep.mediaType);
+      if (targetDoc.storageUri) {
+        const targetRep = getPrimaryRepresentation2(targetDoc);
+        const targetContent = await kb.content.retrieve(targetDoc.storageUri);
+        const contentStr = decodeRepresentation2(targetContent, targetRep?.mediaType ?? "text/plain");
         targetContext = {
           content: contentStr.slice(0, contextWindow * 2),
           summary: inferenceClient ? await generateResourceSummary(targetDoc.name, contentStr, getResourceEntityTypes(targetDoc), inferenceClient) : void 0
@@ -10989,13 +10988,13 @@ Summary:`;
   /**
    * Get resource content as string
    */
-  static async getResourceContent(resource, repStore) {
-    const primaryRep = getPrimaryRepresentation2(resource);
-    if (!primaryRep?.checksum || !primaryRep?.mediaType) {
-      throw new Error("Resource content not found");
+  static async getResourceContent(resource, content) {
+    if (!resource.storageUri) {
+      throw new Error("Resource content not found: no storageUri");
     }
-    const content = await repStore.retrieve(primaryRep.checksum, primaryRep.mediaType);
-    return decodeRepresentation2(content, primaryRep.mediaType);
+    const primaryRep = getPrimaryRepresentation2(resource);
+    const buf = await content.retrieve(resource.storageUri);
+    return decodeRepresentation2(buf, primaryRep?.mediaType ?? "text/plain");
   }
   /**
    * Extract annotation context from resource content
@@ -11882,7 +11881,10 @@ No explanations.`;
 // src/stower.ts
 var import_rxjs5 = __toESM(require_cjs(), 1);
 var import_operators5 = __toESM(require_operators(), 1);
+import { promises as fs3 } from "fs";
 import { resourceId as resourceId3, annotationId as makeAnnotationId3, CREATION_METHODS, generateUuid } from "@semiont/core";
+import { resolveStorageUri } from "@semiont/event-sourcing";
+import { getExtensionForMimeType } from "@semiont/content";
 var Stower = class {
   constructor(kb, eventBus, logger) {
     this.kb = kb;
@@ -11896,6 +11898,8 @@ var Stower = class {
     const pipe = (event, handler) => this.eventBus.get(event).pipe((0, import_operators5.concatMap)((e) => (0, import_rxjs5.from)(handler(e))));
     this.subscription = (0, import_rxjs5.merge)(
       pipe("yield:create", (e) => this.handleYieldCreate(e)),
+      pipe("yield:update", (e) => this.handleYieldUpdate(e)),
+      pipe("yield:mv", (e) => this.handleYieldMv(e)),
       pipe("mark:create", (e) => this.handleMarkCreate(e)),
       pipe("mark:delete", (e) => this.handleMarkDelete(e)),
       pipe("mark:update-body", (e) => this.handleMarkUpdateBody(e)),
@@ -11917,11 +11921,21 @@ var Stower = class {
   async handleYieldCreate(event) {
     try {
       const rId = resourceId3(generateUuid());
-      const storedRep = await this.kb.content.store(event.content, {
-        mediaType: event.format,
-        language: event.language || void 0,
-        rel: "original"
-      });
+      let checksum;
+      let byteSize;
+      const resolvedStorageUri = event.storageUri ?? deriveStorageUri(event.name, event.format);
+      if (event.content !== void 0) {
+        const stored = await this.kb.content.store(event.content, resolvedStorageUri, { noGit: event.noGit });
+        checksum = stored.checksum;
+        byteSize = stored.byteSize;
+      } else {
+        if (!event.storageUri) {
+          throw new Error("yield:create without content requires storageUri");
+        }
+        const stored = await this.kb.content.register(resolvedStorageUri, event.contentChecksum, { noGit: event.noGit });
+        checksum = stored.checksum;
+        byteSize = stored.byteSize;
+      }
       const validCreationMethods = Object.values(CREATION_METHODS);
       const validatedCreationMethod = event.creationMethod && validCreationMethods.includes(event.creationMethod) ? event.creationMethod : CREATION_METHODS.API;
       await this.kb.eventStore.appendEvent({
@@ -11932,8 +11946,9 @@ var Stower = class {
         payload: {
           name: event.name,
           format: event.format,
-          contentChecksum: storedRep.checksum,
-          contentByteSize: storedRep.byteSize,
+          contentChecksum: checksum,
+          contentByteSize: byteSize,
+          storageUri: resolvedStorageUri,
           creationMethod: validatedCreationMethod,
           entityTypes: event.entityTypes || [],
           language: event.language || void 0,
@@ -11949,14 +11964,16 @@ var Stower = class {
         archived: false,
         entityTypes: event.entityTypes || [],
         creationMethod: validatedCreationMethod,
+        storageUri: event.storageUri,
+        currentChecksum: checksum,
         dateCreated: (/* @__PURE__ */ new Date()).toISOString(),
         representations: [
           {
-            mediaType: storedRep.mediaType,
-            checksum: storedRep.checksum,
-            byteSize: storedRep.byteSize,
+            mediaType: event.format,
+            checksum,
+            byteSize,
             rel: "original",
-            language: storedRep.language
+            language: event.language
           }
         ]
       };
@@ -11968,6 +11985,69 @@ var Stower = class {
       });
     }
   }
+  async handleYieldUpdate(event) {
+    try {
+      let byteSize;
+      if (event.content) {
+        const stored = await this.kb.content.store(event.content, event.storageUri, { noGit: event.noGit });
+        byteSize = stored.byteSize;
+      } else {
+        const stored = await this.kb.content.register(event.storageUri, event.contentChecksum, { noGit: event.noGit });
+        byteSize = stored.byteSize;
+      }
+      await this.kb.eventStore.appendEvent({
+        type: "resource.updated",
+        resourceId: event.resourceId,
+        userId: event.userId,
+        version: 1,
+        payload: {
+          contentChecksum: event.contentChecksum,
+          contentByteSize: byteSize
+        }
+      });
+      this.eventBus.get("yield:updated").next({ resourceId: event.resourceId });
+    } catch (error) {
+      this.logger.error("Failed to update resource", { error });
+      this.eventBus.get("yield:update-failed").next({
+        resourceId: event.resourceId,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
+  async handleYieldMv(event) {
+    let rId;
+    try {
+      const resolved = await resolveStorageUri(this.kb.projectionsDir, event.fromUri);
+      rId = resolved;
+    } catch (error) {
+      this.logger.error("Failed to resolve resource for move", { fromUri: event.fromUri, error });
+      this.eventBus.get("yield:move-failed").next({
+        fromUri: event.fromUri,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      return;
+    }
+    try {
+      await this.kb.content.move(event.fromUri, event.toUri, { noGit: event.noGit });
+      await this.kb.eventStore.appendEvent({
+        type: "resource.moved",
+        resourceId: rId,
+        userId: event.userId,
+        version: 1,
+        payload: {
+          fromUri: event.fromUri,
+          toUri: event.toUri
+        }
+      });
+      this.eventBus.get("yield:moved").next({ resourceId: rId });
+    } catch (error) {
+      this.logger.error("Failed to move resource", { error });
+      this.eventBus.get("yield:move-failed").next({
+        fromUri: event.fromUri,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+    }
+  }
   async handleMarkCreate(event) {
     try {
       this.logger.debug("Stowing annotation", { annotationId: event.annotation.id });
@@ -12027,6 +12107,9 @@ var Stower = class {
     if (!event || typeof event !== "object" || !("userId" in event) || !("resourceId" in event) || !event.resourceId) {
       return;
     }
+    if (event.storageUri) {
+      await this.kb.content.remove(event.storageUri, { keepFile: event.keepFile, noGit: event.noGit });
+    }
     await this.kb.eventStore.appendEvent({
       type: "resource.archived",
       resourceId: event.resourceId,
@@ -12039,6 +12122,15 @@ var Stower = class {
     if (!event || typeof event !== "object" || !("userId" in event) || !("resourceId" in event) || !event.resourceId) {
       return;
     }
+    if (event.storageUri) {
+      const absPath = this.kb.content.resolveUri(event.storageUri);
+      try {
+        await fs3.access(absPath);
+      } catch {
+        this.logger.warn("Unarchive failed: file not found at storageUri", { storageUri: event.storageUri });
+        return;
+      }
+    }
     await this.kb.eventStore.appendEvent({
       type: "resource.unarchived",
       resourceId: event.resourceId,
@@ -12140,6 +12232,11 @@ var Stower = class {
     this.logger.info("Stower actor stopped");
   }
 };
+function deriveStorageUri(name, format) {
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  const ext = getExtensionForMimeType(format);
+  return `file://${slug}${ext}`;
+}
 
 // src/clone-token-manager.ts
 var import_rxjs7 = __toESM(require_cjs(), 1);
@@ -12175,7 +12272,8 @@ var ResourceOperations = class {
       userId: userId2,
       language: input.language,
       entityTypes: input.entityTypes,
-      creationMethod: input.creationMethod
+      creationMethod: input.creationMethod,
+      storageUri: input.storageUri
     });
     const outcome = await (0, import_rxjs6.firstValueFrom)(result$);
     if (!outcome.ok) {
@@ -12243,8 +12341,7 @@ var CloneTokenManager = class {
         });
         return;
       }
-      const primaryRep = getPrimaryRepresentation3(resource);
-      if (!primaryRep?.checksum || !primaryRep?.mediaType) {
+      if (!resource.storageUri) {
         this.eventBus.get("yield:clone-token-failed").next({
           correlationId: event.correlationId,
           error: new Error("Resource content not found")
@@ -12252,7 +12349,7 @@ var CloneTokenManager = class {
         return;
       }
       try {
-        await this.kb.content.retrieve(primaryRep.checksum, primaryRep.mediaType);
+        await this.kb.content.retrieve(resource.storageUri);
       } catch {
         this.eventBus.get("yield:clone-token-failed").next({
           correlationId: event.correlationId,
@@ -12444,7 +12541,7 @@ async function startMakeMeaning(project, config, eventBus, logger) {
     error: (err) => jobQueueLogger.error("Job status pipeline error", { error: err })
   });
   const eventStoreLogger = logger.child({ component: "event-store" });
-  const eventStore = createEventStoreCore(project, void 0, eventBus, eventStoreLogger);
+  const eventStore = createEventStoreCore(project, eventBus, eventStoreLogger);
   const gathererInferenceClient = createInferenceClient(
     resolveActorInference(config, "gatherer"),
     logger.child({ component: "inference-client-gatherer" })
@@ -12493,10 +12590,8 @@ async function startMakeMeaning(project, config, eventBus, logger) {
   await cloneTokenManager.initialize();
   const contentFetcher = async (resourceId4) => {
     const view = await kb.views.get(resourceId4);
-    if (!view) return null;
-    const primaryRep = getPrimaryRepresentation4(view.resource);
-    if (!primaryRep?.checksum || !primaryRep?.mediaType) return null;
-    const buffer = await kb.content.retrieve(primaryRep.checksum, primaryRep.mediaType);
+    if (!view?.resource.storageUri) return null;
+    const buffer = await kb.content.retrieve(view.resource.storageUri);
     if (!buffer) return null;
     return Readable.from([buffer]);
   };
@@ -12567,7 +12662,7 @@ async function startMakeMeaning(project, config, eventBus, logger) {
 }
 
 // src/exchange/backup-exporter.ts
-import { getExtensionForMimeType } from "@semiont/content";
+import { getExtensionForMimeType as getExtensionForMimeType2 } from "@semiont/content";
 
 // src/exchange/tar.ts
 import { createGzip, createGunzip } from "zlib";
@@ -12691,10 +12786,10 @@ async function exportBackup(options, output) {
   });
   const contentBlobs = /* @__PURE__ */ new Map();
   let totalContentBytes = 0;
-  for (const [checksum, mediaType] of contentRefs) {
-    const data = await content.retrieve(checksum, mediaType);
-    const ext = getExtensionForMimeType(mediaType);
-    contentBlobs.set(checksum, { data, ext });
+  for (const [storageUri, mediaType] of contentRefs) {
+    const data = await content.retrieve(storageUri);
+    const ext = getExtensionForMimeType2(mediaType);
+    contentBlobs.set(storageUri, { data, ext });
     totalContentBytes += data.length;
   }
   const streamSummaries = [];
@@ -12729,8 +12824,9 @@ async function exportBackup(options, output) {
       const jsonl = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
       yield { name: fileName, data: Buffer.from(jsonl, "utf8") };
     }
-    for (const [checksum, { data, ext }] of contentBlobs) {
-      yield { name: `${checksum}${ext}`, data };
+    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);
@@ -12748,8 +12844,8 @@ function collectContentRefs(streamData) {
     for (const stored of events) {
       if (stored.event.type === "resource.created") {
         const payload = stored.event.payload;
-        if (payload.contentChecksum && payload.format) {
-          refs.set(payload.contentChecksum, payload.format);
+        if (payload.storageUri && payload.format) {
+          refs.set(payload.storageUri, payload.format);
         }
       }
     }
@@ -13054,7 +13150,7 @@ function mergeStats(a, b) {
 }
 
 // src/exchange/linked-data-exporter.ts
-import { getExtensionForMimeType as getExtensionForMimeType2 } from "@semiont/content";
+import { getExtensionForMimeType as getExtensionForMimeType3 } from "@semiont/content";
 var SEMIONT_CONTEXT = [
   "https://schema.org/",
   "http://www.w3.org/ns/anno.jsonld",
@@ -13118,13 +13214,13 @@ async function exportLinkedData(options, output) {
     collectContentRefsFromResource(view.resource, contentRefs);
   }
   const contentBlobs = /* @__PURE__ */ new Map();
-  for (const [checksum, mediaType] of contentRefs) {
+  for (const [storageUri, mediaType] of contentRefs) {
     try {
-      const data = await content.retrieve(checksum, mediaType);
-      const ext = getExtensionForMimeType2(mediaType);
-      contentBlobs.set(checksum, { data, ext });
+      const data = await content.retrieve(storageUri);
+      const ext = getExtensionForMimeType3(mediaType);
+      contentBlobs.set(storageUri, { data, ext });
     } catch (err) {
-      logger?.warn("Failed to retrieve content blob", { checksum, mediaType, error: String(err) });
+      logger?.warn("Failed to retrieve content blob", { storageUri, error: String(err) });
     }
   }
   const manifest = {
@@ -13153,8 +13249,9 @@ async function exportLinkedData(options, output) {
         data: Buffer.from(JSON.stringify(jsonld, null, 2), "utf8")
       };
     }
-    for (const [checksum, { data, ext }] of contentBlobs) {
-      yield { name: `${checksum}${ext}`, data };
+    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);
@@ -13200,7 +13297,7 @@ function buildResourceJsonLd(resource, annotations, sourceUrl) {
       if (rep.checksum) {
         const rawChecksum = rep.checksum.startsWith("sha256:") ? rep.checksum.slice(7) : rep.checksum;
         mediaObj["sha256"] = rawChecksum;
-        const ext = getExtensionForMimeType2(rep.mediaType);
+        const ext = getExtensionForMimeType3(rep.mediaType);
         mediaObj["name"] = `${rawChecksum}${ext}`;
       }
       if (rep.language) mediaObj["inLanguage"] = rep.language;
@@ -13218,12 +13315,10 @@ function normalizeRepresentations(reps) {
   return [reps];
 }
 function collectContentRefsFromResource(resource, refs) {
-  const reps = normalizeRepresentations(resource.representations);
-  for (const rep of reps) {
-    if (rep.checksum && rep.mediaType) {
-      const rawChecksum = rep.checksum.startsWith("sha256:") ? rep.checksum.slice(7) : rep.checksum;
-      refs.set(rawChecksum, rep.mediaType);
-    }
+  if (resource.storageUri) {
+    const reps = normalizeRepresentations(resource.representations);
+    const mediaType = reps[0]?.mediaType ?? "application/octet-stream";
+    refs.set(resource.storageUri, mediaType);
   }
 }