bugfix and new internal API

internal/storage/cid_resolution.go

@@ -462,39 +462,15 @@ func (c *Client) GetMetadataDocument(uuid string) (*MetadataDocument, error) {
 	}, nil
 }
 
-// lookupSidecarPathByCID is the fallback that LookupPathByCID falls into
-// when the token isn't a known root alias. Used to resolve poster/backdrop
-// CIDs, which are stored as values pointing at sidecar files (posterPath /
-// backdropPath) rather than registered as aliases of the file itself.
+// lookupSidecarPathByCID — REMOVED.
 //
-// O(n) — walks every root. Acceptable because (a) sidecar lookups are rare
-// vs. file CID lookups and (b) the alternative is registering sidecars in
-// the reverse index, which conflates "this CID is the file" with "this CID
-// is an image associated with the file."
-func (c *Client) lookupSidecarPathByCID(token string) (string, error) {
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	hashIDs, err := c.getAllHashIDsInternal(ctx)
-	if err != nil {
-		return "", err
-	}
-
-	for _, hashID := range hashIDs {
-		meta, err := c.getMetadataFlatInternal(ctx, hashID)
-		if err != nil || len(meta) == 0 {
-			continue
-		}
-		if meta["poster"] == token {
-			if p := meta["posterPath"]; p != "" {
-				return normalizeFilesRelativePath(p), nil
-			}
-		}
-		if meta["backdrop"] == token {
-			if p := meta["backdropPath"]; p != "" {
-				return normalizeFilesRelativePath(p), nil
-			}
-		}
-	}
-	return "", nil
-}
+// This function used to walk every metadata entry looking for poster/backdrop
+// matches and return their `posterPath`/`backdropPath` companion fields. It
+// was a workaround for plugin output (TMDB images, etc.) not being indexed
+// by the watcher.
+//
+// Now that the plugin output directory is a first-class watcher root
+// (see config.DefaultWatcherPaths), every plugin artefact has its own
+// midhash256 alias and resolves through the standard reverse index. Storing
+// paths in metadata broke the CID-as-identity contract; the watcher
+// indexing fixes the root cause.

internal/storage/client.go

@@ -347,33 +347,40 @@ func (c *Client) CountFiles() (int, error) {
 	return len(hashIDs), nil
 }
 
-// LookupPathByCID resolves a CID to its file path on disk.
+// LookupPathByCID resolves a CID to its file path on disk via the reverse
+// index. O(1) lookup followed by a single GET of file:<uuid>/filePath.
 //
-// Primary path: the reverse index (cid:<token> → uuid). O(1) lookup followed
-// by a single GET of file:<uuid>/filePath.
+// Accepts both prefixed tokens ("midhash256:bafk…", "sha256:…",
+// "ipfs:bafy…") and bare midhash256 CIDs — the bare form is what the
+// editor passes to /api/file/{cid}/info because that's how plugins
+// write the value (e.g. `backdrop=<bare-cid>`). For bare tokens we
+// try the midhash256 prefix as a fallback.
 //
-// Fallback path: poster/backdrop CIDs aren't registered as aliases (they
-// refer to sidecar images, not the main file content), so unknown tokens
-// fall through to a scan of poster/backdrop fields. O(n) but rare in
-// practice — sidecar lookups are infrequent compared to file CID lookups.
-//
-// Accepts CID tokens in prefixed form ("midhash256:bafk…", "sha256:…",
-// "ipfs:bafy…"). Bare CIDs without an algorithm prefix won't resolve via
-// the reverse index — callers should pass the prefixed form.
+// Plugin output (TMDB posters/backdrops, extracted subtitles, etc.) is
+// resolved through this same path: the plugin output directory is a
+// watcher root (see config.DefaultWatcherPaths), so every plugin
+// artefact gets a midhash256 alias and resolves through the reverse
+// index like any other file. There is no path-companion sidecar field.
 func (c *Client) LookupPathByCID(token string) (string, error) {
 	uuid, err := c.GetByCID(token)
 	if err != nil {
 		return "", err
 	}
-	if uuid != "" {
-		fp, err := c.GetProperty(uuid, "filePath")
+	if uuid == "" && !strings.Contains(token, ":") {
+		// Bare CID — most likely a midhash256 written by a plugin.
+		uuid, err = c.GetByCID("midhash256:" + token)
 		if err != nil {
 			return "", err
 		}
-		return normalizeFilesRelativePath(fp), nil
 	}
-	// Not a file alias — try poster/backdrop sidecars.
-	return c.lookupSidecarPathByCID(token)
+	if uuid == "" {
+		return "", nil
+	}
+	fp, err := c.GetProperty(uuid, "filePath")
+	if err != nil {
+		return "", err
+	}
+	return normalizeFilesRelativePath(fp), nil
 }
 
 // normalizeFilesRelativePath strips a leading "/files/" prefix so handlers can