@graffiti-garden/api 0.2.7 → 0.2.8

package/dist/tests.mjs

@@ -1,2 +1,1457 @@
-import{it as z,expect as C,describe as L}from"vitest";import{GraffitiErrorInvalidUri as J}from"@graffiti-garden/api";import{assert as N}from"vitest";function u(){let h=new Uint8Array(16);return crypto.getRandomValues(h),Array.from(h).map(q=>q.toString(16).padStart(2,"0")).join("")+"\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FF}"}function F(){return{[u()]:u()}}function w(){return{value:F(),channels:[u(),u()]}}async function y(h){let p=await h.next();return N(!p.done&&!p.value.error,"result has no value"),p.value.value}var st=h=>{L("URI and location conversion",()=>{z("location to uri and back",async()=>{let p=h(),q={name:u(),actor:u(),source:u()},t=p.locationToUri(q),o=p.uriToLocation(t);C(q).toEqual(o)}),z("collision resistance",async()=>{let p=h(),q={name:u(),actor:u(),source:u()};for(let t of["name","actor","source"]){let o={...q,[t]:u()},e=p.locationToUri(q),a=p.locationToUri(o);C(e).not.toEqual(a)}}),z("random URI should not be a valid location",async()=>{let p=h();C(()=>p.uriToLocation("")).toThrow(J)})})};import{it as x,expect as d,describe as $}from"vitest";import{GraffitiErrorNotFound as O,GraffitiErrorSchemaMismatch as K,GraffitiErrorInvalidSchema as Q,GraffitiErrorForbidden as S,GraffitiErrorPatchTestFailed as W,GraffitiErrorPatchError as R}from"@graffiti-garden/api";var ut=(h,p,q)=>{$("CRUD",{timeout:2e4},()=>{x("put, get, delete",async()=>{let t=h(),o=p(),e={something:"hello, world~ c:"},a=[u(),u()],n=await t.put({value:e,channels:a},o);d(n.value).toEqual({}),d(n.channels).toEqual([]),d(n.allowed).toBeUndefined(),d(n.actor).toEqual(o.actor);let r=await t.get(n,{});d(r.value).toEqual(e),d(r.channels).toEqual([]),d(r.allowed).toBeUndefined(),d(r.name).toEqual(n.name),d(r.actor).toEqual(n.actor),d(r.source).toEqual(n.source),d(r.lastModified).toEqual(n.lastModified);let s={something:"goodbye, world~ :c"},l=await t.put({...n,value:s,channels:[]},o);d(l.value).toEqual(e),d(l.tombstone).toEqual(!0),d(l.name).toEqual(n.name),d(l.actor).toEqual(n.actor),d(l.source).toEqual(n.source),d(l.lastModified).toBeGreaterThan(r.lastModified);let i=await t.get(n,{});d(i.value).toEqual(s),d(i.lastModified).toEqual(l.lastModified),d(i.tombstone).toEqual(!1);let m=await t.delete(i,o);d(m.tombstone).toEqual(!0),d(m.value).toEqual(s),d(m.lastModified).toBeGreaterThan(l.lastModified);let f=await t.get(i,{});d(f).toEqual(m)}),x("get non-existant",async()=>{let t=h(),o=p(),e=await t.put(w(),o);await d(t.get({...e,name:u()},{})).rejects.toBeInstanceOf(O)}),x("put, get, delete with wrong actor",async()=>{let t=h(),o=p(),e=q();await d(t.put({value:{},channels:[],actor:e.actor},o)).rejects.toThrow(S);let a=await t.put({value:{},channels:[]},e);await d(t.delete(a,o)).rejects.toThrow(S),await d(t.patch({},a,o)).rejects.toThrow(S)}),x("put and get with schema",async()=>{let t=h(),o=p(),e={properties:{value:{properties:{something:{type:"string"},another:{type:"integer"}}}}},a={something:"hello",another:42},n=await t.put({value:a,channels:[]},o),r=await t.get(n,e);d(r.value.something).toEqual(a.something),d(r.value.another).toEqual(a.another)}),x("put and get with invalid schema",async()=>{let t=h(),o=p(),e=await t.put({value:{},channels:[]},o);await d(t.get(e,{properties:{value:{type:"asdf"}}})).rejects.toThrow(Q)}),x("put and get with wrong schema",async()=>{let t=h(),o=p(),e=await t.put({value:{hello:"world"},channels:[]},o);await d(t.get(e,{properties:{value:{properties:{hello:{type:"number"}}}}})).rejects.toThrow(K)}),x("put and get with empty access control",async()=>{let t=h(),o=p(),e=q(),a={um:"hi"},n=[u()],r=[u()],s=await t.put({value:a,allowed:n,channels:r},o),l=await t.get(s,{},o);d(l.value).toEqual(a),d(l.allowed).toEqual(n),d(l.channels).toEqual(r),await d(t.get(s,{})).rejects.toBeInstanceOf(O),await d(t.get(s,{},e)).rejects.toBeInstanceOf(O)}),x("put and get with specific access control",async()=>{let t=h(),o=p(),e=q(),a={um:"hi"},n=[u(),e.actor,u()],r=[u()],s=await t.put({value:a,allowed:n,channels:r},o),l=await t.get(s,{},o);d(l.value).toEqual(a),d(l.allowed).toEqual(n),d(l.channels).toEqual(r),await d(t.get(s,{})).rejects.toBeInstanceOf(O);let i=await t.get(s,{},e);d(i.value).toEqual(a),d(i.allowed).toEqual([e.actor]),d(i.channels).toEqual([])}),x("patch value",async()=>{let t=h(),o=p(),e={something:"hello, world~ c:"},a=await t.put({value:e,channels:[]},o),n={value:[{op:"replace",path:"/something",value:"goodbye, world~ :c"}]},r=await t.patch(n,a,o);d(r.value).toEqual(e),d(r.tombstone).toBe(!0);let s=await t.get(a,{});d(s.value).toEqual({something:"goodbye, world~ :c"}),d(r.lastModified).toBe(s.lastModified),await t.delete(a,o)}),x("patch deleted object",async()=>{let t=h(),o=p(),e=await t.put(w(),o),a=await t.delete(e,o);await d(t.patch({},e,o)).rejects.toBeInstanceOf(O)}),x("deep patch",async()=>{let t=h(),o=p(),e={something:{another:{somethingElse:"hello"}}},a=await t.put({value:e,channels:[]},o),n=await t.patch({value:[{op:"replace",path:"/something/another/somethingElse",value:"goodbye"}]},a,o),r=await t.get(a,{});d(n.value).toEqual(e),d(r.value).toEqual({something:{another:{somethingElse:"goodbye"}}})}),x("patch channels",async()=>{let t=h(),o=p(),e=[u()],a=[u()],n=await t.put({value:{},channels:e},o),r={channels:[{op:"replace",path:"/0",value:a[0]}]},s=await t.patch(r,n,o);d(s.channels).toEqual(e);let l=await t.get(n,{},o);d(l.channels).toEqual(a),await t.delete(n,o)}),x("patch 'increment' with test",async()=>{let t=h(),o=p(),e=await t.put({value:{counter:1},channels:[]},o),a=await t.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:2}]},e,o);d(a.value).toEqual({counter:1});let n=await t.get(a,{properties:{value:{properties:{counter:{type:"integer"}}}}});d(n.value.counter).toEqual(2),await d(t.patch({value:[{op:"test",path:"/counter",value:1},{op:"replace",path:"/counter",value:3}]},e,o)).rejects.toThrow(W)}),x("invalid patch",async()=>{let t=h(),o=p(),e=w(),a=await t.put(e,o);await d(t.patch({value:[{op:"add",path:"/root",value:[]},{op:"add",path:"/root/2",value:2}]},a,o)).rejects.toThrow(R)}),x("patch channels to be wrong",async()=>{let t=h(),o=p(),e=w();e.allowed=[u()];let a=await t.put(e,o),n=[{channels:[{op:"replace",path:"",value:null}]},{channels:[{op:"replace",path:"",value:{}}]},{channels:[{op:"replace",path:"",value:["hello",["hi"]]}]},{channels:[{op:"add",path:"/0",value:1}]},{value:[{op:"replace",path:"",value:"not an object"}]},{value:[{op:"replace",path:"",value:null}]},{value:[{op:"replace",path:"",value:[]}]},{allowed:[{op:"replace",path:"",value:{}}]},{allowed:[{op:"replace",path:"",value:["hello",["hi"]]}]}];for(let s of n)await d(t.patch(s,a,o)).rejects.toThrow(R);let r=await t.get(a,{},o);d(r.value).toEqual(e.value),d(r.channels).toEqual(e.channels),d(r.allowed).toEqual(e.allowed),d(r.lastModified).toEqual(a.lastModified)})})};import{it as I,expect as v,describe as D,assert as H}from"vitest";var vt=(h,p,q)=>{D("synchronizeDiscover",()=>{I("get",async()=>{let t=h(),o=p(),e=w(),a=e.channels.slice(1),n=await t.put(e,o),r=h(),s=r.synchronizeDiscover(a,{}).next(),l=await r.get(n,{},o),i=(await s).value;if(!i||i.error)throw new Error("Error in synchronize");v(i.value.value).toEqual(e.value),v(i.value.channels).toEqual(a),v(i.value.tombstone).toBe(!1),v(i.value.lastModified).toEqual(l.lastModified)}),I("put",async()=>{let t=h(),o=p(),e=u(),a=u(),n=u(),r={hello:"world"},s=[e,n],l=await t.put({value:r,channels:s},o),i=t.synchronizeDiscover([e],{}).next(),m=t.synchronizeDiscover([a],{}).next(),f=t.synchronizeDiscover([n],{}).next(),g={goodbye:"world"},E=[a,n];await t.put({...l,value:g,channels:E},o);let b=(await i).value,B=(await m).value,j=(await f).value;if(!b||b.error||!B||B.error||!j||j.error)throw new Error("Error in synchronize");v(b.value.value).toEqual(r),v(b.value.channels).toEqual([e]),v(b.value.tombstone).toBe(!0),v(B.value.value).toEqual(g),v(B.value.channels).toEqual([a]),v(B.value.tombstone).toBe(!1),v(j.value.value).toEqual(g),v(j.value.channels).toEqual([n]),v(j.value.tombstone).toBe(!1),v(b.value.lastModified).toEqual(B.value.lastModified),v(j.value.lastModified).toEqual(B.value.lastModified)}),I("patch",async()=>{let t=h(),o=p(),e=u(),a=u(),n=u(),r={hello:"world"},s=[e,n],l=await t.put({value:r,channels:s},o),i=t.synchronizeDiscover([e],{}).next(),m=t.synchronizeDiscover([a],{}).next(),f=t.synchronizeDiscover([n],{}).next();await t.patch({value:[{op:"add",path:"/something",value:"new value"}],channels:[{op:"add",path:"/-",value:a},{op:"remove",path:`/${s.indexOf(e)}`}]},l,o);let g=(await i).value,E=(await m).value,b=(await f).value;if(!g||g.error||!E||E.error||!b||b.error)throw new Error("Error in synchronize");let B={...r,something:"new value"},j=[n,a];v(g.value.value).toEqual(r),v(g.value.channels).toEqual([e]),v(g.value.tombstone).toBe(!0),v(E.value.value).toEqual(B),v(E.value.channels).toEqual([a]),v(E.value.tombstone).toBe(!1),v(b.value.value).toEqual(B),v(b.value.channels).toEqual([n]),v(b.value.tombstone).toBe(!1),v(g.value.lastModified).toEqual(E.value.lastModified),v(b.value.lastModified).toEqual(E.value.lastModified)}),I("delete",async()=>{let t=h(),o=p(),e=[u(),u(),u()],a={hello:"world"},n=[u(),...e.slice(1)],r=await t.put({value:a,channels:n},o),s=t.synchronizeDiscover(e,{}).next();t.delete(r,o);let l=(await s).value;if(!l||l.error)throw new Error("Error in synchronize");v(l.value.tombstone).toBe(!0),v(l.value.value).toEqual(a),v(l.value.channels).toEqual(e.filter(i=>n.includes(i)))}),I("not allowed",async()=>{let t=h(),o=p(),e=q(),a=[u(),u(),u()],n=a.slice(1),r=t.synchronizeDiscover(n,{},o).next(),s=t.synchronizeDiscover(n,{},e).next(),l=t.synchronizeDiscover(n,{}).next(),i={hello:"world"},m=[u(),e.actor];await t.put({value:i,channels:a,allowed:m},o),await v(Promise.race([l,new Promise((E,b)=>setTimeout(b,100,"Timeout"))])).rejects.toThrow("Timeout");let f=(await r).value,g=(await s).value;if(!f||f.error||!g||g.error)throw new Error("Error in synchronize");v(f.value.value).toEqual(i),v(f.value.allowed).toEqual(m),v(f.value.channels).toEqual(a),v(g.value.value).toEqual(i),v(g.value.allowed).toEqual([e.actor]),v(g.value.channels).toEqual(n)})}),D("synchronizeGet",()=>{I("replace, delete",async()=>{let t=h(),o=p(),e=w(),a=await t.put(e,o),n=t.synchronizeGet(a,{}),r=n.next(),s={goodbye:"world"},l=await t.put({...a,value:s},o),i=(await r).value;H(i&&!i.error),v(i.value.value).toEqual(s),v(i.value.actor).toEqual(o.actor),v(i.value.channels).toEqual([]),v(i.value.tombstone).toBe(!1),v(i.value.lastModified).toEqual(l.lastModified),v(i.value.allowed).toBeUndefined();let m=await t.delete(l,o),f=(await n.next()).value;H(f&&!f.error),v(f.value.tombstone).toBe(!0),v(f.value.lastModified).toEqual(m.lastModified),await t.put(w(),o),await v(Promise.race([n.next(),new Promise((g,E)=>setTimeout(E,100,"Timeout"))])).rejects.toThrow("Timeout")}),I("not allowed",async()=>{let t=h(),o=p(),e=q(),a=w(),n=await t.put(a,o),r=t.synchronizeGet(n,{},o),s=t.synchronizeGet(n,{},e),l=r.next(),i=s.next(),m={goodbye:"world"},f=await t.put({...n,...a,allowed:[],value:m},o),g=(await l).value,E=(await i).value;H(g&&!g.error),H(E&&!E.error),v(g.value.value).toEqual(m),v(E.value.value).toEqual(a.value),v(g.value.actor).toEqual(o.actor),v(E.value.actor).toEqual(o.actor),v(g.value.channels).toEqual(a.channels),v(E.value.channels).toEqual([]),v(g.value.tombstone).toBe(!1),v(E.value.tombstone).toBe(!0),v(g.value.lastModified).toEqual(f.lastModified),v(E.value.lastModified).toEqual(f.lastModified)})})};import{it as M,expect as c,describe as X,assert as U}from"vitest";var gt=(h,p,q)=>{X("discover",{timeout:2e4},()=>{M("discover nothing",async()=>{let o=h().discover([],{});c(await o.next()).toHaveProperty("done",!0)}),M("discover single",async()=>{let t=h(),o=p(),e=w(),a=await t.put(e,o),n=[u(),e.channels[0]],r=t.discover(n,{}),s=await y(r);c(s.value).toEqual(e.value),c(s.channels).toEqual([e.channels[0]]),c(s.allowed).toBeUndefined(),c(s.actor).toEqual(o.actor),c(s.tombstone).toBe(!1),c(s.lastModified).toEqual(a.lastModified);let l=await r.next();c(l.done).toBe(!0)}),M("discover wrong channel",async()=>{let t=h(),o=p(),e=w();await t.put(e,o);let a=t.discover([u()],{});await c(a.next()).resolves.toHaveProperty("done",!0)}),M("discover not allowed",async()=>{let t=h(),o=p(),e=q(),a=w();a.allowed=[u(),u()];let n=await t.put(a,o),r=t.discover(a.channels,{},o),s=await y(r);c(s.value).toEqual(a.value),c(s.channels).toEqual(a.channels),c(s.allowed).toEqual(a.allowed),c(s.actor).toEqual(o.actor),c(s.tombstone).toBe(!1),c(s.lastModified).toEqual(n.lastModified);let l=t.discover(a.channels,{},e);c(await l.next()).toHaveProperty("done",!0);let i=t.discover(a.channels,{});c(await i.next()).toHaveProperty("done",!0)}),M("discover allowed",async()=>{let t=h(),o=p(),e=q(),a=w();a.allowed=[u(),e.actor,u()];let n=await t.put(a,o),r=t.discover(a.channels,{},e),s=await y(r);c(s.value).toEqual(a.value),c(s.allowed).toEqual([e.actor]),c(s.channels).toEqual(a.channels),c(s.actor).toEqual(o.actor),c(s.tombstone).toBe(!1),c(s.lastModified).toEqual(n.lastModified)});for(let t of["name","actor","lastModified"])M(`discover for ${t}`,async()=>{let o=h(),e=p(),a=q(),n=w(),r=await o.put(n,e),s=w();s.channels=n.channels,await new Promise(f=>setTimeout(f,20));let l=await o.put(s,a),i=o.discover(n.channels,{properties:{[t]:{enum:[r[t]]}}}),m=await y(i);c(m.name).toEqual(r.name),c(m.name).not.toEqual(l.name),c(m.value).toEqual(n.value),await c(i.next()).resolves.toHaveProperty("done",!0)});M("discover with lastModified range",async()=>{let t=h(),o=p(),e=w(),a=await t.put(e,o);await new Promise(G=>setTimeout(G,20));let n=await t.put(e,o);c(a.name).not.toEqual(n.name),c(a.lastModified).toBeLessThan(n.lastModified);let r=t.discover([e.channels[0]],{properties:{lastModified:{minimum:n.lastModified,exclusiveMinimum:!0}}});c(await r.next()).toHaveProperty("done",!0);let s=t.discover([e.channels[0]],{properties:{lastModified:{minimum:n.lastModified-.1,exclusiveMinimum:!0}}}),l=await y(s);c(l.name).toEqual(n.name),c(await s.next()).toHaveProperty("done",!0);let i=t.discover(e.channels,{properties:{value:{},lastModified:{minimum:n.lastModified}}}),m=await y(i);c(m.name).toEqual(n.name),c(await i.next()).toHaveProperty("done",!0);let f=t.discover(e.channels,{properties:{lastModified:{minimum:n.lastModified+.1}}});c(await f.next()).toHaveProperty("done",!0);let g=t.discover(e.channels,{properties:{lastModified:{maximum:a.lastModified,exclusiveMaximum:!0}}});c(await g.next()).toHaveProperty("done",!0);let E=t.discover(e.channels,{properties:{lastModified:{maximum:a.lastModified+.1,exclusiveMaximum:!0}}}),b=await y(E);c(b.name).toEqual(a.name),c(await E.next()).toHaveProperty("done",!0);let B=t.discover(e.channels,{properties:{lastModified:{maximum:a.lastModified}}}),j=await y(B);c(j.name).toEqual(a.name),c(await B.next()).toHaveProperty("done",!0);let A=t.discover(e.channels,{properties:{lastModified:{maximum:a.lastModified-.1}}});c(await A.next()).toHaveProperty("done",!0)}),M("discover schema allowed, as and not as owner",async()=>{let t=h(),o=p(),e=q(),a=w();a.allowed=[u(),e.actor,u()],await t.put(a,o);let n=t.discover(a.channels,{properties:{allowed:{minItems:3,not:{items:{not:{enum:[e.actor]}}}}}},o),r=await y(n);c(r.value).toEqual(a.value),await c(n.next()).resolves.toHaveProperty("done",!0);let s=t.discover(a.channels,{properties:{allowed:{minItems:3}}},e);await c(s.next()).resolves.toHaveProperty("done",!0);let l=t.discover(a.channels,{properties:{allowed:{not:{items:{not:{enum:[a.channels[0]]}}}}}},e);await c(l.next()).resolves.toHaveProperty("done",!0);let i=t.discover(a.channels,{properties:{allowed:{maxItems:1,not:{items:{not:{enum:[e.actor]}}}}}},e),m=await y(i);c(m.value).toEqual(a.value),await c(i.next()).resolves.toHaveProperty("done",!0)}),M("discover schema channels, as and not as owner",async()=>{let t=h(),o=p(),e=q(),a=w();a.channels=[u(),u(),u()],await t.put(a,o);let n=t.discover([a.channels[0],a.channels[2]],{properties:{channels:{minItems:3,not:{items:{not:{enum:[a.channels[1]]}}}}}},o),r=await y(n);c(r.value).toEqual(a.value),await c(n.next()).resolves.toHaveProperty("done",!0);let s=t.discover([a.channels[0],a.channels[2]],{properties:{channels:{minItems:3}}},e);await c(s.next()).resolves.toHaveProperty("done",!0);let l=t.discover([a.channels[0],a.channels[2]],{properties:{channels:{not:{items:{not:{enum:[a.channels[1]]}}}}}},e);await c(l.next()).resolves.toHaveProperty("done",!0);let i=t.discover([a.channels[0],a.channels[2]],{properties:{allowed:{maxItems:2,not:{items:{not:{enum:[a.channels[2]]}}}}}},e),m=await y(i);c(m.value).toEqual(a.value),await c(i.next()).resolves.toHaveProperty("done",!0)}),M("discover query for empty allowed",async()=>{let t=h(),o=p(),e=w(),a={not:{required:["allowed"]}};await t.put(e,o);let n=t.discover(e.channels,a,o),r=await y(n);c(r.value).toEqual(e.value),c(r.allowed).toBeUndefined(),await c(n.next()).resolves.toHaveProperty("done",!0);let s=w();s.allowed=[],await t.put(s,o);let l=t.discover(s.channels,a,o);await c(l.next()).resolves.toHaveProperty("done",!0)}),M("discover query for values",async()=>{let t=h(),o=p(),e=w();e.value={test:u()},await t.put(e,o);let a=w();a.channels=e.channels,a.value={test:u(),something:u()},await t.put(a,o);let n=w();n.channels=e.channels,n.value={other:u(),something:u()},await t.put(n,o);let r=new Map;for(let s of["test","something","other"]){let l=0;for await(let i of t.discover(e.channels,{properties:{value:{required:[s]}}}))U(!i.error,"result has error"),s in i.value.value&&l++;r.set(s,l)}c(r.get("test")).toBe(2),c(r.get("something")).toBe(2),c(r.get("other")).toBe(1)}),M("discover for deleted content",async()=>{let t=h(),o=p(),e=w(),a=await t.put(e,o),n=await t.delete(a,o),r=t.discover(e.channels,{}),s=await y(r);c(s.tombstone).toBe(!0),c(s.value).toEqual(e.value),c(s.channels).toEqual(e.channels),c(s.actor).toEqual(o.actor),c(s.lastModified).toEqual(n.lastModified),await c(r.next()).resolves.toHaveProperty("done",!0)}),M("discover for replaced channels",async()=>{for(let t=0;t<10;t++){let o=h(),e=p(),a=w(),n=await o.put(a,e),r=w(),s=await o.put({...n,...r},e),l=o.discover(a.channels,{}),i=await y(l);await c(l.next()).resolves.toHaveProperty("done",!0);let m=o.discover(r.channels,{}),f=await y(m);await c(m.next()).resolves.toHaveProperty("done",!0),n.lastModified===s.lastModified?(c(i.tombstone||f.tombstone).toBe(!0),c(i.tombstone&&f.tombstone).toBe(!1)):(c(i.tombstone).toBe(!0),c(i.value).toEqual(a.value),c(i.channels).toEqual(a.channels),c(i.lastModified).toEqual(s.lastModified),c(f.tombstone).toBe(!1),c(f.value).toEqual(r.value),c(f.channels).toEqual(r.channels),c(f.lastModified).toEqual(s.lastModified))}}),M("discover for patched allowed",async()=>{let t=h(),o=p(),e=w(),a=await t.put(e,o);await t.patch({allowed:[{op:"add",path:"",value:[]}]},a,o);let n=t.discover(e.channels,{}),r=await y(n);c(r.tombstone).toBe(!0),c(r.value).toEqual(e.value),c(r.channels).toEqual(e.channels),c(r.allowed).toBeUndefined(),await c(n.next()).resolves.toHaveProperty("done",!0)}),M("put concurrently and discover one",async()=>{let t=h(),o=p(),e=w();e.name=u();let a=Array(100).fill(0).map(()=>t.put(e,o));await Promise.all(a);let n=t.discover(e.channels,{}),r=0,s=0;for await(let l of n)U(!l.error,"result has error"),l.value.tombstone?r++:s++;c(r).toBe(99),c(s).toBe(1)})})};import{it as V,expect as T,describe as Y}from"vitest";var xt=(h,p,q)=>{Y("recoverOrphans",()=>{V("list orphans",async()=>{let t=h(),o=p(),e=[],a=t.recoverOrphans({},o);for await(let i of a)i.error||e.push(i.value.name);let n=w();n.channels=[];let r=await t.put(n,o),s=t.recoverOrphans({},o),l=0;for await(let i of s)i.error||i.value.name===r.name&&(l++,T(i.value.source).toBe(r.source),T(i.value.lastModified).toBe(r.lastModified));T(l).toBe(1)}),V("replaced orphan, no longer",async()=>{let t=h(),o=p(),e=w();e.channels=[];let a=await t.put(e,o),n=await t.put({...a,...e,channels:[u()]},o);T(n.name).toBe(a.name);let r=t.recoverOrphans({},o),s=0;for await(let l of r)l.error||l.value.name===a.name&&(s++,T(l.value.tombstone).toBe(!0),T(l.value.lastModified).toBe(n.lastModified),T(l.value.channels).toEqual([]));T(s).toBe(1)})})};import{it as k,expect as P,describe as Z,assert as _}from"vitest";var Tt=(h,p,q)=>{Z("channel stats",()=>{k("list channels",async()=>{let t=h(),o=p(),e=new Map,a=t.channelStats(o);for await(let l of a)l.error||e.set(l.value.channel,l.value.count);let n=[u(),u(),u()];for(let l=0;l<3;l++)for(let i=0;i<l+1;i++)await t.put({value:{index:i},channels:n.slice(0,l+1)},o);await t.put({value:{index:3},channels:[n[2]]},o);let r=t.channelStats(o),s=new Map;for await(let l of r)l.error||s.set(l.value.channel,l.value.count);s=new Map(Array.from(s).filter(([l,i])=>!e.has(l))),P(s.size).toBe(3),P(s.get(n[0])).toBe(6),P(s.get(n[1])).toBe(5),P(s.get(n[2])).toBe(4)}),k("list channels with deleted channel",async()=>{let t=h(),o=p(),e=[u(),u(),u()],a=await t.put({value:{index:2},channels:e.slice(1)},o),n=await t.put({value:{index:0},channels:e},o);await t.delete(n,o);let r=await t.put({value:{index:1},channels:e.slice(2)},o),s=t.channelStats(o),l=0,i=0;for await(let m of s){if(m.error)continue;let{channel:f,count:g,lastModified:E}=m.value;_(f!==e[0],"There should not be an object in channel[0]"),f===e[1]?(P(g).toBe(1),P(E).toBe(a.lastModified),l++):f===e[2]&&(P(g).toBe(2),P(E).toBe(r.lastModified),i++)}P(l).toBe(1),P(i).toBe(1)})})};export{ut as graffitiCRUDTests,Tt as graffitiChannelStatsTests,gt as graffitiDiscoverTests,st as graffitiLocationTests,xt as graffitiOrphanTests,vt as graffitiSynchronizeTests};
+// tests/location.ts
+import { it, expect, describe } from "vitest";
+import { GraffitiErrorInvalidUri } from "@graffiti-garden/api";
+
+// tests/utils.ts
+import { assert } from "vitest";
+function randomString() {
+  const array = new Uint8Array(16);
+  crypto.getRandomValues(array);
+  const str = Array.from(array).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return str + "\u{1F469}\u{1F3FD}\u200D\u2764\uFE0F\u200D\u{1F48B}\u200D\u{1F469}\u{1F3FB}\u{1FAF1}\u{1F3FC}\u200D\u{1FAF2}\u{1F3FF}";
+}
+function randomValue() {
+  return {
+    [randomString()]: randomString()
+  };
+}
+function randomPutObject() {
+  return {
+    value: randomValue(),
+    channels: [randomString(), randomString()]
+  };
+}
+async function nextStreamValue(iterator) {
+  const result = await iterator.next();
+  assert(!result.done && !result.value.error, "result has no value");
+  return result.value.value;
+}
+
+// tests/location.ts
+var graffitiLocationTests = (useGraffiti) => {
+  describe.concurrent("URI and location conversion", () => {
+    it("location to uri and back", async () => {
+      const graffiti = useGraffiti();
+      const location = {
+        name: randomString(),
+        actor: randomString(),
+        source: randomString()
+      };
+      const uri = graffiti.locationToUri(location);
+      const location2 = graffiti.uriToLocation(uri);
+      expect(location).toEqual(location2);
+    });
+    it("collision resistance", async () => {
+      const graffiti = useGraffiti();
+      const location1 = {
+        name: randomString(),
+        actor: randomString(),
+        source: randomString()
+      };
+      for (const prop of ["name", "actor", "source"]) {
+        const location2 = { ...location1, [prop]: randomString() };
+        const uri1 = graffiti.locationToUri(location1);
+        const uri2 = graffiti.locationToUri(location2);
+        expect(uri1).not.toEqual(uri2);
+      }
+    });
+    it("random URI should not be a valid location", async () => {
+      const graffiti = useGraffiti();
+      expect(() => graffiti.uriToLocation("")).toThrow(GraffitiErrorInvalidUri);
+    });
+  });
+};
+
+// tests/crud.ts
+import { it as it2, expect as expect2, describe as describe2 } from "vitest";
+import {
+  GraffitiErrorNotFound,
+  GraffitiErrorSchemaMismatch,
+  GraffitiErrorInvalidSchema,
+  GraffitiErrorForbidden,
+  GraffitiErrorPatchTestFailed,
+  GraffitiErrorPatchError
+} from "@graffiti-garden/api";
+var graffitiCRUDTests = (useGraffiti, useSession1, useSession2) => {
+  describe2.concurrent(
+    "CRUD",
+    {
+      timeout: 2e4
+    },
+    () => {
+      it2("put, get, delete", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const value = {
+          something: "hello, world~ c:"
+        };
+        const channels = [randomString(), randomString()];
+        const previous = await graffiti.put({ value, channels }, session);
+        expect2(previous.value).toEqual({});
+        expect2(previous.channels).toEqual([]);
+        expect2(previous.allowed).toBeUndefined();
+        expect2(previous.actor).toEqual(session.actor);
+        const gotten = await graffiti.get(previous, {});
+        expect2(gotten.value).toEqual(value);
+        expect2(gotten.channels).toEqual([]);
+        expect2(gotten.allowed).toBeUndefined();
+        expect2(gotten.name).toEqual(previous.name);
+        expect2(gotten.actor).toEqual(previous.actor);
+        expect2(gotten.source).toEqual(previous.source);
+        expect2(gotten.lastModified).toEqual(previous.lastModified);
+        const newValue = {
+          something: "goodbye, world~ :c"
+        };
+        const beforeReplaced = await graffiti.put(
+          { ...previous, value: newValue, channels: [] },
+          session
+        );
+        expect2(beforeReplaced.value).toEqual(value);
+        expect2(beforeReplaced.tombstone).toEqual(true);
+        expect2(beforeReplaced.name).toEqual(previous.name);
+        expect2(beforeReplaced.actor).toEqual(previous.actor);
+        expect2(beforeReplaced.source).toEqual(previous.source);
+        expect2(beforeReplaced.lastModified).toBeGreaterThanOrEqual(
+          gotten.lastModified
+        );
+        const afterReplaced = await graffiti.get(previous, {});
+        expect2(afterReplaced.value).toEqual(newValue);
+        expect2(afterReplaced.lastModified).toEqual(beforeReplaced.lastModified);
+        expect2(afterReplaced.tombstone).toEqual(false);
+        const beforeDeleted = await graffiti.delete(afterReplaced, session);
+        expect2(beforeDeleted.tombstone).toEqual(true);
+        expect2(beforeDeleted.value).toEqual(newValue);
+        expect2(beforeDeleted.lastModified).toBeGreaterThanOrEqual(
+          beforeReplaced.lastModified
+        );
+        const final = await graffiti.get(afterReplaced, {});
+        expect2(final).toEqual(beforeDeleted);
+      });
+      it2("get non-existant", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const putted = await graffiti.put(randomPutObject(), session);
+        await expect2(
+          graffiti.get(
+            {
+              ...putted,
+              name: randomString()
+            },
+            {}
+          )
+        ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
+      });
+      it2("put, get, delete with wrong actor", async () => {
+        const graffiti = useGraffiti();
+        const session1 = useSession1();
+        const session2 = useSession2();
+        await expect2(
+          graffiti.put(
+            { value: {}, channels: [], actor: session2.actor },
+            session1
+          )
+        ).rejects.toThrow(GraffitiErrorForbidden);
+        const putted = await graffiti.put(
+          { value: {}, channels: [] },
+          session2
+        );
+        await expect2(graffiti.delete(putted, session1)).rejects.toThrow(
+          GraffitiErrorForbidden
+        );
+        await expect2(graffiti.patch({}, putted, session1)).rejects.toThrow(
+          GraffitiErrorForbidden
+        );
+      });
+      it2("put and get with schema", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const schema = {
+          properties: {
+            value: {
+              properties: {
+                something: {
+                  type: "string"
+                },
+                another: {
+                  type: "integer"
+                }
+              }
+            }
+          }
+        };
+        const goodValue = {
+          something: "hello",
+          another: 42
+        };
+        const putted = await graffiti.put(
+          {
+            value: goodValue,
+            channels: []
+          },
+          session
+        );
+        const gotten = await graffiti.get(putted, schema);
+        expect2(gotten.value.something).toEqual(goodValue.something);
+        expect2(gotten.value.another).toEqual(goodValue.another);
+      });
+      it2("put and get with invalid schema", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const putted = await graffiti.put({ value: {}, channels: [] }, session);
+        await expect2(
+          graffiti.get(putted, {
+            properties: {
+              value: {
+                //@ts-ignore
+                type: "asdf"
+              }
+            }
+          })
+        ).rejects.toThrow(GraffitiErrorInvalidSchema);
+      });
+      it2("put and get with wrong schema", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const putted = await graffiti.put(
+          {
+            value: {
+              hello: "world"
+            },
+            channels: []
+          },
+          session
+        );
+        await expect2(
+          graffiti.get(putted, {
+            properties: {
+              value: {
+                properties: {
+                  hello: {
+                    type: "number"
+                  }
+                }
+              }
+            }
+          })
+        ).rejects.toThrow(GraffitiErrorSchemaMismatch);
+      });
+      it2("put and get with empty access control", async () => {
+        const graffiti = useGraffiti();
+        const session1 = useSession1();
+        const session2 = useSession2();
+        const value = {
+          um: "hi"
+        };
+        const allowed = [randomString()];
+        const channels = [randomString()];
+        const putted = await graffiti.put(
+          { value, allowed, channels },
+          session1
+        );
+        const gotten = await graffiti.get(putted, {}, session1);
+        expect2(gotten.value).toEqual(value);
+        expect2(gotten.allowed).toEqual(allowed);
+        expect2(gotten.channels).toEqual(channels);
+        await expect2(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+        await expect2(graffiti.get(putted, {}, session2)).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+      });
+      it2("put and get with specific access control", async () => {
+        const graffiti = useGraffiti();
+        const session1 = useSession1();
+        const session2 = useSession2();
+        const value = {
+          um: "hi"
+        };
+        const allowed = [randomString(), session2.actor, randomString()];
+        const channels = [randomString()];
+        const putted = await graffiti.put(
+          {
+            value,
+            allowed,
+            channels
+          },
+          session1
+        );
+        const gotten = await graffiti.get(putted, {}, session1);
+        expect2(gotten.value).toEqual(value);
+        expect2(gotten.allowed).toEqual(allowed);
+        expect2(gotten.channels).toEqual(channels);
+        await expect2(graffiti.get(putted, {})).rejects.toBeInstanceOf(
+          GraffitiErrorNotFound
+        );
+        const gotten2 = await graffiti.get(putted, {}, session2);
+        expect2(gotten2.value).toEqual(value);
+        expect2(gotten2.allowed).toEqual([session2.actor]);
+        expect2(gotten2.channels).toEqual([]);
+      });
+      it2("patch value", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const value = {
+          something: "hello, world~ c:"
+        };
+        const putted = await graffiti.put({ value, channels: [] }, session);
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const patch = {
+          value: [
+            { op: "replace", path: "/something", value: "goodbye, world~ :c" }
+          ]
+        };
+        const beforePatched = await graffiti.patch(patch, putted, session);
+        expect2(beforePatched.value).toEqual(value);
+        expect2(beforePatched.tombstone).toBe(true);
+        expect2(beforePatched.lastModified).toBeGreaterThan(putted.lastModified);
+        const gotten = await graffiti.get(putted, {});
+        expect2(gotten.value).toEqual({
+          something: "goodbye, world~ :c"
+        });
+        expect2(beforePatched.lastModified).toBe(gotten.lastModified);
+        await graffiti.delete(putted, session);
+      });
+      it2("patch deleted object", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const putted = await graffiti.put(randomPutObject(), session);
+        const deleted = await graffiti.delete(putted, session);
+        await expect2(
+          graffiti.patch({}, putted, session)
+        ).rejects.toBeInstanceOf(GraffitiErrorNotFound);
+      });
+      it2("deep patch", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const value = {
+          something: {
+            another: {
+              somethingElse: "hello"
+            }
+          }
+        };
+        const putted = await graffiti.put(
+          { value, channels: [] },
+          session
+        );
+        const beforePatch = await graffiti.patch(
+          {
+            value: [
+              {
+                op: "replace",
+                path: "/something/another/somethingElse",
+                value: "goodbye"
+              }
+            ]
+          },
+          putted,
+          session
+        );
+        const gotten = await graffiti.get(putted, {});
+        expect2(beforePatch.value).toEqual(value);
+        expect2(gotten.value).toEqual({
+          something: {
+            another: {
+              somethingElse: "goodbye"
+            }
+          }
+        });
+      });
+      it2("patch channels", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const channelsBefore = [randomString()];
+        const channelsAfter = [randomString()];
+        const putted = await graffiti.put(
+          { value: {}, channels: channelsBefore },
+          session
+        );
+        const patch = {
+          channels: [{ op: "replace", path: "/0", value: channelsAfter[0] }]
+        };
+        const patched = await graffiti.patch(patch, putted, session);
+        expect2(patched.channels).toEqual(channelsBefore);
+        const gotten = await graffiti.get(putted, {}, session);
+        expect2(gotten.channels).toEqual(channelsAfter);
+        await graffiti.delete(putted, session);
+      });
+      it2("patch 'increment' with test", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const putted = await graffiti.put(
+          {
+            value: {
+              counter: 1
+            },
+            channels: []
+          },
+          session
+        );
+        const previous = await graffiti.patch(
+          {
+            value: [
+              { op: "test", path: "/counter", value: 1 },
+              { op: "replace", path: "/counter", value: 2 }
+            ]
+          },
+          putted,
+          session
+        );
+        expect2(previous.value).toEqual({ counter: 1 });
+        const result = await graffiti.get(previous, {
+          properties: {
+            value: {
+              properties: {
+                counter: {
+                  type: "integer"
+                }
+              }
+            }
+          }
+        });
+        expect2(result.value.counter).toEqual(2);
+        await expect2(
+          graffiti.patch(
+            {
+              value: [
+                { op: "test", path: "/counter", value: 1 },
+                { op: "replace", path: "/counter", value: 3 }
+              ]
+            },
+            putted,
+            session
+          )
+        ).rejects.toThrow(GraffitiErrorPatchTestFailed);
+      });
+      it2("invalid patch", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const object = randomPutObject();
+        const putted = await graffiti.put(object, session);
+        await expect2(
+          graffiti.patch(
+            {
+              value: [
+                { op: "add", path: "/root", value: [] },
+                { op: "add", path: "/root/2", value: 2 }
+                // out of bounds
+              ]
+            },
+            putted,
+            session
+          )
+        ).rejects.toThrow(GraffitiErrorPatchError);
+      });
+      it2("patch channels to be wrong", async () => {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const object = randomPutObject();
+        object.allowed = [randomString()];
+        const putted = await graffiti.put(object, session);
+        const patches = [
+          {
+            channels: [{ op: "replace", path: "", value: null }]
+          },
+          {
+            channels: [{ op: "replace", path: "", value: {} }]
+          },
+          {
+            channels: [{ op: "replace", path: "", value: ["hello", ["hi"]] }]
+          },
+          {
+            channels: [{ op: "add", path: "/0", value: 1 }]
+          },
+          {
+            value: [{ op: "replace", path: "", value: "not an object" }]
+          },
+          {
+            value: [{ op: "replace", path: "", value: null }]
+          },
+          {
+            value: [{ op: "replace", path: "", value: [] }]
+          },
+          {
+            allowed: [{ op: "replace", path: "", value: {} }]
+          },
+          {
+            allowed: [{ op: "replace", path: "", value: ["hello", ["hi"]] }]
+          }
+        ];
+        for (const patch of patches) {
+          await expect2(graffiti.patch(patch, putted, session)).rejects.toThrow(
+            GraffitiErrorPatchError
+          );
+        }
+        const gotten = await graffiti.get(putted, {}, session);
+        expect2(gotten.value).toEqual(object.value);
+        expect2(gotten.channels).toEqual(object.channels);
+        expect2(gotten.allowed).toEqual(object.allowed);
+        expect2(gotten.lastModified).toEqual(putted.lastModified);
+      });
+    }
+  );
+};
+
+// tests/synchronize.ts
+import { it as it3, expect as expect3, describe as describe3, assert as assert2 } from "vitest";
+var graffitiSynchronizeTests = (useGraffiti, useSession1, useSession2) => {
+  describe3.concurrent("synchronizeDiscover", () => {
+    it3("get", async () => {
+      const graffiti1 = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      const channels = object.channels.slice(1);
+      const putted = await graffiti1.put(object, session);
+      const graffiti2 = useGraffiti();
+      const next = graffiti2.synchronizeDiscover(channels, {}).next();
+      const gotten = await graffiti2.get(putted, {}, session);
+      const result = (await next).value;
+      if (!result || result.error) {
+        throw new Error("Error in synchronize");
+      }
+      expect3(result.value.value).toEqual(object.value);
+      expect3(result.value.channels).toEqual(channels);
+      expect3(result.value.tombstone).toBe(false);
+      expect3(result.value.lastModified).toEqual(gotten.lastModified);
+    });
+    it3("put", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const beforeChannel = randomString();
+      const afterChannel = randomString();
+      const sharedChannel = randomString();
+      const oldValue = { hello: "world" };
+      const oldChannels = [beforeChannel, sharedChannel];
+      const putted = await graffiti.put(
+        {
+          value: oldValue,
+          channels: oldChannels
+        },
+        session
+      );
+      const before = graffiti.synchronizeDiscover([beforeChannel], {}).next();
+      const after = graffiti.synchronizeDiscover([afterChannel], {}).next();
+      const shared = graffiti.synchronizeDiscover([sharedChannel], {}).next();
+      const newValue = { goodbye: "world" };
+      const newChannels = [afterChannel, sharedChannel];
+      await graffiti.put(
+        {
+          ...putted,
+          value: newValue,
+          channels: newChannels
+        },
+        session
+      );
+      const beforeResult = (await before).value;
+      const afterResult = (await after).value;
+      const sharedResult = (await shared).value;
+      if (!beforeResult || beforeResult.error || !afterResult || afterResult.error || !sharedResult || sharedResult.error) {
+        throw new Error("Error in synchronize");
+      }
+      expect3(beforeResult.value.value).toEqual(oldValue);
+      expect3(beforeResult.value.channels).toEqual([beforeChannel]);
+      expect3(beforeResult.value.tombstone).toBe(true);
+      expect3(afterResult.value.value).toEqual(newValue);
+      expect3(afterResult.value.channels).toEqual([afterChannel]);
+      expect3(afterResult.value.tombstone).toBe(false);
+      expect3(sharedResult.value.value).toEqual(newValue);
+      expect3(sharedResult.value.channels).toEqual([sharedChannel]);
+      expect3(sharedResult.value.tombstone).toBe(false);
+      expect3(beforeResult.value.lastModified).toEqual(
+        afterResult.value.lastModified
+      );
+      expect3(sharedResult.value.lastModified).toEqual(
+        afterResult.value.lastModified
+      );
+    });
+    it3("patch", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const beforeChannel = randomString();
+      const afterChannel = randomString();
+      const sharedChannel = randomString();
+      const oldValue = { hello: "world" };
+      const oldChannels = [beforeChannel, sharedChannel];
+      const putted = await graffiti.put(
+        {
+          value: oldValue,
+          channels: oldChannels
+        },
+        session
+      );
+      const before = graffiti.synchronizeDiscover([beforeChannel], {}).next();
+      const after = graffiti.synchronizeDiscover([afterChannel], {}).next();
+      const shared = graffiti.synchronizeDiscover([sharedChannel], {}).next();
+      await graffiti.patch(
+        {
+          value: [
+            {
+              op: "add",
+              path: "/something",
+              value: "new value"
+            }
+          ],
+          channels: [
+            {
+              op: "add",
+              path: "/-",
+              value: afterChannel
+            },
+            {
+              op: "remove",
+              path: `/${oldChannels.indexOf(beforeChannel)}`
+            }
+          ]
+        },
+        putted,
+        session
+      );
+      const beforeResult = (await before).value;
+      const afterResult = (await after).value;
+      const sharedResult = (await shared).value;
+      if (!beforeResult || beforeResult.error || !afterResult || afterResult.error || !sharedResult || sharedResult.error) {
+        throw new Error("Error in synchronize");
+      }
+      const newValue = { ...oldValue, something: "new value" };
+      const newChannels = [sharedChannel, afterChannel];
+      expect3(beforeResult.value.value).toEqual(oldValue);
+      expect3(beforeResult.value.channels).toEqual([beforeChannel]);
+      expect3(beforeResult.value.tombstone).toBe(true);
+      expect3(afterResult.value.value).toEqual(newValue);
+      expect3(afterResult.value.channels).toEqual([afterChannel]);
+      expect3(afterResult.value.tombstone).toBe(false);
+      expect3(sharedResult.value.value).toEqual(newValue);
+      expect3(sharedResult.value.channels).toEqual([sharedChannel]);
+      expect3(sharedResult.value.tombstone).toBe(false);
+      expect3(beforeResult.value.lastModified).toEqual(
+        afterResult.value.lastModified
+      );
+      expect3(sharedResult.value.lastModified).toEqual(
+        afterResult.value.lastModified
+      );
+    });
+    it3("delete", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const channels = [randomString(), randomString(), randomString()];
+      const oldValue = { hello: "world" };
+      const oldChannels = [randomString(), ...channels.slice(1)];
+      const putted = await graffiti.put(
+        {
+          value: oldValue,
+          channels: oldChannels
+        },
+        session
+      );
+      const next = graffiti.synchronizeDiscover(channels, {}).next();
+      graffiti.delete(putted, session);
+      const result = (await next).value;
+      if (!result || result.error) {
+        throw new Error("Error in synchronize");
+      }
+      expect3(result.value.tombstone).toBe(true);
+      expect3(result.value.value).toEqual(oldValue);
+      expect3(result.value.channels).toEqual(
+        channels.filter((c) => oldChannels.includes(c))
+      );
+    });
+    it3("not allowed", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const session2 = useSession2();
+      const allChannels = [randomString(), randomString(), randomString()];
+      const channels = allChannels.slice(1);
+      const creatorNext = graffiti.synchronizeDiscover(channels, {}, session1).next();
+      const allowedNext = graffiti.synchronizeDiscover(channels, {}, session2).next();
+      const noSession = graffiti.synchronizeDiscover(channels, {}).next();
+      const value = {
+        hello: "world"
+      };
+      const allowed = [randomString(), session2.actor];
+      await graffiti.put({ value, channels: allChannels, allowed }, session1);
+      await expect3(
+        Promise.race([
+          noSession,
+          new Promise(
+            (resolve, rejects) => setTimeout(rejects, 100, "Timeout")
+          )
+        ])
+      ).rejects.toThrow("Timeout");
+      const creatorResult = (await creatorNext).value;
+      const allowedResult = (await allowedNext).value;
+      if (!creatorResult || creatorResult.error || !allowedResult || allowedResult.error) {
+        throw new Error("Error in synchronize");
+      }
+      expect3(creatorResult.value.value).toEqual(value);
+      expect3(creatorResult.value.allowed).toEqual(allowed);
+      expect3(creatorResult.value.channels).toEqual(allChannels);
+      expect3(allowedResult.value.value).toEqual(value);
+      expect3(allowedResult.value.allowed).toEqual([session2.actor]);
+      expect3(allowedResult.value.channels).toEqual(channels);
+    });
+  });
+  describe3("synchronizeGet", () => {
+    it3("replace, delete", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      const putted = await graffiti.put(object, session);
+      const iterator = graffiti.synchronizeGet(putted, {});
+      const next = iterator.next();
+      const newValue = { goodbye: "world" };
+      const putted2 = await graffiti.put(
+        {
+          ...putted,
+          value: newValue
+        },
+        session
+      );
+      const result = (await next).value;
+      assert2(result && !result.error);
+      expect3(result.value.value).toEqual(newValue);
+      expect3(result.value.actor).toEqual(session.actor);
+      expect3(result.value.channels).toEqual([]);
+      expect3(result.value.tombstone).toBe(false);
+      expect3(result.value.lastModified).toEqual(putted2.lastModified);
+      expect3(result.value.allowed).toBeUndefined();
+      const deleted = await graffiti.delete(putted2, session);
+      const result2 = (await iterator.next()).value;
+      assert2(result2 && !result2.error);
+      expect3(result2.value.tombstone).toBe(true);
+      expect3(result2.value.lastModified).toEqual(deleted.lastModified);
+      await graffiti.put(randomPutObject(), session);
+      await expect3(
+        Promise.race([
+          iterator.next(),
+          new Promise((resolve, reject) => setTimeout(reject, 100, "Timeout"))
+        ])
+      ).rejects.toThrow("Timeout");
+    });
+    it3("not allowed", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const session2 = useSession2();
+      const object = randomPutObject();
+      const putted = await graffiti.put(object, session1);
+      const iterator1 = graffiti.synchronizeGet(putted, {}, session1);
+      const iterator2 = graffiti.synchronizeGet(putted, {}, session2);
+      const next1 = iterator1.next();
+      const next2 = iterator2.next();
+      const newValue = { goodbye: "world" };
+      const putted2 = await graffiti.put(
+        {
+          ...putted,
+          ...object,
+          allowed: [],
+          value: newValue
+        },
+        session1
+      );
+      const result1 = (await next1).value;
+      const result2 = (await next2).value;
+      assert2(result1 && !result1.error);
+      assert2(result2 && !result2.error);
+      expect3(result1.value.value).toEqual(newValue);
+      expect3(result2.value.value).toEqual(object.value);
+      expect3(result1.value.actor).toEqual(session1.actor);
+      expect3(result2.value.actor).toEqual(session1.actor);
+      expect3(result1.value.channels).toEqual(object.channels);
+      expect3(result2.value.channels).toEqual([]);
+      expect3(result1.value.tombstone).toBe(false);
+      expect3(result2.value.tombstone).toBe(true);
+      expect3(result1.value.lastModified).toEqual(putted2.lastModified);
+      expect3(result2.value.lastModified).toEqual(putted2.lastModified);
+    });
+  });
+};
+
+// tests/discover.ts
+import { it as it4, expect as expect4, describe as describe4, assert as assert3 } from "vitest";
+var graffitiDiscoverTests = (useGraffiti, useSession1, useSession2) => {
+  describe4.concurrent("discover", { timeout: 2e4 }, () => {
+    it4("discover nothing", async () => {
+      const graffiti = useGraffiti();
+      const iterator = graffiti.discover([], {});
+      expect4(await iterator.next()).toHaveProperty("done", true);
+    });
+    it4("discover single", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      const putted = await graffiti.put(object, session);
+      const queryChannels = [randomString(), object.channels[0]];
+      const iterator = graffiti.discover(queryChannels, {});
+      const value = await nextStreamValue(iterator);
+      expect4(value.value).toEqual(object.value);
+      expect4(value.channels).toEqual([object.channels[0]]);
+      expect4(value.allowed).toBeUndefined();
+      expect4(value.actor).toEqual(session.actor);
+      expect4(value.tombstone).toBe(false);
+      expect4(value.lastModified).toEqual(putted.lastModified);
+      const result2 = await iterator.next();
+      expect4(result2.done).toBe(true);
+    });
+    it4("discover wrong channel", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      await graffiti.put(object, session);
+      const iterator = graffiti.discover([randomString()], {});
+      await expect4(iterator.next()).resolves.toHaveProperty("done", true);
+    });
+    it4("discover not allowed", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const session2 = useSession2();
+      const object = randomPutObject();
+      object.allowed = [randomString(), randomString()];
+      const putted = await graffiti.put(object, session1);
+      const iteratorSession1 = graffiti.discover(object.channels, {}, session1);
+      const value = await nextStreamValue(iteratorSession1);
+      expect4(value.value).toEqual(object.value);
+      expect4(value.channels).toEqual(object.channels);
+      expect4(value.allowed).toEqual(object.allowed);
+      expect4(value.actor).toEqual(session1.actor);
+      expect4(value.tombstone).toBe(false);
+      expect4(value.lastModified).toEqual(putted.lastModified);
+      const iteratorSession2 = graffiti.discover(object.channels, {}, session2);
+      expect4(await iteratorSession2.next()).toHaveProperty("done", true);
+      const iteratorNoSession = graffiti.discover(object.channels, {});
+      expect4(await iteratorNoSession.next()).toHaveProperty("done", true);
+    });
+    it4("discover allowed", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const session2 = useSession2();
+      const object = randomPutObject();
+      object.allowed = [randomString(), session2.actor, randomString()];
+      const putted = await graffiti.put(object, session1);
+      const iteratorSession2 = graffiti.discover(object.channels, {}, session2);
+      const value = await nextStreamValue(iteratorSession2);
+      expect4(value.value).toEqual(object.value);
+      expect4(value.allowed).toEqual([session2.actor]);
+      expect4(value.channels).toEqual(object.channels);
+      expect4(value.actor).toEqual(session1.actor);
+      expect4(value.tombstone).toBe(false);
+      expect4(value.lastModified).toEqual(putted.lastModified);
+    });
+    for (const prop of ["name", "actor", "lastModified"]) {
+      it4(`discover for ${prop}`, async () => {
+        const graffiti = useGraffiti();
+        const session1 = useSession1();
+        const session2 = useSession2();
+        const object1 = randomPutObject();
+        const putted1 = await graffiti.put(object1, session1);
+        const object2 = randomPutObject();
+        object2.channels = object1.channels;
+        await new Promise((r) => setTimeout(r, 20));
+        const putted2 = await graffiti.put(object2, session2);
+        const iterator = graffiti.discover(object1.channels, {
+          properties: {
+            [prop]: {
+              enum: [putted1[prop]]
+            }
+          }
+        });
+        const value = await nextStreamValue(iterator);
+        expect4(value.name).toEqual(putted1.name);
+        expect4(value.name).not.toEqual(putted2.name);
+        expect4(value.value).toEqual(object1.value);
+        await expect4(iterator.next()).resolves.toHaveProperty("done", true);
+      });
+    }
+    it4("discover with lastModified range", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      const putted1 = await graffiti.put(object, session);
+      await new Promise((r) => setTimeout(r, 20));
+      const putted2 = await graffiti.put(object, session);
+      expect4(putted1.name).not.toEqual(putted2.name);
+      expect4(putted1.lastModified).toBeLessThan(putted2.lastModified);
+      const gtIterator = graffiti.discover([object.channels[0]], {
+        properties: {
+          lastModified: {
+            minimum: putted2.lastModified,
+            exclusiveMinimum: true
+          }
+        }
+      });
+      expect4(await gtIterator.next()).toHaveProperty("done", true);
+      const gtIteratorEpsilon = graffiti.discover([object.channels[0]], {
+        properties: {
+          lastModified: {
+            minimum: putted2.lastModified - 0.1,
+            exclusiveMinimum: true
+          }
+        }
+      });
+      const value1 = await nextStreamValue(gtIteratorEpsilon);
+      expect4(value1.name).toEqual(putted2.name);
+      expect4(await gtIteratorEpsilon.next()).toHaveProperty("done", true);
+      const gteIterator = graffiti.discover(object.channels, {
+        properties: {
+          value: {},
+          lastModified: {
+            minimum: putted2.lastModified
+          }
+        }
+      });
+      const value = await nextStreamValue(gteIterator);
+      expect4(value.name).toEqual(putted2.name);
+      expect4(await gteIterator.next()).toHaveProperty("done", true);
+      const gteIteratorEpsilon = graffiti.discover(object.channels, {
+        properties: {
+          lastModified: {
+            minimum: putted2.lastModified + 0.1
+          }
+        }
+      });
+      expect4(await gteIteratorEpsilon.next()).toHaveProperty("done", true);
+      const ltIterator = graffiti.discover(object.channels, {
+        properties: {
+          lastModified: {
+            maximum: putted1.lastModified,
+            exclusiveMaximum: true
+          }
+        }
+      });
+      expect4(await ltIterator.next()).toHaveProperty("done", true);
+      const ltIteratorEpsilon = graffiti.discover(object.channels, {
+        properties: {
+          lastModified: {
+            maximum: putted1.lastModified + 0.1,
+            exclusiveMaximum: true
+          }
+        }
+      });
+      const value3 = await nextStreamValue(ltIteratorEpsilon);
+      expect4(value3.name).toEqual(putted1.name);
+      expect4(await ltIteratorEpsilon.next()).toHaveProperty("done", true);
+      const lteIterator = graffiti.discover(object.channels, {
+        properties: {
+          lastModified: {
+            maximum: putted1.lastModified
+          }
+        }
+      });
+      const value2 = await nextStreamValue(lteIterator);
+      expect4(value2.name).toEqual(putted1.name);
+      expect4(await lteIterator.next()).toHaveProperty("done", true);
+      const lteIteratorEpsilon = graffiti.discover(object.channels, {
+        properties: {
+          lastModified: {
+            maximum: putted1.lastModified - 0.1
+          }
+        }
+      });
+      expect4(await lteIteratorEpsilon.next()).toHaveProperty("done", true);
+    });
+    it4("discover schema allowed, as and not as owner", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const session2 = useSession2();
+      const object = randomPutObject();
+      object.allowed = [randomString(), session2.actor, randomString()];
+      await graffiti.put(object, session1);
+      const iteratorSession1 = graffiti.discover(
+        object.channels,
+        {
+          properties: {
+            allowed: {
+              minItems: 3,
+              // Make sure session2.actor is in the allow list
+              not: {
+                items: {
+                  not: {
+                    enum: [session2.actor]
+                  }
+                }
+              }
+            }
+          }
+        },
+        session1
+      );
+      const value = await nextStreamValue(iteratorSession1);
+      expect4(value.value).toEqual(object.value);
+      await expect4(iteratorSession1.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2BigAllow = graffiti.discover(
+        object.channels,
+        {
+          properties: {
+            allowed: {
+              minItems: 3
+            }
+          }
+        },
+        session2
+      );
+      await expect4(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2PeekOther = graffiti.discover(
+        object.channels,
+        {
+          properties: {
+            allowed: {
+              not: {
+                items: {
+                  not: {
+                    enum: [object.channels[0]]
+                  }
+                }
+              }
+            }
+          }
+        },
+        session2
+      );
+      await expect4(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2SmallAllowPeekSelf = graffiti.discover(
+        object.channels,
+        {
+          properties: {
+            allowed: {
+              maxItems: 1,
+              not: {
+                items: {
+                  not: {
+                    enum: [session2.actor]
+                  }
+                }
+              }
+            }
+          }
+        },
+        session2
+      );
+      const value2 = await nextStreamValue(iteratorSession2SmallAllowPeekSelf);
+      expect4(value2.value).toEqual(object.value);
+      await expect4(
+        iteratorSession2SmallAllowPeekSelf.next()
+      ).resolves.toHaveProperty("done", true);
+    });
+    it4("discover schema channels, as and not as owner", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const session2 = useSession2();
+      const object = randomPutObject();
+      object.channels = [randomString(), randomString(), randomString()];
+      await graffiti.put(object, session1);
+      const iteratorSession1 = graffiti.discover(
+        [object.channels[0], object.channels[2]],
+        {
+          properties: {
+            channels: {
+              minItems: 3,
+              // Make sure session2.actor is in the allow list
+              not: {
+                items: {
+                  not: {
+                    enum: [object.channels[1]]
+                  }
+                }
+              }
+            }
+          }
+        },
+        session1
+      );
+      const value = await nextStreamValue(iteratorSession1);
+      expect4(value.value).toEqual(object.value);
+      await expect4(iteratorSession1.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2BigAllow = graffiti.discover(
+        [object.channels[0], object.channels[2]],
+        {
+          properties: {
+            channels: {
+              minItems: 3
+            }
+          }
+        },
+        session2
+      );
+      await expect4(iteratorSession2BigAllow.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2PeekOther = graffiti.discover(
+        [object.channels[0], object.channels[2]],
+        {
+          properties: {
+            channels: {
+              not: {
+                items: {
+                  not: {
+                    enum: [object.channels[1]]
+                  }
+                }
+              }
+            }
+          }
+        },
+        session2
+      );
+      await expect4(iteratorSession2PeekOther.next()).resolves.toHaveProperty(
+        "done",
+        true
+      );
+      const iteratorSession2SmallAllowPeekSelf = graffiti.discover(
+        [object.channels[0], object.channels[2]],
+        {
+          properties: {
+            allowed: {
+              maxItems: 2,
+              not: {
+                items: {
+                  not: {
+                    enum: [object.channels[2]]
+                  }
+                }
+              }
+            }
+          }
+        },
+        session2
+      );
+      const value2 = await nextStreamValue(iteratorSession2SmallAllowPeekSelf);
+      expect4(value2.value).toEqual(object.value);
+      await expect4(
+        iteratorSession2SmallAllowPeekSelf.next()
+      ).resolves.toHaveProperty("done", true);
+    });
+    it4("discover query for empty allowed", async () => {
+      const graffiti = useGraffiti();
+      const session1 = useSession1();
+      const publicO = randomPutObject();
+      const publicSchema = {
+        not: {
+          required: ["allowed"]
+        }
+      };
+      await graffiti.put(publicO, session1);
+      const iterator = graffiti.discover(
+        publicO.channels,
+        publicSchema,
+        session1
+      );
+      const value = await nextStreamValue(iterator);
+      expect4(value.value).toEqual(publicO.value);
+      expect4(value.allowed).toBeUndefined();
+      await expect4(iterator.next()).resolves.toHaveProperty("done", true);
+      const restricted = randomPutObject();
+      restricted.allowed = [];
+      await graffiti.put(restricted, session1);
+      const iterator2 = graffiti.discover(
+        restricted.channels,
+        publicSchema,
+        session1
+      );
+      await expect4(iterator2.next()).resolves.toHaveProperty("done", true);
+    });
+    it4("discover query for values", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object1 = randomPutObject();
+      object1.value = { test: randomString() };
+      await graffiti.put(object1, session);
+      const object2 = randomPutObject();
+      object2.channels = object1.channels;
+      object2.value = { test: randomString(), something: randomString() };
+      await graffiti.put(object2, session);
+      const object3 = randomPutObject();
+      object3.channels = object1.channels;
+      object3.value = { other: randomString(), something: randomString() };
+      await graffiti.put(object3, session);
+      const counts = /* @__PURE__ */ new Map();
+      for (const property of ["test", "something", "other"]) {
+        let count = 0;
+        for await (const result of graffiti.discover(object1.channels, {
+          properties: {
+            value: {
+              required: [property]
+            }
+          }
+        })) {
+          assert3(!result.error, "result has error");
+          if (property in result.value.value) {
+            count++;
+          }
+        }
+        counts.set(property, count);
+      }
+      expect4(counts.get("test")).toBe(2);
+      expect4(counts.get("something")).toBe(2);
+      expect4(counts.get("other")).toBe(1);
+    });
+    it4("discover for deleted content", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      const putted = await graffiti.put(object, session);
+      const deleted = await graffiti.delete(putted, session);
+      const iterator = graffiti.discover(object.channels, {});
+      const value = await nextStreamValue(iterator);
+      expect4(value.tombstone).toBe(true);
+      expect4(value.value).toEqual(object.value);
+      expect4(value.channels).toEqual(object.channels);
+      expect4(value.actor).toEqual(session.actor);
+      expect4(value.lastModified).toEqual(deleted.lastModified);
+      await expect4(iterator.next()).resolves.toHaveProperty("done", true);
+    });
+    it4("discover for replaced channels", async () => {
+      for (let i = 0; i < 10; i++) {
+        const graffiti = useGraffiti();
+        const session = useSession1();
+        const object1 = randomPutObject();
+        const putted = await graffiti.put(object1, session);
+        const object2 = randomPutObject();
+        const replaced = await graffiti.put(
+          {
+            ...putted,
+            ...object2
+          },
+          session
+        );
+        const iterator1 = graffiti.discover(object1.channels, {});
+        const value1 = await nextStreamValue(iterator1);
+        await expect4(iterator1.next()).resolves.toHaveProperty("done", true);
+        const iterator2 = graffiti.discover(object2.channels, {});
+        const value2 = await nextStreamValue(iterator2);
+        await expect4(iterator2.next()).resolves.toHaveProperty("done", true);
+        if (putted.lastModified === replaced.lastModified) {
+          expect4(value1.tombstone || value2.tombstone).toBe(true);
+          expect4(value1.tombstone && value2.tombstone).toBe(false);
+        } else {
+          expect4(value1.tombstone).toBe(true);
+          expect4(value1.value).toEqual(object1.value);
+          expect4(value1.channels).toEqual(object1.channels);
+          expect4(value1.lastModified).toEqual(replaced.lastModified);
+          expect4(value2.tombstone).toBe(false);
+          expect4(value2.value).toEqual(object2.value);
+          expect4(value2.channels).toEqual(object2.channels);
+          expect4(value2.lastModified).toEqual(replaced.lastModified);
+        }
+      }
+    });
+    it4("discover for patched allowed", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      const putted = await graffiti.put(object, session);
+      await graffiti.patch(
+        {
+          allowed: [{ op: "add", path: "", value: [] }]
+        },
+        putted,
+        session
+      );
+      const iterator = graffiti.discover(object.channels, {});
+      const value = await nextStreamValue(iterator);
+      expect4(value.tombstone).toBe(true);
+      expect4(value.value).toEqual(object.value);
+      expect4(value.channels).toEqual(object.channels);
+      expect4(value.allowed).toBeUndefined();
+      await expect4(iterator.next()).resolves.toHaveProperty("done", true);
+    });
+    it4("put concurrently and discover one", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      object.name = randomString();
+      const putPromises = Array(100).fill(0).map(() => graffiti.put(object, session));
+      await Promise.all(putPromises);
+      const iterator = graffiti.discover(object.channels, {});
+      let tombstoneCount = 0;
+      let valueCount = 0;
+      for await (const result of iterator) {
+        assert3(!result.error, "result has error");
+        if (result.value.tombstone) {
+          tombstoneCount++;
+        } else {
+          valueCount++;
+        }
+      }
+      expect4(tombstoneCount).toBe(99);
+      expect4(valueCount).toBe(1);
+    });
+  });
+};
+
+// tests/orphans.ts
+import { it as it5, expect as expect5, describe as describe5 } from "vitest";
+var graffitiOrphanTests = (useGraffiti, useSession1, useSession2) => {
+  describe5("recoverOrphans", () => {
+    it5("list orphans", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const existingOrphans = [];
+      const orphanIterator1 = graffiti.recoverOrphans({}, session);
+      for await (const orphan of orphanIterator1) {
+        if (orphan.error) continue;
+        existingOrphans.push(orphan.value.name);
+      }
+      const object = randomPutObject();
+      object.channels = [];
+      const putted = await graffiti.put(object, session);
+      const orphanIterator2 = graffiti.recoverOrphans({}, session);
+      let numResults = 0;
+      for await (const orphan of orphanIterator2) {
+        if (orphan.error) continue;
+        if (orphan.value.name === putted.name) {
+          numResults++;
+          expect5(orphan.value.source).toBe(putted.source);
+          expect5(orphan.value.lastModified).toBe(putted.lastModified);
+        }
+      }
+      expect5(numResults).toBe(1);
+    });
+    it5("replaced orphan, no longer", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const object = randomPutObject();
+      object.channels = [];
+      const putOrphan = await graffiti.put(object, session);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+      const putNotOrphan = await graffiti.put(
+        {
+          ...putOrphan,
+          ...object,
+          channels: [randomString()]
+        },
+        session
+      );
+      expect5(putNotOrphan.name).toBe(putOrphan.name);
+      expect5(putNotOrphan.lastModified).toBeGreaterThan(putOrphan.lastModified);
+      const orphanIterator = graffiti.recoverOrphans({}, session);
+      let numResults = 0;
+      for await (const orphan of orphanIterator) {
+        if (orphan.error) continue;
+        if (orphan.value.name === putOrphan.name) {
+          numResults++;
+          expect5(orphan.value.tombstone).toBe(true);
+          expect5(orphan.value.lastModified).toBe(putNotOrphan.lastModified);
+          expect5(orphan.value.channels).toEqual([]);
+        }
+      }
+      expect5(numResults).toBe(1);
+    });
+  });
+};
+
+// tests/channel-stats.ts
+import { it as it6, expect as expect6, describe as describe6, assert as assert5 } from "vitest";
+var graffitiChannelStatsTests = (useGraffiti, useSession1, useSession2) => {
+  describe6("channel stats", () => {
+    it6("list channels", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const existingChannels = /* @__PURE__ */ new Map();
+      const channelIterator1 = graffiti.channelStats(session);
+      for await (const channel of channelIterator1) {
+        if (channel.error) continue;
+        existingChannels.set(channel.value.channel, channel.value.count);
+      }
+      const channels = [randomString(), randomString(), randomString()];
+      for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < i + 1; j++) {
+          await graffiti.put(
+            {
+              value: {
+                index: j
+              },
+              channels: channels.slice(0, i + 1)
+            },
+            session
+          );
+        }
+      }
+      await graffiti.put(
+        { value: { index: 3 }, channels: [channels[2]] },
+        session
+      );
+      const channelIterator2 = graffiti.channelStats(session);
+      let newChannels = /* @__PURE__ */ new Map();
+      for await (const channel of channelIterator2) {
+        if (channel.error) continue;
+        newChannels.set(channel.value.channel, channel.value.count);
+      }
+      newChannels = new Map(
+        Array.from(newChannels).filter(
+          ([channel, count]) => !existingChannels.has(channel)
+        )
+      );
+      expect6(newChannels.size).toBe(3);
+      expect6(newChannels.get(channels[0])).toBe(6);
+      expect6(newChannels.get(channels[1])).toBe(5);
+      expect6(newChannels.get(channels[2])).toBe(4);
+    });
+    it6("list channels with deleted channel", async () => {
+      const graffiti = useGraffiti();
+      const session = useSession1();
+      const channels = [randomString(), randomString(), randomString()];
+      const before = await graffiti.put(
+        {
+          value: { index: 2 },
+          channels: channels.slice(1)
+        },
+        session
+      );
+      const first = await graffiti.put(
+        { value: { index: 0 }, channels },
+        session
+      );
+      await graffiti.delete(first, session);
+      const second = await graffiti.put(
+        {
+          value: { index: 1 },
+          channels: channels.slice(2)
+        },
+        session
+      );
+      const channelIterator = graffiti.channelStats(session);
+      let got1 = 0;
+      let got2 = 0;
+      for await (const result of channelIterator) {
+        if (result.error) continue;
+        const { channel, count, lastModified } = result.value;
+        assert5(
+          channel !== channels[0],
+          "There should not be an object in channel[0]"
+        );
+        if (channel === channels[1]) {
+          expect6(count).toBe(1);
+          expect6(lastModified).toBe(before.lastModified);
+          got1++;
+        } else if (channel === channels[2]) {
+          expect6(count).toBe(2);
+          expect6(lastModified).toBe(second.lastModified);
+          got2++;
+        }
+      }
+      expect6(got1).toBe(1);
+      expect6(got2).toBe(1);
+    });
+  });
+};
+export {
+  graffitiCRUDTests,
+  graffitiChannelStatsTests,
+  graffitiDiscoverTests,
+  graffitiLocationTests,
+  graffitiOrphanTests,
+  graffitiSynchronizeTests
+};
 //# sourceMappingURL=tests.mjs.map