@bitefoundry/retrieviewer 0.0.19 → 0.0.20

package/NATIVE-RUNTIME.md

@@ -1,4 +1,4 @@
-# Lightweight desktop runtime · 0.0.19
+# Lightweight desktop runtime · 0.0.20
 
 Windows x64 basic desktop mode runs the existing JavaScript pet behavior in
 QuickJS-NG, inside the same native process that paints the transparent window.
@@ -41,15 +41,14 @@ play/treat/attention or tower/wheel actions. No forced GC or working-set trimmin
 
 | Pet | Median RSS | Sampled maximum | OS lifetime peak |
 |---|---:|---:|---:|
-| Retriever |22.6MiB|35.3MiB|36.5MiB|
-| Ginger cat with tower/wheel |29.5MiB|34.6MiB|39.1MiB|
+| Retriever |22.9MiB|37.9MiB|38.7MiB|
+| Ginger cat with tower/wheel |44.4MiB|64.6MiB|65.5MiB|
 
-Version0.0.19 uses up to8 disjoint cell-aligned paint regions inside the same
-process, reclaiming oversized/hidden surfaces. The preceding0.0.18 final run
-had medians29.4/44.2MiB and OS peaks40.3/65.4MiB for dog/cat respectively.
-See [sparse surface measurements](SPARSE-PAINT.md) for the matching workloads,
-pixel comparisons and CPU tradeoff. This is not a universal50MiB memory cap.
-Raw local evidence: dist/sparse-paint-memory/{dog,cat,report}.json.
+Version 0.0.20 uses one cropped layered window for the complete scene. This
+fixes flicker from the 0.0.19 multi-window painter; its lower memory figures are
+superseded. Buffer shrinking and hidden-state cleanup remain. See the
+[presentation fix](SPARSE-PAINT.md). These finite measurements do not establish
+a universal 50 MiB memory cap. Raw evidence: dist/coherent-paint-memory/.
 
 ## Scope
 
@@ -88,8 +87,9 @@ The executable embeds the Windows UTF-8 process code-page manifest (Windows10
 1903+ /11) so QuickJS stdio also reads Korean/non-ASCII installation paths.
 A regression test launches both species from Korean bundle, art and state paths.
 
-## Sparse paint surfaces
+## Coherent scene presentation
 
-[Sparse paint regions](SPARSE-PAINT.md) preserve final masks while reducing
-empty bitmap space. Their HWNDs remain click-through and non-activating; no
-extra pet process, runtime dependency or animation asset is introduced.
+[One complete-scene upload](SPARSE-PAINT.md) keeps the final pet, props and
+furniture in the same HWND. That window stays click-through and non-activating.
+The 128-frame presentation regression checks window identity, full-frame pixel
+parity and hidden-resource release separately from pet-core pixel parity.

package/PUPPY-MEMORY.md

@@ -1,3 +1,17 @@
+# 0.0.20 coherent scene painter
+
+The complete scene now updates through one native layered window to fix the
+0.0.19 flicker regression. Buffer shrinking, hidden-state release, stamp atlas
+and indexed art loading remain; no art or pet behavior changed. Distant cat
+furniture can enlarge the one bounding surface. The 0.0.19 figures below are
+historical and must not describe the current version. See
+[presentation evidence](SPARSE-PAINT.md) and [current measurements](NATIVE-RUNTIME.md).
+
+Real 4K 150s measurements: dog median22.9MiB / OS peak38.7MiB; cat with
+tower/wheel44.4 /65.5MiB. Watch/brain off, no forced GC/trim; not a hard cap.
+
+## Superseded 0.0.19 result (presentation regression)
+
 # 0.0.19 sparse painter result
 
 Windows x64 basic mode retains one native process and splits sparse content

package/README.ko.md

@@ -148,7 +148,13 @@ JS 플러그인과 JSONL 브리지를 제공해요. 화면·입력·시간 제
 AI로 생성한 그림에 자세 정렬·접지·프레임 처리를 적용한 애니메이션입니다.
 실제 모션 캡처나 자의식이 있는 강아지라고 주장하지 않아요.
 
-## 0.0.19
+## 0.0.20
+
+Windows에서 화면 일부가 깜빡이던 문제를 고쳤어요. 장면 전체를 창 하나로
+갱신하고, 버퍼 축소와 숨김 상태 정리는 유지합니다. 그림과 동작은 그대로예요.
+[수정과 측정 기록](SPARSE-PAINT.md)을 참고하세요.
+
+## 0.0.19 (이전 버전 · 깜빡임 수정으로 대체)
 
 Windows 기본 실행에서 표시 영역을 나누고 불필요하게 커진 버퍼를 회수해요.
 그림과 동작은 그대로예요. 실제4K150초 측정에서 강아지는 중앙값22.6MiB·최고36.5MiB,

package/README.md

@@ -189,7 +189,14 @@ The puppy artwork was developed with AI-generated imagery and programmatic pose,
 grounding and frame processing. It is authored animation, not motion capture or
 a claim of sentience.
 
-## 0.0.19
+## 0.0.20
+
+Fixes Windows flicker introduced by the split-window painter. The whole scene
+updates through one stable transparent window again; buffer shrinking and
+hidden-state cleanup remain. Artwork and behavior are unchanged.
+See [presentation fix and measurements](SPARSE-PAINT.md).
+
+## 0.0.19 (historical; superseded by flicker fix)
 
 Windows basic mode now splits distant content into small paint regions and
 reclaims oversized/hidden surfaces. Same pets, artwork and behavior. In real4K

package/RELEASING.md

@@ -1,4 +1,21 @@
-# Retrieviewer 0.0.19 release process
+# Retrieviewer 0.0.20 release process
+
+Current target: `@bitefoundry/retrieviewer@0.0.20`, public `latest`.
+Hotfix for the reported flicker in the previously authorized npm/site release.
+Replace the dynamically repartitioned HWNDs with one complete-scene layered
+window and one pixel/position/size upload. Keep stamp caching, indexed art,
+buffer shrinking and hidden-state release. Artwork and pet behavior are unchanged.
+
+Verify moving/disjoint masks keep one stable window, exact native paint pixels,
+resize/hide/restore/switch/teardown, full suite and fresh installed artifact.
+Publish that same tested tarball after CI, verify registry integrity and a fresh
+consumer, then confirm the matching bilingual website. Memory figures must
+come from this version, not the regressed sparse painter. Existing code/art
+licenses, optional integrations, user pet and privacy setup are preserved.
+
+## Previous 0.0.19 scope (historical; presentation regression)
+
+### Retrieviewer 0.0.19 release process
 
 Current target: `@bitefoundry/retrieviewer@0.0.19`, public `latest`.
 The owner explicitly authorized npm and website deployment on2026-10-25.

package/SPARSE-PAINT.md

@@ -1,3 +1,56 @@
+# Coherent native painting · 0.0.20
+
+The 0.0.19 sparse-window optimization is superseded. Per-frame pixel comparison
+passed, but a moving scene could change its partition and destroy/reposition
+multiple HWNDs at different compositor moments. The owner reported visible
+flicker. Preparing all DIBs first did not make those window updates atomic.
+
+Version 0.0.20 paints the complete final mask into one cropped layered window.
+`UpdateLayeredWindow` uploads all pixels, position and size together. The same
+HWND survives movement and crop changes. Visibility is changed only when first
+shown; there is no extra per-frame `SetWindowPos` after upload. No animal assets,
+anatomy, motion, Braille masks or optional integrations changed.
+
+The 256-mask stamp atlas and one-process QuickJS host remain. Capacity still
+shrinks when it exceeds twice the rounded target area; hidden/minimized scenes
+release their surface and window. The tradeoff is one bounding bitmap spanning
+distant furniture: memory can exceed the regressed split-painter measurements.
+Those old numbers below must not be presented as current measurements.
+
+## Verification
+
+- Real Win32 presentation regression: 128 changing/disjoint scenes retain one
+  visible HWND, with exact full-scene BGRA pixels; hidden resources release.
+- Native mask/capacity tests: 56 grids across seven cell sizes.
+- Real moving dog/cream, cat/gold and cat/dark: 301 exact paint comparisons.
+- Owned 4K -> small -> 4K, minimize/restore and same-process species switching.
+  DIB capacity shrank from 12.22 to 1.50 MiB and reached zero when minimized.
+
+Reproduce with `node --test native-desktop.test.mjs`,
+`node tools/check-native-paint.mjs` and `node tools/check-native-resources.mjs`.
+This checks actual window lifetime and upload coherence as well as image bytes;
+finite pixel/lifetime checks are not a claim that every display was observed.
+
+## Current memory measurement
+
+Same Windows x64 host, owned off-screen 3840x2160 target, real native painter,
+seed731 and 150s action schedule, 300 roughly half-second samples per pet
+(157.5/156.9s wall time). Watch/brain off; no forced GC or working-set trim.
+Harness and external DWM/GPU allocations are excluded.
+
+| Pet | Median RSS | Sampled maximum | OS lifetime peak |
+|---|---:|---:|---:|
+| Retriever |22.9MiB|37.9MiB|38.7MiB|
+| Cat with tower/wheel |44.4MiB|64.6MiB|65.5MiB|
+
+Cat furniture spans a large bounding bitmap again. This restores coherent
+presentation at a higher RAM cost than 0.0.19; it is not a universal 50MiB cap.
+Both owned processes stopped and removed their sessions. Raw local evidence:
+`dist/coherent-paint-memory/{dog,cat,report}.json`. Full suite:244 passed,
+two macOS-only tests skipped on Windows. No artwork or motion change.
+
+## Superseded 0.0.19 experiment (historical)
+
 # Sparse Windows paint surfaces · 0.0.19
 
 Version0.0.19 builds on0.0.18. JavaScript behavior, Q5 art, world/contact math, colors and

package/integrations/native-windows/host.cpp

@@ -75,6 +75,7 @@ static JSValue blit(JSContext* c,JSValueConst,int argc,JSValueConst* a){try{
 int wmain(int argc,wchar_t** wideArgs){
  std::vector<std::string> argText;for(int i=0;i<argc;i++){int n=WideCharToMultiByte(CP_UTF8,0,wideArgs[i],-1,nullptr,0,nullptr,nullptr);std::string value(n,0);WideCharToMultiByte(CP_UTF8,0,wideArgs[i],-1,value.data(),n,nullptr,nullptr);value.pop_back();argText.push_back(value);}std::vector<char*> args;for(auto& text:argText)args.push_back(text.data());char** argv=args.data();
  if(argc==2&&std::string(argv[1])=="--self-test-regions")try{return NativePet::selfTestPaintRegions();}catch(const std::exception& e){fprintf(stderr,"%s\n",e.what());return 1;}
+ if(argc==2&&std::string(argv[1])=="--self-test-presentation")try{return NativePet::selfTestPaintPresentation();}catch(const std::exception& e){fprintf(stderr,"%s\n",e.what());return 1;}
  bool production=false;for(int i=1;i<argc;i++)if(std::string(argv[i])=="--production")production=true;std::string configuration;
  if(production){char ch;while(std::cin.get(ch)&&ch!='\n'){if(configuration.size()>=8192)return 2;configuration+=ch;}if(configuration.empty())return 2;}
  if(argc<2)return 2;JSRuntime* rt=JS_NewRuntime();js_std_init_handlers(rt);JSContext* ctx=JS_NewContext(rt);JS_SetModuleLoaderFunc2(rt,nullptr,js_module_loader,js_module_check_attributes,nullptr);js_init_module_std(ctx,"qjs:std");js_init_module_os(ctx,"qjs:os");js_std_add_helpers(ctx,argc-1,argv+1);

package/integrations/native-windows/manifest.json

@@ -7,8 +7,8 @@
       "sha256": "e9da942dbe57ac778c44ea8f300e2e868face5e73b00ffcd4399aeb7e94ee09c"
     },
     "bin/win32-x64/retrieviewer-native.exe": {
-      "bytes": 1564672,
-      "sha256": "288150c7112c50214996174250ce71bfa4ffc91779c8ea899a47d85f4fef71dd"
+      "bytes": 1562624,
+      "sha256": "0844d0e5303938e11d3e57acb457d7f6df2f138ee84246ecdf006395055f0fba"
     }
   }
 }

package/integrations/native-windows/native-paint.hpp

@@ -46,7 +46,7 @@ static void verifyPaint(const std::vector<uint8_t>& masks,int columns,const PetP
   static const int dx[]={0,0,0,1,1,1,0,1},dy[]={0,1,2,0,1,2,3,3};float step=cell/2.f,diameter=std::max(1.1f,step*.48f);
   for(int y=all.top;y<all.bottom;y++)for(int x=all.left;x<all.right;x++){int mask=masks[(size_t)y*columns+x];for(int bit=0;bit<8;bit++)if(mask&(1<<bit)){float px=(x-all.left)*cell+(dx[bit]+.5f)*step,py=(y-all.top)*cell*2+(dy[bit]+.5f)*step;g.FillEllipse(&brush,px-diameter/2,py-diameter/2,diameter,diameter);}}g.Flush(Gdiplus::FlushIntentionSync);
  }
- if(reference!=assemble(all,cell))throw std::runtime_error("Partitioned dots changed pixels");verifiedPaints++;
+ if(reference!=assemble(all,cell))throw std::runtime_error("Native dots changed pixels");verifiedPaints++;
  if(!atlasVerified){printf("{\"stage\":\"dot-atlas-verified\",\"pixelExact\":true,\"regions\":%zu}\n",paintCount());fflush(stdout);}atlasVerified=true;
 }
 static void paint(const std::string& text,int columns,int rows,int cell,POINT canvas){
@@ -66,10 +66,11 @@ static void paint(const std::string& text,int columns,int rows,int cell,POINT ca
  for(size_t i=regions.size();i<panels.size();i++)panels[i].release();
  if(verifyAtlas&&(!atlasVerified||verifyEveryPaint))verifyPaint(masks,columns,all,cell);
  if(saveProof&&!proofSaved){const int w=all.width()*cell,h=all.height()*cell*2;auto image=assemble(all,cell);Gdiplus::Bitmap source(w,h,w*4,PixelFormat32bppPARGB,image.data()),proof(w,h,PixelFormat32bppARGB);Gdiplus::Graphics pg(&proof);pg.Clear(Gdiplus::Color(255,0,0,0));pg.DrawImage(&source,Gdiplus::Rect(0,0,w,h),0,0,w,h,Gdiplus::UnitPixel);pg.Flush(Gdiplus::FlushIntentionSync);CLSID png={0x557cf406,0x1a04,0x11d3,{0x9a,0x73,0x00,0x00,0xf8,0x1e,0xf3,0x2e}};if(proof.Save(wide(proofPath).c_str(),&png,nullptr)!=Gdiplus::Ok)throw std::runtime_error("PNG proof failed");proofSaved=true;}
- // Prepare every region before uploading any. The disjoint cell boundaries
- // neither duplicate alpha nor clip a glyph; all share the same source frame.
+ // The complete scene (pet, ball and furniture) has exactly one HWND.
+ // UpdateLayeredWindow changes its pixels, size and position in one call.
+ // Do not add another per-frame SetWindowPos/show: it exposes separate state.
  HDC screen=GetDC(nullptr);BLENDFUNCTION blend={AC_SRC_OVER,0,255,AC_SRC_ALPHA};POINT origin={0,0};
- for(size_t i=0;i<regions.size();i++){auto& p=panels[i];POINT destination={canvas.x+p.crop.left*cell,canvas.y+p.crop.top*cell*2};SIZE size={p.crop.width()*cell,p.crop.height()*cell*2};BOOL ok=UpdateLayeredWindow(p.window,screen,&destination,&size,p.surface.dc,&origin,0,&blend,ULW_ALPHA);if(!ok){ReleaseDC(nullptr,screen);throw std::runtime_error("Native layered update");}SetWindowPos(p.window,HWND_TOPMOST,destination.x,destination.y,size.cx,size.cy,SWP_NOACTIVATE|SWP_SHOWWINDOW);}
+ for(size_t i=0;i<regions.size();i++){auto& p=panels[i];POINT destination={canvas.x+p.crop.left*cell,canvas.y+p.crop.top*cell*2};SIZE size={p.crop.width()*cell,p.crop.height()*cell*2};BOOL ok=UpdateLayeredWindow(p.window,screen,&destination,&size,p.surface.dc,&origin,0,&blend,ULW_ALPHA);if(!ok){ReleaseDC(nullptr,screen);throw std::runtime_error("Native layered update");}if(!IsWindowVisible(p.window))ShowWindow(p.window,SW_SHOWNOACTIVATE);}
  ReleaseDC(nullptr,screen);painted++;
 }
 static int selfTestPaintRegions(){
@@ -77,10 +78,39 @@ static int selfTestPaintRegions(){
  for(int cell:{6,8,10,12,16,24,32})for(int type=0;type<8;type++){
   const int cols=type==7?1000:240,rows=type==7?125:90;std::vector<uint8_t> masks((size_t)cols*rows);
   for(int y=0;y<rows;y++)for(int x=0;x<cols;x++){bool on=type==1||type==2&&x%61==0||type==3&&y%31==0||type==4&&(x<20||x>cols-30)&&y>10||type==5&&(next()%100<4)||type==6&&((x-cols/2)*(x-cols/2)+(y-rows/2)*(y-rows/2)<900)||type==7&&x%97<3&&y%17<2;if(on)masks[(size_t)y*cols+x]=(uint8_t)(1+next()%255);}
-  const auto regions=PetPaint::partition(masks,cols,rows,cell);if(regions.size()>PetPaint::MaxRegions)throw std::runtime_error("Region count overflow");std::vector<uint8_t> seen(masks.size(),0);PetPaint::Rect all;uint64_t bytes=0;
+  const auto regions=PetPaint::partition(masks,cols,rows,cell);if(regions.size()>PetPaint::MaxRegions)throw std::runtime_error("Non-atomic scene partition");std::vector<uint8_t> seen(masks.size(),0);PetPaint::Rect all;uint64_t bytes=0;
   for(const auto& r:regions){if(r.empty()||r.left<0||r.top<0||r.right>cols||r.bottom>rows)throw std::runtime_error("Region outside grid");all.include(r);bytes+=PetPaint::bytes(r,cell);for(int y=r.top;y<r.bottom;y++)for(int x=r.left;x<r.right;x++)if(++seen[(size_t)y*cols+x]!=1)throw std::runtime_error("Overlapping paint regions");}
   for(size_t i=0;i<masks.size();i++)if(masks[i]&&seen[i]!=1)throw std::runtime_error("Missing mask cell");if(bytes>PetPaint::bytes(all,cell))throw std::runtime_error("Partition grew allocation");checks++;
  }
  Surface s;s.ensure(2048,1024);const auto big=s.bytes();s.ensure(1800,900);if(s.bytes()!=big)throw std::runtime_error("Surface churn on small size change");s.ensure(96,64);if(s.bytes()>(uint64_t)128*64*4*2)throw std::runtime_error("Surface did not shrink");s.release();if(s.bytes()!=0)throw std::runtime_error("Surface did not release");
  printf("{\"passed\":true,\"partitionCases\":%zu,\"coverageAndDisjointness\":true,\"surfaceShrink\":true}\n",checks);return 0;
 }
+
+// Real Win32 regression: moving/disjoint masks must retain one display window.
+// Byte equality alone did not catch the multi-HWND presentation regression.
+static int selfTestPaintPresentation(){
+ Gdiplus::GdiplusStartupInput input;ULONG_PTR token=0;
+ if(Gdiplus::GdiplusStartup(&token,&input,nullptr)!=Gdiplus::Ok)throw std::runtime_error("Presentation GDI+ startup");
+ WNDCLASS wc{};wc.lpfnWndProc=DefWindowProc;wc.hInstance=GetModuleHandle(nullptr);wc.lpszClassName=L"RetrieviewerNativeDots";RegisterClass(&wc);
+ const int columns=240,rows=90,cell=8;HWND first=nullptr;size_t checked=0;
+ verifyAtlas=verifyEveryPaint=atlasVerified=true;
+ try{
+  for(int frame=0;frame<128;frame++){
+   std::string text;
+   for(int y=0;y<rows;y++){if(y)text+='\n';for(int x=0;x<columns;x++){
+    bool pet=x>=20+frame%81&&x<55+frame%81&&y>=20&&y<65;
+    bool object=frame%3!=0&&x>=200-frame%13&&x<210-frame%13&&y>=5&&y<30;
+    unsigned ch=0x2800+(pet||object?1+(x+y+frame)%255:0);
+    text+=(char)(0xe0|(ch>>12));text+=(char)(0x80|((ch>>6)&63));text+=(char)(0x80|(ch&63));
+   }}
+   paint(text,columns,rows,cell,POINT{-12000,-12000});
+   if(paintCount()!=1||!IsWindowVisible(panels[0].window))throw std::runtime_error("Scene lost coherent visible window");
+   if(!first)first=panels[0].window;
+   if(panels[0].window!=first)throw std::runtime_error("Moving scene recreated its display window");
+   checked++;
+  }
+  hidePanels();if(paintCount()!=0||paintBytes()!=0)throw std::runtime_error("Hidden scene retained paint resources");
+ }catch(...){releasePanels();atlas.pixels.clear();Gdiplus::GdiplusShutdown(token);throw;}
+ atlas.pixels.clear();Gdiplus::GdiplusShutdown(token);
+ printf("{\"passed\":true,\"frames\":%zu,\"singleWindow\":true,\"stableWindow\":true,\"pixelExact\":true,\"hiddenResourcesReleased\":true}\n",checked);return 0;
+}

package/integrations/native-windows/paint-regions.hpp

@@ -5,9 +5,10 @@
 #include <stdexcept>
 #include <vector>
 
-// Cell-aligned, non-overlapping crops of the FINAL mask. No animal/layer redraw.
+// One final-mask crop and one layered-window upload per scene. Separate HWNDs
+// cannot present a repartitioned frame atomically, even with identical pixels.
 namespace PetPaint {
-constexpr size_t MaxRegions=8;
+constexpr size_t MaxRegions=1;
 struct Rect {
  int left=std::numeric_limits<int>::max(),top=std::numeric_limits<int>::max();
  int right=0,bottom=0;
@@ -19,37 +20,9 @@ struct Rect {
 };
 inline int rounded(int n){return (n+63)/64*64;}
 inline uint64_t bytes(const Rect& r,int cell){return r.empty()?0:(uint64_t)rounded(r.width()*cell)*rounded(r.height()*cell*2)*4;}
-struct Split {Rect box,a,b;uint64_t saved=0;};
-inline Split bestSplit(const std::vector<uint8_t>& masks,int columns,const Rect& box,int cell){
- Split result;result.box=box;const auto parent=bytes(box,cell);
- for(bool horizontal:{false,true}){
-  const int n=horizontal?box.height():box.width();std::vector<Rect> bins(n),suffix(n+1);
-  for(int y=box.top;y<box.bottom;y++)for(int x=box.left;x<box.right;x++)
-   if(masks[(size_t)y*columns+x])bins[horizontal?y-box.top:x-box.left].include(x,y);
-  for(int i=n-1;i>=0;i--){suffix[i]=suffix[i+1];suffix[i].include(bins[i]);}
-  Rect prefix;
-  for(int i=0;i+1<n;i++){
-   prefix.include(bins[i]);const Rect& other=suffix[i+1];if(prefix.empty()||other.empty())continue;
-   const auto cost=bytes(prefix,cell)+bytes(other,cell);
-   if(cost<parent&&parent-cost>result.saved){result.saved=parent-cost;result.a=prefix;result.b=other;}
-  }
- }
- return result;
-}
 inline std::vector<Rect> partition(const std::vector<uint8_t>& masks,int columns,int rows,int cell){
  if(columns<1||rows<1||(uint64_t)columns*rows>125000||masks.size()!=(size_t)columns*rows||cell<6||cell>32)throw std::runtime_error("Invalid paint mask grid");
  Rect all;for(int y=0;y<rows;y++)for(int x=0;x<columns;x++)if(masks[(size_t)y*columns+x])all.include(x,y);
- if(all.empty())return {};
- std::vector<Split> nodes{bestSplit(masks,columns,all,cell)};
- // A new HWND must save meaningful surface space, not split every fur fleck.
- constexpr uint64_t MinimumSaving=256*1024;
- while(nodes.size()<MaxRegions){
-  size_t best=0;for(size_t i=1;i<nodes.size();i++)if(nodes[i].saved>nodes[best].saved)best=i;
-  if(nodes[best].saved<MinimumSaving)break;
-  const auto selected=nodes[best];nodes[best]=bestSplit(masks,columns,selected.a,cell);
-  nodes.push_back(bestSplit(masks,columns,selected.b,cell));
- }
- std::vector<Rect> result;for(const auto& node:nodes)result.push_back(node.box);
- return result;
+ return all.empty()?std::vector<Rect>{}:std::vector<Rect>{all};
 }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bitefoundry/retrieviewer",
-  "version": "0.0.19",
+  "version": "0.0.20",
   "description": "A fluffy Braille desktop pet for Windows and Linux X11, with experimental macOS support and an embeddable TUI engine.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://bitefoundry.github.io/retrieviewer/",